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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.