]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - crypto/crypto_null.c
Merge tag 'platform-drivers-x86-v4.2-2' of git://git.infradead.org/users/dvhart/linux...
[mirror_ubuntu-zesty-kernel.git] / crypto / crypto_null.c
CommitLineData
c9af70fb 1/*
1da177e4
LT
2 * 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.
c9af70fb 8 *
1da177e4
LT
9 * 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 */
3631c650 19
72567258 20#include <crypto/null.h>
d35d2454 21#include <crypto/internal/hash.h>
3631c650 22#include <crypto/internal/skcipher.h>
1da177e4
LT
23#include <linux/init.h>
24#include <linux/module.h>
25#include <linux/mm.h>
d0856009 26#include <linux/string.h>
1da177e4 27
33023463
HX
28static DEFINE_MUTEX(crypto_default_null_skcipher_lock);
29static struct crypto_blkcipher *crypto_default_null_skcipher;
30static int crypto_default_null_skcipher_refcnt;
31
6c2bb98b
HX
32static int null_compress(struct crypto_tfm *tfm, const u8 *src,
33 unsigned int slen, u8 *dst, unsigned int *dlen)
d0856009
PM
34{
35 if (slen > *dlen)
36 return -EINVAL;
37 memcpy(dst, src, slen);
38 *dlen = slen;
39 return 0;
40}
1da177e4 41
d35d2454
HX
42static int null_init(struct shash_desc *desc)
43{
44 return 0;
45}
1da177e4 46
d35d2454
HX
47static int null_update(struct shash_desc *desc, const u8 *data,
48 unsigned int len)
49{
50 return 0;
51}
1da177e4 52
d35d2454
HX
53static 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; }
1da177e4 67
6c2bb98b 68static int null_setkey(struct crypto_tfm *tfm, const u8 *key,
560c06ae 69 unsigned int keylen)
1da177e4
LT
70{ return 0; }
71
6c2bb98b 72static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
d0856009
PM
73{
74 memcpy(dst, src, NULL_BLOCK_SIZE);
75}
1da177e4 76
3631c650
HX
77static 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
d35d2454
HX
97static 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 }
1da177e4
LT
111};
112
70a03bff 113static struct crypto_alg null_algs[3] = { {
1da177e4
LT
114 .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,
1da177e4
LT
119 .cra_u = { .cipher = {
120 .cia_min_keysize = NULL_KEY_SIZE,
121 .cia_max_keysize = NULL_KEY_SIZE,
122 .cia_setkey = null_setkey,
d0856009
PM
123 .cia_encrypt = null_crypt,
124 .cia_decrypt = null_crypt } }
70a03bff 125}, {
3631c650
HX
126 .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,
3631c650
HX
134 .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 } }
70a03bff
JK
141}, {
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} };
3631c650 151
5d26a105
KC
152MODULE_ALIAS_CRYPTO("compress_null");
153MODULE_ALIAS_CRYPTO("digest_null");
154MODULE_ALIAS_CRYPTO("cipher_null");
1da177e4 155
33023463
HX
156struct crypto_blkcipher *crypto_get_default_null_skcipher(void)
157{
158 struct crypto_blkcipher *tfm;
159
160 mutex_lock(&crypto_default_null_skcipher_lock);
161 tfm = crypto_default_null_skcipher;
162
163 if (!tfm) {
164 tfm = crypto_alloc_blkcipher("ecb(cipher_null)", 0, 0);
165 if (IS_ERR(tfm))
166 goto unlock;
167
168 crypto_default_null_skcipher = tfm;
169 }
170
171 crypto_default_null_skcipher_refcnt++;
172
173unlock:
174 mutex_unlock(&crypto_default_null_skcipher_lock);
175
176 return tfm;
177}
178EXPORT_SYMBOL_GPL(crypto_get_default_null_skcipher);
179
180void crypto_put_default_null_skcipher(void)
181{
182 mutex_lock(&crypto_default_null_skcipher_lock);
183 if (!--crypto_default_null_skcipher_refcnt) {
184 crypto_free_blkcipher(crypto_default_null_skcipher);
185 crypto_default_null_skcipher = NULL;
186 }
187 mutex_unlock(&crypto_default_null_skcipher_lock);
188}
189EXPORT_SYMBOL_GPL(crypto_put_default_null_skcipher);
190
3af5b90b 191static int __init crypto_null_mod_init(void)
1da177e4
LT
192{
193 int ret = 0;
c9af70fb 194
70a03bff 195 ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs));
1da177e4
LT
196 if (ret < 0)
197 goto out;
198
d35d2454 199 ret = crypto_register_shash(&digest_null);
3631c650 200 if (ret < 0)
70a03bff 201 goto out_unregister_algs;
1da177e4 202
70a03bff 203 return 0;
1da177e4 204
70a03bff
JK
205out_unregister_algs:
206 crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
c9af70fb 207out:
1da177e4
LT
208 return ret;
209}
210
3af5b90b 211static void __exit crypto_null_mod_fini(void)
1da177e4 212{
d35d2454 213 crypto_unregister_shash(&digest_null);
70a03bff 214 crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
1da177e4
LT
215}
216
3af5b90b
KB
217module_init(crypto_null_mod_init);
218module_exit(crypto_null_mod_fini);
1da177e4
LT
219
220MODULE_LICENSE("GPL");
221MODULE_DESCRIPTION("Null Cryptographic Algorithms");