1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * CCM: Counter with CBC-MAC
4 *
5 * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
6 */
7
8 #include <crypto/internal/aead.h>
9 #include <crypto/internal/hash.h>
10 #include <crypto/internal/skcipher.h>
11 #include <crypto/scatterwalk.h>
12 #include <linux/err.h>
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17
18 #include "internal.h"
19
20 struct ccm_instance_ctx {
21 struct crypto_skcipher_spawn ctr;
22 struct crypto_ahash_spawn mac;
23 };
24
25 struct crypto_ccm_ctx {
26 struct crypto_ahash *mac;
27 struct crypto_skcipher *ctr;
28 };
29
30 struct crypto_rfc4309_ctx {
31 struct crypto_aead *child;
32 u8 nonce[3];
33 };
34
35 struct crypto_rfc4309_req_ctx {
36 struct scatterlist src[3];
37 struct scatterlist dst[3];
38 struct aead_request subreq;
39 };
40
41 struct crypto_ccm_req_priv_ctx {
42 u8 odata[16];
43 u8 idata[16];
44 u8 auth_tag[16];
45 u32 flags;
46 struct scatterlist src[3];
47 struct scatterlist dst[3];
48 union {
49 struct ahash_request ahreq;
50 struct skcipher_request skreq;
51 };
52 };
53
54 struct cbcmac_tfm_ctx {
55 struct crypto_cipher *child;
56 };
57
58 struct cbcmac_desc_ctx {
59 unsigned int len;
60 };
61
crypto_ccm_reqctx(struct aead_request * req)62 static inline struct crypto_ccm_req_priv_ctx *crypto_ccm_reqctx(
63 struct aead_request *req)
64 {
65 unsigned long align = crypto_aead_alignmask(crypto_aead_reqtfm(req));
66
67 return (void *)PTR_ALIGN((u8 *)aead_request_ctx(req), align + 1);
68 }
69
set_msg_len(u8 * block,unsigned int msglen,int csize)70 static int set_msg_len(u8 *block, unsigned int msglen, int csize)
71 {
72 __be32 data;
73
74 memset(block, 0, csize);
75 block += csize;
76
77 if (csize >= 4)
78 csize = 4;
79 else if (msglen > (1 << (8 * csize)))
80 return -EOVERFLOW;
81
82 data = cpu_to_be32(msglen);
83 memcpy(block - csize, (u8 *)&data + 4 - csize, csize);
84
85 return 0;
86 }
87
crypto_ccm_setkey(struct crypto_aead * aead,const u8 * key,unsigned int keylen)88 static int crypto_ccm_setkey(struct crypto_aead *aead, const u8 *key,
89 unsigned int keylen)
90 {
91 struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
92 struct crypto_skcipher *ctr = ctx->ctr;
93 struct crypto_ahash *mac = ctx->mac;
94 int err = 0;
95
96 crypto_skcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK);
97 crypto_skcipher_set_flags(ctr, crypto_aead_get_flags(aead) &
98 CRYPTO_TFM_REQ_MASK);
99 err = crypto_skcipher_setkey(ctr, key, keylen);
100 crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctr) &
101 CRYPTO_TFM_RES_MASK);
102 if (err)
103 goto out;
104
105 crypto_ahash_clear_flags(mac, CRYPTO_TFM_REQ_MASK);
106 crypto_ahash_set_flags(mac, crypto_aead_get_flags(aead) &
107 CRYPTO_TFM_REQ_MASK);
108 err = crypto_ahash_setkey(mac, key, keylen);
109 crypto_aead_set_flags(aead, crypto_ahash_get_flags(mac) &
110 CRYPTO_TFM_RES_MASK);
111
112 out:
113 return err;
114 }
115
crypto_ccm_setauthsize(struct crypto_aead * tfm,unsigned int authsize)116 static int crypto_ccm_setauthsize(struct crypto_aead *tfm,
117 unsigned int authsize)
118 {
119 switch (authsize) {
120 case 4:
121 case 6:
122 case 8:
123 case 10:
124 case 12:
125 case 14:
126 case 16:
127 break;
128 default:
129 return -EINVAL;
130 }
131
132 return 0;
133 }
134
format_input(u8 * info,struct aead_request * req,unsigned int cryptlen)135 static int format_input(u8 *info, struct aead_request *req,
136 unsigned int cryptlen)
137 {
138 struct crypto_aead *aead = crypto_aead_reqtfm(req);
139 unsigned int lp = req->iv[0];
140 unsigned int l = lp + 1;
141 unsigned int m;
142
143 m = crypto_aead_authsize(aead);
144
145 memcpy(info, req->iv, 16);
146
147 /* format control info per RFC 3610 and
148 * NIST Special Publication 800-38C
149 */
150 *info |= (8 * ((m - 2) / 2));
151 if (req->assoclen)
152 *info |= 64;
153
154 return set_msg_len(info + 16 - l, cryptlen, l);
155 }
156
format_adata(u8 * adata,unsigned int a)157 static int format_adata(u8 *adata, unsigned int a)
158 {
159 int len = 0;
160
161 /* add control info for associated data
162 * RFC 3610 and NIST Special Publication 800-38C
163 */
164 if (a < 65280) {
165 *(__be16 *)adata = cpu_to_be16(a);
166 len = 2;
167 } else {
168 *(__be16 *)adata = cpu_to_be16(0xfffe);
169 *(__be32 *)&adata[2] = cpu_to_be32(a);
170 len = 6;
171 }
172
173 return len;
174 }
175
crypto_ccm_auth(struct aead_request * req,struct scatterlist * plain,unsigned int cryptlen)176 static int crypto_ccm_auth(struct aead_request *req, struct scatterlist *plain,
177 unsigned int cryptlen)
178 {
179 struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
180 struct crypto_aead *aead = crypto_aead_reqtfm(req);
181 struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
182 struct ahash_request *ahreq = &pctx->ahreq;
183 unsigned int assoclen = req->assoclen;
184 struct scatterlist sg[3];
185 u8 *odata = pctx->odata;
186 u8 *idata = pctx->idata;
187 int ilen, err;
188
189 /* format control data for input */
190 err = format_input(odata, req, cryptlen);
191 if (err)
192 goto out;
193
194 sg_init_table(sg, 3);
195 sg_set_buf(&sg[0], odata, 16);
196
197 /* format associated data and compute into mac */
198 if (assoclen) {
199 ilen = format_adata(idata, assoclen);
200 sg_set_buf(&sg[1], idata, ilen);
201 sg_chain(sg, 3, req->src);
202 } else {
203 ilen = 0;
204 sg_chain(sg, 2, req->src);
205 }
206
207 ahash_request_set_tfm(ahreq, ctx->mac);
208 ahash_request_set_callback(ahreq, pctx->flags, NULL, NULL);
209 ahash_request_set_crypt(ahreq, sg, NULL, assoclen + ilen + 16);
210 err = crypto_ahash_init(ahreq);
211 if (err)
212 goto out;
213 err = crypto_ahash_update(ahreq);
214 if (err)
215 goto out;
216
217 /* we need to pad the MAC input to a round multiple of the block size */
218 ilen = 16 - (assoclen + ilen) % 16;
219 if (ilen < 16) {
220 memset(idata, 0, ilen);
221 sg_init_table(sg, 2);
222 sg_set_buf(&sg[0], idata, ilen);
223 if (plain)
224 sg_chain(sg, 2, plain);
225 plain = sg;
226 cryptlen += ilen;
227 }
228
229 ahash_request_set_crypt(ahreq, plain, pctx->odata, cryptlen);
230 err = crypto_ahash_finup(ahreq);
231 out:
232 return err;
233 }
234
crypto_ccm_encrypt_done(struct crypto_async_request * areq,int err)235 static void crypto_ccm_encrypt_done(struct crypto_async_request *areq, int err)
236 {
237 struct aead_request *req = areq->data;
238 struct crypto_aead *aead = crypto_aead_reqtfm(req);
239 struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
240 u8 *odata = pctx->odata;
241
242 if (!err)
243 scatterwalk_map_and_copy(odata, req->dst,
244 req->assoclen + req->cryptlen,
245 crypto_aead_authsize(aead), 1);
246 aead_request_complete(req, err);
247 }
248
crypto_ccm_check_iv(const u8 * iv)249 static inline int crypto_ccm_check_iv(const u8 *iv)
250 {
251 /* 2 <= L <= 8, so 1 <= L' <= 7. */
252 if (1 > iv[0] || iv[0] > 7)
253 return -EINVAL;
254
255 return 0;
256 }
257
crypto_ccm_init_crypt(struct aead_request * req,u8 * tag)258 static int crypto_ccm_init_crypt(struct aead_request *req, u8 *tag)
259 {
260 struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
261 struct scatterlist *sg;
262 u8 *iv = req->iv;
263 int err;
264
265 err = crypto_ccm_check_iv(iv);
266 if (err)
267 return err;
268
269 pctx->flags = aead_request_flags(req);
270
271 /* Note: rfc 3610 and NIST 800-38C require counter of
272 * zero to encrypt auth tag.
273 */
274 memset(iv + 15 - iv[0], 0, iv[0] + 1);
275
276 sg_init_table(pctx->src, 3);
277 sg_set_buf(pctx->src, tag, 16);
278 sg = scatterwalk_ffwd(pctx->src + 1, req->src, req->assoclen);
279 if (sg != pctx->src + 1)
280 sg_chain(pctx->src, 2, sg);
281
282 if (req->src != req->dst) {
283 sg_init_table(pctx->dst, 3);
284 sg_set_buf(pctx->dst, tag, 16);
285 sg = scatterwalk_ffwd(pctx->dst + 1, req->dst, req->assoclen);
286 if (sg != pctx->dst + 1)
287 sg_chain(pctx->dst, 2, sg);
288 }
289
290 return 0;
291 }
292
crypto_ccm_encrypt(struct aead_request * req)293 static int crypto_ccm_encrypt(struct aead_request *req)
294 {
295 struct crypto_aead *aead = crypto_aead_reqtfm(req);
296 struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
297 struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
298 struct skcipher_request *skreq = &pctx->skreq;
299 struct scatterlist *dst;
300 unsigned int cryptlen = req->cryptlen;
301 u8 *odata = pctx->odata;
302 u8 *iv = req->iv;
303 int err;
304
305 err = crypto_ccm_init_crypt(req, odata);
306 if (err)
307 return err;
308
309 err = crypto_ccm_auth(req, sg_next(pctx->src), cryptlen);
310 if (err)
311 return err;
312
313 dst = pctx->src;
314 if (req->src != req->dst)
315 dst = pctx->dst;
316
317 skcipher_request_set_tfm(skreq, ctx->ctr);
318 skcipher_request_set_callback(skreq, pctx->flags,
319 crypto_ccm_encrypt_done, req);
320 skcipher_request_set_crypt(skreq, pctx->src, dst, cryptlen + 16, iv);
321 err = crypto_skcipher_encrypt(skreq);
322 if (err)
323 return err;
324
325 /* copy authtag to end of dst */
326 scatterwalk_map_and_copy(odata, sg_next(dst), cryptlen,
327 crypto_aead_authsize(aead), 1);
328 return err;
329 }
330
crypto_ccm_decrypt_done(struct crypto_async_request * areq,int err)331 static void crypto_ccm_decrypt_done(struct crypto_async_request *areq,
332 int err)
333 {
334 struct aead_request *req = areq->data;
335 struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
336 struct crypto_aead *aead = crypto_aead_reqtfm(req);
337 unsigned int authsize = crypto_aead_authsize(aead);
338 unsigned int cryptlen = req->cryptlen - authsize;
339 struct scatterlist *dst;
340
341 pctx->flags = 0;
342
343 dst = sg_next(req->src == req->dst ? pctx->src : pctx->dst);
344
345 if (!err) {
346 err = crypto_ccm_auth(req, dst, cryptlen);
347 if (!err && crypto_memneq(pctx->auth_tag, pctx->odata, authsize))
348 err = -EBADMSG;
349 }
350 aead_request_complete(req, err);
351 }
352
crypto_ccm_decrypt(struct aead_request * req)353 static int crypto_ccm_decrypt(struct aead_request *req)
354 {
355 struct crypto_aead *aead = crypto_aead_reqtfm(req);
356 struct crypto_ccm_ctx *ctx = crypto_aead_ctx(aead);
357 struct crypto_ccm_req_priv_ctx *pctx = crypto_ccm_reqctx(req);
358 struct skcipher_request *skreq = &pctx->skreq;
359 struct scatterlist *dst;
360 unsigned int authsize = crypto_aead_authsize(aead);
361 unsigned int cryptlen = req->cryptlen;
362 u8 *authtag = pctx->auth_tag;
363 u8 *odata = pctx->odata;
364 u8 *iv = pctx->idata;
365 int err;
366
367 cryptlen -= authsize;
368
369 err = crypto_ccm_init_crypt(req, authtag);
370 if (err)
371 return err;
372
373 scatterwalk_map_and_copy(authtag, sg_next(pctx->src), cryptlen,
374 authsize, 0);
375
376 dst = pctx->src;
377 if (req->src != req->dst)
378 dst = pctx->dst;
379
380 memcpy(iv, req->iv, 16);
381
382 skcipher_request_set_tfm(skreq, ctx->ctr);
383 skcipher_request_set_callback(skreq, pctx->flags,
384 crypto_ccm_decrypt_done, req);
385 skcipher_request_set_crypt(skreq, pctx->src, dst, cryptlen + 16, iv);
386 err = crypto_skcipher_decrypt(skreq);
387 if (err)
388 return err;
389
390 err = crypto_ccm_auth(req, sg_next(dst), cryptlen);
391 if (err)
392 return err;
393
394 /* verify */
395 if (crypto_memneq(authtag, odata, authsize))
396 return -EBADMSG;
397
398 return err;
399 }
400
crypto_ccm_init_tfm(struct crypto_aead * tfm)401 static int crypto_ccm_init_tfm(struct crypto_aead *tfm)
402 {
403 struct aead_instance *inst = aead_alg_instance(tfm);
404 struct ccm_instance_ctx *ictx = aead_instance_ctx(inst);
405 struct crypto_ccm_ctx *ctx = crypto_aead_ctx(tfm);
406 struct crypto_ahash *mac;
407 struct crypto_skcipher *ctr;
408 unsigned long align;
409 int err;
410
411 mac = crypto_spawn_ahash(&ictx->mac);
412 if (IS_ERR(mac))
413 return PTR_ERR(mac);
414
415 ctr = crypto_spawn_skcipher(&ictx->ctr);
416 err = PTR_ERR(ctr);
417 if (IS_ERR(ctr))
418 goto err_free_mac;
419
420 ctx->mac = mac;
421 ctx->ctr = ctr;
422
423 align = crypto_aead_alignmask(tfm);
424 align &= ~(crypto_tfm_ctx_alignment() - 1);
425 crypto_aead_set_reqsize(
426 tfm,
427 align + sizeof(struct crypto_ccm_req_priv_ctx) +
428 max(crypto_ahash_reqsize(mac), crypto_skcipher_reqsize(ctr)));
429
430 return 0;
431
432 err_free_mac:
433 crypto_free_ahash(mac);
434 return err;
435 }
436
crypto_ccm_exit_tfm(struct crypto_aead * tfm)437 static void crypto_ccm_exit_tfm(struct crypto_aead *tfm)
438 {
439 struct crypto_ccm_ctx *ctx = crypto_aead_ctx(tfm);
440
441 crypto_free_ahash(ctx->mac);
442 crypto_free_skcipher(ctx->ctr);
443 }
444
crypto_ccm_free(struct aead_instance * inst)445 static void crypto_ccm_free(struct aead_instance *inst)
446 {
447 struct ccm_instance_ctx *ctx = aead_instance_ctx(inst);
448
449 crypto_drop_ahash(&ctx->mac);
450 crypto_drop_skcipher(&ctx->ctr);
451 kfree(inst);
452 }
453
crypto_ccm_create_common(struct crypto_template * tmpl,struct rtattr ** tb,const char * ctr_name,const char * mac_name)454 static int crypto_ccm_create_common(struct crypto_template *tmpl,
455 struct rtattr **tb,
456 const char *ctr_name,
457 const char *mac_name)
458 {
459 struct crypto_attr_type *algt;
460 struct aead_instance *inst;
461 struct skcipher_alg *ctr;
462 struct crypto_alg *mac_alg;
463 struct hash_alg_common *mac;
464 struct ccm_instance_ctx *ictx;
465 int err;
466
467 algt = crypto_get_attr_type(tb);
468 if (IS_ERR(algt))
469 return PTR_ERR(algt);
470
471 if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
472 return -EINVAL;
473
474 mac_alg = crypto_find_alg(mac_name, &crypto_ahash_type,
475 CRYPTO_ALG_TYPE_HASH,
476 CRYPTO_ALG_TYPE_AHASH_MASK |
477 CRYPTO_ALG_ASYNC);
478 if (IS_ERR(mac_alg))
479 return PTR_ERR(mac_alg);
480
481 mac = __crypto_hash_alg_common(mac_alg);
482 err = -EINVAL;
483 if (strncmp(mac->base.cra_name, "cbcmac(", 7) != 0 ||
484 mac->digestsize != 16)
485 goto out_put_mac;
486
487 inst = kzalloc(sizeof(*inst) + sizeof(*ictx), GFP_KERNEL);
488 err = -ENOMEM;
489 if (!inst)
490 goto out_put_mac;
491
492 ictx = aead_instance_ctx(inst);
493 err = crypto_init_ahash_spawn(&ictx->mac, mac,
494 aead_crypto_instance(inst));
495 if (err)
496 goto err_free_inst;
497
498 crypto_set_skcipher_spawn(&ictx->ctr, aead_crypto_instance(inst));
499 err = crypto_grab_skcipher(&ictx->ctr, ctr_name, 0,
500 crypto_requires_sync(algt->type,
501 algt->mask));
502 if (err)
503 goto err_drop_mac;
504
505 ctr = crypto_spawn_skcipher_alg(&ictx->ctr);
506
507 /* The skcipher algorithm must be CTR mode, using 16-byte blocks. */
508 err = -EINVAL;
509 if (strncmp(ctr->base.cra_name, "ctr(", 4) != 0 ||
510 crypto_skcipher_alg_ivsize(ctr) != 16 ||
511 ctr->base.cra_blocksize != 1)
512 goto err_drop_ctr;
513
514 /* ctr and cbcmac must use the same underlying block cipher. */
515 if (strcmp(ctr->base.cra_name + 4, mac->base.cra_name + 7) != 0)
516 goto err_drop_ctr;
517
518 err = -ENAMETOOLONG;
519 if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
520 "ccm(%s", ctr->base.cra_name + 4) >= CRYPTO_MAX_ALG_NAME)
521 goto err_drop_ctr;
522
523 if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
524 "ccm_base(%s,%s)", ctr->base.cra_driver_name,
525 mac->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
526 goto err_drop_ctr;
527
528 inst->alg.base.cra_flags = ctr->base.cra_flags & CRYPTO_ALG_ASYNC;
529 inst->alg.base.cra_priority = (mac->base.cra_priority +
530 ctr->base.cra_priority) / 2;
531 inst->alg.base.cra_blocksize = 1;
532 inst->alg.base.cra_alignmask = mac->base.cra_alignmask |
533 ctr->base.cra_alignmask;
534 inst->alg.ivsize = 16;
535 inst->alg.chunksize = crypto_skcipher_alg_chunksize(ctr);
536 inst->alg.maxauthsize = 16;
537 inst->alg.base.cra_ctxsize = sizeof(struct crypto_ccm_ctx);
538 inst->alg.init = crypto_ccm_init_tfm;
539 inst->alg.exit = crypto_ccm_exit_tfm;
540 inst->alg.setkey = crypto_ccm_setkey;
541 inst->alg.setauthsize = crypto_ccm_setauthsize;
542 inst->alg.encrypt = crypto_ccm_encrypt;
543 inst->alg.decrypt = crypto_ccm_decrypt;
544
545 inst->free = crypto_ccm_free;
546
547 err = aead_register_instance(tmpl, inst);
548 if (err)
549 goto err_drop_ctr;
550
551 out_put_mac:
552 crypto_mod_put(mac_alg);
553 return err;
554
555 err_drop_ctr:
556 crypto_drop_skcipher(&ictx->ctr);
557 err_drop_mac:
558 crypto_drop_ahash(&ictx->mac);
559 err_free_inst:
560 kfree(inst);
561 goto out_put_mac;
562 }
563
crypto_ccm_create(struct crypto_template * tmpl,struct rtattr ** tb)564 static int crypto_ccm_create(struct crypto_template *tmpl, struct rtattr **tb)
565 {
566 const char *cipher_name;
567 char ctr_name[CRYPTO_MAX_ALG_NAME];
568 char mac_name[CRYPTO_MAX_ALG_NAME];
569
570 cipher_name = crypto_attr_alg_name(tb[1]);
571 if (IS_ERR(cipher_name))
572 return PTR_ERR(cipher_name);
573
574 if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)",
575 cipher_name) >= CRYPTO_MAX_ALG_NAME)
576 return -ENAMETOOLONG;
577
578 if (snprintf(mac_name, CRYPTO_MAX_ALG_NAME, "cbcmac(%s)",
579 cipher_name) >= CRYPTO_MAX_ALG_NAME)
580 return -ENAMETOOLONG;
581
582 return crypto_ccm_create_common(tmpl, tb, ctr_name, mac_name);
583 }
584
crypto_ccm_base_create(struct crypto_template * tmpl,struct rtattr ** tb)585 static int crypto_ccm_base_create(struct crypto_template *tmpl,
586 struct rtattr **tb)
587 {
588 const char *ctr_name;
589 const char *mac_name;
590
591 ctr_name = crypto_attr_alg_name(tb[1]);
592 if (IS_ERR(ctr_name))
593 return PTR_ERR(ctr_name);
594
595 mac_name = crypto_attr_alg_name(tb[2]);
596 if (IS_ERR(mac_name))
597 return PTR_ERR(mac_name);
598
599 return crypto_ccm_create_common(tmpl, tb, ctr_name, mac_name);
600 }
601
crypto_rfc4309_setkey(struct crypto_aead * parent,const u8 * key,unsigned int keylen)602 static int crypto_rfc4309_setkey(struct crypto_aead *parent, const u8 *key,
603 unsigned int keylen)
604 {
605 struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(parent);
606 struct crypto_aead *child = ctx->child;
607 int err;
608
609 if (keylen < 3)
610 return -EINVAL;
611
612 keylen -= 3;
613 memcpy(ctx->nonce, key + keylen, 3);
614
615 crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
616 crypto_aead_set_flags(child, crypto_aead_get_flags(parent) &
617 CRYPTO_TFM_REQ_MASK);
618 err = crypto_aead_setkey(child, key, keylen);
619 crypto_aead_set_flags(parent, crypto_aead_get_flags(child) &
620 CRYPTO_TFM_RES_MASK);
621
622 return err;
623 }
624
crypto_rfc4309_setauthsize(struct crypto_aead * parent,unsigned int authsize)625 static int crypto_rfc4309_setauthsize(struct crypto_aead *parent,
626 unsigned int authsize)
627 {
628 struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(parent);
629
630 switch (authsize) {
631 case 8:
632 case 12:
633 case 16:
634 break;
635 default:
636 return -EINVAL;
637 }
638
639 return crypto_aead_setauthsize(ctx->child, authsize);
640 }
641
crypto_rfc4309_crypt(struct aead_request * req)642 static struct aead_request *crypto_rfc4309_crypt(struct aead_request *req)
643 {
644 struct crypto_rfc4309_req_ctx *rctx = aead_request_ctx(req);
645 struct aead_request *subreq = &rctx->subreq;
646 struct crypto_aead *aead = crypto_aead_reqtfm(req);
647 struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(aead);
648 struct crypto_aead *child = ctx->child;
649 struct scatterlist *sg;
650 u8 *iv = PTR_ALIGN((u8 *)(subreq + 1) + crypto_aead_reqsize(child),
651 crypto_aead_alignmask(child) + 1);
652
653 /* L' */
654 iv[0] = 3;
655
656 memcpy(iv + 1, ctx->nonce, 3);
657 memcpy(iv + 4, req->iv, 8);
658
659 scatterwalk_map_and_copy(iv + 16, req->src, 0, req->assoclen - 8, 0);
660
661 sg_init_table(rctx->src, 3);
662 sg_set_buf(rctx->src, iv + 16, req->assoclen - 8);
663 sg = scatterwalk_ffwd(rctx->src + 1, req->src, req->assoclen);
664 if (sg != rctx->src + 1)
665 sg_chain(rctx->src, 2, sg);
666
667 if (req->src != req->dst) {
668 sg_init_table(rctx->dst, 3);
669 sg_set_buf(rctx->dst, iv + 16, req->assoclen - 8);
670 sg = scatterwalk_ffwd(rctx->dst + 1, req->dst, req->assoclen);
671 if (sg != rctx->dst + 1)
672 sg_chain(rctx->dst, 2, sg);
673 }
674
675 aead_request_set_tfm(subreq, child);
676 aead_request_set_callback(subreq, req->base.flags, req->base.complete,
677 req->base.data);
678 aead_request_set_crypt(subreq, rctx->src,
679 req->src == req->dst ? rctx->src : rctx->dst,
680 req->cryptlen, iv);
681 aead_request_set_ad(subreq, req->assoclen - 8);
682
683 return subreq;
684 }
685
crypto_rfc4309_encrypt(struct aead_request * req)686 static int crypto_rfc4309_encrypt(struct aead_request *req)
687 {
688 if (req->assoclen != 16 && req->assoclen != 20)
689 return -EINVAL;
690
691 req = crypto_rfc4309_crypt(req);
692
693 return crypto_aead_encrypt(req);
694 }
695
crypto_rfc4309_decrypt(struct aead_request * req)696 static int crypto_rfc4309_decrypt(struct aead_request *req)
697 {
698 if (req->assoclen != 16 && req->assoclen != 20)
699 return -EINVAL;
700
701 req = crypto_rfc4309_crypt(req);
702
703 return crypto_aead_decrypt(req);
704 }
705
crypto_rfc4309_init_tfm(struct crypto_aead * tfm)706 static int crypto_rfc4309_init_tfm(struct crypto_aead *tfm)
707 {
708 struct aead_instance *inst = aead_alg_instance(tfm);
709 struct crypto_aead_spawn *spawn = aead_instance_ctx(inst);
710 struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(tfm);
711 struct crypto_aead *aead;
712 unsigned long align;
713
714 aead = crypto_spawn_aead(spawn);
715 if (IS_ERR(aead))
716 return PTR_ERR(aead);
717
718 ctx->child = aead;
719
720 align = crypto_aead_alignmask(aead);
721 align &= ~(crypto_tfm_ctx_alignment() - 1);
722 crypto_aead_set_reqsize(
723 tfm,
724 sizeof(struct crypto_rfc4309_req_ctx) +
725 ALIGN(crypto_aead_reqsize(aead), crypto_tfm_ctx_alignment()) +
726 align + 32);
727
728 return 0;
729 }
730
crypto_rfc4309_exit_tfm(struct crypto_aead * tfm)731 static void crypto_rfc4309_exit_tfm(struct crypto_aead *tfm)
732 {
733 struct crypto_rfc4309_ctx *ctx = crypto_aead_ctx(tfm);
734
735 crypto_free_aead(ctx->child);
736 }
737
crypto_rfc4309_free(struct aead_instance * inst)738 static void crypto_rfc4309_free(struct aead_instance *inst)
739 {
740 crypto_drop_aead(aead_instance_ctx(inst));
741 kfree(inst);
742 }
743
crypto_rfc4309_create(struct crypto_template * tmpl,struct rtattr ** tb)744 static int crypto_rfc4309_create(struct crypto_template *tmpl,
745 struct rtattr **tb)
746 {
747 struct crypto_attr_type *algt;
748 struct aead_instance *inst;
749 struct crypto_aead_spawn *spawn;
750 struct aead_alg *alg;
751 const char *ccm_name;
752 int err;
753
754 algt = crypto_get_attr_type(tb);
755 if (IS_ERR(algt))
756 return PTR_ERR(algt);
757
758 if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
759 return -EINVAL;
760
761 ccm_name = crypto_attr_alg_name(tb[1]);
762 if (IS_ERR(ccm_name))
763 return PTR_ERR(ccm_name);
764
765 inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
766 if (!inst)
767 return -ENOMEM;
768
769 spawn = aead_instance_ctx(inst);
770 crypto_set_aead_spawn(spawn, aead_crypto_instance(inst));
771 err = crypto_grab_aead(spawn, ccm_name, 0,
772 crypto_requires_sync(algt->type, algt->mask));
773 if (err)
774 goto out_free_inst;
775
776 alg = crypto_spawn_aead_alg(spawn);
777
778 err = -EINVAL;
779
780 /* We only support 16-byte blocks. */
781 if (crypto_aead_alg_ivsize(alg) != 16)
782 goto out_drop_alg;
783
784 /* Not a stream cipher? */
785 if (alg->base.cra_blocksize != 1)
786 goto out_drop_alg;
787
788 err = -ENAMETOOLONG;
789 if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
790 "rfc4309(%s)", alg->base.cra_name) >=
791 CRYPTO_MAX_ALG_NAME ||
792 snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
793 "rfc4309(%s)", alg->base.cra_driver_name) >=
794 CRYPTO_MAX_ALG_NAME)
795 goto out_drop_alg;
796
797 inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
798 inst->alg.base.cra_priority = alg->base.cra_priority;
799 inst->alg.base.cra_blocksize = 1;
800 inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
801
802 inst->alg.ivsize = 8;
803 inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
804 inst->alg.maxauthsize = 16;
805
806 inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4309_ctx);
807
808 inst->alg.init = crypto_rfc4309_init_tfm;
809 inst->alg.exit = crypto_rfc4309_exit_tfm;
810
811 inst->alg.setkey = crypto_rfc4309_setkey;
812 inst->alg.setauthsize = crypto_rfc4309_setauthsize;
813 inst->alg.encrypt = crypto_rfc4309_encrypt;
814 inst->alg.decrypt = crypto_rfc4309_decrypt;
815
816 inst->free = crypto_rfc4309_free;
817
818 err = aead_register_instance(tmpl, inst);
819 if (err)
820 goto out_drop_alg;
821
822 out:
823 return err;
824
825 out_drop_alg:
826 crypto_drop_aead(spawn);
827 out_free_inst:
828 kfree(inst);
829 goto out;
830 }
831
crypto_cbcmac_digest_setkey(struct crypto_shash * parent,const u8 * inkey,unsigned int keylen)832 static int crypto_cbcmac_digest_setkey(struct crypto_shash *parent,
833 const u8 *inkey, unsigned int keylen)
834 {
835 struct cbcmac_tfm_ctx *ctx = crypto_shash_ctx(parent);
836
837 return crypto_cipher_setkey(ctx->child, inkey, keylen);
838 }
839
crypto_cbcmac_digest_init(struct shash_desc * pdesc)840 static int crypto_cbcmac_digest_init(struct shash_desc *pdesc)
841 {
842 struct cbcmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
843 int bs = crypto_shash_digestsize(pdesc->tfm);
844 u8 *dg = (u8 *)ctx + crypto_shash_descsize(pdesc->tfm) - bs;
845
846 ctx->len = 0;
847 memset(dg, 0, bs);
848
849 return 0;
850 }
851
crypto_cbcmac_digest_update(struct shash_desc * pdesc,const u8 * p,unsigned int len)852 static int crypto_cbcmac_digest_update(struct shash_desc *pdesc, const u8 *p,
853 unsigned int len)
854 {
855 struct crypto_shash *parent = pdesc->tfm;
856 struct cbcmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
857 struct cbcmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
858 struct crypto_cipher *tfm = tctx->child;
859 int bs = crypto_shash_digestsize(parent);
860 u8 *dg = (u8 *)ctx + crypto_shash_descsize(parent) - bs;
861
862 while (len > 0) {
863 unsigned int l = min(len, bs - ctx->len);
864
865 crypto_xor(dg + ctx->len, p, l);
866 ctx->len +=l;
867 len -= l;
868 p += l;
869
870 if (ctx->len == bs) {
871 crypto_cipher_encrypt_one(tfm, dg, dg);
872 ctx->len = 0;
873 }
874 }
875
876 return 0;
877 }
878
crypto_cbcmac_digest_final(struct shash_desc * pdesc,u8 * out)879 static int crypto_cbcmac_digest_final(struct shash_desc *pdesc, u8 *out)
880 {
881 struct crypto_shash *parent = pdesc->tfm;
882 struct cbcmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
883 struct cbcmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
884 struct crypto_cipher *tfm = tctx->child;
885 int bs = crypto_shash_digestsize(parent);
886 u8 *dg = (u8 *)ctx + crypto_shash_descsize(parent) - bs;
887
888 if (ctx->len)
889 crypto_cipher_encrypt_one(tfm, dg, dg);
890
891 memcpy(out, dg, bs);
892 return 0;
893 }
894
cbcmac_init_tfm(struct crypto_tfm * tfm)895 static int cbcmac_init_tfm(struct crypto_tfm *tfm)
896 {
897 struct crypto_cipher *cipher;
898 struct crypto_instance *inst = (void *)tfm->__crt_alg;
899 struct crypto_spawn *spawn = crypto_instance_ctx(inst);
900 struct cbcmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
901
902 cipher = crypto_spawn_cipher(spawn);
903 if (IS_ERR(cipher))
904 return PTR_ERR(cipher);
905
906 ctx->child = cipher;
907
908 return 0;
909 };
910
cbcmac_exit_tfm(struct crypto_tfm * tfm)911 static void cbcmac_exit_tfm(struct crypto_tfm *tfm)
912 {
913 struct cbcmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
914 crypto_free_cipher(ctx->child);
915 }
916
cbcmac_create(struct crypto_template * tmpl,struct rtattr ** tb)917 static int cbcmac_create(struct crypto_template *tmpl, struct rtattr **tb)
918 {
919 struct shash_instance *inst;
920 struct crypto_alg *alg;
921 int err;
922
923 err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH);
924 if (err)
925 return err;
926
927 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
928 CRYPTO_ALG_TYPE_MASK);
929 if (IS_ERR(alg))
930 return PTR_ERR(alg);
931
932 inst = shash_alloc_instance("cbcmac", alg);
933 err = PTR_ERR(inst);
934 if (IS_ERR(inst))
935 goto out_put_alg;
936
937 err = crypto_init_spawn(shash_instance_ctx(inst), alg,
938 shash_crypto_instance(inst),
939 CRYPTO_ALG_TYPE_MASK);
940 if (err)
941 goto out_free_inst;
942
943 inst->alg.base.cra_priority = alg->cra_priority;
944 inst->alg.base.cra_blocksize = 1;
945
946 inst->alg.digestsize = alg->cra_blocksize;
947 inst->alg.descsize = ALIGN(sizeof(struct cbcmac_desc_ctx),
948 alg->cra_alignmask + 1) +
949 alg->cra_blocksize;
950
951 inst->alg.base.cra_ctxsize = sizeof(struct cbcmac_tfm_ctx);
952 inst->alg.base.cra_init = cbcmac_init_tfm;
953 inst->alg.base.cra_exit = cbcmac_exit_tfm;
954
955 inst->alg.init = crypto_cbcmac_digest_init;
956 inst->alg.update = crypto_cbcmac_digest_update;
957 inst->alg.final = crypto_cbcmac_digest_final;
958 inst->alg.setkey = crypto_cbcmac_digest_setkey;
959
960 err = shash_register_instance(tmpl, inst);
961
962 out_free_inst:
963 if (err)
964 shash_free_instance(shash_crypto_instance(inst));
965
966 out_put_alg:
967 crypto_mod_put(alg);
968 return err;
969 }
970
971 static struct crypto_template crypto_ccm_tmpls[] = {
972 {
973 .name = "cbcmac",
974 .create = cbcmac_create,
975 .free = shash_free_instance,
976 .module = THIS_MODULE,
977 }, {
978 .name = "ccm_base",
979 .create = crypto_ccm_base_create,
980 .module = THIS_MODULE,
981 }, {
982 .name = "ccm",
983 .create = crypto_ccm_create,
984 .module = THIS_MODULE,
985 }, {
986 .name = "rfc4309",
987 .create = crypto_rfc4309_create,
988 .module = THIS_MODULE,
989 },
990 };
991
crypto_ccm_module_init(void)992 static int __init crypto_ccm_module_init(void)
993 {
994 return crypto_register_templates(crypto_ccm_tmpls,
995 ARRAY_SIZE(crypto_ccm_tmpls));
996 }
997
crypto_ccm_module_exit(void)998 static void __exit crypto_ccm_module_exit(void)
999 {
1000 crypto_unregister_templates(crypto_ccm_tmpls,
1001 ARRAY_SIZE(crypto_ccm_tmpls));
1002 }
1003
1004 subsys_initcall(crypto_ccm_module_init);
1005 module_exit(crypto_ccm_module_exit);
1006
1007 MODULE_LICENSE("GPL");
1008 MODULE_DESCRIPTION("Counter with CBC MAC");
1009 MODULE_ALIAS_CRYPTO("ccm_base");
1010 MODULE_ALIAS_CRYPTO("rfc4309");
1011 MODULE_ALIAS_CRYPTO("ccm");
1012 MODULE_ALIAS_CRYPTO("cbcmac");
1013
