1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/types.h>
18#include <linux/init.h>
19#include <linux/module.h>
20#include <crypto/internal/hash.h>
21#include "skein_base.h"
22
23static int skein256_init(struct shash_desc *desc)
24{
25 return skein_256_init((struct skein_256_ctx *)shash_desc_ctx(desc),
26 SKEIN256_DIGEST_BIT_SIZE);
27}
28
29static int skein256_update(struct shash_desc *desc, const u8 *data,
30 unsigned int len)
31{
32 return skein_256_update((struct skein_256_ctx *)shash_desc_ctx(desc),
33 data, len);
34}
35
36static int skein256_final(struct shash_desc *desc, u8 *out)
37{
38 return skein_256_final((struct skein_256_ctx *)shash_desc_ctx(desc),
39 out);
40}
41
42static int skein256_export(struct shash_desc *desc, void *out)
43{
44 struct skein_256_ctx *sctx = shash_desc_ctx(desc);
45
46 memcpy(out, sctx, sizeof(*sctx));
47 return 0;
48}
49
50static int skein256_import(struct shash_desc *desc, const void *in)
51{
52 struct skein_256_ctx *sctx = shash_desc_ctx(desc);
53
54 memcpy(sctx, in, sizeof(*sctx));
55 return 0;
56}
57
58static int skein512_init(struct shash_desc *desc)
59{
60 return skein_512_init((struct skein_512_ctx *)shash_desc_ctx(desc),
61 SKEIN512_DIGEST_BIT_SIZE);
62}
63
64static int skein512_update(struct shash_desc *desc, const u8 *data,
65 unsigned int len)
66{
67 return skein_512_update((struct skein_512_ctx *)shash_desc_ctx(desc),
68 data, len);
69}
70
71static int skein512_final(struct shash_desc *desc, u8 *out)
72{
73 return skein_512_final((struct skein_512_ctx *)shash_desc_ctx(desc),
74 out);
75}
76
77static int skein512_export(struct shash_desc *desc, void *out)
78{
79 struct skein_512_ctx *sctx = shash_desc_ctx(desc);
80
81 memcpy(out, sctx, sizeof(*sctx));
82 return 0;
83}
84
85static int skein512_import(struct shash_desc *desc, const void *in)
86{
87 struct skein_512_ctx *sctx = shash_desc_ctx(desc);
88
89 memcpy(sctx, in, sizeof(*sctx));
90 return 0;
91}
92
93static int skein1024_init(struct shash_desc *desc)
94{
95 return skein_1024_init((struct skein_1024_ctx *)shash_desc_ctx(desc),
96 SKEIN1024_DIGEST_BIT_SIZE);
97}
98
99static int skein1024_update(struct shash_desc *desc, const u8 *data,
100 unsigned int len)
101{
102 return skein_1024_update((struct skein_1024_ctx *)shash_desc_ctx(desc),
103 data, len);
104}
105
106static int skein1024_final(struct shash_desc *desc, u8 *out)
107{
108 return skein_1024_final((struct skein_1024_ctx *)shash_desc_ctx(desc),
109 out);
110}
111
112static int skein1024_export(struct shash_desc *desc, void *out)
113{
114 struct skein_1024_ctx *sctx = shash_desc_ctx(desc);
115
116 memcpy(out, sctx, sizeof(*sctx));
117 return 0;
118}
119
120static int skein1024_import(struct shash_desc *desc, const void *in)
121{
122 struct skein_1024_ctx *sctx = shash_desc_ctx(desc);
123
124 memcpy(sctx, in, sizeof(*sctx));
125 return 0;
126}
127
128static struct shash_alg alg256 = {
129 .digestsize = (SKEIN256_DIGEST_BIT_SIZE / 8),
130 .init = skein256_init,
131 .update = skein256_update,
132 .final = skein256_final,
133 .export = skein256_export,
134 .import = skein256_import,
135 .descsize = sizeof(struct skein_256_ctx),
136 .statesize = sizeof(struct skein_256_ctx),
137 .base = {
138 .cra_name = "skein256",
139 .cra_driver_name = "skein",
140 .cra_flags = CRYPTO_ALG_TYPE_SHASH,
141 .cra_blocksize = SKEIN_256_BLOCK_BYTES,
142 .cra_module = THIS_MODULE,
143 }
144};
145
146static struct shash_alg alg512 = {
147 .digestsize = (SKEIN512_DIGEST_BIT_SIZE / 8),
148 .init = skein512_init,
149 .update = skein512_update,
150 .final = skein512_final,
151 .export = skein512_export,
152 .import = skein512_import,
153 .descsize = sizeof(struct skein_512_ctx),
154 .statesize = sizeof(struct skein_512_ctx),
155 .base = {
156 .cra_name = "skein512",
157 .cra_driver_name = "skein",
158 .cra_flags = CRYPTO_ALG_TYPE_SHASH,
159 .cra_blocksize = SKEIN_512_BLOCK_BYTES,
160 .cra_module = THIS_MODULE,
161 }
162};
163
164static struct shash_alg alg1024 = {
165 .digestsize = (SKEIN1024_DIGEST_BIT_SIZE / 8),
166 .init = skein1024_init,
167 .update = skein1024_update,
168 .final = skein1024_final,
169 .export = skein1024_export,
170 .import = skein1024_import,
171 .descsize = sizeof(struct skein_1024_ctx),
172 .statesize = sizeof(struct skein_1024_ctx),
173 .base = {
174 .cra_name = "skein1024",
175 .cra_driver_name = "skein",
176 .cra_flags = CRYPTO_ALG_TYPE_SHASH,
177 .cra_blocksize = SKEIN_1024_BLOCK_BYTES,
178 .cra_module = THIS_MODULE,
179 }
180};
181
182static int __init skein_generic_init(void)
183{
184 if (crypto_register_shash(&alg256))
185 goto out;
186 if (crypto_register_shash(&alg512))
187 goto unreg256;
188 if (crypto_register_shash(&alg1024))
189 goto unreg512;
190
191 return 0;
192
193unreg512:
194 crypto_unregister_shash(&alg512);
195unreg256:
196 crypto_unregister_shash(&alg256);
197out:
198 return -1;
199}
200
201static void __exit skein_generic_fini(void)
202{
203 crypto_unregister_shash(&alg256);
204 crypto_unregister_shash(&alg512);
205 crypto_unregister_shash(&alg1024);
206}
207
208module_init(skein_generic_init);
209module_exit(skein_generic_fini);
210
211MODULE_LICENSE("GPL");
212MODULE_DESCRIPTION("Skein Hash Algorithm");
213
214MODULE_ALIAS("skein");
215
