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> 17#include <crypto/rng.h> 18#include <crypto/crypto_wq.h> 19#include <linux/err.h> 20#include <linux/init.h> 21#include <linux/kernel.h> 22#include <linux/module.h> 23#include <linux/spinlock.h> 24#include <linux/string.h> 25#include <linux/workqueue.h> 26 27enum { 28 CHAINIV_STATE_INUSE = 0, 29}; 30 31struct chainiv_ctx { 32 spinlock_t lock; 33 char iv[]; 34}; 35 36struct 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 48static 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 77unlock: 78 spin_unlock_bh(&ctx->lock); 79 80 return err; 81} 82 83static int chainiv_givencrypt_first(struct skcipher_givcrypt_request *req) 84{ 85 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 86 struct chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 87 int err = 0; 88 89 spin_lock_bh(&ctx->lock); 90 if (crypto_ablkcipher_crt(geniv)->givencrypt != 91 chainiv_givencrypt_first) 92 goto unlock; 93 94 crypto_ablkcipher_crt(geniv)->givencrypt = chainiv_givencrypt; 95 err = crypto_rng_get_bytes(crypto_default_rng, ctx->iv, 96 crypto_ablkcipher_ivsize(geniv)); 97 98unlock: 99 spin_unlock_bh(&ctx->lock); 100 101 if (err) 102 return err; 103 104 return chainiv_givencrypt(req); 105} 106 107static int chainiv_init_common(struct crypto_tfm *tfm) 108{ 109 tfm->crt_ablkcipher.reqsize = sizeof(struct ablkcipher_request); 110 111 return skcipher_geniv_init(tfm); 112} 113 114static int chainiv_init(struct crypto_tfm *tfm) 115{ 116 struct chainiv_ctx *ctx = crypto_tfm_ctx(tfm); 117 118 spin_lock_init(&ctx->lock); 119 120 return chainiv_init_common(tfm); 121} 122 123static int async_chainiv_schedule_work(struct async_chainiv_ctx *ctx) 124{ 125 int queued; 126 int err = ctx->err; 127 128 if (!ctx->queue.qlen) { 129 smp_mb__before_atomic(); 130 clear_bit(CHAINIV_STATE_INUSE, &ctx->state); 131 132 if (!ctx->queue.qlen || 133 test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) 134 goto out; 135 } 136 137 queued = queue_work(kcrypto_wq, &ctx->postponed); 138 BUG_ON(!queued); 139 140out: 141 return err; 142} 143 144static int async_chainiv_postpone_request(struct skcipher_givcrypt_request *req) 145{ 146 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 147 struct async_chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 148 int err; 149 150 spin_lock_bh(&ctx->lock); 151 err = skcipher_enqueue_givcrypt(&ctx->queue, req); 152 spin_unlock_bh(&ctx->lock); 153 154 if (test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) 155 return err; 156 157 ctx->err = err; 158 return async_chainiv_schedule_work(ctx); 159} 160 161static int async_chainiv_givencrypt_tail(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 unsigned int ivsize = crypto_ablkcipher_ivsize(geniv); 167 168 memcpy(req->giv, ctx->iv, ivsize); 169 memcpy(subreq->info, ctx->iv, ivsize); 170 171 ctx->err = crypto_ablkcipher_encrypt(subreq); 172 if (ctx->err) 173 goto out; 174 175 memcpy(ctx->iv, subreq->info, ivsize); 176 177out: 178 return async_chainiv_schedule_work(ctx); 179} 180 181static int async_chainiv_givencrypt(struct skcipher_givcrypt_request *req) 182{ 183 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 184 struct async_chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 185 struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req); 186 187 ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv)); 188 ablkcipher_request_set_callback(subreq, req->creq.base.flags, 189 req->creq.base.complete, 190 req->creq.base.data); 191 ablkcipher_request_set_crypt(subreq, req->creq.src, req->creq.dst, 192 req->creq.nbytes, req->creq.info); 193 194 if (test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) 195 goto postpone; 196 197 if (ctx->queue.qlen) { 198 clear_bit(CHAINIV_STATE_INUSE, &ctx->state); 199 goto postpone; 200 } 201 202 return async_chainiv_givencrypt_tail(req); 203 204postpone: 205 return async_chainiv_postpone_request(req); 206} 207 208static int async_chainiv_givencrypt_first(struct skcipher_givcrypt_request *req) 209{ 210 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 211 struct async_chainiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 212 int err = 0; 213 214 if (test_and_set_bit(CHAINIV_STATE_INUSE, &ctx->state)) 215 goto out; 216 217 if (crypto_ablkcipher_crt(geniv)->givencrypt != 218 async_chainiv_givencrypt_first) 219 goto unlock; 220 221 crypto_ablkcipher_crt(geniv)->givencrypt = async_chainiv_givencrypt; 222 err = crypto_rng_get_bytes(crypto_default_rng, ctx->iv, 223 crypto_ablkcipher_ivsize(geniv)); 224 225unlock: 226 clear_bit(CHAINIV_STATE_INUSE, &ctx->state); 227 228 if (err) 229 return err; 230 231out: 232 return async_chainiv_givencrypt(req); 233} 234 235static void async_chainiv_do_postponed(struct work_struct *work) 236{ 237 struct async_chainiv_ctx *ctx = container_of(work, 238 struct async_chainiv_ctx, 239 postponed); 240 struct skcipher_givcrypt_request *req; 241 struct ablkcipher_request *subreq; 242 int err; 243 244 /* Only handle one request at a time to avoid hogging keventd. */ 245 spin_lock_bh(&ctx->lock); 246 req = skcipher_dequeue_givcrypt(&ctx->queue); 247 spin_unlock_bh(&ctx->lock); 248 249 if (!req) { 250 async_chainiv_schedule_work(ctx); 251 return; 252 } 253 254 subreq = skcipher_givcrypt_reqctx(req); 255 subreq->base.flags |= CRYPTO_TFM_REQ_MAY_SLEEP; 256 257 err = async_chainiv_givencrypt_tail(req); 258 259 local_bh_disable(); 260 skcipher_givcrypt_complete(req, err); 261 local_bh_enable(); 262} 263 264static int async_chainiv_init(struct crypto_tfm *tfm) 265{ 266 struct async_chainiv_ctx *ctx = crypto_tfm_ctx(tfm); 267 268 spin_lock_init(&ctx->lock); 269 270 crypto_init_queue(&ctx->queue, 100); 271 INIT_WORK(&ctx->postponed, async_chainiv_do_postponed); 272 273 return chainiv_init_common(tfm); 274} 275 276static void async_chainiv_exit(struct crypto_tfm *tfm) 277{ 278 struct async_chainiv_ctx *ctx = crypto_tfm_ctx(tfm); 279 280 BUG_ON(test_bit(CHAINIV_STATE_INUSE, &ctx->state) || ctx->queue.qlen); 281 282 skcipher_geniv_exit(tfm); 283} 284 285static struct crypto_template chainiv_tmpl; 286 287static struct crypto_instance *chainiv_alloc(struct rtattr **tb) 288{ 289 struct crypto_attr_type *algt; 290 struct crypto_instance *inst; 291 int err; 292 293 algt = crypto_get_attr_type(tb); 294 if (IS_ERR(algt)) 295 return ERR_CAST(algt); 296 297 err = crypto_get_default_rng(); 298 if (err) 299 return ERR_PTR(err); 300 301 inst = skcipher_geniv_alloc(&chainiv_tmpl, tb, 0, 0); 302 if (IS_ERR(inst)) 303 goto put_rng; 304 305 inst->alg.cra_ablkcipher.givencrypt = chainiv_givencrypt_first; 306 307 inst->alg.cra_init = chainiv_init; 308 inst->alg.cra_exit = skcipher_geniv_exit; 309 310 inst->alg.cra_ctxsize = sizeof(struct chainiv_ctx); 311 312 if (!crypto_requires_sync(algt->type, algt->mask)) { 313 inst->alg.cra_flags |= CRYPTO_ALG_ASYNC; 314 315 inst->alg.cra_ablkcipher.givencrypt = 316 async_chainiv_givencrypt_first; 317 318 inst->alg.cra_init = async_chainiv_init; 319 inst->alg.cra_exit = async_chainiv_exit; 320 321 inst->alg.cra_ctxsize = sizeof(struct async_chainiv_ctx); 322 } 323 324 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; 325 326out: 327 return inst; 328 329put_rng: 330 crypto_put_default_rng(); 331 goto out; 332} 333 334static void chainiv_free(struct crypto_instance *inst) 335{ 336 skcipher_geniv_free(inst); 337 crypto_put_default_rng(); 338} 339 340static struct crypto_template chainiv_tmpl = { 341 .name = "chainiv", 342 .alloc = chainiv_alloc, 343 .free = chainiv_free, 344 .module = THIS_MODULE, 345}; 346 347static int __init chainiv_module_init(void) 348{ 349 return crypto_register_template(&chainiv_tmpl); 350} 351 352static void chainiv_module_exit(void) 353{ 354 crypto_unregister_template(&chainiv_tmpl); 355} 356 357module_init(chainiv_module_init); 358module_exit(chainiv_module_exit); 359 360MODULE_LICENSE("GPL"); 361MODULE_DESCRIPTION("Chain IV Generator"); 362MODULE_ALIAS_CRYPTO("chainiv"); 363