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/geniv.h>
17 #include <crypto/scatterwalk.h>
18 #include <crypto/skcipher.h>
19 #include <linux/err.h>
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
26 static void seqiv_free(struct crypto_instance
*inst
);
28 static void seqiv_aead_encrypt_complete2(struct aead_request
*req
, int err
)
30 struct aead_request
*subreq
= aead_request_ctx(req
);
31 struct crypto_aead
*geniv
;
33 if (err
== -EINPROGRESS
)
39 geniv
= crypto_aead_reqtfm(req
);
40 memcpy(req
->iv
, subreq
->iv
, crypto_aead_ivsize(geniv
));
46 static void seqiv_aead_encrypt_complete(struct crypto_async_request
*base
,
49 struct aead_request
*req
= base
->data
;
51 seqiv_aead_encrypt_complete2(req
, err
);
52 aead_request_complete(req
, err
);
55 static int seqiv_aead_encrypt(struct aead_request
*req
)
57 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
58 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(geniv
);
59 struct aead_request
*subreq
= aead_request_ctx(req
);
60 crypto_completion_t
compl;
63 unsigned int ivsize
= 8;
66 if (req
->cryptlen
< ivsize
)
69 aead_request_set_tfm(subreq
, ctx
->child
);
71 compl = req
->base
.complete
;
72 data
= req
->base
.data
;
75 if (req
->src
!= req
->dst
) {
76 SKCIPHER_REQUEST_ON_STACK(nreq
, ctx
->sknull
);
78 skcipher_request_set_tfm(nreq
, ctx
->sknull
);
79 skcipher_request_set_callback(nreq
, req
->base
.flags
,
81 skcipher_request_set_crypt(nreq
, req
->src
, req
->dst
,
82 req
->assoclen
+ req
->cryptlen
,
85 err
= crypto_skcipher_encrypt(nreq
);
90 if (unlikely(!IS_ALIGNED((unsigned long)info
,
91 crypto_aead_alignmask(geniv
) + 1))) {
92 info
= kmalloc(ivsize
, req
->base
.flags
&
93 CRYPTO_TFM_REQ_MAY_SLEEP
? GFP_KERNEL
:
98 memcpy(info
, req
->iv
, ivsize
);
99 compl = seqiv_aead_encrypt_complete
;
103 aead_request_set_callback(subreq
, req
->base
.flags
, compl, data
);
104 aead_request_set_crypt(subreq
, req
->dst
, req
->dst
,
105 req
->cryptlen
- ivsize
, info
);
106 aead_request_set_ad(subreq
, req
->assoclen
+ ivsize
);
108 crypto_xor(info
, ctx
->salt
, ivsize
);
109 scatterwalk_map_and_copy(info
, req
->dst
, req
->assoclen
, ivsize
, 1);
111 err
= crypto_aead_encrypt(subreq
);
112 if (unlikely(info
!= req
->iv
))
113 seqiv_aead_encrypt_complete2(req
, err
);
117 static int seqiv_aead_decrypt(struct aead_request
*req
)
119 struct crypto_aead
*geniv
= crypto_aead_reqtfm(req
);
120 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(geniv
);
121 struct aead_request
*subreq
= aead_request_ctx(req
);
122 crypto_completion_t
compl;
124 unsigned int ivsize
= 8;
126 if (req
->cryptlen
< ivsize
+ crypto_aead_authsize(geniv
))
129 aead_request_set_tfm(subreq
, ctx
->child
);
131 compl = req
->base
.complete
;
132 data
= req
->base
.data
;
134 aead_request_set_callback(subreq
, req
->base
.flags
, compl, data
);
135 aead_request_set_crypt(subreq
, req
->src
, req
->dst
,
136 req
->cryptlen
- ivsize
, req
->iv
);
137 aead_request_set_ad(subreq
, req
->assoclen
+ ivsize
);
139 scatterwalk_map_and_copy(req
->iv
, req
->src
, req
->assoclen
, ivsize
, 0);
141 return crypto_aead_decrypt(subreq
);
144 static int seqiv_aead_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
146 struct aead_instance
*inst
;
147 struct crypto_aead_spawn
*spawn
;
148 struct aead_alg
*alg
;
151 inst
= aead_geniv_alloc(tmpl
, tb
, 0, 0);
154 return PTR_ERR(inst
);
156 inst
->alg
.base
.cra_alignmask
|= __alignof__(u32
) - 1;
158 spawn
= aead_instance_ctx(inst
);
159 alg
= crypto_spawn_aead_alg(spawn
);
162 if (inst
->alg
.ivsize
!= sizeof(u64
))
165 inst
->alg
.encrypt
= seqiv_aead_encrypt
;
166 inst
->alg
.decrypt
= seqiv_aead_decrypt
;
168 inst
->alg
.init
= aead_init_geniv
;
169 inst
->alg
.exit
= aead_exit_geniv
;
171 inst
->alg
.base
.cra_ctxsize
= sizeof(struct aead_geniv_ctx
);
172 inst
->alg
.base
.cra_ctxsize
+= inst
->alg
.ivsize
;
174 err
= aead_register_instance(tmpl
, inst
);
182 aead_geniv_free(inst
);
186 static int seqiv_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
188 struct crypto_attr_type
*algt
;
190 algt
= crypto_get_attr_type(tb
);
192 return PTR_ERR(algt
);
194 if ((algt
->type
^ CRYPTO_ALG_TYPE_AEAD
) & CRYPTO_ALG_TYPE_MASK
)
197 return seqiv_aead_create(tmpl
, tb
);
200 static void seqiv_free(struct crypto_instance
*inst
)
202 aead_geniv_free(aead_instance(inst
));
205 static struct crypto_template seqiv_tmpl
= {
207 .create
= seqiv_create
,
209 .module
= THIS_MODULE
,
212 static int __init
seqiv_module_init(void)
214 return crypto_register_template(&seqiv_tmpl
);
217 static void __exit
seqiv_module_exit(void)
219 crypto_unregister_template(&seqiv_tmpl
);
222 module_init(seqiv_module_init
);
223 module_exit(seqiv_module_exit
);
225 MODULE_LICENSE("GPL");
226 MODULE_DESCRIPTION("Sequence Number IV Generator");
227 MODULE_ALIAS_CRYPTO("seqiv");