Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
c9af70fb | 2 | /* |
1da177e4 LT |
3 | * Cryptographic API. |
4 | * | |
5 | * Null algorithms, aka Much Ado About Nothing. | |
6 | * | |
7 | * These are needed for IPsec, and may be useful in general for | |
8 | * testing & debugging. | |
c9af70fb | 9 | * |
1da177e4 LT |
10 | * The null cipher is compliant with RFC2410. |
11 | * | |
12 | * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> | |
1da177e4 | 13 | */ |
3631c650 | 14 | |
72567258 | 15 | #include <crypto/null.h> |
d35d2454 | 16 | #include <crypto/internal/hash.h> |
3631c650 | 17 | #include <crypto/internal/skcipher.h> |
1da177e4 LT |
18 | #include <linux/init.h> |
19 | #include <linux/module.h> | |
20 | #include <linux/mm.h> | |
d0856009 | 21 | #include <linux/string.h> |
1da177e4 | 22 | |
33023463 | 23 | static DEFINE_MUTEX(crypto_default_null_skcipher_lock); |
8d605398 | 24 | static struct crypto_sync_skcipher *crypto_default_null_skcipher; |
33023463 HX |
25 | static int crypto_default_null_skcipher_refcnt; |
26 | ||
6c2bb98b HX |
27 | static int null_compress(struct crypto_tfm *tfm, const u8 *src, |
28 | unsigned int slen, u8 *dst, unsigned int *dlen) | |
d0856009 PM |
29 | { |
30 | if (slen > *dlen) | |
31 | return -EINVAL; | |
32 | memcpy(dst, src, slen); | |
33 | *dlen = slen; | |
34 | return 0; | |
35 | } | |
1da177e4 | 36 | |
d35d2454 HX |
37 | static int null_init(struct shash_desc *desc) |
38 | { | |
39 | return 0; | |
40 | } | |
1da177e4 | 41 | |
d35d2454 HX |
42 | static int null_update(struct shash_desc *desc, const u8 *data, |
43 | unsigned int len) | |
44 | { | |
45 | return 0; | |
46 | } | |
1da177e4 | 47 | |
d35d2454 HX |
48 | static int null_final(struct shash_desc *desc, u8 *out) |
49 | { | |
50 | return 0; | |
51 | } | |
52 | ||
53 | static int null_digest(struct shash_desc *desc, const u8 *data, | |
54 | unsigned int len, u8 *out) | |
55 | { | |
56 | return 0; | |
57 | } | |
58 | ||
59 | static int null_hash_setkey(struct crypto_shash *tfm, const u8 *key, | |
60 | unsigned int keylen) | |
61 | { return 0; } | |
1da177e4 | 62 | |
31d40c20 EB |
63 | static int null_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key, |
64 | unsigned int keylen) | |
65 | { return 0; } | |
66 | ||
6c2bb98b | 67 | static int null_setkey(struct crypto_tfm *tfm, const u8 *key, |
560c06ae | 68 | unsigned int keylen) |
1da177e4 LT |
69 | { return 0; } |
70 | ||
6c2bb98b | 71 | static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) |
d0856009 PM |
72 | { |
73 | memcpy(dst, src, NULL_BLOCK_SIZE); | |
74 | } | |
1da177e4 | 75 | |
31d40c20 | 76 | static int null_skcipher_crypt(struct skcipher_request *req) |
3631c650 | 77 | { |
31d40c20 | 78 | struct skcipher_walk walk; |
3631c650 HX |
79 | int err; |
80 | ||
31d40c20 | 81 | err = skcipher_walk_virt(&walk, req, false); |
3631c650 HX |
82 | |
83 | while (walk.nbytes) { | |
84 | if (walk.src.virt.addr != walk.dst.virt.addr) | |
85 | memcpy(walk.dst.virt.addr, walk.src.virt.addr, | |
86 | walk.nbytes); | |
31d40c20 | 87 | err = skcipher_walk_done(&walk, 0); |
3631c650 HX |
88 | } |
89 | ||
90 | return err; | |
91 | } | |
92 | ||
d35d2454 HX |
93 | static struct shash_alg digest_null = { |
94 | .digestsize = NULL_DIGEST_SIZE, | |
95 | .setkey = null_hash_setkey, | |
96 | .init = null_init, | |
97 | .update = null_update, | |
98 | .finup = null_digest, | |
99 | .digest = null_digest, | |
100 | .final = null_final, | |
101 | .base = { | |
102 | .cra_name = "digest_null", | |
d35d2454 HX |
103 | .cra_blocksize = NULL_BLOCK_SIZE, |
104 | .cra_module = THIS_MODULE, | |
105 | } | |
1da177e4 LT |
106 | }; |
107 | ||
31d40c20 EB |
108 | static struct skcipher_alg skcipher_null = { |
109 | .base.cra_name = "ecb(cipher_null)", | |
110 | .base.cra_driver_name = "ecb-cipher_null", | |
111 | .base.cra_priority = 100, | |
112 | .base.cra_blocksize = NULL_BLOCK_SIZE, | |
113 | .base.cra_ctxsize = 0, | |
114 | .base.cra_module = THIS_MODULE, | |
115 | .min_keysize = NULL_KEY_SIZE, | |
116 | .max_keysize = NULL_KEY_SIZE, | |
117 | .ivsize = NULL_IV_SIZE, | |
118 | .setkey = null_skcipher_setkey, | |
119 | .encrypt = null_skcipher_crypt, | |
120 | .decrypt = null_skcipher_crypt, | |
121 | }; | |
122 | ||
123 | static struct crypto_alg null_algs[] = { { | |
1da177e4 LT |
124 | .cra_name = "cipher_null", |
125 | .cra_flags = CRYPTO_ALG_TYPE_CIPHER, | |
126 | .cra_blocksize = NULL_BLOCK_SIZE, | |
127 | .cra_ctxsize = 0, | |
128 | .cra_module = THIS_MODULE, | |
1da177e4 LT |
129 | .cra_u = { .cipher = { |
130 | .cia_min_keysize = NULL_KEY_SIZE, | |
131 | .cia_max_keysize = NULL_KEY_SIZE, | |
132 | .cia_setkey = null_setkey, | |
d0856009 PM |
133 | .cia_encrypt = null_crypt, |
134 | .cia_decrypt = null_crypt } } | |
70a03bff JK |
135 | }, { |
136 | .cra_name = "compress_null", | |
137 | .cra_flags = CRYPTO_ALG_TYPE_COMPRESS, | |
138 | .cra_blocksize = NULL_BLOCK_SIZE, | |
139 | .cra_ctxsize = 0, | |
140 | .cra_module = THIS_MODULE, | |
141 | .cra_u = { .compress = { | |
142 | .coa_compress = null_compress, | |
143 | .coa_decompress = null_compress } } | |
144 | } }; | |
3631c650 | 145 | |
5d26a105 KC |
146 | MODULE_ALIAS_CRYPTO("compress_null"); |
147 | MODULE_ALIAS_CRYPTO("digest_null"); | |
148 | MODULE_ALIAS_CRYPTO("cipher_null"); | |
1da177e4 | 149 | |
8d605398 | 150 | struct crypto_sync_skcipher *crypto_get_default_null_skcipher(void) |
33023463 | 151 | { |
8d605398 | 152 | struct crypto_sync_skcipher *tfm; |
33023463 HX |
153 | |
154 | mutex_lock(&crypto_default_null_skcipher_lock); | |
155 | tfm = crypto_default_null_skcipher; | |
156 | ||
157 | if (!tfm) { | |
8d605398 | 158 | tfm = crypto_alloc_sync_skcipher("ecb(cipher_null)", 0, 0); |
33023463 HX |
159 | if (IS_ERR(tfm)) |
160 | goto unlock; | |
161 | ||
162 | crypto_default_null_skcipher = tfm; | |
163 | } | |
164 | ||
165 | crypto_default_null_skcipher_refcnt++; | |
166 | ||
167 | unlock: | |
168 | mutex_unlock(&crypto_default_null_skcipher_lock); | |
169 | ||
170 | return tfm; | |
171 | } | |
172 | EXPORT_SYMBOL_GPL(crypto_get_default_null_skcipher); | |
173 | ||
174 | void crypto_put_default_null_skcipher(void) | |
175 | { | |
176 | mutex_lock(&crypto_default_null_skcipher_lock); | |
177 | if (!--crypto_default_null_skcipher_refcnt) { | |
8d605398 | 178 | crypto_free_sync_skcipher(crypto_default_null_skcipher); |
33023463 HX |
179 | crypto_default_null_skcipher = NULL; |
180 | } | |
181 | mutex_unlock(&crypto_default_null_skcipher_lock); | |
182 | } | |
183 | EXPORT_SYMBOL_GPL(crypto_put_default_null_skcipher); | |
184 | ||
3af5b90b | 185 | static int __init crypto_null_mod_init(void) |
1da177e4 LT |
186 | { |
187 | int ret = 0; | |
c9af70fb | 188 | |
70a03bff | 189 | ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs)); |
1da177e4 LT |
190 | if (ret < 0) |
191 | goto out; | |
192 | ||
d35d2454 | 193 | ret = crypto_register_shash(&digest_null); |
3631c650 | 194 | if (ret < 0) |
70a03bff | 195 | goto out_unregister_algs; |
1da177e4 | 196 | |
31d40c20 EB |
197 | ret = crypto_register_skcipher(&skcipher_null); |
198 | if (ret < 0) | |
199 | goto out_unregister_shash; | |
200 | ||
70a03bff | 201 | return 0; |
1da177e4 | 202 | |
31d40c20 EB |
203 | out_unregister_shash: |
204 | crypto_unregister_shash(&digest_null); | |
70a03bff JK |
205 | out_unregister_algs: |
206 | crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs)); | |
c9af70fb | 207 | out: |
1da177e4 LT |
208 | return ret; |
209 | } | |
210 | ||
3af5b90b | 211 | static void __exit crypto_null_mod_fini(void) |
1da177e4 | 212 | { |
70a03bff | 213 | crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs)); |
31d40c20 EB |
214 | crypto_unregister_shash(&digest_null); |
215 | crypto_unregister_skcipher(&skcipher_null); | |
1da177e4 LT |
216 | } |
217 | ||
c4741b23 | 218 | subsys_initcall(crypto_null_mod_init); |
3af5b90b | 219 | module_exit(crypto_null_mod_fini); |
1da177e4 LT |
220 | |
221 | MODULE_LICENSE("GPL"); | |
222 | MODULE_DESCRIPTION("Null Cryptographic Algorithms"); |