blob: db1bc3147bc4708b5a4e16c36844e5452101bf64 [file] [log] [blame]
Martin Willi71ebc4d2015-06-01 13:44:00 +02001/*
2 * ChaCha20-Poly1305 AEAD, RFC7539
3 *
4 * Copyright (C) 2015 Martin Willi
5 *
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.
10 */
11
12#include <crypto/internal/aead.h>
13#include <crypto/internal/hash.h>
14#include <crypto/internal/skcipher.h>
15#include <crypto/scatterwalk.h>
Martin Willi31d72472015-07-16 19:14:00 +020016#include <crypto/chacha20.h>
Martin Willi2546f812015-07-16 19:14:05 +020017#include <crypto/poly1305.h>
Martin Willi71ebc4d2015-06-01 13:44:00 +020018#include <linux/err.h>
19#include <linux/init.h>
20#include <linux/kernel.h>
21#include <linux/module.h>
22
23#include "internal.h"
24
Martin Willi71ebc4d2015-06-01 13:44:00 +020025#define CHACHAPOLY_IV_SIZE 12
26
27struct chachapoly_instance_ctx {
28 struct crypto_skcipher_spawn chacha;
29 struct crypto_ahash_spawn poly;
30 unsigned int saltlen;
31};
32
33struct chachapoly_ctx {
Herbert Xu1e1f0062016-07-12 13:17:40 +080034 struct crypto_skcipher *chacha;
Martin Willi71ebc4d2015-06-01 13:44:00 +020035 struct crypto_ahash *poly;
36 /* key bytes we use for the ChaCha20 IV */
37 unsigned int saltlen;
38 u8 salt[];
39};
40
41struct poly_req {
42 /* zero byte padding for AD/ciphertext, as needed */
43 u8 pad[POLY1305_BLOCK_SIZE];
44 /* tail data with AD/ciphertext lengths */
45 struct {
46 __le64 assoclen;
47 __le64 cryptlen;
48 } tail;
49 struct scatterlist src[1];
50 struct ahash_request req; /* must be last member */
51};
52
53struct chacha_req {
Martin Willi71ebc4d2015-06-01 13:44:00 +020054 u8 iv[CHACHA20_IV_SIZE];
55 struct scatterlist src[1];
Herbert Xu1e1f0062016-07-12 13:17:40 +080056 struct skcipher_request req; /* must be last member */
Martin Willi71ebc4d2015-06-01 13:44:00 +020057};
58
59struct chachapoly_req_ctx {
Herbert Xu74790922015-07-16 12:35:08 +080060 struct scatterlist src[2];
61 struct scatterlist dst[2];
Martin Willic2b7b20a2015-06-16 11:34:16 +020062 /* the key we generate for Poly1305 using Chacha20 */
63 u8 key[POLY1305_KEY_SIZE];
Martin Willi71ebc4d2015-06-01 13:44:00 +020064 /* calculated Poly1305 tag */
65 u8 tag[POLY1305_DIGEST_SIZE];
66 /* length of data to en/decrypt, without ICV */
67 unsigned int cryptlen;
Herbert Xu74790922015-07-16 12:35:08 +080068 /* Actual AD, excluding IV */
69 unsigned int assoclen;
Martin Willi71ebc4d2015-06-01 13:44:00 +020070 union {
71 struct poly_req poly;
72 struct chacha_req chacha;
73 } u;
74};
75
76static inline void async_done_continue(struct aead_request *req, int err,
77 int (*cont)(struct aead_request *))
78{
79 if (!err)
80 err = cont(req);
81
82 if (err != -EINPROGRESS && err != -EBUSY)
83 aead_request_complete(req, err);
84}
85
86static void chacha_iv(u8 *iv, struct aead_request *req, u32 icb)
87{
88 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
89 __le32 leicb = cpu_to_le32(icb);
90
91 memcpy(iv, &leicb, sizeof(leicb));
92 memcpy(iv + sizeof(leicb), ctx->salt, ctx->saltlen);
93 memcpy(iv + sizeof(leicb) + ctx->saltlen, req->iv,
94 CHACHA20_IV_SIZE - sizeof(leicb) - ctx->saltlen);
95}
96
97static int poly_verify_tag(struct aead_request *req)
98{
99 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
100 u8 tag[sizeof(rctx->tag)];
101
Herbert Xu74790922015-07-16 12:35:08 +0800102 scatterwalk_map_and_copy(tag, req->src,
103 req->assoclen + rctx->cryptlen,
104 sizeof(tag), 0);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200105 if (crypto_memneq(tag, rctx->tag, sizeof(tag)))
106 return -EBADMSG;
107 return 0;
108}
109
110static int poly_copy_tag(struct aead_request *req)
111{
112 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
113
Herbert Xu74790922015-07-16 12:35:08 +0800114 scatterwalk_map_and_copy(rctx->tag, req->dst,
115 req->assoclen + rctx->cryptlen,
Martin Willi71ebc4d2015-06-01 13:44:00 +0200116 sizeof(rctx->tag), 1);
117 return 0;
118}
119
120static void chacha_decrypt_done(struct crypto_async_request *areq, int err)
121{
122 async_done_continue(areq->data, err, poly_verify_tag);
123}
124
125static int chacha_decrypt(struct aead_request *req)
126{
127 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
128 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
129 struct chacha_req *creq = &rctx->u.chacha;
Herbert Xu74790922015-07-16 12:35:08 +0800130 struct scatterlist *src, *dst;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200131 int err;
132
Jason A. Donenfeld161151d2015-12-06 02:51:38 +0100133 if (rctx->cryptlen == 0)
134 goto skip;
135
Martin Willi71ebc4d2015-06-01 13:44:00 +0200136 chacha_iv(creq->iv, req, 1);
137
Herbert Xu74790922015-07-16 12:35:08 +0800138 sg_init_table(rctx->src, 2);
139 src = scatterwalk_ffwd(rctx->src, req->src, req->assoclen);
140 dst = src;
141
142 if (req->src != req->dst) {
143 sg_init_table(rctx->dst, 2);
144 dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);
145 }
146
Herbert Xu1e1f0062016-07-12 13:17:40 +0800147 skcipher_request_set_callback(&creq->req, aead_request_flags(req),
148 chacha_decrypt_done, req);
149 skcipher_request_set_tfm(&creq->req, ctx->chacha);
150 skcipher_request_set_crypt(&creq->req, src, dst,
151 rctx->cryptlen, creq->iv);
152 err = crypto_skcipher_decrypt(&creq->req);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200153 if (err)
154 return err;
155
Jason A. Donenfeld161151d2015-12-06 02:51:38 +0100156skip:
Martin Willi71ebc4d2015-06-01 13:44:00 +0200157 return poly_verify_tag(req);
158}
159
160static int poly_tail_continue(struct aead_request *req)
161{
162 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
163
164 if (rctx->cryptlen == req->cryptlen) /* encrypting */
165 return poly_copy_tag(req);
166
167 return chacha_decrypt(req);
168}
169
170static void poly_tail_done(struct crypto_async_request *areq, int err)
171{
172 async_done_continue(areq->data, err, poly_tail_continue);
173}
174
175static int poly_tail(struct aead_request *req)
176{
Herbert Xu74790922015-07-16 12:35:08 +0800177 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
178 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200179 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
180 struct poly_req *preq = &rctx->u.poly;
181 __le64 len;
182 int err;
183
184 sg_init_table(preq->src, 1);
Herbert Xu74790922015-07-16 12:35:08 +0800185 len = cpu_to_le64(rctx->assoclen);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200186 memcpy(&preq->tail.assoclen, &len, sizeof(len));
187 len = cpu_to_le64(rctx->cryptlen);
188 memcpy(&preq->tail.cryptlen, &len, sizeof(len));
189 sg_set_buf(preq->src, &preq->tail, sizeof(preq->tail));
190
191 ahash_request_set_callback(&preq->req, aead_request_flags(req),
192 poly_tail_done, req);
193 ahash_request_set_tfm(&preq->req, ctx->poly);
194 ahash_request_set_crypt(&preq->req, preq->src,
195 rctx->tag, sizeof(preq->tail));
196
197 err = crypto_ahash_finup(&preq->req);
198 if (err)
199 return err;
200
201 return poly_tail_continue(req);
202}
203
204static void poly_cipherpad_done(struct crypto_async_request *areq, int err)
205{
206 async_done_continue(areq->data, err, poly_tail);
207}
208
209static int poly_cipherpad(struct aead_request *req)
210{
211 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
212 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
213 struct poly_req *preq = &rctx->u.poly;
214 unsigned int padlen, bs = POLY1305_BLOCK_SIZE;
215 int err;
216
217 padlen = (bs - (rctx->cryptlen % bs)) % bs;
218 memset(preq->pad, 0, sizeof(preq->pad));
219 sg_init_table(preq->src, 1);
220 sg_set_buf(preq->src, &preq->pad, padlen);
221
222 ahash_request_set_callback(&preq->req, aead_request_flags(req),
223 poly_cipherpad_done, req);
224 ahash_request_set_tfm(&preq->req, ctx->poly);
225 ahash_request_set_crypt(&preq->req, preq->src, NULL, padlen);
226
227 err = crypto_ahash_update(&preq->req);
228 if (err)
229 return err;
230
231 return poly_tail(req);
232}
233
234static void poly_cipher_done(struct crypto_async_request *areq, int err)
235{
236 async_done_continue(areq->data, err, poly_cipherpad);
237}
238
239static int poly_cipher(struct aead_request *req)
240{
241 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
242 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
243 struct poly_req *preq = &rctx->u.poly;
244 struct scatterlist *crypt = req->src;
245 int err;
246
247 if (rctx->cryptlen == req->cryptlen) /* encrypting */
248 crypt = req->dst;
249
Herbert Xu74790922015-07-16 12:35:08 +0800250 sg_init_table(rctx->src, 2);
251 crypt = scatterwalk_ffwd(rctx->src, crypt, req->assoclen);
252
Martin Willi71ebc4d2015-06-01 13:44:00 +0200253 ahash_request_set_callback(&preq->req, aead_request_flags(req),
254 poly_cipher_done, req);
255 ahash_request_set_tfm(&preq->req, ctx->poly);
256 ahash_request_set_crypt(&preq->req, crypt, NULL, rctx->cryptlen);
257
258 err = crypto_ahash_update(&preq->req);
259 if (err)
260 return err;
261
262 return poly_cipherpad(req);
263}
264
265static void poly_adpad_done(struct crypto_async_request *areq, int err)
266{
267 async_done_continue(areq->data, err, poly_cipher);
268}
269
270static int poly_adpad(struct aead_request *req)
271{
272 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
273 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
274 struct poly_req *preq = &rctx->u.poly;
275 unsigned int padlen, bs = POLY1305_BLOCK_SIZE;
276 int err;
277
Herbert Xu74790922015-07-16 12:35:08 +0800278 padlen = (bs - (rctx->assoclen % bs)) % bs;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200279 memset(preq->pad, 0, sizeof(preq->pad));
280 sg_init_table(preq->src, 1);
281 sg_set_buf(preq->src, preq->pad, padlen);
282
283 ahash_request_set_callback(&preq->req, aead_request_flags(req),
284 poly_adpad_done, req);
285 ahash_request_set_tfm(&preq->req, ctx->poly);
286 ahash_request_set_crypt(&preq->req, preq->src, NULL, padlen);
287
288 err = crypto_ahash_update(&preq->req);
289 if (err)
290 return err;
291
292 return poly_cipher(req);
293}
294
295static void poly_ad_done(struct crypto_async_request *areq, int err)
296{
297 async_done_continue(areq->data, err, poly_adpad);
298}
299
300static int poly_ad(struct aead_request *req)
301{
302 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
303 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
304 struct poly_req *preq = &rctx->u.poly;
305 int err;
306
307 ahash_request_set_callback(&preq->req, aead_request_flags(req),
308 poly_ad_done, req);
309 ahash_request_set_tfm(&preq->req, ctx->poly);
Herbert Xu74790922015-07-16 12:35:08 +0800310 ahash_request_set_crypt(&preq->req, req->src, NULL, rctx->assoclen);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200311
312 err = crypto_ahash_update(&preq->req);
313 if (err)
314 return err;
315
316 return poly_adpad(req);
317}
318
Martin Willic2b7b20a2015-06-16 11:34:16 +0200319static void poly_setkey_done(struct crypto_async_request *areq, int err)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200320{
321 async_done_continue(areq->data, err, poly_ad);
322}
323
Martin Willic2b7b20a2015-06-16 11:34:16 +0200324static int poly_setkey(struct aead_request *req)
325{
326 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
327 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
328 struct poly_req *preq = &rctx->u.poly;
329 int err;
330
331 sg_init_table(preq->src, 1);
332 sg_set_buf(preq->src, rctx->key, sizeof(rctx->key));
333
334 ahash_request_set_callback(&preq->req, aead_request_flags(req),
335 poly_setkey_done, req);
336 ahash_request_set_tfm(&preq->req, ctx->poly);
337 ahash_request_set_crypt(&preq->req, preq->src, NULL, sizeof(rctx->key));
338
339 err = crypto_ahash_update(&preq->req);
340 if (err)
341 return err;
342
343 return poly_ad(req);
344}
345
346static void poly_init_done(struct crypto_async_request *areq, int err)
347{
348 async_done_continue(areq->data, err, poly_setkey);
349}
350
Martin Willi71ebc4d2015-06-01 13:44:00 +0200351static int poly_init(struct aead_request *req)
352{
353 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
354 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
355 struct poly_req *preq = &rctx->u.poly;
356 int err;
357
358 ahash_request_set_callback(&preq->req, aead_request_flags(req),
359 poly_init_done, req);
360 ahash_request_set_tfm(&preq->req, ctx->poly);
361
362 err = crypto_ahash_init(&preq->req);
363 if (err)
364 return err;
365
Martin Willic2b7b20a2015-06-16 11:34:16 +0200366 return poly_setkey(req);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200367}
368
369static void poly_genkey_done(struct crypto_async_request *areq, int err)
370{
Martin Willic2b7b20a2015-06-16 11:34:16 +0200371 async_done_continue(areq->data, err, poly_init);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200372}
373
374static int poly_genkey(struct aead_request *req)
375{
Herbert Xu74790922015-07-16 12:35:08 +0800376 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
377 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200378 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
379 struct chacha_req *creq = &rctx->u.chacha;
380 int err;
381
Herbert Xu74790922015-07-16 12:35:08 +0800382 rctx->assoclen = req->assoclen;
383
384 if (crypto_aead_ivsize(tfm) == 8) {
385 if (rctx->assoclen < 8)
386 return -EINVAL;
387 rctx->assoclen -= 8;
388 }
389
Martin Willi71ebc4d2015-06-01 13:44:00 +0200390 sg_init_table(creq->src, 1);
Martin Willic2b7b20a2015-06-16 11:34:16 +0200391 memset(rctx->key, 0, sizeof(rctx->key));
392 sg_set_buf(creq->src, rctx->key, sizeof(rctx->key));
Martin Willi71ebc4d2015-06-01 13:44:00 +0200393
394 chacha_iv(creq->iv, req, 0);
395
Herbert Xu1e1f0062016-07-12 13:17:40 +0800396 skcipher_request_set_callback(&creq->req, aead_request_flags(req),
397 poly_genkey_done, req);
398 skcipher_request_set_tfm(&creq->req, ctx->chacha);
399 skcipher_request_set_crypt(&creq->req, creq->src, creq->src,
400 POLY1305_KEY_SIZE, creq->iv);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200401
Herbert Xu1e1f0062016-07-12 13:17:40 +0800402 err = crypto_skcipher_decrypt(&creq->req);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200403 if (err)
404 return err;
405
Martin Willic2b7b20a2015-06-16 11:34:16 +0200406 return poly_init(req);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200407}
408
409static void chacha_encrypt_done(struct crypto_async_request *areq, int err)
410{
411 async_done_continue(areq->data, err, poly_genkey);
412}
413
414static int chacha_encrypt(struct aead_request *req)
415{
416 struct chachapoly_ctx *ctx = crypto_aead_ctx(crypto_aead_reqtfm(req));
417 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
418 struct chacha_req *creq = &rctx->u.chacha;
Herbert Xu74790922015-07-16 12:35:08 +0800419 struct scatterlist *src, *dst;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200420 int err;
421
Jason A. Donenfeld161151d2015-12-06 02:51:38 +0100422 if (req->cryptlen == 0)
423 goto skip;
424
Martin Willi71ebc4d2015-06-01 13:44:00 +0200425 chacha_iv(creq->iv, req, 1);
426
Herbert Xu74790922015-07-16 12:35:08 +0800427 sg_init_table(rctx->src, 2);
428 src = scatterwalk_ffwd(rctx->src, req->src, req->assoclen);
429 dst = src;
430
431 if (req->src != req->dst) {
432 sg_init_table(rctx->dst, 2);
433 dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);
434 }
435
Herbert Xu1e1f0062016-07-12 13:17:40 +0800436 skcipher_request_set_callback(&creq->req, aead_request_flags(req),
437 chacha_encrypt_done, req);
438 skcipher_request_set_tfm(&creq->req, ctx->chacha);
439 skcipher_request_set_crypt(&creq->req, src, dst,
440 req->cryptlen, creq->iv);
441 err = crypto_skcipher_encrypt(&creq->req);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200442 if (err)
443 return err;
444
Jason A. Donenfeld161151d2015-12-06 02:51:38 +0100445skip:
Martin Willi71ebc4d2015-06-01 13:44:00 +0200446 return poly_genkey(req);
447}
448
449static int chachapoly_encrypt(struct aead_request *req)
450{
451 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
452
453 rctx->cryptlen = req->cryptlen;
454
455 /* encrypt call chain:
456 * - chacha_encrypt/done()
Martin Willic2b7b20a2015-06-16 11:34:16 +0200457 * - poly_genkey/done()
Martin Willi71ebc4d2015-06-01 13:44:00 +0200458 * - poly_init/done()
Martin Willic2b7b20a2015-06-16 11:34:16 +0200459 * - poly_setkey/done()
Martin Willi71ebc4d2015-06-01 13:44:00 +0200460 * - poly_ad/done()
461 * - poly_adpad/done()
462 * - poly_cipher/done()
463 * - poly_cipherpad/done()
464 * - poly_tail/done/continue()
465 * - poly_copy_tag()
466 */
467 return chacha_encrypt(req);
468}
469
470static int chachapoly_decrypt(struct aead_request *req)
471{
472 struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
473
Martin Willi71ebc4d2015-06-01 13:44:00 +0200474 rctx->cryptlen = req->cryptlen - POLY1305_DIGEST_SIZE;
475
476 /* decrypt call chain:
Martin Willic2b7b20a2015-06-16 11:34:16 +0200477 * - poly_genkey/done()
Martin Willi71ebc4d2015-06-01 13:44:00 +0200478 * - poly_init/done()
Martin Willic2b7b20a2015-06-16 11:34:16 +0200479 * - poly_setkey/done()
Martin Willi71ebc4d2015-06-01 13:44:00 +0200480 * - poly_ad/done()
481 * - poly_adpad/done()
482 * - poly_cipher/done()
483 * - poly_cipherpad/done()
484 * - poly_tail/done/continue()
485 * - chacha_decrypt/done()
486 * - poly_verify_tag()
487 */
488 return poly_genkey(req);
489}
490
491static int chachapoly_setkey(struct crypto_aead *aead, const u8 *key,
492 unsigned int keylen)
493{
494 struct chachapoly_ctx *ctx = crypto_aead_ctx(aead);
495 int err;
496
497 if (keylen != ctx->saltlen + CHACHA20_KEY_SIZE)
498 return -EINVAL;
499
500 keylen -= ctx->saltlen;
501 memcpy(ctx->salt, key + keylen, ctx->saltlen);
502
Herbert Xu1e1f0062016-07-12 13:17:40 +0800503 crypto_skcipher_clear_flags(ctx->chacha, CRYPTO_TFM_REQ_MASK);
504 crypto_skcipher_set_flags(ctx->chacha, crypto_aead_get_flags(aead) &
505 CRYPTO_TFM_REQ_MASK);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200506
Herbert Xu1e1f0062016-07-12 13:17:40 +0800507 err = crypto_skcipher_setkey(ctx->chacha, key, keylen);
508 crypto_aead_set_flags(aead, crypto_skcipher_get_flags(ctx->chacha) &
509 CRYPTO_TFM_RES_MASK);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200510 return err;
511}
512
513static int chachapoly_setauthsize(struct crypto_aead *tfm,
514 unsigned int authsize)
515{
516 if (authsize != POLY1305_DIGEST_SIZE)
517 return -EINVAL;
518
519 return 0;
520}
521
Herbert Xu74790922015-07-16 12:35:08 +0800522static int chachapoly_init(struct crypto_aead *tfm)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200523{
Herbert Xu74790922015-07-16 12:35:08 +0800524 struct aead_instance *inst = aead_alg_instance(tfm);
525 struct chachapoly_instance_ctx *ictx = aead_instance_ctx(inst);
526 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
Herbert Xu1e1f0062016-07-12 13:17:40 +0800527 struct crypto_skcipher *chacha;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200528 struct crypto_ahash *poly;
529 unsigned long align;
530
531 poly = crypto_spawn_ahash(&ictx->poly);
532 if (IS_ERR(poly))
533 return PTR_ERR(poly);
534
Eric Biggers60425a82016-10-28 09:52:19 -0700535 chacha = crypto_spawn_skcipher(&ictx->chacha);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200536 if (IS_ERR(chacha)) {
537 crypto_free_ahash(poly);
538 return PTR_ERR(chacha);
539 }
540
541 ctx->chacha = chacha;
542 ctx->poly = poly;
543 ctx->saltlen = ictx->saltlen;
544
Herbert Xu74790922015-07-16 12:35:08 +0800545 align = crypto_aead_alignmask(tfm);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200546 align &= ~(crypto_tfm_ctx_alignment() - 1);
Herbert Xu74790922015-07-16 12:35:08 +0800547 crypto_aead_set_reqsize(
548 tfm,
549 align + offsetof(struct chachapoly_req_ctx, u) +
550 max(offsetof(struct chacha_req, req) +
Herbert Xu1e1f0062016-07-12 13:17:40 +0800551 sizeof(struct skcipher_request) +
552 crypto_skcipher_reqsize(chacha),
Herbert Xu74790922015-07-16 12:35:08 +0800553 offsetof(struct poly_req, req) +
554 sizeof(struct ahash_request) +
555 crypto_ahash_reqsize(poly)));
Martin Willi71ebc4d2015-06-01 13:44:00 +0200556
557 return 0;
558}
559
Herbert Xu74790922015-07-16 12:35:08 +0800560static void chachapoly_exit(struct crypto_aead *tfm)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200561{
Herbert Xu74790922015-07-16 12:35:08 +0800562 struct chachapoly_ctx *ctx = crypto_aead_ctx(tfm);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200563
564 crypto_free_ahash(ctx->poly);
Herbert Xu1e1f0062016-07-12 13:17:40 +0800565 crypto_free_skcipher(ctx->chacha);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200566}
567
Herbert Xu74790922015-07-16 12:35:08 +0800568static void chachapoly_free(struct aead_instance *inst)
569{
570 struct chachapoly_instance_ctx *ctx = aead_instance_ctx(inst);
571
572 crypto_drop_skcipher(&ctx->chacha);
573 crypto_drop_ahash(&ctx->poly);
574 kfree(inst);
575}
576
577static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
578 const char *name, unsigned int ivsize)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200579{
580 struct crypto_attr_type *algt;
Herbert Xu74790922015-07-16 12:35:08 +0800581 struct aead_instance *inst;
Herbert Xu1e1f0062016-07-12 13:17:40 +0800582 struct skcipher_alg *chacha;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200583 struct crypto_alg *poly;
Herbert Xu74790922015-07-16 12:35:08 +0800584 struct hash_alg_common *poly_hash;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200585 struct chachapoly_instance_ctx *ctx;
586 const char *chacha_name, *poly_name;
587 int err;
588
589 if (ivsize > CHACHAPOLY_IV_SIZE)
Herbert Xu74790922015-07-16 12:35:08 +0800590 return -EINVAL;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200591
592 algt = crypto_get_attr_type(tb);
593 if (IS_ERR(algt))
Herbert Xu74790922015-07-16 12:35:08 +0800594 return PTR_ERR(algt);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200595
Herbert Xu5e4b8c12015-08-13 17:29:06 +0800596 if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
Herbert Xu74790922015-07-16 12:35:08 +0800597 return -EINVAL;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200598
599 chacha_name = crypto_attr_alg_name(tb[1]);
600 if (IS_ERR(chacha_name))
Herbert Xu74790922015-07-16 12:35:08 +0800601 return PTR_ERR(chacha_name);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200602 poly_name = crypto_attr_alg_name(tb[2]);
603 if (IS_ERR(poly_name))
Herbert Xu74790922015-07-16 12:35:08 +0800604 return PTR_ERR(poly_name);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200605
606 poly = crypto_find_alg(poly_name, &crypto_ahash_type,
607 CRYPTO_ALG_TYPE_HASH,
Herbert Xu1e1f0062016-07-12 13:17:40 +0800608 CRYPTO_ALG_TYPE_AHASH_MASK |
609 crypto_requires_sync(algt->type,
610 algt->mask));
Martin Willi71ebc4d2015-06-01 13:44:00 +0200611 if (IS_ERR(poly))
Herbert Xu74790922015-07-16 12:35:08 +0800612 return PTR_ERR(poly);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200613
614 err = -ENOMEM;
615 inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
616 if (!inst)
617 goto out_put_poly;
618
Herbert Xu74790922015-07-16 12:35:08 +0800619 ctx = aead_instance_ctx(inst);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200620 ctx->saltlen = CHACHAPOLY_IV_SIZE - ivsize;
Herbert Xu74790922015-07-16 12:35:08 +0800621 poly_hash = __crypto_hash_alg_common(poly);
622 err = crypto_init_ahash_spawn(&ctx->poly, poly_hash,
623 aead_crypto_instance(inst));
Martin Willi71ebc4d2015-06-01 13:44:00 +0200624 if (err)
625 goto err_free_inst;
626
Herbert Xu74790922015-07-16 12:35:08 +0800627 crypto_set_skcipher_spawn(&ctx->chacha, aead_crypto_instance(inst));
Eric Biggersa35528e2016-10-28 09:51:13 -0700628 err = crypto_grab_skcipher(&ctx->chacha, chacha_name, 0,
629 crypto_requires_sync(algt->type,
630 algt->mask));
Martin Willi71ebc4d2015-06-01 13:44:00 +0200631 if (err)
632 goto err_drop_poly;
633
Herbert Xu1e1f0062016-07-12 13:17:40 +0800634 chacha = crypto_spawn_skcipher_alg(&ctx->chacha);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200635
636 err = -EINVAL;
637 /* Need 16-byte IV size, including Initial Block Counter value */
Herbert Xu1e1f0062016-07-12 13:17:40 +0800638 if (crypto_skcipher_alg_ivsize(chacha) != CHACHA20_IV_SIZE)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200639 goto out_drop_chacha;
640 /* Not a stream cipher? */
Herbert Xu1e1f0062016-07-12 13:17:40 +0800641 if (chacha->base.cra_blocksize != 1)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200642 goto out_drop_chacha;
643
644 err = -ENAMETOOLONG;
Herbert Xu74790922015-07-16 12:35:08 +0800645 if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
Martin Willi71ebc4d2015-06-01 13:44:00 +0200646 "%s(%s,%s)", name, chacha_name,
647 poly_name) >= CRYPTO_MAX_ALG_NAME)
648 goto out_drop_chacha;
Herbert Xu74790922015-07-16 12:35:08 +0800649 if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
Herbert Xu1e1f0062016-07-12 13:17:40 +0800650 "%s(%s,%s)", name, chacha->base.cra_driver_name,
Martin Willi71ebc4d2015-06-01 13:44:00 +0200651 poly->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
652 goto out_drop_chacha;
653
Herbert Xu1e1f0062016-07-12 13:17:40 +0800654 inst->alg.base.cra_flags = (chacha->base.cra_flags | poly->cra_flags) &
Herbert Xu74790922015-07-16 12:35:08 +0800655 CRYPTO_ALG_ASYNC;
Herbert Xu1e1f0062016-07-12 13:17:40 +0800656 inst->alg.base.cra_priority = (chacha->base.cra_priority +
Herbert Xu74790922015-07-16 12:35:08 +0800657 poly->cra_priority) / 2;
658 inst->alg.base.cra_blocksize = 1;
Herbert Xu1e1f0062016-07-12 13:17:40 +0800659 inst->alg.base.cra_alignmask = chacha->base.cra_alignmask |
Herbert Xu74790922015-07-16 12:35:08 +0800660 poly->cra_alignmask;
661 inst->alg.base.cra_ctxsize = sizeof(struct chachapoly_ctx) +
662 ctx->saltlen;
663 inst->alg.ivsize = ivsize;
Herbert Xu1e1f0062016-07-12 13:17:40 +0800664 inst->alg.chunksize = crypto_skcipher_alg_chunksize(chacha);
Herbert Xu74790922015-07-16 12:35:08 +0800665 inst->alg.maxauthsize = POLY1305_DIGEST_SIZE;
666 inst->alg.init = chachapoly_init;
667 inst->alg.exit = chachapoly_exit;
668 inst->alg.encrypt = chachapoly_encrypt;
669 inst->alg.decrypt = chachapoly_decrypt;
670 inst->alg.setkey = chachapoly_setkey;
671 inst->alg.setauthsize = chachapoly_setauthsize;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200672
Herbert Xu74790922015-07-16 12:35:08 +0800673 inst->free = chachapoly_free;
674
675 err = aead_register_instance(tmpl, inst);
676 if (err)
677 goto out_drop_chacha;
678
679out_put_poly:
Martin Willi71ebc4d2015-06-01 13:44:00 +0200680 crypto_mod_put(poly);
Herbert Xu74790922015-07-16 12:35:08 +0800681 return err;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200682
683out_drop_chacha:
684 crypto_drop_skcipher(&ctx->chacha);
685err_drop_poly:
686 crypto_drop_ahash(&ctx->poly);
687err_free_inst:
688 kfree(inst);
Herbert Xu74790922015-07-16 12:35:08 +0800689 goto out_put_poly;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200690}
691
Herbert Xu74790922015-07-16 12:35:08 +0800692static int rfc7539_create(struct crypto_template *tmpl, struct rtattr **tb)
Martin Willi71ebc4d2015-06-01 13:44:00 +0200693{
Herbert Xu74790922015-07-16 12:35:08 +0800694 return chachapoly_create(tmpl, tb, "rfc7539", 12);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200695}
696
Herbert Xu74790922015-07-16 12:35:08 +0800697static int rfc7539esp_create(struct crypto_template *tmpl, struct rtattr **tb)
Martin Willi4db4ad22015-06-01 13:44:02 +0200698{
Herbert Xu74790922015-07-16 12:35:08 +0800699 return chachapoly_create(tmpl, tb, "rfc7539esp", 8);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200700}
701
702static struct crypto_template rfc7539_tmpl = {
703 .name = "rfc7539",
Herbert Xu74790922015-07-16 12:35:08 +0800704 .create = rfc7539_create,
Martin Willi71ebc4d2015-06-01 13:44:00 +0200705 .module = THIS_MODULE,
706};
707
Martin Willi4db4ad22015-06-01 13:44:02 +0200708static struct crypto_template rfc7539esp_tmpl = {
709 .name = "rfc7539esp",
Herbert Xu74790922015-07-16 12:35:08 +0800710 .create = rfc7539esp_create,
Martin Willi4db4ad22015-06-01 13:44:02 +0200711 .module = THIS_MODULE,
712};
713
Martin Willi71ebc4d2015-06-01 13:44:00 +0200714static int __init chacha20poly1305_module_init(void)
715{
Martin Willi4db4ad22015-06-01 13:44:02 +0200716 int err;
717
718 err = crypto_register_template(&rfc7539_tmpl);
719 if (err)
720 return err;
721
722 err = crypto_register_template(&rfc7539esp_tmpl);
723 if (err)
724 crypto_unregister_template(&rfc7539_tmpl);
725
726 return err;
Martin Willi71ebc4d2015-06-01 13:44:00 +0200727}
728
729static void __exit chacha20poly1305_module_exit(void)
730{
Martin Willi4db4ad22015-06-01 13:44:02 +0200731 crypto_unregister_template(&rfc7539esp_tmpl);
Martin Willi71ebc4d2015-06-01 13:44:00 +0200732 crypto_unregister_template(&rfc7539_tmpl);
733}
734
735module_init(chacha20poly1305_module_init);
736module_exit(chacha20poly1305_module_exit);
737
738MODULE_LICENSE("GPL");
739MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
740MODULE_DESCRIPTION("ChaCha20-Poly1305 AEAD");
Martin Willi71ebc4d2015-06-01 13:44:00 +0200741MODULE_ALIAS_CRYPTO("rfc7539");
Martin Willi4db4ad22015-06-01 13:44:02 +0200742MODULE_ALIAS_CRYPTO("rfc7539esp");