drivers/s390/crypto/zcrypt_ccamisc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Copyright IBM Corp. 2019
   4  *  Author(s): Harald Freudenberger <freude@linux.ibm.com>
   5  *             Ingo Franzki <ifranzki@linux.ibm.com>
   6  *
   7  *  Collection of CCA misc functions used by zcrypt and pkey
   8  */
   9
  10 #define KMSG_COMPONENT "zcrypt"
  11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/random.h>
  17 #include <asm/zcrypt.h>
  18 #include <asm/pkey.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_ccamisc.h"
  25
  26 #define DEBUG_DBG(...)  ZCRYPT_DBF(DBF_DEBUG, ##__VA_ARGS__)
  27 #define DEBUG_INFO(...) ZCRYPT_DBF(DBF_INFO, ##__VA_ARGS__)
  28 #define DEBUG_WARN(...) ZCRYPT_DBF(DBF_WARN, ##__VA_ARGS__)
  29 #define DEBUG_ERR(...)  ZCRYPT_DBF(DBF_ERR, ##__VA_ARGS__)
  30
  31 /* Size of parameter block used for all cca requests/replies */
  32 #define PARMBSIZE 512
  33
  34 /* Size of vardata block used for some of the cca requests/replies */
  35 #define VARDATASIZE 4096
  36
  37 struct cca_info_list_entry {
  38         struct list_head list;
  39         u16 cardnr;
  40         u16 domain;
  41         struct cca_info info;
  42 };
  43
  44 /* a list with cca_info_list_entry entries */
  45 static LIST_HEAD(cca_info_list);
  46 static DEFINE_SPINLOCK(cca_info_list_lock);
  47
  48 /*
  49  * Simple check if the token is a valid CCA secure AES data key
  50  * token. If keybitsize is given, the bitsize of the key is
  51  * also checked. Returns 0 on success or errno value on failure.
  52  */
  53 int cca_check_secaeskeytoken(debug_info_t *dbg, int dbflvl,
  54                              const u8 *token, int keybitsize)
  55 {
  56         struct secaeskeytoken *t = (struct secaeskeytoken *) token;
  57
  58 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
  59
  60         if (t->type != TOKTYPE_CCA_INTERNAL) {
  61                 if (dbg)
  62                         DBF("%s token check failed, type 0x%02x != 0x%02x\n",
  63                             __func__, (int) t->type, TOKTYPE_CCA_INTERNAL);
  64                 return -EINVAL;
  65         }
  66         if (t->version != TOKVER_CCA_AES) {
  67                 if (dbg)
  68                         DBF("%s token check failed, version 0x%02x != 0x%02x\n",
  69                             __func__, (int) t->version, TOKVER_CCA_AES);
  70                 return -EINVAL;
  71         }
  72         if (keybitsize > 0 && t->bitsize != keybitsize) {
  73                 if (dbg)
  74                         DBF("%s token check failed, bitsize %d != %d\n",
  75                             __func__, (int) t->bitsize, keybitsize);
  76                 return -EINVAL;
  77         }
  78
  79 #undef DBF
  80
  81         return 0;
  82 }
  83 EXPORT_SYMBOL(cca_check_secaeskeytoken);
  84
  85 /*
  86  * Simple check if the token is a valid CCA secure AES cipher key
  87  * token. If keybitsize is given, the bitsize of the key is
  88  * also checked. If checkcpacfexport is enabled, the key is also
  89  * checked for the export flag to allow CPACF export.
  90  * Returns 0 on success or errno value on failure.
  91  */
  92 int cca_check_secaescipherkey(debug_info_t *dbg, int dbflvl,
  93                               const u8 *token, int keybitsize,
  94                               int checkcpacfexport)
  95 {
  96         struct cipherkeytoken *t = (struct cipherkeytoken *) token;
  97         bool keybitsizeok = true;
  98
  99 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 100
 101         if (t->type != TOKTYPE_CCA_INTERNAL) {
 102                 if (dbg)
 103                         DBF("%s token check failed, type 0x%02x != 0x%02x\n",
 104                             __func__, (int) t->type, TOKTYPE_CCA_INTERNAL);
 105                 return -EINVAL;
 106         }
 107         if (t->version != TOKVER_CCA_VLSC) {
 108                 if (dbg)
 109                         DBF("%s token check failed, version 0x%02x != 0x%02x\n",
 110                             __func__, (int) t->version, TOKVER_CCA_VLSC);
 111                 return -EINVAL;
 112         }
 113         if (t->algtype != 0x02) {
 114                 if (dbg)
 115                         DBF("%s token check failed, algtype 0x%02x != 0x02\n",
 116                             __func__, (int) t->algtype);
 117                 return -EINVAL;
 118         }
 119         if (t->keytype != 0x0001) {
 120                 if (dbg)
 121                         DBF("%s token check failed, keytype 0x%04x != 0x0001\n",
 122                             __func__, (int) t->keytype);
 123                 return -EINVAL;
 124         }
 125         if (t->plfver != 0x00 && t->plfver != 0x01) {
 126                 if (dbg)
 127                         DBF("%s token check failed, unknown plfver 0x%02x\n",
 128                             __func__, (int) t->plfver);
 129                 return -EINVAL;
 130         }
 131         if (t->wpllen != 512 && t->wpllen != 576 && t->wpllen != 640) {
 132                 if (dbg)
 133                         DBF("%s token check failed, unknown wpllen %d\n",
 134                             __func__, (int) t->wpllen);
 135                 return -EINVAL;
 136         }
 137         if (keybitsize > 0) {
 138                 switch (keybitsize) {
 139                 case 128:
 140                         if (t->wpllen != (t->plfver ? 640 : 512))
 141                                 keybitsizeok = false;
 142                         break;
 143                 case 192:
 144                         if (t->wpllen != (t->plfver ? 640 : 576))
 145                                 keybitsizeok = false;
 146                         break;
 147                 case 256:
 148                         if (t->wpllen != 640)
 149                                 keybitsizeok = false;
 150                         break;
 151                 default:
 152                         keybitsizeok = false;
 153                         break;
 154                 }
 155                 if (!keybitsizeok) {
 156                         if (dbg)
 157                                 DBF("%s token check failed, bitsize %d\n",
 158                                     __func__, keybitsize);
 159                         return -EINVAL;
 160                 }
 161         }
 162         if (checkcpacfexport && !(t->kmf1 & KMF1_XPRT_CPAC)) {
 163                 if (dbg)
 164                         DBF("%s token check failed, XPRT_CPAC bit is 0\n",
 165                             __func__);
 166                 return -EINVAL;
 167         }
 168
 169 #undef DBF
 170
 171         return 0;
 172 }
 173 EXPORT_SYMBOL(cca_check_secaescipherkey);
 174
 175 /*
 176  * Allocate consecutive memory for request CPRB, request param
 177  * block, reply CPRB and reply param block and fill in values
 178  * for the common fields. Returns 0 on success or errno value
 179  * on failure.
 180  */
 181 static int alloc_and_prep_cprbmem(size_t paramblen,
 182                                   u8 **pcprbmem,
 183                                   struct CPRBX **preqCPRB,
 184                                   struct CPRBX **prepCPRB)
 185 {
 186         u8 *cprbmem;
 187         size_t cprbplusparamblen = sizeof(struct CPRBX) + paramblen;
 188         struct CPRBX *preqcblk, *prepcblk;
 189
 190         /*
 191          * allocate consecutive memory for request CPRB, request param
 192          * block, reply CPRB and reply param block
 193          */
 194         cprbmem = kcalloc(2, cprbplusparamblen, GFP_KERNEL);
 195         if (!cprbmem)
 196                 return -ENOMEM;
 197
 198         preqcblk = (struct CPRBX *) cprbmem;
 199         prepcblk = (struct CPRBX *) (cprbmem + cprbplusparamblen);
 200
 201         /* fill request cprb struct */
 202         preqcblk->cprb_len = sizeof(struct CPRBX);
 203         preqcblk->cprb_ver_id = 0x02;
 204         memcpy(preqcblk->func_id, "T2", 2);
 205         preqcblk->rpl_msgbl = cprbplusparamblen;
 206         if (paramblen) {
 207                 preqcblk->req_parmb =
 208                         ((u8 __user *) preqcblk) + sizeof(struct CPRBX);
 209                 preqcblk->rpl_parmb =
 210                         ((u8 __user *) prepcblk) + sizeof(struct CPRBX);
 211         }
 212
 213         *pcprbmem = cprbmem;
 214         *preqCPRB = preqcblk;
 215         *prepCPRB = prepcblk;
 216
 217         return 0;
 218 }
 219
 220 /*
 221  * Free the cprb memory allocated with the function above.
 222  * If the scrub value is not zero, the memory is filled
 223  * with zeros before freeing (useful if there was some
 224  * clear key material in there).
 225  */
 226 static void free_cprbmem(void *mem, size_t paramblen, int scrub)
 227 {
 228         if (scrub)
 229                 memzero_explicit(mem, 2 * (sizeof(struct CPRBX) + paramblen));
 230         kfree(mem);
 231 }
 232
 233 /*
 234  * Helper function to prepare the xcrb struct
 235  */
 236 static inline void prep_xcrb(struct ica_xcRB *pxcrb,
 237                              u16 cardnr,
 238                              struct CPRBX *preqcblk,
 239                              struct CPRBX *prepcblk)
 240 {
 241         memset(pxcrb, 0, sizeof(*pxcrb));
 242         pxcrb->agent_ID = 0x4341; /* 'CA' */
 243         pxcrb->user_defined = (cardnr == 0xFFFF ? AUTOSELECT : cardnr);
 244         pxcrb->request_control_blk_length =
 245                 preqcblk->cprb_len + preqcblk->req_parml;
 246         pxcrb->request_control_blk_addr = (void __user *) preqcblk;
 247         pxcrb->reply_control_blk_length = preqcblk->rpl_msgbl;
 248         pxcrb->reply_control_blk_addr = (void __user *) prepcblk;
 249 }
 250
 251 /*
 252  * Generate (random) CCA AES DATA secure key.
 253  */
 254 int cca_genseckey(u16 cardnr, u16 domain,
 255                   u32 keybitsize, u8 seckey[SECKEYBLOBSIZE])
 256 {
 257         int i, rc, keysize;
 258         int seckeysize;
 259         u8 *mem, *ptr;
 260         struct CPRBX *preqcblk, *prepcblk;
 261         struct ica_xcRB xcrb;
 262         struct kgreqparm {
 263                 u8  subfunc_code[2];
 264                 u16 rule_array_len;
 265                 struct lv1 {
 266                         u16 len;
 267                         char  key_form[8];
 268                         char  key_length[8];
 269                         char  key_type1[8];
 270                         char  key_type2[8];
 271                 } lv1;
 272                 struct lv2 {
 273                         u16 len;
 274                         struct keyid {
 275                                 u16 len;
 276                                 u16 attr;
 277                                 u8  data[SECKEYBLOBSIZE];
 278                         } keyid[6];
 279                 } lv2;
 280         } __packed * preqparm;
 281         struct kgrepparm {
 282                 u8  subfunc_code[2];
 283                 u16 rule_array_len;
 284                 struct lv3 {
 285                         u16 len;
 286                         u16 keyblocklen;
 287                         struct {
 288                                 u16 toklen;
 289                                 u16 tokattr;
 290                                 u8  tok[0];
 291                                 /* ... some more data ... */
 292                         } keyblock;
 293                 } lv3;
 294         } __packed * prepparm;
 295
 296         /* get already prepared memory for 2 cprbs with param block each */
 297         rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
 298         if (rc)
 299                 return rc;
 300
 301         /* fill request cprb struct */
 302         preqcblk->domain = domain;
 303
 304         /* fill request cprb param block with KG request */
 305         preqparm = (struct kgreqparm __force *) preqcblk->req_parmb;
 306         memcpy(preqparm->subfunc_code, "KG", 2);
 307         preqparm->rule_array_len = sizeof(preqparm->rule_array_len);
 308         preqparm->lv1.len = sizeof(struct lv1);
 309         memcpy(preqparm->lv1.key_form,   "OP      ", 8);
 310         switch (keybitsize) {
 311         case PKEY_SIZE_AES_128:
 312         case PKEY_KEYTYPE_AES_128: /* older ioctls used this */
 313                 keysize = 16;
 314                 memcpy(preqparm->lv1.key_length, "KEYLN16 ", 8);
 315                 break;
 316         case PKEY_SIZE_AES_192:
 317         case PKEY_KEYTYPE_AES_192: /* older ioctls used this */
 318                 keysize = 24;
 319                 memcpy(preqparm->lv1.key_length, "KEYLN24 ", 8);
 320                 break;
 321         case PKEY_SIZE_AES_256:
 322         case PKEY_KEYTYPE_AES_256: /* older ioctls used this */
 323                 keysize = 32;
 324                 memcpy(preqparm->lv1.key_length, "KEYLN32 ", 8);
 325                 break;
 326         default:
 327                 DEBUG_ERR("%s unknown/unsupported keybitsize %d\n",
 328                           __func__, keybitsize);
 329                 rc = -EINVAL;
 330                 goto out;
 331         }
 332         memcpy(preqparm->lv1.key_type1,  "AESDATA ", 8);
 333         preqparm->lv2.len = sizeof(struct lv2);
 334         for (i = 0; i < 6; i++) {
 335                 preqparm->lv2.keyid[i].len = sizeof(struct keyid);
 336                 preqparm->lv2.keyid[i].attr = (i == 2 ? 0x30 : 0x10);
 337         }
 338         preqcblk->req_parml = sizeof(struct kgreqparm);
 339
 340         /* fill xcrb struct */
 341         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
 342
 343         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
 344         rc = zcrypt_send_cprb(&xcrb);
 345         if (rc) {
 346                 DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, errno %d\n",
 347                           __func__, (int) cardnr, (int) domain, rc);
 348                 goto out;
 349         }
 350
 351         /* check response returncode and reasoncode */
 352         if (prepcblk->ccp_rtcode != 0) {
 353                 DEBUG_ERR("%s secure key generate failure, card response %d/%d\n",
 354                           __func__,
 355                           (int) prepcblk->ccp_rtcode,
 356                           (int) prepcblk->ccp_rscode);
 357                 rc = -EIO;
 358                 goto out;
 359         }
 360
 361         /* process response cprb param block */
 362         ptr =  ((u8 *) prepcblk) + sizeof(struct CPRBX);
 363         prepcblk->rpl_parmb = (u8 __user *) ptr;
 364         prepparm = (struct kgrepparm *) ptr;
 365
 366         /* check length of the returned secure key token */
 367         seckeysize = prepparm->lv3.keyblock.toklen
 368                 - sizeof(prepparm->lv3.keyblock.toklen)
 369                 - sizeof(prepparm->lv3.keyblock.tokattr);
 370         if (seckeysize != SECKEYBLOBSIZE) {
 371                 DEBUG_ERR("%s secure token size mismatch %d != %d bytes\n",
 372                           __func__, seckeysize, SECKEYBLOBSIZE);
 373                 rc = -EIO;
 374                 goto out;
 375         }
 376
 377         /* check secure key token */
 378         rc = cca_check_secaeskeytoken(zcrypt_dbf_info, DBF_ERR,
 379                                       prepparm->lv3.keyblock.tok, 8*keysize);
 380         if (rc) {
 381                 rc = -EIO;
 382                 goto out;
 383         }
 384
 385         /* copy the generated secure key token */
 386         memcpy(seckey, prepparm->lv3.keyblock.tok, SECKEYBLOBSIZE);
 387
 388 out:
 389         free_cprbmem(mem, PARMBSIZE, 0);
 390         return rc;
 391 }
 392 EXPORT_SYMBOL(cca_genseckey);
 393
 394 /*
 395  * Generate an CCA AES DATA secure key with given key value.
 396  */
 397 int cca_clr2seckey(u16 cardnr, u16 domain, u32 keybitsize,
 398                    const u8 *clrkey, u8 seckey[SECKEYBLOBSIZE])
 399 {
 400         int rc, keysize, seckeysize;
 401         u8 *mem, *ptr;
 402         struct CPRBX *preqcblk, *prepcblk;
 403         struct ica_xcRB xcrb;
 404         struct cmreqparm {
 405                 u8  subfunc_code[2];
 406                 u16 rule_array_len;
 407                 char  rule_array[8];
 408                 struct lv1 {
 409                         u16 len;
 410                         u8  clrkey[0];
 411                 } lv1;
 412                 struct lv2 {
 413                         u16 len;
 414                         struct keyid {
 415                                 u16 len;
 416                                 u16 attr;
 417                                 u8  data[SECKEYBLOBSIZE];
 418                         } keyid;
 419                 } lv2;
 420         } __packed * preqparm;
 421         struct lv2 *plv2;
 422         struct cmrepparm {
 423                 u8  subfunc_code[2];
 424                 u16 rule_array_len;
 425                 struct lv3 {
 426                         u16 len;
 427                         u16 keyblocklen;
 428                         struct {
 429                                 u16 toklen;
 430                                 u16 tokattr;
 431                                 u8  tok[0];
 432                                 /* ... some more data ... */
 433                         } keyblock;
 434                 } lv3;
 435         } __packed * prepparm;
 436
 437         /* get already prepared memory for 2 cprbs with param block each */
 438         rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
 439         if (rc)
 440                 return rc;
 441
 442         /* fill request cprb struct */
 443         preqcblk->domain = domain;
 444
 445         /* fill request cprb param block with CM request */
 446         preqparm = (struct cmreqparm __force *) preqcblk->req_parmb;
 447         memcpy(preqparm->subfunc_code, "CM", 2);
 448         memcpy(preqparm->rule_array, "AES     ", 8);
 449         preqparm->rule_array_len =
 450                 sizeof(preqparm->rule_array_len) + sizeof(preqparm->rule_array);
 451         switch (keybitsize) {
 452         case PKEY_SIZE_AES_128:
 453         case PKEY_KEYTYPE_AES_128: /* older ioctls used this */
 454                 keysize = 16;
 455                 break;
 456         case PKEY_SIZE_AES_192:
 457         case PKEY_KEYTYPE_AES_192: /* older ioctls used this */
 458                 keysize = 24;
 459                 break;
 460         case PKEY_SIZE_AES_256:
 461         case PKEY_KEYTYPE_AES_256: /* older ioctls used this */
 462                 keysize = 32;
 463                 break;
 464         default:
 465                 DEBUG_ERR("%s unknown/unsupported keybitsize %d\n",
 466                           __func__, keybitsize);
 467                 rc = -EINVAL;
 468                 goto out;
 469         }
 470         preqparm->lv1.len = sizeof(struct lv1) + keysize;
 471         memcpy(preqparm->lv1.clrkey, clrkey, keysize);
 472         plv2 = (struct lv2 *) (((u8 *) &preqparm->lv2) + keysize);
 473         plv2->len = sizeof(struct lv2);
 474         plv2->keyid.len = sizeof(struct keyid);
 475         plv2->keyid.attr = 0x30;
 476         preqcblk->req_parml = sizeof(struct cmreqparm) + keysize;
 477
 478         /* fill xcrb struct */
 479         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
 480
 481         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
 482         rc = zcrypt_send_cprb(&xcrb);
 483         if (rc) {
 484                 DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
 485                           __func__, (int) cardnr, (int) domain, rc);
 486                 goto out;
 487         }
 488
 489         /* check response returncode and reasoncode */
 490         if (prepcblk->ccp_rtcode != 0) {
 491                 DEBUG_ERR("%s clear key import failure, card response %d/%d\n",
 492                           __func__,
 493                           (int) prepcblk->ccp_rtcode,
 494                           (int) prepcblk->ccp_rscode);
 495                 rc = -EIO;
 496                 goto out;
 497         }
 498
 499         /* process response cprb param block */
 500         ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
 501         prepcblk->rpl_parmb = (u8 __user *) ptr;
 502         prepparm = (struct cmrepparm *) ptr;
 503
 504         /* check length of the returned secure key token */
 505         seckeysize = prepparm->lv3.keyblock.toklen
 506                 - sizeof(prepparm->lv3.keyblock.toklen)
 507                 - sizeof(prepparm->lv3.keyblock.tokattr);
 508         if (seckeysize != SECKEYBLOBSIZE) {
 509                 DEBUG_ERR("%s secure token size mismatch %d != %d bytes\n",
 510                           __func__, seckeysize, SECKEYBLOBSIZE);
 511                 rc = -EIO;
 512                 goto out;
 513         }
 514
 515         /* check secure key token */
 516         rc = cca_check_secaeskeytoken(zcrypt_dbf_info, DBF_ERR,
 517                                       prepparm->lv3.keyblock.tok, 8*keysize);
 518         if (rc) {
 519                 rc = -EIO;
 520                 goto out;
 521         }
 522
 523         /* copy the generated secure key token */
 524         if (seckey)
 525                 memcpy(seckey, prepparm->lv3.keyblock.tok, SECKEYBLOBSIZE);
 526
 527 out:
 528         free_cprbmem(mem, PARMBSIZE, 1);
 529         return rc;
 530 }
 531 EXPORT_SYMBOL(cca_clr2seckey);
 532
 533 /*
 534  * Derive proteced key from an CCA AES DATA secure key.
 535  */
 536 int cca_sec2protkey(u16 cardnr, u16 domain,
 537                     const u8 seckey[SECKEYBLOBSIZE],
 538                     u8 *protkey, u32 *protkeylen, u32 *protkeytype)
 539 {
 540         int rc;
 541         u8 *mem, *ptr;
 542         struct CPRBX *preqcblk, *prepcblk;
 543         struct ica_xcRB xcrb;
 544         struct uskreqparm {
 545                 u8  subfunc_code[2];
 546                 u16 rule_array_len;
 547                 struct lv1 {
 548                         u16 len;
 549                         u16 attr_len;
 550                         u16 attr_flags;
 551                 } lv1;
 552                 struct lv2 {
 553                         u16 len;
 554                         u16 attr_len;
 555                         u16 attr_flags;
 556                         u8  token[0];         /* cca secure key token */
 557                 } lv2;
 558         } __packed * preqparm;
 559         struct uskrepparm {
 560                 u8  subfunc_code[2];
 561                 u16 rule_array_len;
 562                 struct lv3 {
 563                         u16 len;
 564                         u16 attr_len;
 565                         u16 attr_flags;
 566                         struct cpacfkeyblock {
 567                                 u8  version;  /* version of this struct */
 568                                 u8  flags[2];
 569                                 u8  algo;
 570                                 u8  form;
 571                                 u8  pad1[3];
 572                                 u16 len;
 573                                 u8  key[64];  /* the key (len bytes) */
 574                                 u16 keyattrlen;
 575                                 u8  keyattr[32];
 576                                 u8  pad2[1];
 577                                 u8  vptype;
 578                                 u8  vp[32];  /* verification pattern */
 579                         } ckb;
 580                 } lv3;
 581         } __packed * prepparm;
 582
 583         /* get already prepared memory for 2 cprbs with param block each */
 584         rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
 585         if (rc)
 586                 return rc;
 587
 588         /* fill request cprb struct */
 589         preqcblk->domain = domain;
 590
 591         /* fill request cprb param block with USK request */
 592         preqparm = (struct uskreqparm __force *) preqcblk->req_parmb;
 593         memcpy(preqparm->subfunc_code, "US", 2);
 594         preqparm->rule_array_len = sizeof(preqparm->rule_array_len);
 595         preqparm->lv1.len = sizeof(struct lv1);
 596         preqparm->lv1.attr_len = sizeof(struct lv1) - sizeof(preqparm->lv1.len);
 597         preqparm->lv1.attr_flags = 0x0001;
 598         preqparm->lv2.len = sizeof(struct lv2) + SECKEYBLOBSIZE;
 599         preqparm->lv2.attr_len = sizeof(struct lv2)
 600                 - sizeof(preqparm->lv2.len) + SECKEYBLOBSIZE;
 601         preqparm->lv2.attr_flags = 0x0000;
 602         memcpy(preqparm->lv2.token, seckey, SECKEYBLOBSIZE);
 603         preqcblk->req_parml = sizeof(struct uskreqparm) + SECKEYBLOBSIZE;
 604
 605         /* fill xcrb struct */
 606         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
 607
 608         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
 609         rc = zcrypt_send_cprb(&xcrb);
 610         if (rc) {
 611                 DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
 612                           __func__, (int) cardnr, (int) domain, rc);
 613                 goto out;
 614         }
 615
 616         /* check response returncode and reasoncode */
 617         if (prepcblk->ccp_rtcode != 0) {
 618                 DEBUG_ERR("%s unwrap secure key failure, card response %d/%d\n",
 619                           __func__,
 620                           (int) prepcblk->ccp_rtcode,
 621                           (int) prepcblk->ccp_rscode);
 622                 rc = -EIO;
 623                 goto out;
 624         }
 625         if (prepcblk->ccp_rscode != 0) {
 626                 DEBUG_WARN("%s unwrap secure key warning, card response %d/%d\n",
 627                            __func__,
 628                            (int) prepcblk->ccp_rtcode,
 629                            (int) prepcblk->ccp_rscode);
 630         }
 631
 632         /* process response cprb param block */
 633         ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
 634         prepcblk->rpl_parmb = (u8 __user *) ptr;
 635         prepparm = (struct uskrepparm *) ptr;
 636
 637         /* check the returned keyblock */
 638         if (prepparm->lv3.ckb.version != 0x01 &&
 639             prepparm->lv3.ckb.version != 0x02) {
 640                 DEBUG_ERR("%s reply param keyblock version mismatch 0x%02x\n",
 641                           __func__, (int) prepparm->lv3.ckb.version);
 642                 rc = -EIO;
 643                 goto out;
 644         }
 645
 646         /* copy the tanslated protected key */
 647         switch (prepparm->lv3.ckb.len) {
 648         case 16+32:
 649                 /* AES 128 protected key */
 650                 if (protkeytype)
 651                         *protkeytype = PKEY_KEYTYPE_AES_128;
 652                 break;
 653         case 24+32:
 654                 /* AES 192 protected key */
 655                 if (protkeytype)
 656                         *protkeytype = PKEY_KEYTYPE_AES_192;
 657                 break;
 658         case 32+32:
 659                 /* AES 256 protected key */
 660                 if (protkeytype)
 661                         *protkeytype = PKEY_KEYTYPE_AES_256;
 662                 break;
 663         default:
 664                 DEBUG_ERR("%s unknown/unsupported keylen %d\n",
 665                           __func__, prepparm->lv3.ckb.len);
 666                 rc = -EIO;
 667                 goto out;
 668         }
 669         memcpy(protkey, prepparm->lv3.ckb.key, prepparm->lv3.ckb.len);
 670         if (protkeylen)
 671                 *protkeylen = prepparm->lv3.ckb.len;
 672
 673 out:
 674         free_cprbmem(mem, PARMBSIZE, 0);
 675         return rc;
 676 }
 677 EXPORT_SYMBOL(cca_sec2protkey);
 678
 679 /*
 680  * AES cipher key skeleton created with CSNBKTB2 with these flags:
 681  * INTERNAL, NO-KEY, AES, CIPHER, ANY-MODE, NOEX-SYM, NOEXAASY,
 682  * NOEXUASY, XPRTCPAC, NOEX-RAW, NOEX-DES, NOEX-AES, NOEX-RSA
 683  * used by cca_gencipherkey() and cca_clr2cipherkey().
 684  */
 685 static const u8 aes_cipher_key_skeleton[] = {
 686         0x01, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00,
 687         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 688         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 689         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
 690         0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 691         0x00, 0x02, 0x00, 0x01, 0x02, 0xc0, 0x00, 0xff,
 692         0x00, 0x03, 0x08, 0xc8, 0x00, 0x00, 0x00, 0x00 };
 693 #define SIZEOF_SKELETON (sizeof(aes_cipher_key_skeleton))
 694
 695 /*
 696  * Generate (random) CCA AES CIPHER secure key.
 697  */
 698 int cca_gencipherkey(u16 cardnr, u16 domain, u32 keybitsize, u32 keygenflags,
 699                      u8 *keybuf, size_t *keybufsize)
 700 {
 701         int rc;
 702         u8 *mem, *ptr;
 703         struct CPRBX *preqcblk, *prepcblk;
 704         struct ica_xcRB xcrb;
 705         struct gkreqparm {
 706                 u8  subfunc_code[2];
 707                 u16 rule_array_len;
 708                 char rule_array[2*8];
 709                 struct {
 710                         u16 len;
 711                         u8  key_type_1[8];
 712                         u8  key_type_2[8];
 713                         u16 clear_key_bit_len;
 714                         u16 key_name_1_len;
 715                         u16 key_name_2_len;
 716                         u16 user_data_1_len;
 717                         u16 user_data_2_len;
 718                         u8  key_name_1[0];
 719                         u8  key_name_2[0];
 720                         u8  user_data_1[0];
 721                         u8  user_data_2[0];
 722                 } vud;
 723                 struct {
 724                         u16 len;
 725                         struct {
 726                                 u16 len;
 727                                 u16 flag;
 728                                 u8  kek_id_1[0];
 729                         } tlv1;
 730                         struct {
 731                                 u16 len;
 732                                 u16 flag;
 733                                 u8  kek_id_2[0];
 734                         } tlv2;
 735                         struct {
 736                                 u16 len;
 737                                 u16 flag;
 738                                 u8  gen_key_id_1[SIZEOF_SKELETON];
 739                         } tlv3;
 740                         struct {
 741                                 u16 len;
 742                                 u16 flag;
 743                                 u8  gen_key_id_1_label[0];
 744                         } tlv4;
 745                         struct {
 746                                 u16 len;
 747                                 u16 flag;
 748                                 u8  gen_key_id_2[0];
 749                         } tlv5;
 750                         struct {
 751                                 u16 len;
 752                                 u16 flag;
 753                                 u8  gen_key_id_2_label[0];
 754                         } tlv6;
 755                 } kb;
 756         } __packed * preqparm;
 757         struct gkrepparm {
 758                 u8  subfunc_code[2];
 759                 u16 rule_array_len;
 760                 struct {
 761                         u16 len;
 762                 } vud;
 763                 struct {
 764                         u16 len;
 765                         struct {
 766                                 u16 len;
 767                                 u16 flag;
 768                                 u8  gen_key[0]; /* 120-136 bytes */
 769                         } tlv1;
 770                 } kb;
 771         } __packed * prepparm;
 772         struct cipherkeytoken *t;
 773
 774         /* get already prepared memory for 2 cprbs with param block each */
 775         rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
 776         if (rc)
 777                 return rc;
 778
 779         /* fill request cprb struct */
 780         preqcblk->domain = domain;
 781         preqcblk->req_parml = sizeof(struct gkreqparm);
 782
 783         /* prepare request param block with GK request */
 784         preqparm = (struct gkreqparm __force *) preqcblk->req_parmb;
 785         memcpy(preqparm->subfunc_code, "GK", 2);
 786         preqparm->rule_array_len =  sizeof(uint16_t) + 2 * 8;
 787         memcpy(preqparm->rule_array, "AES     OP      ", 2*8);
 788
 789         /* prepare vud block */
 790         preqparm->vud.len = sizeof(preqparm->vud);
 791         switch (keybitsize) {
 792         case 128:
 793         case 192:
 794         case 256:
 795                 break;
 796         default:
 797                 DEBUG_ERR(
 798                         "%s unknown/unsupported keybitsize %d\n",
 799                         __func__, keybitsize);
 800                 rc = -EINVAL;
 801                 goto out;
 802         }
 803         preqparm->vud.clear_key_bit_len = keybitsize;
 804         memcpy(preqparm->vud.key_type_1, "TOKEN   ", 8);
 805         memset(preqparm->vud.key_type_2, ' ', sizeof(preqparm->vud.key_type_2));
 806
 807         /* prepare kb block */
 808         preqparm->kb.len = sizeof(preqparm->kb);
 809         preqparm->kb.tlv1.len = sizeof(preqparm->kb.tlv1);
 810         preqparm->kb.tlv1.flag = 0x0030;
 811         preqparm->kb.tlv2.len = sizeof(preqparm->kb.tlv2);
 812         preqparm->kb.tlv2.flag = 0x0030;
 813         preqparm->kb.tlv3.len = sizeof(preqparm->kb.tlv3);
 814         preqparm->kb.tlv3.flag = 0x0030;
 815         memcpy(preqparm->kb.tlv3.gen_key_id_1,
 816                aes_cipher_key_skeleton, SIZEOF_SKELETON);
 817         preqparm->kb.tlv4.len = sizeof(preqparm->kb.tlv4);
 818         preqparm->kb.tlv4.flag = 0x0030;
 819         preqparm->kb.tlv5.len = sizeof(preqparm->kb.tlv5);
 820         preqparm->kb.tlv5.flag = 0x0030;
 821         preqparm->kb.tlv6.len = sizeof(preqparm->kb.tlv6);
 822         preqparm->kb.tlv6.flag = 0x0030;
 823
 824         /* patch the skeleton key token export flags inside the kb block */
 825         if (keygenflags) {
 826                 t = (struct cipherkeytoken *) preqparm->kb.tlv3.gen_key_id_1;
 827                 t->kmf1 |= (u16) (keygenflags & 0x0000FF00);
 828                 t->kmf1 &= (u16) ~(keygenflags & 0x000000FF);
 829         }
 830
 831         /* prepare xcrb struct */
 832         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
 833
 834         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
 835         rc = zcrypt_send_cprb(&xcrb);
 836         if (rc) {
 837                 DEBUG_ERR(
 838                         "%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
 839                         __func__, (int) cardnr, (int) domain, rc);
 840                 goto out;
 841         }
 842
 843         /* check response returncode and reasoncode */
 844         if (prepcblk->ccp_rtcode != 0) {
 845                 DEBUG_ERR(
 846                         "%s cipher key generate failure, card response %d/%d\n",
 847                         __func__,
 848                         (int) prepcblk->ccp_rtcode,
 849                         (int) prepcblk->ccp_rscode);
 850                 rc = -EIO;
 851                 goto out;
 852         }
 853
 854         /* process response cprb param block */
 855         ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
 856         prepcblk->rpl_parmb = (u8 __user *) ptr;
 857         prepparm = (struct gkrepparm *) ptr;
 858
 859         /* do some plausibility checks on the key block */
 860         if (prepparm->kb.len < 120 + 5 * sizeof(uint16_t) ||
 861             prepparm->kb.len > 136 + 5 * sizeof(uint16_t)) {
 862                 DEBUG_ERR("%s reply with invalid or unknown key block\n",
 863                           __func__);
 864                 rc = -EIO;
 865                 goto out;
 866         }
 867
 868         /* and some checks on the generated key */
 869         rc = cca_check_secaescipherkey(zcrypt_dbf_info, DBF_ERR,
 870                                        prepparm->kb.tlv1.gen_key,
 871                                        keybitsize, 1);
 872         if (rc) {
 873                 rc = -EIO;
 874                 goto out;
 875         }
 876
 877         /* copy the generated vlsc key token */
 878         t = (struct cipherkeytoken *) prepparm->kb.tlv1.gen_key;
 879         if (keybuf) {
 880                 if (*keybufsize >= t->len)
 881                         memcpy(keybuf, t, t->len);
 882                 else
 883                         rc = -EINVAL;
 884         }
 885         *keybufsize = t->len;
 886
 887 out:
 888         free_cprbmem(mem, PARMBSIZE, 0);
 889         return rc;
 890 }
 891 EXPORT_SYMBOL(cca_gencipherkey);
 892
 893 /*
 894  * Helper function, does a the CSNBKPI2 CPRB.
 895  */
 896 static int _ip_cprb_helper(u16 cardnr, u16 domain,
 897                            const char *rule_array_1,
 898                            const char *rule_array_2,
 899                            const char *rule_array_3,
 900                            const u8 *clr_key_value,
 901                            int clr_key_bit_size,
 902                            u8 *key_token,
 903                            int *key_token_size)
 904 {
 905         int rc, n;
 906         u8 *mem, *ptr;
 907         struct CPRBX *preqcblk, *prepcblk;
 908         struct ica_xcRB xcrb;
 909         struct rule_array_block {
 910                 u8  subfunc_code[2];
 911                 u16 rule_array_len;
 912                 char rule_array[0];
 913         } __packed * preq_ra_block;
 914         struct vud_block {
 915                 u16 len;
 916                 struct {
 917                         u16 len;
 918                         u16 flag;            /* 0x0064 */
 919                         u16 clr_key_bit_len;
 920                 } tlv1;
 921                 struct {
 922                         u16 len;
 923                         u16 flag;       /* 0x0063 */
 924                         u8  clr_key[0]; /* clear key value bytes */
 925                 } tlv2;
 926         } __packed * preq_vud_block;
 927         struct key_block {
 928                 u16 len;
 929                 struct {
 930                         u16 len;
 931                         u16 flag;         /* 0x0030 */
 932                         u8  key_token[0]; /* key skeleton */
 933                 } tlv1;
 934         } __packed * preq_key_block;
 935         struct iprepparm {
 936                 u8  subfunc_code[2];
 937                 u16 rule_array_len;
 938                 struct {
 939                         u16 len;
 940                 } vud;
 941                 struct {
 942                         u16 len;
 943                         struct {
 944                                 u16 len;
 945                                 u16 flag;         /* 0x0030 */
 946                                 u8  key_token[0]; /* key token */
 947                         } tlv1;
 948                 } kb;
 949         } __packed * prepparm;
 950         struct cipherkeytoken *t;
 951         int complete = strncmp(rule_array_2, "COMPLETE", 8) ? 0 : 1;
 952
 953         /* get already prepared memory for 2 cprbs with param block each */
 954         rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
 955         if (rc)
 956                 return rc;
 957
 958         /* fill request cprb struct */
 959         preqcblk->domain = domain;
 960         preqcblk->req_parml = 0;
 961
 962         /* prepare request param block with IP request */
 963         preq_ra_block = (struct rule_array_block __force *) preqcblk->req_parmb;
 964         memcpy(preq_ra_block->subfunc_code, "IP", 2);
 965         preq_ra_block->rule_array_len =  sizeof(uint16_t) + 2 * 8;
 966         memcpy(preq_ra_block->rule_array, rule_array_1, 8);
 967         memcpy(preq_ra_block->rule_array + 8, rule_array_2, 8);
 968         preqcblk->req_parml = sizeof(struct rule_array_block) + 2 * 8;
 969         if (rule_array_3) {
 970                 preq_ra_block->rule_array_len += 8;
 971                 memcpy(preq_ra_block->rule_array + 16, rule_array_3, 8);
 972                 preqcblk->req_parml += 8;
 973         }
 974
 975         /* prepare vud block */
 976         preq_vud_block = (struct vud_block __force *)
 977                 (preqcblk->req_parmb + preqcblk->req_parml);
 978         n = complete ? 0 : (clr_key_bit_size + 7) / 8;
 979         preq_vud_block->len = sizeof(struct vud_block) + n;
 980         preq_vud_block->tlv1.len = sizeof(preq_vud_block->tlv1);
 981         preq_vud_block->tlv1.flag = 0x0064;
 982         preq_vud_block->tlv1.clr_key_bit_len = complete ? 0 : clr_key_bit_size;
 983         preq_vud_block->tlv2.len = sizeof(preq_vud_block->tlv2) + n;
 984         preq_vud_block->tlv2.flag = 0x0063;
 985         if (!complete)
 986                 memcpy(preq_vud_block->tlv2.clr_key, clr_key_value, n);
 987         preqcblk->req_parml += preq_vud_block->len;
 988
 989         /* prepare key block */
 990         preq_key_block = (struct key_block __force *)
 991                 (preqcblk->req_parmb + preqcblk->req_parml);
 992         n = *key_token_size;
 993         preq_key_block->len = sizeof(struct key_block) + n;
 994         preq_key_block->tlv1.len = sizeof(preq_key_block->tlv1) + n;
 995         preq_key_block->tlv1.flag = 0x0030;
 996         memcpy(preq_key_block->tlv1.key_token, key_token, *key_token_size);
 997         preqcblk->req_parml += preq_key_block->len;
 998
 999         /* prepare xcrb struct */
1000         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
1001
1002         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
1003         rc = zcrypt_send_cprb(&xcrb);
1004         if (rc) {
1005                 DEBUG_ERR(
1006                         "%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
1007                         __func__, (int) cardnr, (int) domain, rc);
1008                 goto out;
1009         }
1010
1011         /* check response returncode and reasoncode */
1012         if (prepcblk->ccp_rtcode != 0) {
1013                 DEBUG_ERR(
1014                         "%s CSNBKPI2 failure, card response %d/%d\n",
1015                         __func__,
1016                         (int) prepcblk->ccp_rtcode,
1017                         (int) prepcblk->ccp_rscode);
1018                 rc = -EIO;
1019                 goto out;
1020         }
1021
1022         /* process response cprb param block */
1023         ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
1024         prepcblk->rpl_parmb = (u8 __user *) ptr;
1025         prepparm = (struct iprepparm *) ptr;
1026
1027         /* do some plausibility checks on the key block */
1028         if (prepparm->kb.len < 120 + 3 * sizeof(uint16_t) ||
1029             prepparm->kb.len > 136 + 3 * sizeof(uint16_t)) {
1030                 DEBUG_ERR("%s reply with invalid or unknown key block\n",
1031                           __func__);
1032                 rc = -EIO;
1033                 goto out;
1034         }
1035
1036         /* do not check the key here, it may be incomplete */
1037
1038         /* copy the vlsc key token back */
1039         t = (struct cipherkeytoken *) prepparm->kb.tlv1.key_token;
1040         memcpy(key_token, t, t->len);
1041         *key_token_size = t->len;
1042
1043 out:
1044         free_cprbmem(mem, PARMBSIZE, 0);
1045         return rc;
1046 }
1047
1048 /*
1049  * Build CCA AES CIPHER secure key with a given clear key value.
1050  */
1051 int cca_clr2cipherkey(u16 card, u16 dom, u32 keybitsize, u32 keygenflags,
1052                       const u8 *clrkey, u8 *keybuf, size_t *keybufsize)
1053 {
1054         int rc;
1055         u8 *token;
1056         int tokensize;
1057         u8 exorbuf[32];
1058         struct cipherkeytoken *t;
1059
1060         /* fill exorbuf with random data */
1061         get_random_bytes(exorbuf, sizeof(exorbuf));
1062
1063         /* allocate space for the key token to build */
1064         token = kmalloc(MAXCCAVLSCTOKENSIZE, GFP_KERNEL);
1065         if (!token)
1066                 return -ENOMEM;
1067
1068         /* prepare the token with the key skeleton */
1069         tokensize = SIZEOF_SKELETON;
1070         memcpy(token, aes_cipher_key_skeleton, tokensize);
1071
1072         /* patch the skeleton key token export flags */
1073         if (keygenflags) {
1074                 t = (struct cipherkeytoken *) token;
1075                 t->kmf1 |= (u16) (keygenflags & 0x0000FF00);
1076                 t->kmf1 &= (u16) ~(keygenflags & 0x000000FF);
1077         }
1078
1079         /*
1080          * Do the key import with the clear key value in 4 steps:
1081          * 1/4 FIRST import with only random data
1082          * 2/4 EXOR the clear key
1083          * 3/4 EXOR the very same random data again
1084          * 4/4 COMPLETE the secure cipher key import
1085          */
1086         rc = _ip_cprb_helper(card, dom, "AES     ", "FIRST   ", "MIN3PART",
1087                              exorbuf, keybitsize, token, &tokensize);
1088         if (rc) {
1089                 DEBUG_ERR(
1090                         "%s clear key import 1/4 with CSNBKPI2 failed, rc=%d\n",
1091                         __func__, rc);
1092                 goto out;
1093         }
1094         rc = _ip_cprb_helper(card, dom, "AES     ", "ADD-PART", NULL,
1095                              clrkey, keybitsize, token, &tokensize);
1096         if (rc) {
1097                 DEBUG_ERR(
1098                         "%s clear key import 2/4 with CSNBKPI2 failed, rc=%d\n",
1099                         __func__, rc);
1100                 goto out;
1101         }
1102         rc = _ip_cprb_helper(card, dom, "AES     ", "ADD-PART", NULL,
1103                              exorbuf, keybitsize, token, &tokensize);
1104         if (rc) {
1105                 DEBUG_ERR(
1106                         "%s clear key import 3/4 with CSNBKPI2 failed, rc=%d\n",
1107                         __func__, rc);
1108                 goto out;
1109         }
1110         rc = _ip_cprb_helper(card, dom, "AES     ", "COMPLETE", NULL,
1111                              NULL, keybitsize, token, &tokensize);
1112         if (rc) {
1113                 DEBUG_ERR(
1114                         "%s clear key import 4/4 with CSNBKPI2 failed, rc=%d\n",
1115                         __func__, rc);
1116                 goto out;
1117         }
1118
1119         /* copy the generated key token */
1120         if (keybuf) {
1121                 if (tokensize > *keybufsize)
1122                         rc = -EINVAL;
1123                 else
1124                         memcpy(keybuf, token, tokensize);
1125         }
1126         *keybufsize = tokensize;
1127
1128 out:
1129         kfree(token);
1130         return rc;
1131 }
1132 EXPORT_SYMBOL(cca_clr2cipherkey);
1133
1134 /*
1135  * Derive proteced key from CCA AES cipher secure key.
1136  */
1137 int cca_cipher2protkey(u16 cardnr, u16 domain, const u8 *ckey,
1138                        u8 *protkey, u32 *protkeylen, u32 *protkeytype)
1139 {
1140         int rc;
1141         u8 *mem, *ptr;
1142         struct CPRBX *preqcblk, *prepcblk;
1143         struct ica_xcRB xcrb;
1144         struct aureqparm {
1145                 u8  subfunc_code[2];
1146                 u16 rule_array_len;
1147                 u8  rule_array[8];
1148                 struct {
1149                         u16 len;
1150                         u16 tk_blob_len;
1151                         u16 tk_blob_tag;
1152                         u8  tk_blob[66];
1153                 } vud;
1154                 struct {
1155                         u16 len;
1156                         u16 cca_key_token_len;
1157                         u16 cca_key_token_flags;
1158                         u8  cca_key_token[0]; // 64 or more
1159                 } kb;
1160         } __packed * preqparm;
1161         struct aurepparm {
1162                 u8  subfunc_code[2];
1163                 u16 rule_array_len;
1164                 struct {
1165                         u16 len;
1166                         u16 sublen;
1167                         u16 tag;
1168                         struct cpacfkeyblock {
1169                                 u8  version;  /* version of this struct */
1170                                 u8  flags[2];
1171                                 u8  algo;
1172                                 u8  form;
1173                                 u8  pad1[3];
1174                                 u16 keylen;
1175                                 u8  key[64];  /* the key (keylen bytes) */
1176                                 u16 keyattrlen;
1177                                 u8  keyattr[32];
1178                                 u8  pad2[1];
1179                                 u8  vptype;
1180                                 u8  vp[32];  /* verification pattern */
1181                         } ckb;
1182                 } vud;
1183                 struct {
1184                         u16 len;
1185                 } kb;
1186         } __packed * prepparm;
1187         int keytoklen = ((struct cipherkeytoken *)ckey)->len;
1188
1189         /* get already prepared memory for 2 cprbs with param block each */
1190         rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
1191         if (rc)
1192                 return rc;
1193
1194         /* fill request cprb struct */
1195         preqcblk->domain = domain;
1196
1197         /* fill request cprb param block with AU request */
1198         preqparm = (struct aureqparm __force *) preqcblk->req_parmb;
1199         memcpy(preqparm->subfunc_code, "AU", 2);
1200         preqparm->rule_array_len =
1201                 sizeof(preqparm->rule_array_len)
1202                 + sizeof(preqparm->rule_array);
1203         memcpy(preqparm->rule_array, "EXPT-SK ", 8);
1204         /* vud, tk blob */
1205         preqparm->vud.len = sizeof(preqparm->vud);
1206         preqparm->vud.tk_blob_len = sizeof(preqparm->vud.tk_blob)
1207                 + 2 * sizeof(uint16_t);
1208         preqparm->vud.tk_blob_tag = 0x00C2;
1209         /* kb, cca token */
1210         preqparm->kb.len = keytoklen + 3 * sizeof(uint16_t);
1211         preqparm->kb.cca_key_token_len = keytoklen + 2 * sizeof(uint16_t);
1212         memcpy(preqparm->kb.cca_key_token, ckey, keytoklen);
1213         /* now fill length of param block into cprb */
1214         preqcblk->req_parml = sizeof(struct aureqparm) + keytoklen;
1215
1216         /* fill xcrb struct */
1217         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
1218
1219         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
1220         rc = zcrypt_send_cprb(&xcrb);
1221         if (rc) {
1222                 DEBUG_ERR(
1223                         "%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
1224                         __func__, (int) cardnr, (int) domain, rc);
1225                 goto out;
1226         }
1227
1228         /* check response returncode and reasoncode */
1229         if (prepcblk->ccp_rtcode != 0) {
1230                 DEBUG_ERR(
1231                         "%s unwrap secure key failure, card response %d/%d\n",
1232                         __func__,
1233                         (int) prepcblk->ccp_rtcode,
1234                         (int) prepcblk->ccp_rscode);
1235                 rc = -EIO;
1236                 goto out;
1237         }
1238         if (prepcblk->ccp_rscode != 0) {
1239                 DEBUG_WARN(
1240                         "%s unwrap secure key warning, card response %d/%d\n",
1241                         __func__,
1242                         (int) prepcblk->ccp_rtcode,
1243                         (int) prepcblk->ccp_rscode);
1244         }
1245
1246         /* process response cprb param block */
1247         ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
1248         prepcblk->rpl_parmb = (u8 __user *) ptr;
1249         prepparm = (struct aurepparm *) ptr;
1250
1251         /* check the returned keyblock */
1252         if (prepparm->vud.ckb.version != 0x01 &&
1253             prepparm->vud.ckb.version != 0x02) {
1254                 DEBUG_ERR("%s reply param keyblock version mismatch 0x%02x\n",
1255                           __func__, (int) prepparm->vud.ckb.version);
1256                 rc = -EIO;
1257                 goto out;
1258         }
1259         if (prepparm->vud.ckb.algo != 0x02) {
1260                 DEBUG_ERR(
1261                         "%s reply param keyblock algo mismatch 0x%02x != 0x02\n",
1262                         __func__, (int) prepparm->vud.ckb.algo);
1263                 rc = -EIO;
1264                 goto out;
1265         }
1266
1267         /* copy the translated protected key */
1268         switch (prepparm->vud.ckb.keylen) {
1269         case 16+32:
1270                 /* AES 128 protected key */
1271                 if (protkeytype)
1272                         *protkeytype = PKEY_KEYTYPE_AES_128;
1273                 break;
1274         case 24+32:
1275                 /* AES 192 protected key */
1276                 if (protkeytype)
1277                         *protkeytype = PKEY_KEYTYPE_AES_192;
1278                 break;
1279         case 32+32:
1280                 /* AES 256 protected key */
1281                 if (protkeytype)
1282                         *protkeytype = PKEY_KEYTYPE_AES_256;
1283                 break;
1284         default:
1285                 DEBUG_ERR("%s unknown/unsupported keylen %d\n",
1286                           __func__, prepparm->vud.ckb.keylen);
1287                 rc = -EIO;
1288                 goto out;
1289         }
1290         memcpy(protkey, prepparm->vud.ckb.key, prepparm->vud.ckb.keylen);
1291         if (protkeylen)
1292                 *protkeylen = prepparm->vud.ckb.keylen;
1293
1294 out:
1295         free_cprbmem(mem, PARMBSIZE, 0);
1296         return rc;
1297 }
1298 EXPORT_SYMBOL(cca_cipher2protkey);
1299
1300 /*
1301  * query cryptographic facility from CCA adapter
1302  */
1303 int cca_query_crypto_facility(u16 cardnr, u16 domain,
1304                               const char *keyword,
1305                               u8 *rarray, size_t *rarraylen,
1306                               u8 *varray, size_t *varraylen)
1307 {
1308         int rc;
1309         u16 len;
1310         u8 *mem, *ptr;
1311         struct CPRBX *preqcblk, *prepcblk;
1312         struct ica_xcRB xcrb;
1313         struct fqreqparm {
1314                 u8  subfunc_code[2];
1315                 u16 rule_array_len;
1316                 char  rule_array[8];
1317                 struct lv1 {
1318                         u16 len;
1319                         u8  data[VARDATASIZE];
1320                 } lv1;
1321                 u16 dummylen;
1322         } __packed * preqparm;
1323         size_t parmbsize = sizeof(struct fqreqparm);
1324         struct fqrepparm {
1325                 u8  subfunc_code[2];
1326                 u8  lvdata[0];
1327         } __packed * prepparm;
1328
1329         /* get already prepared memory for 2 cprbs with param block each */
1330         rc = alloc_and_prep_cprbmem(parmbsize, &mem, &preqcblk, &prepcblk);
1331         if (rc)
1332                 return rc;
1333
1334         /* fill request cprb struct */
1335         preqcblk->domain = domain;
1336
1337         /* fill request cprb param block with FQ request */
1338         preqparm = (struct fqreqparm __force *) preqcblk->req_parmb;
1339         memcpy(preqparm->subfunc_code, "FQ", 2);
1340         memcpy(preqparm->rule_array, keyword, sizeof(preqparm->rule_array));
1341         preqparm->rule_array_len =
1342                 sizeof(preqparm->rule_array_len) + sizeof(preqparm->rule_array);
1343         preqparm->lv1.len = sizeof(preqparm->lv1);
1344         preqparm->dummylen = sizeof(preqparm->dummylen);
1345         preqcblk->req_parml = parmbsize;
1346
1347         /* fill xcrb struct */
1348         prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
1349
1350         /* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
1351         rc = zcrypt_send_cprb(&xcrb);
1352         if (rc) {
1353                 DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
1354                           __func__, (int) cardnr, (int) domain, rc);
1355                 goto out;
1356         }
1357
1358         /* check response returncode and reasoncode */
1359         if (prepcblk->ccp_rtcode != 0) {
1360                 DEBUG_ERR("%s unwrap secure key failure, card response %d/%d\n",
1361                           __func__,
1362                           (int) prepcblk->ccp_rtcode,
1363                           (int) prepcblk->ccp_rscode);
1364                 rc = -EIO;
1365                 goto out;
1366         }
1367
1368         /* process response cprb param block */
1369         ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
1370         prepcblk->rpl_parmb = (u8 __user *) ptr;
1371         prepparm = (struct fqrepparm *) ptr;
1372         ptr = prepparm->lvdata;
1373
1374         /* check and possibly copy reply rule array */
1375         len = *((u16 *) ptr);
1376         if (len > sizeof(u16)) {
1377                 ptr += sizeof(u16);
1378                 len -= sizeof(u16);
1379                 if (rarray && rarraylen && *rarraylen > 0) {
1380                         *rarraylen = (len > *rarraylen ? *rarraylen : len);
1381                         memcpy(rarray, ptr, *rarraylen);
1382                 }
1383                 ptr += len;
1384         }
1385         /* check and possible copy reply var array */
1386         len = *((u16 *) ptr);
1387         if (len > sizeof(u16)) {
1388                 ptr += sizeof(u16);
1389                 len -= sizeof(u16);
1390                 if (varray && varraylen && *varraylen > 0) {
1391                         *varraylen = (len > *varraylen ? *varraylen : len);
1392                         memcpy(varray, ptr, *varraylen);
1393                 }
1394                 ptr += len;
1395         }
1396
1397 out:
1398         free_cprbmem(mem, parmbsize, 0);
1399         return rc;
1400 }
1401 EXPORT_SYMBOL(cca_query_crypto_facility);
1402
1403 static int cca_info_cache_fetch(u16 cardnr, u16 domain, struct cca_info *ci)
1404 {
1405         int rc = -ENOENT;
1406         struct cca_info_list_entry *ptr;
1407
1408         spin_lock_bh(&cca_info_list_lock);
1409         list_for_each_entry(ptr, &cca_info_list, list) {
1410                 if (ptr->cardnr == cardnr && ptr->domain == domain) {
1411                         memcpy(ci, &ptr->info, sizeof(*ci));
1412                         rc = 0;
1413                         break;
1414                 }
1415         }
1416         spin_unlock_bh(&cca_info_list_lock);
1417
1418         return rc;
1419 }
1420
1421 static void cca_info_cache_update(u16 cardnr, u16 domain,
1422                                   const struct cca_info *ci)
1423 {
1424         int found = 0;
1425         struct cca_info_list_entry *ptr;
1426
1427         spin_lock_bh(&cca_info_list_lock);
1428         list_for_each_entry(ptr, &cca_info_list, list) {
1429                 if (ptr->cardnr == cardnr &&
1430                     ptr->domain == domain) {
1431                         memcpy(&ptr->info, ci, sizeof(*ci));
1432                         found = 1;
1433                         break;
1434                 }
1435         }
1436         if (!found) {
1437                 ptr = kmalloc(sizeof(*ptr), GFP_ATOMIC);
1438                 if (!ptr) {
1439                         spin_unlock_bh(&cca_info_list_lock);
1440                         return;
1441                 }
1442                 ptr->cardnr = cardnr;
1443                 ptr->domain = domain;
1444                 memcpy(&ptr->info, ci, sizeof(*ci));
1445                 list_add(&ptr->list, &cca_info_list);
1446         }
1447         spin_unlock_bh(&cca_info_list_lock);
1448 }
1449
1450 static void cca_info_cache_scrub(u16 cardnr, u16 domain)
1451 {
1452         struct cca_info_list_entry *ptr;
1453
1454         spin_lock_bh(&cca_info_list_lock);
1455         list_for_each_entry(ptr, &cca_info_list, list) {
1456                 if (ptr->cardnr == cardnr &&
1457                     ptr->domain == domain) {
1458                         list_del(&ptr->list);
1459                         kfree(ptr);
1460                         break;
1461                 }
1462         }
1463         spin_unlock_bh(&cca_info_list_lock);
1464 }
1465
1466 static void __exit mkvp_cache_free(void)
1467 {
1468         struct cca_info_list_entry *ptr, *pnext;
1469
1470         spin_lock_bh(&cca_info_list_lock);
1471         list_for_each_entry_safe(ptr, pnext, &cca_info_list, list) {
1472                 list_del(&ptr->list);
1473                 kfree(ptr);
1474         }
1475         spin_unlock_bh(&cca_info_list_lock);
1476 }
1477
1478 /*
1479  * Fetch cca_info values via query_crypto_facility from adapter.
1480  */
1481 static int fetch_cca_info(u16 cardnr, u16 domain, struct cca_info *ci)
1482 {
1483         int rc, found = 0;
1484         size_t rlen, vlen;
1485         u8 *rarray, *varray, *pg;
1486         struct zcrypt_device_status_ext devstat;
1487
1488         memset(ci, 0, sizeof(*ci));
1489
1490         /* get first info from zcrypt device driver about this apqn */
1491         rc = zcrypt_device_status_ext(cardnr, domain, &devstat);
1492         if (rc)
1493                 return rc;
1494         ci->hwtype = devstat.hwtype;
1495
1496         /* prep page for rule array and var array use */
1497         pg = (u8 *) __get_free_page(GFP_KERNEL);
1498         if (!pg)
1499                 return -ENOMEM;
1500         rarray = pg;
1501         varray = pg + PAGE_SIZE/2;
1502         rlen = vlen = PAGE_SIZE/2;
1503
1504         /* QF for this card/domain */
1505         rc = cca_query_crypto_facility(cardnr, domain, "STATICSA",
1506                                        rarray, &rlen, varray, &vlen);
1507         if (rc == 0 && rlen >= 10*8 && vlen >= 204) {
1508                 memcpy(ci->serial, rarray, 8);
1509                 ci->new_mk_state = (char) rarray[7*8];
1510                 ci->cur_mk_state = (char) rarray[8*8];
1511                 ci->old_mk_state = (char) rarray[9*8];
1512                 if (ci->old_mk_state == '2')
1513                         memcpy(&ci->old_mkvp, varray + 172, 8);
1514                 if (ci->cur_mk_state == '2')
1515                         memcpy(&ci->cur_mkvp, varray + 184, 8);
1516                 if (ci->new_mk_state == '3')
1517                         memcpy(&ci->new_mkvp, varray + 196, 8);
1518                 found = 1;
1519         }
1520
1521         free_page((unsigned long) pg);
1522
1523         return found ? 0 : -ENOENT;
1524 }
1525
1526 /*
1527  * Fetch cca information about a CCA queue.
1528  */
1529 int cca_get_info(u16 card, u16 dom, struct cca_info *ci, int verify)
1530 {
1531         int rc;
1532
1533         rc = cca_info_cache_fetch(card, dom, ci);
1534         if (rc || verify) {
1535                 rc = fetch_cca_info(card, dom, ci);
1536                 if (rc == 0)
1537                         cca_info_cache_update(card, dom, ci);
1538         }
1539
1540         return rc;
1541 }
1542 EXPORT_SYMBOL(cca_get_info);
1543
1544 /*
1545  * Search for a matching crypto card based on the
1546  * Master Key Verification Pattern given.
1547  */
1548 static int findcard(u64 mkvp, u16 *pcardnr, u16 *pdomain,
1549                     int verify, int minhwtype)
1550 {
1551         struct zcrypt_device_status_ext *device_status;
1552         u16 card, dom;
1553         struct cca_info ci;
1554         int i, rc, oi = -1;
1555
1556         /* mkvp must not be zero, minhwtype needs to be >= 0 */
1557         if (mkvp == 0 || minhwtype < 0)
1558                 return -EINVAL;
1559
1560         /* fetch status of all crypto cards */
1561         device_status = kvmalloc_array(MAX_ZDEV_ENTRIES_EXT,
1562                                        sizeof(struct zcrypt_device_status_ext),
1563                                        GFP_KERNEL);
1564         if (!device_status)
1565                 return -ENOMEM;
1566         zcrypt_device_status_mask_ext(device_status);
1567
1568         /* walk through all crypto cards */
1569         for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
1570                 card = AP_QID_CARD(device_status[i].qid);
1571                 dom = AP_QID_QUEUE(device_status[i].qid);
1572                 if (device_status[i].online &&
1573                     device_status[i].functions & 0x04) {
1574                         /* enabled CCA card, check current mkvp from cache */
1575                         if (cca_info_cache_fetch(card, dom, &ci) == 0 &&
1576                             ci.hwtype >= minhwtype &&
1577                             ci.cur_mk_state == '2' &&
1578                             ci.cur_mkvp == mkvp) {
1579                                 if (!verify)
1580                                         break;
1581                                 /* verify: refresh card info */
1582                                 if (fetch_cca_info(card, dom, &ci) == 0) {
1583                                         cca_info_cache_update(card, dom, &ci);
1584                                         if (ci.hwtype >= minhwtype &&
1585                                             ci.cur_mk_state == '2' &&
1586                                             ci.cur_mkvp == mkvp)
1587                                                 break;
1588                                 }
1589                         }
1590                 } else {
1591                         /* Card is offline and/or not a CCA card. */
1592                         /* del mkvp entry from cache if it exists */
1593                         cca_info_cache_scrub(card, dom);
1594                 }
1595         }
1596         if (i >= MAX_ZDEV_ENTRIES_EXT) {
1597                 /* nothing found, so this time without cache */
1598                 for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
1599                         if (!(device_status[i].online &&
1600                               device_status[i].functions & 0x04))
1601                                 continue;
1602                         card = AP_QID_CARD(device_status[i].qid);
1603                         dom = AP_QID_QUEUE(device_status[i].qid);
1604                         /* fresh fetch mkvp from adapter */
1605                         if (fetch_cca_info(card, dom, &ci) == 0) {
1606                                 cca_info_cache_update(card, dom, &ci);
1607                                 if (ci.hwtype >= minhwtype &&
1608                                     ci.cur_mk_state == '2' &&
1609                                     ci.cur_mkvp == mkvp)
1610                                         break;
1611                                 if (ci.hwtype >= minhwtype &&
1612                                     ci.old_mk_state == '2' &&
1613                                     ci.old_mkvp == mkvp &&
1614                                     oi < 0)
1615                                         oi = i;
1616                         }
1617                 }
1618                 if (i >= MAX_ZDEV_ENTRIES_EXT && oi >= 0) {
1619                         /* old mkvp matched, use this card then */
1620                         card = AP_QID_CARD(device_status[oi].qid);
1621                         dom = AP_QID_QUEUE(device_status[oi].qid);
1622                 }
1623         }
1624         if (i < MAX_ZDEV_ENTRIES_EXT || oi >= 0) {
1625                 if (pcardnr)
1626                         *pcardnr = card;
1627                 if (pdomain)
1628                         *pdomain = dom;
1629                 rc = (i < MAX_ZDEV_ENTRIES_EXT ? 0 : 1);
1630         } else
1631                 rc = -ENODEV;
1632
1633         kvfree(device_status);
1634         return rc;
1635 }
1636
1637 /*
1638  * Search for a matching crypto card based on the Master Key
1639  * Verification Pattern provided inside a secure key token.
1640  */
1641 int cca_findcard(const u8 *key, u16 *pcardnr, u16 *pdomain, int verify)
1642 {
1643         u64 mkvp;
1644         int minhwtype = 0;
1645         const struct keytoken_header *hdr = (struct keytoken_header *) key;
1646
1647         if (hdr->type != TOKTYPE_CCA_INTERNAL)
1648                 return -EINVAL;
1649
1650         switch (hdr->version) {
1651         case TOKVER_CCA_AES:
1652                 mkvp = ((struct secaeskeytoken *)key)->mkvp;
1653                 break;
1654         case TOKVER_CCA_VLSC:
1655                 mkvp = ((struct cipherkeytoken *)key)->mkvp0;
1656                 minhwtype = AP_DEVICE_TYPE_CEX6;
1657                 break;
1658         default:
1659                 return -EINVAL;
1660         }
1661
1662         return findcard(mkvp, pcardnr, pdomain, verify, minhwtype);
1663 }
1664 EXPORT_SYMBOL(cca_findcard);
1665
1666 int cca_findcard2(u32 **apqns, u32 *nr_apqns, u16 cardnr, u16 domain,
1667                   int minhwtype, u64 cur_mkvp, u64 old_mkvp, int verify)
1668 {
1669         struct zcrypt_device_status_ext *device_status;
1670         u32 *_apqns = NULL, _nr_apqns = 0;
1671         int i, card, dom, curmatch, oldmatch, rc = 0;
1672         struct cca_info ci;
1673
1674         /* fetch status of all crypto cards */
1675         device_status = kmalloc_array(MAX_ZDEV_ENTRIES_EXT,
1676                                       sizeof(struct zcrypt_device_status_ext),
1677                                       GFP_KERNEL);
1678         if (!device_status)
1679                 return -ENOMEM;
1680         zcrypt_device_status_mask_ext(device_status);
1681
1682         /* allocate 1k space for up to 256 apqns */
1683         _apqns = kmalloc_array(256, sizeof(u32), GFP_KERNEL);
1684         if (!_apqns) {
1685                 kvfree(device_status);
1686                 return -ENOMEM;
1687         }
1688
1689         /* walk through all the crypto apqnss */
1690         for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
1691                 card = AP_QID_CARD(device_status[i].qid);
1692                 dom = AP_QID_QUEUE(device_status[i].qid);
1693                 /* check online state */
1694                 if (!device_status[i].online)
1695                         continue;
1696                 /* check for cca functions */
1697                 if (!(device_status[i].functions & 0x04))
1698                         continue;
1699                 /* check cardnr */
1700                 if (cardnr != 0xFFFF && card != cardnr)
1701                         continue;
1702                 /* check domain */
1703                 if (domain != 0xFFFF && dom != domain)
1704                         continue;
1705                 /* get cca info on this apqn */
1706                 if (cca_get_info(card, dom, &ci, verify))
1707                         continue;
1708                 /* current master key needs to be valid */
1709                 if (ci.cur_mk_state != '2')
1710                         continue;
1711                 /* check min hardware type */
1712                 if (minhwtype > 0 && minhwtype > ci.hwtype)
1713                         continue;
1714                 if (cur_mkvp || old_mkvp) {
1715                         /* check mkvps */
1716                         curmatch = oldmatch = 0;
1717                         if (cur_mkvp && cur_mkvp == ci.cur_mkvp)
1718                                 curmatch = 1;
1719                         if (old_mkvp && ci.old_mk_state == '2' &&
1720                             old_mkvp == ci.old_mkvp)
1721                                 oldmatch = 1;
1722                         if ((cur_mkvp || old_mkvp) &&
1723                             (curmatch + oldmatch < 1))
1724                                 continue;
1725                 }
1726                 /* apqn passed all filtering criterons, add to the array */
1727                 if (_nr_apqns < 256)
1728                         _apqns[_nr_apqns++] = (((u16)card) << 16) | ((u16) dom);
1729         }
1730
1731         /* nothing found ? */
1732         if (!_nr_apqns) {
1733                 kfree(_apqns);
1734                 rc = -ENODEV;
1735         } else {
1736                 /* no re-allocation, simple return the _apqns array */
1737                 *apqns = _apqns;
1738                 *nr_apqns = _nr_apqns;
1739                 rc = 0;
1740         }
1741
1742         kfree(device_status);
1743         return rc;
1744 }
1745 EXPORT_SYMBOL(cca_findcard2);
1746
1747 void __exit zcrypt_ccamisc_exit(void)
1748 {
1749         mkvp_cache_free();
1750 }