1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * ECB: Electronic CodeBook mode
5 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
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>
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
*))
20 const unsigned int bsize
= crypto_cipher_blocksize(cipher
);
22 while (nbytes
>= bsize
) {
23 fn(crypto_cipher_tfm(cipher
), dst
, src
);
31 return nbytes
&& final
? -EINVAL
: nbytes
;
34 static int crypto_ecb_encrypt2(struct crypto_lskcipher
*tfm
, const u8
*src
,
35 u8
*dst
, unsigned len
, u8
*iv
, bool final
)
37 struct crypto_cipher
**ctx
= crypto_lskcipher_ctx(tfm
);
38 struct crypto_cipher
*cipher
= *ctx
;
40 return crypto_ecb_crypt(cipher
, src
, dst
, len
, final
,
41 crypto_cipher_alg(cipher
)->cia_encrypt
);
44 static int crypto_ecb_decrypt2(struct crypto_lskcipher
*tfm
, const u8
*src
,
45 u8
*dst
, unsigned len
, u8
*iv
, bool final
)
47 struct crypto_cipher
**ctx
= crypto_lskcipher_ctx(tfm
);
48 struct crypto_cipher
*cipher
= *ctx
;
50 return crypto_ecb_crypt(cipher
, src
, dst
, len
, final
,
51 crypto_cipher_alg(cipher
)->cia_decrypt
);
54 static int lskcipher_setkey_simple2(struct crypto_lskcipher
*tfm
,
55 const u8
*key
, unsigned int keylen
)
57 struct crypto_cipher
**ctx
= crypto_lskcipher_ctx(tfm
);
58 struct crypto_cipher
*cipher
= *ctx
;
60 crypto_cipher_clear_flags(cipher
, CRYPTO_TFM_REQ_MASK
);
61 crypto_cipher_set_flags(cipher
, crypto_lskcipher_get_flags(tfm
) &
63 return crypto_cipher_setkey(cipher
, key
, keylen
);
66 static int lskcipher_init_tfm_simple2(struct crypto_lskcipher
*tfm
)
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
;
73 spawn
= lskcipher_instance_ctx(inst
);
74 cipher
= crypto_spawn_cipher(spawn
);
76 return PTR_ERR(cipher
);
82 static void lskcipher_exit_tfm_simple2(struct crypto_lskcipher
*tfm
)
84 struct crypto_cipher
**ctx
= crypto_lskcipher_ctx(tfm
);
86 crypto_free_cipher(*ctx
);
89 static void lskcipher_free_instance_simple2(struct lskcipher_instance
*inst
)
91 crypto_drop_cipher(lskcipher_instance_ctx(inst
));
95 static struct lskcipher_instance
*lskcipher_alloc_instance_simple2(
96 struct crypto_template
*tmpl
, struct rtattr
**tb
)
98 struct crypto_cipher_spawn
*spawn
;
99 struct lskcipher_instance
*inst
;
100 struct crypto_alg
*cipher_alg
;
104 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_LSKCIPHER
, &mask
);
108 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
110 return ERR_PTR(-ENOMEM
);
111 spawn
= lskcipher_instance_ctx(inst
);
113 err
= crypto_grab_cipher(spawn
, lskcipher_crypto_instance(inst
),
114 crypto_attr_alg_name(tb
[1]), 0, mask
);
117 cipher_alg
= crypto_spawn_cipher_alg(spawn
);
119 err
= crypto_inst_setname(lskcipher_crypto_instance(inst
), tmpl
->name
,
124 inst
->free
= lskcipher_free_instance_simple2
;
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
;
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
;
143 lskcipher_free_instance_simple2(inst
);
147 static int crypto_ecb_create2(struct crypto_template
*tmpl
, struct rtattr
**tb
)
149 struct lskcipher_instance
*inst
;
152 inst
= lskcipher_alloc_instance_simple2(tmpl
, tb
);
154 return PTR_ERR(inst
);
156 /* ECB mode doesn't take an IV */
157 inst
->alg
.co
.ivsize
= 0;
159 inst
->alg
.encrypt
= crypto_ecb_encrypt2
;
160 inst
->alg
.decrypt
= crypto_ecb_decrypt2
;
162 err
= lskcipher_register_instance(tmpl
, inst
);
169 static int crypto_ecb_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
171 struct crypto_lskcipher_spawn
*spawn
;
172 struct lskcipher_alg
*cipher_alg
;
173 struct lskcipher_instance
*inst
;
176 inst
= lskcipher_alloc_instance_simple(tmpl
, tb
);
178 err
= crypto_ecb_create2(tmpl
, tb
);
182 spawn
= lskcipher_instance_ctx(inst
);
183 cipher_alg
= crypto_lskcipher_spawn_alg(spawn
);
185 /* ECB mode doesn't take an IV */
186 inst
->alg
.co
.ivsize
= 0;
187 if (cipher_alg
->co
.ivsize
)
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
;
197 err
= lskcipher_register_instance(tmpl
, inst
);
204 static struct crypto_template crypto_ecb_tmpl
= {
206 .create
= crypto_ecb_create
,
207 .module
= THIS_MODULE
,
210 static int __init
crypto_ecb_module_init(void)
212 return crypto_register_template(&crypto_ecb_tmpl
);
215 static void __exit
crypto_ecb_module_exit(void)
217 crypto_unregister_template(&crypto_ecb_tmpl
);
220 subsys_initcall(crypto_ecb_module_init
);
221 module_exit(crypto_ecb_module_exit
);
223 MODULE_LICENSE("GPL");
224 MODULE_DESCRIPTION("ECB block cipher mode of operation");
225 MODULE_ALIAS_CRYPTO("ecb");
226 MODULE_IMPORT_NS(CRYPTO_INTERNAL
);