crypto/ecb.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * ECB: Electronic CodeBook mode
   4  *
   5  * Copyright (c) 2006 Herbert Xu <[email protected]>
   6  */
   7
   8 #include <crypto/internal/cipher.h>
   9 #include <crypto/internal/skcipher.h>
  10 #include <linux/err.h>
  11 #include <linux/init.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15
  16 static int crypto_ecb_crypt(struct crypto_cipher *cipher, const u8 *src,
  17                             u8 *dst, unsigned nbytes, bool final,
  18                             void (*fn)(struct crypto_tfm *, u8 *, const u8 *))
  19 {
  20         const unsigned int bsize = crypto_cipher_blocksize(cipher);
  21
  22         while (nbytes >= bsize) {
  23                 fn(crypto_cipher_tfm(cipher), dst, src);
  24
  25                 src += bsize;
  26                 dst += bsize;
  27
  28                 nbytes -= bsize;
  29         }
  30
  31         return nbytes && final ? -EINVAL : nbytes;
  32 }
  33
  34 static int crypto_ecb_encrypt2(struct crypto_lskcipher *tfm, const u8 *src,
  35                                u8 *dst, unsigned len, u8 *iv, bool final)
  36 {
  37         struct crypto_cipher **ctx = crypto_lskcipher_ctx(tfm);
  38         struct crypto_cipher *cipher = *ctx;
  39
  40         return crypto_ecb_crypt(cipher, src, dst, len, final,
  41                                 crypto_cipher_alg(cipher)->cia_encrypt);
  42 }
  43
  44 static int crypto_ecb_decrypt2(struct crypto_lskcipher *tfm, const u8 *src,
  45                                u8 *dst, unsigned len, u8 *iv, bool final)
  46 {
  47         struct crypto_cipher **ctx = crypto_lskcipher_ctx(tfm);
  48         struct crypto_cipher *cipher = *ctx;
  49
  50         return crypto_ecb_crypt(cipher, src, dst, len, final,
  51                                 crypto_cipher_alg(cipher)->cia_decrypt);
  52 }
  53
  54 static int lskcipher_setkey_simple2(struct crypto_lskcipher *tfm,
  55                                     const u8 *key, unsigned int keylen)
  56 {
  57         struct crypto_cipher **ctx = crypto_lskcipher_ctx(tfm);
  58         struct crypto_cipher *cipher = *ctx;
  59
  60         crypto_cipher_clear_flags(cipher, CRYPTO_TFM_REQ_MASK);
  61         crypto_cipher_set_flags(cipher, crypto_lskcipher_get_flags(tfm) &
  62                                 CRYPTO_TFM_REQ_MASK);
  63         return crypto_cipher_setkey(cipher, key, keylen);
  64 }
  65
  66 static int lskcipher_init_tfm_simple2(struct crypto_lskcipher *tfm)
  67 {
  68         struct lskcipher_instance *inst = lskcipher_alg_instance(tfm);
  69         struct crypto_cipher **ctx = crypto_lskcipher_ctx(tfm);
  70         struct crypto_cipher_spawn *spawn;
  71         struct crypto_cipher *cipher;
  72
  73         spawn = lskcipher_instance_ctx(inst);
  74         cipher = crypto_spawn_cipher(spawn);
  75         if (IS_ERR(cipher))
  76                 return PTR_ERR(cipher);
  77
  78         *ctx = cipher;
  79         return 0;
  80 }
  81
  82 static void lskcipher_exit_tfm_simple2(struct crypto_lskcipher *tfm)
  83 {
  84         struct crypto_cipher **ctx = crypto_lskcipher_ctx(tfm);
  85
  86         crypto_free_cipher(*ctx);
  87 }
  88
  89 static void lskcipher_free_instance_simple2(struct lskcipher_instance *inst)
  90 {
  91         crypto_drop_cipher(lskcipher_instance_ctx(inst));
  92         kfree(inst);
  93 }
  94
  95 static struct lskcipher_instance *lskcipher_alloc_instance_simple2(
  96         struct crypto_template *tmpl, struct rtattr **tb)
  97 {
  98         struct crypto_cipher_spawn *spawn;
  99         struct lskcipher_instance *inst;
 100         struct crypto_alg *cipher_alg;
 101         u32 mask;
 102         int err;
 103
 104         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_LSKCIPHER, &mask);
 105         if (err)
 106                 return ERR_PTR(err);
 107
 108         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
 109         if (!inst)
 110                 return ERR_PTR(-ENOMEM);
 111         spawn = lskcipher_instance_ctx(inst);
 112
 113         err = crypto_grab_cipher(spawn, lskcipher_crypto_instance(inst),
 114                                  crypto_attr_alg_name(tb[1]), 0, mask);
 115         if (err)
 116                 goto err_free_inst;
 117         cipher_alg = crypto_spawn_cipher_alg(spawn);
 118
 119         err = crypto_inst_setname(lskcipher_crypto_instance(inst), tmpl->name,
 120                                   cipher_alg);
 121         if (err)
 122                 goto err_free_inst;
 123
 124         inst->free = lskcipher_free_instance_simple2;
 125
 126         /* Default algorithm properties, can be overridden */
 127         inst->alg.co.base.cra_blocksize = cipher_alg->cra_blocksize;
 128         inst->alg.co.base.cra_alignmask = cipher_alg->cra_alignmask;
 129         inst->alg.co.base.cra_priority = cipher_alg->cra_priority;
 130         inst->alg.co.min_keysize = cipher_alg->cra_cipher.cia_min_keysize;
 131         inst->alg.co.max_keysize = cipher_alg->cra_cipher.cia_max_keysize;
 132         inst->alg.co.ivsize = cipher_alg->cra_blocksize;
 133
 134         /* Use struct crypto_cipher * by default, can be overridden */
 135         inst->alg.co.base.cra_ctxsize = sizeof(struct crypto_cipher *);
 136         inst->alg.setkey = lskcipher_setkey_simple2;
 137         inst->alg.init = lskcipher_init_tfm_simple2;
 138         inst->alg.exit = lskcipher_exit_tfm_simple2;
 139
 140         return inst;
 141
 142 err_free_inst:
 143         lskcipher_free_instance_simple2(inst);
 144         return ERR_PTR(err);
 145 }
 146
 147 static int crypto_ecb_create2(struct crypto_template *tmpl, struct rtattr **tb)
 148 {
 149         struct lskcipher_instance *inst;
 150         int err;
 151
 152         inst = lskcipher_alloc_instance_simple2(tmpl, tb);
 153         if (IS_ERR(inst))
 154                 return PTR_ERR(inst);
 155
 156         /* ECB mode doesn't take an IV */
 157         inst->alg.co.ivsize = 0;
 158
 159         inst->alg.encrypt = crypto_ecb_encrypt2;
 160         inst->alg.decrypt = crypto_ecb_decrypt2;
 161
 162         err = lskcipher_register_instance(tmpl, inst);
 163         if (err)
 164                 inst->free(inst);
 165
 166         return err;
 167 }
 168
 169 static int crypto_ecb_create(struct crypto_template *tmpl, struct rtattr **tb)
 170 {
 171         struct crypto_lskcipher_spawn *spawn;
 172         struct lskcipher_alg *cipher_alg;
 173         struct lskcipher_instance *inst;
 174         int err;
 175
 176         inst = lskcipher_alloc_instance_simple(tmpl, tb);
 177         if (IS_ERR(inst)) {
 178                 err = crypto_ecb_create2(tmpl, tb);
 179                 return err;
 180         }
 181
 182         spawn = lskcipher_instance_ctx(inst);
 183         cipher_alg = crypto_lskcipher_spawn_alg(spawn);
 184
 185         /* ECB mode doesn't take an IV */
 186         inst->alg.co.ivsize = 0;
 187         if (cipher_alg->co.ivsize)
 188                 return -EINVAL;
 189
 190         inst->alg.co.base.cra_ctxsize = cipher_alg->co.base.cra_ctxsize;
 191         inst->alg.setkey = cipher_alg->setkey;
 192         inst->alg.encrypt = cipher_alg->encrypt;
 193         inst->alg.decrypt = cipher_alg->decrypt;
 194         inst->alg.init = cipher_alg->init;
 195         inst->alg.exit = cipher_alg->exit;
 196
 197         err = lskcipher_register_instance(tmpl, inst);
 198         if (err)
 199                 inst->free(inst);
 200
 201         return err;
 202 }
 203
 204 static struct crypto_template crypto_ecb_tmpl = {
 205         .name = "ecb",
 206         .create = crypto_ecb_create,
 207         .module = THIS_MODULE,
 208 };
 209
 210 static int __init crypto_ecb_module_init(void)
 211 {
 212         return crypto_register_template(&crypto_ecb_tmpl);
 213 }
 214
 215 static void __exit crypto_ecb_module_exit(void)
 216 {
 217         crypto_unregister_template(&crypto_ecb_tmpl);
 218 }
 219
 220 subsys_initcall(crypto_ecb_module_init);
 221 module_exit(crypto_ecb_module_exit);
 222
 223 MODULE_LICENSE("GPL");
 224 MODULE_DESCRIPTION("ECB block cipher mode of operation");
 225 MODULE_ALIAS_CRYPTO("ecb");
 226 MODULE_IMPORT_NS(CRYPTO_INTERNAL);