drivers/s390/crypto/pkey_api.c

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