usb: gadget: composite: Fix cdev null after rmmod
[linux-3.10.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 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         }
111 };
112
113 static struct crypto_alg null_algs[3] = { {
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,
119         .cra_u                  =       { .cipher = {
120         .cia_min_keysize        =       NULL_KEY_SIZE,
121         .cia_max_keysize        =       NULL_KEY_SIZE,
122         .cia_setkey             =       null_setkey,
123         .cia_encrypt            =       null_crypt,
124         .cia_decrypt            =       null_crypt } }
125 }, {
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,
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 } }
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 } };
151
152 MODULE_ALIAS("compress_null");
153 MODULE_ALIAS("digest_null");
154 MODULE_ALIAS("cipher_null");
155
156 static int __init crypto_null_mod_init(void)
157 {
158         int ret = 0;
159
160         ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs));
161         if (ret < 0)
162                 goto out;
163
164         ret = crypto_register_shash(&digest_null);
165         if (ret < 0)
166                 goto out_unregister_algs;
167
168         return 0;
169
170 out_unregister_algs:
171         crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
172 out:
173         return ret;
174 }
175
176 static void __exit crypto_null_mod_fini(void)
177 {
178         crypto_unregister_shash(&digest_null);
179         crypto_unregister_algs(null_algs, ARRAY_SIZE(null_algs));
180 }
181
182 module_init(crypto_null_mod_init);
183 module_exit(crypto_null_mod_fini);
184
185 MODULE_LICENSE("GPL");
186 MODULE_DESCRIPTION("Null Cryptographic Algorithms");