projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
s390/pkey: Wipe copies of clear-key structures on failure
[linux-2.6-block.git] / drivers / s390 / crypto / pkey_api.c
CommitLineData
812141a9 1// SPDX-License-Identifier: GPL-2.0
e80d4af0
HF		 2/*
3 * pkey device driver
4 *
9e436c19
HF		 5 * Copyright IBM Corp. 2017, 2023
6 *
e80d4af0 7 * Author(s): Harald Freudenberger
e80d4af0
HF		 8 */
9
10#define KMSG_COMPONENT "pkey"
11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13#include <linux/fs.h>
14#include <linux/init.h>
15#include <linux/miscdevice.h>
16#include <linux/module.h>
17#include <linux/slab.h>
18#include <linux/kallsyms.h>
19#include <linux/debugfs.h>
a45a5c7d 20#include <linux/random.h>
63c19be0 21#include <linux/cpufeature.h>
e80d4af0
HF		 22#include <asm/zcrypt.h>
23#include <asm/cpacf.h>
24#include <asm/pkey.h>
cb26b9ff 25#include <crypto/aes.h>
e80d4af0
HF		 26
27#include "zcrypt_api.h"
efc598e6 28#include "zcrypt_ccamisc.h"
55d0a513 29#include "zcrypt_ep11misc.h"
e80d4af0
HF		 30
31MODULE_LICENSE("GPL");
32MODULE_AUTHOR("IBM Corporation");
33MODULE_DESCRIPTION("s390 protected key interface");
34
fa6999e3 35#define KEYBLOBBUFSIZE 8192 /* key buffer size used for internal processing */
9e436c19 36#define MINKEYBLOBBUFSIZE (sizeof(struct keytoken_header))
fa6999e3
HF		 37#define PROTKEYBLOBBUFSIZE 256 /* protected key buffer size used internal */
38#define MAXAPQNSINLIST 64 /* max 64 apqns within a apqn list */
f370f45c 39#define AES_WK_VP_SIZE 32 /* Size of WK VP block appended to a prot key */
f2bbc96e 40
e80d4af0
HF		 41/*
42 * debug feature data and functions
43 */
44
0ccac452 45static debug_info_t *pkey_dbf_info;
e80d4af0 46
0ccac452
HF		 47#define PKEY_DBF_INFO(...) debug_sprintf_event(pkey_dbf_info, 5, ##__VA_ARGS__)
48#define PKEY_DBF_WARN(...) debug_sprintf_event(pkey_dbf_info, 4, ##__VA_ARGS__)
49#define PKEY_DBF_ERR(...) debug_sprintf_event(pkey_dbf_info, 3, ##__VA_ARGS__)
e80d4af0
HF		 50
51static void __init pkey_debug_init(void)
52{
6b1f16ba 53 /* 5 arguments per dbf entry (including the format string ptr) */
0ccac452
HF		 54 pkey_dbf_info = debug_register("pkey", 1, 1, 5 * sizeof(long));
55 debug_register_view(pkey_dbf_info, &debug_sprintf_view);
56 debug_set_level(pkey_dbf_info, 3);
e80d4af0
HF		 57}
58
59static void __exit pkey_debug_exit(void)
60{
0ccac452 61 debug_unregister(pkey_dbf_info);
e80d4af0
HF		 62}
63
0534bde7
IF		 64/* inside view of a protected key token (only type 0x00 version 0x01) */
65struct protaeskeytoken {
66 u8 type; /* 0x00 for PAES specific key tokens */
67 u8 res0[3];
68 u8 version; /* should be 0x01 for protected AES key token */
69 u8 res1[3];
70 u32 keytype; /* key type, one of the PKEY_KEYTYPE values */
71 u32 len; /* bytes actually stored in protkey[] */
72 u8 protkey[MAXPROTKEYSIZE]; /* the protected key blob */
73} __packed;
74
888edbc4 75/* inside view of a clear key token (type 0x00 version 0x02) */
9e436c19
HF		 76struct clearkeytoken {
77 u8 type; /* 0x00 for PAES specific key tokens */
888edbc4 78 u8 res0[3];
9e436c19 79 u8 version; /* 0x02 for clear key token */
888edbc4 80 u8 res1[3];
9e436c19
HF		 81 u32 keytype; /* key type, one of the PKEY_KEYTYPE_* values */
82 u32 len; /* bytes actually stored in clearkey[] */
fa226f1d 83 u8 clearkey[]; /* clear key value */
888edbc4
HF		 84} __packed;
85
9e436c19
HF		 86/* helper function which translates the PKEY_KEYTYPE_AES_* to their keysize */
87static inline u32 pkey_keytype_aes_to_size(u32 keytype)
88{
89 switch (keytype) {
90 case PKEY_KEYTYPE_AES_128:
91 return 16;
92 case PKEY_KEYTYPE_AES_192:
93 return 24;
94 case PKEY_KEYTYPE_AES_256:
95 return 32;
96 default:
97 return 0;
98 }
99}
100
e80d4af0 101/*
f370f45c 102 * Create a protected key from a clear key value via PCKMO instruction.
e80d4af0 103 */
f370f45c
HF		 104static int pkey_clr2protkey(u32 keytype, const u8 *clrkey,
105 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
e80d4af0 106{
5b35047e
HF		 107 /* mask of available pckmo subfunctions */
108 static cpacf_mask_t pckmo_functions;
109
9e436c19
HF		 110 u8 paramblock[112];
111 u32 pkeytype;
46a29b03
HF		 112 int keysize;
113 long fc;
e80d4af0
HF		 114
115 switch (keytype) {
116 case PKEY_KEYTYPE_AES_128:
9e436c19 117 /* 16 byte key, 32 byte aes wkvp, total 48 bytes */
e80d4af0 118 keysize = 16;
9e436c19 119 pkeytype = keytype;
e80d4af0
HF		 120 fc = CPACF_PCKMO_ENC_AES_128_KEY;
121 break;
122 case PKEY_KEYTYPE_AES_192:
9e436c19 123 /* 24 byte key, 32 byte aes wkvp, total 56 bytes */
e80d4af0 124 keysize = 24;
9e436c19 125 pkeytype = keytype;
e80d4af0
HF		 126 fc = CPACF_PCKMO_ENC_AES_192_KEY;
127 break;
128 case PKEY_KEYTYPE_AES_256:
9e436c19 129 /* 32 byte key, 32 byte aes wkvp, total 64 bytes */
e80d4af0 130 keysize = 32;
9e436c19 131 pkeytype = keytype;
e80d4af0
HF		 132 fc = CPACF_PCKMO_ENC_AES_256_KEY;
133 break;
9e436c19
HF		 134 case PKEY_KEYTYPE_ECC_P256:
135 /* 32 byte key, 32 byte aes wkvp, total 64 bytes */
136 keysize = 32;
137 pkeytype = PKEY_KEYTYPE_ECC;
138 fc = CPACF_PCKMO_ENC_ECC_P256_KEY;
139 break;
140 case PKEY_KEYTYPE_ECC_P384:
141 /* 48 byte key, 32 byte aes wkvp, total 80 bytes */
142 keysize = 48;
143 pkeytype = PKEY_KEYTYPE_ECC;
144 fc = CPACF_PCKMO_ENC_ECC_P384_KEY;
145 break;
146 case PKEY_KEYTYPE_ECC_P521:
147 /* 80 byte key, 32 byte aes wkvp, total 112 bytes */
148 keysize = 80;
149 pkeytype = PKEY_KEYTYPE_ECC;
150 fc = CPACF_PCKMO_ENC_ECC_P521_KEY;
151 break;
152 case PKEY_KEYTYPE_ECC_ED25519:
153 /* 32 byte key, 32 byte aes wkvp, total 64 bytes */
154 keysize = 32;
155 pkeytype = PKEY_KEYTYPE_ECC;
156 fc = CPACF_PCKMO_ENC_ECC_ED25519_KEY;
157 break;
158 case PKEY_KEYTYPE_ECC_ED448:
159 /* 64 byte key, 32 byte aes wkvp, total 96 bytes */
160 keysize = 64;
161 pkeytype = PKEY_KEYTYPE_ECC;
162 fc = CPACF_PCKMO_ENC_ECC_ED448_KEY;
163 break;
e80d4af0 164 default:
0ccac452
HF		 165 PKEY_DBF_ERR("%s unknown/unsupported keytype %u\n",
166 __func__, keytype);
e80d4af0
HF		 167 return -EINVAL;
168 }
169
f370f45c 170 if (*protkeylen < keysize + AES_WK_VP_SIZE) {
0ccac452
HF		 171 PKEY_DBF_ERR("%s prot key buffer size too small: %u < %d\n",
172 __func__, *protkeylen, keysize + AES_WK_VP_SIZE);
f370f45c
HF		 173 return -EINVAL;
174 }
175
5b35047e
HF		 176 /* Did we already check for PCKMO ? */
177 if (!pckmo_functions.bytes[0]) {
178 /* no, so check now */
179 if (!cpacf_query(CPACF_PCKMO, &pckmo_functions))
180 return -ENODEV;
181 }
182 /* check for the pckmo subfunction we need now */
f822ad2c 183 if (!cpacf_test_func(&pckmo_functions, fc)) {
0ccac452 184 PKEY_DBF_ERR("%s pckmo functions not available\n", __func__);
58443b67 185 return -ENODEV;
f822ad2c
HF		 186 }
187
e80d4af0
HF		 188 /* prepare param block */
189 memset(paramblock, 0, sizeof(paramblock));
f370f45c 190 memcpy(paramblock, clrkey, keysize);
e80d4af0
HF		 191
192 /* call the pckmo instruction */
193 cpacf_pckmo(fc, paramblock);
194
f370f45c
HF		 195 /* copy created protected key to key buffer including the wkvp block */
196 *protkeylen = keysize + AES_WK_VP_SIZE;
197 memcpy(protkey, paramblock, *protkeylen);
9e436c19 198 *protkeytype = pkeytype;
e80d4af0
HF		 199
200 return 0;
201}
e80d4af0 202
e80d4af0
HF		 203/*
204 * Find card and transform secure key into protected key.
205 */
f370f45c
HF		 206static int pkey_skey2pkey(const u8 *key, u8 *protkey,
207 u32 *protkeylen, u32 *protkeytype)
e80d4af0 208{
f2bbc96e 209 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03
HF		 210 u16 cardnr, domain;
211 int rc, verify;
e80d4af0 212
43cb5a7c
HF		 213 zcrypt_wait_api_operational();
214
e80d4af0 215 /*
f2bbc96e 216 * The cca_xxx2protkey call may fail when a card has been
e80d4af0 217 * addressed where the master key was changed after last fetch
f4272c03 218 * of the mkvp into the cache. Try 3 times: First without verify
efc598e6
HF		 219 * then with verify and last round with verify and old master
220 * key verification pattern match not ignored.
e80d4af0 221 */
efc598e6 222 for (verify = 0; verify < 3; verify++) {
f2bbc96e 223 rc = cca_findcard(key, &cardnr, &domain, verify);
efc598e6
HF		 224 if (rc < 0)
225 continue;
226 if (rc > 0 && verify < 2)
e80d4af0 227 continue;
f2bbc96e
HF		 228 switch (hdr->version) {
229 case TOKVER_CCA_AES:
f370f45c
HF		 230 rc = cca_sec2protkey(cardnr, domain, key,
231 protkey, protkeylen, protkeytype);
f2bbc96e
HF		 232 break;
233 case TOKVER_CCA_VLSC:
f370f45c
HF		 234 rc = cca_cipher2protkey(cardnr, domain, key,
235 protkey, protkeylen,
236 protkeytype);
f2bbc96e
HF		 237 break;
238 default:
239 return -EINVAL;
240 }
e80d4af0
HF		 241 if (rc == 0)
242 break;
243 }
244
245 if (rc)
6d749b4e 246 pr_debug("%s failed rc=%d\n", __func__, rc);
e80d4af0
HF		 247
248 return rc;
249}
e80d4af0 250
55d0a513
HF		 251/*
252 * Construct EP11 key with given clear key value.
253 */
254static int pkey_clr2ep11key(const u8 *clrkey, size_t clrkeylen,
255 u8 *keybuf, size_t *keybuflen)
256{
55d0a513 257 u32 nr_apqns, *apqns = NULL;
46a29b03
HF		 258 u16 card, dom;
259 int i, rc;
55d0a513 260
43cb5a7c
HF		 261 zcrypt_wait_api_operational();
262
55d0a513
HF		 263 /* build a list of apqns suitable for ep11 keys with cpacf support */
264 rc = ep11_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
386cb81e
HD		 265 ZCRYPT_CEX7,
266 ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4,
267 NULL);
55d0a513
HF		 268 if (rc)
269 goto out;
270
271 /* go through the list of apqns and try to bild an ep11 key */
272 for (rc = -ENODEV, i = 0; i < nr_apqns; i++) {
273 card = apqns[i] >> 16;
274 dom = apqns[i] & 0xFFFF;
275 rc = ep11_clr2keyblob(card, dom, clrkeylen * 8,
da2863f1
HD		 276 0, clrkey, keybuf, keybuflen,
277 PKEY_TYPE_EP11);
55d0a513
HF		 278 if (rc == 0)
279 break;
280 }
281
282out:
283 kfree(apqns);
284 if (rc)
6d749b4e 285 pr_debug("%s failed rc=%d\n", __func__, rc);
55d0a513
HF		 286 return rc;
287}
288
289/*
290 * Find card and transform EP11 secure key into protected key.
291 */
d1fdfb0b
HD		 292static int pkey_ep11key2pkey(const u8 *key, size_t keylen,
293 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
55d0a513 294{
46a29b03 295 u32 nr_apqns, *apqns = NULL;
5dabfeca 296 int i, j, rc = -ENODEV;
46a29b03 297 u16 card, dom;
55d0a513 298
43cb5a7c
HF		 299 zcrypt_wait_api_operational();
300
5dabfeca
HF		 301 /* try two times in case of failure */
302 for (i = 0; i < 2 && rc; i++) {
303
304 /* build a list of apqns suitable for this key */
305 rc = ep11_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
306 ZCRYPT_CEX7,
307 ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4,
308 ep11_kb_wkvp(key, keylen));
309 if (rc)
310 continue; /* retry findcard on failure */
311
312 /* go through the list of apqns and try to derive an pkey */
313 for (rc = -ENODEV, j = 0; j < nr_apqns && rc; j++) {
314 card = apqns[j] >> 16;
315 dom = apqns[j] & 0xFFFF;
316 rc = ep11_kblob2protkey(card, dom, key, keylen,
317 protkey, protkeylen, protkeytype);
318 }
55d0a513 319
5dabfeca 320 kfree(apqns);
55d0a513
HF		 321 }
322
55d0a513 323 if (rc)
6d749b4e 324 pr_debug("%s failed rc=%d\n", __func__, rc);
5dabfeca 325
55d0a513
HF		 326 return rc;
327}
328
e61a6134
HF		 329/*
330 * Verify key and give back some info about the key.
331 */
183cb469
HF		 332static int pkey_verifykey(const struct pkey_seckey *seckey,
333 u16 *pcardnr, u16 *pdomain,
334 u16 *pkeysize, u32 *pattributes)
e61a6134 335{
2004b57c 336 struct secaeskeytoken *t = (struct secaeskeytoken *)seckey;
e61a6134 337 u16 cardnr, domain;
e61a6134
HF		 338 int rc;
339
340 /* check the secure key for valid AES secure key */
0ccac452 341 rc = cca_check_secaeskeytoken(pkey_dbf_info, 3, (u8 *)seckey, 0);
e61a6134
HF		 342 if (rc)
343 goto out;
344 if (pattributes)
345 *pattributes = PKEY_VERIFY_ATTR_AES;
346 if (pkeysize)
347 *pkeysize = t->bitsize;
348
349 /* try to find a card which can handle this key */
efc598e6
HF		 350 rc = cca_findcard(seckey->seckey, &cardnr, &domain, 1);
351 if (rc < 0)
e61a6134
HF		 352 goto out;
353
efc598e6
HF		 354 if (rc > 0) {
355 /* key mkvp matches to old master key mkvp */
6d749b4e 356 pr_debug("%s secure key has old mkvp\n", __func__);
e61a6134
HF		 357 if (pattributes)
358 *pattributes |= PKEY_VERIFY_ATTR_OLD_MKVP;
efc598e6 359 rc = 0;
e61a6134
HF		 360 }
361
362 if (pcardnr)
363 *pcardnr = cardnr;
364 if (pdomain)
365 *pdomain = domain;
366
367out:
6d749b4e 368 pr_debug("%s rc=%d\n", __func__, rc);
e61a6134
HF		 369 return rc;
370}
e61a6134 371
a45a5c7d
IF		 372/*
373 * Generate a random protected key
374 */
f370f45c
HF		 375static int pkey_genprotkey(u32 keytype, u8 *protkey,
376 u32 *protkeylen, u32 *protkeytype)
a45a5c7d 377{
f370f45c 378 u8 clrkey[32];
a45a5c7d
IF		 379 int keysize;
380 int rc;
381
9e436c19
HF		 382 keysize = pkey_keytype_aes_to_size(keytype);
383 if (!keysize) {
0ccac452
HF		 384 PKEY_DBF_ERR("%s unknown/unsupported keytype %d\n", __func__,
385 keytype);
a45a5c7d
IF		 386 return -EINVAL;
387 }
388
389 /* generate a dummy random clear key */
f370f45c 390 get_random_bytes(clrkey, keysize);
a45a5c7d
IF		 391
392 /* convert it to a dummy protected key */
f370f45c
HF		 393 rc = pkey_clr2protkey(keytype, clrkey,
394 protkey, protkeylen, protkeytype);
a45a5c7d
IF		 395 if (rc)
396 return rc;
397
398 /* replace the key part of the protected key with random bytes */
f370f45c 399 get_random_bytes(protkey, keysize);
a45a5c7d
IF		 400
401 return 0;
402}
a45a5c7d 403
cb26b9ff
IF		 404/*
405 * Verify if a protected key is still valid
406 */
f370f45c
HF		 407static int pkey_verifyprotkey(const u8 *protkey, u32 protkeylen,
408 u32 protkeytype)
cb26b9ff 409{
cb26b9ff
IF		 410 struct {
411 u8 iv[AES_BLOCK_SIZE];
412 u8 key[MAXPROTKEYSIZE];
413 } param;
414 u8 null_msg[AES_BLOCK_SIZE];
415 u8 dest_buf[AES_BLOCK_SIZE];
f370f45c 416 unsigned int k, pkeylen;
46a29b03 417 unsigned long fc;
cb26b9ff 418
f370f45c 419 switch (protkeytype) {
cb26b9ff 420 case PKEY_KEYTYPE_AES_128:
f370f45c 421 pkeylen = 16 + AES_WK_VP_SIZE;
cb26b9ff
IF		 422 fc = CPACF_KMC_PAES_128;
423 break;
424 case PKEY_KEYTYPE_AES_192:
f370f45c 425 pkeylen = 24 + AES_WK_VP_SIZE;
cb26b9ff
IF		 426 fc = CPACF_KMC_PAES_192;
427 break;
428 case PKEY_KEYTYPE_AES_256:
f370f45c 429 pkeylen = 32 + AES_WK_VP_SIZE;
cb26b9ff
IF		 430 fc = CPACF_KMC_PAES_256;
431 break;
432 default:
0ccac452
HF		 433 PKEY_DBF_ERR("%s unknown/unsupported keytype %u\n", __func__,
434 protkeytype);
f370f45c
HF		 435 return -EINVAL;
436 }
437 if (protkeylen != pkeylen) {
0ccac452
HF		 438 PKEY_DBF_ERR("%s invalid protected key size %u for keytype %u\n",
439 __func__, protkeylen, protkeytype);
cb26b9ff
IF		 440 return -EINVAL;
441 }
442
443 memset(null_msg, 0, sizeof(null_msg));
444
445 memset(param.iv, 0, sizeof(param.iv));
f370f45c 446 memcpy(param.key, protkey, protkeylen);
cb26b9ff
IF		 447
448 k = cpacf_kmc(fc | CPACF_ENCRYPT, &param, null_msg, dest_buf,
449 sizeof(null_msg));
450 if (k != sizeof(null_msg)) {
0ccac452 451 PKEY_DBF_ERR("%s protected key is not valid\n", __func__);
cb26b9ff
IF		 452 return -EKEYREJECTED;
453 }
454
455 return 0;
456}
cb26b9ff 457
9e436c19
HF		 458/* Helper for pkey_nonccatok2pkey, handles aes clear key token */
459static int nonccatokaes2pkey(const struct clearkeytoken *t,
460 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
461{
462 size_t tmpbuflen = max_t(size_t, SECKEYBLOBSIZE, MAXEP11AESKEYBLOBSIZE);
463 u8 *tmpbuf = NULL;
464 u32 keysize;
465 int rc;
466
467 keysize = pkey_keytype_aes_to_size(t->keytype);
468 if (!keysize) {
0ccac452
HF		 469 PKEY_DBF_ERR("%s unknown/unsupported keytype %u\n",
470 __func__, t->keytype);
9e436c19
HF		 471 return -EINVAL;
472 }
473 if (t->len != keysize) {
0ccac452
HF		 474 PKEY_DBF_ERR("%s non clear key aes token: invalid key len %u\n",
475 __func__, t->len);
9e436c19
HF		 476 return -EINVAL;
477 }
478
479 /* try direct way with the PCKMO instruction */
480 rc = pkey_clr2protkey(t->keytype, t->clearkey,
481 protkey, protkeylen, protkeytype);
482 if (!rc)
483 goto out;
484
485 /* PCKMO failed, so try the CCA secure key way */
486 tmpbuf = kmalloc(tmpbuflen, GFP_ATOMIC);
487 if (!tmpbuf)
488 return -ENOMEM;
489 zcrypt_wait_api_operational();
490 rc = cca_clr2seckey(0xFFFF, 0xFFFF, t->keytype, t->clearkey, tmpbuf);
491 if (rc)
492 goto try_via_ep11;
493 rc = pkey_skey2pkey(tmpbuf,
494 protkey, protkeylen, protkeytype);
495 if (!rc)
496 goto out;
497
498try_via_ep11:
499 /* if the CCA way also failed, let's try via EP11 */
500 rc = pkey_clr2ep11key(t->clearkey, t->len,
501 tmpbuf, &tmpbuflen);
502 if (rc)
503 goto failure;
d1fdfb0b 504 rc = pkey_ep11key2pkey(tmpbuf, tmpbuflen,
9e436c19
HF		 505 protkey, protkeylen, protkeytype);
506 if (!rc)
507 goto out;
508
509failure:
0ccac452 510 PKEY_DBF_ERR("%s unable to build protected key from clear", __func__);
9e436c19
HF		 511
512out:
513 kfree(tmpbuf);
514 return rc;
515}
516
517/* Helper for pkey_nonccatok2pkey, handles ecc clear key token */
518static int nonccatokecc2pkey(const struct clearkeytoken *t,
519 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
520{
521 u32 keylen;
522 int rc;
523
524 switch (t->keytype) {
525 case PKEY_KEYTYPE_ECC_P256:
526 keylen = 32;
527 break;
528 case PKEY_KEYTYPE_ECC_P384:
529 keylen = 48;
530 break;
531 case PKEY_KEYTYPE_ECC_P521:
532 keylen = 80;
533 break;
534 case PKEY_KEYTYPE_ECC_ED25519:
535 keylen = 32;
536 break;
537 case PKEY_KEYTYPE_ECC_ED448:
538 keylen = 64;
539 break;
540 default:
0ccac452
HF		 541 PKEY_DBF_ERR("%s unknown/unsupported keytype %u\n",
542 __func__, t->keytype);
9e436c19
HF		 543 return -EINVAL;
544 }
545
546 if (t->len != keylen) {
0ccac452
HF		 547 PKEY_DBF_ERR("%s non clear key ecc token: invalid key len %u\n",
548 __func__, t->len);
9e436c19
HF		 549 return -EINVAL;
550 }
551
552 /* only one path possible: via PCKMO instruction */
553 rc = pkey_clr2protkey(t->keytype, t->clearkey,
554 protkey, protkeylen, protkeytype);
555 if (rc) {
0ccac452
HF		 556 PKEY_DBF_ERR("%s unable to build protected key from clear",
557 __func__);
9e436c19
HF		 558 }
559
560 return rc;
561}
562
fb1136d6
IF		 563/*
564 * Transform a non-CCA key token into a protected key
565 */
183cb469 566static int pkey_nonccatok2pkey(const u8 *key, u32 keylen,
f370f45c 567 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
fb1136d6
IF		 568{
569 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03 570 int rc = -EINVAL;
fb1136d6
IF		 571
572 switch (hdr->version) {
888edbc4
HF		 573 case TOKVER_PROTECTED_KEY: {
574 struct protaeskeytoken *t;
fb1136d6 575
888edbc4
HF		 576 if (keylen != sizeof(struct protaeskeytoken))
577 goto out;
fb1136d6 578 t = (struct protaeskeytoken *)key;
f370f45c
HF		 579 rc = pkey_verifyprotkey(t->protkey, t->len, t->keytype);
580 if (rc)
581 goto out;
582 memcpy(protkey, t->protkey, t->len);
583 *protkeylen = t->len;
584 *protkeytype = t->keytype;
888edbc4
HF		 585 break;
586 }
587 case TOKVER_CLEAR_KEY: {
9e436c19
HF		 588 struct clearkeytoken *t = (struct clearkeytoken *)key;
589
590 if (keylen < sizeof(struct clearkeytoken) ||
591 keylen != sizeof(*t) + t->len)
55d0a513 592 goto out;
9e436c19
HF		 593 switch (t->keytype) {
594 case PKEY_KEYTYPE_AES_128:
595 case PKEY_KEYTYPE_AES_192:
596 case PKEY_KEYTYPE_AES_256:
597 rc = nonccatokaes2pkey(t, protkey,
598 protkeylen, protkeytype);
888edbc4 599 break;
9e436c19
HF		 600 case PKEY_KEYTYPE_ECC_P256:
601 case PKEY_KEYTYPE_ECC_P384:
602 case PKEY_KEYTYPE_ECC_P521:
603 case PKEY_KEYTYPE_ECC_ED25519:
604 case PKEY_KEYTYPE_ECC_ED448:
605 rc = nonccatokecc2pkey(t, protkey,
606 protkeylen, protkeytype);
888edbc4 607 break;
9e436c19 608 default:
0ccac452
HF		 609 PKEY_DBF_ERR("%s unknown/unsupported non cca clear key type %u\n",
610 __func__, t->keytype);
9e436c19
HF		 611 return -EINVAL;
612 }
888edbc4
HF		 613 break;
614 }
55d0a513 615 case TOKVER_EP11_AES: {
55d0a513 616 /* check ep11 key for exportable as protected key */
0ccac452 617 rc = ep11_check_aes_key(pkey_dbf_info, 3, key, keylen, 1);
55d0a513
HF		 618 if (rc)
619 goto out;
d1fdfb0b 620 rc = pkey_ep11key2pkey(key, keylen,
f370f45c 621 protkey, protkeylen, protkeytype);
55d0a513
HF		 622 break;
623 }
fa6999e3
HF		 624 case TOKVER_EP11_AES_WITH_HEADER:
625 /* check ep11 key with header for exportable as protected key */
0ccac452
HF		 626 rc = ep11_check_aes_key_with_hdr(pkey_dbf_info,
627 3, key, keylen, 1);
fa6999e3
HF		 628 if (rc)
629 goto out;
d1fdfb0b 630 rc = pkey_ep11key2pkey(key, keylen,
f370f45c 631 protkey, protkeylen, protkeytype);
fa6999e3 632 break;
fb1136d6 633 default:
0ccac452
HF		 634 PKEY_DBF_ERR("%s unknown/unsupported non-CCA token version %d\n",
635 __func__, hdr->version);
fb1136d6 636 }
888edbc4
HF		 637
638out:
639 return rc;
fb1136d6
IF		 640}
641
642/*
643 * Transform a CCA internal key token into a protected key
644 */
183cb469 645static int pkey_ccainttok2pkey(const u8 *key, u32 keylen,
f370f45c 646 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
fb1136d6
IF		 647{
648 struct keytoken_header *hdr = (struct keytoken_header *)key;
649
650 switch (hdr->version) {
651 case TOKVER_CCA_AES:
652 if (keylen != sizeof(struct secaeskeytoken))
653 return -EINVAL;
f2bbc96e
HF		 654 break;
655 case TOKVER_CCA_VLSC:
656 if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
657 return -EINVAL;
658 break;
fb1136d6 659 default:
0ccac452
HF		 660 PKEY_DBF_ERR("%s unknown/unsupported CCA internal token version %d\n",
661 __func__, hdr->version);
fb1136d6
IF		 662 return -EINVAL;
663 }
f2bbc96e 664
f370f45c 665 return pkey_skey2pkey(key, protkey, protkeylen, protkeytype);
fb1136d6
IF		 666}
667
668/*
669 * Transform a key blob (of any type) into a protected key
670 */
183cb469 671int pkey_keyblob2pkey(const u8 *key, u32 keylen,
f370f45c 672 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
fb1136d6
IF		 673{
674 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03 675 int rc;
fb1136d6 676
f2bbc96e 677 if (keylen < sizeof(struct keytoken_header)) {
0ccac452 678 PKEY_DBF_ERR("%s invalid keylen %d\n", __func__, keylen);
fb1136d6 679 return -EINVAL;
f2bbc96e 680 }
fb1136d6
IF		 681
682 switch (hdr->type) {
683 case TOKTYPE_NON_CCA:
f370f45c
HF		 684 rc = pkey_nonccatok2pkey(key, keylen,
685 protkey, protkeylen, protkeytype);
f2bbc96e 686 break;
fb1136d6 687 case TOKTYPE_CCA_INTERNAL:
f370f45c
HF		 688 rc = pkey_ccainttok2pkey(key, keylen,
689 protkey, protkeylen, protkeytype);
f2bbc96e 690 break;
fb1136d6 691 default:
0ccac452
HF		 692 PKEY_DBF_ERR("%s unknown/unsupported blob type %d\n",
693 __func__, hdr->type);
fb1136d6
IF		 694 return -EINVAL;
695 }
f2bbc96e 696
6d749b4e 697 pr_debug("%s rc=%d\n", __func__, rc);
f2bbc96e 698 return rc;
fb1136d6
IF		 699}
700EXPORT_SYMBOL(pkey_keyblob2pkey);
701
f2bbc96e
HF		 702static int pkey_genseckey2(const struct pkey_apqn *apqns, size_t nr_apqns,
703 enum pkey_key_type ktype, enum pkey_key_size ksize,
704 u32 kflags, u8 *keybuf, size_t *keybufsize)
705{
706 int i, card, dom, rc;
707
708 /* check for at least one apqn given */
709 if (!apqns || !nr_apqns)
710 return -EINVAL;
711
712 /* check key type and size */
713 switch (ktype) {
714 case PKEY_TYPE_CCA_DATA:
715 case PKEY_TYPE_CCA_CIPHER:
716 if (*keybufsize < SECKEYBLOBSIZE)
717 return -EINVAL;
718 break;
55d0a513
HF		 719 case PKEY_TYPE_EP11:
720 if (*keybufsize < MINEP11AESKEYBLOBSIZE)
721 return -EINVAL;
722 break;
fb249ce7
HD		 723 case PKEY_TYPE_EP11_AES:
724 if (*keybufsize < (sizeof(struct ep11kblob_header) +
725 MINEP11AESKEYBLOBSIZE))
726 return -EINVAL;
727 break;
f2bbc96e
HF		 728 default:
729 return -EINVAL;
730 }
731 switch (ksize) {
732 case PKEY_SIZE_AES_128:
733 case PKEY_SIZE_AES_192:
734 case PKEY_SIZE_AES_256:
735 break;
736 default:
737 return -EINVAL;
738 }
739
740 /* simple try all apqns from the list */
741 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
742 card = apqns[i].card;
743 dom = apqns[i].domain;
fb249ce7
HD		 744 if (ktype == PKEY_TYPE_EP11 ||
745 ktype == PKEY_TYPE_EP11_AES) {
55d0a513 746 rc = ep11_genaeskey(card, dom, ksize, kflags,
fb249ce7 747 keybuf, keybufsize, ktype);
55d0a513 748 } else if (ktype == PKEY_TYPE_CCA_DATA) {
f2bbc96e
HF		 749 rc = cca_genseckey(card, dom, ksize, keybuf);
750 *keybufsize = (rc ? 0 : SECKEYBLOBSIZE);
2004b57c
HF		 751 } else {
752 /* TOKVER_CCA_VLSC */
f2bbc96e
HF		 753 rc = cca_gencipherkey(card, dom, ksize, kflags,
754 keybuf, keybufsize);
2004b57c 755 }
f2bbc96e
HF		 756 if (rc == 0)
757 break;
758 }
759
760 return rc;
761}
762
763static int pkey_clr2seckey2(const struct pkey_apqn *apqns, size_t nr_apqns,
764 enum pkey_key_type ktype, enum pkey_key_size ksize,
765 u32 kflags, const u8 *clrkey,
766 u8 *keybuf, size_t *keybufsize)
767{
768 int i, card, dom, rc;
769
770 /* check for at least one apqn given */
771 if (!apqns || !nr_apqns)
772 return -EINVAL;
773
774 /* check key type and size */
775 switch (ktype) {
776 case PKEY_TYPE_CCA_DATA:
777 case PKEY_TYPE_CCA_CIPHER:
778 if (*keybufsize < SECKEYBLOBSIZE)
779 return -EINVAL;
780 break;
55d0a513
HF		 781 case PKEY_TYPE_EP11:
782 if (*keybufsize < MINEP11AESKEYBLOBSIZE)
783 return -EINVAL;
784 break;
da2863f1
HD		 785 case PKEY_TYPE_EP11_AES:
786 if (*keybufsize < (sizeof(struct ep11kblob_header) +
787 MINEP11AESKEYBLOBSIZE))
788 return -EINVAL;
789 break;
f2bbc96e
HF		 790 default:
791 return -EINVAL;
792 }
793 switch (ksize) {
794 case PKEY_SIZE_AES_128:
795 case PKEY_SIZE_AES_192:
796 case PKEY_SIZE_AES_256:
797 break;
798 default:
799 return -EINVAL;
800 }
801
43cb5a7c
HF		 802 zcrypt_wait_api_operational();
803
f2bbc96e
HF		 804 /* simple try all apqns from the list */
805 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
806 card = apqns[i].card;
807 dom = apqns[i].domain;
da2863f1
HD		 808 if (ktype == PKEY_TYPE_EP11 ||
809 ktype == PKEY_TYPE_EP11_AES) {
55d0a513 810 rc = ep11_clr2keyblob(card, dom, ksize, kflags,
da2863f1
HD		 811 clrkey, keybuf, keybufsize,
812 ktype);
55d0a513 813 } else if (ktype == PKEY_TYPE_CCA_DATA) {
f2bbc96e
HF		 814 rc = cca_clr2seckey(card, dom, ksize,
815 clrkey, keybuf);
816 *keybufsize = (rc ? 0 : SECKEYBLOBSIZE);
2004b57c
HF		 817 } else {
818 /* TOKVER_CCA_VLSC */
f2bbc96e
HF		 819 rc = cca_clr2cipherkey(card, dom, ksize, kflags,
820 clrkey, keybuf, keybufsize);
2004b57c 821 }
f2bbc96e
HF		 822 if (rc == 0)
823 break;
824 }
825
826 return rc;
827}
828
829static int pkey_verifykey2(const u8 *key, size_t keylen,
830 u16 *cardnr, u16 *domain,
831 enum pkey_key_type *ktype,
832 enum pkey_key_size *ksize, u32 *flags)
833{
f2bbc96e 834 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03
HF		 835 u32 _nr_apqns, *_apqns = NULL;
836 int rc;
f2bbc96e 837
55d0a513 838 if (keylen < sizeof(struct keytoken_header))
f2bbc96e
HF		 839 return -EINVAL;
840
2004b57c
HF		 841 if (hdr->type == TOKTYPE_CCA_INTERNAL &&
842 hdr->version == TOKVER_CCA_AES) {
f2bbc96e
HF		 843 struct secaeskeytoken *t = (struct secaeskeytoken *)key;
844
0ccac452 845 rc = cca_check_secaeskeytoken(pkey_dbf_info, 3, key, 0);
f2bbc96e
HF		 846 if (rc)
847 goto out;
848 if (ktype)
849 *ktype = PKEY_TYPE_CCA_DATA;
850 if (ksize)
2004b57c 851 *ksize = (enum pkey_key_size)t->bitsize;
f2bbc96e
HF		 852
853 rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
32ca04bb 854 ZCRYPT_CEX3C, AES_MK_SET, t->mkvp, 0, 1);
f2bbc96e
HF		 855 if (rc == 0 && flags)
856 *flags = PKEY_FLAGS_MATCH_CUR_MKVP;
857 if (rc == -ENODEV) {
858 rc = cca_findcard2(&_apqns, &_nr_apqns,
859 *cardnr, *domain,
32ca04bb
HF		 860 ZCRYPT_CEX3C, AES_MK_SET,
861 0, t->mkvp, 1);
f2bbc96e
HF		 862 if (rc == 0 && flags)
863 *flags = PKEY_FLAGS_MATCH_ALT_MKVP;
864 }
865 if (rc)
866 goto out;
867
868 *cardnr = ((struct pkey_apqn *)_apqns)->card;
869 *domain = ((struct pkey_apqn *)_apqns)->domain;
870
2004b57c
HF		 871 } else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
872 hdr->version == TOKVER_CCA_VLSC) {
f2bbc96e
HF		 873 struct cipherkeytoken *t = (struct cipherkeytoken *)key;
874
0ccac452 875 rc = cca_check_secaescipherkey(pkey_dbf_info, 3, key, 0, 1);
f2bbc96e
HF		 876 if (rc)
877 goto out;
878 if (ktype)
879 *ktype = PKEY_TYPE_CCA_CIPHER;
880 if (ksize) {
881 *ksize = PKEY_SIZE_UNKNOWN;
882 if (!t->plfver && t->wpllen == 512)
883 *ksize = PKEY_SIZE_AES_128;
884 else if (!t->plfver && t->wpllen == 576)
885 *ksize = PKEY_SIZE_AES_192;
886 else if (!t->plfver && t->wpllen == 640)
887 *ksize = PKEY_SIZE_AES_256;
888 }
889
890 rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
32ca04bb 891 ZCRYPT_CEX6, AES_MK_SET, t->mkvp0, 0, 1);
f2bbc96e
HF		 892 if (rc == 0 && flags)
893 *flags = PKEY_FLAGS_MATCH_CUR_MKVP;
894 if (rc == -ENODEV) {
895 rc = cca_findcard2(&_apqns, &_nr_apqns,
896 *cardnr, *domain,
32ca04bb
HF		 897 ZCRYPT_CEX6, AES_MK_SET,
898 0, t->mkvp0, 1);
f2bbc96e
HF		 899 if (rc == 0 && flags)
900 *flags = PKEY_FLAGS_MATCH_ALT_MKVP;
901 }
902 if (rc)
903 goto out;
904
905 *cardnr = ((struct pkey_apqn *)_apqns)->card;
906 *domain = ((struct pkey_apqn *)_apqns)->domain;
907
2004b57c
HF		 908 } else if (hdr->type == TOKTYPE_NON_CCA &&
909 hdr->version == TOKVER_EP11_AES) {
55d0a513 910 struct ep11keyblob *kb = (struct ep11keyblob *)key;
386cb81e 911 int api;
55d0a513 912
0ccac452 913 rc = ep11_check_aes_key(pkey_dbf_info, 3, key, keylen, 1);
55d0a513
HF		 914 if (rc)
915 goto out;
916 if (ktype)
917 *ktype = PKEY_TYPE_EP11;
918 if (ksize)
37a08f01 919 *ksize = kb->head.bitlen;
55d0a513 920
386cb81e 921 api = ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4;
55d0a513 922 rc = ep11_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
386cb81e 923 ZCRYPT_CEX7, api,
745742db 924 ep11_kb_wkvp(key, keylen));
55d0a513
HF		 925 if (rc)
926 goto out;
927
928 if (flags)
929 *flags = PKEY_FLAGS_MATCH_CUR_MKVP;
930
931 *cardnr = ((struct pkey_apqn *)_apqns)->card;
932 *domain = ((struct pkey_apqn *)_apqns)->domain;
933
745742db
HD		 934 } else if (hdr->type == TOKTYPE_NON_CCA &&
935 hdr->version == TOKVER_EP11_AES_WITH_HEADER) {
936 struct ep11kblob_header *kh = (struct ep11kblob_header *)key;
386cb81e 937 int api;
745742db 938
0ccac452
HF		 939 rc = ep11_check_aes_key_with_hdr(pkey_dbf_info,
940 3, key, keylen, 1);
745742db
HD		 941 if (rc)
942 goto out;
943 if (ktype)
944 *ktype = PKEY_TYPE_EP11_AES;
945 if (ksize)
946 *ksize = kh->bitlen;
947
386cb81e 948 api = ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4;
745742db 949 rc = ep11_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
386cb81e 950 ZCRYPT_CEX7, api,
745742db
HD		 951 ep11_kb_wkvp(key, keylen));
952 if (rc)
953 goto out;
954
955 if (flags)
956 *flags = PKEY_FLAGS_MATCH_CUR_MKVP;
957
958 *cardnr = ((struct pkey_apqn *)_apqns)->card;
959 *domain = ((struct pkey_apqn *)_apqns)->domain;
2004b57c 960 } else {
f2bbc96e 961 rc = -EINVAL;
2004b57c 962 }
f2bbc96e
HF		 963
964out:
965 kfree(_apqns);
966 return rc;
967}
968
969static int pkey_keyblob2pkey2(const struct pkey_apqn *apqns, size_t nr_apqns,
970 const u8 *key, size_t keylen,
f370f45c 971 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
f2bbc96e 972{
f2bbc96e 973 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03 974 int i, card, dom, rc;
f2bbc96e
HF		 975
976 /* check for at least one apqn given */
977 if (!apqns || !nr_apqns)
978 return -EINVAL;
979
980 if (keylen < sizeof(struct keytoken_header))
981 return -EINVAL;
982
55d0a513
HF		 983 if (hdr->type == TOKTYPE_CCA_INTERNAL) {
984 if (hdr->version == TOKVER_CCA_AES) {
f2bbc96e
HF		 985 if (keylen != sizeof(struct secaeskeytoken))
986 return -EINVAL;
0ccac452 987 if (cca_check_secaeskeytoken(pkey_dbf_info, 3, key, 0))
f2bbc96e 988 return -EINVAL;
55d0a513 989 } else if (hdr->version == TOKVER_CCA_VLSC) {
f2bbc96e
HF		 990 if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
991 return -EINVAL;
0ccac452
HF		 992 if (cca_check_secaescipherkey(pkey_dbf_info,
993 3, key, 0, 1))
f2bbc96e 994 return -EINVAL;
55d0a513 995 } else {
0ccac452
HF		 996 PKEY_DBF_ERR("%s unknown CCA internal token version %d\n",
997 __func__, hdr->version);
f2bbc96e
HF		 998 return -EINVAL;
999 }
55d0a513
HF		 1000 } else if (hdr->type == TOKTYPE_NON_CCA) {
1001 if (hdr->version == TOKVER_EP11_AES) {
0ccac452
HF		 1002 if (ep11_check_aes_key(pkey_dbf_info,
1003 3, key, keylen, 1))
55d0a513 1004 return -EINVAL;
d1fdfb0b 1005 } else if (hdr->version == TOKVER_EP11_AES_WITH_HEADER) {
0ccac452
HF		 1006 if (ep11_check_aes_key_with_hdr(pkey_dbf_info,
1007 3, key, keylen, 1))
d1fdfb0b 1008 return -EINVAL;
55d0a513 1009 } else {
f370f45c
HF		 1010 return pkey_nonccatok2pkey(key, keylen,
1011 protkey, protkeylen,
1012 protkeytype);
55d0a513
HF		 1013 }
1014 } else {
0ccac452
HF		 1015 PKEY_DBF_ERR("%s unknown/unsupported blob type %d\n",
1016 __func__, hdr->type);
f2bbc96e
HF		 1017 return -EINVAL;
1018 }
1019
43cb5a7c
HF		 1020 zcrypt_wait_api_operational();
1021
f2bbc96e
HF		 1022 /* simple try all apqns from the list */
1023 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
1024 card = apqns[i].card;
1025 dom = apqns[i].domain;
2004b57c
HF		 1026 if (hdr->type == TOKTYPE_CCA_INTERNAL &&
1027 hdr->version == TOKVER_CCA_AES) {
f370f45c
HF		 1028 rc = cca_sec2protkey(card, dom, key,
1029 protkey, protkeylen, protkeytype);
2004b57c
HF		 1030 } else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
1031 hdr->version == TOKVER_CCA_VLSC) {
f370f45c
HF		 1032 rc = cca_cipher2protkey(card, dom, key,
1033 protkey, protkeylen,
1034 protkeytype);
2004b57c 1035 } else {
d1fdfb0b 1036 rc = ep11_kblob2protkey(card, dom, key, keylen,
f370f45c
HF		 1037 protkey, protkeylen,
1038 protkeytype);
55d0a513 1039 }
f2bbc96e
HF		 1040 if (rc == 0)
1041 break;
1042 }
1043
1044 return rc;
1045}
1046
1047static int pkey_apqns4key(const u8 *key, size_t keylen, u32 flags,
1048 struct pkey_apqn *apqns, size_t *nr_apqns)
1049{
f2bbc96e 1050 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03
HF		 1051 u32 _nr_apqns, *_apqns = NULL;
1052 int rc;
f2bbc96e 1053
55d0a513 1054 if (keylen < sizeof(struct keytoken_header) || flags == 0)
f2bbc96e
HF		 1055 return -EINVAL;
1056
43cb5a7c
HF		 1057 zcrypt_wait_api_operational();
1058
2004b57c
HF		 1059 if (hdr->type == TOKTYPE_NON_CCA &&
1060 (hdr->version == TOKVER_EP11_AES_WITH_HEADER ||
1061 hdr->version == TOKVER_EP11_ECC_WITH_HEADER) &&
1062 is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
fa6999e3
HF		 1063 struct ep11keyblob *kb = (struct ep11keyblob *)
1064 (key + sizeof(struct ep11kblob_header));
46a29b03 1065 int minhwtype = 0, api = 0;
fa6999e3
HF		 1066
1067 if (flags != PKEY_FLAGS_MATCH_CUR_MKVP)
1068 return -EINVAL;
1069 if (kb->attr & EP11_BLOB_PKEY_EXTRACTABLE) {
1070 minhwtype = ZCRYPT_CEX7;
386cb81e 1071 api = ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4;
fa6999e3
HF		 1072 }
1073 rc = ep11_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
1074 minhwtype, api, kb->wkvp);
1075 if (rc)
1076 goto out;
2004b57c
HF		 1077 } else if (hdr->type == TOKTYPE_NON_CCA &&
1078 hdr->version == TOKVER_EP11_AES &&
1079 is_ep11_keyblob(key)) {
2004b57c 1080 struct ep11keyblob *kb = (struct ep11keyblob *)key;
46a29b03 1081 int minhwtype = 0, api = 0;
55d0a513
HF		 1082
1083 if (flags != PKEY_FLAGS_MATCH_CUR_MKVP)
1084 return -EINVAL;
1085 if (kb->attr & EP11_BLOB_PKEY_EXTRACTABLE) {
1086 minhwtype = ZCRYPT_CEX7;
386cb81e 1087 api = ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4;
55d0a513
HF		 1088 }
1089 rc = ep11_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
1090 minhwtype, api, kb->wkvp);
1091 if (rc)
1092 goto out;
1093 } else if (hdr->type == TOKTYPE_CCA_INTERNAL) {
f2bbc96e 1094 u64 cur_mkvp = 0, old_mkvp = 0;
46a29b03 1095 int minhwtype = ZCRYPT_CEX3C;
f2bbc96e
HF		 1096
1097 if (hdr->version == TOKVER_CCA_AES) {
1098 struct secaeskeytoken *t = (struct secaeskeytoken *)key;
1099
1100 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
1101 cur_mkvp = t->mkvp;
1102 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
1103 old_mkvp = t->mkvp;
55d0a513 1104 } else if (hdr->version == TOKVER_CCA_VLSC) {
f2bbc96e
HF		 1105 struct cipherkeytoken *t = (struct cipherkeytoken *)key;
1106
1107 minhwtype = ZCRYPT_CEX6;
1108 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
1109 cur_mkvp = t->mkvp0;
1110 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
1111 old_mkvp = t->mkvp0;
55d0a513
HF		 1112 } else {
1113 /* unknown cca internal token type */
1114 return -EINVAL;
f2bbc96e
HF		 1115 }
1116 rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
32ca04bb
HF		 1117 minhwtype, AES_MK_SET,
1118 cur_mkvp, old_mkvp, 1);
f2bbc96e
HF		 1119 if (rc)
1120 goto out;
fa6999e3 1121 } else if (hdr->type == TOKTYPE_CCA_INTERNAL_PKA) {
fa6999e3 1122 struct eccprivkeytoken *t = (struct eccprivkeytoken *)key;
46a29b03 1123 u64 cur_mkvp = 0, old_mkvp = 0;
fa6999e3
HF		 1124
1125 if (t->secid == 0x20) {
1126 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
1127 cur_mkvp = t->mkvp;
1128 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
1129 old_mkvp = t->mkvp;
1130 } else {
1131 /* unknown cca internal 2 token type */
1132 return -EINVAL;
1133 }
1134 rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
1135 ZCRYPT_CEX7, APKA_MK_SET,
1136 cur_mkvp, old_mkvp, 1);
1137 if (rc)
1138 goto out;
2004b57c 1139 } else {
55d0a513 1140 return -EINVAL;
2004b57c 1141 }
55d0a513
HF		 1142
1143 if (apqns) {
1144 if (*nr_apqns < _nr_apqns)
1145 rc = -ENOSPC;
1146 else
1147 memcpy(apqns, _apqns, _nr_apqns * sizeof(u32));
f2bbc96e 1148 }
55d0a513 1149 *nr_apqns = _nr_apqns;
f2bbc96e
HF		 1150
1151out:
1152 kfree(_apqns);
1153 return rc;
1154}
1155
1156static int pkey_apqns4keytype(enum pkey_key_type ktype,
1157 u8 cur_mkvp[32], u8 alt_mkvp[32], u32 flags,
1158 struct pkey_apqn *apqns, size_t *nr_apqns)
1159{
f2bbc96e 1160 u32 _nr_apqns, *_apqns = NULL;
46a29b03 1161 int rc;
f2bbc96e 1162
43cb5a7c
HF		 1163 zcrypt_wait_api_operational();
1164
f2bbc96e
HF		 1165 if (ktype == PKEY_TYPE_CCA_DATA || ktype == PKEY_TYPE_CCA_CIPHER) {
1166 u64 cur_mkvp = 0, old_mkvp = 0;
1167 int minhwtype = ZCRYPT_CEX3C;
1168
1169 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
2004b57c 1170 cur_mkvp = *((u64 *)cur_mkvp);
f2bbc96e 1171 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
2004b57c 1172 old_mkvp = *((u64 *)alt_mkvp);
f2bbc96e
HF		 1173 if (ktype == PKEY_TYPE_CCA_CIPHER)
1174 minhwtype = ZCRYPT_CEX6;
1175 rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
32ca04bb
HF		 1176 minhwtype, AES_MK_SET,
1177 cur_mkvp, old_mkvp, 1);
f2bbc96e
HF		 1178 if (rc)
1179 goto out;
fa6999e3
HF		 1180 } else if (ktype == PKEY_TYPE_CCA_ECC) {
1181 u64 cur_mkvp = 0, old_mkvp = 0;
1182
1183 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
2004b57c 1184 cur_mkvp = *((u64 *)cur_mkvp);
fa6999e3 1185 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
2004b57c 1186 old_mkvp = *((u64 *)alt_mkvp);
fa6999e3
HF		 1187 rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
1188 ZCRYPT_CEX7, APKA_MK_SET,
1189 cur_mkvp, old_mkvp, 1);
1190 if (rc)
1191 goto out;
1192
1193 } else if (ktype == PKEY_TYPE_EP11 ||
1194 ktype == PKEY_TYPE_EP11_AES ||
1195 ktype == PKEY_TYPE_EP11_ECC) {
55d0a513 1196 u8 *wkvp = NULL;
386cb81e 1197 int api;
55d0a513
HF		 1198
1199 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
1200 wkvp = cur_mkvp;
386cb81e 1201 api = ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4;
55d0a513 1202 rc = ep11_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
386cb81e 1203 ZCRYPT_CEX7, api, wkvp);
55d0a513
HF		 1204 if (rc)
1205 goto out;
1206
2004b57c 1207 } else {
55d0a513 1208 return -EINVAL;
2004b57c 1209 }
55d0a513
HF		 1210
1211 if (apqns) {
1212 if (*nr_apqns < _nr_apqns)
1213 rc = -ENOSPC;
1214 else
1215 memcpy(apqns, _apqns, _nr_apqns * sizeof(u32));
f2bbc96e 1216 }
55d0a513 1217 *nr_apqns = _nr_apqns;
f2bbc96e
HF		 1218
1219out:
1220 kfree(_apqns);
1221 return rc;
1222}
1223
fa6999e3 1224static int pkey_keyblob2pkey3(const struct pkey_apqn *apqns, size_t nr_apqns,
f370f45c
HF		 1225 const u8 *key, size_t keylen,
1226 u8 *protkey, u32 *protkeylen, u32 *protkeytype)
fa6999e3 1227{
fa6999e3 1228 struct keytoken_header *hdr = (struct keytoken_header *)key;
46a29b03 1229 int i, card, dom, rc;
fa6999e3
HF		 1230
1231 /* check for at least one apqn given */
1232 if (!apqns || !nr_apqns)
1233 return -EINVAL;
1234
1235 if (keylen < sizeof(struct keytoken_header))
1236 return -EINVAL;
1237
2004b57c
HF		 1238 if (hdr->type == TOKTYPE_NON_CCA &&
1239 hdr->version == TOKVER_EP11_AES_WITH_HEADER &&
1240 is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
fa6999e3 1241 /* EP11 AES key blob with header */
0ccac452
HF		 1242 if (ep11_check_aes_key_with_hdr(pkey_dbf_info,
1243 3, key, keylen, 1))
fa6999e3 1244 return -EINVAL;
2004b57c
HF		 1245 } else if (hdr->type == TOKTYPE_NON_CCA &&
1246 hdr->version == TOKVER_EP11_ECC_WITH_HEADER &&
1247 is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
fa6999e3 1248 /* EP11 ECC key blob with header */
0ccac452
HF		 1249 if (ep11_check_ecc_key_with_hdr(pkey_dbf_info,
1250 3, key, keylen, 1))
fa6999e3 1251 return -EINVAL;
2004b57c
HF		 1252 } else if (hdr->type == TOKTYPE_NON_CCA &&
1253 hdr->version == TOKVER_EP11_AES &&
1254 is_ep11_keyblob(key)) {
fa6999e3 1255 /* EP11 AES key blob with header in session field */
0ccac452 1256 if (ep11_check_aes_key(pkey_dbf_info, 3, key, keylen, 1))
fa6999e3
HF		 1257 return -EINVAL;
1258 } else if (hdr->type == TOKTYPE_CCA_INTERNAL) {
1259 if (hdr->version == TOKVER_CCA_AES) {
1260 /* CCA AES data key */
1261 if (keylen != sizeof(struct secaeskeytoken))
1262 return -EINVAL;
0ccac452 1263 if (cca_check_secaeskeytoken(pkey_dbf_info, 3, key, 0))
fa6999e3
HF		 1264 return -EINVAL;
1265 } else if (hdr->version == TOKVER_CCA_VLSC) {
1266 /* CCA AES cipher key */
1267 if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
1268 return -EINVAL;
0ccac452
HF		 1269 if (cca_check_secaescipherkey(pkey_dbf_info,
1270 3, key, 0, 1))
fa6999e3
HF		 1271 return -EINVAL;
1272 } else {
0ccac452
HF		 1273 PKEY_DBF_ERR("%s unknown CCA internal token version %d\n",
1274 __func__, hdr->version);
fa6999e3
HF		 1275 return -EINVAL;
1276 }
1277 } else if (hdr->type == TOKTYPE_CCA_INTERNAL_PKA) {
1278 /* CCA ECC (private) key */
1279 if (keylen < sizeof(struct eccprivkeytoken))
1280 return -EINVAL;
0ccac452 1281 if (cca_check_sececckeytoken(pkey_dbf_info, 3, key, keylen, 1))
fa6999e3
HF		 1282 return -EINVAL;
1283 } else if (hdr->type == TOKTYPE_NON_CCA) {
f370f45c
HF		 1284 return pkey_nonccatok2pkey(key, keylen,
1285 protkey, protkeylen, protkeytype);
fa6999e3 1286 } else {
0ccac452
HF		 1287 PKEY_DBF_ERR("%s unknown/unsupported blob type %d\n",
1288 __func__, hdr->type);
fa6999e3
HF		 1289 return -EINVAL;
1290 }
1291
1292 /* simple try all apqns from the list */
1293 for (rc = -ENODEV, i = 0; rc && i < nr_apqns; i++) {
1294 card = apqns[i].card;
1295 dom = apqns[i].domain;
2004b57c
HF		 1296 if (hdr->type == TOKTYPE_NON_CCA &&
1297 (hdr->version == TOKVER_EP11_AES_WITH_HEADER ||
1298 hdr->version == TOKVER_EP11_ECC_WITH_HEADER) &&
1299 is_ep11_keyblob(key + sizeof(struct ep11kblob_header)))
fa6999e3 1300 rc = ep11_kblob2protkey(card, dom, key, hdr->len,
d1fdfb0b
HD		 1301 protkey, protkeylen,
1302 protkeytype);
2004b57c
HF		 1303 else if (hdr->type == TOKTYPE_NON_CCA &&
1304 hdr->version == TOKVER_EP11_AES &&
1305 is_ep11_keyblob(key))
fa6999e3 1306 rc = ep11_kblob2protkey(card, dom, key, hdr->len,
d1fdfb0b
HD		 1307 protkey, protkeylen,
1308 protkeytype);
fa6999e3
HF		 1309 else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
1310 hdr->version == TOKVER_CCA_AES)
1311 rc = cca_sec2protkey(card, dom, key, protkey,
1312 protkeylen, protkeytype);
1313 else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
1314 hdr->version == TOKVER_CCA_VLSC)
1315 rc = cca_cipher2protkey(card, dom, key, protkey,
1316 protkeylen, protkeytype);
1317 else if (hdr->type == TOKTYPE_CCA_INTERNAL_PKA)
1318 rc = cca_ecc2protkey(card, dom, key, protkey,
1319 protkeylen, protkeytype);
1320 else
1321 return -EINVAL;
1322 }
1323
1324 return rc;
1325}
1326
e80d4af0
HF		 1327/*
1328 * File io functions
1329 */
1330
f2bbc96e
HF		 1331static void *_copy_key_from_user(void __user *ukey, size_t keylen)
1332{
9e436c19 1333 if (!ukey || keylen < MINKEYBLOBBUFSIZE || keylen > KEYBLOBBUFSIZE)
f2bbc96e 1334 return ERR_PTR(-EINVAL);
f2bbc96e 1335
8b57e7c8 1336 return memdup_user(ukey, keylen);
f2bbc96e
HF		 1337}
1338
1339static void *_copy_apqns_from_user(void __user *uapqns, size_t nr_apqns)
1340{
8b57e7c8
ME		 1341 if (!uapqns || nr_apqns == 0)
1342 return NULL;
f2bbc96e 1343
8b57e7c8 1344 return memdup_user(uapqns, nr_apqns * sizeof(struct pkey_apqn));
f2bbc96e
HF		 1345}
1346
e80d4af0
HF		 1347static long pkey_unlocked_ioctl(struct file *filp, unsigned int cmd,
1348 unsigned long arg)
1349{
1350 int rc;
1351
1352 switch (cmd) {
1353 case PKEY_GENSECK: {
2004b57c 1354 struct pkey_genseck __user *ugs = (void __user *)arg;
e80d4af0
HF		 1355 struct pkey_genseck kgs;
1356
1357 if (copy_from_user(&kgs, ugs, sizeof(kgs)))
1358 return -EFAULT;
efc598e6
HF		 1359 rc = cca_genseckey(kgs.cardnr, kgs.domain,
1360 kgs.keytype, kgs.seckey.seckey);
6d749b4e 1361 pr_debug("%s cca_genseckey()=%d\n", __func__, rc);
e80d4af0
HF		 1362 if (rc)
1363 break;
1364 if (copy_to_user(ugs, &kgs, sizeof(kgs)))
1365 return -EFAULT;
1366 break;
1367 }
1368 case PKEY_CLR2SECK: {
2004b57c 1369 struct pkey_clr2seck __user *ucs = (void __user *)arg;
e80d4af0
HF		 1370 struct pkey_clr2seck kcs;
1371
1372 if (copy_from_user(&kcs, ucs, sizeof(kcs)))
1373 return -EFAULT;
efc598e6
HF		 1374 rc = cca_clr2seckey(kcs.cardnr, kcs.domain, kcs.keytype,
1375 kcs.clrkey.clrkey, kcs.seckey.seckey);
6d749b4e 1376 pr_debug("%s cca_clr2seckey()=%d\n", __func__, rc);
d65d76a4 1377 if (!rc && copy_to_user(ucs, &kcs, sizeof(kcs)))
1d8c270d 1378 rc = -EFAULT;
e80d4af0
HF		 1379 memzero_explicit(&kcs, sizeof(kcs));
1380 break;
1381 }
1382 case PKEY_SEC2PROTK: {
2004b57c 1383 struct pkey_sec2protk __user *usp = (void __user *)arg;
e80d4af0
HF		 1384 struct pkey_sec2protk ksp;
1385
1386 if (copy_from_user(&ksp, usp, sizeof(ksp)))
1387 return -EFAULT;
f370f45c 1388 ksp.protkey.len = sizeof(ksp.protkey.protkey);
efc598e6
HF		 1389 rc = cca_sec2protkey(ksp.cardnr, ksp.domain,
1390 ksp.seckey.seckey, ksp.protkey.protkey,
aab73d27 1391 &ksp.protkey.len, &ksp.protkey.type);
6d749b4e 1392 pr_debug("%s cca_sec2protkey()=%d\n", __func__, rc);
e80d4af0
HF		 1393 if (rc)
1394 break;
1395 if (copy_to_user(usp, &ksp, sizeof(ksp)))
1396 return -EFAULT;
1397 break;
1398 }
1399 case PKEY_CLR2PROTK: {
2004b57c 1400 struct pkey_clr2protk __user *ucp = (void __user *)arg;
e80d4af0
HF		 1401 struct pkey_clr2protk kcp;
1402
1403 if (copy_from_user(&kcp, ucp, sizeof(kcp)))
1404 return -EFAULT;
f370f45c
HF		 1405 kcp.protkey.len = sizeof(kcp.protkey.protkey);
1406 rc = pkey_clr2protkey(kcp.keytype, kcp.clrkey.clrkey,
1407 kcp.protkey.protkey,
1408 &kcp.protkey.len, &kcp.protkey.type);
6d749b4e 1409 pr_debug("%s pkey_clr2protkey()=%d\n", __func__, rc);
d65d76a4 1410 if (!rc && copy_to_user(ucp, &kcp, sizeof(kcp)))
1d8c270d 1411 rc = -EFAULT;
e80d4af0
HF		 1412 memzero_explicit(&kcp, sizeof(kcp));
1413 break;
1414 }
1415 case PKEY_FINDCARD: {
2004b57c 1416 struct pkey_findcard __user *ufc = (void __user *)arg;
e80d4af0
HF		 1417 struct pkey_findcard kfc;
1418
1419 if (copy_from_user(&kfc, ufc, sizeof(kfc)))
1420 return -EFAULT;
efc598e6
HF		 1421 rc = cca_findcard(kfc.seckey.seckey,
1422 &kfc.cardnr, &kfc.domain, 1);
6d749b4e 1423 pr_debug("%s cca_findcard()=%d\n", __func__, rc);
efc598e6 1424 if (rc < 0)
e80d4af0
HF		 1425 break;
1426 if (copy_to_user(ufc, &kfc, sizeof(kfc)))
1427 return -EFAULT;
1428 break;
1429 }
1430 case PKEY_SKEY2PKEY: {
2004b57c 1431 struct pkey_skey2pkey __user *usp = (void __user *)arg;
e80d4af0
HF		 1432 struct pkey_skey2pkey ksp;
1433
1434 if (copy_from_user(&ksp, usp, sizeof(ksp)))
1435 return -EFAULT;
f370f45c
HF		 1436 ksp.protkey.len = sizeof(ksp.protkey.protkey);
1437 rc = pkey_skey2pkey(ksp.seckey.seckey, ksp.protkey.protkey,
1438 &ksp.protkey.len, &ksp.protkey.type);
6d749b4e 1439 pr_debug("%s pkey_skey2pkey()=%d\n", __func__, rc);
e80d4af0
HF		 1440 if (rc)
1441 break;
1442 if (copy_to_user(usp, &ksp, sizeof(ksp)))
1443 return -EFAULT;
1444 break;
1445 }
e61a6134 1446 case PKEY_VERIFYKEY: {
2004b57c 1447 struct pkey_verifykey __user *uvk = (void __user *)arg;
e61a6134
HF		 1448 struct pkey_verifykey kvk;
1449
1450 if (copy_from_user(&kvk, uvk, sizeof(kvk)))
1451 return -EFAULT;
1452 rc = pkey_verifykey(&kvk.seckey, &kvk.cardnr, &kvk.domain,
1453 &kvk.keysize, &kvk.attributes);
6d749b4e 1454 pr_debug("%s pkey_verifykey()=%d\n", __func__, rc);
e61a6134
HF		 1455 if (rc)
1456 break;
1457 if (copy_to_user(uvk, &kvk, sizeof(kvk)))
1458 return -EFAULT;
1459 break;
1460 }
a45a5c7d 1461 case PKEY_GENPROTK: {
2004b57c 1462 struct pkey_genprotk __user *ugp = (void __user *)arg;
a45a5c7d
IF		 1463 struct pkey_genprotk kgp;
1464
1465 if (copy_from_user(&kgp, ugp, sizeof(kgp)))
1466 return -EFAULT;
f370f45c
HF		 1467 kgp.protkey.len = sizeof(kgp.protkey.protkey);
1468 rc = pkey_genprotkey(kgp.keytype, kgp.protkey.protkey,
1469 &kgp.protkey.len, &kgp.protkey.type);
6d749b4e 1470 pr_debug("%s pkey_genprotkey()=%d\n", __func__, rc);
a45a5c7d
IF		 1471 if (rc)
1472 break;
1473 if (copy_to_user(ugp, &kgp, sizeof(kgp)))
1474 return -EFAULT;
1475 break;
1476 }
cb26b9ff 1477 case PKEY_VERIFYPROTK: {
2004b57c 1478 struct pkey_verifyprotk __user *uvp = (void __user *)arg;
cb26b9ff
IF		 1479 struct pkey_verifyprotk kvp;
1480
1481 if (copy_from_user(&kvp, uvp, sizeof(kvp)))
1482 return -EFAULT;
f370f45c
HF		 1483 rc = pkey_verifyprotkey(kvp.protkey.protkey,
1484 kvp.protkey.len, kvp.protkey.type);
6d749b4e 1485 pr_debug("%s pkey_verifyprotkey()=%d\n", __func__, rc);
cb26b9ff
IF		 1486 break;
1487 }
fb1136d6 1488 case PKEY_KBLOB2PROTK: {
2004b57c 1489 struct pkey_kblob2pkey __user *utp = (void __user *)arg;
fb1136d6 1490 struct pkey_kblob2pkey ktp;
183cb469 1491 u8 *kkey;
fb1136d6
IF		 1492
1493 if (copy_from_user(&ktp, utp, sizeof(ktp)))
1494 return -EFAULT;
f2bbc96e
HF		 1495 kkey = _copy_key_from_user(ktp.key, ktp.keylen);
1496 if (IS_ERR(kkey))
1497 return PTR_ERR(kkey);
f370f45c
HF		 1498 ktp.protkey.len = sizeof(ktp.protkey.protkey);
1499 rc = pkey_keyblob2pkey(kkey, ktp.keylen, ktp.protkey.protkey,
1500 &ktp.protkey.len, &ktp.protkey.type);
6d749b4e 1501 pr_debug("%s pkey_keyblob2pkey()=%d\n", __func__, rc);
22e68246 1502 kfree_sensitive(kkey);
f2bbc96e
HF		 1503 if (rc)
1504 break;
1505 if (copy_to_user(utp, &ktp, sizeof(ktp)))
1506 return -EFAULT;
1507 break;
1508 }
1509 case PKEY_GENSECK2: {
2004b57c 1510 struct pkey_genseck2 __user *ugs = (void __user *)arg;
46a29b03 1511 size_t klen = KEYBLOBBUFSIZE;
f2bbc96e
HF		 1512 struct pkey_genseck2 kgs;
1513 struct pkey_apqn *apqns;
f2bbc96e
HF		 1514 u8 *kkey;
1515
1516 if (copy_from_user(&kgs, ugs, sizeof(kgs)))
1517 return -EFAULT;
1518 apqns = _copy_apqns_from_user(kgs.apqns, kgs.apqn_entries);
1519 if (IS_ERR(apqns))
1520 return PTR_ERR(apqns);
fb249ce7 1521 kkey = kzalloc(klen, GFP_KERNEL);
f2bbc96e
HF		 1522 if (!kkey) {
1523 kfree(apqns);
fb1136d6 1524 return -ENOMEM;
f2bbc96e
HF		 1525 }
1526 rc = pkey_genseckey2(apqns, kgs.apqn_entries,
1527 kgs.type, kgs.size, kgs.keygenflags,
1528 kkey, &klen);
6d749b4e 1529 pr_debug("%s pkey_genseckey2()=%d\n", __func__, rc);
f2bbc96e
HF		 1530 kfree(apqns);
1531 if (rc) {
fb1136d6 1532 kfree(kkey);
f2bbc96e
HF		 1533 break;
1534 }
1535 if (kgs.key) {
1536 if (kgs.keylen < klen) {
1537 kfree(kkey);
1538 return -EINVAL;
1539 }
1540 if (copy_to_user(kgs.key, kkey, klen)) {
1541 kfree(kkey);
1542 return -EFAULT;
1543 }
1544 }
1545 kgs.keylen = klen;
1546 if (copy_to_user(ugs, &kgs, sizeof(kgs)))
1547 rc = -EFAULT;
1548 kfree(kkey);
1549 break;
1550 }
1551 case PKEY_CLR2SECK2: {
2004b57c 1552 struct pkey_clr2seck2 __user *ucs = (void __user *)arg;
46a29b03 1553 size_t klen = KEYBLOBBUFSIZE;
f2bbc96e
HF		 1554 struct pkey_clr2seck2 kcs;
1555 struct pkey_apqn *apqns;
f2bbc96e
HF		 1556 u8 *kkey;
1557
1558 if (copy_from_user(&kcs, ucs, sizeof(kcs)))
fb1136d6 1559 return -EFAULT;
f2bbc96e 1560 apqns = _copy_apqns_from_user(kcs.apqns, kcs.apqn_entries);
d65d76a4
HD		 1561 if (IS_ERR(apqns)) {
1562 memzero_explicit(&kcs, sizeof(kcs));
f2bbc96e 1563 return PTR_ERR(apqns);
d65d76a4 1564 }
da2863f1 1565 kkey = kzalloc(klen, GFP_KERNEL);
f2bbc96e
HF		 1566 if (!kkey) {
1567 kfree(apqns);
d65d76a4 1568 memzero_explicit(&kcs, sizeof(kcs));
f2bbc96e 1569 return -ENOMEM;
fb1136d6 1570 }
f2bbc96e
HF		 1571 rc = pkey_clr2seckey2(apqns, kcs.apqn_entries,
1572 kcs.type, kcs.size, kcs.keygenflags,
1573 kcs.clrkey.clrkey, kkey, &klen);
6d749b4e 1574 pr_debug("%s pkey_clr2seckey2()=%d\n", __func__, rc);
f2bbc96e
HF		 1575 kfree(apqns);
1576 if (rc) {
1577 kfree(kkey);
d65d76a4 1578 memzero_explicit(&kcs, sizeof(kcs));
f2bbc96e
HF		 1579 break;
1580 }
1581 if (kcs.key) {
1582 if (kcs.keylen < klen) {
1583 kfree(kkey);
d65d76a4 1584 memzero_explicit(&kcs, sizeof(kcs));
f2bbc96e
HF		 1585 return -EINVAL;
1586 }
1587 if (copy_to_user(kcs.key, kkey, klen)) {
1588 kfree(kkey);
d65d76a4 1589 memzero_explicit(&kcs, sizeof(kcs));
f2bbc96e
HF		 1590 return -EFAULT;
1591 }
1592 }
1593 kcs.keylen = klen;
1594 if (copy_to_user(ucs, &kcs, sizeof(kcs)))
1595 rc = -EFAULT;
1596 memzero_explicit(&kcs, sizeof(kcs));
1597 kfree(kkey);
1598 break;
1599 }
1600 case PKEY_VERIFYKEY2: {
2004b57c 1601 struct pkey_verifykey2 __user *uvk = (void __user *)arg;
f2bbc96e
HF		 1602 struct pkey_verifykey2 kvk;
1603 u8 *kkey;
1604
1605 if (copy_from_user(&kvk, uvk, sizeof(kvk)))
1606 return -EFAULT;
1607 kkey = _copy_key_from_user(kvk.key, kvk.keylen);
1608 if (IS_ERR(kkey))
1609 return PTR_ERR(kkey);
1610 rc = pkey_verifykey2(kkey, kvk.keylen,
1611 &kvk.cardnr, &kvk.domain,
1612 &kvk.type, &kvk.size, &kvk.flags);
6d749b4e 1613 pr_debug("%s pkey_verifykey2()=%d\n", __func__, rc);
f2bbc96e
HF		 1614 kfree(kkey);
1615 if (rc)
1616 break;
1617 if (copy_to_user(uvk, &kvk, sizeof(kvk)))
1618 return -EFAULT;
1619 break;
1620 }
1621 case PKEY_KBLOB2PROTK2: {
2004b57c 1622 struct pkey_kblob2pkey2 __user *utp = (void __user *)arg;
f2bbc96e 1623 struct pkey_apqn *apqns = NULL;
46a29b03 1624 struct pkey_kblob2pkey2 ktp;
f2bbc96e
HF		 1625 u8 *kkey;
1626
1627 if (copy_from_user(&ktp, utp, sizeof(ktp)))
1628 return -EFAULT;
1629 apqns = _copy_apqns_from_user(ktp.apqns, ktp.apqn_entries);
1630 if (IS_ERR(apqns))
1631 return PTR_ERR(apqns);
1632 kkey = _copy_key_from_user(ktp.key, ktp.keylen);
1633 if (IS_ERR(kkey)) {
1634 kfree(apqns);
1635 return PTR_ERR(kkey);
1636 }
f370f45c 1637 ktp.protkey.len = sizeof(ktp.protkey.protkey);
f2bbc96e 1638 rc = pkey_keyblob2pkey2(apqns, ktp.apqn_entries,
f370f45c
HF		 1639 kkey, ktp.keylen,
1640 ktp.protkey.protkey, &ktp.protkey.len,
1641 &ktp.protkey.type);
6d749b4e 1642 pr_debug("%s pkey_keyblob2pkey2()=%d\n", __func__, rc);
f2bbc96e 1643 kfree(apqns);
22e68246 1644 kfree_sensitive(kkey);
fb1136d6
IF		 1645 if (rc)
1646 break;
1647 if (copy_to_user(utp, &ktp, sizeof(ktp)))
1648 return -EFAULT;
1649 break;
1650 }
f2bbc96e 1651 case PKEY_APQNS4K: {
2004b57c 1652 struct pkey_apqns4key __user *uak = (void __user *)arg;
f2bbc96e 1653 struct pkey_apqn *apqns = NULL;
46a29b03 1654 struct pkey_apqns4key kak;
f2bbc96e
HF		 1655 size_t nr_apqns, len;
1656 u8 *kkey;
1657
1658 if (copy_from_user(&kak, uak, sizeof(kak)))
1659 return -EFAULT;
1660 nr_apqns = kak.apqn_entries;
1661 if (nr_apqns) {
1662 apqns = kmalloc_array(nr_apqns,
1663 sizeof(struct pkey_apqn),
1664 GFP_KERNEL);
1665 if (!apqns)
1666 return -ENOMEM;
1667 }
1668 kkey = _copy_key_from_user(kak.key, kak.keylen);
1669 if (IS_ERR(kkey)) {
1670 kfree(apqns);
1671 return PTR_ERR(kkey);
1672 }
1673 rc = pkey_apqns4key(kkey, kak.keylen, kak.flags,
1674 apqns, &nr_apqns);
6d749b4e 1675 pr_debug("%s pkey_apqns4key()=%d\n", __func__, rc);
f2bbc96e
HF		 1676 kfree(kkey);
1677 if (rc && rc != -ENOSPC) {
1678 kfree(apqns);
1679 break;
1680 }
1681 if (!rc && kak.apqns) {
1682 if (nr_apqns > kak.apqn_entries) {
1683 kfree(apqns);
1684 return -EINVAL;
1685 }
1686 len = nr_apqns * sizeof(struct pkey_apqn);
1687 if (len) {
1688 if (copy_to_user(kak.apqns, apqns, len)) {
1689 kfree(apqns);
1690 return -EFAULT;
1691 }
1692 }
1693 }
1694 kak.apqn_entries = nr_apqns;
1695 if (copy_to_user(uak, &kak, sizeof(kak)))
1696 rc = -EFAULT;
1697 kfree(apqns);
1698 break;
1699 }
1700 case PKEY_APQNS4KT: {
2004b57c 1701 struct pkey_apqns4keytype __user *uat = (void __user *)arg;
f2bbc96e 1702 struct pkey_apqn *apqns = NULL;
46a29b03 1703 struct pkey_apqns4keytype kat;
f2bbc96e
HF		 1704 size_t nr_apqns, len;
1705
1706 if (copy_from_user(&kat, uat, sizeof(kat)))
1707 return -EFAULT;
1708 nr_apqns = kat.apqn_entries;
1709 if (nr_apqns) {
1710 apqns = kmalloc_array(nr_apqns,
1711 sizeof(struct pkey_apqn),
1712 GFP_KERNEL);
1713 if (!apqns)
1714 return -ENOMEM;
1715 }
1716 rc = pkey_apqns4keytype(kat.type, kat.cur_mkvp, kat.alt_mkvp,
1717 kat.flags, apqns, &nr_apqns);
6d749b4e 1718 pr_debug("%s pkey_apqns4keytype()=%d\n", __func__, rc);
f2bbc96e
HF		 1719 if (rc && rc != -ENOSPC) {
1720 kfree(apqns);
1721 break;
1722 }
1723 if (!rc && kat.apqns) {
1724 if (nr_apqns > kat.apqn_entries) {
1725 kfree(apqns);
1726 return -EINVAL;
1727 }
1728 len = nr_apqns * sizeof(struct pkey_apqn);
1729 if (len) {
1730 if (copy_to_user(kat.apqns, apqns, len)) {
1731 kfree(apqns);
1732 return -EFAULT;
1733 }
1734 }
1735 }
1736 kat.apqn_entries = nr_apqns;
1737 if (copy_to_user(uat, &kat, sizeof(kat)))
1738 rc = -EFAULT;
1739 kfree(apqns);
1740 break;
1741 }
fa6999e3 1742 case PKEY_KBLOB2PROTK3: {
2004b57c 1743 struct pkey_kblob2pkey3 __user *utp = (void __user *)arg;
fa6999e3 1744 u32 protkeylen = PROTKEYBLOBBUFSIZE;
46a29b03
HF		 1745 struct pkey_apqn *apqns = NULL;
1746 struct pkey_kblob2pkey3 ktp;
fa6999e3
HF		 1747 u8 *kkey, *protkey;
1748
1749 if (copy_from_user(&ktp, utp, sizeof(ktp)))
1750 return -EFAULT;
1751 apqns = _copy_apqns_from_user(ktp.apqns, ktp.apqn_entries);
1752 if (IS_ERR(apqns))
1753 return PTR_ERR(apqns);
1754 kkey = _copy_key_from_user(ktp.key, ktp.keylen);
1755 if (IS_ERR(kkey)) {
1756 kfree(apqns);
1757 return PTR_ERR(kkey);
1758 }
1759 protkey = kmalloc(protkeylen, GFP_KERNEL);
1760 if (!protkey) {
1761 kfree(apqns);
1762 kfree(kkey);
1763 return -ENOMEM;
1764 }
f370f45c
HF		 1765 rc = pkey_keyblob2pkey3(apqns, ktp.apqn_entries,
1766 kkey, ktp.keylen,
1767 protkey, &protkeylen, &ktp.pkeytype);
6d749b4e 1768 pr_debug("%s pkey_keyblob2pkey3()=%d\n", __func__, rc);
fa6999e3 1769 kfree(apqns);
22e68246 1770 kfree_sensitive(kkey);
fa6999e3
HF		 1771 if (rc) {
1772 kfree(protkey);
1773 break;
1774 }
1775 if (ktp.pkey && ktp.pkeylen) {
1776 if (protkeylen > ktp.pkeylen) {
1777 kfree(protkey);
1778 return -EINVAL;
1779 }
1780 if (copy_to_user(ktp.pkey, protkey, protkeylen)) {
1781 kfree(protkey);
1782 return -EFAULT;
1783 }
1784 }
1785 kfree(protkey);
1786 ktp.pkeylen = protkeylen;
1787 if (copy_to_user(utp, &ktp, sizeof(ktp)))
1788 return -EFAULT;
1789 break;
1790 }
e80d4af0
HF		 1791 default:
1792 /* unknown/unsupported ioctl cmd */
1793 return -ENOTTY;
1794 }
1795
1796 return rc;
1797}
1798
1799/*
1800 * Sysfs and file io operations
1801 */
d632c047
IF		 1802
1803/*
1804 * Sysfs attribute read function for all protected key binary attributes.
1805 * The implementation can not deal with partial reads, because a new random
1806 * protected key blob is generated with each read. In case of partial reads
1807 * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
1808 */
1809static ssize_t pkey_protkey_aes_attr_read(u32 keytype, bool is_xts, char *buf,
1810 loff_t off, size_t count)
1811{
1812 struct protaeskeytoken protkeytoken;
1813 struct pkey_protkey protkey;
1814 int rc;
1815
1816 if (off != 0 || count < sizeof(protkeytoken))
1817 return -EINVAL;
1818 if (is_xts)
1819 if (count < 2 * sizeof(protkeytoken))
1820 return -EINVAL;
1821
1822 memset(&protkeytoken, 0, sizeof(protkeytoken));
1823 protkeytoken.type = TOKTYPE_NON_CCA;
1824 protkeytoken.version = TOKVER_PROTECTED_KEY;
1825 protkeytoken.keytype = keytype;
1826
f370f45c
HF		 1827 protkey.len = sizeof(protkey.protkey);
1828 rc = pkey_genprotkey(protkeytoken.keytype,
1829 protkey.protkey, &protkey.len, &protkey.type);
d632c047
IF		 1830 if (rc)
1831 return rc;
1832
1833 protkeytoken.len = protkey.len;
1834 memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len);
1835
1836 memcpy(buf, &protkeytoken, sizeof(protkeytoken));
1837
1838 if (is_xts) {
f370f45c
HF		 1839 /* xts needs a second protected key, reuse protkey struct */
1840 protkey.len = sizeof(protkey.protkey);
1841 rc = pkey_genprotkey(protkeytoken.keytype,
1842 protkey.protkey, &protkey.len, &protkey.type);
d632c047
IF		 1843 if (rc)
1844 return rc;
1845
1846 protkeytoken.len = protkey.len;
1847 memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len);
1848
1849 memcpy(buf + sizeof(protkeytoken), &protkeytoken,
1850 sizeof(protkeytoken));
1851
1852 return 2 * sizeof(protkeytoken);
1853 }
1854
1855 return sizeof(protkeytoken);
1856}
1857
1858static ssize_t protkey_aes_128_read(struct file *filp,
1859 struct kobject *kobj,
1860 struct bin_attribute *attr,
1861 char *buf, loff_t off,
1862 size_t count)
1863{
1864 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf,
1865 off, count);
1866}
1867
1868static ssize_t protkey_aes_192_read(struct file *filp,
1869 struct kobject *kobj,
1870 struct bin_attribute *attr,
1871 char *buf, loff_t off,
1872 size_t count)
1873{
1874 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf,
1875 off, count);
1876}
1877
1878static ssize_t protkey_aes_256_read(struct file *filp,
1879 struct kobject *kobj,
1880 struct bin_attribute *attr,
1881 char *buf, loff_t off,
1882 size_t count)
1883{
1884 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf,
1885 off, count);
1886}
1887
1888static ssize_t protkey_aes_128_xts_read(struct file *filp,
1889 struct kobject *kobj,
1890 struct bin_attribute *attr,
1891 char *buf, loff_t off,
1892 size_t count)
1893{
1894 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf,
1895 off, count);
1896}
1897
1898static ssize_t protkey_aes_256_xts_read(struct file *filp,
1899 struct kobject *kobj,
1900 struct bin_attribute *attr,
1901 char *buf, loff_t off,
1902 size_t count)
1903{
1904 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf,
1905 off, count);
1906}
1907
1908static BIN_ATTR_RO(protkey_aes_128, sizeof(struct protaeskeytoken));
1909static BIN_ATTR_RO(protkey_aes_192, sizeof(struct protaeskeytoken));
1910static BIN_ATTR_RO(protkey_aes_256, sizeof(struct protaeskeytoken));
1911static BIN_ATTR_RO(protkey_aes_128_xts, 2 * sizeof(struct protaeskeytoken));
1912static BIN_ATTR_RO(protkey_aes_256_xts, 2 * sizeof(struct protaeskeytoken));
1913
1914static struct bin_attribute *protkey_attrs[] = {
1915 &bin_attr_protkey_aes_128,
1916 &bin_attr_protkey_aes_192,
1917 &bin_attr_protkey_aes_256,
1918 &bin_attr_protkey_aes_128_xts,
1919 &bin_attr_protkey_aes_256_xts,
1920 NULL
1921};
1922
1923static struct attribute_group protkey_attr_group = {
1924 .name = "protkey",
1925 .bin_attrs = protkey_attrs,
1926};
1927
af504452
IF		 1928/*
1929 * Sysfs attribute read function for all secure key ccadata binary attributes.
1930 * The implementation can not deal with partial reads, because a new random
1931 * protected key blob is generated with each read. In case of partial reads
1932 * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
1933 */
1934static ssize_t pkey_ccadata_aes_attr_read(u32 keytype, bool is_xts, char *buf,
1935 loff_t off, size_t count)
1936{
2004b57c 1937 struct pkey_seckey *seckey = (struct pkey_seckey *)buf;
46a29b03 1938 int rc;
af504452
IF		 1939
1940 if (off != 0 || count < sizeof(struct secaeskeytoken))
1941 return -EINVAL;
1942 if (is_xts)
1943 if (count < 2 * sizeof(struct secaeskeytoken))
1944 return -EINVAL;
1945
efc598e6 1946 rc = cca_genseckey(-1, -1, keytype, seckey->seckey);
af504452
IF		 1947 if (rc)
1948 return rc;
1949
1950 if (is_xts) {
efc598e6
HF		 1951 seckey++;
1952 rc = cca_genseckey(-1, -1, keytype, seckey->seckey);
af504452
IF		 1953 if (rc)
1954 return rc;
1955
1956 return 2 * sizeof(struct secaeskeytoken);
1957 }
1958
1959 return sizeof(struct secaeskeytoken);
1960}
1961
1962static ssize_t ccadata_aes_128_read(struct file *filp,
1963 struct kobject *kobj,
1964 struct bin_attribute *attr,
1965 char *buf, loff_t off,
1966 size_t count)
1967{
1968 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf,
1969 off, count);
1970}
1971
1972static ssize_t ccadata_aes_192_read(struct file *filp,
1973 struct kobject *kobj,
1974 struct bin_attribute *attr,
1975 char *buf, loff_t off,
1976 size_t count)
1977{
1978 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf,
1979 off, count);
1980}
1981
1982static ssize_t ccadata_aes_256_read(struct file *filp,
1983 struct kobject *kobj,
1984 struct bin_attribute *attr,
1985 char *buf, loff_t off,
1986 size_t count)
1987{
1988 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf,
1989 off, count);
1990}
1991
1992static ssize_t ccadata_aes_128_xts_read(struct file *filp,
1993 struct kobject *kobj,
1994 struct bin_attribute *attr,
1995 char *buf, loff_t off,
1996 size_t count)
1997{
1998 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf,
1999 off, count);
2000}
2001
2002static ssize_t ccadata_aes_256_xts_read(struct file *filp,
2003 struct kobject *kobj,
2004 struct bin_attribute *attr,
2005 char *buf, loff_t off,
2006 size_t count)
2007{
2008 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf,
2009 off, count);
2010}
2011
2012static BIN_ATTR_RO(ccadata_aes_128, sizeof(struct secaeskeytoken));
2013static BIN_ATTR_RO(ccadata_aes_192, sizeof(struct secaeskeytoken));
2014static BIN_ATTR_RO(ccadata_aes_256, sizeof(struct secaeskeytoken));
2015static BIN_ATTR_RO(ccadata_aes_128_xts, 2 * sizeof(struct secaeskeytoken));
2016static BIN_ATTR_RO(ccadata_aes_256_xts, 2 * sizeof(struct secaeskeytoken));
2017
2018static struct bin_attribute *ccadata_attrs[] = {
2019 &bin_attr_ccadata_aes_128,
2020 &bin_attr_ccadata_aes_192,
2021 &bin_attr_ccadata_aes_256,
2022 &bin_attr_ccadata_aes_128_xts,
2023 &bin_attr_ccadata_aes_256_xts,
2024 NULL
2025};
2026
2027static struct attribute_group ccadata_attr_group = {
2028 .name = "ccadata",
2029 .bin_attrs = ccadata_attrs,
2030};
2031
f71fee27
IF		 2032#define CCACIPHERTOKENSIZE (sizeof(struct cipherkeytoken) + 80)
2033
2034/*
2035 * Sysfs attribute read function for all secure key ccacipher binary attributes.
2036 * The implementation can not deal with partial reads, because a new random
2037 * secure key blob is generated with each read. In case of partial reads
2038 * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
2039 */
2040static ssize_t pkey_ccacipher_aes_attr_read(enum pkey_key_size keybits,
2041 bool is_xts, char *buf, loff_t off,
2042 size_t count)
2043{
55d0a513 2044 size_t keysize = CCACIPHERTOKENSIZE;
46a29b03
HF		 2045 u32 nr_apqns, *apqns = NULL;
2046 int i, rc, card, dom;
f71fee27
IF		 2047
2048 if (off != 0 || count < CCACIPHERTOKENSIZE)
2049 return -EINVAL;
2050 if (is_xts)
2051 if (count < 2 * CCACIPHERTOKENSIZE)
2052 return -EINVAL;
2053
55d0a513
HF		 2054 /* build a list of apqns able to generate an cipher key */
2055 rc = cca_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
32ca04bb 2056 ZCRYPT_CEX6, 0, 0, 0, 0);
f71fee27
IF		 2057 if (rc)
2058 return rc;
f71fee27 2059
55d0a513
HF		 2060 memset(buf, 0, is_xts ? 2 * keysize : keysize);
2061
2062 /* simple try all apqns from the list */
2063 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
2064 card = apqns[i] >> 16;
2065 dom = apqns[i] & 0xFFFF;
2066 rc = cca_gencipherkey(card, dom, keybits, 0, buf, &keysize);
2067 if (rc == 0)
2068 break;
2069 }
c6337c6e
HF		 2070 if (rc)
2071 return rc;
f71fee27 2072
55d0a513
HF		 2073 if (is_xts) {
2074 keysize = CCACIPHERTOKENSIZE;
2075 buf += CCACIPHERTOKENSIZE;
2076 rc = cca_gencipherkey(card, dom, keybits, 0, buf, &keysize);
2077 if (rc == 0)
2078 return 2 * CCACIPHERTOKENSIZE;
f71fee27
IF		 2079 }
2080
2081 return CCACIPHERTOKENSIZE;
2082}
2083
2084static ssize_t ccacipher_aes_128_read(struct file *filp,
2085 struct kobject *kobj,
2086 struct bin_attribute *attr,
2087 char *buf, loff_t off,
2088 size_t count)
2089{
2090 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, false, buf,
2091 off, count);
2092}
2093
2094static ssize_t ccacipher_aes_192_read(struct file *filp,
2095 struct kobject *kobj,
2096 struct bin_attribute *attr,
2097 char *buf, loff_t off,
2098 size_t count)
2099{
2100 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_192, false, buf,
2101 off, count);
2102}
2103
2104static ssize_t ccacipher_aes_256_read(struct file *filp,
2105 struct kobject *kobj,
2106 struct bin_attribute *attr,
2107 char *buf, loff_t off,
2108 size_t count)
2109{
2110 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, false, buf,
2111 off, count);
2112}
2113
2114static ssize_t ccacipher_aes_128_xts_read(struct file *filp,
2115 struct kobject *kobj,
2116 struct bin_attribute *attr,
2117 char *buf, loff_t off,
2118 size_t count)
2119{
2120 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, true, buf,
2121 off, count);
2122}
2123
2124static ssize_t ccacipher_aes_256_xts_read(struct file *filp,
2125 struct kobject *kobj,
2126 struct bin_attribute *attr,
2127 char *buf, loff_t off,
2128 size_t count)
2129{
2130 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, true, buf,
2131 off, count);
2132}
2133
2134static BIN_ATTR_RO(ccacipher_aes_128, CCACIPHERTOKENSIZE);
2135static BIN_ATTR_RO(ccacipher_aes_192, CCACIPHERTOKENSIZE);
2136static BIN_ATTR_RO(ccacipher_aes_256, CCACIPHERTOKENSIZE);
2137static BIN_ATTR_RO(ccacipher_aes_128_xts, 2 * CCACIPHERTOKENSIZE);
2138static BIN_ATTR_RO(ccacipher_aes_256_xts, 2 * CCACIPHERTOKENSIZE);
2139
2140static struct bin_attribute *ccacipher_attrs[] = {
2141 &bin_attr_ccacipher_aes_128,
2142 &bin_attr_ccacipher_aes_192,
2143 &bin_attr_ccacipher_aes_256,
2144 &bin_attr_ccacipher_aes_128_xts,
2145 &bin_attr_ccacipher_aes_256_xts,
2146 NULL
2147};
2148
2149static struct attribute_group ccacipher_attr_group = {
2150 .name = "ccacipher",
2151 .bin_attrs = ccacipher_attrs,
2152};
2153
55d0a513
HF		 2154/*
2155 * Sysfs attribute read function for all ep11 aes key binary attributes.
2156 * The implementation can not deal with partial reads, because a new random
2157 * secure key blob is generated with each read. In case of partial reads
2158 * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
2159 * This function and the sysfs attributes using it provide EP11 key blobs
2160 * padded to the upper limit of MAXEP11AESKEYBLOBSIZE which is currently
b9352e4b 2161 * 336 bytes.
55d0a513
HF		 2162 */
2163static ssize_t pkey_ep11_aes_attr_read(enum pkey_key_size keybits,
2164 bool is_xts, char *buf, loff_t off,
2165 size_t count)
2166{
55d0a513 2167 size_t keysize = MAXEP11AESKEYBLOBSIZE;
46a29b03
HF		 2168 u32 nr_apqns, *apqns = NULL;
2169 int i, rc, card, dom;
55d0a513
HF		 2170
2171 if (off != 0 || count < MAXEP11AESKEYBLOBSIZE)
2172 return -EINVAL;
2173 if (is_xts)
2174 if (count < 2 * MAXEP11AESKEYBLOBSIZE)
2175 return -EINVAL;
2176
2177 /* build a list of apqns able to generate an cipher key */
2178 rc = ep11_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
386cb81e
HD		 2179 ZCRYPT_CEX7,
2180 ap_is_se_guest() ? EP11_API_V6 : EP11_API_V4,
2181 NULL);
55d0a513
HF		 2182 if (rc)
2183 return rc;
2184
2185 memset(buf, 0, is_xts ? 2 * keysize : keysize);
2186
2187 /* simple try all apqns from the list */
2188 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
2189 card = apqns[i] >> 16;
2190 dom = apqns[i] & 0xFFFF;
fb249ce7 2191 rc = ep11_genaeskey(card, dom, keybits, 0, buf, &keysize,
b9352e4b 2192 PKEY_TYPE_EP11_AES);
55d0a513
HF		 2193 if (rc == 0)
2194 break;
2195 }
2196 if (rc)
2197 return rc;
2198
2199 if (is_xts) {
2200 keysize = MAXEP11AESKEYBLOBSIZE;
2201 buf += MAXEP11AESKEYBLOBSIZE;
fb249ce7 2202 rc = ep11_genaeskey(card, dom, keybits, 0, buf, &keysize,
b9352e4b 2203 PKEY_TYPE_EP11_AES);
55d0a513
HF		 2204 if (rc == 0)
2205 return 2 * MAXEP11AESKEYBLOBSIZE;
2206 }
2207
2208 return MAXEP11AESKEYBLOBSIZE;
2209}
2210
2211static ssize_t ep11_aes_128_read(struct file *filp,
2212 struct kobject *kobj,
2213 struct bin_attribute *attr,
2214 char *buf, loff_t off,
2215 size_t count)
2216{
2217 return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_128, false, buf,
2218 off, count);
2219}
2220
2221static ssize_t ep11_aes_192_read(struct file *filp,
2222 struct kobject *kobj,
2223 struct bin_attribute *attr,
2224 char *buf, loff_t off,
2225 size_t count)
2226{
2227 return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_192, false, buf,
2228 off, count);
2229}
2230
2231static ssize_t ep11_aes_256_read(struct file *filp,
2232 struct kobject *kobj,
2233 struct bin_attribute *attr,
2234 char *buf, loff_t off,
2235 size_t count)
2236{
2237 return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_256, false, buf,
2238 off, count);
2239}
2240
2241static ssize_t ep11_aes_128_xts_read(struct file *filp,
2242 struct kobject *kobj,
2243 struct bin_attribute *attr,
2244 char *buf, loff_t off,
2245 size_t count)
2246{
2247 return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_128, true, buf,
2248 off, count);
2249}
2250
2251static ssize_t ep11_aes_256_xts_read(struct file *filp,
2252 struct kobject *kobj,
2253 struct bin_attribute *attr,
2254 char *buf, loff_t off,
2255 size_t count)
2256{
2257 return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_256, true, buf,
2258 off, count);
2259}
2260
2261static BIN_ATTR_RO(ep11_aes_128, MAXEP11AESKEYBLOBSIZE);
2262static BIN_ATTR_RO(ep11_aes_192, MAXEP11AESKEYBLOBSIZE);
2263static BIN_ATTR_RO(ep11_aes_256, MAXEP11AESKEYBLOBSIZE);
2264static BIN_ATTR_RO(ep11_aes_128_xts, 2 * MAXEP11AESKEYBLOBSIZE);
2265static BIN_ATTR_RO(ep11_aes_256_xts, 2 * MAXEP11AESKEYBLOBSIZE);
2266
2267static struct bin_attribute *ep11_attrs[] = {
2268 &bin_attr_ep11_aes_128,
2269 &bin_attr_ep11_aes_192,
2270 &bin_attr_ep11_aes_256,
2271 &bin_attr_ep11_aes_128_xts,
2272 &bin_attr_ep11_aes_256_xts,
2273 NULL
2274};
2275
2276static struct attribute_group ep11_attr_group = {
2277 .name = "ep11",
2278 .bin_attrs = ep11_attrs,
2279};
2280
d632c047
IF		 2281static const struct attribute_group *pkey_attr_groups[] = {
2282 &protkey_attr_group,
af504452 2283 &ccadata_attr_group,
f71fee27 2284 &ccacipher_attr_group,
55d0a513 2285 &ep11_attr_group,
d632c047
IF		 2286 NULL,
2287};
2288
e80d4af0
HF		 2289static const struct file_operations pkey_fops = {
2290 .owner = THIS_MODULE,
2291 .open = nonseekable_open,
2292 .llseek = no_llseek,
2293 .unlocked_ioctl = pkey_unlocked_ioctl,
2294};
2295
2296static struct miscdevice pkey_dev = {
2297 .name = "pkey",
2298 .minor = MISC_DYNAMIC_MINOR,
2299 .mode = 0666,
2300 .fops = &pkey_fops,
d632c047 2301 .groups = pkey_attr_groups,
e80d4af0
HF		 2302};
2303
2304/*
2305 * Module init
2306 */
cb4ef3c2 2307static int __init pkey_init(void)
e80d4af0 2308{
5b35047e 2309 cpacf_mask_t func_mask;
e80d4af0 2310
f822ad2c
HF		 2311 /*
2312 * The pckmo instruction should be available - even if we don't
2313 * actually invoke it. This instruction comes with MSA 3 which
2314 * is also the minimum level for the kmc instructions which
2315 * are able to work with protected keys.
2316 */
5b35047e 2317 if (!cpacf_query(CPACF_PCKMO, &func_mask))
58443b67 2318 return -ENODEV;
e80d4af0 2319
cb26b9ff 2320 /* check for kmc instructions available */
5b35047e 2321 if (!cpacf_query(CPACF_KMC, &func_mask))
58443b67 2322 return -ENODEV;
5b35047e
HF		 2323 if (!cpacf_test_func(&func_mask, CPACF_KMC_PAES_128) ||
2324 !cpacf_test_func(&func_mask, CPACF_KMC_PAES_192) ||
2325 !cpacf_test_func(&func_mask, CPACF_KMC_PAES_256))
58443b67 2326 return -ENODEV;
cb26b9ff 2327
e80d4af0
HF		 2328 pkey_debug_init();
2329
2330 return misc_register(&pkey_dev);
2331}
2332
2333/*
2334 * Module exit
2335 */
2336static void __exit pkey_exit(void)
2337{
2338 misc_deregister(&pkey_dev);
e80d4af0
HF		 2339 pkey_debug_exit();
2340}
2341
0a5f9b38 2342module_cpu_feature_match(S390_CPU_FEATURE_MSA, pkey_init);
e80d4af0 2343module_exit(pkey_exit);
Linux 6.x block layer and io_uring tree(s)