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(tfm: cipher); |
21 | |
22 | while (nbytes >= bsize) { |
23 | fn(crypto_cipher_tfm(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, nbytes: len, final, |
41 | fn: crypto_cipher_alg(tfm: 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, nbytes: len, final, |
51 | fn: crypto_cipher_alg(tfm: 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(tfm: cipher, CRYPTO_TFM_REQ_MASK); |
61 | crypto_cipher_set_flags(tfm: cipher, flags: crypto_lskcipher_get_flags(tfm) & |
62 | CRYPTO_TFM_REQ_MASK); |
63 | return crypto_cipher_setkey(tfm: 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(lskcipher: 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(ptr: cipher)) |
76 | return PTR_ERR(ptr: 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(tfm: *ctx); |
87 | } |
88 | |
89 | static void lskcipher_free_instance_simple2(struct lskcipher_instance *inst) |
90 | { |
91 | crypto_drop_cipher(spawn: lskcipher_instance_ctx(inst)); |
92 | kfree(objp: 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_ret: &mask); |
105 | if (err) |
106 | return ERR_PTR(error: err); |
107 | |
108 | inst = kzalloc(size: sizeof(*inst) + sizeof(*spawn), GFP_KERNEL); |
109 | if (!inst) |
110 | return ERR_PTR(error: -ENOMEM); |
111 | spawn = lskcipher_instance_ctx(inst); |
112 | |
113 | err = crypto_grab_cipher(spawn, inst: lskcipher_crypto_instance(inst), |
114 | name: crypto_attr_alg_name(rta: tb[1]), type: 0, mask); |
115 | if (err) |
116 | goto err_free_inst; |
117 | cipher_alg = crypto_spawn_cipher_alg(spawn); |
118 | |
119 | err = crypto_inst_setname(inst: lskcipher_crypto_instance(inst), name: tmpl->name, |
120 | alg: 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(error: 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(ptr: inst)) |
154 | return PTR_ERR(ptr: 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(ptr: 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(tmpl: &crypto_ecb_tmpl); |
213 | } |
214 | |
215 | static void __exit crypto_ecb_module_exit(void) |
216 | { |
217 | crypto_unregister_template(tmpl: &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); |
227 | |