2 * seqiv: Sequence Number IV Generator
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.
7 * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
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)
16 #include <crypto/internal/aead.h>
17 #include <crypto/internal/skcipher.h>
18 #include <crypto/null.h>
19 #include <crypto/rng.h>
20 #include <crypto/scatterwalk.h>
21 #include <linux/err.h>
22 #include <linux/init.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/spinlock.h>
27 #include <linux/string.h>
29 struct seqniv_request_ctx
{
30 struct scatterlist dst
[2];
31 struct aead_request subreq
;
36 u8 salt
[] __attribute__ ((aligned(__alignof__(u32
))));
39 struct seqiv_aead_ctx
{
40 struct crypto_aead
*child
;
42 struct crypto_blkcipher
*null
;
43 u8 salt
[] __attribute__ ((aligned(__alignof__(u32
))));
46 static void seqiv_free(struct crypto_instance
*inst
);
48 static int seqiv_aead_setkey(struct crypto_aead
*tfm
,
49 const u8
*key
, unsigned int keylen
)
51 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(tfm
);
53 return crypto_aead_setkey(ctx
->child
, key
, keylen
);
56 static int seqiv_aead_setauthsize(struct crypto_aead
*tfm
,
57 unsigned int authsize
)
59 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(tfm
);
61 return crypto_aead_setauthsize(ctx
->child
, authsize
);
64 static void seqiv_complete2(struct skcipher_givcrypt_request
*req
, int err
)
66 struct ablkcipher_request
*subreq
= skcipher_givcrypt_reqctx(req
);
67 struct crypto_ablkcipher
*geniv
;
69 if (err
== -EINPROGRESS
)
75 geniv
= skcipher_givcrypt_reqtfm(req
);
76 memcpy(req
->creq
.info
, subreq
->info
, crypto_ablkcipher_ivsize(geniv
));
82 static void seqiv_complete(struct crypto_async_request
*base
, int err
)
84 struct skcipher_givcrypt_request
*req
= base
->data
;
86 seqiv_complete2(req
, err
);
87 skcipher_givcrypt_complete(req
, err
);
90 static void seqiv_aead_complete2(struct aead_givcrypt_request
*req
, int err
)
92 struct aead_request
*subreq
= aead_givcrypt_reqctx(req
);
93 struct crypto_aead
*geniv
;
95 if (err
== -EINPROGRESS
)
101 geniv
= aead_givcrypt_reqtfm(req
);
102 memcpy(req
->areq
.iv
, subreq
->iv
, crypto_aead_ivsize(geniv
));
108 static void seqiv_aead_complete(struct crypto_async_request
*base
, int err
)
110 struct aead_givcrypt_request
*req
= base
->data
;
112 seqiv_aead_complete2(req
, err
);
113 aead_givcrypt_complete(req
, err
);
116 static void seqiv_aead_encrypt_complete2(struct aead_request
*req
, int err
)
118 struct aead_request
*subreq
= aead_request_ctx(req
);
119 struct crypto_aead
*geniv
;
121 if (err
== -EINPROGRESS
)
127 geniv
= crypto_aead_reqtfm(req
);
128 memcpy(req
->iv
, subreq
->iv
, crypto_aead_ivsize(geniv
));
134 static void seqiv_aead_encrypt_complete(struct crypto_async_request
*base
,
137 struct aead_request
*req
= base
->data
;
139 seqiv_aead_encrypt_complete2(req
, err
);
140 aead_request_complete(req
, err
);
143 static void seqniv_aead_encrypt_complete2(struct aead_request
*req
, int err
)
145 unsigned int ivsize
= 8;
148 if (err
== -EINPROGRESS
)
151 /* Swap IV and ESP header back to correct order. */
152 scatterwalk_map_and_copy(data
, req
->dst
, 0, req
->assoclen
+ ivsize
, 0);
153 scatterwalk_map_and_copy(data
+ ivsize
, req
->dst
, 0, req
->assoclen
, 1);
154 scatterwalk_map_and_copy(data
, req
->dst
, req
->assoclen
, ivsize
, 1);
157 static void seqniv_aead_encrypt_complete(struct crypto_async_request
*base
,
160 struct aead_request
*req
= base
->data
;
162 seqniv_aead_encrypt_complete2(req
, err
);
163 aead_request_complete(req
, err
);
166 static void seqniv_aead_decrypt_complete2(struct aead_request
*req
, int err
)
170 if (err
== -EINPROGRESS
)
173 /* Move ESP header back to correct location. */
174 scatterwalk_map_and_copy(data
, req
->dst
, 16, req
->assoclen
- 8, 0);
175 scatterwalk_map_and_copy(data
, req
->dst
, 8, req
->assoclen
- 8, 1);
178 static void seqniv_aead_decrypt_complete(struct crypto_async_request
*base
,
181 struct aead_request
*req
= base
->data
;
183 seqniv_aead_decrypt_complete2(req
, err
);
184 aead_request_complete(req
, err
);
187 static void seqiv_geniv(struct seqiv_ctx
*ctx
, u8
*info
, u64 seq
,
190 unsigned int len
= ivsize
;
192 if (ivsize
> sizeof(u64
)) {
193 memset(info
, 0, ivsize
- sizeof(u64
));
196 seq
= cpu_to_be64(seq
);
197 memcpy(info
+ ivsize
- len
, &seq
, len
);
198 crypto_xor(info
, ctx
->salt
, ivsize
);
201 static int seqiv_givencrypt(struct skcipher_givcrypt_request
*req
)
203 struct crypto_ablkcipher
*geniv
= skcipher_givcrypt_reqtfm(req
);
204 struct seqiv_ctx
*ctx
= crypto_ablkcipher_ctx(geniv
);
205 struct ablkcipher_request
*subreq
= skcipher_givcrypt_reqctx(req
);
206 crypto_completion_t
compl;
212 ablkcipher_request_set_tfm(subreq
, skcipher_geniv_cipher(geniv
));
214 compl = req
->creq
.base
.complete
;
215 data
= req
->creq
.base
.data
;
216 info
= req
->creq
.info
;
218 ivsize
= crypto_ablkcipher_ivsize(geniv
);
220 if (unlikely(!IS_ALIGNED((unsigned long)info
,
221 crypto_ablkcipher_alignmask(geniv
) + 1))) {
222 info
= kmalloc(ivsize
, req
->creq
.base
.flags
&
223 CRYPTO_TFM_REQ_MAY_SLEEP
? GFP_KERNEL
:
228 compl = seqiv_complete
;
232 ablkcipher_request_set_callback(subreq
, req
->creq
.base
.flags
, compl,
234 ablkcipher_request_set_crypt(subreq
, req
->creq
.src
, req
->creq
.dst
,
235 req
->creq
.nbytes
, info
);
237 seqiv_geniv(ctx
, info
, req
->seq
, ivsize
);
238 memcpy(req
->giv
, info
, ivsize
);
240 err
= crypto_ablkcipher_encrypt(subreq
);
241 if (unlikely(info
!= req
->creq
.info
))
242 seqiv_complete2(req
, err
);
246 static int seqiv_aead_givencrypt(struct aead_givcrypt_request
*req
)
248 struct crypto_aead
*geniv
= aead_givcrypt_reqtfm(req
);
249 struct seqiv_ctx
*ctx
= crypto_aead_ctx(geniv
);
250 struct aead_request
*areq
= &req
->areq
;
251 struct aead_request
*subreq
= aead_givcrypt_reqctx(req
);
252 crypto_completion_t
compl;
258 aead_request_set_tfm(subreq
, aead_geniv_base(geniv
));
260 compl = areq
->base
.complete
;
261 data
= areq
->base
.data
;
264 ivsize
= crypto_aead_ivsize(geniv
);
266 if (unlikely(!IS_ALIGNED((unsigned long)info
,
267 crypto_aead_alignmask(geniv
) + 1))) {
268 info
= kmalloc(ivsize
, areq
->base
.flags
&
269 CRYPTO_TFM_REQ_MAY_SLEEP
? GFP_KERNEL
:
274 compl = seqiv_aead_complete
;
278 aead_request_set_callback(subreq
, areq
->base
.flags
, compl, data
);
279 aead_request_set_crypt(subreq
, areq
->src
, areq
->dst
, areq
->cryptlen
,
281 aead_request_set_assoc(subreq
, areq
->assoc
, areq
->assoclen
);
283 seqiv_geniv(ctx
, info
, req
->seq
, ivsize
);
284 memcpy(req
->giv
, info
, ivsize
);
286 err
= crypto_aead_encrypt(subreq
);
287 if (unlikely(info
!= areq
->iv
))
288 seqiv_aead_complete2(req
, err
);
292 static int seqiv_aead_encrypt_compat(struct aead_request
*req
)
294 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
295 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
296 struct seqniv_request_ctx
*rctx
= aead_request_ctx(req
);
297 struct aead_request
*subreq
= &rctx
->subreq
;
298 struct scatterlist
*dst
;
299 crypto_completion_t
compl;
301 unsigned int ivsize
= 8;
302 u8 buf
[20] __attribute__ ((aligned(__alignof__(u32
))));
305 if (req
->cryptlen
< ivsize
)
308 /* ESP AD is at most 12 bytes (ESN). */
309 if (req
->assoclen
> 12)
312 aead_request_set_tfm(subreq
, ctx
->child
);
314 compl = seqniv_aead_encrypt_complete
;
317 if (req
->src
!= req
->dst
) {
318 struct scatterlist srcbuf
[2];
319 struct scatterlist dstbuf
[2];
320 struct blkcipher_desc desc
= {
324 err
= crypto_blkcipher_encrypt(
326 scatterwalk_ffwd(dstbuf
, req
->dst
,
327 req
->assoclen
+ ivsize
),
328 scatterwalk_ffwd(srcbuf
, req
->src
,
329 req
->assoclen
+ ivsize
),
330 req
->cryptlen
- ivsize
);
335 dst
= scatterwalk_ffwd(rctx
->dst
, req
->dst
, ivsize
);
337 aead_request_set_callback(subreq
, req
->base
.flags
, compl, data
);
338 aead_request_set_crypt(subreq
, dst
, dst
,
339 req
->cryptlen
- ivsize
, req
->iv
);
340 aead_request_set_ad(subreq
, req
->assoclen
);
342 memcpy(buf
, req
->iv
, ivsize
);
343 crypto_xor(buf
, ctx
->salt
, ivsize
);
344 memcpy(req
->iv
, buf
, ivsize
);
346 /* Swap order of IV and ESP AD for ICV generation. */
347 scatterwalk_map_and_copy(buf
+ ivsize
, req
->dst
, 0, req
->assoclen
, 0);
348 scatterwalk_map_and_copy(buf
, req
->dst
, 0, req
->assoclen
+ ivsize
, 1);
350 err
= crypto_aead_encrypt(subreq
);
351 seqniv_aead_encrypt_complete2(req
, err
);
355 static int seqiv_aead_encrypt(struct aead_request
*req
)
357 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
358 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
359 struct aead_request
*subreq
= aead_request_ctx(req
);
360 crypto_completion_t
compl;
363 unsigned int ivsize
= 8;
366 if (req
->cryptlen
< ivsize
)
369 aead_request_set_tfm(subreq
, ctx
->child
);
371 compl = req
->base
.complete
;
372 data
= req
->base
.data
;
375 if (req
->src
!= req
->dst
) {
376 struct scatterlist src
[2];
377 struct scatterlist dst
[2];
378 struct blkcipher_desc desc
= {
382 err
= crypto_blkcipher_encrypt(
384 scatterwalk_ffwd(dst
, req
->dst
,
385 req
->assoclen
+ ivsize
),
386 scatterwalk_ffwd(src
, req
->src
,
387 req
->assoclen
+ ivsize
),
388 req
->cryptlen
- ivsize
);
393 if (unlikely(!IS_ALIGNED((unsigned long)info
,
394 crypto_aead_alignmask(geniv
) + 1))) {
395 info
= kmalloc(ivsize
, req
->base
.flags
&
396 CRYPTO_TFM_REQ_MAY_SLEEP
? GFP_KERNEL
:
401 memcpy(info
, req
->iv
, ivsize
);
402 compl = seqiv_aead_encrypt_complete
;
406 aead_request_set_callback(subreq
, req
->base
.flags
, compl, data
);
407 aead_request_set_crypt(subreq
, req
->dst
, req
->dst
,
408 req
->cryptlen
- ivsize
, info
);
409 aead_request_set_ad(subreq
, req
->assoclen
+ ivsize
);
411 crypto_xor(info
, ctx
->salt
, ivsize
);
412 scatterwalk_map_and_copy(info
, req
->dst
, req
->assoclen
, ivsize
, 1);
414 err
= crypto_aead_encrypt(subreq
);
415 if (unlikely(info
!= req
->iv
))
416 seqiv_aead_encrypt_complete2(req
, err
);
420 static int seqiv_aead_decrypt_compat(struct aead_request
*req
)
422 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
423 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
424 struct seqniv_request_ctx
*rctx
= aead_request_ctx(req
);
425 struct aead_request
*subreq
= &rctx
->subreq
;
426 struct scatterlist
*dst
;
427 crypto_completion_t
compl;
429 unsigned int ivsize
= 8;
433 if (req
->cryptlen
< ivsize
+ crypto_aead_authsize(geniv
))
436 aead_request_set_tfm(subreq
, ctx
->child
);
438 compl = req
->base
.complete
;
439 data
= req
->base
.data
;
441 if (req
->assoclen
> 12)
443 else if (req
->assoclen
> 8) {
444 compl = seqniv_aead_decrypt_complete
;
448 if (req
->src
!= req
->dst
) {
449 struct scatterlist srcbuf
[2];
450 struct scatterlist dstbuf
[2];
451 struct blkcipher_desc desc
= {
455 err
= crypto_blkcipher_encrypt(
457 scatterwalk_ffwd(dstbuf
, req
->dst
,
458 req
->assoclen
+ ivsize
),
459 scatterwalk_ffwd(srcbuf
, req
->src
,
460 req
->assoclen
+ ivsize
),
461 req
->cryptlen
- ivsize
);
466 /* Move ESP AD forward for ICV generation. */
467 scatterwalk_map_and_copy(buf
, req
->dst
, 0, req
->assoclen
+ ivsize
, 0);
468 memcpy(req
->iv
, buf
+ req
->assoclen
, ivsize
);
469 scatterwalk_map_and_copy(buf
, req
->dst
, ivsize
, req
->assoclen
, 1);
471 dst
= scatterwalk_ffwd(rctx
->dst
, req
->dst
, ivsize
);
473 aead_request_set_callback(subreq
, req
->base
.flags
, compl, data
);
474 aead_request_set_crypt(subreq
, dst
, dst
,
475 req
->cryptlen
- ivsize
, req
->iv
);
476 aead_request_set_ad(subreq
, req
->assoclen
);
478 err
= crypto_aead_decrypt(subreq
);
479 if (req
->assoclen
> 8)
480 seqniv_aead_decrypt_complete2(req
, err
);
484 static int seqiv_aead_decrypt(struct aead_request
*req
)
486 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
487 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
488 struct aead_request
*subreq
= aead_request_ctx(req
);
489 crypto_completion_t
compl;
491 unsigned int ivsize
= 8;
493 if (req
->cryptlen
< ivsize
+ crypto_aead_authsize(geniv
))
496 aead_request_set_tfm(subreq
, ctx
->child
);
498 compl = req
->base
.complete
;
499 data
= req
->base
.data
;
501 aead_request_set_callback(subreq
, req
->base
.flags
, compl, data
);
502 aead_request_set_crypt(subreq
, req
->src
, req
->dst
,
503 req
->cryptlen
- ivsize
, req
->iv
);
504 aead_request_set_ad(subreq
, req
->assoclen
+ ivsize
);
506 scatterwalk_map_and_copy(req
->iv
, req
->src
, req
->assoclen
, ivsize
, 0);
507 if (req
->src
!= req
->dst
)
508 scatterwalk_map_and_copy(req
->iv
, req
->dst
,
509 req
->assoclen
, ivsize
, 1);
511 return crypto_aead_decrypt(subreq
);
514 static int seqiv_givencrypt_first(struct skcipher_givcrypt_request
*req
)
516 struct crypto_ablkcipher
*geniv
= skcipher_givcrypt_reqtfm(req
);
517 struct seqiv_ctx
*ctx
= crypto_ablkcipher_ctx(geniv
);
520 spin_lock_bh(&ctx
->lock
);
521 if (crypto_ablkcipher_crt(geniv
)->givencrypt
!= seqiv_givencrypt_first
)
524 crypto_ablkcipher_crt(geniv
)->givencrypt
= seqiv_givencrypt
;
525 err
= crypto_rng_get_bytes(crypto_default_rng
, ctx
->salt
,
526 crypto_ablkcipher_ivsize(geniv
));
529 spin_unlock_bh(&ctx
->lock
);
534 return seqiv_givencrypt(req
);
537 static int seqiv_aead_givencrypt_first(struct aead_givcrypt_request
*req
)
539 struct crypto_aead
*geniv
= aead_givcrypt_reqtfm(req
);
540 struct seqiv_ctx
*ctx
= crypto_aead_ctx(geniv
);
543 spin_lock_bh(&ctx
->lock
);
544 if (crypto_aead_crt(geniv
)->givencrypt
!= seqiv_aead_givencrypt_first
)
547 crypto_aead_crt(geniv
)->givencrypt
= seqiv_aead_givencrypt
;
548 err
= crypto_rng_get_bytes(crypto_default_rng
, ctx
->salt
,
549 crypto_aead_ivsize(geniv
));
552 spin_unlock_bh(&ctx
->lock
);
557 return seqiv_aead_givencrypt(req
);
560 static int seqiv_aead_encrypt_compat_first(struct aead_request
*req
)
562 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
563 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
566 spin_lock_bh(&ctx
->lock
);
567 if (geniv
->encrypt
!= seqiv_aead_encrypt_compat_first
)
570 geniv
->encrypt
= seqiv_aead_encrypt_compat
;
571 err
= crypto_rng_get_bytes(crypto_default_rng
, ctx
->salt
,
572 crypto_aead_ivsize(geniv
));
575 spin_unlock_bh(&ctx
->lock
);
580 return seqiv_aead_encrypt_compat(req
);
583 static int seqiv_aead_encrypt_first(struct aead_request
*req
)
585 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
586 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
589 spin_lock_bh(&ctx
->lock
);
590 if (geniv
->encrypt
!= seqiv_aead_encrypt_first
)
593 geniv
->encrypt
= seqiv_aead_encrypt
;
594 err
= crypto_rng_get_bytes(crypto_default_rng
, ctx
->salt
,
595 crypto_aead_ivsize(geniv
));
598 spin_unlock_bh(&ctx
->lock
);
603 return seqiv_aead_encrypt(req
);
606 static int seqiv_init(struct crypto_tfm
*tfm
)
608 struct crypto_ablkcipher
*geniv
= __crypto_ablkcipher_cast(tfm
);
609 struct seqiv_ctx
*ctx
= crypto_ablkcipher_ctx(geniv
);
611 spin_lock_init(&ctx
->lock
);
613 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct ablkcipher_request
);
615 return skcipher_geniv_init(tfm
);
618 static int seqiv_old_aead_init(struct crypto_tfm
*tfm
)
620 struct crypto_aead
*geniv
= __crypto_aead_cast(tfm
);
621 struct seqiv_ctx
*ctx
= crypto_aead_ctx(geniv
);
623 spin_lock_init(&ctx
->lock
);
625 crypto_aead_set_reqsize(__crypto_aead_cast(tfm
),
626 sizeof(struct aead_request
));
628 return aead_geniv_init(tfm
);
631 static int seqiv_aead_init_common(struct crypto_tfm
*tfm
, unsigned int reqsize
)
633 struct crypto_aead
*geniv
= __crypto_aead_cast(tfm
);
634 struct seqiv_aead_ctx
*ctx
= crypto_aead_ctx(geniv
);
637 spin_lock_init(&ctx
->lock
);
639 crypto_aead_set_reqsize(geniv
, sizeof(struct aead_request
));
641 ctx
->null
= crypto_get_default_null_skcipher();
642 err
= PTR_ERR(ctx
->null
);
643 if (IS_ERR(ctx
->null
))
646 err
= aead_geniv_init(tfm
);
650 ctx
->child
= geniv
->child
;
651 geniv
->child
= geniv
;
657 crypto_put_default_null_skcipher();
661 static int seqiv_aead_init(struct crypto_tfm
*tfm
)
663 return seqiv_aead_init_common(tfm
, sizeof(struct aead_request
));
666 static int seqniv_aead_init(struct crypto_tfm
*tfm
)
668 return seqiv_aead_init_common(tfm
, sizeof(struct seqniv_request_ctx
));
671 static void seqiv_aead_exit(struct crypto_tfm
*tfm
)
673 struct seqiv_aead_ctx
*ctx
= crypto_tfm_ctx(tfm
);
675 crypto_free_aead(ctx
->child
);
676 crypto_put_default_null_skcipher();
679 static int seqiv_ablkcipher_create(struct crypto_template
*tmpl
,
682 struct crypto_instance
*inst
;
685 inst
= skcipher_geniv_alloc(tmpl
, tb
, 0, 0);
688 return PTR_ERR(inst
);
691 if (inst
->alg
.cra_ablkcipher
.ivsize
< sizeof(u64
))
694 inst
->alg
.cra_ablkcipher
.givencrypt
= seqiv_givencrypt_first
;
696 inst
->alg
.cra_init
= seqiv_init
;
697 inst
->alg
.cra_exit
= skcipher_geniv_exit
;
699 inst
->alg
.cra_ctxsize
+= inst
->alg
.cra_ablkcipher
.ivsize
;
700 inst
->alg
.cra_ctxsize
+= sizeof(struct seqiv_ctx
);
702 inst
->alg
.cra_alignmask
|= __alignof__(u32
) - 1;
704 err
= crypto_register_instance(tmpl
, inst
);
712 skcipher_geniv_free(inst
);
716 static int seqiv_old_aead_create(struct crypto_template
*tmpl
,
717 struct aead_instance
*aead
)
719 struct crypto_instance
*inst
= aead_crypto_instance(aead
);
722 if (inst
->alg
.cra_aead
.ivsize
< sizeof(u64
))
725 inst
->alg
.cra_aead
.givencrypt
= seqiv_aead_givencrypt_first
;
727 inst
->alg
.cra_init
= seqiv_old_aead_init
;
728 inst
->alg
.cra_exit
= aead_geniv_exit
;
730 inst
->alg
.cra_ctxsize
= inst
->alg
.cra_aead
.ivsize
;
731 inst
->alg
.cra_ctxsize
+= sizeof(struct seqiv_ctx
);
733 err
= crypto_register_instance(tmpl
, inst
);
741 aead_geniv_free(aead
);
745 static int seqiv_aead_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
747 struct aead_instance
*inst
;
748 struct crypto_aead_spawn
*spawn
;
749 struct aead_alg
*alg
;
752 inst
= aead_geniv_alloc(tmpl
, tb
, 0, 0);
755 return PTR_ERR(inst
);
757 inst
->alg
.base
.cra_alignmask
|= __alignof__(u32
) - 1;
759 if (inst
->alg
.base
.cra_aead
.encrypt
)
760 return seqiv_old_aead_create(tmpl
, inst
);
763 if (inst
->alg
.ivsize
!= sizeof(u64
))
766 spawn
= aead_instance_ctx(inst
);
767 alg
= crypto_spawn_aead_alg(spawn
);
769 inst
->alg
.setkey
= seqiv_aead_setkey
;
770 inst
->alg
.setauthsize
= seqiv_aead_setauthsize
;
771 inst
->alg
.encrypt
= seqiv_aead_encrypt_first
;
772 inst
->alg
.decrypt
= seqiv_aead_decrypt
;
774 inst
->alg
.base
.cra_init
= seqiv_aead_init
;
775 inst
->alg
.base
.cra_exit
= seqiv_aead_exit
;
777 inst
->alg
.base
.cra_ctxsize
= sizeof(struct seqiv_aead_ctx
);
778 inst
->alg
.base
.cra_ctxsize
+= inst
->alg
.base
.cra_aead
.ivsize
;
780 if (alg
->base
.cra_aead
.encrypt
) {
781 inst
->alg
.encrypt
= seqiv_aead_encrypt_compat_first
;
782 inst
->alg
.decrypt
= seqiv_aead_decrypt_compat
;
784 inst
->alg
.base
.cra_init
= seqniv_aead_init
;
785 inst
->alg
.base
.cra_exit
= seqiv_aead_exit
;
788 err
= aead_register_instance(tmpl
, inst
);
796 aead_geniv_free(inst
);
800 static int seqiv_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
802 struct crypto_attr_type
*algt
;
805 algt
= crypto_get_attr_type(tb
);
807 return PTR_ERR(algt
);
809 err
= crypto_get_default_rng();
813 if ((algt
->type
^ CRYPTO_ALG_TYPE_AEAD
) & CRYPTO_ALG_TYPE_MASK
)
814 err
= seqiv_ablkcipher_create(tmpl
, tb
);
816 err
= seqiv_aead_create(tmpl
, tb
);
819 crypto_put_default_rng();
824 static int seqniv_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
826 struct aead_instance
*inst
;
827 struct crypto_aead_spawn
*spawn
;
828 struct aead_alg
*alg
;
831 err
= crypto_get_default_rng();
835 inst
= aead_geniv_alloc(tmpl
, tb
, 0, 0);
841 if (inst
->alg
.ivsize
!= sizeof(u64
))
844 spawn
= aead_instance_ctx(inst
);
845 alg
= crypto_spawn_aead_alg(spawn
);
847 inst
->alg
.setkey
= seqiv_aead_setkey
;
848 inst
->alg
.setauthsize
= seqiv_aead_setauthsize
;
849 inst
->alg
.encrypt
= seqiv_aead_encrypt_compat_first
;
850 inst
->alg
.decrypt
= seqiv_aead_decrypt_compat
;
852 inst
->alg
.base
.cra_init
= seqniv_aead_init
;
853 inst
->alg
.base
.cra_exit
= seqiv_aead_exit
;
855 inst
->alg
.base
.cra_alignmask
|= __alignof__(u32
) - 1;
856 inst
->alg
.base
.cra_ctxsize
= sizeof(struct seqiv_aead_ctx
);
857 inst
->alg
.base
.cra_ctxsize
+= inst
->alg
.base
.cra_aead
.ivsize
;
859 err
= aead_register_instance(tmpl
, inst
);
867 aead_geniv_free(inst
);
869 crypto_put_default_rng();
873 static void seqiv_free(struct crypto_instance
*inst
)
875 if ((inst
->alg
.cra_flags
^ CRYPTO_ALG_TYPE_AEAD
) & CRYPTO_ALG_TYPE_MASK
)
876 skcipher_geniv_free(inst
);
878 aead_geniv_free(aead_instance(inst
));
879 crypto_put_default_rng();
882 static struct crypto_template seqiv_tmpl
= {
884 .create
= seqiv_create
,
886 .module
= THIS_MODULE
,
889 static struct crypto_template seqniv_tmpl
= {
891 .create
= seqniv_create
,
893 .module
= THIS_MODULE
,
896 static int __init
seqiv_module_init(void)
900 err
= crypto_register_template(&seqiv_tmpl
);
904 err
= crypto_register_template(&seqniv_tmpl
);
912 crypto_unregister_template(&seqiv_tmpl
);
916 static void __exit
seqiv_module_exit(void)
918 crypto_unregister_template(&seqiv_tmpl
);
921 module_init(seqiv_module_init
);
922 module_exit(seqiv_module_exit
);
924 MODULE_LICENSE("GPL");
925 MODULE_DESCRIPTION("Sequence Number IV Generator");
926 MODULE_ALIAS_CRYPTO("seqiv");
927 MODULE_ALIAS_CRYPTO("seqniv");