drivers/s390/crypto/zcrypt_ep11misc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Copyright IBM Corp. 2019
   4  *  Author(s): Harald Freudenberger <freude@linux.ibm.com>
   5  *
   6  *  Collection of EP11 misc functions used by zcrypt and pkey
   7  */
   8
   9 #define KMSG_COMPONENT "zcrypt"
  10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/random.h>
  16 #include <asm/zcrypt.h>
  17 #include <asm/pkey.h>
  18 #include <crypto/aes.h>
  19
  20 #include "ap_bus.h"
  21 #include "zcrypt_api.h"
  22 #include "zcrypt_debug.h"
  23 #include "zcrypt_msgtype6.h"
  24 #include "zcrypt_ep11misc.h"
  25 #include "zcrypt_ccamisc.h"
  26
  27 #define DEBUG_DBG(...)  ZCRYPT_DBF(DBF_DEBUG, ##__VA_ARGS__)
  28 #define DEBUG_INFO(...) ZCRYPT_DBF(DBF_INFO, ##__VA_ARGS__)
  29 #define DEBUG_WARN(...) ZCRYPT_DBF(DBF_WARN, ##__VA_ARGS__)
  30 #define DEBUG_ERR(...)  ZCRYPT_DBF(DBF_ERR, ##__VA_ARGS__)
  31
  32 #define EP11_PINBLOB_V1_BYTES 56
  33
  34 /* default iv used here */
  35 static const u8 def_iv[16] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
  36                                0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
  37
  38 /* ep11 card info cache */
  39 struct card_list_entry {
  40         struct list_head list;
  41         u16 cardnr;
  42         struct ep11_card_info info;
  43 };
  44 static LIST_HEAD(card_list);
  45 static DEFINE_SPINLOCK(card_list_lock);
  46
  47 static int card_cache_fetch(u16 cardnr, struct ep11_card_info *ci)
  48 {
  49         int rc = -ENOENT;
  50         struct card_list_entry *ptr;
  51
  52         spin_lock_bh(&card_list_lock);
  53         list_for_each_entry(ptr, &card_list, list) {
  54                 if (ptr->cardnr == cardnr) {
  55                         memcpy(ci, &ptr->info, sizeof(*ci));
  56                         rc = 0;
  57                         break;
  58                 }
  59         }
  60         spin_unlock_bh(&card_list_lock);
  61
  62         return rc;
  63 }
  64
  65 static void card_cache_update(u16 cardnr, const struct ep11_card_info *ci)
  66 {
  67         int found = 0;
  68         struct card_list_entry *ptr;
  69
  70         spin_lock_bh(&card_list_lock);
  71         list_for_each_entry(ptr, &card_list, list) {
  72                 if (ptr->cardnr == cardnr) {
  73                         memcpy(&ptr->info, ci, sizeof(*ci));
  74                         found = 1;
  75                         break;
  76                 }
  77         }
  78         if (!found) {
  79                 ptr = kmalloc(sizeof(*ptr), GFP_ATOMIC);
  80                 if (!ptr) {
  81                         spin_unlock_bh(&card_list_lock);
  82                         return;
  83                 }
  84                 ptr->cardnr = cardnr;
  85                 memcpy(&ptr->info, ci, sizeof(*ci));
  86                 list_add(&ptr->list, &card_list);
  87         }
  88         spin_unlock_bh(&card_list_lock);
  89 }
  90
  91 static void card_cache_scrub(u16 cardnr)
  92 {
  93         struct card_list_entry *ptr;
  94
  95         spin_lock_bh(&card_list_lock);
  96         list_for_each_entry(ptr, &card_list, list) {
  97                 if (ptr->cardnr == cardnr) {
  98                         list_del(&ptr->list);
  99                         kfree(ptr);
 100                         break;
 101                 }
 102         }
 103         spin_unlock_bh(&card_list_lock);
 104 }
 105
 106 static void __exit card_cache_free(void)
 107 {
 108         struct card_list_entry *ptr, *pnext;
 109
 110         spin_lock_bh(&card_list_lock);
 111         list_for_each_entry_safe(ptr, pnext, &card_list, list) {
 112                 list_del(&ptr->list);
 113                 kfree(ptr);
 114         }
 115         spin_unlock_bh(&card_list_lock);
 116 }
 117
 118 static int ep11_kb_split(const u8 *kb, size_t kblen, u32 kbver,
 119                          struct ep11kblob_header **kbhdr, size_t *kbhdrsize,
 120                          u8 **kbpl, size_t *kbplsize)
 121 {
 122         struct ep11kblob_header *hdr = NULL;
 123         size_t hdrsize, plsize = 0;
 124         int rc = -EINVAL;
 125         u8 *pl = NULL;
 126
 127         if (kblen < sizeof(struct ep11kblob_header))
 128                 goto out;
 129         hdr = (struct ep11kblob_header *)kb;
 130
 131         switch (kbver) {
 132         case TOKVER_EP11_AES:
 133                 /* header overlays the payload */
 134                 hdrsize = 0;
 135                 break;
 136         case TOKVER_EP11_ECC_WITH_HEADER:
 137         case TOKVER_EP11_AES_WITH_HEADER:
 138                 /* payload starts after the header */
 139                 hdrsize = sizeof(struct ep11kblob_header);
 140                 break;
 141         default:
 142                 goto out;
 143         }
 144
 145         plsize = kblen - hdrsize;
 146         pl = (u8 *)kb + hdrsize;
 147
 148         if (kbhdr)
 149                 *kbhdr = hdr;
 150         if (kbhdrsize)
 151                 *kbhdrsize = hdrsize;
 152         if (kbpl)
 153                 *kbpl = pl;
 154         if (kbplsize)
 155                 *kbplsize = plsize;
 156
 157         rc = 0;
 158 out:
 159         return rc;
 160 }
 161
 162 static int ep11_kb_decode(const u8 *kb, size_t kblen,
 163                           struct ep11kblob_header **kbhdr, size_t *kbhdrsize,
 164                           struct ep11keyblob **kbpl, size_t *kbplsize)
 165 {
 166         struct ep11kblob_header *tmph, *hdr = NULL;
 167         size_t hdrsize = 0, plsize = 0;
 168         struct ep11keyblob *pl = NULL;
 169         int rc = -EINVAL;
 170         u8 *tmpp;
 171
 172         if (kblen < sizeof(struct ep11kblob_header))
 173                 goto out;
 174         tmph = (struct ep11kblob_header *)kb;
 175
 176         if (tmph->type != TOKTYPE_NON_CCA &&
 177             tmph->len > kblen)
 178                 goto out;
 179
 180         if (ep11_kb_split(kb, kblen, tmph->version,
 181                           &hdr, &hdrsize, &tmpp, &plsize))
 182                 goto out;
 183
 184         if (plsize < sizeof(struct ep11keyblob))
 185                 goto out;
 186
 187         if (!is_ep11_keyblob(tmpp))
 188                 goto out;
 189
 190         pl = (struct ep11keyblob *)tmpp;
 191         plsize = hdr->len - hdrsize;
 192
 193         if (kbhdr)
 194                 *kbhdr = hdr;
 195         if (kbhdrsize)
 196                 *kbhdrsize = hdrsize;
 197         if (kbpl)
 198                 *kbpl = pl;
 199         if (kbplsize)
 200                 *kbplsize = plsize;
 201
 202         rc = 0;
 203 out:
 204         return rc;
 205 }
 206
 207 /*
 208  * For valid ep11 keyblobs, returns a reference to the wrappingkey verification
 209  * pattern. Otherwise NULL.
 210  */
 211 const u8 *ep11_kb_wkvp(const u8 *keyblob, size_t keybloblen)
 212 {
 213         struct ep11keyblob *kb;
 214
 215         if (ep11_kb_decode(keyblob, keybloblen, NULL, NULL, &kb, NULL))
 216                 return NULL;
 217         return kb->wkvp;
 218 }
 219 EXPORT_SYMBOL(ep11_kb_wkvp);
 220
 221 /*
 222  * Simple check if the key blob is a valid EP11 AES key blob with header.
 223  */
 224 int ep11_check_aes_key_with_hdr(debug_info_t *dbg, int dbflvl,
 225                                 const u8 *key, size_t keylen, int checkcpacfexp)
 226 {
 227         struct ep11kblob_header *hdr = (struct ep11kblob_header *)key;
 228         struct ep11keyblob *kb = (struct ep11keyblob *)(key + sizeof(*hdr));
 229
 230 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 231
 232         if (keylen < sizeof(*hdr) + sizeof(*kb)) {
 233                 DBF("%s key check failed, keylen %zu < %zu\n",
 234                     __func__, keylen, sizeof(*hdr) + sizeof(*kb));
 235                 return -EINVAL;
 236         }
 237
 238         if (hdr->type != TOKTYPE_NON_CCA) {
 239                 if (dbg)
 240                         DBF("%s key check failed, type 0x%02x != 0x%02x\n",
 241                             __func__, (int)hdr->type, TOKTYPE_NON_CCA);
 242                 return -EINVAL;
 243         }
 244         if (hdr->hver != 0x00) {
 245                 if (dbg)
 246                         DBF("%s key check failed, header version 0x%02x != 0x00\n",
 247                             __func__, (int)hdr->hver);
 248                 return -EINVAL;
 249         }
 250         if (hdr->version != TOKVER_EP11_AES_WITH_HEADER) {
 251                 if (dbg)
 252                         DBF("%s key check failed, version 0x%02x != 0x%02x\n",
 253                             __func__, (int)hdr->version, TOKVER_EP11_AES_WITH_HEADER);
 254                 return -EINVAL;
 255         }
 256         if (hdr->len > keylen) {
 257                 if (dbg)
 258                         DBF("%s key check failed, header len %d keylen %zu mismatch\n",
 259                             __func__, (int)hdr->len, keylen);
 260                 return -EINVAL;
 261         }
 262         if (hdr->len < sizeof(*hdr) + sizeof(*kb)) {
 263                 if (dbg)
 264                         DBF("%s key check failed, header len %d < %zu\n",
 265                             __func__, (int)hdr->len, sizeof(*hdr) + sizeof(*kb));
 266                 return -EINVAL;
 267         }
 268
 269         if (kb->version != EP11_STRUCT_MAGIC) {
 270                 if (dbg)
 271                         DBF("%s key check failed, blob magic 0x%04x != 0x%04x\n",
 272                             __func__, (int)kb->version, EP11_STRUCT_MAGIC);
 273                 return -EINVAL;
 274         }
 275         if (checkcpacfexp && !(kb->attr & EP11_BLOB_PKEY_EXTRACTABLE)) {
 276                 if (dbg)
 277                         DBF("%s key check failed, PKEY_EXTRACTABLE is off\n",
 278                             __func__);
 279                 return -EINVAL;
 280         }
 281
 282 #undef DBF
 283
 284         return 0;
 285 }
 286 EXPORT_SYMBOL(ep11_check_aes_key_with_hdr);
 287
 288 /*
 289  * Simple check if the key blob is a valid EP11 ECC key blob with header.
 290  */
 291 int ep11_check_ecc_key_with_hdr(debug_info_t *dbg, int dbflvl,
 292                                 const u8 *key, size_t keylen, int checkcpacfexp)
 293 {
 294         struct ep11kblob_header *hdr = (struct ep11kblob_header *)key;
 295         struct ep11keyblob *kb = (struct ep11keyblob *)(key + sizeof(*hdr));
 296
 297 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 298
 299         if (keylen < sizeof(*hdr) + sizeof(*kb)) {
 300                 DBF("%s key check failed, keylen %zu < %zu\n",
 301                     __func__, keylen, sizeof(*hdr) + sizeof(*kb));
 302                 return -EINVAL;
 303         }
 304
 305         if (hdr->type != TOKTYPE_NON_CCA) {
 306                 if (dbg)
 307                         DBF("%s key check failed, type 0x%02x != 0x%02x\n",
 308                             __func__, (int)hdr->type, TOKTYPE_NON_CCA);
 309                 return -EINVAL;
 310         }
 311         if (hdr->hver != 0x00) {
 312                 if (dbg)
 313                         DBF("%s key check failed, header version 0x%02x != 0x00\n",
 314                             __func__, (int)hdr->hver);
 315                 return -EINVAL;
 316         }
 317         if (hdr->version != TOKVER_EP11_ECC_WITH_HEADER) {
 318                 if (dbg)
 319                         DBF("%s key check failed, version 0x%02x != 0x%02x\n",
 320                             __func__, (int)hdr->version, TOKVER_EP11_ECC_WITH_HEADER);
 321                 return -EINVAL;
 322         }
 323         if (hdr->len > keylen) {
 324                 if (dbg)
 325                         DBF("%s key check failed, header len %d keylen %zu mismatch\n",
 326                             __func__, (int)hdr->len, keylen);
 327                 return -EINVAL;
 328         }
 329         if (hdr->len < sizeof(*hdr) + sizeof(*kb)) {
 330                 if (dbg)
 331                         DBF("%s key check failed, header len %d < %zu\n",
 332                             __func__, (int)hdr->len, sizeof(*hdr) + sizeof(*kb));
 333                 return -EINVAL;
 334         }
 335
 336         if (kb->version != EP11_STRUCT_MAGIC) {
 337                 if (dbg)
 338                         DBF("%s key check failed, blob magic 0x%04x != 0x%04x\n",
 339                             __func__, (int)kb->version, EP11_STRUCT_MAGIC);
 340                 return -EINVAL;
 341         }
 342         if (checkcpacfexp && !(kb->attr & EP11_BLOB_PKEY_EXTRACTABLE)) {
 343                 if (dbg)
 344                         DBF("%s key check failed, PKEY_EXTRACTABLE is off\n",
 345                             __func__);
 346                 return -EINVAL;
 347         }
 348
 349 #undef DBF
 350
 351         return 0;
 352 }
 353 EXPORT_SYMBOL(ep11_check_ecc_key_with_hdr);
 354
 355 /*
 356  * Simple check if the key blob is a valid EP11 AES key blob with
 357  * the header in the session field (old style EP11 AES key).
 358  */
 359 int ep11_check_aes_key(debug_info_t *dbg, int dbflvl,
 360                        const u8 *key, size_t keylen, int checkcpacfexp)
 361 {
 362         struct ep11keyblob *kb = (struct ep11keyblob *)key;
 363
 364 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 365
 366         if (keylen < sizeof(*kb)) {
 367                 DBF("%s key check failed, keylen %zu < %zu\n",
 368                     __func__, keylen, sizeof(*kb));
 369                 return -EINVAL;
 370         }
 371
 372         if (kb->head.type != TOKTYPE_NON_CCA) {
 373                 if (dbg)
 374                         DBF("%s key check failed, type 0x%02x != 0x%02x\n",
 375                             __func__, (int)kb->head.type, TOKTYPE_NON_CCA);
 376                 return -EINVAL;
 377         }
 378         if (kb->head.version != TOKVER_EP11_AES) {
 379                 if (dbg)
 380                         DBF("%s key check failed, version 0x%02x != 0x%02x\n",
 381                             __func__, (int)kb->head.version, TOKVER_EP11_AES);
 382                 return -EINVAL;
 383         }
 384         if (kb->head.len > keylen) {
 385                 if (dbg)
 386                         DBF("%s key check failed, header len %d keylen %zu mismatch\n",
 387                             __func__, (int)kb->head.len, keylen);
 388                 return -EINVAL;
 389         }
 390         if (kb->head.len < sizeof(*kb)) {
 391                 if (dbg)
 392                         DBF("%s key check failed, header len %d < %zu\n",
 393                             __func__, (int)kb->head.len, sizeof(*kb));
 394                 return -EINVAL;
 395         }
 396
 397         if (kb->version != EP11_STRUCT_MAGIC) {
 398                 if (dbg)
 399                         DBF("%s key check failed, blob magic 0x%04x != 0x%04x\n",
 400                             __func__, (int)kb->version, EP11_STRUCT_MAGIC);
 401                 return -EINVAL;
 402         }
 403         if (checkcpacfexp && !(kb->attr & EP11_BLOB_PKEY_EXTRACTABLE)) {
 404                 if (dbg)
 405                         DBF("%s key check failed, PKEY_EXTRACTABLE is off\n",
 406                             __func__);
 407                 return -EINVAL;
 408         }
 409
 410 #undef DBF
 411
 412         return 0;
 413 }
 414 EXPORT_SYMBOL(ep11_check_aes_key);
 415
 416 /*
 417  * Allocate and prepare ep11 cprb plus additional payload.
 418  */
 419 static inline struct ep11_cprb *alloc_cprb(size_t payload_len)
 420 {
 421         size_t len = sizeof(struct ep11_cprb) + payload_len;
 422         struct ep11_cprb *cprb;
 423
 424         cprb = kzalloc(len, GFP_KERNEL);
 425         if (!cprb)
 426                 return NULL;
 427
 428         cprb->cprb_len = sizeof(struct ep11_cprb);
 429         cprb->cprb_ver_id = 0x04;
 430         memcpy(cprb->func_id, "T4", 2);
 431         cprb->ret_code = 0xFFFFFFFF;
 432         cprb->payload_len = payload_len;
 433
 434         return cprb;
 435 }
 436
 437 /*
 438  * Some helper functions related to ASN1 encoding.
 439  * Limited to length info <= 2 byte.
 440  */
 441
 442 #define ASN1TAGLEN(x) (2 + (x) + ((x) > 127 ? 1 : 0) + ((x) > 255 ? 1 : 0))
 443
 444 static int asn1tag_write(u8 *ptr, u8 tag, const u8 *pvalue, u16 valuelen)
 445 {
 446         ptr[0] = tag;
 447         if (valuelen > 255) {
 448                 ptr[1] = 0x82;
 449                 *((u16 *)(ptr + 2)) = valuelen;
 450                 memcpy(ptr + 4, pvalue, valuelen);
 451                 return 4 + valuelen;
 452         }
 453         if (valuelen > 127) {
 454                 ptr[1] = 0x81;
 455                 ptr[2] = (u8)valuelen;
 456                 memcpy(ptr + 3, pvalue, valuelen);
 457                 return 3 + valuelen;
 458         }
 459         ptr[1] = (u8)valuelen;
 460         memcpy(ptr + 2, pvalue, valuelen);
 461         return 2 + valuelen;
 462 }
 463
 464 /* EP11 payload > 127 bytes starts with this struct */
 465 struct pl_head {
 466         u8  tag;
 467         u8  lenfmt;
 468         u16 len;
 469         u8  func_tag;
 470         u8  func_len;
 471         u32 func;
 472         u8  dom_tag;
 473         u8  dom_len;
 474         u32 dom;
 475 } __packed;
 476
 477 /* prep ep11 payload head helper function */
 478 static inline void prep_head(struct pl_head *h,
 479                              size_t pl_size, int api, int func)
 480 {
 481         h->tag = 0x30;
 482         h->lenfmt = 0x82;
 483         h->len = pl_size - 4;
 484         h->func_tag = 0x04;
 485         h->func_len = sizeof(u32);
 486         h->func = (api << 16) + func;
 487         h->dom_tag = 0x04;
 488         h->dom_len = sizeof(u32);
 489 }
 490
 491 /* prep urb helper function */
 492 static inline void prep_urb(struct ep11_urb *u,
 493                             struct ep11_target_dev *t, int nt,
 494                             struct ep11_cprb *req, size_t req_len,
 495                             struct ep11_cprb *rep, size_t rep_len)
 496 {
 497         u->targets = (u8 __user *)t;
 498         u->targets_num = nt;
 499         u->req = (u8 __user *)req;
 500         u->req_len = req_len;
 501         u->resp = (u8 __user *)rep;
 502         u->resp_len = rep_len;
 503 }
 504
 505 /* Check ep11 reply payload, return 0 or suggested errno value. */
 506 static int check_reply_pl(const u8 *pl, const char *func)
 507 {
 508         int len;
 509         u32 ret;
 510
 511         /* start tag */
 512         if (*pl++ != 0x30) {
 513                 DEBUG_ERR("%s reply start tag mismatch\n", func);
 514                 return -EIO;
 515         }
 516
 517         /* payload length format */
 518         if (*pl < 127) {
 519                 len = *pl;
 520                 pl++;
 521         } else if (*pl == 0x81) {
 522                 pl++;
 523                 len = *pl;
 524                 pl++;
 525         } else if (*pl == 0x82) {
 526                 pl++;
 527                 len = *((u16 *)pl);
 528                 pl += 2;
 529         } else {
 530                 DEBUG_ERR("%s reply start tag lenfmt mismatch 0x%02hhx\n",
 531                           func, *pl);
 532                 return -EIO;
 533         }
 534
 535         /* len should cover at least 3 fields with 32 bit value each */
 536         if (len < 3 * 6) {
 537                 DEBUG_ERR("%s reply length %d too small\n", func, len);
 538                 return -EIO;
 539         }
 540
 541         /* function tag, length and value */
 542         if (pl[0] != 0x04 || pl[1] != 0x04) {
 543                 DEBUG_ERR("%s function tag or length mismatch\n", func);
 544                 return -EIO;
 545         }
 546         pl += 6;
 547
 548         /* dom tag, length and value */
 549         if (pl[0] != 0x04 || pl[1] != 0x04) {
 550                 DEBUG_ERR("%s dom tag or length mismatch\n", func);
 551                 return -EIO;
 552         }
 553         pl += 6;
 554
 555         /* return value tag, length and value */
 556         if (pl[0] != 0x04 || pl[1] != 0x04) {
 557                 DEBUG_ERR("%s return value tag or length mismatch\n", func);
 558                 return -EIO;
 559         }
 560         pl += 2;
 561         ret = *((u32 *)pl);
 562         if (ret != 0) {
 563                 DEBUG_ERR("%s return value 0x%04x != 0\n", func, ret);
 564                 return -EIO;
 565         }
 566
 567         return 0;
 568 }
 569
 570 /*
 571  * Helper function which does an ep11 query with given query type.
 572  */
 573 static int ep11_query_info(u16 cardnr, u16 domain, u32 query_type,
 574                            size_t buflen, u8 *buf)
 575 {
 576         struct ep11_info_req_pl {
 577                 struct pl_head head;
 578                 u8  query_type_tag;
 579                 u8  query_type_len;
 580                 u32 query_type;
 581                 u8  query_subtype_tag;
 582                 u8  query_subtype_len;
 583                 u32 query_subtype;
 584         } __packed * req_pl;
 585         struct ep11_info_rep_pl {
 586                 struct pl_head head;
 587                 u8  rc_tag;
 588                 u8  rc_len;
 589                 u32 rc;
 590                 u8  data_tag;
 591                 u8  data_lenfmt;
 592                 u16 data_len;
 593         } __packed * rep_pl;
 594         struct ep11_cprb *req = NULL, *rep = NULL;
 595         struct ep11_target_dev target;
 596         struct ep11_urb *urb = NULL;
 597         int api = EP11_API_V1, rc = -ENOMEM;
 598
 599         /* request cprb and payload */
 600         req = alloc_cprb(sizeof(struct ep11_info_req_pl));
 601         if (!req)
 602                 goto out;
 603         req_pl = (struct ep11_info_req_pl *)(((u8 *)req) + sizeof(*req));
 604         prep_head(&req_pl->head, sizeof(*req_pl), api, 38); /* get xcp info */
 605         req_pl->query_type_tag = 0x04;
 606         req_pl->query_type_len = sizeof(u32);
 607         req_pl->query_type = query_type;
 608         req_pl->query_subtype_tag = 0x04;
 609         req_pl->query_subtype_len = sizeof(u32);
 610
 611         /* reply cprb and payload */
 612         rep = alloc_cprb(sizeof(struct ep11_info_rep_pl) + buflen);
 613         if (!rep)
 614                 goto out;
 615         rep_pl = (struct ep11_info_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 616
 617         /* urb and target */
 618         urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 619         if (!urb)
 620                 goto out;
 621         target.ap_id = cardnr;
 622         target.dom_id = domain;
 623         prep_urb(urb, &target, 1,
 624                  req, sizeof(*req) + sizeof(*req_pl),
 625                  rep, sizeof(*rep) + sizeof(*rep_pl) + buflen);
 626
 627         rc = zcrypt_send_ep11_cprb(urb);
 628         if (rc) {
 629                 DEBUG_ERR(
 630                         "%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
 631                         __func__, (int)cardnr, (int)domain, rc);
 632                 goto out;
 633         }
 634
 635         rc = check_reply_pl((u8 *)rep_pl, __func__);
 636         if (rc)
 637                 goto out;
 638         if (rep_pl->data_tag != 0x04 || rep_pl->data_lenfmt != 0x82) {
 639                 DEBUG_ERR("%s unknown reply data format\n", __func__);
 640                 rc = -EIO;
 641                 goto out;
 642         }
 643         if (rep_pl->data_len > buflen) {
 644                 DEBUG_ERR("%s mismatch between reply data len and buffer len\n",
 645                           __func__);
 646                 rc = -ENOSPC;
 647                 goto out;
 648         }
 649
 650         memcpy(buf, ((u8 *)rep_pl) + sizeof(*rep_pl), rep_pl->data_len);
 651
 652 out:
 653         kfree(req);
 654         kfree(rep);
 655         kfree(urb);
 656         return rc;
 657 }
 658
 659 /*
 660  * Provide information about an EP11 card.
 661  */
 662 int ep11_get_card_info(u16 card, struct ep11_card_info *info, int verify)
 663 {
 664         int rc;
 665         struct ep11_module_query_info {
 666                 u32 API_ord_nr;
 667                 u32 firmware_id;
 668                 u8  FW_major_vers;
 669                 u8  FW_minor_vers;
 670                 u8  CSP_major_vers;
 671                 u8  CSP_minor_vers;
 672                 u8  fwid[32];
 673                 u8  xcp_config_hash[32];
 674                 u8  CSP_config_hash[32];
 675                 u8  serial[16];
 676                 u8  module_date_time[16];
 677                 u64 op_mode;
 678                 u32 PKCS11_flags;
 679                 u32 ext_flags;
 680                 u32 domains;
 681                 u32 sym_state_bytes;
 682                 u32 digest_state_bytes;
 683                 u32 pin_blob_bytes;
 684                 u32 SPKI_bytes;
 685                 u32 priv_key_blob_bytes;
 686                 u32 sym_blob_bytes;
 687                 u32 max_payload_bytes;
 688                 u32 CP_profile_bytes;
 689                 u32 max_CP_index;
 690         } __packed * pmqi = NULL;
 691
 692         rc = card_cache_fetch(card, info);
 693         if (rc || verify) {
 694                 pmqi = kmalloc(sizeof(*pmqi), GFP_KERNEL);
 695                 if (!pmqi)
 696                         return -ENOMEM;
 697                 rc = ep11_query_info(card, AUTOSEL_DOM,
 698                                      0x01 /* module info query */,
 699                                      sizeof(*pmqi), (u8 *)pmqi);
 700                 if (rc) {
 701                         if (rc == -ENODEV)
 702                                 card_cache_scrub(card);
 703                         goto out;
 704                 }
 705                 memset(info, 0, sizeof(*info));
 706                 info->API_ord_nr = pmqi->API_ord_nr;
 707                 info->FW_version =
 708                         (pmqi->FW_major_vers << 8) + pmqi->FW_minor_vers;
 709                 memcpy(info->serial, pmqi->serial, sizeof(info->serial));
 710                 info->op_mode = pmqi->op_mode;
 711                 card_cache_update(card, info);
 712         }
 713
 714 out:
 715         kfree(pmqi);
 716         return rc;
 717 }
 718 EXPORT_SYMBOL(ep11_get_card_info);
 719
 720 /*
 721  * Provide information about a domain within an EP11 card.
 722  */
 723 int ep11_get_domain_info(u16 card, u16 domain, struct ep11_domain_info *info)
 724 {
 725         int rc;
 726         struct ep11_domain_query_info {
 727                 u32 dom_index;
 728                 u8  cur_WK_VP[32];
 729                 u8  new_WK_VP[32];
 730                 u32 dom_flags;
 731                 u64 op_mode;
 732         } __packed * p_dom_info;
 733
 734         p_dom_info = kmalloc(sizeof(*p_dom_info), GFP_KERNEL);
 735         if (!p_dom_info)
 736                 return -ENOMEM;
 737
 738         rc = ep11_query_info(card, domain, 0x03 /* domain info query */,
 739                              sizeof(*p_dom_info), (u8 *)p_dom_info);
 740         if (rc)
 741                 goto out;
 742
 743         memset(info, 0, sizeof(*info));
 744         info->cur_wk_state = '0';
 745         info->new_wk_state = '0';
 746         if (p_dom_info->dom_flags & 0x10 /* left imprint mode */) {
 747                 if (p_dom_info->dom_flags & 0x02 /* cur wk valid */) {
 748                         info->cur_wk_state = '1';
 749                         memcpy(info->cur_wkvp, p_dom_info->cur_WK_VP, 32);
 750                 }
 751                 if (p_dom_info->dom_flags & 0x04 || /* new wk present */
 752                     p_dom_info->dom_flags & 0x08 /* new wk committed */) {
 753                         info->new_wk_state =
 754                                 p_dom_info->dom_flags & 0x08 ? '2' : '1';
 755                         memcpy(info->new_wkvp, p_dom_info->new_WK_VP, 32);
 756                 }
 757         }
 758         info->op_mode = p_dom_info->op_mode;
 759
 760 out:
 761         kfree(p_dom_info);
 762         return rc;
 763 }
 764 EXPORT_SYMBOL(ep11_get_domain_info);
 765
 766 /*
 767  * Default EP11 AES key generate attributes, used when no keygenflags given:
 768  * XCP_BLOB_ENCRYPT | XCP_BLOB_DECRYPT | XCP_BLOB_PROTKEY_EXTRACTABLE
 769  */
 770 #define KEY_ATTR_DEFAULTS 0x00200c00
 771
 772 static int _ep11_genaeskey(u16 card, u16 domain,
 773                            u32 keybitsize, u32 keygenflags,
 774                            u8 *keybuf, size_t *keybufsize)
 775 {
 776         struct keygen_req_pl {
 777                 struct pl_head head;
 778                 u8  var_tag;
 779                 u8  var_len;
 780                 u32 var;
 781                 u8  keybytes_tag;
 782                 u8  keybytes_len;
 783                 u32 keybytes;
 784                 u8  mech_tag;
 785                 u8  mech_len;
 786                 u32 mech;
 787                 u8  attr_tag;
 788                 u8  attr_len;
 789                 u32 attr_header;
 790                 u32 attr_bool_mask;
 791                 u32 attr_bool_bits;
 792                 u32 attr_val_len_type;
 793                 u32 attr_val_len_value;
 794                 /* followed by empty pin tag or empty pinblob tag */
 795         } __packed * req_pl;
 796         struct keygen_rep_pl {
 797                 struct pl_head head;
 798                 u8  rc_tag;
 799                 u8  rc_len;
 800                 u32 rc;
 801                 u8  data_tag;
 802                 u8  data_lenfmt;
 803                 u16 data_len;
 804                 u8  data[512];
 805         } __packed * rep_pl;
 806         struct ep11_cprb *req = NULL, *rep = NULL;
 807         size_t req_pl_size, pinblob_size = 0;
 808         struct ep11_target_dev target;
 809         struct ep11_urb *urb = NULL;
 810         int api, rc = -ENOMEM;
 811         u8 *p;
 812
 813         switch (keybitsize) {
 814         case 128:
 815         case 192:
 816         case 256:
 817                 break;
 818         default:
 819                 DEBUG_ERR(
 820                         "%s unknown/unsupported keybitsize %d\n",
 821                         __func__, keybitsize);
 822                 rc = -EINVAL;
 823                 goto out;
 824         }
 825
 826         /* request cprb and payload */
 827         api = (!keygenflags || keygenflags & 0x00200000) ?
 828                 EP11_API_V4 : EP11_API_V1;
 829         if (ap_is_se_guest()) {
 830                 /*
 831                  * genkey within SE environment requires API ordinal 6
 832                  * with empty pinblob
 833                  */
 834                 api = EP11_API_V6;
 835                 pinblob_size = EP11_PINBLOB_V1_BYTES;
 836         }
 837         req_pl_size = sizeof(struct keygen_req_pl) + ASN1TAGLEN(pinblob_size);
 838         req = alloc_cprb(req_pl_size);
 839         if (!req)
 840                 goto out;
 841         req_pl = (struct keygen_req_pl *)(((u8 *)req) + sizeof(*req));
 842         prep_head(&req_pl->head, req_pl_size, api, 21); /* GenerateKey */
 843         req_pl->var_tag = 0x04;
 844         req_pl->var_len = sizeof(u32);
 845         req_pl->keybytes_tag = 0x04;
 846         req_pl->keybytes_len = sizeof(u32);
 847         req_pl->keybytes = keybitsize / 8;
 848         req_pl->mech_tag = 0x04;
 849         req_pl->mech_len = sizeof(u32);
 850         req_pl->mech = 0x00001080; /* CKM_AES_KEY_GEN */
 851         req_pl->attr_tag = 0x04;
 852         req_pl->attr_len = 5 * sizeof(u32);
 853         req_pl->attr_header = 0x10010000;
 854         req_pl->attr_bool_mask = keygenflags ? keygenflags : KEY_ATTR_DEFAULTS;
 855         req_pl->attr_bool_bits = keygenflags ? keygenflags : KEY_ATTR_DEFAULTS;
 856         req_pl->attr_val_len_type = 0x00000161; /* CKA_VALUE_LEN */
 857         req_pl->attr_val_len_value = keybitsize / 8;
 858         p = ((u8 *)req_pl) + sizeof(*req_pl);
 859         /* pin tag */
 860         *p++ = 0x04;
 861         *p++ = pinblob_size;
 862
 863         /* reply cprb and payload */
 864         rep = alloc_cprb(sizeof(struct keygen_rep_pl));
 865         if (!rep)
 866                 goto out;
 867         rep_pl = (struct keygen_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 868
 869         /* urb and target */
 870         urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 871         if (!urb)
 872                 goto out;
 873         target.ap_id = card;
 874         target.dom_id = domain;
 875         prep_urb(urb, &target, 1,
 876                  req, sizeof(*req) + req_pl_size,
 877                  rep, sizeof(*rep) + sizeof(*rep_pl));
 878
 879         rc = zcrypt_send_ep11_cprb(urb);
 880         if (rc) {
 881                 DEBUG_ERR(
 882                         "%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
 883                         __func__, (int)card, (int)domain, rc);
 884                 goto out;
 885         }
 886
 887         rc = check_reply_pl((u8 *)rep_pl, __func__);
 888         if (rc)
 889                 goto out;
 890         if (rep_pl->data_tag != 0x04 || rep_pl->data_lenfmt != 0x82) {
 891                 DEBUG_ERR("%s unknown reply data format\n", __func__);
 892                 rc = -EIO;
 893                 goto out;
 894         }
 895         if (rep_pl->data_len > *keybufsize) {
 896                 DEBUG_ERR("%s mismatch reply data len / key buffer len\n",
 897                           __func__);
 898                 rc = -ENOSPC;
 899                 goto out;
 900         }
 901
 902         /* copy key blob */
 903         memcpy(keybuf, rep_pl->data, rep_pl->data_len);
 904         *keybufsize = rep_pl->data_len;
 905
 906 out:
 907         kfree(req);
 908         kfree(rep);
 909         kfree(urb);
 910         return rc;
 911 }
 912
 913 int ep11_genaeskey(u16 card, u16 domain, u32 keybitsize, u32 keygenflags,
 914                    u8 *keybuf, size_t *keybufsize, u32 keybufver)
 915 {
 916         struct ep11kblob_header *hdr;
 917         size_t hdr_size, pl_size;
 918         u8 *pl;
 919         int rc;
 920
 921         switch (keybufver) {
 922         case TOKVER_EP11_AES:
 923         case TOKVER_EP11_AES_WITH_HEADER:
 924                 break;
 925         default:
 926                 return -EINVAL;
 927         }
 928
 929         rc = ep11_kb_split(keybuf, *keybufsize, keybufver,
 930                            &hdr, &hdr_size, &pl, &pl_size);
 931         if (rc)
 932                 return rc;
 933
 934         rc = _ep11_genaeskey(card, domain, keybitsize, keygenflags,
 935                              pl, &pl_size);
 936         if (rc)
 937                 return rc;
 938
 939         *keybufsize = hdr_size + pl_size;
 940
 941         /* update header information */
 942         hdr->type = TOKTYPE_NON_CCA;
 943         hdr->len = *keybufsize;
 944         hdr->version = keybufver;
 945         hdr->bitlen = keybitsize;
 946
 947         return 0;
 948 }
 949 EXPORT_SYMBOL(ep11_genaeskey);
 950
 951 static int ep11_cryptsingle(u16 card, u16 domain,
 952                             u16 mode, u32 mech, const u8 *iv,
 953                             const u8 *key, size_t keysize,
 954                             const u8 *inbuf, size_t inbufsize,
 955                             u8 *outbuf, size_t *outbufsize)
 956 {
 957         struct crypt_req_pl {
 958                 struct pl_head head;
 959                 u8  var_tag;
 960                 u8  var_len;
 961                 u32 var;
 962                 u8  mech_tag;
 963                 u8  mech_len;
 964                 u32 mech;
 965                 /*
 966                  * maybe followed by iv data
 967                  * followed by key tag + key blob
 968                  * followed by plaintext tag + plaintext
 969                  */
 970         } __packed * req_pl;
 971         struct crypt_rep_pl {
 972                 struct pl_head head;
 973                 u8  rc_tag;
 974                 u8  rc_len;
 975                 u32 rc;
 976                 u8  data_tag;
 977                 u8  data_lenfmt;
 978                 /* data follows */
 979         } __packed * rep_pl;
 980         struct ep11_cprb *req = NULL, *rep = NULL;
 981         struct ep11_target_dev target;
 982         struct ep11_urb *urb = NULL;
 983         size_t req_pl_size, rep_pl_size;
 984         int n, api = EP11_API_V1, rc = -ENOMEM;
 985         u8 *p;
 986
 987         /* the simple asn1 coding used has length limits */
 988         if (keysize > 0xFFFF || inbufsize > 0xFFFF)
 989                 return -EINVAL;
 990
 991         /* request cprb and payload */
 992         req_pl_size = sizeof(struct crypt_req_pl) + (iv ? 16 : 0)
 993                 + ASN1TAGLEN(keysize) + ASN1TAGLEN(inbufsize);
 994         req = alloc_cprb(req_pl_size);
 995         if (!req)
 996                 goto out;
 997         req_pl = (struct crypt_req_pl *)(((u8 *)req) + sizeof(*req));
 998         prep_head(&req_pl->head, req_pl_size, api, (mode ? 20 : 19));
 999         req_pl->var_tag = 0x04;
1000         req_pl->var_len = sizeof(u32);
1001         /* mech is mech + mech params (iv here) */
1002         req_pl->mech_tag = 0x04;
1003         req_pl->mech_len = sizeof(u32) + (iv ? 16 : 0);
1004         req_pl->mech = (mech ? mech : 0x00001085); /* CKM_AES_CBC_PAD */
1005         p = ((u8 *)req_pl) + sizeof(*req_pl);
1006         if (iv) {
1007                 memcpy(p, iv, 16);
1008                 p += 16;
1009         }
1010         /* key and input data */
1011         p += asn1tag_write(p, 0x04, key, keysize);
1012         p += asn1tag_write(p, 0x04, inbuf, inbufsize);
1013
1014         /* reply cprb and payload, assume out data size <= in data size + 32 */
1015         rep_pl_size = sizeof(struct crypt_rep_pl) + ASN1TAGLEN(inbufsize + 32);
1016         rep = alloc_cprb(rep_pl_size);
1017         if (!rep)
1018                 goto out;
1019         rep_pl = (struct crypt_rep_pl *)(((u8 *)rep) + sizeof(*rep));
1020
1021         /* urb and target */
1022         urb = kmalloc(sizeof(*urb), GFP_KERNEL);
1023         if (!urb)
1024                 goto out;
1025         target.ap_id = card;
1026         target.dom_id = domain;
1027         prep_urb(urb, &target, 1,
1028                  req, sizeof(*req) + req_pl_size,
1029                  rep, sizeof(*rep) + rep_pl_size);
1030
1031         rc = zcrypt_send_ep11_cprb(urb);
1032         if (rc) {
1033                 DEBUG_ERR(
1034                         "%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
1035                         __func__, (int)card, (int)domain, rc);
1036                 goto out;
1037         }
1038
1039         rc = check_reply_pl((u8 *)rep_pl, __func__);
1040         if (rc)
1041                 goto out;
1042         if (rep_pl->data_tag != 0x04) {
1043                 DEBUG_ERR("%s unknown reply data format\n", __func__);
1044                 rc = -EIO;
1045                 goto out;
1046         }
1047         p = ((u8 *)rep_pl) + sizeof(*rep_pl);
1048         if (rep_pl->data_lenfmt <= 127) {
1049                 n = rep_pl->data_lenfmt;
1050         } else if (rep_pl->data_lenfmt == 0x81) {
1051                 n = *p++;
1052         } else if (rep_pl->data_lenfmt == 0x82) {
1053                 n = *((u16 *)p);
1054                 p += 2;
1055         } else {
1056                 DEBUG_ERR("%s unknown reply data length format 0x%02hhx\n",
1057                           __func__, rep_pl->data_lenfmt);
1058                 rc = -EIO;
1059                 goto out;
1060         }
1061         if (n > *outbufsize) {
1062                 DEBUG_ERR("%s mismatch reply data len %d / output buffer %zu\n",
1063                           __func__, n, *outbufsize);
1064                 rc = -ENOSPC;
1065                 goto out;
1066         }
1067
1068         memcpy(outbuf, p, n);
1069         *outbufsize = n;
1070
1071 out:
1072         kfree(req);
1073         kfree(rep);
1074         kfree(urb);
1075         return rc;
1076 }
1077
1078 static int _ep11_unwrapkey(u16 card, u16 domain,
1079                            const u8 *kek, size_t keksize,
1080                            const u8 *enckey, size_t enckeysize,
1081                            u32 mech, const u8 *iv,
1082                            u32 keybitsize, u32 keygenflags,
1083                            u8 *keybuf, size_t *keybufsize)
1084 {
1085         struct uw_req_pl {
1086                 struct pl_head head;
1087                 u8  attr_tag;
1088                 u8  attr_len;
1089                 u32 attr_header;
1090                 u32 attr_bool_mask;
1091                 u32 attr_bool_bits;
1092                 u32 attr_key_type;
1093                 u32 attr_key_type_value;
1094                 u32 attr_val_len;
1095                 u32 attr_val_len_value;
1096                 u8  mech_tag;
1097                 u8  mech_len;
1098                 u32 mech;
1099                 /*
1100                  * maybe followed by iv data
1101                  * followed by kek tag + kek blob
1102                  * followed by empty mac tag
1103                  * followed by empty pin tag or empty pinblob tag
1104                  * followed by encryted key tag + bytes
1105                  */
1106         } __packed * req_pl;
1107         struct uw_rep_pl {
1108                 struct pl_head head;
1109                 u8  rc_tag;
1110                 u8  rc_len;
1111                 u32 rc;
1112                 u8  data_tag;
1113                 u8  data_lenfmt;
1114                 u16 data_len;
1115                 u8  data[512];
1116         } __packed * rep_pl;
1117         struct ep11_cprb *req = NULL, *rep = NULL;
1118         size_t req_pl_size, pinblob_size = 0;
1119         struct ep11_target_dev target;
1120         struct ep11_urb *urb = NULL;
1121         int api, rc = -ENOMEM;
1122         u8 *p;
1123
1124         /* request cprb and payload */
1125         api = (!keygenflags || keygenflags & 0x00200000) ?
1126                 EP11_API_V4 : EP11_API_V1;
1127         if (ap_is_se_guest()) {
1128                 /*
1129                  * unwrap within SE environment requires API ordinal 6
1130                  * with empty pinblob
1131                  */
1132                 api = EP11_API_V6;
1133                 pinblob_size = EP11_PINBLOB_V1_BYTES;
1134         }
1135         req_pl_size = sizeof(struct uw_req_pl) + (iv ? 16 : 0)
1136                 + ASN1TAGLEN(keksize) + ASN1TAGLEN(0)
1137                 + ASN1TAGLEN(pinblob_size) + ASN1TAGLEN(enckeysize);
1138         req = alloc_cprb(req_pl_size);
1139         if (!req)
1140                 goto out;
1141         req_pl = (struct uw_req_pl *)(((u8 *)req) + sizeof(*req));
1142         prep_head(&req_pl->head, req_pl_size, api, 34); /* UnwrapKey */
1143         req_pl->attr_tag = 0x04;
1144         req_pl->attr_len = 7 * sizeof(u32);
1145         req_pl->attr_header = 0x10020000;
1146         req_pl->attr_bool_mask = keygenflags ? keygenflags : KEY_ATTR_DEFAULTS;
1147         req_pl->attr_bool_bits = keygenflags ? keygenflags : KEY_ATTR_DEFAULTS;
1148         req_pl->attr_key_type = 0x00000100; /* CKA_KEY_TYPE */
1149         req_pl->attr_key_type_value = 0x0000001f; /* CKK_AES */
1150         req_pl->attr_val_len = 0x00000161; /* CKA_VALUE_LEN */
1151         req_pl->attr_val_len_value = keybitsize / 8;
1152         /* mech is mech + mech params (iv here) */
1153         req_pl->mech_tag = 0x04;
1154         req_pl->mech_len = sizeof(u32) + (iv ? 16 : 0);
1155         req_pl->mech = (mech ? mech : 0x00001085); /* CKM_AES_CBC_PAD */
1156         p = ((u8 *)req_pl) + sizeof(*req_pl);
1157         if (iv) {
1158                 memcpy(p, iv, 16);
1159                 p += 16;
1160         }
1161         /* kek */
1162         p += asn1tag_write(p, 0x04, kek, keksize);
1163         /* empty mac key tag */
1164         *p++ = 0x04;
1165         *p++ = 0;
1166         /* pin tag */
1167         *p++ = 0x04;
1168         *p++ = pinblob_size;
1169         p += pinblob_size;
1170         /* encrypted key value tag and bytes */
1171         p += asn1tag_write(p, 0x04, enckey, enckeysize);
1172
1173         /* reply cprb and payload */
1174         rep = alloc_cprb(sizeof(struct uw_rep_pl));
1175         if (!rep)
1176                 goto out;
1177         rep_pl = (struct uw_rep_pl *)(((u8 *)rep) + sizeof(*rep));
1178
1179         /* urb and target */
1180         urb = kmalloc(sizeof(*urb), GFP_KERNEL);
1181         if (!urb)
1182                 goto out;
1183         target.ap_id = card;
1184         target.dom_id = domain;
1185         prep_urb(urb, &target, 1,
1186                  req, sizeof(*req) + req_pl_size,
1187                  rep, sizeof(*rep) + sizeof(*rep_pl));
1188
1189         rc = zcrypt_send_ep11_cprb(urb);
1190         if (rc) {
1191                 DEBUG_ERR(
1192                         "%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
1193                         __func__, (int)card, (int)domain, rc);
1194                 goto out;
1195         }
1196
1197         rc = check_reply_pl((u8 *)rep_pl, __func__);
1198         if (rc)
1199                 goto out;
1200         if (rep_pl->data_tag != 0x04 || rep_pl->data_lenfmt != 0x82) {
1201                 DEBUG_ERR("%s unknown reply data format\n", __func__);
1202                 rc = -EIO;
1203                 goto out;
1204         }
1205         if (rep_pl->data_len > *keybufsize) {
1206                 DEBUG_ERR("%s mismatch reply data len / key buffer len\n",
1207                           __func__);
1208                 rc = -ENOSPC;
1209                 goto out;
1210         }
1211
1212         /* copy key blob */
1213         memcpy(keybuf, rep_pl->data, rep_pl->data_len);
1214         *keybufsize = rep_pl->data_len;
1215
1216 out:
1217         kfree(req);
1218         kfree(rep);
1219         kfree(urb);
1220         return rc;
1221 }
1222
1223 static int ep11_unwrapkey(u16 card, u16 domain,
1224                           const u8 *kek, size_t keksize,
1225                           const u8 *enckey, size_t enckeysize,
1226                           u32 mech, const u8 *iv,
1227                           u32 keybitsize, u32 keygenflags,
1228                           u8 *keybuf, size_t *keybufsize,
1229                           u8 keybufver)
1230 {
1231         struct ep11kblob_header *hdr;
1232         size_t hdr_size, pl_size;
1233         u8 *pl;
1234         int rc;
1235
1236         rc = ep11_kb_split(keybuf, *keybufsize, keybufver,
1237                            &hdr, &hdr_size, &pl, &pl_size);
1238         if (rc)
1239                 return rc;
1240
1241         rc = _ep11_unwrapkey(card, domain, kek, keksize, enckey, enckeysize,
1242                              mech, iv, keybitsize, keygenflags,
1243                              pl, &pl_size);
1244         if (rc)
1245                 return rc;
1246
1247         *keybufsize = hdr_size + pl_size;
1248
1249         /* update header information */
1250         hdr = (struct ep11kblob_header *)keybuf;
1251         hdr->type = TOKTYPE_NON_CCA;
1252         hdr->len = *keybufsize;
1253         hdr->version = keybufver;
1254         hdr->bitlen = keybitsize;
1255
1256         return 0;
1257 }
1258
1259 static int _ep11_wrapkey(u16 card, u16 domain,
1260                          const u8 *key, size_t keysize,
1261                          u32 mech, const u8 *iv,
1262                          u8 *databuf, size_t *datasize)
1263 {
1264         struct wk_req_pl {
1265                 struct pl_head head;
1266                 u8  var_tag;
1267                 u8  var_len;
1268                 u32 var;
1269                 u8  mech_tag;
1270                 u8  mech_len;
1271                 u32 mech;
1272                 /*
1273                  * followed by iv data
1274                  * followed by key tag + key blob
1275                  * followed by dummy kek param
1276                  * followed by dummy mac param
1277                  */
1278         } __packed * req_pl;
1279         struct wk_rep_pl {
1280                 struct pl_head head;
1281                 u8  rc_tag;
1282                 u8  rc_len;
1283                 u32 rc;
1284                 u8  data_tag;
1285                 u8  data_lenfmt;
1286                 u16 data_len;
1287                 u8  data[1024];
1288         } __packed * rep_pl;
1289         struct ep11_cprb *req = NULL, *rep = NULL;
1290         struct ep11_target_dev target;
1291         struct ep11_urb *urb = NULL;
1292         size_t req_pl_size;
1293         int api, rc = -ENOMEM;
1294         u8 *p;
1295
1296         /* request cprb and payload */
1297         req_pl_size = sizeof(struct wk_req_pl) + (iv ? 16 : 0)
1298                 + ASN1TAGLEN(keysize) + 4;
1299         req = alloc_cprb(req_pl_size);
1300         if (!req)
1301                 goto out;
1302         if (!mech || mech == 0x80060001)
1303                 req->flags |= 0x20; /* CPACF_WRAP needs special bit */
1304         req_pl = (struct wk_req_pl *)(((u8 *)req) + sizeof(*req));
1305         api = (!mech || mech == 0x80060001) ? /* CKM_IBM_CPACF_WRAP */
1306                 EP11_API_V4 : EP11_API_V1;
1307         prep_head(&req_pl->head, req_pl_size, api, 33); /* WrapKey */
1308         req_pl->var_tag = 0x04;
1309         req_pl->var_len = sizeof(u32);
1310         /* mech is mech + mech params (iv here) */
1311         req_pl->mech_tag = 0x04;
1312         req_pl->mech_len = sizeof(u32) + (iv ? 16 : 0);
1313         req_pl->mech = (mech ? mech : 0x80060001); /* CKM_IBM_CPACF_WRAP */
1314         p = ((u8 *)req_pl) + sizeof(*req_pl);
1315         if (iv) {
1316                 memcpy(p, iv, 16);
1317                 p += 16;
1318         }
1319         /* key blob */
1320         p += asn1tag_write(p, 0x04, key, keysize);
1321         /* empty kek tag */
1322         *p++ = 0x04;
1323         *p++ = 0;
1324         /* empty mac tag */
1325         *p++ = 0x04;
1326         *p++ = 0;
1327
1328         /* reply cprb and payload */
1329         rep = alloc_cprb(sizeof(struct wk_rep_pl));
1330         if (!rep)
1331                 goto out;
1332         rep_pl = (struct wk_rep_pl *)(((u8 *)rep) + sizeof(*rep));
1333
1334         /* urb and target */
1335         urb = kmalloc(sizeof(*urb), GFP_KERNEL);
1336         if (!urb)
1337                 goto out;
1338         target.ap_id = card;
1339         target.dom_id = domain;
1340         prep_urb(urb, &target, 1,
1341                  req, sizeof(*req) + req_pl_size,
1342                  rep, sizeof(*rep) + sizeof(*rep_pl));
1343
1344         rc = zcrypt_send_ep11_cprb(urb);
1345         if (rc) {
1346                 DEBUG_ERR(
1347                         "%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
1348                         __func__, (int)card, (int)domain, rc);
1349                 goto out;
1350         }
1351
1352         rc = check_reply_pl((u8 *)rep_pl, __func__);
1353         if (rc)
1354                 goto out;
1355         if (rep_pl->data_tag != 0x04 || rep_pl->data_lenfmt != 0x82) {
1356                 DEBUG_ERR("%s unknown reply data format\n", __func__);
1357                 rc = -EIO;
1358                 goto out;
1359         }
1360         if (rep_pl->data_len > *datasize) {
1361                 DEBUG_ERR("%s mismatch reply data len / data buffer len\n",
1362                           __func__);
1363                 rc = -ENOSPC;
1364                 goto out;
1365         }
1366
1367         /* copy the data from the cprb to the data buffer */
1368         memcpy(databuf, rep_pl->data, rep_pl->data_len);
1369         *datasize = rep_pl->data_len;
1370
1371 out:
1372         kfree(req);
1373         kfree(rep);
1374         kfree(urb);
1375         return rc;
1376 }
1377
1378 int ep11_clr2keyblob(u16 card, u16 domain, u32 keybitsize, u32 keygenflags,
1379                      const u8 *clrkey, u8 *keybuf, size_t *keybufsize,
1380                      u32 keytype)
1381 {
1382         int rc;
1383         u8 encbuf[64], *kek = NULL;
1384         size_t clrkeylen, keklen, encbuflen = sizeof(encbuf);
1385
1386         if (keybitsize == 128 || keybitsize == 192 || keybitsize == 256) {
1387                 clrkeylen = keybitsize / 8;
1388         } else {
1389                 DEBUG_ERR(
1390                         "%s unknown/unsupported keybitsize %d\n",
1391                         __func__, keybitsize);
1392                 return -EINVAL;
1393         }
1394
1395         /* allocate memory for the temp kek */
1396         keklen = MAXEP11AESKEYBLOBSIZE;
1397         kek = kmalloc(keklen, GFP_ATOMIC);
1398         if (!kek) {
1399                 rc = -ENOMEM;
1400                 goto out;
1401         }
1402
1403         /* Step 1: generate AES 256 bit random kek key */
1404         rc = _ep11_genaeskey(card, domain, 256,
1405                              0x00006c00, /* EN/DECRYPT, WRAP/UNWRAP */
1406                              kek, &keklen);
1407         if (rc) {
1408                 DEBUG_ERR(
1409                         "%s generate kek key failed, rc=%d\n",
1410                         __func__, rc);
1411                 goto out;
1412         }
1413
1414         /* Step 2: encrypt clear key value with the kek key */
1415         rc = ep11_cryptsingle(card, domain, 0, 0, def_iv, kek, keklen,
1416                               clrkey, clrkeylen, encbuf, &encbuflen);
1417         if (rc) {
1418                 DEBUG_ERR(
1419                         "%s encrypting key value with kek key failed, rc=%d\n",
1420                         __func__, rc);
1421                 goto out;
1422         }
1423
1424         /* Step 3: import the encrypted key value as a new key */
1425         rc = ep11_unwrapkey(card, domain, kek, keklen,
1426                             encbuf, encbuflen, 0, def_iv,
1427                             keybitsize, 0, keybuf, keybufsize, keytype);
1428         if (rc) {
1429                 DEBUG_ERR(
1430                         "%s importing key value as new key failed,, rc=%d\n",
1431                         __func__, rc);
1432                 goto out;
1433         }
1434
1435 out:
1436         kfree(kek);
1437         return rc;
1438 }
1439 EXPORT_SYMBOL(ep11_clr2keyblob);
1440
1441 int ep11_kblob2protkey(u16 card, u16 dom,
1442                        const u8 *keyblob, size_t keybloblen,
1443                        u8 *protkey, u32 *protkeylen, u32 *protkeytype)
1444 {
1445         struct ep11kblob_header *hdr;
1446         struct ep11keyblob *key;
1447         size_t wkbuflen, keylen;
1448         struct wk_info {
1449                 u16 version;
1450                 u8  res1[16];
1451                 u32 pkeytype;
1452                 u32 pkeybitsize;
1453                 u64 pkeysize;
1454                 u8  res2[8];
1455                 u8  pkey[];
1456         } __packed * wki;
1457         u8 *wkbuf = NULL;
1458         int rc = -EIO;
1459
1460         if (ep11_kb_decode((u8 *)keyblob, keybloblen, &hdr, NULL, &key, &keylen))
1461                 return -EINVAL;
1462
1463         if (hdr->version == TOKVER_EP11_AES) {
1464                 /* wipe overlayed header */
1465                 memset(hdr, 0, sizeof(*hdr));
1466         }
1467         /* !!! hdr is no longer a valid header !!! */
1468
1469         /* alloc temp working buffer */
1470         wkbuflen = (keylen + AES_BLOCK_SIZE) & (~(AES_BLOCK_SIZE - 1));
1471         wkbuf = kmalloc(wkbuflen, GFP_ATOMIC);
1472         if (!wkbuf)
1473                 return -ENOMEM;
1474
1475         /* ep11 secure key -> protected key + info */
1476         rc = _ep11_wrapkey(card, dom, (u8 *)key, keylen,
1477                            0, def_iv, wkbuf, &wkbuflen);
1478         if (rc) {
1479                 DEBUG_ERR(
1480                         "%s rewrapping ep11 key to pkey failed, rc=%d\n",
1481                         __func__, rc);
1482                 goto out;
1483         }
1484         wki = (struct wk_info *)wkbuf;
1485
1486         /* check struct version and pkey type */
1487         if (wki->version != 1 || wki->pkeytype < 1 || wki->pkeytype > 5) {
1488                 DEBUG_ERR("%s wk info version %d or pkeytype %d mismatch.\n",
1489                           __func__, (int)wki->version, (int)wki->pkeytype);
1490                 rc = -EIO;
1491                 goto out;
1492         }
1493
1494         /* check protected key type field */
1495         switch (wki->pkeytype) {
1496         case 1: /* AES */
1497                 switch (wki->pkeysize) {
1498                 case 16 + 32:
1499                         /* AES 128 protected key */
1500                         if (protkeytype)
1501                                 *protkeytype = PKEY_KEYTYPE_AES_128;
1502                         break;
1503                 case 24 + 32:
1504                         /* AES 192 protected key */
1505                         if (protkeytype)
1506                                 *protkeytype = PKEY_KEYTYPE_AES_192;
1507                         break;
1508                 case 32 + 32:
1509                         /* AES 256 protected key */
1510                         if (protkeytype)
1511                                 *protkeytype = PKEY_KEYTYPE_AES_256;
1512                         break;
1513                 default:
1514                         DEBUG_ERR("%s unknown/unsupported AES pkeysize %d\n",
1515                                   __func__, (int)wki->pkeysize);
1516                         rc = -EIO;
1517                         goto out;
1518                 }
1519                 break;
1520         case 3: /* EC-P */
1521         case 4: /* EC-ED */
1522         case 5: /* EC-BP */
1523                 if (protkeytype)
1524                         *protkeytype = PKEY_KEYTYPE_ECC;
1525                 break;
1526         case 2: /* TDES */
1527         default:
1528                 DEBUG_ERR("%s unknown/unsupported key type %d\n",
1529                           __func__, (int)wki->pkeytype);
1530                 rc = -EIO;
1531                 goto out;
1532         }
1533
1534         /* copy the translated protected key */
1535         if (wki->pkeysize > *protkeylen) {
1536                 DEBUG_ERR("%s wk info pkeysize %llu > protkeysize %u\n",
1537                           __func__, wki->pkeysize, *protkeylen);
1538                 rc = -EINVAL;
1539                 goto out;
1540         }
1541         memcpy(protkey, wki->pkey, wki->pkeysize);
1542         *protkeylen = wki->pkeysize;
1543
1544 out:
1545         kfree(wkbuf);
1546         return rc;
1547 }
1548 EXPORT_SYMBOL(ep11_kblob2protkey);
1549
1550 int ep11_findcard2(u32 **apqns, u32 *nr_apqns, u16 cardnr, u16 domain,
1551                    int minhwtype, int minapi, const u8 *wkvp)
1552 {
1553         struct zcrypt_device_status_ext *device_status;
1554         u32 *_apqns = NULL, _nr_apqns = 0;
1555         int i, card, dom, rc = -ENOMEM;
1556         struct ep11_domain_info edi;
1557         struct ep11_card_info eci;
1558
1559         /* fetch status of all crypto cards */
1560         device_status = kvmalloc_array(MAX_ZDEV_ENTRIES_EXT,
1561                                        sizeof(struct zcrypt_device_status_ext),
1562                                        GFP_KERNEL);
1563         if (!device_status)
1564                 return -ENOMEM;
1565         zcrypt_device_status_mask_ext(device_status);
1566
1567         /* allocate 1k space for up to 256 apqns */
1568         _apqns = kmalloc_array(256, sizeof(u32), GFP_KERNEL);
1569         if (!_apqns) {
1570                 kvfree(device_status);
1571                 return -ENOMEM;
1572         }
1573
1574         /* walk through all the crypto apqnss */
1575         for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
1576                 card = AP_QID_CARD(device_status[i].qid);
1577                 dom = AP_QID_QUEUE(device_status[i].qid);
1578                 /* check online state */
1579                 if (!device_status[i].online)
1580                         continue;
1581                 /* check for ep11 functions */
1582                 if (!(device_status[i].functions & 0x01))
1583                         continue;
1584                 /* check cardnr */
1585                 if (cardnr != 0xFFFF && card != cardnr)
1586                         continue;
1587                 /* check domain */
1588                 if (domain != 0xFFFF && dom != domain)
1589                         continue;
1590                 /* check min hardware type */
1591                 if (minhwtype && device_status[i].hwtype < minhwtype)
1592                         continue;
1593                 /* check min api version if given */
1594                 if (minapi > 0) {
1595                         if (ep11_get_card_info(card, &eci, 0))
1596                                 continue;
1597                         if (minapi > eci.API_ord_nr)
1598                                 continue;
1599                 }
1600                 /* check wkvp if given */
1601                 if (wkvp) {
1602                         if (ep11_get_domain_info(card, dom, &edi))
1603                                 continue;
1604                         if (edi.cur_wk_state != '1')
1605                                 continue;
1606                         if (memcmp(wkvp, edi.cur_wkvp, 16))
1607                                 continue;
1608                 }
1609                 /* apqn passed all filtering criterons, add to the array */
1610                 if (_nr_apqns < 256)
1611                         _apqns[_nr_apqns++] = (((u16)card) << 16) | ((u16)dom);
1612         }
1613
1614         /* nothing found ? */
1615         if (!_nr_apqns) {
1616                 kfree(_apqns);
1617                 rc = -ENODEV;
1618         } else {
1619                 /* no re-allocation, simple return the _apqns array */
1620                 *apqns = _apqns;
1621                 *nr_apqns = _nr_apqns;
1622                 rc = 0;
1623         }
1624
1625         kvfree(device_status);
1626         return rc;
1627 }
1628 EXPORT_SYMBOL(ep11_findcard2);
1629
1630 void __exit zcrypt_ep11misc_exit(void)
1631 {
1632         card_cache_free();
1633 }