xref: /openbmc/linux/drivers/s390/crypto/pkey_api.c (revision da2ef666)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  pkey device driver
4  *
5  *  Copyright IBM Corp. 2017
6  *  Author(s): Harald Freudenberger
7  */
8 
9 #define KMSG_COMPONENT "pkey"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11 
12 #include <linux/fs.h>
13 #include <linux/init.h>
14 #include <linux/miscdevice.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/kallsyms.h>
18 #include <linux/debugfs.h>
19 #include <asm/zcrypt.h>
20 #include <asm/cpacf.h>
21 #include <asm/pkey.h>
22 
23 #include "zcrypt_api.h"
24 
25 MODULE_LICENSE("GPL");
26 MODULE_AUTHOR("IBM Corporation");
27 MODULE_DESCRIPTION("s390 protected key interface");
28 
29 /* Size of parameter block used for all cca requests/replies */
30 #define PARMBSIZE 512
31 
32 /* Size of vardata block used for some of the cca requests/replies */
33 #define VARDATASIZE 4096
34 
35 /*
36  * debug feature data and functions
37  */
38 
39 static debug_info_t *debug_info;
40 
41 #define DEBUG_DBG(...)	debug_sprintf_event(debug_info, 6, ##__VA_ARGS__)
42 #define DEBUG_INFO(...) debug_sprintf_event(debug_info, 5, ##__VA_ARGS__)
43 #define DEBUG_WARN(...) debug_sprintf_event(debug_info, 4, ##__VA_ARGS__)
44 #define DEBUG_ERR(...)	debug_sprintf_event(debug_info, 3, ##__VA_ARGS__)
45 
46 static void __init pkey_debug_init(void)
47 {
48 	debug_info = debug_register("pkey", 1, 1, 4 * sizeof(long));
49 	debug_register_view(debug_info, &debug_sprintf_view);
50 	debug_set_level(debug_info, 3);
51 }
52 
53 static void __exit pkey_debug_exit(void)
54 {
55 	debug_unregister(debug_info);
56 }
57 
58 /* inside view of a secure key token (only type 0x01 version 0x04) */
59 struct secaeskeytoken {
60 	u8  type;     /* 0x01 for internal key token */
61 	u8  res0[3];
62 	u8  version;  /* should be 0x04 */
63 	u8  res1[1];
64 	u8  flag;     /* key flags */
65 	u8  res2[1];
66 	u64 mkvp;     /* master key verification pattern */
67 	u8  key[32];  /* key value (encrypted) */
68 	u8  cv[8];    /* control vector */
69 	u16 bitsize;  /* key bit size */
70 	u16 keysize;  /* key byte size */
71 	u8  tvv[4];   /* token validation value */
72 } __packed;
73 
74 /*
75  * Simple check if the token is a valid CCA secure AES key
76  * token. If keybitsize is given, the bitsize of the key is
77  * also checked. Returns 0 on success or errno value on failure.
78  */
79 static int check_secaeskeytoken(const u8 *token, int keybitsize)
80 {
81 	struct secaeskeytoken *t = (struct secaeskeytoken *) token;
82 
83 	if (t->type != 0x01) {
84 		DEBUG_ERR(
85 			"%s secure token check failed, type mismatch 0x%02x != 0x01\n",
86 			__func__, (int) t->type);
87 		return -EINVAL;
88 	}
89 	if (t->version != 0x04) {
90 		DEBUG_ERR(
91 			"%s secure token check failed, version mismatch 0x%02x != 0x04\n",
92 			__func__, (int) t->version);
93 		return -EINVAL;
94 	}
95 	if (keybitsize > 0 && t->bitsize != keybitsize) {
96 		DEBUG_ERR(
97 			"%s secure token check failed, bitsize mismatch %d != %d\n",
98 			__func__, (int) t->bitsize, keybitsize);
99 		return -EINVAL;
100 	}
101 
102 	return 0;
103 }
104 
105 /*
106  * Allocate consecutive memory for request CPRB, request param
107  * block, reply CPRB and reply param block and fill in values
108  * for the common fields. Returns 0 on success or errno value
109  * on failure.
110  */
111 static int alloc_and_prep_cprbmem(size_t paramblen,
112 				  u8 **pcprbmem,
113 				  struct CPRBX **preqCPRB,
114 				  struct CPRBX **prepCPRB)
115 {
116 	u8 *cprbmem;
117 	size_t cprbplusparamblen = sizeof(struct CPRBX) + paramblen;
118 	struct CPRBX *preqcblk, *prepcblk;
119 
120 	/*
121 	 * allocate consecutive memory for request CPRB, request param
122 	 * block, reply CPRB and reply param block
123 	 */
124 	cprbmem = kcalloc(2, cprbplusparamblen, GFP_KERNEL);
125 	if (!cprbmem)
126 		return -ENOMEM;
127 
128 	preqcblk = (struct CPRBX *) cprbmem;
129 	prepcblk = (struct CPRBX *) (cprbmem + cprbplusparamblen);
130 
131 	/* fill request cprb struct */
132 	preqcblk->cprb_len = sizeof(struct CPRBX);
133 	preqcblk->cprb_ver_id = 0x02;
134 	memcpy(preqcblk->func_id, "T2", 2);
135 	preqcblk->rpl_msgbl = cprbplusparamblen;
136 	if (paramblen) {
137 		preqcblk->req_parmb =
138 			((u8 *) preqcblk) + sizeof(struct CPRBX);
139 		preqcblk->rpl_parmb =
140 			((u8 *) prepcblk) + sizeof(struct CPRBX);
141 	}
142 
143 	*pcprbmem = cprbmem;
144 	*preqCPRB = preqcblk;
145 	*prepCPRB = prepcblk;
146 
147 	return 0;
148 }
149 
150 /*
151  * Free the cprb memory allocated with the function above.
152  * If the scrub value is not zero, the memory is filled
153  * with zeros before freeing (useful if there was some
154  * clear key material in there).
155  */
156 static void free_cprbmem(void *mem, size_t paramblen, int scrub)
157 {
158 	if (scrub)
159 		memzero_explicit(mem, 2 * (sizeof(struct CPRBX) + paramblen));
160 	kfree(mem);
161 }
162 
163 /*
164  * Helper function to prepare the xcrb struct
165  */
166 static inline void prep_xcrb(struct ica_xcRB *pxcrb,
167 			     u16 cardnr,
168 			     struct CPRBX *preqcblk,
169 			     struct CPRBX *prepcblk)
170 {
171 	memset(pxcrb, 0, sizeof(*pxcrb));
172 	pxcrb->agent_ID = 0x4341; /* 'CA' */
173 	pxcrb->user_defined = (cardnr == 0xFFFF ? AUTOSELECT : cardnr);
174 	pxcrb->request_control_blk_length =
175 		preqcblk->cprb_len + preqcblk->req_parml;
176 	pxcrb->request_control_blk_addr = (void __user *) preqcblk;
177 	pxcrb->reply_control_blk_length = preqcblk->rpl_msgbl;
178 	pxcrb->reply_control_blk_addr = (void __user *) prepcblk;
179 }
180 
181 /*
182  * Helper function which calls zcrypt_send_cprb with
183  * memory management segment adjusted to kernel space
184  * so that the copy_from_user called within this
185  * function do in fact copy from kernel space.
186  */
187 static inline int _zcrypt_send_cprb(struct ica_xcRB *xcrb)
188 {
189 	int rc;
190 	mm_segment_t old_fs = get_fs();
191 
192 	set_fs(KERNEL_DS);
193 	rc = zcrypt_send_cprb(xcrb);
194 	set_fs(old_fs);
195 
196 	return rc;
197 }
198 
199 /*
200  * Generate (random) AES secure key.
201  */
202 int pkey_genseckey(u16 cardnr, u16 domain,
203 		   u32 keytype, struct pkey_seckey *seckey)
204 {
205 	int i, rc, keysize;
206 	int seckeysize;
207 	u8 *mem;
208 	struct CPRBX *preqcblk, *prepcblk;
209 	struct ica_xcRB xcrb;
210 	struct kgreqparm {
211 		u8  subfunc_code[2];
212 		u16 rule_array_len;
213 		struct lv1 {
214 			u16 len;
215 			char  key_form[8];
216 			char  key_length[8];
217 			char  key_type1[8];
218 			char  key_type2[8];
219 		} lv1;
220 		struct lv2 {
221 			u16 len;
222 			struct keyid {
223 				u16 len;
224 				u16 attr;
225 				u8  data[SECKEYBLOBSIZE];
226 			} keyid[6];
227 		} lv2;
228 	} *preqparm;
229 	struct kgrepparm {
230 		u8  subfunc_code[2];
231 		u16 rule_array_len;
232 		struct lv3 {
233 			u16 len;
234 			u16 keyblocklen;
235 			struct {
236 				u16 toklen;
237 				u16 tokattr;
238 				u8  tok[0];
239 				/* ... some more data ... */
240 			} keyblock;
241 		} lv3;
242 	} *prepparm;
243 
244 	/* get already prepared memory for 2 cprbs with param block each */
245 	rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
246 	if (rc)
247 		return rc;
248 
249 	/* fill request cprb struct */
250 	preqcblk->domain = domain;
251 
252 	/* fill request cprb param block with KG request */
253 	preqparm = (struct kgreqparm *) preqcblk->req_parmb;
254 	memcpy(preqparm->subfunc_code, "KG", 2);
255 	preqparm->rule_array_len = sizeof(preqparm->rule_array_len);
256 	preqparm->lv1.len = sizeof(struct lv1);
257 	memcpy(preqparm->lv1.key_form,	 "OP      ", 8);
258 	switch (keytype) {
259 	case PKEY_KEYTYPE_AES_128:
260 		keysize = 16;
261 		memcpy(preqparm->lv1.key_length, "KEYLN16 ", 8);
262 		break;
263 	case PKEY_KEYTYPE_AES_192:
264 		keysize = 24;
265 		memcpy(preqparm->lv1.key_length, "KEYLN24 ", 8);
266 		break;
267 	case PKEY_KEYTYPE_AES_256:
268 		keysize = 32;
269 		memcpy(preqparm->lv1.key_length, "KEYLN32 ", 8);
270 		break;
271 	default:
272 		DEBUG_ERR(
273 			"%s unknown/unsupported keytype %d\n",
274 			__func__, keytype);
275 		rc = -EINVAL;
276 		goto out;
277 	}
278 	memcpy(preqparm->lv1.key_type1,  "AESDATA ", 8);
279 	preqparm->lv2.len = sizeof(struct lv2);
280 	for (i = 0; i < 6; i++) {
281 		preqparm->lv2.keyid[i].len = sizeof(struct keyid);
282 		preqparm->lv2.keyid[i].attr = (i == 2 ? 0x30 : 0x10);
283 	}
284 	preqcblk->req_parml = sizeof(struct kgreqparm);
285 
286 	/* fill xcrb struct */
287 	prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
288 
289 	/* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
290 	rc = _zcrypt_send_cprb(&xcrb);
291 	if (rc) {
292 		DEBUG_ERR(
293 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed with errno %d\n",
294 			__func__, (int) cardnr, (int) domain, rc);
295 		goto out;
296 	}
297 
298 	/* check response returncode and reasoncode */
299 	if (prepcblk->ccp_rtcode != 0) {
300 		DEBUG_ERR(
301 			"%s secure key generate failure, card response %d/%d\n",
302 			__func__,
303 			(int) prepcblk->ccp_rtcode,
304 			(int) prepcblk->ccp_rscode);
305 		rc = -EIO;
306 		goto out;
307 	}
308 
309 	/* process response cprb param block */
310 	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
311 	prepparm = (struct kgrepparm *) prepcblk->rpl_parmb;
312 
313 	/* check length of the returned secure key token */
314 	seckeysize = prepparm->lv3.keyblock.toklen
315 		- sizeof(prepparm->lv3.keyblock.toklen)
316 		- sizeof(prepparm->lv3.keyblock.tokattr);
317 	if (seckeysize != SECKEYBLOBSIZE) {
318 		DEBUG_ERR(
319 			"%s secure token size mismatch %d != %d bytes\n",
320 			__func__, seckeysize, SECKEYBLOBSIZE);
321 		rc = -EIO;
322 		goto out;
323 	}
324 
325 	/* check secure key token */
326 	rc = check_secaeskeytoken(prepparm->lv3.keyblock.tok, 8*keysize);
327 	if (rc) {
328 		rc = -EIO;
329 		goto out;
330 	}
331 
332 	/* copy the generated secure key token */
333 	memcpy(seckey->seckey, prepparm->lv3.keyblock.tok, SECKEYBLOBSIZE);
334 
335 out:
336 	free_cprbmem(mem, PARMBSIZE, 0);
337 	return rc;
338 }
339 EXPORT_SYMBOL(pkey_genseckey);
340 
341 /*
342  * Generate an AES secure key with given key value.
343  */
344 int pkey_clr2seckey(u16 cardnr, u16 domain, u32 keytype,
345 		    const struct pkey_clrkey *clrkey,
346 		    struct pkey_seckey *seckey)
347 {
348 	int rc, keysize, seckeysize;
349 	u8 *mem;
350 	struct CPRBX *preqcblk, *prepcblk;
351 	struct ica_xcRB xcrb;
352 	struct cmreqparm {
353 		u8  subfunc_code[2];
354 		u16 rule_array_len;
355 		char  rule_array[8];
356 		struct lv1 {
357 			u16 len;
358 			u8  clrkey[0];
359 		} lv1;
360 		struct lv2 {
361 			u16 len;
362 			struct keyid {
363 				u16 len;
364 				u16 attr;
365 				u8  data[SECKEYBLOBSIZE];
366 			} keyid;
367 		} lv2;
368 	} *preqparm;
369 	struct lv2 *plv2;
370 	struct cmrepparm {
371 		u8  subfunc_code[2];
372 		u16 rule_array_len;
373 		struct lv3 {
374 			u16 len;
375 			u16 keyblocklen;
376 			struct {
377 				u16 toklen;
378 				u16 tokattr;
379 				u8  tok[0];
380 				/* ... some more data ... */
381 			} keyblock;
382 		} lv3;
383 	} *prepparm;
384 
385 	/* get already prepared memory for 2 cprbs with param block each */
386 	rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
387 	if (rc)
388 		return rc;
389 
390 	/* fill request cprb struct */
391 	preqcblk->domain = domain;
392 
393 	/* fill request cprb param block with CM request */
394 	preqparm = (struct cmreqparm *) preqcblk->req_parmb;
395 	memcpy(preqparm->subfunc_code, "CM", 2);
396 	memcpy(preqparm->rule_array, "AES     ", 8);
397 	preqparm->rule_array_len =
398 		sizeof(preqparm->rule_array_len) + sizeof(preqparm->rule_array);
399 	switch (keytype) {
400 	case PKEY_KEYTYPE_AES_128:
401 		keysize = 16;
402 		break;
403 	case PKEY_KEYTYPE_AES_192:
404 		keysize = 24;
405 		break;
406 	case PKEY_KEYTYPE_AES_256:
407 		keysize = 32;
408 		break;
409 	default:
410 		DEBUG_ERR(
411 			"%s unknown/unsupported keytype %d\n",
412 			__func__, keytype);
413 		rc = -EINVAL;
414 		goto out;
415 	}
416 	preqparm->lv1.len = sizeof(struct lv1) + keysize;
417 	memcpy(preqparm->lv1.clrkey, clrkey->clrkey, keysize);
418 	plv2 = (struct lv2 *) (((u8 *) &preqparm->lv2) + keysize);
419 	plv2->len = sizeof(struct lv2);
420 	plv2->keyid.len = sizeof(struct keyid);
421 	plv2->keyid.attr = 0x30;
422 	preqcblk->req_parml = sizeof(struct cmreqparm) + keysize;
423 
424 	/* fill xcrb struct */
425 	prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
426 
427 	/* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
428 	rc = _zcrypt_send_cprb(&xcrb);
429 	if (rc) {
430 		DEBUG_ERR(
431 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed with errno %d\n",
432 			__func__, (int) cardnr, (int) domain, rc);
433 		goto out;
434 	}
435 
436 	/* check response returncode and reasoncode */
437 	if (prepcblk->ccp_rtcode != 0) {
438 		DEBUG_ERR(
439 			"%s clear key import failure, card response %d/%d\n",
440 			__func__,
441 			(int) prepcblk->ccp_rtcode,
442 			(int) prepcblk->ccp_rscode);
443 		rc = -EIO;
444 		goto out;
445 	}
446 
447 	/* process response cprb param block */
448 	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
449 	prepparm = (struct cmrepparm *) prepcblk->rpl_parmb;
450 
451 	/* check length of the returned secure key token */
452 	seckeysize = prepparm->lv3.keyblock.toklen
453 		- sizeof(prepparm->lv3.keyblock.toklen)
454 		- sizeof(prepparm->lv3.keyblock.tokattr);
455 	if (seckeysize != SECKEYBLOBSIZE) {
456 		DEBUG_ERR(
457 			"%s secure token size mismatch %d != %d bytes\n",
458 			__func__, seckeysize, SECKEYBLOBSIZE);
459 		rc = -EIO;
460 		goto out;
461 	}
462 
463 	/* check secure key token */
464 	rc = check_secaeskeytoken(prepparm->lv3.keyblock.tok, 8*keysize);
465 	if (rc) {
466 		rc = -EIO;
467 		goto out;
468 	}
469 
470 	/* copy the generated secure key token */
471 	memcpy(seckey->seckey, prepparm->lv3.keyblock.tok, SECKEYBLOBSIZE);
472 
473 out:
474 	free_cprbmem(mem, PARMBSIZE, 1);
475 	return rc;
476 }
477 EXPORT_SYMBOL(pkey_clr2seckey);
478 
479 /*
480  * Derive a proteced key from the secure key blob.
481  */
482 int pkey_sec2protkey(u16 cardnr, u16 domain,
483 		     const struct pkey_seckey *seckey,
484 		     struct pkey_protkey *protkey)
485 {
486 	int rc;
487 	u8 *mem;
488 	struct CPRBX *preqcblk, *prepcblk;
489 	struct ica_xcRB xcrb;
490 	struct uskreqparm {
491 		u8  subfunc_code[2];
492 		u16 rule_array_len;
493 		struct lv1 {
494 			u16 len;
495 			u16 attr_len;
496 			u16 attr_flags;
497 		} lv1;
498 		struct lv2 {
499 			u16 len;
500 			u16 attr_len;
501 			u16 attr_flags;
502 			u8  token[0];	      /* cca secure key token */
503 		} lv2 __packed;
504 	} *preqparm;
505 	struct uskrepparm {
506 		u8  subfunc_code[2];
507 		u16 rule_array_len;
508 		struct lv3 {
509 			u16 len;
510 			u16 attr_len;
511 			u16 attr_flags;
512 			struct cpacfkeyblock {
513 				u8  version;  /* version of this struct */
514 				u8  flags[2];
515 				u8  algo;
516 				u8  form;
517 				u8  pad1[3];
518 				u16 keylen;
519 				u8  key[64];  /* the key (keylen bytes) */
520 				u16 keyattrlen;
521 				u8  keyattr[32];
522 				u8  pad2[1];
523 				u8  vptype;
524 				u8  vp[32];  /* verification pattern */
525 			} keyblock;
526 		} lv3 __packed;
527 	} *prepparm;
528 
529 	/* get already prepared memory for 2 cprbs with param block each */
530 	rc = alloc_and_prep_cprbmem(PARMBSIZE, &mem, &preqcblk, &prepcblk);
531 	if (rc)
532 		return rc;
533 
534 	/* fill request cprb struct */
535 	preqcblk->domain = domain;
536 
537 	/* fill request cprb param block with USK request */
538 	preqparm = (struct uskreqparm *) preqcblk->req_parmb;
539 	memcpy(preqparm->subfunc_code, "US", 2);
540 	preqparm->rule_array_len = sizeof(preqparm->rule_array_len);
541 	preqparm->lv1.len = sizeof(struct lv1);
542 	preqparm->lv1.attr_len = sizeof(struct lv1) - sizeof(preqparm->lv1.len);
543 	preqparm->lv1.attr_flags = 0x0001;
544 	preqparm->lv2.len = sizeof(struct lv2) + SECKEYBLOBSIZE;
545 	preqparm->lv2.attr_len = sizeof(struct lv2)
546 		- sizeof(preqparm->lv2.len) + SECKEYBLOBSIZE;
547 	preqparm->lv2.attr_flags = 0x0000;
548 	memcpy(preqparm->lv2.token, seckey->seckey, SECKEYBLOBSIZE);
549 	preqcblk->req_parml = sizeof(struct uskreqparm) + SECKEYBLOBSIZE;
550 
551 	/* fill xcrb struct */
552 	prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
553 
554 	/* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
555 	rc = _zcrypt_send_cprb(&xcrb);
556 	if (rc) {
557 		DEBUG_ERR(
558 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed with errno %d\n",
559 			__func__, (int) cardnr, (int) domain, rc);
560 		goto out;
561 	}
562 
563 	/* check response returncode and reasoncode */
564 	if (prepcblk->ccp_rtcode != 0) {
565 		DEBUG_ERR(
566 			"%s unwrap secure key failure, card response %d/%d\n",
567 			__func__,
568 			(int) prepcblk->ccp_rtcode,
569 			(int) prepcblk->ccp_rscode);
570 		rc = -EIO;
571 		goto out;
572 	}
573 	if (prepcblk->ccp_rscode != 0) {
574 		DEBUG_WARN(
575 			"%s unwrap secure key warning, card response %d/%d\n",
576 			__func__,
577 			(int) prepcblk->ccp_rtcode,
578 			(int) prepcblk->ccp_rscode);
579 	}
580 
581 	/* process response cprb param block */
582 	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
583 	prepparm = (struct uskrepparm *) prepcblk->rpl_parmb;
584 
585 	/* check the returned keyblock */
586 	if (prepparm->lv3.keyblock.version != 0x01) {
587 		DEBUG_ERR(
588 			"%s reply param keyblock version mismatch 0x%02x != 0x01\n",
589 			__func__, (int) prepparm->lv3.keyblock.version);
590 		rc = -EIO;
591 		goto out;
592 	}
593 
594 	/* copy the tanslated protected key */
595 	switch (prepparm->lv3.keyblock.keylen) {
596 	case 16+32:
597 		protkey->type = PKEY_KEYTYPE_AES_128;
598 		break;
599 	case 24+32:
600 		protkey->type = PKEY_KEYTYPE_AES_192;
601 		break;
602 	case 32+32:
603 		protkey->type = PKEY_KEYTYPE_AES_256;
604 		break;
605 	default:
606 		DEBUG_ERR("%s unknown/unsupported keytype %d\n",
607 			  __func__, prepparm->lv3.keyblock.keylen);
608 		rc = -EIO;
609 		goto out;
610 	}
611 	protkey->len = prepparm->lv3.keyblock.keylen;
612 	memcpy(protkey->protkey, prepparm->lv3.keyblock.key, protkey->len);
613 
614 out:
615 	free_cprbmem(mem, PARMBSIZE, 0);
616 	return rc;
617 }
618 EXPORT_SYMBOL(pkey_sec2protkey);
619 
620 /*
621  * Create a protected key from a clear key value.
622  */
623 int pkey_clr2protkey(u32 keytype,
624 		     const struct pkey_clrkey *clrkey,
625 		     struct pkey_protkey *protkey)
626 {
627 	long fc;
628 	int keysize;
629 	u8 paramblock[64];
630 
631 	switch (keytype) {
632 	case PKEY_KEYTYPE_AES_128:
633 		keysize = 16;
634 		fc = CPACF_PCKMO_ENC_AES_128_KEY;
635 		break;
636 	case PKEY_KEYTYPE_AES_192:
637 		keysize = 24;
638 		fc = CPACF_PCKMO_ENC_AES_192_KEY;
639 		break;
640 	case PKEY_KEYTYPE_AES_256:
641 		keysize = 32;
642 		fc = CPACF_PCKMO_ENC_AES_256_KEY;
643 		break;
644 	default:
645 		DEBUG_ERR("%s unknown/unsupported keytype %d\n",
646 			  __func__, keytype);
647 		return -EINVAL;
648 	}
649 
650 	/* prepare param block */
651 	memset(paramblock, 0, sizeof(paramblock));
652 	memcpy(paramblock, clrkey->clrkey, keysize);
653 
654 	/* call the pckmo instruction */
655 	cpacf_pckmo(fc, paramblock);
656 
657 	/* copy created protected key */
658 	protkey->type = keytype;
659 	protkey->len = keysize + 32;
660 	memcpy(protkey->protkey, paramblock, keysize + 32);
661 
662 	return 0;
663 }
664 EXPORT_SYMBOL(pkey_clr2protkey);
665 
666 /*
667  * query cryptographic facility from adapter
668  */
669 static int query_crypto_facility(u16 cardnr, u16 domain,
670 				 const char *keyword,
671 				 u8 *rarray, size_t *rarraylen,
672 				 u8 *varray, size_t *varraylen)
673 {
674 	int rc;
675 	u16 len;
676 	u8 *mem, *ptr;
677 	struct CPRBX *preqcblk, *prepcblk;
678 	struct ica_xcRB xcrb;
679 	struct fqreqparm {
680 		u8  subfunc_code[2];
681 		u16 rule_array_len;
682 		char  rule_array[8];
683 		struct lv1 {
684 			u16 len;
685 			u8  data[VARDATASIZE];
686 		} lv1;
687 		u16 dummylen;
688 	} *preqparm;
689 	size_t parmbsize = sizeof(struct fqreqparm);
690 	struct fqrepparm {
691 		u8  subfunc_code[2];
692 		u8  lvdata[0];
693 	} *prepparm;
694 
695 	/* get already prepared memory for 2 cprbs with param block each */
696 	rc = alloc_and_prep_cprbmem(parmbsize, &mem, &preqcblk, &prepcblk);
697 	if (rc)
698 		return rc;
699 
700 	/* fill request cprb struct */
701 	preqcblk->domain = domain;
702 
703 	/* fill request cprb param block with FQ request */
704 	preqparm = (struct fqreqparm *) preqcblk->req_parmb;
705 	memcpy(preqparm->subfunc_code, "FQ", 2);
706 	memcpy(preqparm->rule_array, keyword, sizeof(preqparm->rule_array));
707 	preqparm->rule_array_len =
708 		sizeof(preqparm->rule_array_len) + sizeof(preqparm->rule_array);
709 	preqparm->lv1.len = sizeof(preqparm->lv1);
710 	preqparm->dummylen = sizeof(preqparm->dummylen);
711 	preqcblk->req_parml = parmbsize;
712 
713 	/* fill xcrb struct */
714 	prep_xcrb(&xcrb, cardnr, preqcblk, prepcblk);
715 
716 	/* forward xcrb with request CPRB and reply CPRB to zcrypt dd */
717 	rc = _zcrypt_send_cprb(&xcrb);
718 	if (rc) {
719 		DEBUG_ERR(
720 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed with errno %d\n",
721 			__func__, (int) cardnr, (int) domain, rc);
722 		goto out;
723 	}
724 
725 	/* check response returncode and reasoncode */
726 	if (prepcblk->ccp_rtcode != 0) {
727 		DEBUG_ERR(
728 			"%s unwrap secure key failure, card response %d/%d\n",
729 			__func__,
730 			(int) prepcblk->ccp_rtcode,
731 			(int) prepcblk->ccp_rscode);
732 		rc = -EIO;
733 		goto out;
734 	}
735 
736 	/* process response cprb param block */
737 	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
738 	prepparm = (struct fqrepparm *) prepcblk->rpl_parmb;
739 	ptr = prepparm->lvdata;
740 
741 	/* check and possibly copy reply rule array */
742 	len = *((u16 *) ptr);
743 	if (len > sizeof(u16)) {
744 		ptr += sizeof(u16);
745 		len -= sizeof(u16);
746 		if (rarray && rarraylen && *rarraylen > 0) {
747 			*rarraylen = (len > *rarraylen ? *rarraylen : len);
748 			memcpy(rarray, ptr, *rarraylen);
749 		}
750 		ptr += len;
751 	}
752 	/* check and possible copy reply var array */
753 	len = *((u16 *) ptr);
754 	if (len > sizeof(u16)) {
755 		ptr += sizeof(u16);
756 		len -= sizeof(u16);
757 		if (varray && varraylen && *varraylen > 0) {
758 			*varraylen = (len > *varraylen ? *varraylen : len);
759 			memcpy(varray, ptr, *varraylen);
760 		}
761 		ptr += len;
762 	}
763 
764 out:
765 	free_cprbmem(mem, parmbsize, 0);
766 	return rc;
767 }
768 
769 /*
770  * Fetch the current and old mkvp values via
771  * query_crypto_facility from adapter.
772  */
773 static int fetch_mkvp(u16 cardnr, u16 domain, u64 mkvp[2])
774 {
775 	int rc, found = 0;
776 	size_t rlen, vlen;
777 	u8 *rarray, *varray, *pg;
778 
779 	pg = (u8 *) __get_free_page(GFP_KERNEL);
780 	if (!pg)
781 		return -ENOMEM;
782 	rarray = pg;
783 	varray = pg + PAGE_SIZE/2;
784 	rlen = vlen = PAGE_SIZE/2;
785 
786 	rc = query_crypto_facility(cardnr, domain, "STATICSA",
787 				   rarray, &rlen, varray, &vlen);
788 	if (rc == 0 && rlen > 8*8 && vlen > 184+8) {
789 		if (rarray[8*8] == '2') {
790 			/* current master key state is valid */
791 			mkvp[0] = *((u64 *)(varray + 184));
792 			mkvp[1] = *((u64 *)(varray + 172));
793 			found = 1;
794 		}
795 	}
796 
797 	free_page((unsigned long) pg);
798 
799 	return found ? 0 : -ENOENT;
800 }
801 
802 /* struct to hold cached mkvp info for each card/domain */
803 struct mkvp_info {
804 	struct list_head list;
805 	u16 cardnr;
806 	u16 domain;
807 	u64 mkvp[2];
808 };
809 
810 /* a list with mkvp_info entries */
811 static LIST_HEAD(mkvp_list);
812 static DEFINE_SPINLOCK(mkvp_list_lock);
813 
814 static int mkvp_cache_fetch(u16 cardnr, u16 domain, u64 mkvp[2])
815 {
816 	int rc = -ENOENT;
817 	struct mkvp_info *ptr;
818 
819 	spin_lock_bh(&mkvp_list_lock);
820 	list_for_each_entry(ptr, &mkvp_list, list) {
821 		if (ptr->cardnr == cardnr &&
822 		    ptr->domain == domain) {
823 			memcpy(mkvp, ptr->mkvp, 2 * sizeof(u64));
824 			rc = 0;
825 			break;
826 		}
827 	}
828 	spin_unlock_bh(&mkvp_list_lock);
829 
830 	return rc;
831 }
832 
833 static void mkvp_cache_update(u16 cardnr, u16 domain, u64 mkvp[2])
834 {
835 	int found = 0;
836 	struct mkvp_info *ptr;
837 
838 	spin_lock_bh(&mkvp_list_lock);
839 	list_for_each_entry(ptr, &mkvp_list, list) {
840 		if (ptr->cardnr == cardnr &&
841 		    ptr->domain == domain) {
842 			memcpy(ptr->mkvp, mkvp, 2 * sizeof(u64));
843 			found = 1;
844 			break;
845 		}
846 	}
847 	if (!found) {
848 		ptr = kmalloc(sizeof(*ptr), GFP_ATOMIC);
849 		if (!ptr) {
850 			spin_unlock_bh(&mkvp_list_lock);
851 			return;
852 		}
853 		ptr->cardnr = cardnr;
854 		ptr->domain = domain;
855 		memcpy(ptr->mkvp, mkvp, 2 * sizeof(u64));
856 		list_add(&ptr->list, &mkvp_list);
857 	}
858 	spin_unlock_bh(&mkvp_list_lock);
859 }
860 
861 static void mkvp_cache_scrub(u16 cardnr, u16 domain)
862 {
863 	struct mkvp_info *ptr;
864 
865 	spin_lock_bh(&mkvp_list_lock);
866 	list_for_each_entry(ptr, &mkvp_list, list) {
867 		if (ptr->cardnr == cardnr &&
868 		    ptr->domain == domain) {
869 			list_del(&ptr->list);
870 			kfree(ptr);
871 			break;
872 		}
873 	}
874 	spin_unlock_bh(&mkvp_list_lock);
875 }
876 
877 static void __exit mkvp_cache_free(void)
878 {
879 	struct mkvp_info *ptr, *pnext;
880 
881 	spin_lock_bh(&mkvp_list_lock);
882 	list_for_each_entry_safe(ptr, pnext, &mkvp_list, list) {
883 		list_del(&ptr->list);
884 		kfree(ptr);
885 	}
886 	spin_unlock_bh(&mkvp_list_lock);
887 }
888 
889 /*
890  * Search for a matching crypto card based on the Master Key
891  * Verification Pattern provided inside a secure key.
892  */
893 int pkey_findcard(const struct pkey_seckey *seckey,
894 		  u16 *pcardnr, u16 *pdomain, int verify)
895 {
896 	struct secaeskeytoken *t = (struct secaeskeytoken *) seckey;
897 	struct zcrypt_device_status_ext *device_status;
898 	u16 card, dom;
899 	u64 mkvp[2];
900 	int i, rc, oi = -1;
901 
902 	/* mkvp must not be zero */
903 	if (t->mkvp == 0)
904 		return -EINVAL;
905 
906 	/* fetch status of all crypto cards */
907 	device_status = kmalloc_array(MAX_ZDEV_ENTRIES_EXT,
908 				      sizeof(struct zcrypt_device_status_ext),
909 				      GFP_KERNEL);
910 	if (!device_status)
911 		return -ENOMEM;
912 	zcrypt_device_status_mask_ext(device_status);
913 
914 	/* walk through all crypto cards */
915 	for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
916 		card = AP_QID_CARD(device_status[i].qid);
917 		dom = AP_QID_QUEUE(device_status[i].qid);
918 		if (device_status[i].online &&
919 		    device_status[i].functions & 0x04) {
920 			/* an enabled CCA Coprocessor card */
921 			/* try cached mkvp */
922 			if (mkvp_cache_fetch(card, dom, mkvp) == 0 &&
923 			    t->mkvp == mkvp[0]) {
924 				if (!verify)
925 					break;
926 				/* verify: fetch mkvp from adapter */
927 				if (fetch_mkvp(card, dom, mkvp) == 0) {
928 					mkvp_cache_update(card, dom, mkvp);
929 					if (t->mkvp == mkvp[0])
930 						break;
931 				}
932 			}
933 		} else {
934 			/* Card is offline and/or not a CCA card. */
935 			/* del mkvp entry from cache if it exists */
936 			mkvp_cache_scrub(card, dom);
937 		}
938 	}
939 	if (i >= MAX_ZDEV_ENTRIES_EXT) {
940 		/* nothing found, so this time without cache */
941 		for (i = 0; i < MAX_ZDEV_ENTRIES_EXT; i++) {
942 			if (!(device_status[i].online &&
943 			      device_status[i].functions & 0x04))
944 				continue;
945 			card = AP_QID_CARD(device_status[i].qid);
946 			dom = AP_QID_QUEUE(device_status[i].qid);
947 			/* fresh fetch mkvp from adapter */
948 			if (fetch_mkvp(card, dom, mkvp) == 0) {
949 				mkvp_cache_update(card, dom, mkvp);
950 				if (t->mkvp == mkvp[0])
951 					break;
952 				if (t->mkvp == mkvp[1] && oi < 0)
953 					oi = i;
954 			}
955 		}
956 		if (i >= MAX_ZDEV_ENTRIES_EXT && oi >= 0) {
957 			/* old mkvp matched, use this card then */
958 			card = AP_QID_CARD(device_status[oi].qid);
959 			dom = AP_QID_QUEUE(device_status[oi].qid);
960 		}
961 	}
962 	if (i < MAX_ZDEV_ENTRIES_EXT || oi >= 0) {
963 		if (pcardnr)
964 			*pcardnr = card;
965 		if (pdomain)
966 			*pdomain = dom;
967 		rc = 0;
968 	} else
969 		rc = -ENODEV;
970 
971 	kfree(device_status);
972 	return rc;
973 }
974 EXPORT_SYMBOL(pkey_findcard);
975 
976 /*
977  * Find card and transform secure key into protected key.
978  */
979 int pkey_skey2pkey(const struct pkey_seckey *seckey,
980 		   struct pkey_protkey *protkey)
981 {
982 	u16 cardnr, domain;
983 	int rc, verify;
984 
985 	/*
986 	 * The pkey_sec2protkey call may fail when a card has been
987 	 * addressed where the master key was changed after last fetch
988 	 * of the mkvp into the cache. So first try without verify then
989 	 * with verify enabled (thus refreshing the mkvp for each card).
990 	 */
991 	for (verify = 0; verify < 2; verify++) {
992 		rc = pkey_findcard(seckey, &cardnr, &domain, verify);
993 		if (rc)
994 			continue;
995 		rc = pkey_sec2protkey(cardnr, domain, seckey, protkey);
996 		if (rc == 0)
997 			break;
998 	}
999 
1000 	if (rc)
1001 		DEBUG_DBG("%s failed rc=%d\n", __func__, rc);
1002 
1003 	return rc;
1004 }
1005 EXPORT_SYMBOL(pkey_skey2pkey);
1006 
1007 /*
1008  * Verify key and give back some info about the key.
1009  */
1010 int pkey_verifykey(const struct pkey_seckey *seckey,
1011 		   u16 *pcardnr, u16 *pdomain,
1012 		   u16 *pkeysize, u32 *pattributes)
1013 {
1014 	struct secaeskeytoken *t = (struct secaeskeytoken *) seckey;
1015 	u16 cardnr, domain;
1016 	u64 mkvp[2];
1017 	int rc;
1018 
1019 	/* check the secure key for valid AES secure key */
1020 	rc = check_secaeskeytoken((u8 *) seckey, 0);
1021 	if (rc)
1022 		goto out;
1023 	if (pattributes)
1024 		*pattributes = PKEY_VERIFY_ATTR_AES;
1025 	if (pkeysize)
1026 		*pkeysize = t->bitsize;
1027 
1028 	/* try to find a card which can handle this key */
1029 	rc = pkey_findcard(seckey, &cardnr, &domain, 1);
1030 	if (rc)
1031 		goto out;
1032 
1033 	/* check mkvp for old mkvp match */
1034 	rc = mkvp_cache_fetch(cardnr, domain, mkvp);
1035 	if (rc)
1036 		goto out;
1037 	if (t->mkvp == mkvp[1]) {
1038 		DEBUG_DBG("%s secure key has old mkvp\n", __func__);
1039 		if (pattributes)
1040 			*pattributes |= PKEY_VERIFY_ATTR_OLD_MKVP;
1041 	}
1042 
1043 	if (pcardnr)
1044 		*pcardnr = cardnr;
1045 	if (pdomain)
1046 		*pdomain = domain;
1047 
1048 out:
1049 	DEBUG_DBG("%s rc=%d\n", __func__, rc);
1050 	return rc;
1051 }
1052 EXPORT_SYMBOL(pkey_verifykey);
1053 
1054 /*
1055  * File io functions
1056  */
1057 
1058 static long pkey_unlocked_ioctl(struct file *filp, unsigned int cmd,
1059 				unsigned long arg)
1060 {
1061 	int rc;
1062 
1063 	switch (cmd) {
1064 	case PKEY_GENSECK: {
1065 		struct pkey_genseck __user *ugs = (void __user *) arg;
1066 		struct pkey_genseck kgs;
1067 
1068 		if (copy_from_user(&kgs, ugs, sizeof(kgs)))
1069 			return -EFAULT;
1070 		rc = pkey_genseckey(kgs.cardnr, kgs.domain,
1071 				    kgs.keytype, &kgs.seckey);
1072 		DEBUG_DBG("%s pkey_genseckey()=%d\n", __func__, rc);
1073 		if (rc)
1074 			break;
1075 		if (copy_to_user(ugs, &kgs, sizeof(kgs)))
1076 			return -EFAULT;
1077 		break;
1078 	}
1079 	case PKEY_CLR2SECK: {
1080 		struct pkey_clr2seck __user *ucs = (void __user *) arg;
1081 		struct pkey_clr2seck kcs;
1082 
1083 		if (copy_from_user(&kcs, ucs, sizeof(kcs)))
1084 			return -EFAULT;
1085 		rc = pkey_clr2seckey(kcs.cardnr, kcs.domain, kcs.keytype,
1086 				     &kcs.clrkey, &kcs.seckey);
1087 		DEBUG_DBG("%s pkey_clr2seckey()=%d\n", __func__, rc);
1088 		if (rc)
1089 			break;
1090 		if (copy_to_user(ucs, &kcs, sizeof(kcs)))
1091 			return -EFAULT;
1092 		memzero_explicit(&kcs, sizeof(kcs));
1093 		break;
1094 	}
1095 	case PKEY_SEC2PROTK: {
1096 		struct pkey_sec2protk __user *usp = (void __user *) arg;
1097 		struct pkey_sec2protk ksp;
1098 
1099 		if (copy_from_user(&ksp, usp, sizeof(ksp)))
1100 			return -EFAULT;
1101 		rc = pkey_sec2protkey(ksp.cardnr, ksp.domain,
1102 				      &ksp.seckey, &ksp.protkey);
1103 		DEBUG_DBG("%s pkey_sec2protkey()=%d\n", __func__, rc);
1104 		if (rc)
1105 			break;
1106 		if (copy_to_user(usp, &ksp, sizeof(ksp)))
1107 			return -EFAULT;
1108 		break;
1109 	}
1110 	case PKEY_CLR2PROTK: {
1111 		struct pkey_clr2protk __user *ucp = (void __user *) arg;
1112 		struct pkey_clr2protk kcp;
1113 
1114 		if (copy_from_user(&kcp, ucp, sizeof(kcp)))
1115 			return -EFAULT;
1116 		rc = pkey_clr2protkey(kcp.keytype,
1117 				      &kcp.clrkey, &kcp.protkey);
1118 		DEBUG_DBG("%s pkey_clr2protkey()=%d\n", __func__, rc);
1119 		if (rc)
1120 			break;
1121 		if (copy_to_user(ucp, &kcp, sizeof(kcp)))
1122 			return -EFAULT;
1123 		memzero_explicit(&kcp, sizeof(kcp));
1124 		break;
1125 	}
1126 	case PKEY_FINDCARD: {
1127 		struct pkey_findcard __user *ufc = (void __user *) arg;
1128 		struct pkey_findcard kfc;
1129 
1130 		if (copy_from_user(&kfc, ufc, sizeof(kfc)))
1131 			return -EFAULT;
1132 		rc = pkey_findcard(&kfc.seckey,
1133 				   &kfc.cardnr, &kfc.domain, 1);
1134 		DEBUG_DBG("%s pkey_findcard()=%d\n", __func__, rc);
1135 		if (rc)
1136 			break;
1137 		if (copy_to_user(ufc, &kfc, sizeof(kfc)))
1138 			return -EFAULT;
1139 		break;
1140 	}
1141 	case PKEY_SKEY2PKEY: {
1142 		struct pkey_skey2pkey __user *usp = (void __user *) arg;
1143 		struct pkey_skey2pkey ksp;
1144 
1145 		if (copy_from_user(&ksp, usp, sizeof(ksp)))
1146 			return -EFAULT;
1147 		rc = pkey_skey2pkey(&ksp.seckey, &ksp.protkey);
1148 		DEBUG_DBG("%s pkey_skey2pkey()=%d\n", __func__, rc);
1149 		if (rc)
1150 			break;
1151 		if (copy_to_user(usp, &ksp, sizeof(ksp)))
1152 			return -EFAULT;
1153 		break;
1154 	}
1155 	case PKEY_VERIFYKEY: {
1156 		struct pkey_verifykey __user *uvk = (void __user *) arg;
1157 		struct pkey_verifykey kvk;
1158 
1159 		if (copy_from_user(&kvk, uvk, sizeof(kvk)))
1160 			return -EFAULT;
1161 		rc = pkey_verifykey(&kvk.seckey, &kvk.cardnr, &kvk.domain,
1162 				    &kvk.keysize, &kvk.attributes);
1163 		DEBUG_DBG("%s pkey_verifykey()=%d\n", __func__, rc);
1164 		if (rc)
1165 			break;
1166 		if (copy_to_user(uvk, &kvk, sizeof(kvk)))
1167 			return -EFAULT;
1168 		break;
1169 	}
1170 	default:
1171 		/* unknown/unsupported ioctl cmd */
1172 		return -ENOTTY;
1173 	}
1174 
1175 	return rc;
1176 }
1177 
1178 /*
1179  * Sysfs and file io operations
1180  */
1181 static const struct file_operations pkey_fops = {
1182 	.owner		= THIS_MODULE,
1183 	.open		= nonseekable_open,
1184 	.llseek		= no_llseek,
1185 	.unlocked_ioctl = pkey_unlocked_ioctl,
1186 };
1187 
1188 static struct miscdevice pkey_dev = {
1189 	.name	= "pkey",
1190 	.minor	= MISC_DYNAMIC_MINOR,
1191 	.mode	= 0666,
1192 	.fops	= &pkey_fops,
1193 };
1194 
1195 /*
1196  * Module init
1197  */
1198 static int __init pkey_init(void)
1199 {
1200 	cpacf_mask_t pckmo_functions;
1201 
1202 	/* check for pckmo instructions available */
1203 	if (!cpacf_query(CPACF_PCKMO, &pckmo_functions))
1204 		return -EOPNOTSUPP;
1205 	if (!cpacf_test_func(&pckmo_functions, CPACF_PCKMO_ENC_AES_128_KEY) ||
1206 	    !cpacf_test_func(&pckmo_functions, CPACF_PCKMO_ENC_AES_192_KEY) ||
1207 	    !cpacf_test_func(&pckmo_functions, CPACF_PCKMO_ENC_AES_256_KEY))
1208 		return -EOPNOTSUPP;
1209 
1210 	pkey_debug_init();
1211 
1212 	return misc_register(&pkey_dev);
1213 }
1214 
1215 /*
1216  * Module exit
1217  */
1218 static void __exit pkey_exit(void)
1219 {
1220 	misc_deregister(&pkey_dev);
1221 	mkvp_cache_free();
1222 	pkey_debug_exit();
1223 }
1224 
1225 module_init(pkey_init);
1226 module_exit(pkey_exit);
1227