xref: /openbmc/linux/arch/sparc/crypto/des_glue.c (revision ff6defa6) 
1 /* Glue code for DES encryption optimized for sparc64 crypto opcodes.
2  *
3  * Copyright (C) 2012 David S. Miller <davem@davemloft.net>
4  */
5 
6 #define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt
7 
8 #include <linux/crypto.h>
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/mm.h>
12 #include <linux/types.h>
13 #include <crypto/algapi.h>
14 #include <crypto/des.h>
15 
16 #include <asm/fpumacro.h>
17 #include <asm/pstate.h>
18 #include <asm/elf.h>
19 
20 #include "opcodes.h"
21 
22 struct des_sparc64_ctx {
23 	u64 encrypt_expkey[DES_EXPKEY_WORDS / 2];
24 	u64 decrypt_expkey[DES_EXPKEY_WORDS / 2];
25 };
26 
27 struct des3_ede_sparc64_ctx {
28 	u64 encrypt_expkey[DES3_EDE_EXPKEY_WORDS / 2];
29 	u64 decrypt_expkey[DES3_EDE_EXPKEY_WORDS / 2];
30 };
31 
32 static void encrypt_to_decrypt(u64 *d, const u64 *e)
33 {
34 	const u64 *s = e + (DES_EXPKEY_WORDS / 2) - 1;
35 	int i;
36 
37 	for (i = 0; i < DES_EXPKEY_WORDS / 2; i++)
38 		*d++ = *s--;
39 }
40 
41 extern void des_sparc64_key_expand(const u32 *input_key, u64 *key);
42 
43 static int des_set_key(struct crypto_tfm *tfm, const u8 *key,
44 		       unsigned int keylen)
45 {
46 	struct des_sparc64_ctx *dctx = crypto_tfm_ctx(tfm);
47 	u32 *flags = &tfm->crt_flags;
48 	u32 tmp[DES_EXPKEY_WORDS];
49 	int ret;
50 
51 	/* Even though we have special instructions for key expansion,
52 	 * we call des_ekey() so that we don't have to write our own
53 	 * weak key detection code.
54 	 */
55 	ret = des_ekey(tmp, key);
56 	if (unlikely(ret == 0) && (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
57 		*flags |= CRYPTO_TFM_RES_WEAK_KEY;
58 		return -EINVAL;
59 	}
60 
61 	des_sparc64_key_expand((const u32 *) key, &dctx->encrypt_expkey[0]);
62 	encrypt_to_decrypt(&dctx->decrypt_expkey[0], &dctx->encrypt_expkey[0]);
63 
64 	return 0;
65 }
66 
67 extern void des_sparc64_crypt(const u64 *key, const u64 *input,
68 			      u64 *output);
69 
70 static void des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
71 {
72 	struct des_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
73 	const u64 *K = ctx->encrypt_expkey;
74 
75 	des_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);
76 }
77 
78 static void des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
79 {
80 	struct des_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
81 	const u64 *K = ctx->decrypt_expkey;
82 
83 	des_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);
84 }
85 
86 extern void des_sparc64_load_keys(const u64 *key);
87 
88 extern void des_sparc64_ecb_crypt(const u64 *input, u64 *output,
89 				  unsigned int len);
90 
91 #define DES_BLOCK_MASK	(~(DES_BLOCK_SIZE - 1))
92 
93 static int __ecb_crypt(struct blkcipher_desc *desc,
94 		       struct scatterlist *dst, struct scatterlist *src,
95 		       unsigned int nbytes, bool encrypt)
96 {
97 	struct des_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
98 	struct blkcipher_walk walk;
99 	int err;
100 
101 	blkcipher_walk_init(&walk, dst, src, nbytes);
102 	err = blkcipher_walk_virt(desc, &walk);
103 	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
104 
105 	if (encrypt)
106 		des_sparc64_load_keys(&ctx->encrypt_expkey[0]);
107 	else
108 		des_sparc64_load_keys(&ctx->decrypt_expkey[0]);
109 	while ((nbytes = walk.nbytes)) {
110 		unsigned int block_len = nbytes & DES_BLOCK_MASK;
111 
112 		if (likely(block_len)) {
113 			des_sparc64_ecb_crypt((const u64 *)walk.src.virt.addr,
114 					      (u64 *) walk.dst.virt.addr,
115 					      block_len);
116 		}
117 		nbytes &= DES_BLOCK_SIZE - 1;
118 		err = blkcipher_walk_done(desc, &walk, nbytes);
119 	}
120 	fprs_write(0);
121 	return err;
122 }
123 
124 static int ecb_encrypt(struct blkcipher_desc *desc,
125 		       struct scatterlist *dst, struct scatterlist *src,
126 		       unsigned int nbytes)
127 {
128 	return __ecb_crypt(desc, dst, src, nbytes, true);
129 }
130 
131 static int ecb_decrypt(struct blkcipher_desc *desc,
132 		       struct scatterlist *dst, struct scatterlist *src,
133 		       unsigned int nbytes)
134 {
135 	return __ecb_crypt(desc, dst, src, nbytes, false);
136 }
137 
138 extern void des_sparc64_cbc_encrypt(const u64 *input, u64 *output,
139 				    unsigned int len, u64 *iv);
140 
141 static int cbc_encrypt(struct blkcipher_desc *desc,
142 		       struct scatterlist *dst, struct scatterlist *src,
143 		       unsigned int nbytes)
144 {
145 	struct des_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
146 	struct blkcipher_walk walk;
147 	int err;
148 
149 	blkcipher_walk_init(&walk, dst, src, nbytes);
150 	err = blkcipher_walk_virt(desc, &walk);
151 	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
152 
153 	des_sparc64_load_keys(&ctx->encrypt_expkey[0]);
154 	while ((nbytes = walk.nbytes)) {
155 		unsigned int block_len = nbytes & DES_BLOCK_MASK;
156 
157 		if (likely(block_len)) {
158 			des_sparc64_cbc_encrypt((const u64 *)walk.src.virt.addr,
159 						(u64 *) walk.dst.virt.addr,
160 						block_len, (u64 *) walk.iv);
161 		}
162 		nbytes &= DES_BLOCK_SIZE - 1;
163 		err = blkcipher_walk_done(desc, &walk, nbytes);
164 	}
165 	fprs_write(0);
166 	return err;
167 }
168 
169 extern void des_sparc64_cbc_decrypt(const u64 *input, u64 *output,
170 				    unsigned int len, u64 *iv);
171 
172 static int cbc_decrypt(struct blkcipher_desc *desc,
173 		       struct scatterlist *dst, struct scatterlist *src,
174 		       unsigned int nbytes)
175 {
176 	struct des_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
177 	struct blkcipher_walk walk;
178 	int err;
179 
180 	blkcipher_walk_init(&walk, dst, src, nbytes);
181 	err = blkcipher_walk_virt(desc, &walk);
182 	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
183 
184 	des_sparc64_load_keys(&ctx->decrypt_expkey[0]);
185 	while ((nbytes = walk.nbytes)) {
186 		unsigned int block_len = nbytes & DES_BLOCK_MASK;
187 
188 		if (likely(block_len)) {
189 			des_sparc64_cbc_decrypt((const u64 *)walk.src.virt.addr,
190 						(u64 *) walk.dst.virt.addr,
191 						block_len, (u64 *) walk.iv);
192 		}
193 		nbytes &= DES_BLOCK_SIZE - 1;
194 		err = blkcipher_walk_done(desc, &walk, nbytes);
195 	}
196 	fprs_write(0);
197 	return err;
198 }
199 
200 static int des3_ede_set_key(struct crypto_tfm *tfm, const u8 *key,
201 			    unsigned int keylen)
202 {
203 	struct des3_ede_sparc64_ctx *dctx = crypto_tfm_ctx(tfm);
204 	const u32 *K = (const u32 *)key;
205 	u32 *flags = &tfm->crt_flags;
206 	u64 k1[DES_EXPKEY_WORDS / 2];
207 	u64 k2[DES_EXPKEY_WORDS / 2];
208 	u64 k3[DES_EXPKEY_WORDS / 2];
209 
210 	if (unlikely(!((K[0] ^ K[2]) | (K[1] ^ K[3])) ||
211 		     !((K[2] ^ K[4]) | (K[3] ^ K[5]))) &&
212 		     (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
213 		*flags |= CRYPTO_TFM_RES_WEAK_KEY;
214 		return -EINVAL;
215 	}
216 
217 	des_sparc64_key_expand((const u32 *)key, k1);
218 	key += DES_KEY_SIZE;
219 	des_sparc64_key_expand((const u32 *)key, k2);
220 	key += DES_KEY_SIZE;
221 	des_sparc64_key_expand((const u32 *)key, k3);
222 
223 	memcpy(&dctx->encrypt_expkey[0], &k1[0], sizeof(k1));
224 	encrypt_to_decrypt(&dctx->encrypt_expkey[DES_EXPKEY_WORDS / 2], &k2[0]);
225 	memcpy(&dctx->encrypt_expkey[(DES_EXPKEY_WORDS / 2) * 2],
226 	       &k3[0], sizeof(k3));
227 
228 	encrypt_to_decrypt(&dctx->decrypt_expkey[0], &k3[0]);
229 	memcpy(&dctx->decrypt_expkey[DES_EXPKEY_WORDS / 2],
230 	       &k2[0], sizeof(k2));
231 	encrypt_to_decrypt(&dctx->decrypt_expkey[(DES_EXPKEY_WORDS / 2) * 2],
232 			   &k1[0]);
233 
234 	return 0;
235 }
236 
237 extern void des3_ede_sparc64_crypt(const u64 *key, const u64 *input,
238 				   u64 *output);
239 
240 static void des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
241 {
242 	struct des3_ede_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
243 	const u64 *K = ctx->encrypt_expkey;
244 
245 	des3_ede_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);
246 }
247 
248 static void des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
249 {
250 	struct des3_ede_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
251 	const u64 *K = ctx->decrypt_expkey;
252 
253 	des3_ede_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);
254 }
255 
256 extern void des3_ede_sparc64_load_keys(const u64 *key);
257 
258 extern void des3_ede_sparc64_ecb_crypt(const u64 *expkey, const u64 *input,
259 				       u64 *output, unsigned int len);
260 
261 static int __ecb3_crypt(struct blkcipher_desc *desc,
262 			struct scatterlist *dst, struct scatterlist *src,
263 			unsigned int nbytes, bool encrypt)
264 {
265 	struct des3_ede_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
266 	struct blkcipher_walk walk;
267 	const u64 *K;
268 	int err;
269 
270 	blkcipher_walk_init(&walk, dst, src, nbytes);
271 	err = blkcipher_walk_virt(desc, &walk);
272 	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
273 
274 	if (encrypt)
275 		K = &ctx->encrypt_expkey[0];
276 	else
277 		K = &ctx->decrypt_expkey[0];
278 	des3_ede_sparc64_load_keys(K);
279 	while ((nbytes = walk.nbytes)) {
280 		unsigned int block_len = nbytes & DES_BLOCK_MASK;
281 
282 		if (likely(block_len)) {
283 			const u64 *src64 = (const u64 *)walk.src.virt.addr;
284 			des3_ede_sparc64_ecb_crypt(K, src64,
285 						   (u64 *) walk.dst.virt.addr,
286 						   block_len);
287 		}
288 		nbytes &= DES_BLOCK_SIZE - 1;
289 		err = blkcipher_walk_done(desc, &walk, nbytes);
290 	}
291 	fprs_write(0);
292 	return err;
293 }
294 
295 static int ecb3_encrypt(struct blkcipher_desc *desc,
296 		       struct scatterlist *dst, struct scatterlist *src,
297 		       unsigned int nbytes)
298 {
299 	return __ecb3_crypt(desc, dst, src, nbytes, true);
300 }
301 
302 static int ecb3_decrypt(struct blkcipher_desc *desc,
303 		       struct scatterlist *dst, struct scatterlist *src,
304 		       unsigned int nbytes)
305 {
306 	return __ecb3_crypt(desc, dst, src, nbytes, false);
307 }
308 
309 extern void des3_ede_sparc64_cbc_encrypt(const u64 *expkey, const u64 *input,
310 					 u64 *output, unsigned int len,
311 					 u64 *iv);
312 
313 static int cbc3_encrypt(struct blkcipher_desc *desc,
314 			struct scatterlist *dst, struct scatterlist *src,
315 			unsigned int nbytes)
316 {
317 	struct des3_ede_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
318 	struct blkcipher_walk walk;
319 	const u64 *K;
320 	int err;
321 
322 	blkcipher_walk_init(&walk, dst, src, nbytes);
323 	err = blkcipher_walk_virt(desc, &walk);
324 	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
325 
326 	K = &ctx->encrypt_expkey[0];
327 	des3_ede_sparc64_load_keys(K);
328 	while ((nbytes = walk.nbytes)) {
329 		unsigned int block_len = nbytes & DES_BLOCK_MASK;
330 
331 		if (likely(block_len)) {
332 			const u64 *src64 = (const u64 *)walk.src.virt.addr;
333 			des3_ede_sparc64_cbc_encrypt(K, src64,
334 						     (u64 *) walk.dst.virt.addr,
335 						     block_len,
336 						     (u64 *) walk.iv);
337 		}
338 		nbytes &= DES_BLOCK_SIZE - 1;
339 		err = blkcipher_walk_done(desc, &walk, nbytes);
340 	}
341 	fprs_write(0);
342 	return err;
343 }
344 
345 extern void des3_ede_sparc64_cbc_decrypt(const u64 *expkey, const u64 *input,
346 					 u64 *output, unsigned int len,
347 					 u64 *iv);
348 
349 static int cbc3_decrypt(struct blkcipher_desc *desc,
350 			struct scatterlist *dst, struct scatterlist *src,
351 			unsigned int nbytes)
352 {
353 	struct des3_ede_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
354 	struct blkcipher_walk walk;
355 	const u64 *K;
356 	int err;
357 
358 	blkcipher_walk_init(&walk, dst, src, nbytes);
359 	err = blkcipher_walk_virt(desc, &walk);
360 	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
361 
362 	K = &ctx->decrypt_expkey[0];
363 	des3_ede_sparc64_load_keys(K);
364 	while ((nbytes = walk.nbytes)) {
365 		unsigned int block_len = nbytes & DES_BLOCK_MASK;
366 
367 		if (likely(block_len)) {
368 			const u64 *src64 = (const u64 *)walk.src.virt.addr;
369 			des3_ede_sparc64_cbc_decrypt(K, src64,
370 						     (u64 *) walk.dst.virt.addr,
371 						     block_len,
372 						     (u64 *) walk.iv);
373 		}
374 		nbytes &= DES_BLOCK_SIZE - 1;
375 		err = blkcipher_walk_done(desc, &walk, nbytes);
376 	}
377 	fprs_write(0);
378 	return err;
379 }
380 
381 static struct crypto_alg algs[] = { {
382 	.cra_name		= "des",
383 	.cra_driver_name	= "des-sparc64",
384 	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
385 	.cra_flags		= CRYPTO_ALG_TYPE_CIPHER,
386 	.cra_blocksize		= DES_BLOCK_SIZE,
387 	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
388 	.cra_alignmask		= 7,
389 	.cra_module		= THIS_MODULE,
390 	.cra_u	= {
391 		.cipher	= {
392 			.cia_min_keysize	= DES_KEY_SIZE,
393 			.cia_max_keysize	= DES_KEY_SIZE,
394 			.cia_setkey		= des_set_key,
395 			.cia_encrypt		= des_encrypt,
396 			.cia_decrypt		= des_decrypt
397 		}
398 	}
399 }, {
400 	.cra_name		= "ecb(des)",
401 	.cra_driver_name	= "ecb-des-sparc64",
402 	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
403 	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
404 	.cra_blocksize		= DES_BLOCK_SIZE,
405 	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
406 	.cra_alignmask		= 7,
407 	.cra_type		= &crypto_blkcipher_type,
408 	.cra_module		= THIS_MODULE,
409 	.cra_u = {
410 		.blkcipher = {
411 			.min_keysize	= DES_KEY_SIZE,
412 			.max_keysize	= DES_KEY_SIZE,
413 			.setkey		= des_set_key,
414 			.encrypt	= ecb_encrypt,
415 			.decrypt	= ecb_decrypt,
416 		},
417 	},
418 }, {
419 	.cra_name		= "cbc(des)",
420 	.cra_driver_name	= "cbc-des-sparc64",
421 	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
422 	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
423 	.cra_blocksize		= DES_BLOCK_SIZE,
424 	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
425 	.cra_alignmask		= 7,
426 	.cra_type		= &crypto_blkcipher_type,
427 	.cra_module		= THIS_MODULE,
428 	.cra_u = {
429 		.blkcipher = {
430 			.min_keysize	= DES_KEY_SIZE,
431 			.max_keysize	= DES_KEY_SIZE,
432 			.setkey		= des_set_key,
433 			.encrypt	= cbc_encrypt,
434 			.decrypt	= cbc_decrypt,
435 		},
436 	},
437 }, {
438 	.cra_name		= "des3_ede",
439 	.cra_driver_name	= "des3_ede-sparc64",
440 	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
441 	.cra_flags		= CRYPTO_ALG_TYPE_CIPHER,
442 	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
443 	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
444 	.cra_alignmask		= 7,
445 	.cra_module		= THIS_MODULE,
446 	.cra_u	= {
447 		.cipher	= {
448 			.cia_min_keysize	= DES3_EDE_KEY_SIZE,
449 			.cia_max_keysize	= DES3_EDE_KEY_SIZE,
450 			.cia_setkey		= des3_ede_set_key,
451 			.cia_encrypt		= des3_ede_encrypt,
452 			.cia_decrypt		= des3_ede_decrypt
453 		}
454 	}
455 }, {
456 	.cra_name		= "ecb(des3_ede)",
457 	.cra_driver_name	= "ecb-des3_ede-sparc64",
458 	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
459 	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
460 	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
461 	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
462 	.cra_alignmask		= 7,
463 	.cra_type		= &crypto_blkcipher_type,
464 	.cra_module		= THIS_MODULE,
465 	.cra_u = {
466 		.blkcipher = {
467 			.min_keysize	= DES3_EDE_KEY_SIZE,
468 			.max_keysize	= DES3_EDE_KEY_SIZE,
469 			.setkey		= des3_ede_set_key,
470 			.encrypt	= ecb3_encrypt,
471 			.decrypt	= ecb3_decrypt,
472 		},
473 	},
474 }, {
475 	.cra_name		= "cbc(des3_ede)",
476 	.cra_driver_name	= "cbc-des3_ede-sparc64",
477 	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
478 	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
479 	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
480 	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
481 	.cra_alignmask		= 7,
482 	.cra_type		= &crypto_blkcipher_type,
483 	.cra_module		= THIS_MODULE,
484 	.cra_u = {
485 		.blkcipher = {
486 			.min_keysize	= DES3_EDE_KEY_SIZE,
487 			.max_keysize	= DES3_EDE_KEY_SIZE,
488 			.setkey		= des3_ede_set_key,
489 			.encrypt	= cbc3_encrypt,
490 			.decrypt	= cbc3_decrypt,
491 		},
492 	},
493 } };
494 
495 static bool __init sparc64_has_des_opcode(void)
496 {
497 	unsigned long cfr;
498 
499 	if (!(sparc64_elf_hwcap & HWCAP_SPARC_CRYPTO))
500 		return false;
501 
502 	__asm__ __volatile__("rd %%asr26, %0" : "=r" (cfr));
503 	if (!(cfr & CFR_DES))
504 		return false;
505 
506 	return true;
507 }
508 
509 static int __init des_sparc64_mod_init(void)
510 {
511 	int i;
512 
513 	for (i = 0; i < ARRAY_SIZE(algs); i++)
514 		INIT_LIST_HEAD(&algs[i].cra_list);
515 
516 	if (sparc64_has_des_opcode()) {
517 		pr_info("Using sparc64 des opcodes optimized DES implementation\n");
518 		return crypto_register_algs(algs, ARRAY_SIZE(algs));
519 	}
520 	pr_info("sparc64 des opcodes not available.\n");
521 	return -ENODEV;
522 }
523 
524 static void __exit des_sparc64_mod_fini(void)
525 {
526 	crypto_unregister_algs(algs, ARRAY_SIZE(algs));
527 }
528 
529 module_init(des_sparc64_mod_init);
530 module_exit(des_sparc64_mod_fini);
531 
532 MODULE_LICENSE("GPL");
533 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms, sparc64 des opcode accelerated");
534 
535 MODULE_ALIAS_CRYPTO("des");
536 
537 #include "crop_devid.c"
538