crypto: crc32c - Switch to shash
[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 key;
29 };
30
31 struct chksum_desc_ctx {
32         u32 crc;
33 };
34
35 /*
36  * Steps through buffer one byte at at time, calculates reflected 
37  * crc using table.
38  */
39
40 static int chksum_init(struct shash_desc *desc)
41 {
42         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
43         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
44
45         ctx->crc = mctx->key;
46
47         return 0;
48 }
49
50 /*
51  * Setting the seed allows arbitrary accumulators and flexible XOR policy
52  * If your algorithm starts with ~0, then XOR with ~0 before you set
53  * the seed.
54  */
55 static int chksum_setkey(struct crypto_shash *tfm, const u8 *key,
56                          unsigned int keylen)
57 {
58         struct chksum_ctx *mctx = crypto_shash_ctx(tfm);
59
60         if (keylen != sizeof(mctx->key)) {
61                 crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
62                 return -EINVAL;
63         }
64         mctx->key = le32_to_cpu(*(__le32 *)key);
65         return 0;
66 }
67
68 static int chksum_update(struct shash_desc *desc, const u8 *data,
69                          unsigned int length)
70 {
71         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
72
73         ctx->crc = crc32c(ctx->crc, data, length);
74         return 0;
75 }
76
77 static int chksum_final(struct shash_desc *desc, u8 *out)
78 {
79         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
80
81         *(__le32 *)out = ~cpu_to_le32p(&ctx->crc);
82         return 0;
83 }
84
85 static int __chksum_finup(u32 *crcp, const u8 *data, unsigned int len, u8 *out)
86 {
87         *(__le32 *)out = ~cpu_to_le32(crc32c(*crcp, data, len));
88         return 0;
89 }
90
91 static int chksum_finup(struct shash_desc *desc, const u8 *data,
92                         unsigned int len, u8 *out)
93 {
94         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
95
96         return __chksum_finup(&ctx->crc, data, len, out);
97 }
98
99 static int chksum_digest(struct shash_desc *desc, const u8 *data,
100                          unsigned int length, u8 *out)
101 {
102         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
103
104         return __chksum_finup(&mctx->key, data, length, out);
105 }
106
107 static int crc32c_cra_init(struct crypto_tfm *tfm)
108 {
109         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
110
111         mctx->key = ~0;
112         return 0;
113 }
114
115 static struct shash_alg alg = {
116         .digestsize             =       CHKSUM_DIGEST_SIZE,
117         .setkey                 =       chksum_setkey,
118         .init                   =       chksum_init,
119         .update                 =       chksum_update,
120         .final                  =       chksum_final,
121         .finup                  =       chksum_finup,
122         .digest                 =       chksum_digest,
123         .descsize               =       sizeof(struct chksum_desc_ctx),
124         .base                   =       {
125                 .cra_name               =       "crc32c",
126                 .cra_driver_name        =       "crc32c-generic",
127                 .cra_priority           =       100,
128                 .cra_blocksize          =       CHKSUM_BLOCK_SIZE,
129                 .cra_alignmask          =       3,
130                 .cra_ctxsize            =       sizeof(struct chksum_ctx),
131                 .cra_module             =       THIS_MODULE,
132                 .cra_init               =       crc32c_cra_init,
133         }
134 };
135
136 static int __init crc32c_mod_init(void)
137 {
138         return crypto_register_shash(&alg);
139 }
140
141 static void __exit crc32c_mod_fini(void)
142 {
143         crypto_unregister_shash(&alg);
144 }
145
146 module_init(crc32c_mod_init);
147 module_exit(crc32c_mod_fini);
148
149 MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");
150 MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c");
151 MODULE_LICENSE("GPL");