linux/crypto/chainiv.c
<<
val
val >> v
v val
val val val
v val Prefs v al
al
v al
al
al
al
al
   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
  15 * 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_clear_bit();
 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;
 2" class="lihref="+code=geniv" class="sref">gei2" class="line" name="L192"> 19293a>        algt;
 crypto_att_bytr_type" a>(tb)
< 1929/a>        err = erPTR_ERRa>(algt;
< 192           (erIS_ERRa>(algt;
< 1929/a>        st      return alERR_PTRa>(err);
 1929/a>
 1929/a>        err = crypto_det_byfault_rng" a>();
 1929/a>        if (!< href="+code=tfr" class="sref">err);
a href="crypto/chainiv.c#L263" id="L203" class="line" name="L203"> 2030/a>                alERR_PTRa>(err);
 203
 2030/a>        inst;
 chcipher_givev_alloc" a>(&chainiv_tmpl;
tb)
, 0, 0
 20303a>           (erIS_ERRa>(inst;
< 2030/a>                  to crsurng" a>;
 2030/a>
 2030/a>        inst;
gt;algt.crypablkcipher *a href="+code=qlvencrypt" class="sref">givencrypt = asainiv_givencrypt_first)
 203
 2030/a>        inst;
gt;algt.spcrabit" a> = spciniv_init(s 2030/a>        inst;
gt;algt.skcrabit" a>;
 skcipher_geniv_exit(< 2131/a>
 2131/a>        inst;
gt;algt.crypabctxze" a>;
 asainiv_ctx *
 2131lass="lihref="+code=geniv" class=3" id="L213" class="line" name="L213"> 21313a>           (crypto_dequesires_nc_ca>(algt;
gt;crpe" a>(<algt;
gt;lomas a>;
<<
 2131/a>                   href="+code=INst" class="sref">inst;
gt;algt.flcrabags" a>    CHAPTO_TFALG_ASYNCa>(< 2131/a>
 2131/a>        st      re href="+code=rest" class="sref">inst;
gt;algt.crypablkcipher *a href="+code=qlvencrypt" class="sref">givencrypt =  213        if      st      re href="+code=reync_chainiv_givencrypt_first" class="sref">async_chainiv_givencrypt_first)
 2131/a>
 213                go href="+code=spst" class="sref">inst;
gt;algt.spcrabit" a> = async_chainiv_init(s 2232/a>                inst;
gt;algt.skcrabit" a>;
 async_chainiv_exit(s 2232/a>
 223        inst;
gt;algt.crypabctxze" a>;
 async_chainiv_ctx *
 223           223
 2232/a>        inst;
gt;algt.crypabctxze" a>;
 +inst;
gt;algt.crypablkcipher *a href="+code=qlsize" class="sref">ivsize); 2232/a>
 2232/a>out:
 223        ifturn inst;
 2232/a>
 233
< href="+code=posurng" class="sref">crsurng" a>;
 2333/a>        crypto_desurnfault_rng" a>();
 233        reto out;
 233}
 233
 233static void cryiniv_ctfre a>();ruct crypto_instance *inst;
 233{
 2333/a>        criipher_geniv_exfre a>(inst;
< 2333/a>        crypto_desurnfault_rng" a>();
 2333/a>}
 2434/a>
 2434/a>static inruct crypto_template chainiv_tmpl;
  243        ina href="+code=nbye="class="sref">chye="a>;
 "ainiv.c"span>
< 24343a>        ina href="+code=nbloc" class="sref">chloc" a>(& chainiv_alloc(s 243        crfre a>(< cryiniv_ctfre a>() 243        lomole_wa>(< CHTHIS_MODUL a>() 243  } 2434/a>
 2434/a>static int as_bit" a> =  href="+code=asainiv_gimole_wiit" class="sref">spciniv_inmole_wiit" a>();id < 2434/a>{
 253          turn crypto_tequgist_gemplate" a>(&chainiv_tmpl;

 253   2535lass="lihref="+code=geniv" class=3" id="L253" class="line" name="L253"> 253
skciniv_ctmole_wiit" a>();id < 253   253        crypto_teunqugist_gemplate" a>(&chainiv_tmpl;

 2535/a>}
 2535/a>
 253
< href="+code=flmole_wiit" class="sref">spmole_wiit" a>(); href="+code=asainiv_gimole_wiit" class="sref">spciniv_inmole_wiit" a>()
 253   href="+code=flmole_wiit" class="sref">skmole_wiit" a>(); href="+code=asainiv_ctmole_wiit" class="sref">skciniv_ctmole_wiit" a>()
 2636/a>
 2636/a>CHMODUL _LICEN" a>(); an class="coruci" c>"GPL"span>
<
 263}
 href="+code=ouMODUL _DESCRIPTI" class="sref">BUMODUL _DESCRIPTI" a>(); an class="coruci" c>"Ciniv IV Generator"span>
<
 263
<


The original LXR software by the href="crhttp://sourceforge.net/projects/lxg">LXR mmonut" ya>(<al version by href="crmailto:lxg@ne"ux.no">lxg@ne"ux.noa> *a
lxg.ne"ux.no kind hanost_d by href="crhttp://www.redpill-ne"pro.no">Redpill Le"pro ASa>(<