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
16static 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
34static 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
44static 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
54static 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
66static 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
82static 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
89static 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
95static 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
142err_free_inst:
143 lskcipher_free_instance_simple2(inst);
144 return ERR_PTR(error: err);
145}
146
147static 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
169static 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
204static struct crypto_template crypto_ecb_tmpl = {
205 .name = "ecb",
206 .create = crypto_ecb_create,
207 .module = THIS_MODULE,
208};
209
210static int __init crypto_ecb_module_init(void)
211{
212 return crypto_register_template(tmpl: &crypto_ecb_tmpl);
213}
214
215static void __exit crypto_ecb_module_exit(void)
216{
217 crypto_unregister_template(tmpl: &crypto_ecb_tmpl);
218}
219
220subsys_initcall(crypto_ecb_module_init);
221module_exit(crypto_ecb_module_exit);
222
223MODULE_LICENSE("GPL");
224MODULE_DESCRIPTION("ECB block cipher mode of operation");
225MODULE_ALIAS_CRYPTO("ecb");
226MODULE_IMPORT_NS(CRYPTO_INTERNAL);
227

source code of linux/crypto/ecb.c