drivers/s390/crypto/pkey

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pkey_debug_init
pkey_debug_exit
pkey_clr2protkey
pkey_skey2pkey
pkey_verifykey
pkey_genprotkey
pkey_verifyprotkey
pkey_nonccatok2pkey
pkey_ccainttok2pkey
pkey_keyblob2pkey
pkey_genseckey2
pkey_clr2seckey2
pkey_verifykey2
pkey_keyblob2pkey2
pkey_apqns4key
pkey_apqns4keytype
_copy_key_from_user
_copy_apqns_from_user
pkey_unlocked_ioctl
pkey_protkey_aes_attr_read
protkey_aes_128_read
protkey_aes_192_read
protkey_aes_256_read
protkey_aes_128_xts_read
protkey_aes_256_xts_read
pkey_ccadata_aes_attr_read
ccadata_aes_128_read
ccadata_aes_192_read
ccadata_aes_256_read
ccadata_aes_128_xts_read
ccadata_aes_256_xts_read
ccacipher_aes_128_read
ccacipher_aes_192_read
ccacipher_aes_256_read
ccacipher_aes_128_xts_read
ccacipher_aes_256_xts_read
pkey_init
pkey_exit
   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                         kfree(kapqns);
 745                         return ERR_PTR(-EFAULT);
 746                 }
 747         }
 748 
 749         return kapqns;
 750 }
 751 
 752 static long pkey_unlocked_ioctl(struct file *filp, unsigned int cmd,
 753                                 unsigned long arg)
 754 {
 755         int rc;
 756 
 757         switch (cmd) {
 758         case PKEY_GENSECK: {
 759                 struct pkey_genseck __user *ugs = (void __user *) arg;
 760                 struct pkey_genseck kgs;
 761 
 762                 if (copy_from_user(&kgs, ugs, sizeof(kgs)))
 763                         return -EFAULT;
 764                 rc = cca_genseckey(kgs.cardnr, kgs.domain,
 765                                    kgs.keytype, kgs.seckey.seckey);
 766                 DEBUG_DBG("%s cca_genseckey()=%d\n", __func__, rc);
 767                 if (rc)
 768                         break;
 769                 if (copy_to_user(ugs, &kgs, sizeof(kgs)))
 770                         return -EFAULT;
 771                 break;
 772         }
 773         case PKEY_CLR2SECK: {
 774                 struct pkey_clr2seck __user *ucs = (void __user *) arg;
 775                 struct pkey_clr2seck kcs;
 776 
 777                 if (copy_from_user(&kcs, ucs, sizeof(kcs)))
 778                         return -EFAULT;
 779                 rc = cca_clr2seckey(kcs.cardnr, kcs.domain, kcs.keytype,
 780                                     kcs.clrkey.clrkey, kcs.seckey.seckey);
 781                 DEBUG_DBG("%s cca_clr2seckey()=%d\n", __func__, rc);
 782                 if (rc)
 783                         break;
 784                 if (copy_to_user(ucs, &kcs, sizeof(kcs)))
 785                         return -EFAULT;
 786                 memzero_explicit(&kcs, sizeof(kcs));
 787                 break;
 788         }
 789         case PKEY_SEC2PROTK: {
 790                 struct pkey_sec2protk __user *usp = (void __user *) arg;
 791                 struct pkey_sec2protk ksp;
 792 
 793                 if (copy_from_user(&ksp, usp, sizeof(ksp)))
 794                         return -EFAULT;
 795                 rc = cca_sec2protkey(ksp.cardnr, ksp.domain,
 796                                      ksp.seckey.seckey, ksp.protkey.protkey,
 797                                      &ksp.protkey.len, &ksp.protkey.type);
 798                 DEBUG_DBG("%s cca_sec2protkey()=%d\n", __func__, rc);
 799                 if (rc)
 800                         break;
 801                 if (copy_to_user(usp, &ksp, sizeof(ksp)))
 802                         return -EFAULT;
 803                 break;
 804         }
 805         case PKEY_CLR2PROTK: {
 806                 struct pkey_clr2protk __user *ucp = (void __user *) arg;
 807                 struct pkey_clr2protk kcp;
 808 
 809                 if (copy_from_user(&kcp, ucp, sizeof(kcp)))
 810                         return -EFAULT;
 811                 rc = pkey_clr2protkey(kcp.keytype,
 812                                       &kcp.clrkey, &kcp.protkey);
 813                 DEBUG_DBG("%s pkey_clr2protkey()=%d\n", __func__, rc);
 814                 if (rc)
 815                         break;
 816                 if (copy_to_user(ucp, &kcp, sizeof(kcp)))
 817                         return -EFAULT;
 818                 memzero_explicit(&kcp, sizeof(kcp));
 819                 break;
 820         }
 821         case PKEY_FINDCARD: {
 822                 struct pkey_findcard __user *ufc = (void __user *) arg;
 823                 struct pkey_findcard kfc;
 824 
 825                 if (copy_from_user(&kfc, ufc, sizeof(kfc)))
 826                         return -EFAULT;
 827                 rc = cca_findcard(kfc.seckey.seckey,
 828                                   &kfc.cardnr, &kfc.domain, 1);
 829                 DEBUG_DBG("%s cca_findcard()=%d\n", __func__, rc);
 830                 if (rc < 0)
 831                         break;
 832                 if (copy_to_user(ufc, &kfc, sizeof(kfc)))
 833                         return -EFAULT;
 834                 break;
 835         }
 836         case PKEY_SKEY2PKEY: {
 837                 struct pkey_skey2pkey __user *usp = (void __user *) arg;
 838                 struct pkey_skey2pkey ksp;
 839 
 840                 if (copy_from_user(&ksp, usp, sizeof(ksp)))
 841                         return -EFAULT;
 842                 rc = pkey_skey2pkey(ksp.seckey.seckey, &ksp.protkey);
 843                 DEBUG_DBG("%s pkey_skey2pkey()=%d\n", __func__, rc);
 844                 if (rc)
 845                         break;
 846                 if (copy_to_user(usp, &ksp, sizeof(ksp)))
 847                         return -EFAULT;
 848                 break;
 849         }
 850         case PKEY_VERIFYKEY: {
 851                 struct pkey_verifykey __user *uvk = (void __user *) arg;
 852                 struct pkey_verifykey kvk;
 853 
 854                 if (copy_from_user(&kvk, uvk, sizeof(kvk)))
 855                         return -EFAULT;
 856                 rc = pkey_verifykey(&kvk.seckey, &kvk.cardnr, &kvk.domain,
 857                                     &kvk.keysize, &kvk.attributes);
 858                 DEBUG_DBG("%s pkey_verifykey()=%d\n", __func__, rc);
 859                 if (rc)
 860                         break;
 861                 if (copy_to_user(uvk, &kvk, sizeof(kvk)))
 862                         return -EFAULT;
 863                 break;
 864         }
 865         case PKEY_GENPROTK: {
 866                 struct pkey_genprotk __user *ugp = (void __user *) arg;
 867                 struct pkey_genprotk kgp;
 868 
 869                 if (copy_from_user(&kgp, ugp, sizeof(kgp)))
 870                         return -EFAULT;
 871                 rc = pkey_genprotkey(kgp.keytype, &kgp.protkey);
 872                 DEBUG_DBG("%s pkey_genprotkey()=%d\n", __func__, rc);
 873                 if (rc)
 874                         break;
 875                 if (copy_to_user(ugp, &kgp, sizeof(kgp)))
 876                         return -EFAULT;
 877                 break;
 878         }
 879         case PKEY_VERIFYPROTK: {
 880                 struct pkey_verifyprotk __user *uvp = (void __user *) arg;
 881                 struct pkey_verifyprotk kvp;
 882 
 883                 if (copy_from_user(&kvp, uvp, sizeof(kvp)))
 884                         return -EFAULT;
 885                 rc = pkey_verifyprotkey(&kvp.protkey);
 886                 DEBUG_DBG("%s pkey_verifyprotkey()=%d\n", __func__, rc);
 887                 break;
 888         }
 889         case PKEY_KBLOB2PROTK: {
 890                 struct pkey_kblob2pkey __user *utp = (void __user *) arg;
 891                 struct pkey_kblob2pkey ktp;
 892                 u8 *kkey;
 893 
 894                 if (copy_from_user(&ktp, utp, sizeof(ktp)))
 895                         return -EFAULT;
 896                 kkey = _copy_key_from_user(ktp.key, ktp.keylen);
 897                 if (IS_ERR(kkey))
 898                         return PTR_ERR(kkey);
 899                 rc = pkey_keyblob2pkey(kkey, ktp.keylen, &ktp.protkey);
 900                 DEBUG_DBG("%s pkey_keyblob2pkey()=%d\n", __func__, rc);
 901                 kfree(kkey);
 902                 if (rc)
 903                         break;
 904                 if (copy_to_user(utp, &ktp, sizeof(ktp)))
 905                         return -EFAULT;
 906                 break;
 907         }
 908         case PKEY_GENSECK2: {
 909                 struct pkey_genseck2 __user *ugs = (void __user *) arg;
 910                 struct pkey_genseck2 kgs;
 911                 struct pkey_apqn *apqns;
 912                 size_t klen = KEYBLOBBUFSIZE;
 913                 u8 *kkey;
 914 
 915                 if (copy_from_user(&kgs, ugs, sizeof(kgs)))
 916                         return -EFAULT;
 917                 apqns = _copy_apqns_from_user(kgs.apqns, kgs.apqn_entries);
 918                 if (IS_ERR(apqns))
 919                         return PTR_ERR(apqns);
 920                 kkey = kmalloc(klen, GFP_KERNEL);
 921                 if (!kkey) {
 922                         kfree(apqns);
 923                         return -ENOMEM;
 924                 }
 925                 rc = pkey_genseckey2(apqns, kgs.apqn_entries,
 926                                      kgs.type, kgs.size, kgs.keygenflags,
 927                                      kkey, &klen);
 928                 DEBUG_DBG("%s pkey_genseckey2()=%d\n", __func__, rc);
 929                 kfree(apqns);
 930                 if (rc) {
 931                         kfree(kkey);
 932                         break;
 933                 }
 934                 if (kgs.key) {
 935                         if (kgs.keylen < klen) {
 936                                 kfree(kkey);
 937                                 return -EINVAL;
 938                         }
 939                         if (copy_to_user(kgs.key, kkey, klen)) {
 940                                 kfree(kkey);
 941                                 return -EFAULT;
 942                         }
 943                 }
 944                 kgs.keylen = klen;
 945                 if (copy_to_user(ugs, &kgs, sizeof(kgs)))
 946                         rc = -EFAULT;
 947                 kfree(kkey);
 948                 break;
 949         }
 950         case PKEY_CLR2SECK2: {
 951                 struct pkey_clr2seck2 __user *ucs = (void __user *) arg;
 952                 struct pkey_clr2seck2 kcs;
 953                 struct pkey_apqn *apqns;
 954                 size_t klen = KEYBLOBBUFSIZE;
 955                 u8 *kkey;
 956 
 957                 if (copy_from_user(&kcs, ucs, sizeof(kcs)))
 958                         return -EFAULT;
 959                 apqns = _copy_apqns_from_user(kcs.apqns, kcs.apqn_entries);
 960                 if (IS_ERR(apqns))
 961                         return PTR_ERR(apqns);
 962                 kkey = kmalloc(klen, GFP_KERNEL);
 963                 if (!kkey) {
 964                         kfree(apqns);
 965                         return -ENOMEM;
 966                 }
 967                 rc = pkey_clr2seckey2(apqns, kcs.apqn_entries,
 968                                       kcs.type, kcs.size, kcs.keygenflags,
 969                                       kcs.clrkey.clrkey, kkey, &klen);
 970                 DEBUG_DBG("%s pkey_clr2seckey2()=%d\n", __func__, rc);
 971                 kfree(apqns);
 972                 if (rc) {
 973                         kfree(kkey);
 974                         break;
 975                 }
 976                 if (kcs.key) {
 977                         if (kcs.keylen < klen) {
 978                                 kfree(kkey);
 979                                 return -EINVAL;
 980                         }
 981                         if (copy_to_user(kcs.key, kkey, klen)) {
 982                                 kfree(kkey);
 983                                 return -EFAULT;
 984                         }
 985                 }
 986                 kcs.keylen = klen;
 987                 if (copy_to_user(ucs, &kcs, sizeof(kcs)))
 988                         rc = -EFAULT;
 989                 memzero_explicit(&kcs, sizeof(kcs));
 990                 kfree(kkey);
 991                 break;
 992         }
 993         case PKEY_VERIFYKEY2: {
 994                 struct pkey_verifykey2 __user *uvk = (void __user *) arg;
 995                 struct pkey_verifykey2 kvk;
 996                 u8 *kkey;
 997 
 998                 if (copy_from_user(&kvk, uvk, sizeof(kvk)))
 999                         return -EFAULT;
1000                 kkey = _copy_key_from_user(kvk.key, kvk.keylen);
1001                 if (IS_ERR(kkey))
1002                         return PTR_ERR(kkey);
1003                 rc = pkey_verifykey2(kkey, kvk.keylen,
1004                                      &kvk.cardnr, &kvk.domain,
1005                                      &kvk.type, &kvk.size, &kvk.flags);
1006                 DEBUG_DBG("%s pkey_verifykey2()=%d\n", __func__, rc);
1007                 kfree(kkey);
1008                 if (rc)
1009                         break;
1010                 if (copy_to_user(uvk, &kvk, sizeof(kvk)))
1011                         return -EFAULT;
1012                 break;
1013         }
1014         case PKEY_KBLOB2PROTK2: {
1015                 struct pkey_kblob2pkey2 __user *utp = (void __user *) arg;
1016                 struct pkey_kblob2pkey2 ktp;
1017                 struct pkey_apqn *apqns = NULL;
1018                 u8 *kkey;
1019 
1020                 if (copy_from_user(&ktp, utp, sizeof(ktp)))
1021                         return -EFAULT;
1022                 apqns = _copy_apqns_from_user(ktp.apqns, ktp.apqn_entries);
1023                 if (IS_ERR(apqns))
1024                         return PTR_ERR(apqns);
1025                 kkey = _copy_key_from_user(ktp.key, ktp.keylen);
1026                 if (IS_ERR(kkey)) {
1027                         kfree(apqns);
1028                         return PTR_ERR(kkey);
1029                 }
1030                 rc = pkey_keyblob2pkey2(apqns, ktp.apqn_entries,
1031                                         kkey, ktp.keylen, &ktp.protkey);
1032                 DEBUG_DBG("%s pkey_keyblob2pkey2()=%d\n", __func__, rc);
1033                 kfree(apqns);
1034                 kfree(kkey);
1035                 if (rc)
1036                         break;
1037                 if (copy_to_user(utp, &ktp, sizeof(ktp)))
1038                         return -EFAULT;
1039                 break;
1040         }
1041         case PKEY_APQNS4K: {
1042                 struct pkey_apqns4key __user *uak = (void __user *) arg;
1043                 struct pkey_apqns4key kak;
1044                 struct pkey_apqn *apqns = NULL;
1045                 size_t nr_apqns, len;
1046                 u8 *kkey;
1047 
1048                 if (copy_from_user(&kak, uak, sizeof(kak)))
1049                         return -EFAULT;
1050                 nr_apqns = kak.apqn_entries;
1051                 if (nr_apqns) {
1052                         apqns = kmalloc_array(nr_apqns,
1053                                               sizeof(struct pkey_apqn),
1054                                               GFP_KERNEL);
1055                         if (!apqns)
1056                                 return -ENOMEM;
1057                 }
1058                 kkey = _copy_key_from_user(kak.key, kak.keylen);
1059                 if (IS_ERR(kkey)) {
1060                         kfree(apqns);
1061                         return PTR_ERR(kkey);
1062                 }
1063                 rc = pkey_apqns4key(kkey, kak.keylen, kak.flags,
1064                                     apqns, &nr_apqns);
1065                 DEBUG_DBG("%s pkey_apqns4key()=%d\n", __func__, rc);
1066                 kfree(kkey);
1067                 if (rc && rc != -ENOSPC) {
1068                         kfree(apqns);
1069                         break;
1070                 }
1071                 if (!rc && kak.apqns) {
1072                         if (nr_apqns > kak.apqn_entries) {
1073                                 kfree(apqns);
1074                                 return -EINVAL;
1075                         }
1076                         len = nr_apqns * sizeof(struct pkey_apqn);
1077                         if (len) {
1078                                 if (copy_to_user(kak.apqns, apqns, len)) {
1079                                         kfree(apqns);
1080                                         return -EFAULT;
1081                                 }
1082                         }
1083                 }
1084                 kak.apqn_entries = nr_apqns;
1085                 if (copy_to_user(uak, &kak, sizeof(kak)))
1086                         rc = -EFAULT;
1087                 kfree(apqns);
1088                 break;
1089         }
1090         case PKEY_APQNS4KT: {
1091                 struct pkey_apqns4keytype __user *uat = (void __user *) arg;
1092                 struct pkey_apqns4keytype kat;
1093                 struct pkey_apqn *apqns = NULL;
1094                 size_t nr_apqns, len;
1095 
1096                 if (copy_from_user(&kat, uat, sizeof(kat)))
1097                         return -EFAULT;
1098                 nr_apqns = kat.apqn_entries;
1099                 if (nr_apqns) {
1100                         apqns = kmalloc_array(nr_apqns,
1101                                               sizeof(struct pkey_apqn),
1102                                               GFP_KERNEL);
1103                         if (!apqns)
1104                                 return -ENOMEM;
1105                 }
1106                 rc = pkey_apqns4keytype(kat.type, kat.cur_mkvp, kat.alt_mkvp,
1107                                         kat.flags, apqns, &nr_apqns);
1108                 DEBUG_DBG("%s pkey_apqns4keytype()=%d\n", __func__, rc);
1109                 if (rc && rc != -ENOSPC) {
1110                         kfree(apqns);
1111                         break;
1112                 }
1113                 if (!rc && kat.apqns) {
1114                         if (nr_apqns > kat.apqn_entries) {
1115                                 kfree(apqns);
1116                                 return -EINVAL;
1117                         }
1118                         len = nr_apqns * sizeof(struct pkey_apqn);
1119                         if (len) {
1120                                 if (copy_to_user(kat.apqns, apqns, len)) {
1121                                         kfree(apqns);
1122                                         return -EFAULT;
1123                                 }
1124                         }
1125                 }
1126                 kat.apqn_entries = nr_apqns;
1127                 if (copy_to_user(uat, &kat, sizeof(kat)))
1128                         rc = -EFAULT;
1129                 kfree(apqns);
1130                 break;
1131         }
1132         default:
1133                 /* unknown/unsupported ioctl cmd */
1134                 return -ENOTTY;
1135         }
1136 
1137         return rc;
1138 }
1139 
1140 /*
1141  * Sysfs and file io operations
1142  */
1143 
1144 /*
1145  * Sysfs attribute read function for all protected key binary attributes.
1146  * The implementation can not deal with partial reads, because a new random
1147  * protected key blob is generated with each read. In case of partial reads
1148  * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
1149  */
1150 static ssize_t pkey_protkey_aes_attr_read(u32 keytype, bool is_xts, char *buf,
1151                                           loff_t off, size_t count)
1152 {
1153         struct protaeskeytoken protkeytoken;
1154         struct pkey_protkey protkey;
1155         int rc;
1156 
1157         if (off != 0 || count < sizeof(protkeytoken))
1158                 return -EINVAL;
1159         if (is_xts)
1160                 if (count < 2 * sizeof(protkeytoken))
1161                         return -EINVAL;
1162 
1163         memset(&protkeytoken, 0, sizeof(protkeytoken));
1164         protkeytoken.type = TOKTYPE_NON_CCA;
1165         protkeytoken.version = TOKVER_PROTECTED_KEY;
1166         protkeytoken.keytype = keytype;
1167 
1168         rc = pkey_genprotkey(protkeytoken.keytype, &protkey);
1169         if (rc)
1170                 return rc;
1171 
1172         protkeytoken.len = protkey.len;
1173         memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len);
1174 
1175         memcpy(buf, &protkeytoken, sizeof(protkeytoken));
1176 
1177         if (is_xts) {
1178                 rc = pkey_genprotkey(protkeytoken.keytype, &protkey);
1179                 if (rc)
1180                         return rc;
1181 
1182                 protkeytoken.len = protkey.len;
1183                 memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len);
1184 
1185                 memcpy(buf + sizeof(protkeytoken), &protkeytoken,
1186                        sizeof(protkeytoken));
1187 
1188                 return 2 * sizeof(protkeytoken);
1189         }
1190 
1191         return sizeof(protkeytoken);
1192 }
1193 
1194 static ssize_t protkey_aes_128_read(struct file *filp,
1195                                     struct kobject *kobj,
1196                                     struct bin_attribute *attr,
1197                                     char *buf, loff_t off,
1198                                     size_t count)
1199 {
1200         return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf,
1201                                           off, count);
1202 }
1203 
1204 static ssize_t protkey_aes_192_read(struct file *filp,
1205                                     struct kobject *kobj,
1206                                     struct bin_attribute *attr,
1207                                     char *buf, loff_t off,
1208                                     size_t count)
1209 {
1210         return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf,
1211                                           off, count);
1212 }
1213 
1214 static ssize_t protkey_aes_256_read(struct file *filp,
1215                                     struct kobject *kobj,
1216                                     struct bin_attribute *attr,
1217                                     char *buf, loff_t off,
1218                                     size_t count)
1219 {
1220         return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf,
1221                                           off, count);
1222 }
1223 
1224 static ssize_t protkey_aes_128_xts_read(struct file *filp,
1225                                         struct kobject *kobj,
1226                                         struct bin_attribute *attr,
1227                                         char *buf, loff_t off,
1228                                         size_t count)
1229 {
1230         return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf,
1231                                           off, count);
1232 }
1233 
1234 static ssize_t protkey_aes_256_xts_read(struct file *filp,
1235                                         struct kobject *kobj,
1236                                         struct bin_attribute *attr,
1237                                         char *buf, loff_t off,
1238                                         size_t count)
1239 {
1240         return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf,
1241                                           off, count);
1242 }
1243 
1244 static BIN_ATTR_RO(protkey_aes_128, sizeof(struct protaeskeytoken));
1245 static BIN_ATTR_RO(protkey_aes_192, sizeof(struct protaeskeytoken));
1246 static BIN_ATTR_RO(protkey_aes_256, sizeof(struct protaeskeytoken));
1247 static BIN_ATTR_RO(protkey_aes_128_xts, 2 * sizeof(struct protaeskeytoken));
1248 static BIN_ATTR_RO(protkey_aes_256_xts, 2 * sizeof(struct protaeskeytoken));
1249 
1250 static struct bin_attribute *protkey_attrs[] = {
1251         &bin_attr_protkey_aes_128,
1252         &bin_attr_protkey_aes_192,
1253         &bin_attr_protkey_aes_256,
1254         &bin_attr_protkey_aes_128_xts,
1255         &bin_attr_protkey_aes_256_xts,
1256         NULL
1257 };
1258 
1259 static struct attribute_group protkey_attr_group = {
1260         .name      = "protkey",
1261         .bin_attrs = protkey_attrs,
1262 };
1263 
1264 /*
1265  * Sysfs attribute read function for all secure key ccadata binary attributes.
1266  * The implementation can not deal with partial reads, because a new random
1267  * protected key blob is generated with each read. In case of partial reads
1268  * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
1269  */
1270 static ssize_t pkey_ccadata_aes_attr_read(u32 keytype, bool is_xts, char *buf,
1271                                           loff_t off, size_t count)
1272 {
1273         int rc;
1274         struct pkey_seckey *seckey = (struct pkey_seckey *) buf;
1275 
1276         if (off != 0 || count < sizeof(struct secaeskeytoken))
1277                 return -EINVAL;
1278         if (is_xts)
1279                 if (count < 2 * sizeof(struct secaeskeytoken))
1280                         return -EINVAL;
1281 
1282         rc = cca_genseckey(-1, -1, keytype, seckey->seckey);
1283         if (rc)
1284                 return rc;
1285 
1286         if (is_xts) {
1287                 seckey++;
1288                 rc = cca_genseckey(-1, -1, keytype, seckey->seckey);
1289                 if (rc)
1290                         return rc;
1291 
1292                 return 2 * sizeof(struct secaeskeytoken);
1293         }
1294 
1295         return sizeof(struct secaeskeytoken);
1296 }
1297 
1298 static ssize_t ccadata_aes_128_read(struct file *filp,
1299                                     struct kobject *kobj,
1300                                     struct bin_attribute *attr,
1301                                     char *buf, loff_t off,
1302                                     size_t count)
1303 {
1304         return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf,
1305                                           off, count);
1306 }
1307 
1308 static ssize_t ccadata_aes_192_read(struct file *filp,
1309                                     struct kobject *kobj,
1310                                     struct bin_attribute *attr,
1311                                     char *buf, loff_t off,
1312                                     size_t count)
1313 {
1314         return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf,
1315                                           off, count);
1316 }
1317 
1318 static ssize_t ccadata_aes_256_read(struct file *filp,
1319                                     struct kobject *kobj,
1320                                     struct bin_attribute *attr,
1321                                     char *buf, loff_t off,
1322                                     size_t count)
1323 {
1324         return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf,
1325                                           off, count);
1326 }
1327 
1328 static ssize_t ccadata_aes_128_xts_read(struct file *filp,
1329                                         struct kobject *kobj,
1330                                         struct bin_attribute *attr,
1331                                         char *buf, loff_t off,
1332                                         size_t count)
1333 {
1334         return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf,
1335                                           off, count);
1336 }
1337 
1338 static ssize_t ccadata_aes_256_xts_read(struct file *filp,
1339                                         struct kobject *kobj,
1340                                         struct bin_attribute *attr,
1341                                         char *buf, loff_t off,
1342                                         size_t count)
1343 {
1344         return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf,
1345                                           off, count);
1346 }
1347 
1348 static BIN_ATTR_RO(ccadata_aes_128, sizeof(struct secaeskeytoken));
1349 static BIN_ATTR_RO(ccadata_aes_192, sizeof(struct secaeskeytoken));
1350 static BIN_ATTR_RO(ccadata_aes_256, sizeof(struct secaeskeytoken));
1351 static BIN_ATTR_RO(ccadata_aes_128_xts, 2 * sizeof(struct secaeskeytoken));
1352 static BIN_ATTR_RO(ccadata_aes_256_xts, 2 * sizeof(struct secaeskeytoken));
1353 
1354 static struct bin_attribute *ccadata_attrs[] = {
1355         &bin_attr_ccadata_aes_128,
1356         &bin_attr_ccadata_aes_192,
1357         &bin_attr_ccadata_aes_256,
1358         &bin_attr_ccadata_aes_128_xts,
1359         &bin_attr_ccadata_aes_256_xts,
1360         NULL
1361 };
1362 
1363 static struct attribute_group ccadata_attr_group = {
1364         .name      = "ccadata",
1365         .bin_attrs = ccadata_attrs,
1366 };
1367 
1368 #define CCACIPHERTOKENSIZE      (sizeof(struct cipherkeytoken) + 80)
1369 
1370 /*
1371  * Sysfs attribute read function for all secure key ccacipher binary attributes.
1372  * The implementation can not deal with partial reads, because a new random
1373  * secure key blob is generated with each read. In case of partial reads
1374  * (i.e. off != 0 or count < key blob size) -EINVAL is returned.
1375  */
1376 static ssize_t pkey_ccacipher_aes_attr_read(enum pkey_key_size keybits,
1377                                             bool is_xts, char *buf, loff_t off,
1378                                             size_t count)
1379 {
1380         size_t keysize;
1381         int rc;
1382 
1383         if (off != 0 || count < CCACIPHERTOKENSIZE)
1384                 return -EINVAL;
1385         if (is_xts)
1386                 if (count < 2 * CCACIPHERTOKENSIZE)
1387                         return -EINVAL;
1388 
1389         keysize = CCACIPHERTOKENSIZE;
1390         rc = cca_gencipherkey(-1, -1, keybits, 0, buf, &keysize);
1391         if (rc)
1392                 return rc;
1393         memset(buf + keysize, 0, CCACIPHERTOKENSIZE - keysize);
1394 
1395         if (is_xts) {
1396                 keysize = CCACIPHERTOKENSIZE;
1397                 rc = cca_gencipherkey(-1, -1, keybits, 0,
1398                                       buf + CCACIPHERTOKENSIZE, &keysize);
1399                 if (rc)
1400                         return rc;
1401                 memset(buf + CCACIPHERTOKENSIZE + keysize, 0,
1402                        CCACIPHERTOKENSIZE - keysize);
1403 
1404                 return 2 * CCACIPHERTOKENSIZE;
1405         }
1406 
1407         return CCACIPHERTOKENSIZE;
1408 }
1409 
1410 static ssize_t ccacipher_aes_128_read(struct file *filp,
1411                                       struct kobject *kobj,
1412                                       struct bin_attribute *attr,
1413                                       char *buf, loff_t off,
1414                                       size_t count)
1415 {
1416         return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, false, buf,
1417                                             off, count);
1418 }
1419 
1420 static ssize_t ccacipher_aes_192_read(struct file *filp,
1421                                       struct kobject *kobj,
1422                                       struct bin_attribute *attr,
1423                                       char *buf, loff_t off,
1424                                       size_t count)
1425 {
1426         return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_192, false, buf,
1427                                             off, count);
1428 }
1429 
1430 static ssize_t ccacipher_aes_256_read(struct file *filp,
1431                                       struct kobject *kobj,
1432                                       struct bin_attribute *attr,
1433                                       char *buf, loff_t off,
1434                                       size_t count)
1435 {
1436         return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, false, buf,
1437                                             off, count);
1438 }
1439 
1440 static ssize_t ccacipher_aes_128_xts_read(struct file *filp,
1441                                           struct kobject *kobj,
1442                                           struct bin_attribute *attr,
1443                                           char *buf, loff_t off,
1444                                           size_t count)
1445 {
1446         return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, true, buf,
1447                                             off, count);
1448 }
1449 
1450 static ssize_t ccacipher_aes_256_xts_read(struct file *filp,
1451                                           struct kobject *kobj,
1452                                           struct bin_attribute *attr,
1453                                           char *buf, loff_t off,
1454                                           size_t count)
1455 {
1456         return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, true, buf,
1457                                             off, count);
1458 }
1459 
1460 static BIN_ATTR_RO(ccacipher_aes_128, CCACIPHERTOKENSIZE);
1461 static BIN_ATTR_RO(ccacipher_aes_192, CCACIPHERTOKENSIZE);
1462 static BIN_ATTR_RO(ccacipher_aes_256, CCACIPHERTOKENSIZE);
1463 static BIN_ATTR_RO(ccacipher_aes_128_xts, 2 * CCACIPHERTOKENSIZE);
1464 static BIN_ATTR_RO(ccacipher_aes_256_xts, 2 * CCACIPHERTOKENSIZE);
1465 
1466 static struct bin_attribute *ccacipher_attrs[] = {
1467         &bin_attr_ccacipher_aes_128,
1468         &bin_attr_ccacipher_aes_192,
1469         &bin_attr_ccacipher_aes_256,
1470         &bin_attr_ccacipher_aes_128_xts,
1471         &bin_attr_ccacipher_aes_256_xts,
1472         NULL
1473 };
1474 
1475 static struct attribute_group ccacipher_attr_group = {
1476         .name      = "ccacipher",
1477         .bin_attrs = ccacipher_attrs,
1478 };
1479 
1480 static const struct attribute_group *pkey_attr_groups[] = {
1481         &protkey_attr_group,
1482         &ccadata_attr_group,
1483         &ccacipher_attr_group,
1484         NULL,
1485 };
1486 
1487 static const struct file_operations pkey_fops = {
1488         .owner          = THIS_MODULE,
1489         .open           = nonseekable_open,
1490         .llseek         = no_llseek,
1491         .unlocked_ioctl = pkey_unlocked_ioctl,
1492 };
1493 
1494 static struct miscdevice pkey_dev = {
1495         .name   = "pkey",
1496         .minor  = MISC_DYNAMIC_MINOR,
1497         .mode   = 0666,
1498         .fops   = &pkey_fops,
1499         .groups = pkey_attr_groups,
1500 };
1501 
1502 /*
1503  * Module init
1504  */
1505 static int __init pkey_init(void)
1506 {
1507         cpacf_mask_t kmc_functions;
1508 
1509         /*
1510          * The pckmo instruction should be available - even if we don't
1511          * actually invoke it. This instruction comes with MSA 3 which
1512          * is also the minimum level for the kmc instructions which
1513          * are able to work with protected keys.
1514          */
1515         if (!cpacf_query(CPACF_PCKMO, &pckmo_functions))
1516                 return -ENODEV;
1517 
1518         /* check for kmc instructions available */
1519         if (!cpacf_query(CPACF_KMC, &kmc_functions))
1520                 return -ENODEV;
1521         if (!cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_128) ||
1522             !cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_192) ||
1523             !cpacf_test_func(&kmc_functions, CPACF_KMC_PAES_256))
1524                 return -ENODEV;
1525 
1526         pkey_debug_init();
1527 
1528         return misc_register(&pkey_dev);
1529 }
1530 
1531 /*
1532  * Module exit
1533  */
1534 static void __exit pkey_exit(void)
1535 {
1536         misc_deregister(&pkey_dev);
1537         pkey_debug_exit();
1538 }
1539 
1540 module_cpu_feature_match(MSA, pkey_init);
1541 module_exit(pkey_exit);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/s390/crypto/pkey_api.c

DEFINITIONS
