1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * pkey device driver 4 * 5 * Copyright IBM Corp. 2017,2019 6 * Author(s): Harald Freudenberger 7 */ 8 9 #define KMSG_COMPONENT "pkey" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include <linux/fs.h> 13 #include <linux/init.h> 14 #include <linux/miscdevice.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/kallsyms.h> 18 #include <linux/debugfs.h> 19 #include <linux/random.h> 20 #include <linux/cpufeature.h> 21 #include <asm/zcrypt.h> 22 #include <asm/cpacf.h> 23 #include <asm/pkey.h> 24 #include <crypto/aes.h> 25 26 #include "zcrypt_api.h" 27 #include "zcrypt_ccamisc.h" 28 29 MODULE_LICENSE("GPL"); 30 MODULE_AUTHOR("IBM Corporation"); 31 MODULE_DESCRIPTION("s390 protected key interface"); 32 33 #define KEYBLOBBUFSIZE 8192 /* key buffer size used for internal processing */ 34 #define MAXAPQNSINLIST 64 /* max 64 apqns within a apqn list */ 35 36 /* mask of available pckmo subfunctions, fetched once at module init */ 37 static cpacf_mask_t pckmo_functions; 38 39 /* 40 * debug feature data and functions 41 */ 42 43 static debug_info_t *debug_info; 44 45 #define DEBUG_DBG(...) debug_sprintf_event(debug_info, 6, ##__VA_ARGS__) 46 #define DEBUG_INFO(...) debug_sprintf_event(debug_info, 5, ##__VA_ARGS__) 47 #define DEBUG_WARN(...) debug_sprintf_event(debug_info, 4, ##__VA_ARGS__) 48 #define DEBUG_ERR(...) debug_sprintf_event(debug_info, 3, ##__VA_ARGS__) 49 50 static void __init pkey_debug_init(void) 51 { 52 /* 5 arguments per dbf entry (including the format string ptr) */ 53 debug_info = debug_register("pkey", 1, 1, 5 * sizeof(long)); 54 debug_register_view(debug_info, &debug_sprintf_view); 55 debug_set_level(debug_info, 3); 56 } 57 58 static void __exit pkey_debug_exit(void) 59 { 60 debug_unregister(debug_info); 61 } 62 63 /* inside view of a protected key token (only type 0x00 version 0x01) */ 64 struct protaeskeytoken { 65 u8 type; /* 0x00 for PAES specific key tokens */ 66 u8 res0[3]; 67 u8 version; /* should be 0x01 for protected AES key token */ 68 u8 res1[3]; 69 u32 keytype; /* key type, one of the PKEY_KEYTYPE values */ 70 u32 len; /* bytes actually stored in protkey[] */ 71 u8 protkey[MAXPROTKEYSIZE]; /* the protected key blob */ 72 } __packed; 73 74 /* 75 * Create a protected key from a clear key value. 76 */ 77 static int pkey_clr2protkey(u32 keytype, 78 const struct pkey_clrkey *clrkey, 79 struct pkey_protkey *protkey) 80 { 81 long fc; 82 int keysize; 83 u8 paramblock[64]; 84 85 switch (keytype) { 86 case PKEY_KEYTYPE_AES_128: 87 keysize = 16; 88 fc = CPACF_PCKMO_ENC_AES_128_KEY; 89 break; 90 case PKEY_KEYTYPE_AES_192: 91 keysize = 24; 92 fc = CPACF_PCKMO_ENC_AES_192_KEY; 93 break; 94 case PKEY_KEYTYPE_AES_256: 95 keysize = 32; 96 fc = CPACF_PCKMO_ENC_AES_256_KEY; 97 break; 98 default: 99 DEBUG_ERR("%s unknown/unsupported keytype %d\n", 100 __func__, keytype); 101 return -EINVAL; 102 } 103 104 /* 105 * Check if the needed pckmo subfunction is available. 106 * These subfunctions can be enabled/disabled by customers 107 * in the LPAR profile or may even change on the fly. 108 */ 109 if (!cpacf_test_func(&pckmo_functions, fc)) { 110 DEBUG_ERR("%s pckmo functions not available\n", __func__); 111 return -ENODEV; 112 } 113 114 /* prepare param block */ 115 memset(paramblock, 0, sizeof(paramblock)); 116 memcpy(paramblock, clrkey->clrkey, keysize); 117 118 /* call the pckmo instruction */ 119 cpacf_pckmo(fc, paramblock); 120 121 /* copy created protected key */ 122 protkey->type = keytype; 123 protkey->len = keysize + 32; 124 memcpy(protkey->protkey, paramblock, keysize + 32); 125 126 return 0; 127 } 128 129 /* 130 * Find card and transform secure key into protected key. 131 */ 132 static int pkey_skey2pkey(const u8 *key, struct pkey_protkey *pkey) 133 { 134 int rc, verify; 135 u16 cardnr, domain; 136 struct keytoken_header *hdr = (struct keytoken_header *)key; 137 138 /* 139 * The cca_xxx2protkey call may fail when a card has been 140 * addressed where the master key was changed after last fetch 141 * of the mkvp into the cache. Try 3 times: First witout verify 142 * then with verify and last round with verify and old master 143 * key verification pattern match not ignored. 144 */ 145 for (verify = 0; verify < 3; verify++) { 146 rc = cca_findcard(key, &cardnr, &domain, verify); 147 if (rc < 0) 148 continue; 149 if (rc > 0 && verify < 2) 150 continue; 151 switch (hdr->version) { 152 case TOKVER_CCA_AES: 153 rc = cca_sec2protkey(cardnr, domain, 154 key, pkey->protkey, 155 &pkey->len, &pkey->type); 156 break; 157 case TOKVER_CCA_VLSC: 158 rc = cca_cipher2protkey(cardnr, domain, 159 key, pkey->protkey, 160 &pkey->len, &pkey->type); 161 break; 162 default: 163 return -EINVAL; 164 } 165 if (rc == 0) 166 break; 167 } 168 169 if (rc) 170 DEBUG_DBG("%s failed rc=%d\n", __func__, rc); 171 172 return rc; 173 } 174 175 /* 176 * Verify key and give back some info about the key. 177 */ 178 static int pkey_verifykey(const struct pkey_seckey *seckey, 179 u16 *pcardnr, u16 *pdomain, 180 u16 *pkeysize, u32 *pattributes) 181 { 182 struct secaeskeytoken *t = (struct secaeskeytoken *) seckey; 183 u16 cardnr, domain; 184 int rc; 185 186 /* check the secure key for valid AES secure key */ 187 rc = cca_check_secaeskeytoken(debug_info, 3, (u8 *) seckey, 0); 188 if (rc) 189 goto out; 190 if (pattributes) 191 *pattributes = PKEY_VERIFY_ATTR_AES; 192 if (pkeysize) 193 *pkeysize = t->bitsize; 194 195 /* try to find a card which can handle this key */ 196 rc = cca_findcard(seckey->seckey, &cardnr, &domain, 1); 197 if (rc < 0) 198 goto out; 199 200 if (rc > 0) { 201 /* key mkvp matches to old master key mkvp */ 202 DEBUG_DBG("%s secure key has old mkvp\n", __func__); 203 if (pattributes) 204 *pattributes |= PKEY_VERIFY_ATTR_OLD_MKVP; 205 rc = 0; 206 } 207 208 if (pcardnr) 209 *pcardnr = cardnr; 210 if (pdomain) 211 *pdomain = domain; 212 213 out: 214 DEBUG_DBG("%s rc=%d\n", __func__, rc); 215 return rc; 216 } 217 218 /* 219 * Generate a random protected key 220 */ 221 static int pkey_genprotkey(u32 keytype, struct pkey_protkey *protkey) 222 { 223 struct pkey_clrkey clrkey; 224 int keysize; 225 int rc; 226 227 switch (keytype) { 228 case PKEY_KEYTYPE_AES_128: 229 keysize = 16; 230 break; 231 case PKEY_KEYTYPE_AES_192: 232 keysize = 24; 233 break; 234 case PKEY_KEYTYPE_AES_256: 235 keysize = 32; 236 break; 237 default: 238 DEBUG_ERR("%s unknown/unsupported keytype %d\n", __func__, 239 keytype); 240 return -EINVAL; 241 } 242 243 /* generate a dummy random clear key */ 244 get_random_bytes(clrkey.clrkey, keysize); 245 246 /* convert it to a dummy protected key */ 247 rc = pkey_clr2protkey(keytype, &clrkey, protkey); 248 if (rc) 249 return rc; 250 251 /* replace the key part of the protected key with random bytes */ 252 get_random_bytes(protkey->protkey, keysize); 253 254 return 0; 255 } 256 257 /* 258 * Verify if a protected key is still valid 259 */ 260 static int pkey_verifyprotkey(const struct pkey_protkey *protkey) 261 { 262 unsigned long fc; 263 struct { 264 u8 iv[AES_BLOCK_SIZE]; 265 u8 key[MAXPROTKEYSIZE]; 266 } param; 267 u8 null_msg[AES_BLOCK_SIZE]; 268 u8 dest_buf[AES_BLOCK_SIZE]; 269 unsigned int k; 270 271 switch (protkey->type) { 272 case PKEY_KEYTYPE_AES_128: 273 fc = CPACF_KMC_PAES_128; 274 break; 275 case PKEY_KEYTYPE_AES_192: 276 fc = CPACF_KMC_PAES_192; 277 break; 278 case PKEY_KEYTYPE_AES_256: 279 fc = CPACF_KMC_PAES_256; 280 break; 281 default: 282 DEBUG_ERR("%s unknown/unsupported keytype %d\n", __func__, 283 protkey->type); 284 return -EINVAL; 285 } 286 287 memset(null_msg, 0, sizeof(null_msg)); 288 289 memset(param.iv, 0, sizeof(param.iv)); 290 memcpy(param.key, protkey->protkey, sizeof(param.key)); 291 292 k = cpacf_kmc(fc | CPACF_ENCRYPT, ¶m, null_msg, dest_buf, 293 sizeof(null_msg)); 294 if (k != sizeof(null_msg)) { 295 DEBUG_ERR("%s protected key is not valid\n", __func__); 296 return -EKEYREJECTED; 297 } 298 299 return 0; 300 } 301 302 /* 303 * Transform a non-CCA key token into a protected key 304 */ 305 static int pkey_nonccatok2pkey(const u8 *key, u32 keylen, 306 struct pkey_protkey *protkey) 307 { 308 struct keytoken_header *hdr = (struct keytoken_header *)key; 309 struct protaeskeytoken *t; 310 311 switch (hdr->version) { 312 case TOKVER_PROTECTED_KEY: 313 if (keylen != sizeof(struct protaeskeytoken)) 314 return -EINVAL; 315 316 t = (struct protaeskeytoken *)key; 317 protkey->len = t->len; 318 protkey->type = t->keytype; 319 memcpy(protkey->protkey, t->protkey, 320 sizeof(protkey->protkey)); 321 322 return pkey_verifyprotkey(protkey); 323 default: 324 DEBUG_ERR("%s unknown/unsupported non-CCA token version %d\n", 325 __func__, hdr->version); 326 return -EINVAL; 327 } 328 } 329 330 /* 331 * Transform a CCA internal key token into a protected key 332 */ 333 static int pkey_ccainttok2pkey(const u8 *key, u32 keylen, 334 struct pkey_protkey *protkey) 335 { 336 struct keytoken_header *hdr = (struct keytoken_header *)key; 337 338 switch (hdr->version) { 339 case TOKVER_CCA_AES: 340 if (keylen != sizeof(struct secaeskeytoken)) 341 return -EINVAL; 342 break; 343 case TOKVER_CCA_VLSC: 344 if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE) 345 return -EINVAL; 346 break; 347 default: 348 DEBUG_ERR("%s unknown/unsupported CCA internal token version %d\n", 349 __func__, hdr->version); 350 return -EINVAL; 351 } 352 353 return pkey_skey2pkey(key, protkey); 354 } 355 356 /* 357 * Transform a key blob (of any type) into a protected key 358 */ 359 int pkey_keyblob2pkey(const u8 *key, u32 keylen, 360 struct pkey_protkey *protkey) 361 { 362 int rc; 363 struct keytoken_header *hdr = (struct keytoken_header *)key; 364 365 if (keylen < sizeof(struct keytoken_header)) { 366 DEBUG_ERR("%s invalid keylen %d\n", __func__, keylen); 367 return -EINVAL; 368 } 369 370 switch (hdr->type) { 371 case TOKTYPE_NON_CCA: 372 rc = pkey_nonccatok2pkey(key, keylen, protkey); 373 break; 374 case TOKTYPE_CCA_INTERNAL: 375 rc = pkey_ccainttok2pkey(key, keylen, protkey); 376 break; 377 default: 378 DEBUG_ERR("%s unknown/unsupported blob type %d\n", 379 __func__, hdr->type); 380 return -EINVAL; 381 } 382 383 DEBUG_DBG("%s rc=%d\n", __func__, rc); 384 return rc; 385 386 } 387 EXPORT_SYMBOL(pkey_keyblob2pkey); 388 389 static int pkey_genseckey2(const struct pkey_apqn *apqns, size_t nr_apqns, 390 enum pkey_key_type ktype, enum pkey_key_size ksize, 391 u32 kflags, u8 *keybuf, size_t *keybufsize) 392 { 393 int i, card, dom, rc; 394 395 /* check for at least one apqn given */ 396 if (!apqns || !nr_apqns) 397 return -EINVAL; 398 399 /* check key type and size */ 400 switch (ktype) { 401 case PKEY_TYPE_CCA_DATA: 402 case PKEY_TYPE_CCA_CIPHER: 403 if (*keybufsize < SECKEYBLOBSIZE) 404 return -EINVAL; 405 break; 406 default: 407 return -EINVAL; 408 } 409 switch (ksize) { 410 case PKEY_SIZE_AES_128: 411 case PKEY_SIZE_AES_192: 412 case PKEY_SIZE_AES_256: 413 break; 414 default: 415 return -EINVAL; 416 } 417 418 /* simple try all apqns from the list */ 419 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) { 420 card = apqns[i].card; 421 dom = apqns[i].domain; 422 if (ktype == PKEY_TYPE_CCA_DATA) { 423 rc = cca_genseckey(card, dom, ksize, keybuf); 424 *keybufsize = (rc ? 0 : SECKEYBLOBSIZE); 425 } else /* TOKVER_CCA_VLSC */ 426 rc = cca_gencipherkey(card, dom, ksize, kflags, 427 keybuf, keybufsize); 428 if (rc == 0) 429 break; 430 } 431 432 return rc; 433 } 434 435 static int pkey_clr2seckey2(const struct pkey_apqn *apqns, size_t nr_apqns, 436 enum pkey_key_type ktype, enum pkey_key_size ksize, 437 u32 kflags, const u8 *clrkey, 438 u8 *keybuf, size_t *keybufsize) 439 { 440 int i, card, dom, rc; 441 442 /* check for at least one apqn given */ 443 if (!apqns || !nr_apqns) 444 return -EINVAL; 445 446 /* check key type and size */ 447 switch (ktype) { 448 case PKEY_TYPE_CCA_DATA: 449 case PKEY_TYPE_CCA_CIPHER: 450 if (*keybufsize < SECKEYBLOBSIZE) 451 return -EINVAL; 452 break; 453 default: 454 return -EINVAL; 455 } 456 switch (ksize) { 457 case PKEY_SIZE_AES_128: 458 case PKEY_SIZE_AES_192: 459 case PKEY_SIZE_AES_256: 460 break; 461 default: 462 return -EINVAL; 463 } 464 465 /* simple try all apqns from the list */ 466 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) { 467 card = apqns[i].card; 468 dom = apqns[i].domain; 469 if (ktype == PKEY_TYPE_CCA_DATA) { 470 rc = cca_clr2seckey(card, dom, ksize, 471 clrkey, keybuf); 472 *keybufsize = (rc ? 0 : SECKEYBLOBSIZE); 473 } else /* TOKVER_CCA_VLSC */ 474 rc = cca_clr2cipherkey(card, dom, ksize, kflags, 475 clrkey, keybuf, keybufsize); 476 if (rc == 0) 477 break; 478 } 479 480 return rc; 481 } 482 483 static int pkey_verifykey2(const u8 *key, size_t keylen, 484 u16 *cardnr, u16 *domain, 485 enum pkey_key_type *ktype, 486 enum pkey_key_size *ksize, u32 *flags) 487 { 488 int rc; 489 u32 _nr_apqns, *_apqns = NULL; 490 struct keytoken_header *hdr = (struct keytoken_header *)key; 491 492 if (keylen < sizeof(struct keytoken_header) || 493 hdr->type != TOKTYPE_CCA_INTERNAL) 494 return -EINVAL; 495 496 if (hdr->version == TOKVER_CCA_AES) { 497 struct secaeskeytoken *t = (struct secaeskeytoken *)key; 498 499 rc = cca_check_secaeskeytoken(debug_info, 3, key, 0); 500 if (rc) 501 goto out; 502 if (ktype) 503 *ktype = PKEY_TYPE_CCA_DATA; 504 if (ksize) 505 *ksize = (enum pkey_key_size) t->bitsize; 506 507 rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain, 508 ZCRYPT_CEX3C, t->mkvp, 0, 1); 509 if (rc == 0 && flags) 510 *flags = PKEY_FLAGS_MATCH_CUR_MKVP; 511 if (rc == -ENODEV) { 512 rc = cca_findcard2(&_apqns, &_nr_apqns, 513 *cardnr, *domain, 514 ZCRYPT_CEX3C, 0, t->mkvp, 1); 515 if (rc == 0 && flags) 516 *flags = PKEY_FLAGS_MATCH_ALT_MKVP; 517 } 518 if (rc) 519 goto out; 520 521 *cardnr = ((struct pkey_apqn *)_apqns)->card; 522 *domain = ((struct pkey_apqn *)_apqns)->domain; 523 524 } else if (hdr->version == TOKVER_CCA_VLSC) { 525 struct cipherkeytoken *t = (struct cipherkeytoken *)key; 526 527 rc = cca_check_secaescipherkey(debug_info, 3, key, 0, 1); 528 if (rc) 529 goto out; 530 if (ktype) 531 *ktype = PKEY_TYPE_CCA_CIPHER; 532 if (ksize) { 533 *ksize = PKEY_SIZE_UNKNOWN; 534 if (!t->plfver && t->wpllen == 512) 535 *ksize = PKEY_SIZE_AES_128; 536 else if (!t->plfver && t->wpllen == 576) 537 *ksize = PKEY_SIZE_AES_192; 538 else if (!t->plfver && t->wpllen == 640) 539 *ksize = PKEY_SIZE_AES_256; 540 } 541 542 rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain, 543 ZCRYPT_CEX6, t->mkvp0, 0, 1); 544 if (rc == 0 && flags) 545 *flags = PKEY_FLAGS_MATCH_CUR_MKVP; 546 if (rc == -ENODEV) { 547 rc = cca_findcard2(&_apqns, &_nr_apqns, 548 *cardnr, *domain, 549 ZCRYPT_CEX6, 0, t->mkvp0, 1); 550 if (rc == 0 && flags) 551 *flags = PKEY_FLAGS_MATCH_ALT_MKVP; 552 } 553 if (rc) 554 goto out; 555 556 *cardnr = ((struct pkey_apqn *)_apqns)->card; 557 *domain = ((struct pkey_apqn *)_apqns)->domain; 558 559 } else 560 rc = -EINVAL; 561 562 out: 563 kfree(_apqns); 564 return rc; 565 } 566 567 static int pkey_keyblob2pkey2(const struct pkey_apqn *apqns, size_t nr_apqns, 568 const u8 *key, size_t keylen, 569 struct pkey_protkey *pkey) 570 { 571 int i, card, dom, rc; 572 struct keytoken_header *hdr = (struct keytoken_header *)key; 573 574 /* check for at least one apqn given */ 575 if (!apqns || !nr_apqns) 576 return -EINVAL; 577 578 if (keylen < sizeof(struct keytoken_header)) 579 return -EINVAL; 580 581 switch (hdr->type) { 582 case TOKTYPE_NON_CCA: 583 return pkey_nonccatok2pkey(key, keylen, pkey); 584 case TOKTYPE_CCA_INTERNAL: 585 switch (hdr->version) { 586 case TOKVER_CCA_AES: 587 if (keylen != sizeof(struct secaeskeytoken)) 588 return -EINVAL; 589 if (cca_check_secaeskeytoken(debug_info, 3, key, 0)) 590 return -EINVAL; 591 break; 592 case TOKVER_CCA_VLSC: 593 if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE) 594 return -EINVAL; 595 if (cca_check_secaescipherkey(debug_info, 3, key, 0, 1)) 596 return -EINVAL; 597 break; 598 default: 599 DEBUG_ERR("%s unknown CCA internal token version %d\n", 600 __func__, hdr->version); 601 return -EINVAL; 602 } 603 break; 604 default: 605 DEBUG_ERR("%s unknown/unsupported blob type %d\n", 606 __func__, hdr->type); 607 return -EINVAL; 608 } 609 610 /* simple try all apqns from the list */ 611 for (i = 0, rc = -ENODEV; i < nr_apqns; i++) { 612 card = apqns[i].card; 613 dom = apqns[i].domain; 614 if (hdr->version == TOKVER_CCA_AES) 615 rc = cca_sec2protkey(card, dom, key, pkey->protkey, 616 &pkey->len, &pkey->type); 617 else /* TOKVER_CCA_VLSC */ 618 rc = cca_cipher2protkey(card, dom, key, pkey->protkey, 619 &pkey->len, &pkey->type); 620 if (rc == 0) 621 break; 622 } 623 624 return rc; 625 } 626 627 static int pkey_apqns4key(const u8 *key, size_t keylen, u32 flags, 628 struct pkey_apqn *apqns, size_t *nr_apqns) 629 { 630 int rc = EINVAL; 631 u32 _nr_apqns, *_apqns = NULL; 632 struct keytoken_header *hdr = (struct keytoken_header *)key; 633 634 if (keylen < sizeof(struct keytoken_header) || 635 hdr->type != TOKTYPE_CCA_INTERNAL || 636 flags == 0) 637 return -EINVAL; 638 639 if (hdr->version == TOKVER_CCA_AES || hdr->version == TOKVER_CCA_VLSC) { 640 int minhwtype = ZCRYPT_CEX3C; 641 u64 cur_mkvp = 0, old_mkvp = 0; 642 643 if (hdr->version == TOKVER_CCA_AES) { 644 struct secaeskeytoken *t = (struct secaeskeytoken *)key; 645 646 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP) 647 cur_mkvp = t->mkvp; 648 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP) 649 old_mkvp = t->mkvp; 650 } else { 651 struct cipherkeytoken *t = (struct cipherkeytoken *)key; 652 653 minhwtype = ZCRYPT_CEX6; 654 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP) 655 cur_mkvp = t->mkvp0; 656 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP) 657 old_mkvp = t->mkvp0; 658 } 659 rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF, 660 minhwtype, cur_mkvp, old_mkvp, 1); 661 if (rc) 662 goto out; 663 if (apqns) { 664 if (*nr_apqns < _nr_apqns) 665 rc = -ENOSPC; 666 else 667 memcpy(apqns, _apqns, _nr_apqns * sizeof(u32)); 668 } 669 *nr_apqns = _nr_apqns; 670 } 671 672 out: 673 kfree(_apqns); 674 return rc; 675 } 676 677 static int pkey_apqns4keytype(enum pkey_key_type ktype, 678 u8 cur_mkvp[32], u8 alt_mkvp[32], u32 flags, 679 struct pkey_apqn *apqns, size_t *nr_apqns) 680 { 681 int rc = -EINVAL; 682 u32 _nr_apqns, *_apqns = NULL; 683 684 if (ktype == PKEY_TYPE_CCA_DATA || ktype == PKEY_TYPE_CCA_CIPHER) { 685 u64 cur_mkvp = 0, old_mkvp = 0; 686 int minhwtype = ZCRYPT_CEX3C; 687 688 if (flags & PKEY_FLAGS_MATCH_CUR_MKVP) 689 cur_mkvp = *((u64 *) cur_mkvp); 690 if (flags & PKEY_FLAGS_MATCH_ALT_MKVP) 691 old_mkvp = *((u64 *) alt_mkvp); 692 if (ktype == PKEY_TYPE_CCA_CIPHER) 693 minhwtype = ZCRYPT_CEX6; 694 rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF, 695 minhwtype, cur_mkvp, old_mkvp, 1); 696 if (rc) 697 goto out; 698 if (apqns) { 699 if (*nr_apqns < _nr_apqns) 700 rc = -ENOSPC; 701 else 702 memcpy(apqns, _apqns, _nr_apqns * sizeof(u32)); 703 } 704 *nr_apqns = _nr_apqns; 705 } 706 707 out: 708 kfree(_apqns); 709 return rc; 710 } 711 712 /* 713 * File io functions 714 */ 715 716 static void *_copy_key_from_user(void __user *ukey, size_t keylen) 717 { 718 void *kkey; 719 720 if (!ukey || keylen < MINKEYBLOBSIZE || keylen > KEYBLOBBUFSIZE) 721 return ERR_PTR(-EINVAL); 722 kkey = kmalloc(keylen, GFP_KERNEL); 723 if (!kkey) 724 return ERR_PTR(-ENOMEM); 725 if (copy_from_user(kkey, ukey, keylen)) { 726 kfree(kkey); 727 return ERR_PTR(-EFAULT); 728 } 729 730 return kkey; 731 } 732 733 static void *_copy_apqns_from_user(void __user *uapqns, size_t nr_apqns) 734 { 735 void *kapqns = NULL; 736 size_t nbytes; 737 738 if (uapqns && nr_apqns > 0) { 739 nbytes = nr_apqns * sizeof(struct pkey_apqn); 740 kapqns = kmalloc(nbytes, GFP_KERNEL); 741 if (!kapqns) 742 return ERR_PTR(-ENOMEM); 743 if (copy_from_user(kapqns, uapqns, nbytes)) 744 return ERR_PTR(-EFAULT); 745 } 746 747 return kapqns; 748 } 749 750 static long pkey_unlocked_ioctl(struct file *filp, unsigned int cmd, 751 unsigned long arg) 752 { 753 int rc; 754 755 switch (cmd) { 756 case PKEY_GENSECK: { 757 struct pkey_genseck __user *ugs = (void __user *) arg; 758 struct pkey_genseck kgs; 759 760 if (copy_from_user(&kgs, ugs, sizeof(kgs))) 761 return -EFAULT; 762 rc = cca_genseckey(kgs.cardnr, kgs.domain, 763 kgs.keytype, kgs.seckey.seckey); 764 DEBUG_DBG("%s cca_genseckey()=%d\n", __func__, rc); 765 if (rc) 766 break; 767 if (copy_to_user(ugs, &kgs, sizeof(kgs))) 768 return -EFAULT; 769 break; 770 } 771 case PKEY_CLR2SECK: { 772 struct pkey_clr2seck __user *ucs = (void __user *) arg; 773 struct pkey_clr2seck kcs; 774 775 if (copy_from_user(&kcs, ucs, sizeof(kcs))) 776 return -EFAULT; 777 rc = cca_clr2seckey(kcs.cardnr, kcs.domain, kcs.keytype, 778 kcs.clrkey.clrkey, kcs.seckey.seckey); 779 DEBUG_DBG("%s cca_clr2seckey()=%d\n", __func__, rc); 780 if (rc) 781 break; 782 if (copy_to_user(ucs, &kcs, sizeof(kcs))) 783 return -EFAULT; 784 memzero_explicit(&kcs, sizeof(kcs)); 785 break; 786 } 787 case PKEY_SEC2PROTK: { 788 struct pkey_sec2protk __user *usp = (void __user *) arg; 789 struct pkey_sec2protk ksp; 790 791 if (copy_from_user(&ksp, usp, sizeof(ksp))) 792 return -EFAULT; 793 rc = cca_sec2protkey(ksp.cardnr, ksp.domain, 794 ksp.seckey.seckey, ksp.protkey.protkey, 795 NULL, &ksp.protkey.type); 796 DEBUG_DBG("%s cca_sec2protkey()=%d\n", __func__, rc); 797 if (rc) 798 break; 799 if (copy_to_user(usp, &ksp, sizeof(ksp))) 800 return -EFAULT; 801 break; 802 } 803 case PKEY_CLR2PROTK: { 804 struct pkey_clr2protk __user *ucp = (void __user *) arg; 805 struct pkey_clr2protk kcp; 806 807 if (copy_from_user(&kcp, ucp, sizeof(kcp))) 808 return -EFAULT; 809 rc = pkey_clr2protkey(kcp.keytype, 810 &kcp.clrkey, &kcp.protkey); 811 DEBUG_DBG("%s pkey_clr2protkey()=%d\n", __func__, rc); 812 if (rc) 813 break; 814 if (copy_to_user(ucp, &kcp, sizeof(kcp))) 815 return -EFAULT; 816 memzero_explicit(&kcp, sizeof(kcp)); 817 break; 818 } 819 case PKEY_FINDCARD: { 820 struct pkey_findcard __user *ufc = (void __user *) arg; 821 struct pkey_findcard kfc; 822 823 if (copy_from_user(&kfc, ufc, sizeof(kfc))) 824 return -EFAULT; 825 rc = cca_findcard(kfc.seckey.seckey, 826 &kfc.cardnr, &kfc.domain, 1); 827 DEBUG_DBG("%s cca_findcard()=%d\n", __func__, rc); 828 if (rc < 0) 829 break; 830 if (copy_to_user(ufc, &kfc, sizeof(kfc))) 831 return -EFAULT; 832 break; 833 } 834 case PKEY_SKEY2PKEY: { 835 struct pkey_skey2pkey __user *usp = (void __user *) arg; 836 struct pkey_skey2pkey ksp; 837 838 if (copy_from_user(&ksp, usp, sizeof(ksp))) 839 return -EFAULT; 840 rc = pkey_skey2pkey(ksp.seckey.seckey, &ksp.protkey); 841 DEBUG_DBG("%s pkey_skey2pkey()=%d\n", __func__, rc); 842 if (rc) 843 break; 844 if (copy_to_user(usp, &ksp, sizeof(ksp))) 845 return -EFAULT; 846 break; 847 } 848 case PKEY_VERIFYKEY: { 849 struct pkey_verifykey __user *uvk = (void __user *) arg; 850 struct pkey_verifykey kvk; 851 852 if (copy_from_user(&kvk, uvk, sizeof(kvk))) 853 return -EFAULT; 854 rc = pkey_verifykey(&kvk.seckey, &kvk.cardnr, &kvk.domain, 855 &kvk.keysize, &kvk.attributes); 856 DEBUG_DBG("%s pkey_verifykey()=%d\n", __func__, rc); 857 if (rc) 858 break; 859 if (copy_to_user(uvk, &kvk, sizeof(kvk))) 860 return -EFAULT; 861 break; 862 } 863 case PKEY_GENPROTK: { 864 struct pkey_genprotk __user *ugp = (void __user *) arg; 865 struct pkey_genprotk kgp; 866 867 if (copy_from_user(&kgp, ugp, sizeof(kgp))) 868 return -EFAULT; 869 rc = pkey_genprotkey(kgp.keytype, &kgp.protkey); 870 DEBUG_DBG("%s pkey_genprotkey()=%d\n", __func__, rc); 871 if (rc) 872 break; 873 if (copy_to_user(ugp, &kgp, sizeof(kgp))) 874 return -EFAULT; 875 break; 876 } 877 case PKEY_VERIFYPROTK: { 878 struct pkey_verifyprotk __user *uvp = (void __user *) arg; 879 struct pkey_verifyprotk kvp; 880 881 if (copy_from_user(&kvp, uvp, sizeof(kvp))) 882 return -EFAULT; 883 rc = pkey_verifyprotkey(&kvp.protkey); 884 DEBUG_DBG("%s pkey_verifyprotkey()=%d\n", __func__, rc); 885 break; 886 } 887 case PKEY_KBLOB2PROTK: { 888 struct pkey_kblob2pkey __user *utp = (void __user *) arg; 889 struct pkey_kblob2pkey ktp; 890 u8 *kkey; 891 892 if (copy_from_user(&ktp, utp, sizeof(ktp))) 893 return -EFAULT; 894 kkey = _copy_key_from_user(ktp.key, ktp.keylen); 895 if (IS_ERR(kkey)) 896 return PTR_ERR(kkey); 897 rc = pkey_keyblob2pkey(kkey, ktp.keylen, &ktp.protkey); 898 DEBUG_DBG("%s pkey_keyblob2pkey()=%d\n", __func__, rc); 899 kfree(kkey); 900 if (rc) 901 break; 902 if (copy_to_user(utp, &ktp, sizeof(ktp))) 903 return -EFAULT; 904 break; 905 } 906 case PKEY_GENSECK2: { 907 struct pkey_genseck2 __user *ugs = (void __user *) arg; 908 struct pkey_genseck2 kgs; 909 struct pkey_apqn *apqns; 910 size_t klen = KEYBLOBBUFSIZE; 911 u8 *kkey; 912 913 if (copy_from_user(&kgs, ugs, sizeof(kgs))) 914 return -EFAULT; 915 apqns = _copy_apqns_from_user(kgs.apqns, kgs.apqn_entries); 916 if (IS_ERR(apqns)) 917 return PTR_ERR(apqns); 918 kkey = kmalloc(klen, GFP_KERNEL); 919 if (!kkey) { 920 kfree(apqns); 921 return -ENOMEM; 922 } 923 rc = pkey_genseckey2(apqns, kgs.apqn_entries, 924 kgs.type, kgs.size, kgs.keygenflags, 925 kkey, &klen); 926 DEBUG_DBG("%s pkey_genseckey2()=%d\n", __func__, rc); 927 kfree(apqns); 928 if (rc) { 929 kfree(kkey); 930 break; 931 } 932 if (kgs.key) { 933 if (kgs.keylen < klen) { 934 kfree(kkey); 935 return -EINVAL; 936 } 937 if (copy_to_user(kgs.key, kkey, klen)) { 938 kfree(kkey); 939 return -EFAULT; 940 } 941 } 942 kgs.keylen = klen; 943 if (copy_to_user(ugs, &kgs, sizeof(kgs))) 944 rc = -EFAULT; 945 kfree(kkey); 946 break; 947 } 948 case PKEY_CLR2SECK2: { 949 struct pkey_clr2seck2 __user *ucs = (void __user *) arg; 950 struct pkey_clr2seck2 kcs; 951 struct pkey_apqn *apqns; 952 size_t klen = KEYBLOBBUFSIZE; 953 u8 *kkey; 954 955 if (copy_from_user(&kcs, ucs, sizeof(kcs))) 956 return -EFAULT; 957 apqns = _copy_apqns_from_user(kcs.apqns, kcs.apqn_entries); 958 if (IS_ERR(apqns)) 959 return PTR_ERR(apqns); 960 kkey = kmalloc(klen, GFP_KERNEL); 961 if (!kkey) { 962 kfree(apqns); 963 return -ENOMEM; 964 } 965 rc = pkey_clr2seckey2(apqns, kcs.apqn_entries, 966 kcs.type, kcs.size, kcs.keygenflags, 967 kcs.clrkey.clrkey, kkey, &klen); 968 DEBUG_DBG("%s pkey_clr2seckey2()=%d\n", __func__, rc); 969 kfree(apqns); 970 if (rc) { 971 kfree(kkey); 972 break; 973 } 974 if (kcs.key) { 975 if (kcs.keylen < klen) { 976 kfree(kkey); 977 return -EINVAL; 978 } 979 if (copy_to_user(kcs.key, kkey, klen)) { 980 kfree(kkey); 981 return -EFAULT; 982 } 983 } 984 kcs.keylen = klen; 985 if (copy_to_user(ucs, &kcs, sizeof(kcs))) 986 rc = -EFAULT; 987 memzero_explicit(&kcs, sizeof(kcs)); 988 kfree(kkey); 989 break; 990 } 991 case PKEY_VERIFYKEY2: { 992 struct pkey_verifykey2 __user *uvk = (void __user *) arg; 993 struct pkey_verifykey2 kvk; 994 u8 *kkey; 995 996 if (copy_from_user(&kvk, uvk, sizeof(kvk))) 997 return -EFAULT; 998 kkey = _copy_key_from_user(kvk.key, kvk.keylen); 999 if (IS_ERR(kkey)) 1000 return PTR_ERR(kkey); 1001 rc = pkey_verifykey2(kkey, kvk.keylen, 1002 &kvk.cardnr, &kvk.domain, 1003 &kvk.type, &kvk.size, &kvk.flags); 1004 DEBUG_DBG("%s pkey_verifykey2()=%d\n", __func__, rc); 1005 kfree(kkey); 1006 if (rc) 1007 break; 1008 if (copy_to_user(uvk, &kvk, sizeof(kvk))) 1009 return -EFAULT; 1010 break; 1011 } 1012 case PKEY_KBLOB2PROTK2: { 1013 struct pkey_kblob2pkey2 __user *utp = (void __user *) arg; 1014 struct pkey_kblob2pkey2 ktp; 1015 struct pkey_apqn *apqns = NULL; 1016 u8 *kkey; 1017 1018 if (copy_from_user(&ktp, utp, sizeof(ktp))) 1019 return -EFAULT; 1020 apqns = _copy_apqns_from_user(ktp.apqns, ktp.apqn_entries); 1021 if (IS_ERR(apqns)) 1022 return PTR_ERR(apqns); 1023 kkey = _copy_key_from_user(ktp.key, ktp.keylen); 1024 if (IS_ERR(kkey)) { 1025 kfree(apqns); 1026 return PTR_ERR(kkey); 1027 } 1028 rc = pkey_keyblob2pkey2(apqns, ktp.apqn_entries, 1029 kkey, ktp.keylen, &ktp.protkey); 1030 DEBUG_DBG("%s pkey_keyblob2pkey2()=%d\n", __func__, rc); 1031 kfree(apqns); 1032 kfree(kkey); 1033 if (rc) 1034 break; 1035 if (copy_to_user(utp, &ktp, sizeof(ktp))) 1036 return -EFAULT; 1037 break; 1038 } 1039 case PKEY_APQNS4K: { 1040 struct pkey_apqns4key __user *uak = (void __user *) arg; 1041 struct pkey_apqns4key kak; 1042 struct pkey_apqn *apqns = NULL; 1043 size_t nr_apqns, len; 1044 u8 *kkey; 1045 1046 if (copy_from_user(&kak, uak, sizeof(kak))) 1047 return -EFAULT; 1048 nr_apqns = kak.apqn_entries; 1049 if (nr_apqns) { 1050 apqns = kmalloc_array(nr_apqns, 1051 sizeof(struct pkey_apqn), 1052 GFP_KERNEL); 1053 if (!apqns) 1054 return -ENOMEM; 1055 } 1056 kkey = _copy_key_from_user(kak.key, kak.keylen); 1057 if (IS_ERR(kkey)) { 1058 kfree(apqns); 1059 return PTR_ERR(kkey); 1060 } 1061 rc = pkey_apqns4key(kkey, kak.keylen, kak.flags, 1062 apqns, &nr_apqns); 1063 DEBUG_DBG("%s pkey_apqns4key()=%d\n", __func__, rc); 1064 kfree(kkey); 1065 if (rc && rc != -ENOSPC) { 1066 kfree(apqns); 1067 break; 1068 } 1069 if (!rc && kak.apqns) { 1070 if (nr_apqns > kak.apqn_entries) { 1071 kfree(apqns); 1072 return -EINVAL; 1073 } 1074 len = nr_apqns * sizeof(struct pkey_apqn); 1075 if (len) { 1076 if (copy_to_user(kak.apqns, apqns, len)) { 1077 kfree(apqns); 1078 return -EFAULT; 1079 } 1080 } 1081 } 1082 kak.apqn_entries = nr_apqns; 1083 if (copy_to_user(uak, &kak, sizeof(kak))) 1084 rc = -EFAULT; 1085 kfree(apqns); 1086 break; 1087 } 1088 case PKEY_APQNS4KT: { 1089 struct pkey_apqns4keytype __user *uat = (void __user *) arg; 1090 struct pkey_apqns4keytype kat; 1091 struct pkey_apqn *apqns = NULL; 1092 size_t nr_apqns, len; 1093 1094 if (copy_from_user(&kat, uat, sizeof(kat))) 1095 return -EFAULT; 1096 nr_apqns = kat.apqn_entries; 1097 if (nr_apqns) { 1098 apqns = kmalloc_array(nr_apqns, 1099 sizeof(struct pkey_apqn), 1100 GFP_KERNEL); 1101 if (!apqns) 1102 return -ENOMEM; 1103 } 1104 rc = pkey_apqns4keytype(kat.type, kat.cur_mkvp, kat.alt_mkvp, 1105 kat.flags, apqns, &nr_apqns); 1106 DEBUG_DBG("%s pkey_apqns4keytype()=%d\n", __func__, rc); 1107 if (rc && rc != -ENOSPC) { 1108 kfree(apqns); 1109 break; 1110 } 1111 if (!rc && kat.apqns) { 1112 if (nr_apqns > kat.apqn_entries) { 1113 kfree(apqns); 1114 return -EINVAL; 1115 } 1116 len = nr_apqns * sizeof(struct pkey_apqn); 1117 if (len) { 1118 if (copy_to_user(kat.apqns, apqns, len)) { 1119 kfree(apqns); 1120 return -EFAULT; 1121 } 1122 } 1123 } 1124 kat.apqn_entries = nr_apqns; 1125 if (copy_to_user(uat, &kat, sizeof(kat))) 1126 rc = -EFAULT; 1127 kfree(apqns); 1128 break; 1129 } 1130 default: 1131 /* unknown/unsupported ioctl cmd */ 1132 return -ENOTTY; 1133 } 1134 1135 return rc; 1136 } 1137 1138 /* 1139 * Sysfs and file io operations 1140 */ 1141 1142 /* 1143 * Sysfs attribute read function for all protected key binary attributes. 1144 * The implementation can not deal with partial reads, because a new random 1145 * protected key blob is generated with each read. In case of partial reads 1146 * (i.e. off != 0 or count < key blob size) -EINVAL is returned. 1147 */ 1148 static ssize_t pkey_protkey_aes_attr_read(u32 keytype, bool is_xts, char *buf, 1149 loff_t off, size_t count) 1150 { 1151 struct protaeskeytoken protkeytoken; 1152 struct pkey_protkey protkey; 1153 int rc; 1154 1155 if (off != 0 || count < sizeof(protkeytoken)) 1156 return -EINVAL; 1157 if (is_xts) 1158 if (count < 2 * sizeof(protkeytoken)) 1159 return -EINVAL; 1160 1161 memset(&protkeytoken, 0, sizeof(protkeytoken)); 1162 protkeytoken.type = TOKTYPE_NON_CCA; 1163 protkeytoken.version = TOKVER_PROTECTED_KEY; 1164 protkeytoken.keytype = keytype; 1165 1166 rc = pkey_genprotkey(protkeytoken.keytype, &protkey); 1167 if (rc) 1168 return rc; 1169 1170 protkeytoken.len = protkey.len; 1171 memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len); 1172 1173 memcpy(buf, &protkeytoken, sizeof(protkeytoken)); 1174 1175 if (is_xts) { 1176 rc = pkey_genprotkey(protkeytoken.keytype, &protkey); 1177 if (rc) 1178 return rc; 1179 1180 protkeytoken.len = protkey.len; 1181 memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len); 1182 1183 memcpy(buf + sizeof(protkeytoken), &protkeytoken, 1184 sizeof(protkeytoken)); 1185 1186 return 2 * sizeof(protkeytoken); 1187 } 1188 1189 return sizeof(protkeytoken); 1190 } 1191 1192 static ssize_t protkey_aes_128_read(struct file *filp, 1193 struct kobject *kobj, 1194 struct bin_attribute *attr, 1195 char *buf, loff_t off, 1196 size_t count) 1197 { 1198 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf, 1199 off, count); 1200 } 1201 1202 static ssize_t protkey_aes_192_read(struct file *filp, 1203 struct kobject *kobj, 1204 struct bin_attribute *attr, 1205 char *buf, loff_t off, 1206 size_t count) 1207 { 1208 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf, 1209 off, count); 1210 } 1211 1212 static ssize_t protkey_aes_256_read(struct file *filp, 1213 struct kobject *kobj, 1214 struct bin_attribute *attr, 1215 char *buf, loff_t off, 1216 size_t count) 1217 { 1218 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf, 1219 off, count); 1220 } 1221 1222 static ssize_t protkey_aes_128_xts_read(struct file *filp, 1223 struct kobject *kobj, 1224 struct bin_attribute *attr, 1225 char *buf, loff_t off, 1226 size_t count) 1227 { 1228 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf, 1229 off, count); 1230 } 1231 1232 static ssize_t protkey_aes_256_xts_read(struct file *filp, 1233 struct kobject *kobj, 1234 struct bin_attribute *attr, 1235 char *buf, loff_t off, 1236 size_t count) 1237 { 1238 return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf, 1239 off, count); 1240 } 1241 1242 static BIN_ATTR_RO(protkey_aes_128, sizeof(struct protaeskeytoken)); 1243 static BIN_ATTR_RO(protkey_aes_192, sizeof(struct protaeskeytoken)); 1244 static BIN_ATTR_RO(protkey_aes_256, sizeof(struct protaeskeytoken)); 1245 static BIN_ATTR_RO(protkey_aes_128_xts, 2 * sizeof(struct protaeskeytoken)); 1246 static BIN_ATTR_RO(protkey_aes_256_xts, 2 * sizeof(struct protaeskeytoken)); 1247 1248 static struct bin_attribute *protkey_attrs[] = { 1249 &bin_attr_protkey_aes_128, 1250 &bin_attr_protkey_aes_192, 1251 &bin_attr_protkey_aes_256, 1252 &bin_attr_protkey_aes_128_xts, 1253 &bin_attr_protkey_aes_256_xts, 1254 NULL 1255 }; 1256 1257 static struct attribute_group protkey_attr_group = { 1258 .name = "protkey", 1259 .bin_attrs = protkey_attrs, 1260 }; 1261 1262 /* 1263 * Sysfs attribute read function for all secure key ccadata binary attributes. 1264 * The implementation can not deal with partial reads, because a new random 1265 * protected key blob is generated with each read. In case of partial reads 1266 * (i.e. off != 0 or count < key blob size) -EINVAL is returned. 1267 */ 1268 static ssize_t pkey_ccadata_aes_attr_read(u32 keytype, bool is_xts, char *buf, 1269 loff_t off, size_t count) 1270 { 1271 int rc; 1272 struct pkey_seckey *seckey = (struct pkey_seckey *) buf; 1273 1274 if (off != 0 || count < sizeof(struct secaeskeytoken)) 1275 return -EINVAL; 1276 if (is_xts) 1277 if (count < 2 * sizeof(struct secaeskeytoken)) 1278 return -EINVAL; 1279 1280 rc = cca_genseckey(-1, -1, keytype, seckey->seckey); 1281 if (rc) 1282 return rc; 1283 1284 if (is_xts) { 1285 seckey++; 1286 rc = cca_genseckey(-1, -1, keytype, seckey->seckey); 1287 if (rc) 1288 return rc; 1289 1290 return 2 * sizeof(struct secaeskeytoken); 1291 } 1292 1293 return sizeof(struct secaeskeytoken); 1294 } 1295 1296 static ssize_t ccadata_aes_128_read(struct file *filp, 1297 struct kobject *kobj, 1298 struct bin_attribute *attr, 1299 char *buf, loff_t off, 1300 size_t count) 1301 { 1302 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf, 1303 off, count); 1304 } 1305 1306 static ssize_t ccadata_aes_192_read(struct file *filp, 1307 struct kobject *kobj, 1308 struct bin_attribute *attr, 1309 char *buf, loff_t off, 1310 size_t count) 1311 { 1312 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf, 1313 off, count); 1314 } 1315 1316 static ssize_t ccadata_aes_256_read(struct file *filp, 1317 struct kobject *kobj, 1318 struct bin_attribute *attr, 1319 char *buf, loff_t off, 1320 size_t count) 1321 { 1322 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf, 1323 off, count); 1324 } 1325 1326 static ssize_t ccadata_aes_128_xts_read(struct file *filp, 1327 struct kobject *kobj, 1328 struct bin_attribute *attr, 1329 char *buf, loff_t off, 1330 size_t count) 1331 { 1332 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf, 1333 off, count); 1334 } 1335 1336 static ssize_t ccadata_aes_256_xts_read(struct file *filp, 1337 struct kobject *kobj, 1338 struct bin_attribute *attr, 1339 char *buf, loff_t off, 1340 size_t count) 1341 { 1342 return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf, 1343 off, count); 1344 } 1345 1346 static BIN_ATTR_RO(ccadata_aes_128, sizeof(struct secaeskeytoken)); 1347 static BIN_ATTR_RO(ccadata_aes_192, sizeof(struct secaeskeytoken)); 1348 static BIN_ATTR_RO(ccadata_aes_256, sizeof(struct secaeskeytoken)); 1349 static BIN_ATTR_RO(ccadata_aes_128_xts, 2 * sizeof(struct secaeskeytoken)); 1350 static BIN_ATTR_RO(ccadata_aes_256_xts, 2 * sizeof(struct secaeskeytoken)); 1351 1352 static struct bin_attribute *ccadata_attrs[] = { 1353 &bin_attr_ccadata_aes_128, 1354 &bin_attr_ccadata_aes_192, 1355 &bin_attr_ccadata_aes_256, 1356 &bin_attr_ccadata_aes_128_xts, 1357 &bin_attr_ccadata_aes_256_xts, 1358 NULL 1359 }; 1360 1361 static struct attribute_group ccadata_attr_group = { 1362 .name = "ccadata", 1363 .bin_attrs = ccadata_attrs, 1364 }; 1365 1366 #define CCACIPHERTOKENSIZE (sizeof(struct cipherkeytoken) + 80) 1367 1368 /* 1369 * Sysfs attribute read function for all secure key ccacipher binary attributes. 1370 * The implementation can not deal with partial reads, because a new random 1371 * secure key blob is generated with each read. In case of partial reads 1372 * (i.e. off != 0 or count < key blob size) -EINVAL is returned. 1373 */ 1374 static ssize_t pkey_ccacipher_aes_attr_read(enum pkey_key_size keybits, 1375 bool is_xts, char *buf, loff_t off, 1376 size_t count) 1377 { 1378 size_t keysize; 1379 int rc; 1380 1381 if (off != 0 || count < CCACIPHERTOKENSIZE) 1382 return -EINVAL; 1383 if (is_xts) 1384 if (count < 2 * CCACIPHERTOKENSIZE) 1385 return -EINVAL; 1386 1387 keysize = CCACIPHERTOKENSIZE; 1388 rc = cca_gencipherkey(-1, -1, keybits, 0, buf, &keysize); 1389 if (rc) 1390 return rc; 1391 memset(buf + keysize, 0, CCACIPHERTOKENSIZE - keysize); 1392 1393 if (is_xts) { 1394 keysize = CCACIPHERTOKENSIZE; 1395 rc = cca_gencipherkey(-1, -1, keybits, 0, 1396 buf + CCACIPHERTOKENSIZE, &keysize); 1397 if (rc) 1398 return rc; 1399 memset(buf + CCACIPHERTOKENSIZE + keysize, 0, 1400 CCACIPHERTOKENSIZE - keysize); 1401 1402 return 2 * CCACIPHERTOKENSIZE; 1403 } 1404 1405 return CCACIPHERTOKENSIZE; 1406 } 1407 1408 static ssize_t ccacipher_aes_128_read(struct file *filp, 1409 struct kobject *kobj, 1410 struct bin_attribute *attr, 1411 char *buf, loff_t off, 1412 size_t count) 1413 { 1414 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, false, buf, 1415 off, count); 1416 } 1417 1418 static ssize_t ccacipher_aes_192_read(struct file *filp, 1419 struct kobject *kobj, 1420 struct bin_attribute *attr, 1421 char *buf, loff_t off, 1422 size_t count) 1423 { 1424 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_192, false, buf, 1425 off, count); 1426 } 1427 1428 static ssize_t ccacipher_aes_256_read(struct file *filp, 1429 struct kobject *kobj, 1430 struct bin_attribute *attr, 1431 char *buf, loff_t off, 1432 size_t count) 1433 { 1434 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, false, buf, 1435 off, count); 1436 } 1437 1438 static ssize_t ccacipher_aes_128_xts_read(struct file *filp, 1439 struct kobject *kobj, 1440 struct bin_attribute *attr, 1441 char *buf, loff_t off, 1442 size_t count) 1443 { 1444 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, true, buf, 1445 off, count); 1446 } 1447 1448 static ssize_t ccacipher_aes_256_xts_read(struct file *filp, 1449 struct kobject *kobj, 1450 struct bin_attribute *attr, 1451 char *buf, loff_t off, 1452 size_t count) 1453 { 1454 return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, true, buf, 1455 off, count); 1456 } 1457 1458 static BIN_ATTR_RO(ccacipher_aes_128, CCACIPHERTOKENSIZE); 1459 static BIN_ATTR_RO(ccacipher_aes_192, CCACIPHERTOKENSIZE); 1460 static BIN_ATTR_RO(ccacipher_aes_256, CCACIPHERTOKENSIZE); 1461 static BIN_ATTR_RO(ccacipher_aes_128_xts, 2 * CCACIPHERTOKENSIZE); 1462 static BIN_ATTR_RO(ccacipher_aes_256_xts, 2 * CCACIPHERTOKENSIZE); 1463 1464 static struct bin_attribute *ccacipher_attrs[] = { 1465 &bin_attr_ccacipher_aes_128, 1466 &bin_attr_ccacipher_aes_192, 1467 &bin_attr_ccacipher_aes_256, 1468 &bin_attr_ccacipher_aes_128_xts, 1469 &bin_attr_ccacipher_aes_256_xts, 1470 NULL 1471 }; 1472 1473 static struct attribute_group ccacipher_attr_group = { 1474 .name = "ccacipher", 1475 .bin_attrs = ccacipher_attrs, 1476 }; 1477 1478 static const struct attribute_group *pkey_attr_groups[] = { 1479 &protkey_attr_group, 1480 &ccadata_attr_group, 1481 &ccacipher_attr_group, 1482 NULL, 1483 }; 1484 1485 static const struct file_operations pkey_fops = { 1486 .owner = THIS_MODULE, 1487 .open = nonseekable_open, 1488 .llseek = no_llseek, 1489 .unlocked_ioctl = pkey_unlocked_ioctl, 1490 }; 1491 1492 static struct miscdevice pkey_dev = { 1493 .name = "pkey", 1494 .minor = MISC_DYNAMIC_MINOR, 1495 .mode = 0666, 1496 .fops = &pkey_fops, 1497 .groups = pkey_attr_groups, 1498 }; 1499 1500 /* 1501 * Module init 1502 */ 1503 static int __init pkey_init(void) 1504 { 1505 cpacf_mask_t kmc_functions; 1506 1507 /* 1508 * The pckmo instruction should be available - even if we don't 1509 * actually invoke it. This instruction comes with MSA 3 which 1510 * is also the minimum level for the kmc instructions which 1511 * are able to work with protected keys. 1512 */ 1513 if (!cpacf_query(CPACF_PCKMO, &pckmo_functions)) 1514 return -ENODEV; 1515 1516 /* check for kmc instructions available */ 1517 if (!cpacf_query(CPACF_KMC, &kmc_functions)) 1518 return -ENODEV; 1519 if (!cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_128) || 1520 !cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_192) || 1521 !cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_256)) 1522 return -ENODEV; 1523 1524 pkey_debug_init(); 1525 1526 return misc_register(&pkey_dev); 1527 } 1528 1529 /* 1530 * Module exit 1531 */ 1532 static void __exit pkey_exit(void) 1533 { 1534 misc_deregister(&pkey_dev); 1535 pkey_debug_exit(); 1536 } 1537 1538 module_cpu_feature_match(MSA, pkey_init); 1539 module_exit(pkey_exit); 1540