a882d9e4e63e741fd90ec2d6183cee337c841c54
[linux-2.6.git] / crypto / crc32c.c
1 /* 
2  * Cryptographic API.
3  *
4  * CRC32C chksum
5  *
6  * This module file is a wrapper to invoke the lib/crc32c routines.
7  *
8  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 2 of the License, or (at your option) 
13  * any later version.
14  *
15  */
16
17 #include <crypto/internal/hash.h>
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/string.h>
21 #include <linux/crc32c.h>
22 #include <linux/kernel.h>
23
24 #define CHKSUM_BLOCK_SIZE       1
25 #define CHKSUM_DIGEST_SIZE      4
26
27 struct chksum_ctx {
28         u32 crc;
29         u32 key;
30 };
31
32 /*
33  * Steps through buffer one byte at at time, calculates reflected 
34  * crc using table.
35  */
36
37 static void chksum_init(struct crypto_tfm *tfm)
38 {
39         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
40
41         mctx->crc = mctx->key;
42 }
43
44 /*
45  * Setting the seed allows arbitrary accumulators and flexible XOR policy
46  * If your algorithm starts with ~0, then XOR with ~0 before you set
47  * the seed.
48  */
49 static int chksum_setkey(struct crypto_tfm *tfm, const u8 *key,
50                          unsigned int keylen)
51 {
52         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
53
54         if (keylen != sizeof(mctx->crc)) {
55                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
56                 return -EINVAL;
57         }
58         mctx->key = le32_to_cpu(*(__le32 *)key);
59         return 0;
60 }
61
62 static void chksum_update(struct crypto_tfm *tfm, const u8 *data,
63                           unsigned int length)
64 {
65         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
66
67         mctx->crc = crc32c(mctx->crc, data, length);
68 }
69
70 static void chksum_final(struct crypto_tfm *tfm, u8 *out)
71 {
72         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
73         
74         *(__le32 *)out = ~cpu_to_le32(mctx->crc);
75 }
76
77 static int crc32c_cra_init_old(struct crypto_tfm *tfm)
78 {
79         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
80
81         mctx->key = ~0;
82         return 0;
83 }
84
85 static struct crypto_alg old_alg = {
86         .cra_name       =       "crc32c",
87         .cra_flags      =       CRYPTO_ALG_TYPE_DIGEST,
88         .cra_blocksize  =       CHKSUM_BLOCK_SIZE,
89         .cra_ctxsize    =       sizeof(struct chksum_ctx),
90         .cra_module     =       THIS_MODULE,
91         .cra_list       =       LIST_HEAD_INIT(old_alg.cra_list),
92         .cra_init       =       crc32c_cra_init_old,
93         .cra_u          =       {
94                 .digest = {
95                          .dia_digestsize=       CHKSUM_DIGEST_SIZE,
96                          .dia_setkey    =       chksum_setkey,
97                          .dia_init      =       chksum_init,
98                          .dia_update    =       chksum_update,
99                          .dia_final     =       chksum_final
100                  }
101         }
102 };
103
104 /*
105  * Setting the seed allows arbitrary accumulators and flexible XOR policy
106  * If your algorithm starts with ~0, then XOR with ~0 before you set
107  * the seed.
108  */
109 static int crc32c_setkey(struct crypto_ahash *hash, const u8 *key,
110                          unsigned int keylen)
111 {
112         u32 *mctx = crypto_ahash_ctx(hash);
113
114         if (keylen != sizeof(u32)) {
115                 crypto_ahash_set_flags(hash, CRYPTO_TFM_RES_BAD_KEY_LEN);
116                 return -EINVAL;
117         }
118         *mctx = le32_to_cpup((__le32 *)key);
119         return 0;
120 }
121
122 static int crc32c_init(struct ahash_request *req)
123 {
124         u32 *mctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
125         u32 *crcp = ahash_request_ctx(req);
126
127         *crcp = *mctx;
128         return 0;
129 }
130
131 static int crc32c_update(struct ahash_request *req)
132 {
133         struct crypto_hash_walk walk;
134         u32 *crcp = ahash_request_ctx(req);
135         u32 crc = *crcp;
136         int nbytes;
137
138         for (nbytes = crypto_hash_walk_first(req, &walk); nbytes;
139              nbytes = crypto_hash_walk_done(&walk, 0))
140                 crc = crc32c(crc, walk.data, nbytes);
141
142         *crcp = crc;
143         return 0;
144 }
145
146 static int crc32c_final(struct ahash_request *req)
147 {
148         u32 *crcp = ahash_request_ctx(req);
149         
150         *(__le32 *)req->result = ~cpu_to_le32p(crcp);
151         return 0;
152 }
153
154 static int crc32c_digest(struct ahash_request *req)
155 {
156         struct crypto_hash_walk walk;
157         u32 *mctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
158         u32 crc = *mctx;
159         int nbytes;
160
161         for (nbytes = crypto_hash_walk_first(req, &walk); nbytes;
162              nbytes = crypto_hash_walk_done(&walk, 0))
163                 crc = crc32c(crc, walk.data, nbytes);
164
165         *(__le32 *)req->result = ~cpu_to_le32(crc);
166         return 0;
167 }
168
169 static int crc32c_cra_init(struct crypto_tfm *tfm)
170 {
171         u32 *key = crypto_tfm_ctx(tfm);
172
173         *key = ~0;
174
175         tfm->crt_ahash.reqsize = sizeof(u32);
176
177         return 0;
178 }
179
180 static struct crypto_alg alg = {
181         .cra_name               =       "crc32c",
182         .cra_driver_name        =       "crc32c-generic",
183         .cra_priority           =       100,
184         .cra_flags              =       CRYPTO_ALG_TYPE_AHASH,
185         .cra_blocksize          =       CHKSUM_BLOCK_SIZE,
186         .cra_alignmask          =       3,
187         .cra_ctxsize            =       sizeof(u32),
188         .cra_module             =       THIS_MODULE,
189         .cra_list               =       LIST_HEAD_INIT(alg.cra_list),
190         .cra_init               =       crc32c_cra_init,
191         .cra_type               =       &crypto_ahash_type,
192         .cra_u                  =       {
193                 .ahash = {
194                          .digestsize    =       CHKSUM_DIGEST_SIZE,
195                          .setkey        =       crc32c_setkey,
196                          .init          =       crc32c_init,
197                          .update        =       crc32c_update,
198                          .final         =       crc32c_final,
199                          .digest        =       crc32c_digest,
200                  }
201         }
202 };
203
204 static int __init crc32c_mod_init(void)
205 {
206         int err;
207
208         err = crypto_register_alg(&old_alg);
209         if (err)
210                 return err;
211
212         err = crypto_register_alg(&alg);
213         if (err)
214                 crypto_unregister_alg(&old_alg);
215
216         return err;
217 }
218
219 static void __exit crc32c_mod_fini(void)
220 {
221         crypto_unregister_alg(&alg);
222         crypto_unregister_alg(&old_alg);
223 }
224
225 module_init(crc32c_mod_init);
226 module_exit(crc32c_mod_fini);
227
228 MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");
229 MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c");
230 MODULE_LICENSE("GPL");