1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Accelerated GHASH implementation with ARMv8 PMULL instructions.
4  *
5  * Copyright (C) 2014 - 2018 Linaro Ltd. <ard.biesheuvel@linaro.org>
6  */
7 
8 #include <asm/neon.h>
9 #include <asm/simd.h>
10 #include <asm/unaligned.h>
11 #include <crypto/aes.h>
12 #include <crypto/gcm.h>
13 #include <crypto/algapi.h>
14 #include <crypto/b128ops.h>
15 #include <crypto/gf128mul.h>
16 #include <crypto/internal/aead.h>
17 #include <crypto/internal/hash.h>
18 #include <crypto/internal/simd.h>
19 #include <crypto/internal/skcipher.h>
20 #include <crypto/scatterwalk.h>
21 #include <linux/cpufeature.h>
22 #include <linux/crypto.h>
23 #include <linux/module.h>
24 
25 MODULE_DESCRIPTION("GHASH and AES-GCM using ARMv8 Crypto Extensions");
26 MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
27 MODULE_LICENSE("GPL v2");
28 MODULE_ALIAS_CRYPTO("ghash");
29 
30 #define GHASH_BLOCK_SIZE	16
31 #define GHASH_DIGEST_SIZE	16
32 
33 #define RFC4106_NONCE_SIZE	4
34 
35 struct ghash_key {
36 	be128			k;
37 	u64			h[][2];
38 };
39 
40 struct ghash_desc_ctx {
41 	u64 digest[GHASH_DIGEST_SIZE/sizeof(u64)];
42 	u8 buf[GHASH_BLOCK_SIZE];
43 	u32 count;
44 };
45 
46 struct gcm_aes_ctx {
47 	struct crypto_aes_ctx	aes_key;
48 	u8			nonce[RFC4106_NONCE_SIZE];
49 	struct ghash_key	ghash_key;
50 };
51 
52 asmlinkage void pmull_ghash_update_p64(int blocks, u64 dg[], const char *src,
53 				       u64 const h[][2], const char *head);
54 
55 asmlinkage void pmull_ghash_update_p8(int blocks, u64 dg[], const char *src,
56 				      u64 const h[][2], const char *head);
57 
58 asmlinkage void pmull_gcm_encrypt(int bytes, u8 dst[], const u8 src[],
59 				  u64 const h[][2], u64 dg[], u8 ctr[],
60 				  u32 const rk[], int rounds, u8 tag[]);
61 asmlinkage int pmull_gcm_decrypt(int bytes, u8 dst[], const u8 src[],
62 				 u64 const h[][2], u64 dg[], u8 ctr[],
63 				 u32 const rk[], int rounds, const u8 l[],
64 				 const u8 tag[], u64 authsize);
65 
66 static int ghash_init(struct shash_desc *desc)
67 {
68 	struct ghash_desc_ctx *ctx = shash_desc_ctx(desc);
69 
70 	*ctx = (struct ghash_desc_ctx){};
71 	return 0;
72 }
73 
74 static void ghash_do_update(int blocks, u64 dg[], const char *src,
75 			    struct ghash_key *key, const char *head)
76 {
77 	be128 dst = { cpu_to_be64(dg[1]), cpu_to_be64(dg[0]) };
78 
79 	do {
80 		const u8 *in = src;
81 
82 		if (head) {
83 			in = head;
84 			blocks++;
85 			head = NULL;
86 		} else {
87 			src += GHASH_BLOCK_SIZE;
88 		}
89 
90 		crypto_xor((u8 *)&dst, in, GHASH_BLOCK_SIZE);
91 		gf128mul_lle(&dst, &key->k);
92 	} while (--blocks);
93 
94 	dg[0] = be64_to_cpu(dst.b);
95 	dg[1] = be64_to_cpu(dst.a);
96 }
97 
98 static __always_inline
99 void ghash_do_simd_update(int blocks, u64 dg[], const char *src,
100 			  struct ghash_key *key, const char *head,
101 			  void (*simd_update)(int blocks, u64 dg[],
102 					      const char *src,
103 					      u64 const h[][2],
104 					      const char *head))
105 {
106 	if (likely(crypto_simd_usable())) {
107 		kernel_neon_begin();
108 		simd_update(blocks, dg, src, key->h, head);
109 		kernel_neon_end();
110 	} else {
111 		ghash_do_update(blocks, dg, src, key, head);
112 	}
113 }
114 
115 /* avoid hogging the CPU for too long */
116 #define MAX_BLOCKS	(SZ_64K / GHASH_BLOCK_SIZE)
117 
118 static int ghash_update(struct shash_desc *desc, const u8 *src,
119 			unsigned int len)
120 {
121 	struct ghash_desc_ctx *ctx = shash_desc_ctx(desc);
122 	unsigned int partial = ctx->count % GHASH_BLOCK_SIZE;
123 
124 	ctx->count += len;
125 
126 	if ((partial + len) >= GHASH_BLOCK_SIZE) {
127 		struct ghash_key *key = crypto_shash_ctx(desc->tfm);
128 		int blocks;
129 
130 		if (partial) {
131 			int p = GHASH_BLOCK_SIZE - partial;
132 
133 			memcpy(ctx->buf + partial, src, p);
134 			src += p;
135 			len -= p;
136 		}
137 
138 		blocks = len / GHASH_BLOCK_SIZE;
139 		len %= GHASH_BLOCK_SIZE;
140 
141 		do {
142 			int chunk = min(blocks, MAX_BLOCKS);
143 
144 			ghash_do_simd_update(chunk, ctx->digest, src, key,
145 					     partial ? ctx->buf : NULL,
146 					     pmull_ghash_update_p8);
147 
148 			blocks -= chunk;
149 			src += chunk * GHASH_BLOCK_SIZE;
150 			partial = 0;
151 		} while (unlikely(blocks > 0));
152 	}
153 	if (len)
154 		memcpy(ctx->buf + partial, src, len);
155 	return 0;
156 }
157 
158 static int ghash_final(struct shash_desc *desc, u8 *dst)
159 {
160 	struct ghash_desc_ctx *ctx = shash_desc_ctx(desc);
161 	unsigned int partial = ctx->count % GHASH_BLOCK_SIZE;
162 
163 	if (partial) {
164 		struct ghash_key *key = crypto_shash_ctx(desc->tfm);
165 
166 		memset(ctx->buf + partial, 0, GHASH_BLOCK_SIZE - partial);
167 
168 		ghash_do_simd_update(1, ctx->digest, ctx->buf, key, NULL,
169 				     pmull_ghash_update_p8);
170 	}
171 	put_unaligned_be64(ctx->digest[1], dst);
172 	put_unaligned_be64(ctx->digest[0], dst + 8);
173 
174 	memzero_explicit(ctx, sizeof(*ctx));
175 	return 0;
176 }
177 
178 static void ghash_reflect(u64 h[], const be128 *k)
179 {
180 	u64 carry = be64_to_cpu(k->a) & BIT(63) ? 1 : 0;
181 
182 	h[0] = (be64_to_cpu(k->b) << 1) | carry;
183 	h[1] = (be64_to_cpu(k->a) << 1) | (be64_to_cpu(k->b) >> 63);
184 
185 	if (carry)
186 		h[1] ^= 0xc200000000000000UL;
187 }
188 
189 static int ghash_setkey(struct crypto_shash *tfm,
190 			const u8 *inkey, unsigned int keylen)
191 {
192 	struct ghash_key *key = crypto_shash_ctx(tfm);
193 
194 	if (keylen != GHASH_BLOCK_SIZE)
195 		return -EINVAL;
196 
197 	/* needed for the fallback */
198 	memcpy(&key->k, inkey, GHASH_BLOCK_SIZE);
199 
200 	ghash_reflect(key->h[0], &key->k);
201 	return 0;
202 }
203 
204 static struct shash_alg ghash_alg = {
205 	.base.cra_name		= "ghash",
206 	.base.cra_driver_name	= "ghash-neon",
207 	.base.cra_priority	= 150,
208 	.base.cra_blocksize	= GHASH_BLOCK_SIZE,
209 	.base.cra_ctxsize	= sizeof(struct ghash_key) + sizeof(u64[2]),
210 	.base.cra_module	= THIS_MODULE,
211 
212 	.digestsize		= GHASH_DIGEST_SIZE,
213 	.init			= ghash_init,
214 	.update			= ghash_update,
215 	.final			= ghash_final,
216 	.setkey			= ghash_setkey,
217 	.descsize		= sizeof(struct ghash_desc_ctx),
218 };
219 
220 static int num_rounds(struct crypto_aes_ctx *ctx)
221 {
222 	/*
223 	 * # of rounds specified by AES:
224 	 * 128 bit key		10 rounds
225 	 * 192 bit key		12 rounds
226 	 * 256 bit key		14 rounds
227 	 * => n byte key	=> 6 + (n/4) rounds
228 	 */
229 	return 6 + ctx->key_length / 4;
230 }
231 
232 static int gcm_aes_setkey(struct crypto_aead *tfm, const u8 *inkey,
233 			  unsigned int keylen)
234 {
235 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(tfm);
236 	u8 key[GHASH_BLOCK_SIZE];
237 	be128 h;
238 	int ret;
239 
240 	ret = aes_expandkey(&ctx->aes_key, inkey, keylen);
241 	if (ret)
242 		return -EINVAL;
243 
244 	aes_encrypt(&ctx->aes_key, key, (u8[AES_BLOCK_SIZE]){});
245 
246 	/* needed for the fallback */
247 	memcpy(&ctx->ghash_key.k, key, GHASH_BLOCK_SIZE);
248 
249 	ghash_reflect(ctx->ghash_key.h[0], &ctx->ghash_key.k);
250 
251 	h = ctx->ghash_key.k;
252 	gf128mul_lle(&h, &ctx->ghash_key.k);
253 	ghash_reflect(ctx->ghash_key.h[1], &h);
254 
255 	gf128mul_lle(&h, &ctx->ghash_key.k);
256 	ghash_reflect(ctx->ghash_key.h[2], &h);
257 
258 	gf128mul_lle(&h, &ctx->ghash_key.k);
259 	ghash_reflect(ctx->ghash_key.h[3], &h);
260 
261 	return 0;
262 }
263 
264 static int gcm_aes_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
265 {
266 	return crypto_gcm_check_authsize(authsize);
267 }
268 
269 static void gcm_update_mac(u64 dg[], const u8 *src, int count, u8 buf[],
270 			   int *buf_count, struct gcm_aes_ctx *ctx)
271 {
272 	if (*buf_count > 0) {
273 		int buf_added = min(count, GHASH_BLOCK_SIZE - *buf_count);
274 
275 		memcpy(&buf[*buf_count], src, buf_added);
276 
277 		*buf_count += buf_added;
278 		src += buf_added;
279 		count -= buf_added;
280 	}
281 
282 	if (count >= GHASH_BLOCK_SIZE || *buf_count == GHASH_BLOCK_SIZE) {
283 		int blocks = count / GHASH_BLOCK_SIZE;
284 
285 		ghash_do_simd_update(blocks, dg, src, &ctx->ghash_key,
286 				     *buf_count ? buf : NULL,
287 				     pmull_ghash_update_p64);
288 
289 		src += blocks * GHASH_BLOCK_SIZE;
290 		count %= GHASH_BLOCK_SIZE;
291 		*buf_count = 0;
292 	}
293 
294 	if (count > 0) {
295 		memcpy(buf, src, count);
296 		*buf_count = count;
297 	}
298 }
299 
300 static void gcm_calculate_auth_mac(struct aead_request *req, u64 dg[], u32 len)
301 {
302 	struct crypto_aead *aead = crypto_aead_reqtfm(req);
303 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(aead);
304 	u8 buf[GHASH_BLOCK_SIZE];
305 	struct scatter_walk walk;
306 	int buf_count = 0;
307 
308 	scatterwalk_start(&walk, req->src);
309 
310 	do {
311 		u32 n = scatterwalk_clamp(&walk, len);
312 		u8 *p;
313 
314 		if (!n) {
315 			scatterwalk_start(&walk, sg_next(walk.sg));
316 			n = scatterwalk_clamp(&walk, len);
317 		}
318 		p = scatterwalk_map(&walk);
319 
320 		gcm_update_mac(dg, p, n, buf, &buf_count, ctx);
321 		len -= n;
322 
323 		scatterwalk_unmap(p);
324 		scatterwalk_advance(&walk, n);
325 		scatterwalk_done(&walk, 0, len);
326 	} while (len);
327 
328 	if (buf_count) {
329 		memset(&buf[buf_count], 0, GHASH_BLOCK_SIZE - buf_count);
330 		ghash_do_simd_update(1, dg, buf, &ctx->ghash_key, NULL,
331 				     pmull_ghash_update_p64);
332 	}
333 }
334 
335 static int gcm_encrypt(struct aead_request *req, char *iv, int assoclen)
336 {
337 	struct crypto_aead *aead = crypto_aead_reqtfm(req);
338 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(aead);
339 	int nrounds = num_rounds(&ctx->aes_key);
340 	struct skcipher_walk walk;
341 	u8 buf[AES_BLOCK_SIZE];
342 	u64 dg[2] = {};
343 	be128 lengths;
344 	u8 *tag;
345 	int err;
346 
347 	lengths.a = cpu_to_be64(assoclen * 8);
348 	lengths.b = cpu_to_be64(req->cryptlen * 8);
349 
350 	if (assoclen)
351 		gcm_calculate_auth_mac(req, dg, assoclen);
352 
353 	put_unaligned_be32(2, iv + GCM_AES_IV_SIZE);
354 
355 	err = skcipher_walk_aead_encrypt(&walk, req, false);
356 
357 	do {
358 		const u8 *src = walk.src.virt.addr;
359 		u8 *dst = walk.dst.virt.addr;
360 		int nbytes = walk.nbytes;
361 
362 		tag = (u8 *)&lengths;
363 
364 		if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE)) {
365 			src = dst = memcpy(buf + sizeof(buf) - nbytes,
366 					   src, nbytes);
367 		} else if (nbytes < walk.total) {
368 			nbytes &= ~(AES_BLOCK_SIZE - 1);
369 			tag = NULL;
370 		}
371 
372 		kernel_neon_begin();
373 		pmull_gcm_encrypt(nbytes, dst, src, ctx->ghash_key.h,
374 				  dg, iv, ctx->aes_key.key_enc, nrounds,
375 				  tag);
376 		kernel_neon_end();
377 
378 		if (unlikely(!nbytes))
379 			break;
380 
381 		if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE))
382 			memcpy(walk.dst.virt.addr,
383 			       buf + sizeof(buf) - nbytes, nbytes);
384 
385 		err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
386 	} while (walk.nbytes);
387 
388 	if (err)
389 		return err;
390 
391 	/* copy authtag to end of dst */
392 	scatterwalk_map_and_copy(tag, req->dst, req->assoclen + req->cryptlen,
393 				 crypto_aead_authsize(aead), 1);
394 
395 	return 0;
396 }
397 
398 static int gcm_decrypt(struct aead_request *req, char *iv, int assoclen)
399 {
400 	struct crypto_aead *aead = crypto_aead_reqtfm(req);
401 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(aead);
402 	unsigned int authsize = crypto_aead_authsize(aead);
403 	int nrounds = num_rounds(&ctx->aes_key);
404 	struct skcipher_walk walk;
405 	u8 otag[AES_BLOCK_SIZE];
406 	u8 buf[AES_BLOCK_SIZE];
407 	u64 dg[2] = {};
408 	be128 lengths;
409 	u8 *tag;
410 	int ret;
411 	int err;
412 
413 	lengths.a = cpu_to_be64(assoclen * 8);
414 	lengths.b = cpu_to_be64((req->cryptlen - authsize) * 8);
415 
416 	if (assoclen)
417 		gcm_calculate_auth_mac(req, dg, assoclen);
418 
419 	put_unaligned_be32(2, iv + GCM_AES_IV_SIZE);
420 
421 	scatterwalk_map_and_copy(otag, req->src,
422 				 req->assoclen + req->cryptlen - authsize,
423 				 authsize, 0);
424 
425 	err = skcipher_walk_aead_decrypt(&walk, req, false);
426 
427 	do {
428 		const u8 *src = walk.src.virt.addr;
429 		u8 *dst = walk.dst.virt.addr;
430 		int nbytes = walk.nbytes;
431 
432 		tag = (u8 *)&lengths;
433 
434 		if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE)) {
435 			src = dst = memcpy(buf + sizeof(buf) - nbytes,
436 					   src, nbytes);
437 		} else if (nbytes < walk.total) {
438 			nbytes &= ~(AES_BLOCK_SIZE - 1);
439 			tag = NULL;
440 		}
441 
442 		kernel_neon_begin();
443 		ret = pmull_gcm_decrypt(nbytes, dst, src, ctx->ghash_key.h,
444 					dg, iv, ctx->aes_key.key_enc,
445 					nrounds, tag, otag, authsize);
446 		kernel_neon_end();
447 
448 		if (unlikely(!nbytes))
449 			break;
450 
451 		if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE))
452 			memcpy(walk.dst.virt.addr,
453 			       buf + sizeof(buf) - nbytes, nbytes);
454 
455 		err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
456 	} while (walk.nbytes);
457 
458 	if (err)
459 		return err;
460 
461 	return ret ? -EBADMSG : 0;
462 }
463 
464 static int gcm_aes_encrypt(struct aead_request *req)
465 {
466 	u8 iv[AES_BLOCK_SIZE];
467 
468 	memcpy(iv, req->iv, GCM_AES_IV_SIZE);
469 	return gcm_encrypt(req, iv, req->assoclen);
470 }
471 
472 static int gcm_aes_decrypt(struct aead_request *req)
473 {
474 	u8 iv[AES_BLOCK_SIZE];
475 
476 	memcpy(iv, req->iv, GCM_AES_IV_SIZE);
477 	return gcm_decrypt(req, iv, req->assoclen);
478 }
479 
480 static int rfc4106_setkey(struct crypto_aead *tfm, const u8 *inkey,
481 			  unsigned int keylen)
482 {
483 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(tfm);
484 	int err;
485 
486 	keylen -= RFC4106_NONCE_SIZE;
487 	err = gcm_aes_setkey(tfm, inkey, keylen);
488 	if (err)
489 		return err;
490 
491 	memcpy(ctx->nonce, inkey + keylen, RFC4106_NONCE_SIZE);
492 	return 0;
493 }
494 
495 static int rfc4106_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
496 {
497 	return crypto_rfc4106_check_authsize(authsize);
498 }
499 
500 static int rfc4106_encrypt(struct aead_request *req)
501 {
502 	struct crypto_aead *aead = crypto_aead_reqtfm(req);
503 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(aead);
504 	u8 iv[AES_BLOCK_SIZE];
505 
506 	memcpy(iv, ctx->nonce, RFC4106_NONCE_SIZE);
507 	memcpy(iv + RFC4106_NONCE_SIZE, req->iv, GCM_RFC4106_IV_SIZE);
508 
509 	return crypto_ipsec_check_assoclen(req->assoclen) ?:
510 	       gcm_encrypt(req, iv, req->assoclen - GCM_RFC4106_IV_SIZE);
511 }
512 
513 static int rfc4106_decrypt(struct aead_request *req)
514 {
515 	struct crypto_aead *aead = crypto_aead_reqtfm(req);
516 	struct gcm_aes_ctx *ctx = crypto_aead_ctx(aead);
517 	u8 iv[AES_BLOCK_SIZE];
518 
519 	memcpy(iv, ctx->nonce, RFC4106_NONCE_SIZE);
520 	memcpy(iv + RFC4106_NONCE_SIZE, req->iv, GCM_RFC4106_IV_SIZE);
521 
522 	return crypto_ipsec_check_assoclen(req->assoclen) ?:
523 	       gcm_decrypt(req, iv, req->assoclen - GCM_RFC4106_IV_SIZE);
524 }
525 
526 static struct aead_alg gcm_aes_algs[] = {{
527 	.ivsize			= GCM_AES_IV_SIZE,
528 	.chunksize		= AES_BLOCK_SIZE,
529 	.maxauthsize		= AES_BLOCK_SIZE,
530 	.setkey			= gcm_aes_setkey,
531 	.setauthsize		= gcm_aes_setauthsize,
532 	.encrypt		= gcm_aes_encrypt,
533 	.decrypt		= gcm_aes_decrypt,
534 
535 	.base.cra_name		= "gcm(aes)",
536 	.base.cra_driver_name	= "gcm-aes-ce",
537 	.base.cra_priority	= 300,
538 	.base.cra_blocksize	= 1,
539 	.base.cra_ctxsize	= sizeof(struct gcm_aes_ctx) +
540 				  4 * sizeof(u64[2]),
541 	.base.cra_module	= THIS_MODULE,
542 }, {
543 	.ivsize			= GCM_RFC4106_IV_SIZE,
544 	.chunksize		= AES_BLOCK_SIZE,
545 	.maxauthsize		= AES_BLOCK_SIZE,
546 	.setkey			= rfc4106_setkey,
547 	.setauthsize		= rfc4106_setauthsize,
548 	.encrypt		= rfc4106_encrypt,
549 	.decrypt		= rfc4106_decrypt,
550 
551 	.base.cra_name		= "rfc4106(gcm(aes))",
552 	.base.cra_driver_name	= "rfc4106-gcm-aes-ce",
553 	.base.cra_priority	= 300,
554 	.base.cra_blocksize	= 1,
555 	.base.cra_ctxsize	= sizeof(struct gcm_aes_ctx) +
556 				  4 * sizeof(u64[2]),
557 	.base.cra_module	= THIS_MODULE,
558 }};
559 
560 static int __init ghash_ce_mod_init(void)
561 {
562 	if (!cpu_have_named_feature(ASIMD))
563 		return -ENODEV;
564 
565 	if (cpu_have_named_feature(PMULL))
566 		return crypto_register_aeads(gcm_aes_algs,
567 					     ARRAY_SIZE(gcm_aes_algs));
568 
569 	return crypto_register_shash(&ghash_alg);
570 }
571 
572 static void __exit ghash_ce_mod_exit(void)
573 {
574 	if (cpu_have_named_feature(PMULL))
575 		crypto_unregister_aeads(gcm_aes_algs, ARRAY_SIZE(gcm_aes_algs));
576 	else
577 		crypto_unregister_shash(&ghash_alg);
578 }
579 
580 static const struct cpu_feature __maybe_unused ghash_cpu_feature[] = {
581 	{ cpu_feature(PMULL) }, { }
582 };
583 MODULE_DEVICE_TABLE(cpu, ghash_cpu_feature);
584 
585 module_init(ghash_ce_mod_init);
586 module_exit(ghash_ce_mod_exit);
587