2 * ChaCha20-Poly1305 AEAD, RFC7539
4 * Copyright (C) 2015 Martin Willi
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #include <crypto/internal/aead.h>
13 #include <crypto/internal/hash.h>
14 #include <crypto/internal/skcipher.h>
15 #include <crypto/scatterwalk.h>
16 #include <crypto/chacha20.h>
17 #include <linux/err.h>
18 #include <linux/init.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
24 #define POLY1305_BLOCK_SIZE 16
25 #define POLY1305_DIGEST_SIZE 16
26 #define POLY1305_KEY_SIZE 32
27 #define CHACHAPOLY_IV_SIZE 12
29 struct chachapoly_instance_ctx {
30 struct crypto_skcipher_spawn chacha;
31 struct crypto_ahash_spawn poly;
35 struct chachapoly_ctx {
36 struct crypto_ablkcipher *chacha;
37 struct crypto_ahash *poly;
38 /* key bytes we use for the ChaCha20 IV */
44 /* zero byte padding for AD/ciphertext, as needed */
45 u8 pad[POLY1305_BLOCK_SIZE];
46 /* tail data with AD/ciphertext lengths */
51 struct scatterlist src[1];
52 struct ahash_request req; /* must be last member */
56 u8 iv[CHACHA20_IV_SIZE];
57 struct scatterlist src[1];
58 struct ablkcipher_request req; /* must be last member */
61 struct chachapoly_req_ctx {
62 struct scatterlist src[2];
63 struct scatterlist dst[2];
64 /* the key we generate for Poly1305 using Chacha20 */
65 u8 key[POLY1305_KEY_SIZE];
66 /* calculated Poly1305 tag */
67 u8 tag[POLY1305_DIGEST_SIZE];
68 /* length of data to en/decrypt, without ICV */
69 unsigned int cryptlen;
70 /* Actual AD, excluding IV */
71 unsigned int assoclen;
74 struct chacha_req chacha;
78 static inline void async_done_continue(struct aead_request *req, int err,
79 int (*cont)(struct aead_request *))
84 if (err != -EINPROGRESS && err != -EBUSY)
85 aead_request_complete(req, err);
88 static void chacha_iv(u8 *iv, struct aead_request *req, u32 icb)
90 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
91 __le32 leicb = cpu_to_le32(icb);
93 memcpy(iv, &leicb, sizeof(leicb));
94 memcpy(iv + sizeof(leicb), ctx->salt, ctx->saltlen);
95 memcpy(iv + sizeof(leicb) + ctx->saltlen, req->iv,
96 CHACHA20_IV_SIZE - sizeof(leicb) - ctx->saltlen);
99 static int poly_verify_tag(struct aead_request *req)
101 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
102 u8 tag[sizeof(rctx->tag)];
104 scatterwalk_map_and_copy(tag, req->src,
105 req->assoclen + rctx->cryptlen,
107 if (crypto_memneq(tag, rctx->tag, sizeof(tag)))
112 static int poly_copy_tag(struct aead_request *req)
114 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
116 scatterwalk_map_and_copy(rctx->tag, req->dst,
117 req->assoclen + rctx->cryptlen,
118 sizeof(rctx->tag), 1);
122 static void chacha_decrypt_done(struct crypto_async_request *areq, int err)
124 async_done_continue(areq->data, err, poly_verify_tag);
127 static int chacha_decrypt(struct aead_request *req)
129 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
130 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
131 struct chacha_req *creq = &rctx->u.chacha;
132 struct scatterlist *src, *dst;
135 chacha_iv(creq->iv, req, 1);
137 sg_init_table(rctx->src, 2);
138 src = scatterwalk_ffwd(rctx->src, req->src, req->assoclen);
141 if (req->src != req->dst) {
142 sg_init_table(rctx->dst, 2);
143 dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);
146 ablkcipher_request_set_callback(&creq->req, aead_request_flags(req),
147 chacha_decrypt_done, req);
148 ablkcipher_request_set_tfm(&creq->req, ctx->chacha);
149 ablkcipher_request_set_crypt(&creq->req, src, dst,
150 rctx->cryptlen, creq->iv);
151 err = crypto_ablkcipher_decrypt(&creq->req);
155 return poly_verify_tag(req);
158 static int poly_tail_continue(struct aead_request *req)
160 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
162 if (rctx->cryptlen == req->cryptlen) /* encrypting */
163 return poly_copy_tag(req);
165 return chacha_decrypt(req);
168 static void poly_tail_done(struct crypto_async_request *areq, int err)
170 async_done_continue(areq->data, err, poly_tail_continue);
173 static int poly_tail(struct aead_request *req)
175 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
176 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
177 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
178 struct poly_req *preq = &rctx->u.poly;
182 sg_init_table(preq->src, 1);
183 len = cpu_to_le64(rctx->assoclen);
184 memcpy(&preq->tail.assoclen, &len, sizeof(len));
185 len = cpu_to_le64(rctx->cryptlen);
186 memcpy(&preq->tail.cryptlen, &len, sizeof(len));
187 sg_set_buf(preq->src, &preq->tail, sizeof(preq->tail));
189 ahash_request_set_callback(&preq->req, aead_request_flags(req),
190 poly_tail_done, req);
191 ahash_request_set_tfm(&preq->req, ctx->poly);
192 ahash_request_set_crypt(&preq->req, preq->src,
193 rctx->tag, sizeof(preq->tail));
195 err = crypto_ahash_finup(&preq->req);
199 return poly_tail_continue(req);
202 static void poly_cipherpad_done(struct crypto_async_request *areq, int err)
204 async_done_continue(areq->data, err, poly_tail);
207 static int poly_cipherpad(struct aead_request *req)
209 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
210 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
211 struct poly_req *preq = &rctx->u.poly;
212 unsigned int padlen, bs = POLY1305_BLOCK_SIZE;
215 padlen = (bs - (rctx->cryptlen % bs)) % bs;
216 memset(preq->pad, 0, sizeof(preq->pad));
217 sg_init_table(preq->src, 1);
218 sg_set_buf(preq->src, &preq->pad, padlen);
220 ahash_request_set_callback(&preq->req, aead_request_flags(req),
221 poly_cipherpad_done, req);
222 ahash_request_set_tfm(&preq->req, ctx->poly);
223 ahash_request_set_crypt(&preq->req, preq->src, NULL, padlen);
225 err = crypto_ahash_update(&preq->req);
229 return poly_tail(req);
232 static void poly_cipher_done(struct crypto_async_request *areq, int err)
234 async_done_continue(areq->data, err, poly_cipherpad);
237 static int poly_cipher(struct aead_request *req)
239 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
240 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
241 struct poly_req *preq = &rctx->u.poly;
242 struct scatterlist *crypt = req->src;
245 if (rctx->cryptlen == req->cryptlen) /* encrypting */
248 sg_init_table(rctx->src, 2);
249 crypt = scatterwalk_ffwd(rctx->src, crypt, req->assoclen);
251 ahash_request_set_callback(&preq->req, aead_request_flags(req),
252 poly_cipher_done, req);
253 ahash_request_set_tfm(&preq->req, ctx->poly);
254 ahash_request_set_crypt(&preq->req, crypt, NULL, rctx->cryptlen);
256 err = crypto_ahash_update(&preq->req);
260 return poly_cipherpad(req);
263 static void poly_adpad_done(struct crypto_async_request *areq, int err)
265 async_done_continue(areq->data, err, poly_cipher);
268 static int poly_adpad(struct aead_request *req)
270 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
271 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
272 struct poly_req *preq = &rctx->u.poly;
273 unsigned int padlen, bs = POLY1305_BLOCK_SIZE;
276 padlen = (bs - (rctx->assoclen % bs)) % bs;
277 memset(preq->pad, 0, sizeof(preq->pad));
278 sg_init_table(preq->src, 1);
279 sg_set_buf(preq->src, preq->pad, padlen);
281 ahash_request_set_callback(&preq->req, aead_request_flags(req),
282 poly_adpad_done, req);
283 ahash_request_set_tfm(&preq->req, ctx->poly);
284 ahash_request_set_crypt(&preq->req, preq->src, NULL, padlen);
286 err = crypto_ahash_update(&preq->req);
290 return poly_cipher(req);
293 static void poly_ad_done(struct crypto_async_request *areq, int err)
295 async_done_continue(areq->data, err, poly_adpad);
298 static int poly_ad(struct aead_request *req)
300 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
301 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
302 struct poly_req *preq = &rctx->u.poly;
305 ahash_request_set_callback(&preq->req, aead_request_flags(req),
307 ahash_request_set_tfm(&preq->req, ctx->poly);
308 ahash_request_set_crypt(&preq->req, req->src, NULL, rctx->assoclen);
310 err = crypto_ahash_update(&preq->req);
314 return poly_adpad(req);
317 static void poly_setkey_done(struct crypto_async_request *areq, int err)
319 async_done_continue(areq->data, err, poly_ad);
322 static int poly_setkey(struct aead_request *req)
324 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
325 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
326 struct poly_req *preq = &rctx->u.poly;
329 sg_init_table(preq->src, 1);
330 sg_set_buf(preq->src, rctx->key, sizeof(rctx->key));
332 ahash_request_set_callback(&preq->req, aead_request_flags(req),
333 poly_setkey_done, req);
334 ahash_request_set_tfm(&preq->req, ctx->poly);
335 ahash_request_set_crypt(&preq->req, preq->src, NULL, sizeof(rctx->key));
337 err = crypto_ahash_update(&preq->req);
344 static void poly_init_done(struct crypto_async_request *areq, int err)
346 async_done_continue(areq->data, err, poly_setkey);
349 static int poly_init(struct aead_request *req)
351 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
352 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
353 struct poly_req *preq = &rctx->u.poly;
356 ahash_request_set_callback(&preq->req, aead_request_flags(req),
357 poly_init_done, req);
358 ahash_request_set_tfm(&preq->req, ctx->poly);
360 err = crypto_ahash_init(&preq->req);
364 return poly_setkey(req);
367 static void poly_genkey_done(struct crypto_async_request *areq, int err)
369 async_done_continue(areq->data, err, poly_init);
372 static int poly_genkey(struct aead_request *req)
374 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
375 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
376 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
377 struct chacha_req *creq = &rctx->u.chacha;
380 rctx->assoclen = req->assoclen;
382 if (crypto_aead_ivsize(tfm) == 8) {
383 if (rctx->assoclen < 8)
388 sg_init_table(creq->src, 1);
389 memset(rctx->key, 0, sizeof(rctx->key));
390 sg_set_buf(creq->src, rctx->key, sizeof(rctx->key));
392 chacha_iv(creq->iv, req, 0);
394 ablkcipher_request_set_callback(&creq->req, aead_request_flags(req),
395 poly_genkey_done, req);
396 ablkcipher_request_set_tfm(&creq->req, ctx->chacha);
397 ablkcipher_request_set_crypt(&creq->req, creq->src, creq->src,
398 POLY1305_KEY_SIZE, creq->iv);
400 err = crypto_ablkcipher_decrypt(&creq->req);
404 return poly_init(req);
407 static void chacha_encrypt_done(struct crypto_async_request *areq, int err)
409 async_done_continue(areq->data, err, poly_genkey);
412 static int chacha_encrypt(struct aead_request *req)
414 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
415 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
416 struct chacha_req *creq = &rctx->u.chacha;
417 struct scatterlist *src, *dst;
420 chacha_iv(creq->iv, req, 1);
422 sg_init_table(rctx->src, 2);
423 src = scatterwalk_ffwd(rctx->src, req->src, req->assoclen);
426 if (req->src != req->dst) {
427 sg_init_table(rctx->dst, 2);
428 dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);
431 ablkcipher_request_set_callback(&creq->req, aead_request_flags(req),
432 chacha_encrypt_done, req);
433 ablkcipher_request_set_tfm(&creq->req, ctx->chacha);
434 ablkcipher_request_set_crypt(&creq->req, src, dst,
435 req->cryptlen, creq->iv);
436 err = crypto_ablkcipher_encrypt(&creq->req);
440 return poly_genkey(req);
443 static int chachapoly_encrypt(struct aead_request *req)
445 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
447 rctx->cryptlen = req->cryptlen;
449 /* encrypt call chain:
450 * - chacha_encrypt/done()
451 * - poly_genkey/done()
453 * - poly_setkey/done()
455 * - poly_adpad/done()
456 * - poly_cipher/done()
457 * - poly_cipherpad/done()
458 * - poly_tail/done/continue()
461 return chacha_encrypt(req);
464 static int chachapoly_decrypt(struct aead_request *req)
466 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
468 rctx->cryptlen = req->cryptlen - POLY1305_DIGEST_SIZE;
470 /* decrypt call chain:
471 * - poly_genkey/done()
473 * - poly_setkey/done()
475 * - poly_adpad/done()
476 * - poly_cipher/done()
477 * - poly_cipherpad/done()
478 * - poly_tail/done/continue()
479 * - chacha_decrypt/done()
480 * - poly_verify_tag()
482 return poly_genkey(req);
485 static int chachapoly_setkey(struct crypto_aead *aead, const u8 *key,
488 struct chachapoly_ctx *ctx = crypto_aead_ctx(aead);
491 if (keylen != ctx->saltlen + CHACHA20_KEY_SIZE)
494 keylen -= ctx->saltlen;
495 memcpy(ctx->salt, key + keylen, ctx->saltlen);
497 crypto_ablkcipher_clear_flags(ctx->chacha, CRYPTO_TFM_REQ_MASK);
498 crypto_ablkcipher_set_flags(ctx->chacha, crypto_aead_get_flags(aead) &
499 CRYPTO_TFM_REQ_MASK);
501 err = crypto_ablkcipher_setkey(ctx->chacha, key, keylen);
502 crypto_aead_set_flags(aead, crypto_ablkcipher_get_flags(ctx->chacha) &
503 CRYPTO_TFM_RES_MASK);
507 static int chachapoly_setauthsize(struct crypto_aead *tfm,
508 unsigned int authsize)
510 if (authsize != POLY1305_DIGEST_SIZE)
516 static int chachapoly_init(struct crypto_aead *tfm)
518 struct aead_instance *inst = aead_alg_instance(tfm);
519 struct chachapoly_instance_ctx *ictx = aead_instance_ctx(inst);
520 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
521 struct crypto_ablkcipher *chacha;
522 struct crypto_ahash *poly;
525 poly = crypto_spawn_ahash(&ictx->poly);
527 return PTR_ERR(poly);
529 chacha = crypto_spawn_skcipher(&ictx->chacha);
530 if (IS_ERR(chacha)) {
531 crypto_free_ahash(poly);
532 return PTR_ERR(chacha);
535 ctx->chacha = chacha;
537 ctx->saltlen = ictx->saltlen;
539 align = crypto_aead_alignmask(tfm);
540 align &= ~(crypto_tfm_ctx_alignment() - 1);
541 crypto_aead_set_reqsize(
543 align + offsetof(struct chachapoly_req_ctx, u) +
544 max(offsetof(struct chacha_req, req) +
545 sizeof(struct ablkcipher_request) +
546 crypto_ablkcipher_reqsize(chacha),
547 offsetof(struct poly_req, req) +
548 sizeof(struct ahash_request) +
549 crypto_ahash_reqsize(poly)));
554 static void chachapoly_exit(struct crypto_aead *tfm)
556 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
558 crypto_free_ahash(ctx->poly);
559 crypto_free_ablkcipher(ctx->chacha);
562 static void chachapoly_free(struct aead_instance *inst)
564 struct chachapoly_instance_ctx *ctx = aead_instance_ctx(inst);
566 crypto_drop_skcipher(&ctx->chacha);
567 crypto_drop_ahash(&ctx->poly);
571 static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
572 const char *name, unsigned int ivsize)
574 struct crypto_attr_type *algt;
575 struct aead_instance *inst;
576 struct crypto_alg *chacha;
577 struct crypto_alg *poly;
578 struct hash_alg_common *poly_hash;
579 struct chachapoly_instance_ctx *ctx;
580 const char *chacha_name, *poly_name;
583 if (ivsize > CHACHAPOLY_IV_SIZE)
586 algt = crypto_get_attr_type(tb);
588 return PTR_ERR(algt);
590 if ((algt->type ^ (CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_AEAD_NEW)) &
594 chacha_name = crypto_attr_alg_name(tb[1]);
595 if (IS_ERR(chacha_name))
596 return PTR_ERR(chacha_name);
597 poly_name = crypto_attr_alg_name(tb[2]);
598 if (IS_ERR(poly_name))
599 return PTR_ERR(poly_name);
601 poly = crypto_find_alg(poly_name, &crypto_ahash_type,
602 CRYPTO_ALG_TYPE_HASH,
603 CRYPTO_ALG_TYPE_AHASH_MASK);
605 return PTR_ERR(poly);
608 inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
612 ctx = aead_instance_ctx(inst);
613 ctx->saltlen = CHACHAPOLY_IV_SIZE - ivsize;
614 poly_hash = __crypto_hash_alg_common(poly);
615 err = crypto_init_ahash_spawn(&ctx->poly, poly_hash,
616 aead_crypto_instance(inst));
620 crypto_set_skcipher_spawn(&ctx->chacha, aead_crypto_instance(inst));
621 err = crypto_grab_skcipher(&ctx->chacha, chacha_name, 0,
622 crypto_requires_sync(algt->type,
627 chacha = crypto_skcipher_spawn_alg(&ctx->chacha);
630 /* Need 16-byte IV size, including Initial Block Counter value */
631 if (chacha->cra_ablkcipher.ivsize != CHACHA20_IV_SIZE)
632 goto out_drop_chacha;
633 /* Not a stream cipher? */
634 if (chacha->cra_blocksize != 1)
635 goto out_drop_chacha;
638 if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
639 "%s(%s,%s)", name, chacha_name,
640 poly_name) >= CRYPTO_MAX_ALG_NAME)
641 goto out_drop_chacha;
642 if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
643 "%s(%s,%s)", name, chacha->cra_driver_name,
644 poly->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
645 goto out_drop_chacha;
647 inst->alg.base.cra_flags = (chacha->cra_flags | poly->cra_flags) &
649 inst->alg.base.cra_flags |= CRYPTO_ALG_AEAD_NEW;
650 inst->alg.base.cra_priority = (chacha->cra_priority +
651 poly->cra_priority) / 2;
652 inst->alg.base.cra_blocksize = 1;
653 inst->alg.base.cra_alignmask = chacha->cra_alignmask |
655 inst->alg.base.cra_ctxsize = sizeof(struct chachapoly_ctx) +
657 inst->alg.ivsize = ivsize;
658 inst->alg.maxauthsize = POLY1305_DIGEST_SIZE;
659 inst->alg.init = chachapoly_init;
660 inst->alg.exit = chachapoly_exit;
661 inst->alg.encrypt = chachapoly_encrypt;
662 inst->alg.decrypt = chachapoly_decrypt;
663 inst->alg.setkey = chachapoly_setkey;
664 inst->alg.setauthsize = chachapoly_setauthsize;
666 inst->free = chachapoly_free;
668 err = aead_register_instance(tmpl, inst);
670 goto out_drop_chacha;
673 crypto_mod_put(poly);
677 crypto_drop_skcipher(&ctx->chacha);
679 crypto_drop_ahash(&ctx->poly);
685 static int rfc7539_create(struct crypto_template *tmpl, struct rtattr **tb)
687 return chachapoly_create(tmpl, tb, "rfc7539", 12);
690 static int rfc7539esp_create(struct crypto_template *tmpl, struct rtattr **tb)
692 return chachapoly_create(tmpl, tb, "rfc7539esp", 8);
695 static struct crypto_template rfc7539_tmpl = {
697 .create = rfc7539_create,
698 .module = THIS_MODULE,
701 static struct crypto_template rfc7539esp_tmpl = {
702 .name = "rfc7539esp",
703 .create = rfc7539esp_create,
704 .module = THIS_MODULE,
707 static int __init chacha20poly1305_module_init(void)
711 err = crypto_register_template(&rfc7539_tmpl);
715 err = crypto_register_template(&rfc7539esp_tmpl);
717 crypto_unregister_template(&rfc7539_tmpl);
722 static void __exit chacha20poly1305_module_exit(void)
724 crypto_unregister_template(&rfc7539esp_tmpl);
725 crypto_unregister_template(&rfc7539_tmpl);
728 module_init(chacha20poly1305_module_init);
729 module_exit(chacha20poly1305_module_exit);
731 MODULE_LICENSE("GPL");
732 MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
733 MODULE_DESCRIPTION("ChaCha20-Poly1305 AEAD");
734 MODULE_ALIAS_CRYPTO("rfc7539");
735 MODULE_ALIAS_CRYPTO("rfc7539esp");