Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6.git] / crypto / crypto_null.c
1 /*
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.
8  *
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  */
19
20 #include <crypto/internal/hash.h>
21 #include <crypto/internal/skcipher.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/mm.h>
25 #include <linux/string.h>
26
27 #define NULL_KEY_SIZE           0
28 #define NULL_BLOCK_SIZE         1
29 #define NULL_DIGEST_SIZE        0
30 #define NULL_IV_SIZE            0
31
32 static int null_compress(struct crypto_tfm *tfm, const u8 *src,
33                          unsigned int slen, u8 *dst, unsigned int *dlen)
34 {
35         if (slen > *dlen)
36                 return -EINVAL;
37         memcpy(dst, src, slen);
38         *dlen = slen;
39         return 0;
40 }
41
42 static int null_init(struct shash_desc *desc)
43 {
44         return 0;
45 }
46
47 static int null_update(struct shash_desc *desc, const u8 *data,
48                        unsigned int len)
49 {
50         return 0;
51 }
52
53 static int null_final(struct shash_desc *desc, u8 *out)
54 {
55         return 0;
56 }
57
58 static int null_digest(struct shash_desc *desc, const u8 *data,
59                        unsigned int len, u8 *out)
60 {
61         return 0;
62 }
63
64 static int null_hash_setkey(struct crypto_shash *tfm, const u8 *key,
65                             unsigned int keylen)
66 { return 0; }
67
68 static int null_setkey(struct crypto_tfm *tfm, const u8 *key,
69                        unsigned int keylen)
70 { return 0; }
71
72 static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
73 {
74         memcpy(dst, src, NULL_BLOCK_SIZE);
75 }
76
77 static 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
97 static struct crypto_alg compress_null = {
98         .cra_name               =       "compress_null",
99         .cra_flags              =       CRYPTO_ALG_TYPE_COMPRESS,
100         .cra_blocksize          =       NULL_BLOCK_SIZE,
101         .cra_ctxsize            =       0,
102         .cra_module             =       THIS_MODULE,
103         .cra_list               =       LIST_HEAD_INIT(compress_null.cra_list),
104         .cra_u                  =       { .compress = {
105         .coa_compress           =       null_compress,
106         .coa_decompress         =       null_compress } }
107 };
108
109 static struct shash_alg digest_null = {
110         .digestsize             =       NULL_DIGEST_SIZE,
111         .setkey                 =       null_hash_setkey,
112         .init                   =       null_init,
113         .update                 =       null_update,
114         .finup                  =       null_digest,
115         .digest                 =       null_digest,
116         .final                  =       null_final,
117         .base                   =       {
118                 .cra_name               =       "digest_null",
119                 .cra_flags              =       CRYPTO_ALG_TYPE_SHASH,
120                 .cra_blocksize          =       NULL_BLOCK_SIZE,
121                 .cra_module             =       THIS_MODULE,
122         }
123 };
124
125 static struct crypto_alg cipher_null = {
126         .cra_name               =       "cipher_null",
127         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
128         .cra_blocksize          =       NULL_BLOCK_SIZE,
129         .cra_ctxsize            =       0,
130         .cra_module             =       THIS_MODULE,
131         .cra_list               =       LIST_HEAD_INIT(cipher_null.cra_list),
132         .cra_u                  =       { .cipher = {
133         .cia_min_keysize        =       NULL_KEY_SIZE,
134         .cia_max_keysize        =       NULL_KEY_SIZE,
135         .cia_setkey             =       null_setkey,
136         .cia_encrypt            =       null_crypt,
137         .cia_decrypt            =       null_crypt } }
138 };
139
140 static struct crypto_alg skcipher_null = {
141         .cra_name               =       "ecb(cipher_null)",
142         .cra_driver_name        =       "ecb-cipher_null",
143         .cra_priority           =       100,
144         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
145         .cra_blocksize          =       NULL_BLOCK_SIZE,
146         .cra_type               =       &crypto_blkcipher_type,
147         .cra_ctxsize            =       0,
148         .cra_module             =       THIS_MODULE,
149         .cra_list               =       LIST_HEAD_INIT(skcipher_null.cra_list),
150         .cra_u                  =       { .blkcipher = {
151         .min_keysize            =       NULL_KEY_SIZE,
152         .max_keysize            =       NULL_KEY_SIZE,
153         .ivsize                 =       NULL_IV_SIZE,
154         .setkey                 =       null_setkey,
155         .encrypt                =       skcipher_null_crypt,
156         .decrypt                =       skcipher_null_crypt } }
157 };
158
159 MODULE_ALIAS("compress_null");
160 MODULE_ALIAS("digest_null");
161 MODULE_ALIAS("cipher_null");
162
163 static int __init crypto_null_mod_init(void)
164 {
165         int ret = 0;
166
167         ret = crypto_register_alg(&cipher_null);
168         if (ret < 0)
169                 goto out;
170
171         ret = crypto_register_alg(&skcipher_null);
172         if (ret < 0)
173                 goto out_unregister_cipher;
174
175         ret = crypto_register_shash(&digest_null);
176         if (ret < 0)
177                 goto out_unregister_skcipher;
178
179         ret = crypto_register_alg(&compress_null);
180         if (ret < 0)
181                 goto out_unregister_digest;
182
183 out:
184         return ret;
185
186 out_unregister_digest:
187         crypto_unregister_shash(&digest_null);
188 out_unregister_skcipher:
189         crypto_unregister_alg(&skcipher_null);
190 out_unregister_cipher:
191         crypto_unregister_alg(&cipher_null);
192         goto out;
193 }
194
195 static void __exit crypto_null_mod_fini(void)
196 {
197         crypto_unregister_alg(&compress_null);
198         crypto_unregister_shash(&digest_null);
199         crypto_unregister_alg(&skcipher_null);
200         crypto_unregister_alg(&cipher_null);
201 }
202
203 module_init(crypto_null_mod_init);
204 module_exit(crypto_null_mod_fini);
205
206 MODULE_LICENSE("GPL");
207 MODULE_DESCRIPTION("Null Cryptographic Algorithms");