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