blob: 20ff2c746e0ba220a192dc460194b97de0cc0702 [file] [log] [blame]
Richard Hartmannc9af70f2010-02-16 20:31:54 +08001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Cryptographic API.
3 *
4 * Null algorithms, aka Much Ado About Nothing.
5 *
6 * These are needed for IPsec, and may be useful in general for
7 * testing & debugging.
Richard Hartmannc9af70f2010-02-16 20:31:54 +08008 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * The null cipher is compliant with RFC2410.
10 *
11 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 */
Herbert Xu3631c652007-12-13 22:28:59 +080019
Horia Geanta72567252014-03-14 17:46:50 +020020#include <crypto/null.h>
Herbert Xud35d2452008-11-08 08:09:56 +080021#include <crypto/internal/hash.h>
Herbert Xu3631c652007-12-13 22:28:59 +080022#include <crypto/internal/skcipher.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/init.h>
24#include <linux/module.h>
25#include <linux/mm.h>
Patrick McHardyd0856002005-05-16 21:53:41 -070026#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Herbert Xu33023462015-05-21 15:11:09 +080028static DEFINE_MUTEX(crypto_default_null_skcipher_lock);
Herbert Xu499a66e2016-07-12 13:17:47 +080029static struct crypto_skcipher *crypto_default_null_skcipher;
Herbert Xu33023462015-05-21 15:11:09 +080030static int crypto_default_null_skcipher_refcnt;
31
Herbert Xu6c2bb982006-05-16 22:09:29 +100032static int null_compress(struct crypto_tfm *tfm, const u8 *src,
33 unsigned int slen, u8 *dst, unsigned int *dlen)
Patrick McHardyd0856002005-05-16 21:53:41 -070034{
35 if (slen > *dlen)
36 return -EINVAL;
37 memcpy(dst, src, slen);
38 *dlen = slen;
39 return 0;
40}
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Herbert Xud35d2452008-11-08 08:09:56 +080042static int null_init(struct shash_desc *desc)
43{
44 return 0;
45}
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Herbert Xud35d2452008-11-08 08:09:56 +080047static int null_update(struct shash_desc *desc, const u8 *data,
48 unsigned int len)
49{
50 return 0;
51}
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Herbert Xud35d2452008-11-08 08:09:56 +080053static int null_final(struct shash_desc *desc, u8 *out)
54{
55 return 0;
56}
57
58static int null_digest(struct shash_desc *desc, const u8 *data,
59 unsigned int len, u8 *out)
60{
61 return 0;
62}
63
64static int null_hash_setkey(struct crypto_shash *tfm, const u8 *key,
65 unsigned int keylen)
66{ return 0; }
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Herbert Xu6c2bb982006-05-16 22:09:29 +100068static int null_setkey(struct crypto_tfm *tfm, const u8 *key,
Herbert Xu560c06a2006-08-13 14:16:39 +100069 unsigned int keylen)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{ return 0; }
71
Herbert Xu6c2bb982006-05-16 22:09:29 +100072static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
Patrick McHardyd0856002005-05-16 21:53:41 -070073{
74 memcpy(dst, src, NULL_BLOCK_SIZE);
75}
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Herbert Xu3631c652007-12-13 22:28:59 +080077static int skcipher_null_crypt(struct blkcipher_desc *desc,
78 struct scatterlist *dst,
79 struct scatterlist *src, unsigned int nbytes)
80{
81 struct blkcipher_walk walk;
82 int err;
83
84 blkcipher_walk_init(&walk, dst, src, nbytes);
85 err = blkcipher_walk_virt(desc, &walk);
86
87 while (walk.nbytes) {
88 if (walk.src.virt.addr != walk.dst.virt.addr)
89 memcpy(walk.dst.virt.addr, walk.src.virt.addr,
90 walk.nbytes);
91 err = blkcipher_walk_done(desc, &walk, 0);
92 }
93
94 return err;
95}
96
Herbert Xud35d2452008-11-08 08:09:56 +080097static struct shash_alg digest_null = {
98 .digestsize = NULL_DIGEST_SIZE,
99 .setkey = null_hash_setkey,
100 .init = null_init,
101 .update = null_update,
102 .finup = null_digest,
103 .digest = null_digest,
104 .final = null_final,
105 .base = {
106 .cra_name = "digest_null",
107 .cra_flags = CRYPTO_ALG_TYPE_SHASH,
108 .cra_blocksize = NULL_BLOCK_SIZE,
109 .cra_module = THIS_MODULE,
110 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111};
112
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300113static struct crypto_alg null_algs[3] = { {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 .cra_name = "cipher_null",
115 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
116 .cra_blocksize = NULL_BLOCK_SIZE,
117 .cra_ctxsize = 0,
118 .cra_module = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 .cra_u = { .cipher = {
120 .cia_min_keysize = NULL_KEY_SIZE,
121 .cia_max_keysize = NULL_KEY_SIZE,
122 .cia_setkey = null_setkey,
Patrick McHardyd0856002005-05-16 21:53:41 -0700123 .cia_encrypt = null_crypt,
124 .cia_decrypt = null_crypt } }
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300125}, {
Herbert Xu3631c652007-12-13 22:28:59 +0800126 .cra_name = "ecb(cipher_null)",
127 .cra_driver_name = "ecb-cipher_null",
128 .cra_priority = 100,
129 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
130 .cra_blocksize = NULL_BLOCK_SIZE,
131 .cra_type = &crypto_blkcipher_type,
132 .cra_ctxsize = 0,
133 .cra_module = THIS_MODULE,
Herbert Xu3631c652007-12-13 22:28:59 +0800134 .cra_u = { .blkcipher = {
135 .min_keysize = NULL_KEY_SIZE,
136 .max_keysize = NULL_KEY_SIZE,
137 .ivsize = NULL_IV_SIZE,
138 .setkey = null_setkey,
139 .encrypt = skcipher_null_crypt,
140 .decrypt = skcipher_null_crypt } }
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300141}, {
142 .cra_name = "compress_null",
143 .cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
144 .cra_blocksize = NULL_BLOCK_SIZE,
145 .cra_ctxsize = 0,
146 .cra_module = THIS_MODULE,
147 .cra_u = { .compress = {
148 .coa_compress = null_compress,
149 .coa_decompress = null_compress } }
150} };
Herbert Xu3631c652007-12-13 22:28:59 +0800151
Kees Cook5d26a102014-11-20 17:05:53 -0800152MODULE_ALIAS_CRYPTO("compress_null");
153MODULE_ALIAS_CRYPTO("digest_null");
154MODULE_ALIAS_CRYPTO("cipher_null");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Herbert Xu499a66e2016-07-12 13:17:47 +0800156struct crypto_skcipher *crypto_get_default_null_skcipher(void)
Herbert Xu33023462015-05-21 15:11:09 +0800157{
Herbert Xu499a66e2016-07-12 13:17:47 +0800158 struct crypto_skcipher *tfm;
Herbert Xu33023462015-05-21 15:11:09 +0800159
160 mutex_lock(&crypto_default_null_skcipher_lock);
161 tfm = crypto_default_null_skcipher;
162
163 if (!tfm) {
Herbert Xu499a66e2016-07-12 13:17:47 +0800164 tfm = crypto_alloc_skcipher("ecb(cipher_null)",
165 0, CRYPTO_ALG_ASYNC);
Herbert Xu33023462015-05-21 15:11:09 +0800166 if (IS_ERR(tfm))
167 goto unlock;
168
169 crypto_default_null_skcipher = tfm;
170 }
171
172 crypto_default_null_skcipher_refcnt++;
173
174unlock:
175 mutex_unlock(&crypto_default_null_skcipher_lock);
176
177 return tfm;
178}
179EXPORT_SYMBOL_GPL(crypto_get_default_null_skcipher);
180
181void crypto_put_default_null_skcipher(void)
182{
183 mutex_lock(&crypto_default_null_skcipher_lock);
184 if (!--crypto_default_null_skcipher_refcnt) {
Herbert Xu499a66e2016-07-12 13:17:47 +0800185 crypto_free_skcipher(crypto_default_null_skcipher);
Herbert Xu33023462015-05-21 15:11:09 +0800186 crypto_default_null_skcipher = NULL;
187 }
188 mutex_unlock(&crypto_default_null_skcipher_lock);
189}
190EXPORT_SYMBOL_GPL(crypto_put_default_null_skcipher);
191
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800192static int __init crypto_null_mod_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 int ret = 0;
Richard Hartmannc9af70f2010-02-16 20:31:54 +0800195
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300196 ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (ret < 0)
198 goto out;
199
Herbert Xud35d2452008-11-08 08:09:56 +0800200 ret = crypto_register_shash(&digest_null);
Herbert Xu3631c652007-12-13 22:28:59 +0800201 if (ret < 0)
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300202 goto out_unregister_algs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300204 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300206out_unregister_algs:
207 crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
Richard Hartmannc9af70f2010-02-16 20:31:54 +0800208out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 return ret;
210}
211
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800212static void __exit crypto_null_mod_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Herbert Xud35d2452008-11-08 08:09:56 +0800214 crypto_unregister_shash(&digest_null);
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300215 crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800218module_init(crypto_null_mod_init);
219module_exit(crypto_null_mod_fini);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221MODULE_LICENSE("GPL");
222MODULE_DESCRIPTION("Null Cryptographic Algorithms");