blob: 0bae59922a8055d715e5598a34a9479e07a947c4 [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);
Kees Cook064e99d2018-09-18 19:10:51 -070029static struct crypto_sync_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",
Herbert Xud35d2452008-11-08 08:09:56 +0800107 .cra_blocksize = NULL_BLOCK_SIZE,
108 .cra_module = THIS_MODULE,
109 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110};
111
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300112static struct crypto_alg null_algs[3] = { {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 .cra_name = "cipher_null",
114 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
115 .cra_blocksize = NULL_BLOCK_SIZE,
116 .cra_ctxsize = 0,
117 .cra_module = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 .cra_u = { .cipher = {
119 .cia_min_keysize = NULL_KEY_SIZE,
120 .cia_max_keysize = NULL_KEY_SIZE,
121 .cia_setkey = null_setkey,
Patrick McHardyd0856002005-05-16 21:53:41 -0700122 .cia_encrypt = null_crypt,
123 .cia_decrypt = null_crypt } }
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300124}, {
Herbert Xu3631c652007-12-13 22:28:59 +0800125 .cra_name = "ecb(cipher_null)",
126 .cra_driver_name = "ecb-cipher_null",
127 .cra_priority = 100,
128 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
129 .cra_blocksize = NULL_BLOCK_SIZE,
130 .cra_type = &crypto_blkcipher_type,
131 .cra_ctxsize = 0,
132 .cra_module = THIS_MODULE,
Herbert Xu3631c652007-12-13 22:28:59 +0800133 .cra_u = { .blkcipher = {
134 .min_keysize = NULL_KEY_SIZE,
135 .max_keysize = NULL_KEY_SIZE,
136 .ivsize = NULL_IV_SIZE,
137 .setkey = null_setkey,
138 .encrypt = skcipher_null_crypt,
139 .decrypt = skcipher_null_crypt } }
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300140}, {
141 .cra_name = "compress_null",
142 .cra_flags = CRYPTO_ALG_TYPE_COMPRESS,
143 .cra_blocksize = NULL_BLOCK_SIZE,
144 .cra_ctxsize = 0,
145 .cra_module = THIS_MODULE,
146 .cra_u = { .compress = {
147 .coa_compress = null_compress,
148 .coa_decompress = null_compress } }
149} };
Herbert Xu3631c652007-12-13 22:28:59 +0800150
Kees Cook5d26a102014-11-20 17:05:53 -0800151MODULE_ALIAS_CRYPTO("compress_null");
152MODULE_ALIAS_CRYPTO("digest_null");
153MODULE_ALIAS_CRYPTO("cipher_null");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Kees Cook064e99d2018-09-18 19:10:51 -0700155struct crypto_sync_skcipher *crypto_get_default_null_skcipher(void)
Herbert Xu33023462015-05-21 15:11:09 +0800156{
Kees Cook064e99d2018-09-18 19:10:51 -0700157 struct crypto_sync_skcipher *tfm;
Herbert Xu33023462015-05-21 15:11:09 +0800158
159 mutex_lock(&crypto_default_null_skcipher_lock);
160 tfm = crypto_default_null_skcipher;
161
162 if (!tfm) {
Kees Cook064e99d2018-09-18 19:10:51 -0700163 tfm = crypto_alloc_sync_skcipher("ecb(cipher_null)", 0, 0);
Herbert Xu33023462015-05-21 15:11:09 +0800164 if (IS_ERR(tfm))
165 goto unlock;
166
167 crypto_default_null_skcipher = tfm;
168 }
169
170 crypto_default_null_skcipher_refcnt++;
171
172unlock:
173 mutex_unlock(&crypto_default_null_skcipher_lock);
174
175 return tfm;
176}
177EXPORT_SYMBOL_GPL(crypto_get_default_null_skcipher);
178
179void crypto_put_default_null_skcipher(void)
180{
181 mutex_lock(&crypto_default_null_skcipher_lock);
182 if (!--crypto_default_null_skcipher_refcnt) {
Kees Cook064e99d2018-09-18 19:10:51 -0700183 crypto_free_sync_skcipher(crypto_default_null_skcipher);
Herbert Xu33023462015-05-21 15:11:09 +0800184 crypto_default_null_skcipher = NULL;
185 }
186 mutex_unlock(&crypto_default_null_skcipher_lock);
187}
188EXPORT_SYMBOL_GPL(crypto_put_default_null_skcipher);
189
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800190static int __init crypto_null_mod_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
192 int ret = 0;
Richard Hartmannc9af70f2010-02-16 20:31:54 +0800193
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300194 ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 if (ret < 0)
196 goto out;
197
Herbert Xud35d2452008-11-08 08:09:56 +0800198 ret = crypto_register_shash(&digest_null);
Herbert Xu3631c652007-12-13 22:28:59 +0800199 if (ret < 0)
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300200 goto out_unregister_algs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300202 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300204out_unregister_algs:
205 crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
Richard Hartmannc9af70f2010-02-16 20:31:54 +0800206out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 return ret;
208}
209
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800210static void __exit crypto_null_mod_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
Herbert Xud35d2452008-11-08 08:09:56 +0800212 crypto_unregister_shash(&digest_null);
Jussi Kivilinna70a03bf2012-07-11 14:20:00 +0300213 crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
215
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800216module_init(crypto_null_mod_init);
217module_exit(crypto_null_mod_fini);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219MODULE_LICENSE("GPL");
220MODULE_DESCRIPTION("Null Cryptographic Algorithms");