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
  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, &param, 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);