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