Commit | Line | Data |
---|---|---|
7f470739 HX |
1 | /* |
2 | * chainiv: Chain IV Generator | |
3 | * | |
4 | * Generate IVs simply be using the last block of the previous encryption. | |
5 | * This is mainly useful for CBC with a synchronous algorithm. | |
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 | ||
16 | #include <crypto/internal/skcipher.h> | |
a0f000ec | 17 | #include <crypto/rng.h> |
0a2e821d | 18 | #include <crypto/crypto_wq.h> |
7f470739 HX |
19 | #include <linux/err.h> |
20 | #include <linux/init.h> | |
e7cd2514 | 21 | #include <linux/kernel.h> |
7f470739 | 22 | #include <linux/module.h> |
7f470739 HX |
23 | #include <linux/spinlock.h> |
24 | #include <linux/string.h> | |
e7cd2514 HX |
25 | #include <linux/workqueue.h> |
26 | ||
27 | enum { | |
28 | CHAINIV_STATE_INUSE = 0, | |
29 | }; | |
7f470739 HX |
30 | |
31 | struct chainiv_ctx { | |
32 | spinlock_t lock; | |
33 | char iv[]; | |
34 | }; | |
35 | ||
e7cd2514 HX |
36 | struct async_chainiv_ctx { |
37 | unsigned long state; | |
38 | ||
39 | spinlock_t lock; | |
40 | int err; | |
41 | ||
42 | struct crypto_queue queue; | |
43 | struct work_struct postponed; | |
44 | ||
45 | char iv[]; | |
46 | }; | |
47 | ||
7f470739 HX |
48 | static int chainiv_givencrypt(struct skcipher_givcrypt_request *req) |
49 | { | |
50 | struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); | |
51 | struct chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); | |
52 | struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req); | |
53 | unsigned int ivsize; | |
54 | int err; | |
55 | ||
56 | ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv)); | |
57 | ablkcipher_request_set_callback(subreq, req->creq.base.flags & | |
58 | ~CRYPTO_TFM_REQ_MAY_SLEEP, | |
59 | req->creq.base.complete, | |
60 | req->creq.base.data); | |
61 | ablkcipher_request_set_crypt(subreq, req->creq.src, req->creq.dst, | |
62 | req->creq.nbytes, req->creq.info); | |
63 | ||
64 | spin_lock_bh(&ctx->lock); | |
65 | ||
66 | ivsize = crypto_ablkcipher_ivsize(geniv); | |
67 | ||
68 | memcpy(req->giv, ctx->iv, ivsize); | |
69 | memcpy(subreq->info, ctx->iv, ivsize); | |
70 | ||
71 | err = crypto_ablkcipher_encrypt(subreq); | |
72 | if (err) | |
73 | goto unlock; | |
74 | ||
75 | memcpy(ctx->iv, subreq->info, ivsize); | |
76 | ||
77 | unlock: | |
78 | spin_unlock_bh(&ctx->lock); | |
79 | ||
80 | return err; | |
81 | } | |
82 | ||
65fe6740 | 83 | static int chainiv_init_common(struct crypto_tfm *tfm, char iv[]) |
7f470739 | 84 | { |
65fe6740 | 85 | struct crypto_ablkcipher *geniv = __crypto_ablkcipher_cast(tfm); |
7f470739 | 86 | |
e7cd2514 HX |
87 | tfm->crt_ablkcipher.reqsize = sizeof(struct ablkcipher_request); |
88 | ||
65fe6740 HX |
89 | return crypto_rng_get_bytes(crypto_default_rng, iv, |
90 | crypto_ablkcipher_ivsize(geniv)) ?: | |
91 | skcipher_geniv_init(tfm); | |
e7cd2514 HX |
92 | } |
93 | ||
7f470739 HX |
94 | static int chainiv_init(struct crypto_tfm *tfm) |
95 | { | |
e7cd2514 | 96 | struct chainiv_ctx *ctx = crypto_tfm_ctx(tfm); |
7f470739 HX |
97 | |
98 | spin_lock_init(&ctx->lock); | |
99 | ||
65fe6740 | 100 | return chainiv_init_common(tfm, ctx->iv); |
e7cd2514 | 101 | } |
7f470739 | 102 | |
e7cd2514 HX |
103 | static int async_chainiv_schedule_work(struct async_chainiv_ctx *ctx) |
104 | { | |
105 | int queued; | |
872ac874 | 106 | int err = ctx->err; |
e7cd2514 HX |
107 | |
108 | if (!ctx->queue.qlen) { | |
4e857c58 | 109 | smp_mb__before_atomic(); |
e7cd2514 HX |
110 | clear_bit(CHAINIV_STATE_INUSE, &ctx->state); |
111 | ||
112 | if (!ctx->queue.qlen || | |
113 | test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) | |
114 | goto out; | |
115 | } | |
116 | ||
0a2e821d | 117 | queued = queue_work(kcrypto_wq, &ctx->postponed); |
e7cd2514 HX |
118 | BUG_ON(!queued); |
119 | ||
120 | out: | |
872ac874 | 121 | return err; |
e7cd2514 HX |
122 | } |
123 | ||
124 | static int async_chainiv_postpone_request(struct skcipher_givcrypt_request *req) | |
125 | { | |
126 | struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); | |
127 | struct async_chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); | |
128 | int err; | |
129 | ||
130 | spin_lock_bh(&ctx->lock); | |
131 | err = skcipher_enqueue_givcrypt(&ctx->queue, req); | |
132 | spin_unlock_bh(&ctx->lock); | |
133 | ||
134 | if (test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) | |
135 | return err; | |
136 | ||
137 | ctx->err = err; | |
138 | return async_chainiv_schedule_work(ctx); | |
139 | } | |
140 | ||
141 | static int async_chainiv_givencrypt_tail(struct skcipher_givcrypt_request *req) | |
142 | { | |
143 | struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); | |
144 | struct async_chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); | |
145 | struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req); | |
146 | unsigned int ivsize = crypto_ablkcipher_ivsize(geniv); | |
147 | ||
148 | memcpy(req->giv, ctx->iv, ivsize); | |
149 | memcpy(subreq->info, ctx->iv, ivsize); | |
150 | ||
151 | ctx->err = crypto_ablkcipher_encrypt(subreq); | |
152 | if (ctx->err) | |
153 | goto out; | |
154 | ||
155 | memcpy(ctx->iv, subreq->info, ivsize); | |
156 | ||
157 | out: | |
158 | return async_chainiv_schedule_work(ctx); | |
159 | } | |
160 | ||
161 | static int async_chainiv_givencrypt(struct skcipher_givcrypt_request *req) | |
162 | { | |
163 | struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); | |
164 | struct async_chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); | |
165 | struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req); | |
166 | ||
167 | ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv)); | |
168 | ablkcipher_request_set_callback(subreq, req->creq.base.flags, | |
169 | req->creq.base.complete, | |
170 | req->creq.base.data); | |
171 | ablkcipher_request_set_crypt(subreq, req->creq.src, req->creq.dst, | |
172 | req->creq.nbytes, req->creq.info); | |
173 | ||
174 | if (test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) | |
175 | goto postpone; | |
176 | ||
177 | if (ctx->queue.qlen) { | |
178 | clear_bit(CHAINIV_STATE_INUSE, &ctx->state); | |
179 | goto postpone; | |
180 | } | |
181 | ||
182 | return async_chainiv_givencrypt_tail(req); | |
183 | ||
184 | postpone: | |
185 | return async_chainiv_postpone_request(req); | |
186 | } | |
187 | ||
e7cd2514 HX |
188 | static void async_chainiv_do_postponed(struct work_struct *work) |
189 | { | |
190 | struct async_chainiv_ctx *ctx = container_of(work, | |
191 | struct async_chainiv_ctx, | |
192 | postponed); | |
193 | struct skcipher_givcrypt_request *req; | |
194 | struct ablkcipher_request *subreq; | |
872ac874 | 195 | int err; |
e7cd2514 HX |
196 | |
197 | /* Only handle one request at a time to avoid hogging keventd. */ | |
198 | spin_lock_bh(&ctx->lock); | |
199 | req = skcipher_dequeue_givcrypt(&ctx->queue); | |
200 | spin_unlock_bh(&ctx->lock); | |
201 | ||
202 | if (!req) { | |
203 | async_chainiv_schedule_work(ctx); | |
204 | return; | |
205 | } | |
206 | ||
207 | subreq = skcipher_givcrypt_reqctx(req); | |
208 | subreq->base.flags |= CRYPTO_TFM_REQ_MAY_SLEEP; | |
209 | ||
872ac874 HX |
210 | err = async_chainiv_givencrypt_tail(req); |
211 | ||
212 | local_bh_disable(); | |
213 | skcipher_givcrypt_complete(req, err); | |
214 | local_bh_enable(); | |
e7cd2514 HX |
215 | } |
216 | ||
217 | static int async_chainiv_init(struct crypto_tfm *tfm) | |
218 | { | |
219 | struct async_chainiv_ctx *ctx = crypto_tfm_ctx(tfm); | |
220 | ||
221 | spin_lock_init(&ctx->lock); | |
222 | ||
223 | crypto_init_queue(&ctx->queue, 100); | |
224 | INIT_WORK(&ctx->postponed, async_chainiv_do_postponed); | |
225 | ||
65fe6740 | 226 | return chainiv_init_common(tfm, ctx->iv); |
e7cd2514 HX |
227 | } |
228 | ||
229 | static void async_chainiv_exit(struct crypto_tfm *tfm) | |
230 | { | |
231 | struct async_chainiv_ctx *ctx = crypto_tfm_ctx(tfm); | |
232 | ||
233 | BUG_ON(test_bit(CHAINIV_STATE_INUSE, &ctx->state) || ctx->queue.qlen); | |
234 | ||
235 | skcipher_geniv_exit(tfm); | |
7f470739 HX |
236 | } |
237 | ||
238 | static struct crypto_template chainiv_tmpl; | |
239 | ||
240 | static struct crypto_instance *chainiv_alloc(struct rtattr **tb) | |
241 | { | |
e7cd2514 | 242 | struct crypto_attr_type *algt; |
7f470739 | 243 | struct crypto_instance *inst; |
e7cd2514 | 244 | int err; |
7f470739 | 245 | |
e7cd2514 | 246 | algt = crypto_get_attr_type(tb); |
e7cd2514 | 247 | if (IS_ERR(algt)) |
3e8afe35 | 248 | return ERR_CAST(algt); |
e7cd2514 | 249 | |
a0f000ec HX |
250 | err = crypto_get_default_rng(); |
251 | if (err) | |
252 | return ERR_PTR(err); | |
253 | ||
e7cd2514 | 254 | inst = skcipher_geniv_alloc(&chainiv_tmpl, tb, 0, 0); |
7f470739 | 255 | if (IS_ERR(inst)) |
a0f000ec | 256 | goto put_rng; |
7f470739 | 257 | |
65fe6740 | 258 | inst->alg.cra_ablkcipher.givencrypt = chainiv_givencrypt; |
7f470739 HX |
259 | |
260 | inst->alg.cra_init = chainiv_init; | |
261 | inst->alg.cra_exit = skcipher_geniv_exit; | |
262 | ||
e7cd2514 HX |
263 | inst->alg.cra_ctxsize = sizeof(struct chainiv_ctx); |
264 | ||
265 | if (!crypto_requires_sync(algt->type, algt->mask)) { | |
266 | inst->alg.cra_flags |= CRYPTO_ALG_ASYNC; | |
267 | ||
65fe6740 | 268 | inst->alg.cra_ablkcipher.givencrypt = async_chainiv_givencrypt; |
e7cd2514 HX |
269 | |
270 | inst->alg.cra_init = async_chainiv_init; | |
271 | inst->alg.cra_exit = async_chainiv_exit; | |
272 | ||
273 | inst->alg.cra_ctxsize = sizeof(struct async_chainiv_ctx); | |
274 | } | |
275 | ||
276 | inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; | |
7f470739 HX |
277 | |
278 | out: | |
279 | return inst; | |
a0f000ec HX |
280 | |
281 | put_rng: | |
282 | crypto_put_default_rng(); | |
283 | goto out; | |
284 | } | |
285 | ||
286 | static void chainiv_free(struct crypto_instance *inst) | |
287 | { | |
288 | skcipher_geniv_free(inst); | |
289 | crypto_put_default_rng(); | |
7f470739 HX |
290 | } |
291 | ||
292 | static struct crypto_template chainiv_tmpl = { | |
293 | .name = "chainiv", | |
294 | .alloc = chainiv_alloc, | |
a0f000ec | 295 | .free = chainiv_free, |
7f470739 HX |
296 | .module = THIS_MODULE, |
297 | }; | |
298 | ||
5be5e667 | 299 | static int __init chainiv_module_init(void) |
7f470739 HX |
300 | { |
301 | return crypto_register_template(&chainiv_tmpl); | |
302 | } | |
303 | ||
5be5e667 | 304 | static void chainiv_module_exit(void) |
7f470739 HX |
305 | { |
306 | crypto_unregister_template(&chainiv_tmpl); | |
307 | } | |
5be5e667 HX |
308 | |
309 | module_init(chainiv_module_init); | |
310 | module_exit(chainiv_module_exit); | |
311 | ||
312 | MODULE_LICENSE("GPL"); | |
313 | MODULE_DESCRIPTION("Chain IV Generator"); | |
4943ba16 | 314 | MODULE_ALIAS_CRYPTO("chainiv"); |