blob: 122c56e3491b9819b20cc34871a8cb4f6d6fdaac [file] [log] [blame]
Herbert Xu0a270322007-11-30 21:38:37 +11001/*
2 * seqiv: Sequence Number IV Generator
3 *
4 * This generator generates an IV based on a sequence number by xoring it
5 * with a salt. This algorithm is mainly useful for CTR and similar modes.
6 *
7 * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 *
14 */
15
Herbert Xu661cfd02015-05-27 14:37:37 +080016#include <crypto/internal/geniv.h>
Herbert Xu0a270322007-11-30 21:38:37 +110017#include <crypto/internal/skcipher.h>
Herbert Xu856e3f402015-05-21 15:11:13 +080018#include <crypto/null.h>
Herbert Xua0f000e2008-08-14 22:21:31 +100019#include <crypto/rng.h>
Herbert Xu856e3f402015-05-21 15:11:13 +080020#include <crypto/scatterwalk.h>
Herbert Xu0a270322007-11-30 21:38:37 +110021#include <linux/err.h>
22#include <linux/init.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
Herbert Xu0a270322007-11-30 21:38:37 +110026#include <linux/spinlock.h>
27#include <linux/string.h>
28
Herbert Xudd044462015-05-23 15:41:56 +080029struct seqniv_request_ctx {
30 struct scatterlist dst[2];
31 struct aead_request subreq;
32};
33
Herbert Xu0a270322007-11-30 21:38:37 +110034struct seqiv_ctx {
35 spinlock_t lock;
36 u8 salt[] __attribute__ ((aligned(__alignof__(u32))));
37};
38
Herbert Xu856e3f402015-05-21 15:11:13 +080039struct seqiv_aead_ctx {
Herbert Xu661cfd02015-05-27 14:37:37 +080040 /* aead_geniv_ctx must be first the element */
41 struct aead_geniv_ctx geniv;
Herbert Xu856e3f402015-05-21 15:11:13 +080042 struct crypto_blkcipher *null;
43 u8 salt[] __attribute__ ((aligned(__alignof__(u32))));
44};
45
Herbert Xu06771572015-05-23 15:41:51 +080046static void seqiv_free(struct crypto_instance *inst);
47
Herbert Xu0a270322007-11-30 21:38:37 +110048static void seqiv_complete2(struct skcipher_givcrypt_request *req, int err)
49{
50 struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req);
51 struct crypto_ablkcipher *geniv;
52
53 if (err == -EINPROGRESS)
54 return;
55
56 if (err)
57 goto out;
58
59 geniv = skcipher_givcrypt_reqtfm(req);
60 memcpy(req->creq.info, subreq->info, crypto_ablkcipher_ivsize(geniv));
61
62out:
63 kfree(subreq->info);
64}
65
66static void seqiv_complete(struct crypto_async_request *base, int err)
67{
68 struct skcipher_givcrypt_request *req = base->data;
69
70 seqiv_complete2(req, err);
71 skcipher_givcrypt_complete(req, err);
72}
73
Herbert Xu14df4d82007-12-12 12:27:26 +080074static void seqiv_aead_complete2(struct aead_givcrypt_request *req, int err)
75{
76 struct aead_request *subreq = aead_givcrypt_reqctx(req);
77 struct crypto_aead *geniv;
78
79 if (err == -EINPROGRESS)
80 return;
81
82 if (err)
83 goto out;
84
85 geniv = aead_givcrypt_reqtfm(req);
86 memcpy(req->areq.iv, subreq->iv, crypto_aead_ivsize(geniv));
87
88out:
89 kfree(subreq->iv);
90}
91
92static void seqiv_aead_complete(struct crypto_async_request *base, int err)
93{
94 struct aead_givcrypt_request *req = base->data;
95
96 seqiv_aead_complete2(req, err);
97 aead_givcrypt_complete(req, err);
98}
99
Herbert Xu856e3f402015-05-21 15:11:13 +0800100static void seqiv_aead_encrypt_complete2(struct aead_request *req, int err)
101{
102 struct aead_request *subreq = aead_request_ctx(req);
103 struct crypto_aead *geniv;
104
105 if (err == -EINPROGRESS)
106 return;
107
108 if (err)
109 goto out;
110
111 geniv = crypto_aead_reqtfm(req);
112 memcpy(req->iv, subreq->iv, crypto_aead_ivsize(geniv));
113
114out:
115 kzfree(subreq->iv);
116}
117
118static void seqiv_aead_encrypt_complete(struct crypto_async_request *base,
119 int err)
120{
121 struct aead_request *req = base->data;
122
123 seqiv_aead_encrypt_complete2(req, err);
124 aead_request_complete(req, err);
125}
126
Herbert Xudd044462015-05-23 15:41:56 +0800127static void seqniv_aead_encrypt_complete2(struct aead_request *req, int err)
128{
129 unsigned int ivsize = 8;
130 u8 data[20];
131
132 if (err == -EINPROGRESS)
133 return;
134
135 /* Swap IV and ESP header back to correct order. */
136 scatterwalk_map_and_copy(data, req->dst, 0, req->assoclen + ivsize, 0);
137 scatterwalk_map_and_copy(data + ivsize, req->dst, 0, req->assoclen, 1);
138 scatterwalk_map_and_copy(data, req->dst, req->assoclen, ivsize, 1);
139}
140
141static void seqniv_aead_encrypt_complete(struct crypto_async_request *base,
142 int err)
143{
144 struct aead_request *req = base->data;
145
146 seqniv_aead_encrypt_complete2(req, err);
147 aead_request_complete(req, err);
148}
149
150static void seqniv_aead_decrypt_complete2(struct aead_request *req, int err)
151{
152 u8 data[4];
153
154 if (err == -EINPROGRESS)
155 return;
156
157 /* Move ESP header back to correct location. */
158 scatterwalk_map_and_copy(data, req->dst, 16, req->assoclen - 8, 0);
159 scatterwalk_map_and_copy(data, req->dst, 8, req->assoclen - 8, 1);
160}
161
162static void seqniv_aead_decrypt_complete(struct crypto_async_request *base,
163 int err)
164{
165 struct aead_request *req = base->data;
166
167 seqniv_aead_decrypt_complete2(req, err);
168 aead_request_complete(req, err);
169}
170
Herbert Xu14df4d82007-12-12 12:27:26 +0800171static void seqiv_geniv(struct seqiv_ctx *ctx, u8 *info, u64 seq,
172 unsigned int ivsize)
173{
174 unsigned int len = ivsize;
175
176 if (ivsize > sizeof(u64)) {
177 memset(info, 0, ivsize - sizeof(u64));
178 len = sizeof(u64);
179 }
180 seq = cpu_to_be64(seq);
181 memcpy(info + ivsize - len, &seq, len);
182 crypto_xor(info, ctx->salt, ivsize);
183}
184
Herbert Xu0a270322007-11-30 21:38:37 +1100185static int seqiv_givencrypt(struct skcipher_givcrypt_request *req)
186{
187 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req);
188 struct seqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv);
189 struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req);
Mark Rustad3e3dc252014-07-25 02:53:38 -0700190 crypto_completion_t compl;
Herbert Xu0a270322007-11-30 21:38:37 +1100191 void *data;
192 u8 *info;
Herbert Xu0a270322007-11-30 21:38:37 +1100193 unsigned int ivsize;
Herbert Xu0a270322007-11-30 21:38:37 +1100194 int err;
195
196 ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv));
197
Mark Rustad3e3dc252014-07-25 02:53:38 -0700198 compl = req->creq.base.complete;
Herbert Xu0a270322007-11-30 21:38:37 +1100199 data = req->creq.base.data;
200 info = req->creq.info;
201
202 ivsize = crypto_ablkcipher_ivsize(geniv);
203
204 if (unlikely(!IS_ALIGNED((unsigned long)info,
205 crypto_ablkcipher_alignmask(geniv) + 1))) {
206 info = kmalloc(ivsize, req->creq.base.flags &
207 CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL:
208 GFP_ATOMIC);
209 if (!info)
210 return -ENOMEM;
211
Mark Rustad3e3dc252014-07-25 02:53:38 -0700212 compl = seqiv_complete;
Herbert Xu0a270322007-11-30 21:38:37 +1100213 data = req;
214 }
215
Mark Rustad3e3dc252014-07-25 02:53:38 -0700216 ablkcipher_request_set_callback(subreq, req->creq.base.flags, compl,
Herbert Xu0a270322007-11-30 21:38:37 +1100217 data);
218 ablkcipher_request_set_crypt(subreq, req->creq.src, req->creq.dst,
219 req->creq.nbytes, info);
220
Herbert Xu14df4d82007-12-12 12:27:26 +0800221 seqiv_geniv(ctx, info, req->seq, ivsize);
Herbert Xu0a270322007-11-30 21:38:37 +1100222 memcpy(req->giv, info, ivsize);
223
224 err = crypto_ablkcipher_encrypt(subreq);
225 if (unlikely(info != req->creq.info))
226 seqiv_complete2(req, err);
227 return err;
228}
229
Herbert Xu14df4d82007-12-12 12:27:26 +0800230static int seqiv_aead_givencrypt(struct aead_givcrypt_request *req)
231{
232 struct crypto_aead *geniv = aead_givcrypt_reqtfm(req);
233 struct seqiv_ctx *ctx = crypto_aead_ctx(geniv);
234 struct aead_request *areq = &req->areq;
235 struct aead_request *subreq = aead_givcrypt_reqctx(req);
Mark Rustad3e3dc252014-07-25 02:53:38 -0700236 crypto_completion_t compl;
Herbert Xu14df4d82007-12-12 12:27:26 +0800237 void *data;
238 u8 *info;
239 unsigned int ivsize;
240 int err;
241
242 aead_request_set_tfm(subreq, aead_geniv_base(geniv));
243
Mark Rustad3e3dc252014-07-25 02:53:38 -0700244 compl = areq->base.complete;
Herbert Xu14df4d82007-12-12 12:27:26 +0800245 data = areq->base.data;
246 info = areq->iv;
247
248 ivsize = crypto_aead_ivsize(geniv);
249
250 if (unlikely(!IS_ALIGNED((unsigned long)info,
251 crypto_aead_alignmask(geniv) + 1))) {
252 info = kmalloc(ivsize, areq->base.flags &
253 CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL:
254 GFP_ATOMIC);
255 if (!info)
256 return -ENOMEM;
257
Mark Rustad3e3dc252014-07-25 02:53:38 -0700258 compl = seqiv_aead_complete;
Herbert Xu14df4d82007-12-12 12:27:26 +0800259 data = req;
260 }
261
Mark Rustad3e3dc252014-07-25 02:53:38 -0700262 aead_request_set_callback(subreq, areq->base.flags, compl, data);
Herbert Xu14df4d82007-12-12 12:27:26 +0800263 aead_request_set_crypt(subreq, areq->src, areq->dst, areq->cryptlen,
264 info);
265 aead_request_set_assoc(subreq, areq->assoc, areq->assoclen);
266
267 seqiv_geniv(ctx, info, req->seq, ivsize);
268 memcpy(req->giv, info, ivsize);
269
270 err = crypto_aead_encrypt(subreq);
271 if (unlikely(info != areq->iv))
272 seqiv_aead_complete2(req, err);
273 return err;
274}
275
Herbert Xu661cfd02015-05-27 14:37:37 +0800276static int seqniv_aead_encrypt(struct aead_request *req)
Herbert Xu856e3f402015-05-21 15:11:13 +0800277{
278 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
279 struct seqiv_aead_ctx *ctx = crypto_aead_ctx(geniv);
Herbert Xudd044462015-05-23 15:41:56 +0800280 struct seqniv_request_ctx *rctx = aead_request_ctx(req);
281 struct aead_request *subreq = &rctx->subreq;
282 struct scatterlist *dst;
Herbert Xu856e3f402015-05-21 15:11:13 +0800283 crypto_completion_t compl;
284 void *data;
Herbert Xudd044462015-05-23 15:41:56 +0800285 unsigned int ivsize = 8;
286 u8 buf[20] __attribute__ ((aligned(__alignof__(u32))));
Herbert Xu856e3f402015-05-21 15:11:13 +0800287 int err;
288
Herbert Xudd044462015-05-23 15:41:56 +0800289 if (req->cryptlen < ivsize)
290 return -EINVAL;
291
292 /* ESP AD is at most 12 bytes (ESN). */
293 if (req->assoclen > 12)
294 return -EINVAL;
295
Herbert Xu661cfd02015-05-27 14:37:37 +0800296 aead_request_set_tfm(subreq, ctx->geniv.child);
Herbert Xu856e3f402015-05-21 15:11:13 +0800297
Herbert Xudd044462015-05-23 15:41:56 +0800298 compl = seqniv_aead_encrypt_complete;
299 data = req;
Herbert Xu856e3f402015-05-21 15:11:13 +0800300
Herbert Xudd044462015-05-23 15:41:56 +0800301 if (req->src != req->dst) {
Herbert Xudd044462015-05-23 15:41:56 +0800302 struct blkcipher_desc desc = {
303 .tfm = ctx->null,
304 };
Herbert Xu856e3f402015-05-21 15:11:13 +0800305
Herbert Xud0ad1b22015-05-27 14:37:36 +0800306 err = crypto_blkcipher_encrypt(&desc, req->dst, req->src,
307 req->assoclen + req->cryptlen);
Herbert Xudd044462015-05-23 15:41:56 +0800308 if (err)
309 return err;
Herbert Xu856e3f402015-05-21 15:11:13 +0800310 }
311
Herbert Xudd044462015-05-23 15:41:56 +0800312 dst = scatterwalk_ffwd(rctx->dst, req->dst, ivsize);
Herbert Xu856e3f402015-05-21 15:11:13 +0800313
Herbert Xudd044462015-05-23 15:41:56 +0800314 aead_request_set_callback(subreq, req->base.flags, compl, data);
315 aead_request_set_crypt(subreq, dst, dst,
316 req->cryptlen - ivsize, req->iv);
Herbert Xu374d4ad2015-05-23 15:41:57 +0800317 aead_request_set_ad(subreq, req->assoclen);
Herbert Xudd044462015-05-23 15:41:56 +0800318
319 memcpy(buf, req->iv, ivsize);
320 crypto_xor(buf, ctx->salt, ivsize);
321 memcpy(req->iv, buf, ivsize);
322
323 /* Swap order of IV and ESP AD for ICV generation. */
324 scatterwalk_map_and_copy(buf + ivsize, req->dst, 0, req->assoclen, 0);
325 scatterwalk_map_and_copy(buf, req->dst, 0, req->assoclen + ivsize, 1);
Herbert Xu856e3f402015-05-21 15:11:13 +0800326
327 err = crypto_aead_encrypt(subreq);
Herbert Xudd044462015-05-23 15:41:56 +0800328 seqniv_aead_encrypt_complete2(req, err);
Herbert Xu856e3f402015-05-21 15:11:13 +0800329 return err;
330}
331
332static int seqiv_aead_encrypt(struct aead_request *req)
333{
334 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
335 struct seqiv_aead_ctx *ctx = crypto_aead_ctx(geniv);
336 struct aead_request *subreq = aead_request_ctx(req);
337 crypto_completion_t compl;
338 void *data;
339 u8 *info;
Herbert Xudd044462015-05-23 15:41:56 +0800340 unsigned int ivsize = 8;
Herbert Xu856e3f402015-05-21 15:11:13 +0800341 int err;
342
Herbert Xudd044462015-05-23 15:41:56 +0800343 if (req->cryptlen < ivsize)
344 return -EINVAL;
345
Herbert Xu661cfd02015-05-27 14:37:37 +0800346 aead_request_set_tfm(subreq, ctx->geniv.child);
Herbert Xu856e3f402015-05-21 15:11:13 +0800347
348 compl = req->base.complete;
349 data = req->base.data;
350 info = req->iv;
351
Herbert Xu856e3f402015-05-21 15:11:13 +0800352 if (req->src != req->dst) {
Herbert Xu856e3f402015-05-21 15:11:13 +0800353 struct blkcipher_desc desc = {
354 .tfm = ctx->null,
355 };
356
Herbert Xud0ad1b22015-05-27 14:37:36 +0800357 err = crypto_blkcipher_encrypt(&desc, req->dst, req->src,
358 req->assoclen + req->cryptlen);
Herbert Xu856e3f402015-05-21 15:11:13 +0800359 if (err)
360 return err;
361 }
362
363 if (unlikely(!IS_ALIGNED((unsigned long)info,
364 crypto_aead_alignmask(geniv) + 1))) {
365 info = kmalloc(ivsize, req->base.flags &
366 CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL:
367 GFP_ATOMIC);
368 if (!info)
369 return -ENOMEM;
370
371 memcpy(info, req->iv, ivsize);
372 compl = seqiv_aead_encrypt_complete;
373 data = req;
374 }
375
376 aead_request_set_callback(subreq, req->base.flags, compl, data);
377 aead_request_set_crypt(subreq, req->dst, req->dst,
378 req->cryptlen - ivsize, info);
Herbert Xu374d4ad2015-05-23 15:41:57 +0800379 aead_request_set_ad(subreq, req->assoclen + ivsize);
Herbert Xu856e3f402015-05-21 15:11:13 +0800380
381 crypto_xor(info, ctx->salt, ivsize);
382 scatterwalk_map_and_copy(info, req->dst, req->assoclen, ivsize, 1);
383
384 err = crypto_aead_encrypt(subreq);
385 if (unlikely(info != req->iv))
386 seqiv_aead_encrypt_complete2(req, err);
387 return err;
388}
389
Herbert Xu661cfd02015-05-27 14:37:37 +0800390static int seqniv_aead_decrypt(struct aead_request *req)
Herbert Xu856e3f402015-05-21 15:11:13 +0800391{
392 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
393 struct seqiv_aead_ctx *ctx = crypto_aead_ctx(geniv);
Herbert Xudd044462015-05-23 15:41:56 +0800394 struct seqniv_request_ctx *rctx = aead_request_ctx(req);
395 struct aead_request *subreq = &rctx->subreq;
396 struct scatterlist *dst;
Herbert Xu856e3f402015-05-21 15:11:13 +0800397 crypto_completion_t compl;
398 void *data;
Herbert Xudd044462015-05-23 15:41:56 +0800399 unsigned int ivsize = 8;
400 u8 buf[20];
401 int err;
402
403 if (req->cryptlen < ivsize + crypto_aead_authsize(geniv))
404 return -EINVAL;
Herbert Xu856e3f402015-05-21 15:11:13 +0800405
Herbert Xu661cfd02015-05-27 14:37:37 +0800406 aead_request_set_tfm(subreq, ctx->geniv.child);
Herbert Xu856e3f402015-05-21 15:11:13 +0800407
408 compl = req->base.complete;
409 data = req->base.data;
410
Herbert Xudd044462015-05-23 15:41:56 +0800411 if (req->assoclen > 12)
412 return -EINVAL;
413 else if (req->assoclen > 8) {
414 compl = seqniv_aead_decrypt_complete;
415 data = req;
416 }
417
418 if (req->src != req->dst) {
Herbert Xudd044462015-05-23 15:41:56 +0800419 struct blkcipher_desc desc = {
420 .tfm = ctx->null,
421 };
422
Herbert Xud0ad1b22015-05-27 14:37:36 +0800423 err = crypto_blkcipher_encrypt(&desc, req->dst, req->src,
424 req->assoclen + req->cryptlen);
Herbert Xudd044462015-05-23 15:41:56 +0800425 if (err)
426 return err;
427 }
428
429 /* Move ESP AD forward for ICV generation. */
430 scatterwalk_map_and_copy(buf, req->dst, 0, req->assoclen + ivsize, 0);
431 memcpy(req->iv, buf + req->assoclen, ivsize);
432 scatterwalk_map_and_copy(buf, req->dst, ivsize, req->assoclen, 1);
433
434 dst = scatterwalk_ffwd(rctx->dst, req->dst, ivsize);
Herbert Xu856e3f402015-05-21 15:11:13 +0800435
436 aead_request_set_callback(subreq, req->base.flags, compl, data);
Herbert Xudd044462015-05-23 15:41:56 +0800437 aead_request_set_crypt(subreq, dst, dst,
Herbert Xu856e3f402015-05-21 15:11:13 +0800438 req->cryptlen - ivsize, req->iv);
Herbert Xu374d4ad2015-05-23 15:41:57 +0800439 aead_request_set_ad(subreq, req->assoclen);
Herbert Xu856e3f402015-05-21 15:11:13 +0800440
Herbert Xudd044462015-05-23 15:41:56 +0800441 err = crypto_aead_decrypt(subreq);
442 if (req->assoclen > 8)
443 seqniv_aead_decrypt_complete2(req, err);
444 return err;
Herbert Xu856e3f402015-05-21 15:11:13 +0800445}
446
447static int seqiv_aead_decrypt(struct aead_request *req)
448{
449 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
450 struct seqiv_aead_ctx *ctx = crypto_aead_ctx(geniv);
451 struct aead_request *subreq = aead_request_ctx(req);
452 crypto_completion_t compl;
453 void *data;
Herbert Xudd044462015-05-23 15:41:56 +0800454 unsigned int ivsize = 8;
455
456 if (req->cryptlen < ivsize + crypto_aead_authsize(geniv))
457 return -EINVAL;
Herbert Xu856e3f402015-05-21 15:11:13 +0800458
Herbert Xu661cfd02015-05-27 14:37:37 +0800459 aead_request_set_tfm(subreq, ctx->geniv.child);
Herbert Xu856e3f402015-05-21 15:11:13 +0800460
461 compl = req->base.complete;
462 data = req->base.data;
463
Herbert Xu856e3f402015-05-21 15:11:13 +0800464 aead_request_set_callback(subreq, req->base.flags, compl, data);
465 aead_request_set_crypt(subreq, req->src, req->dst,
466 req->cryptlen - ivsize, req->iv);
Herbert Xu374d4ad2015-05-23 15:41:57 +0800467 aead_request_set_ad(subreq, req->assoclen + ivsize);
Herbert Xu856e3f402015-05-21 15:11:13 +0800468
469 scatterwalk_map_and_copy(req->iv, req->src, req->assoclen, ivsize, 0);
470 if (req->src != req->dst)
471 scatterwalk_map_and_copy(req->iv, req->dst,
472 req->assoclen, ivsize, 1);
473
474 return crypto_aead_decrypt(subreq);
475}
476
Herbert Xu0a270322007-11-30 21:38:37 +1100477static int seqiv_init(struct crypto_tfm *tfm)
478{
479 struct crypto_ablkcipher *geniv = __crypto_ablkcipher_cast(tfm);
480 struct seqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv);
Herbert Xueeee12a2015-06-21 19:11:49 +0800481 int err;
Herbert Xu0a270322007-11-30 21:38:37 +1100482
483 spin_lock_init(&ctx->lock);
484
485 tfm->crt_ablkcipher.reqsize = sizeof(struct ablkcipher_request);
486
Herbert Xueeee12a2015-06-21 19:11:49 +0800487 err = 0;
488 if (!crypto_get_default_rng()) {
489 crypto_ablkcipher_crt(geniv)->givencrypt = seqiv_givencrypt;
490 err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,
491 crypto_ablkcipher_ivsize(geniv));
492 crypto_put_default_rng();
493 }
494
495 return err ?: skcipher_geniv_init(tfm);
Herbert Xu0a270322007-11-30 21:38:37 +1100496}
497
Herbert Xu856e3f402015-05-21 15:11:13 +0800498static int seqiv_old_aead_init(struct crypto_tfm *tfm)
Herbert Xu14df4d82007-12-12 12:27:26 +0800499{
500 struct crypto_aead *geniv = __crypto_aead_cast(tfm);
501 struct seqiv_ctx *ctx = crypto_aead_ctx(geniv);
Herbert Xueeee12a2015-06-21 19:11:49 +0800502 int err;
Herbert Xu14df4d82007-12-12 12:27:26 +0800503
504 spin_lock_init(&ctx->lock);
505
Herbert Xuba6d8e32015-05-11 17:48:03 +0800506 crypto_aead_set_reqsize(__crypto_aead_cast(tfm),
507 sizeof(struct aead_request));
Herbert Xueeee12a2015-06-21 19:11:49 +0800508 err = 0;
509 if (!crypto_get_default_rng()) {
510 geniv->givencrypt = seqiv_aead_givencrypt;
511 err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,
512 crypto_aead_ivsize(geniv));
513 crypto_put_default_rng();
514 }
Herbert Xu14df4d82007-12-12 12:27:26 +0800515
Herbert Xueeee12a2015-06-21 19:11:49 +0800516 return err ?: aead_geniv_init(tfm);
Herbert Xu14df4d82007-12-12 12:27:26 +0800517}
518
Herbert Xudd044462015-05-23 15:41:56 +0800519static int seqiv_aead_init_common(struct crypto_tfm *tfm, unsigned int reqsize)
Herbert Xu856e3f402015-05-21 15:11:13 +0800520{
521 struct crypto_aead *geniv = __crypto_aead_cast(tfm);
522 struct seqiv_aead_ctx *ctx = crypto_aead_ctx(geniv);
523 int err;
524
Herbert Xu661cfd02015-05-27 14:37:37 +0800525 spin_lock_init(&ctx->geniv.lock);
Herbert Xu856e3f402015-05-21 15:11:13 +0800526
527 crypto_aead_set_reqsize(geniv, sizeof(struct aead_request));
528
Herbert Xueeee12a2015-06-21 19:11:49 +0800529 err = crypto_get_default_rng();
530 if (err)
531 goto out;
532
Herbert Xub7dcfab2015-06-03 14:49:27 +0800533 err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,
534 crypto_aead_ivsize(geniv));
Herbert Xueeee12a2015-06-21 19:11:49 +0800535 crypto_put_default_rng();
Herbert Xub7dcfab2015-06-03 14:49:27 +0800536 if (err)
537 goto out;
538
Herbert Xu856e3f402015-05-21 15:11:13 +0800539 ctx->null = crypto_get_default_null_skcipher();
540 err = PTR_ERR(ctx->null);
541 if (IS_ERR(ctx->null))
542 goto out;
543
544 err = aead_geniv_init(tfm);
545 if (err)
546 goto drop_null;
547
Herbert Xu661cfd02015-05-27 14:37:37 +0800548 ctx->geniv.child = geniv->child;
Herbert Xu856e3f402015-05-21 15:11:13 +0800549 geniv->child = geniv;
550
551out:
552 return err;
553
554drop_null:
555 crypto_put_default_null_skcipher();
556 goto out;
557}
558
Herbert Xudd044462015-05-23 15:41:56 +0800559static int seqiv_aead_init(struct crypto_tfm *tfm)
Herbert Xu856e3f402015-05-21 15:11:13 +0800560{
Herbert Xudd044462015-05-23 15:41:56 +0800561 return seqiv_aead_init_common(tfm, sizeof(struct aead_request));
562}
Herbert Xu856e3f402015-05-21 15:11:13 +0800563
Herbert Xudd044462015-05-23 15:41:56 +0800564static int seqniv_aead_init(struct crypto_tfm *tfm)
565{
566 return seqiv_aead_init_common(tfm, sizeof(struct seqniv_request_ctx));
Herbert Xu856e3f402015-05-21 15:11:13 +0800567}
568
569static void seqiv_aead_exit(struct crypto_tfm *tfm)
570{
571 struct seqiv_aead_ctx *ctx = crypto_tfm_ctx(tfm);
572
Herbert Xu661cfd02015-05-27 14:37:37 +0800573 crypto_free_aead(ctx->geniv.child);
Herbert Xu856e3f402015-05-21 15:11:13 +0800574 crypto_put_default_null_skcipher();
575}
576
Herbert Xu06771572015-05-23 15:41:51 +0800577static int seqiv_ablkcipher_create(struct crypto_template *tmpl,
578 struct rtattr **tb)
Herbert Xu0a270322007-11-30 21:38:37 +1100579{
580 struct crypto_instance *inst;
Herbert Xu06771572015-05-23 15:41:51 +0800581 int err;
Herbert Xu0a270322007-11-30 21:38:37 +1100582
Herbert Xu06771572015-05-23 15:41:51 +0800583 inst = skcipher_geniv_alloc(tmpl, tb, 0, 0);
Herbert Xu14df4d82007-12-12 12:27:26 +0800584
Herbert Xu0a270322007-11-30 21:38:37 +1100585 if (IS_ERR(inst))
Herbert Xu06771572015-05-23 15:41:51 +0800586 return PTR_ERR(inst);
Herbert Xu0a270322007-11-30 21:38:37 +1100587
Herbert Xu06771572015-05-23 15:41:51 +0800588 err = -EINVAL;
589 if (inst->alg.cra_ablkcipher.ivsize < sizeof(u64))
590 goto free_inst;
Herbert Xuc0ecf892015-01-16 19:51:20 +1100591
Herbert Xu0a270322007-11-30 21:38:37 +1100592 inst->alg.cra_init = seqiv_init;
593 inst->alg.cra_exit = skcipher_geniv_exit;
594
Herbert Xu0a270322007-11-30 21:38:37 +1100595 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize;
Herbert Xu856e3f402015-05-21 15:11:13 +0800596 inst->alg.cra_ctxsize += sizeof(struct seqiv_ctx);
Herbert Xu0a270322007-11-30 21:38:37 +1100597
Herbert Xu06771572015-05-23 15:41:51 +0800598 inst->alg.cra_alignmask |= __alignof__(u32) - 1;
599
600 err = crypto_register_instance(tmpl, inst);
601 if (err)
602 goto free_inst;
603
Herbert Xu0a270322007-11-30 21:38:37 +1100604out:
Herbert Xu06771572015-05-23 15:41:51 +0800605 return err;
606
607free_inst:
608 skcipher_geniv_free(inst);
609 goto out;
Herbert Xu0a270322007-11-30 21:38:37 +1100610}
611
Herbert Xu06771572015-05-23 15:41:51 +0800612static int seqiv_old_aead_create(struct crypto_template *tmpl,
613 struct aead_instance *aead)
Herbert Xu856e3f402015-05-21 15:11:13 +0800614{
615 struct crypto_instance *inst = aead_crypto_instance(aead);
Herbert Xu06771572015-05-23 15:41:51 +0800616 int err = -EINVAL;
Herbert Xu856e3f402015-05-21 15:11:13 +0800617
Herbert Xu06771572015-05-23 15:41:51 +0800618 if (inst->alg.cra_aead.ivsize < sizeof(u64))
619 goto free_inst;
Herbert Xu856e3f402015-05-21 15:11:13 +0800620
Herbert Xu856e3f402015-05-21 15:11:13 +0800621 inst->alg.cra_init = seqiv_old_aead_init;
622 inst->alg.cra_exit = aead_geniv_exit;
623
624 inst->alg.cra_ctxsize = inst->alg.cra_aead.ivsize;
625 inst->alg.cra_ctxsize += sizeof(struct seqiv_ctx);
626
Herbert Xu06771572015-05-23 15:41:51 +0800627 err = crypto_register_instance(tmpl, inst);
628 if (err)
629 goto free_inst;
630
631out:
632 return err;
633
634free_inst:
635 aead_geniv_free(aead);
636 goto out;
Herbert Xu856e3f402015-05-21 15:11:13 +0800637}
638
Herbert Xu06771572015-05-23 15:41:51 +0800639static int seqiv_aead_create(struct crypto_template *tmpl, struct rtattr **tb)
Herbert Xu14df4d82007-12-12 12:27:26 +0800640{
Herbert Xu856e3f402015-05-21 15:11:13 +0800641 struct aead_instance *inst;
642 struct crypto_aead_spawn *spawn;
643 struct aead_alg *alg;
Herbert Xu06771572015-05-23 15:41:51 +0800644 int err;
Herbert Xu14df4d82007-12-12 12:27:26 +0800645
Herbert Xu06771572015-05-23 15:41:51 +0800646 inst = aead_geniv_alloc(tmpl, tb, 0, 0);
Herbert Xu14df4d82007-12-12 12:27:26 +0800647
648 if (IS_ERR(inst))
Herbert Xu06771572015-05-23 15:41:51 +0800649 return PTR_ERR(inst);
650
651 inst->alg.base.cra_alignmask |= __alignof__(u32) - 1;
Herbert Xu14df4d82007-12-12 12:27:26 +0800652
Herbert Xu856e3f402015-05-21 15:11:13 +0800653 if (inst->alg.base.cra_aead.encrypt)
Herbert Xu06771572015-05-23 15:41:51 +0800654 return seqiv_old_aead_create(tmpl, inst);
Herbert Xu856e3f402015-05-21 15:11:13 +0800655
Herbert Xu661cfd02015-05-27 14:37:37 +0800656 spawn = aead_instance_ctx(inst);
657 alg = crypto_spawn_aead_alg(spawn);
658
659 if (alg->base.cra_aead.encrypt)
660 goto done;
661
Herbert Xu06771572015-05-23 15:41:51 +0800662 err = -EINVAL;
Herbert Xudd044462015-05-23 15:41:56 +0800663 if (inst->alg.ivsize != sizeof(u64))
Herbert Xu06771572015-05-23 15:41:51 +0800664 goto free_inst;
Herbert Xuc0ecf892015-01-16 19:51:20 +1100665
Herbert Xub7dcfab2015-06-03 14:49:27 +0800666 inst->alg.encrypt = seqiv_aead_encrypt;
Herbert Xu856e3f402015-05-21 15:11:13 +0800667 inst->alg.decrypt = seqiv_aead_decrypt;
Herbert Xu14df4d82007-12-12 12:27:26 +0800668
Herbert Xu856e3f402015-05-21 15:11:13 +0800669 inst->alg.base.cra_init = seqiv_aead_init;
670 inst->alg.base.cra_exit = seqiv_aead_exit;
671
672 inst->alg.base.cra_ctxsize = sizeof(struct seqiv_aead_ctx);
673 inst->alg.base.cra_ctxsize += inst->alg.base.cra_aead.ivsize;
674
Herbert Xu661cfd02015-05-27 14:37:37 +0800675done:
Herbert Xu06771572015-05-23 15:41:51 +0800676 err = aead_register_instance(tmpl, inst);
677 if (err)
678 goto free_inst;
679
Herbert Xu14df4d82007-12-12 12:27:26 +0800680out:
Herbert Xu06771572015-05-23 15:41:51 +0800681 return err;
682
683free_inst:
684 aead_geniv_free(inst);
685 goto out;
Herbert Xu14df4d82007-12-12 12:27:26 +0800686}
687
Herbert Xu06771572015-05-23 15:41:51 +0800688static int seqiv_create(struct crypto_template *tmpl, struct rtattr **tb)
Herbert Xu14df4d82007-12-12 12:27:26 +0800689{
690 struct crypto_attr_type *algt;
Herbert Xu14df4d82007-12-12 12:27:26 +0800691 int err;
692
693 algt = crypto_get_attr_type(tb);
Herbert Xu14df4d82007-12-12 12:27:26 +0800694 if (IS_ERR(algt))
Herbert Xu06771572015-05-23 15:41:51 +0800695 return PTR_ERR(algt);
Herbert Xu14df4d82007-12-12 12:27:26 +0800696
697 if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK)
Herbert Xu06771572015-05-23 15:41:51 +0800698 err = seqiv_ablkcipher_create(tmpl, tb);
Herbert Xu14df4d82007-12-12 12:27:26 +0800699 else
Herbert Xu06771572015-05-23 15:41:51 +0800700 err = seqiv_aead_create(tmpl, tb);
Herbert Xu14df4d82007-12-12 12:27:26 +0800701
Herbert Xu06771572015-05-23 15:41:51 +0800702 return err;
Herbert Xu14df4d82007-12-12 12:27:26 +0800703}
704
Herbert Xu06771572015-05-23 15:41:51 +0800705static int seqniv_create(struct crypto_template *tmpl, struct rtattr **tb)
Herbert Xu3c08fee2015-05-21 15:11:14 +0800706{
707 struct aead_instance *inst;
708 struct crypto_aead_spawn *spawn;
709 struct aead_alg *alg;
710 int err;
711
Herbert Xu06771572015-05-23 15:41:51 +0800712 inst = aead_geniv_alloc(tmpl, tb, 0, 0);
713 err = PTR_ERR(inst);
Herbert Xu3c08fee2015-05-21 15:11:14 +0800714 if (IS_ERR(inst))
Herbert Xueeee12a2015-06-21 19:11:49 +0800715 goto out;
Herbert Xu3c08fee2015-05-21 15:11:14 +0800716
Herbert Xu661cfd02015-05-27 14:37:37 +0800717 spawn = aead_instance_ctx(inst);
718 alg = crypto_spawn_aead_alg(spawn);
719
720 if (alg->base.cra_aead.encrypt)
721 goto done;
722
Herbert Xu06771572015-05-23 15:41:51 +0800723 err = -EINVAL;
Herbert Xudd044462015-05-23 15:41:56 +0800724 if (inst->alg.ivsize != sizeof(u64))
Herbert Xu06771572015-05-23 15:41:51 +0800725 goto free_inst;
Herbert Xu3c08fee2015-05-21 15:11:14 +0800726
Herbert Xub7dcfab2015-06-03 14:49:27 +0800727 inst->alg.encrypt = seqniv_aead_encrypt;
Herbert Xu661cfd02015-05-27 14:37:37 +0800728 inst->alg.decrypt = seqniv_aead_decrypt;
Herbert Xu3c08fee2015-05-21 15:11:14 +0800729
Herbert Xudd044462015-05-23 15:41:56 +0800730 inst->alg.base.cra_init = seqniv_aead_init;
731 inst->alg.base.cra_exit = seqiv_aead_exit;
Herbert Xu3c08fee2015-05-21 15:11:14 +0800732
733 inst->alg.base.cra_alignmask |= __alignof__(u32) - 1;
734 inst->alg.base.cra_ctxsize = sizeof(struct seqiv_aead_ctx);
Herbert Xuccdb8a02015-05-27 14:37:39 +0800735 inst->alg.base.cra_ctxsize += inst->alg.ivsize;
Herbert Xu3c08fee2015-05-21 15:11:14 +0800736
Herbert Xu661cfd02015-05-27 14:37:37 +0800737done:
Herbert Xu06771572015-05-23 15:41:51 +0800738 err = aead_register_instance(tmpl, inst);
739 if (err)
740 goto free_inst;
Herbert Xu3c08fee2015-05-21 15:11:14 +0800741
Herbert Xu06771572015-05-23 15:41:51 +0800742out:
743 return err;
744
745free_inst:
746 aead_geniv_free(inst);
Herbert Xu3c08fee2015-05-21 15:11:14 +0800747 goto out;
748}
749
Herbert Xu14df4d82007-12-12 12:27:26 +0800750static void seqiv_free(struct crypto_instance *inst)
751{
752 if ((inst->alg.cra_flags ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK)
753 skcipher_geniv_free(inst);
754 else
Herbert Xu856e3f402015-05-21 15:11:13 +0800755 aead_geniv_free(aead_instance(inst));
Herbert Xu14df4d82007-12-12 12:27:26 +0800756}
757
Herbert Xu0a270322007-11-30 21:38:37 +1100758static struct crypto_template seqiv_tmpl = {
759 .name = "seqiv",
Herbert Xu06771572015-05-23 15:41:51 +0800760 .create = seqiv_create,
Herbert Xu14df4d82007-12-12 12:27:26 +0800761 .free = seqiv_free,
Herbert Xu0a270322007-11-30 21:38:37 +1100762 .module = THIS_MODULE,
763};
764
Herbert Xu3c08fee2015-05-21 15:11:14 +0800765static struct crypto_template seqniv_tmpl = {
766 .name = "seqniv",
Herbert Xu06771572015-05-23 15:41:51 +0800767 .create = seqniv_create,
Herbert Xu3c08fee2015-05-21 15:11:14 +0800768 .free = seqiv_free,
769 .module = THIS_MODULE,
770};
771
Herbert Xu0a270322007-11-30 21:38:37 +1100772static int __init seqiv_module_init(void)
773{
Herbert Xu3c08fee2015-05-21 15:11:14 +0800774 int err;
775
776 err = crypto_register_template(&seqiv_tmpl);
777 if (err)
778 goto out;
779
780 err = crypto_register_template(&seqniv_tmpl);
781 if (err)
782 goto out_undo_niv;
783
784out:
785 return err;
786
787out_undo_niv:
788 crypto_unregister_template(&seqiv_tmpl);
789 goto out;
Herbert Xu0a270322007-11-30 21:38:37 +1100790}
791
792static void __exit seqiv_module_exit(void)
793{
Herbert Xu056c04b2015-05-27 14:37:40 +0800794 crypto_unregister_template(&seqniv_tmpl);
Herbert Xu0a270322007-11-30 21:38:37 +1100795 crypto_unregister_template(&seqiv_tmpl);
796}
797
798module_init(seqiv_module_init);
799module_exit(seqiv_module_exit);
800
801MODULE_LICENSE("GPL");
802MODULE_DESCRIPTION("Sequence Number IV Generator");
Kees Cook4943ba12014-11-24 16:32:38 -0800803MODULE_ALIAS_CRYPTO("seqiv");
Herbert Xu3c08fee2015-05-21 15:11:14 +0800804MODULE_ALIAS_CRYPTO("seqniv");