crypto/cbc.c

   1 /*
   2  * CBC: Cipher Block Chaining mode
   3  *
   4  * Copyright (c) 2006-2016 Herbert Xu <herbert@gondor.apana.org.au>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  */
  12
  13 #include <crypto/cbc.h>
  14 #include <crypto/internal/skcipher.h>
  15 #include <linux/err.h>
  16 #include <linux/init.h>
  17 #include <linux/kernel.h>
  18 #include <linux/log2.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21
  22 struct crypto_cbc_ctx {
  23         struct crypto_cipher *child;
  24 };
  25
  26 static int crypto_cbc_setkey(struct crypto_skcipher *parent, const u8 *key,
  27                              unsigned int keylen)
  28 {
  29         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(parent);
  30         struct crypto_cipher *child = ctx->child;
  31         int err;
  32
  33         crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
  34         crypto_cipher_set_flags(child, crypto_skcipher_get_flags(parent) &
  35                                        CRYPTO_TFM_REQ_MASK);
  36         err = crypto_cipher_setkey(child, key, keylen);
  37         crypto_skcipher_set_flags(parent, crypto_cipher_get_flags(child) &
  38                                           CRYPTO_TFM_RES_MASK);
  39         return err;
  40 }
  41
  42 static inline void crypto_cbc_encrypt_one(struct crypto_skcipher *tfm,
  43                                           const u8 *src, u8 *dst)
  44 {
  45         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
  46
  47         crypto_cipher_encrypt_one(ctx->child, dst, src);
  48 }
  49
  50 static int crypto_cbc_encrypt(struct skcipher_request *req)
  51 {
  52         return crypto_cbc_encrypt_walk(req, crypto_cbc_encrypt_one);
  53 }
  54
  55 static inline void crypto_cbc_decrypt_one(struct crypto_skcipher *tfm,
  56                                           const u8 *src, u8 *dst)
  57 {
  58         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
  59
  60         crypto_cipher_decrypt_one(ctx->child, dst, src);
  61 }
  62
  63 static int crypto_cbc_decrypt(struct skcipher_request *req)
  64 {
  65         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  66         struct skcipher_walk walk;
  67         int err;
  68
  69         err = skcipher_walk_virt(&walk, req, false);
  70
  71         while (walk.nbytes) {
  72                 err = crypto_cbc_decrypt_blocks(&walk, tfm,
  73                                                 crypto_cbc_decrypt_one);
  74                 err = skcipher_walk_done(&walk, err);
  75         }
  76
  77         return err;
  78 }
  79
  80 static int crypto_cbc_init_tfm(struct crypto_skcipher *tfm)
  81 {
  82         struct skcipher_instance *inst = skcipher_alg_instance(tfm);
  83         struct crypto_spawn *spawn = skcipher_instance_ctx(inst);
  84         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
  85         struct crypto_cipher *cipher;
  86
  87         cipher = crypto_spawn_cipher(spawn);
  88         if (IS_ERR(cipher))
  89                 return PTR_ERR(cipher);
  90
  91         ctx->child = cipher;
  92         return 0;
  93 }
  94
  95 static void crypto_cbc_exit_tfm(struct crypto_skcipher *tfm)
  96 {
  97         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
  98
  99         crypto_free_cipher(ctx->child);
 100 }
 101
 102 static void crypto_cbc_free(struct skcipher_instance *inst)
 103 {
 104         crypto_drop_skcipher(skcipher_instance_ctx(inst));
 105         kfree(inst);
 106 }
 107
 108 static int crypto_cbc_create(struct crypto_template *tmpl, struct rtattr **tb)
 109 {
 110         struct skcipher_instance *inst;
 111         struct crypto_spawn *spawn;
 112         struct crypto_alg *alg;
 113         int err;
 114
 115         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER);
 116         if (err)
 117                 return err;
 118
 119         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
 120         if (!inst)
 121                 return -ENOMEM;
 122
 123         alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
 124                                   CRYPTO_ALG_TYPE_MASK);
 125         err = PTR_ERR(alg);
 126         if (IS_ERR(alg))
 127                 goto err_free_inst;
 128
 129         spawn = skcipher_instance_ctx(inst);
 130         err = crypto_init_spawn(spawn, alg, skcipher_crypto_instance(inst),
 131                                 CRYPTO_ALG_TYPE_MASK);
 132         crypto_mod_put(alg);
 133         if (err)
 134                 goto err_free_inst;
 135
 136         err = crypto_inst_setname(skcipher_crypto_instance(inst), "cbc", alg);
 137         if (err)
 138                 goto err_drop_spawn;
 139
 140         err = -EINVAL;
 141         if (!is_power_of_2(alg->cra_blocksize))
 142                 goto err_drop_spawn;
 143
 144         inst->alg.base.cra_priority = alg->cra_priority;
 145         inst->alg.base.cra_blocksize = alg->cra_blocksize;
 146         inst->alg.base.cra_alignmask = alg->cra_alignmask;
 147
 148         /* We access the data as u32s when xoring. */
 149         inst->alg.base.cra_alignmask |= __alignof__(u32) - 1;
 150
 151         inst->alg.ivsize = alg->cra_blocksize;
 152         inst->alg.min_keysize = alg->cra_cipher.cia_min_keysize;
 153         inst->alg.max_keysize = alg->cra_cipher.cia_max_keysize;
 154
 155         inst->alg.base.cra_ctxsize = sizeof(struct crypto_cbc_ctx);
 156
 157         inst->alg.init = crypto_cbc_init_tfm;
 158         inst->alg.exit = crypto_cbc_exit_tfm;
 159
 160         inst->alg.setkey = crypto_cbc_setkey;
 161         inst->alg.encrypt = crypto_cbc_encrypt;
 162         inst->alg.decrypt = crypto_cbc_decrypt;
 163
 164         inst->free = crypto_cbc_free;
 165
 166         err = skcipher_register_instance(tmpl, inst);
 167         if (err)
 168                 goto err_drop_spawn;
 169
 170 out:
 171         return err;
 172
 173 err_drop_spawn:
 174         crypto_drop_spawn(spawn);
 175 err_free_inst:
 176         kfree(inst);
 177         goto out;
 178 }
 179
 180 static struct crypto_template crypto_cbc_tmpl = {
 181         .name = "cbc",
 182         .create = crypto_cbc_create,
 183         .module = THIS_MODULE,
 184 };
 185
 186 static int __init crypto_cbc_module_init(void)
 187 {
 188         return crypto_register_template(&crypto_cbc_tmpl);
 189 }
 190
 191 static void __exit crypto_cbc_module_exit(void)
 192 {
 193         crypto_unregister_template(&crypto_cbc_tmpl);
 194 }
 195
 196 module_init(crypto_cbc_module_init);
 197 module_exit(crypto_cbc_module_exit);
 198
 199 MODULE_LICENSE("GPL");
 200 MODULE_DESCRIPTION("CBC block cipher algorithm");
 201 MODULE_ALIAS_CRYPTO("cbc");