Merge branch '3.1-rc-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/nab...
[linux-2.6.git] / include / crypto / hash.h
1 /*
2  * Hash: Hash algorithms under the crypto API
3  * 
4  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the Free
8  * Software Foundation; either version 2 of the License, or (at your option) 
9  * any later version.
10  *
11  */
12
13 #ifndef _CRYPTO_HASH_H
14 #define _CRYPTO_HASH_H
15
16 #include <linux/crypto.h>
17
18 struct crypto_ahash;
19
20 struct hash_alg_common {
21         unsigned int digestsize;
22         unsigned int statesize;
23
24         struct crypto_alg base;
25 };
26
27 struct ahash_request {
28         struct crypto_async_request base;
29
30         unsigned int nbytes;
31         struct scatterlist *src;
32         u8 *result;
33
34         /* This field may only be used by the ahash API code. */
35         void *priv;
36
37         void *__ctx[] CRYPTO_MINALIGN_ATTR;
38 };
39
40 struct ahash_alg {
41         int (*init)(struct ahash_request *req);
42         int (*update)(struct ahash_request *req);
43         int (*final)(struct ahash_request *req);
44         int (*finup)(struct ahash_request *req);
45         int (*digest)(struct ahash_request *req);
46         int (*export)(struct ahash_request *req, void *out);
47         int (*import)(struct ahash_request *req, const void *in);
48         int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
49                       unsigned int keylen);
50
51         struct hash_alg_common halg;
52 };
53
54 struct shash_desc {
55         struct crypto_shash *tfm;
56         u32 flags;
57
58         void *__ctx[] CRYPTO_MINALIGN_ATTR;
59 };
60
61 struct shash_alg {
62         int (*init)(struct shash_desc *desc);
63         int (*update)(struct shash_desc *desc, const u8 *data,
64                       unsigned int len);
65         int (*final)(struct shash_desc *desc, u8 *out);
66         int (*finup)(struct shash_desc *desc, const u8 *data,
67                      unsigned int len, u8 *out);
68         int (*digest)(struct shash_desc *desc, const u8 *data,
69                       unsigned int len, u8 *out);
70         int (*export)(struct shash_desc *desc, void *out);
71         int (*import)(struct shash_desc *desc, const void *in);
72         int (*setkey)(struct crypto_shash *tfm, const u8 *key,
73                       unsigned int keylen);
74
75         unsigned int descsize;
76
77         /* These fields must match hash_alg_common. */
78         unsigned int digestsize
79                 __attribute__ ((aligned(__alignof__(struct hash_alg_common))));
80         unsigned int statesize;
81
82         struct crypto_alg base;
83 };
84
85 struct crypto_ahash {
86         int (*init)(struct ahash_request *req);
87         int (*update)(struct ahash_request *req);
88         int (*final)(struct ahash_request *req);
89         int (*finup)(struct ahash_request *req);
90         int (*digest)(struct ahash_request *req);
91         int (*export)(struct ahash_request *req, void *out);
92         int (*import)(struct ahash_request *req, const void *in);
93         int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
94                       unsigned int keylen);
95
96         unsigned int reqsize;
97         struct crypto_tfm base;
98 };
99
100 struct crypto_shash {
101         unsigned int descsize;
102         struct crypto_tfm base;
103 };
104
105 static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
106 {
107         return container_of(tfm, struct crypto_ahash, base);
108 }
109
110 struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
111                                         u32 mask);
112
113 static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
114 {
115         return &tfm->base;
116 }
117
118 static inline void crypto_free_ahash(struct crypto_ahash *tfm)
119 {
120         crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
121 }
122
123 static inline unsigned int crypto_ahash_alignmask(
124         struct crypto_ahash *tfm)
125 {
126         return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
127 }
128
129 static inline struct hash_alg_common *__crypto_hash_alg_common(
130         struct crypto_alg *alg)
131 {
132         return container_of(alg, struct hash_alg_common, base);
133 }
134
135 static inline struct hash_alg_common *crypto_hash_alg_common(
136         struct crypto_ahash *tfm)
137 {
138         return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);
139 }
140
141 static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
142 {
143         return crypto_hash_alg_common(tfm)->digestsize;
144 }
145
146 static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
147 {
148         return crypto_hash_alg_common(tfm)->statesize;
149 }
150
151 static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
152 {
153         return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
154 }
155
156 static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
157 {
158         crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
159 }
160
161 static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
162 {
163         crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
164 }
165
166 static inline struct crypto_ahash *crypto_ahash_reqtfm(
167         struct ahash_request *req)
168 {
169         return __crypto_ahash_cast(req->base.tfm);
170 }
171
172 static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
173 {
174         return tfm->reqsize;
175 }
176
177 static inline void *ahash_request_ctx(struct ahash_request *req)
178 {
179         return req->__ctx;
180 }
181
182 int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
183                         unsigned int keylen);
184 int crypto_ahash_finup(struct ahash_request *req);
185 int crypto_ahash_final(struct ahash_request *req);
186 int crypto_ahash_digest(struct ahash_request *req);
187
188 static inline int crypto_ahash_export(struct ahash_request *req, void *out)
189 {
190         return crypto_ahash_reqtfm(req)->export(req, out);
191 }
192
193 static inline int crypto_ahash_import(struct ahash_request *req, const void *in)
194 {
195         return crypto_ahash_reqtfm(req)->import(req, in);
196 }
197
198 static inline int crypto_ahash_init(struct ahash_request *req)
199 {
200         return crypto_ahash_reqtfm(req)->init(req);
201 }
202
203 static inline int crypto_ahash_update(struct ahash_request *req)
204 {
205         return crypto_ahash_reqtfm(req)->update(req);
206 }
207
208 static inline void ahash_request_set_tfm(struct ahash_request *req,
209                                          struct crypto_ahash *tfm)
210 {
211         req->base.tfm = crypto_ahash_tfm(tfm);
212 }
213
214 static inline struct ahash_request *ahash_request_alloc(
215         struct crypto_ahash *tfm, gfp_t gfp)
216 {
217         struct ahash_request *req;
218
219         req = kmalloc(sizeof(struct ahash_request) +
220                       crypto_ahash_reqsize(tfm), gfp);
221
222         if (likely(req))
223                 ahash_request_set_tfm(req, tfm);
224
225         return req;
226 }
227
228 static inline void ahash_request_free(struct ahash_request *req)
229 {
230         kzfree(req);
231 }
232
233 static inline struct ahash_request *ahash_request_cast(
234         struct crypto_async_request *req)
235 {
236         return container_of(req, struct ahash_request, base);
237 }
238
239 static inline void ahash_request_set_callback(struct ahash_request *req,
240                                               u32 flags,
241                                               crypto_completion_t complete,
242                                               void *data)
243 {
244         req->base.complete = complete;
245         req->base.data = data;
246         req->base.flags = flags;
247 }
248
249 static inline void ahash_request_set_crypt(struct ahash_request *req,
250                                            struct scatterlist *src, u8 *result,
251                                            unsigned int nbytes)
252 {
253         req->src = src;
254         req->nbytes = nbytes;
255         req->result = result;
256 }
257
258 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
259                                         u32 mask);
260
261 static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
262 {
263         return &tfm->base;
264 }
265
266 static inline void crypto_free_shash(struct crypto_shash *tfm)
267 {
268         crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
269 }
270
271 static inline unsigned int crypto_shash_alignmask(
272         struct crypto_shash *tfm)
273 {
274         return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
275 }
276
277 static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
278 {
279         return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
280 }
281
282 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
283 {
284         return container_of(alg, struct shash_alg, base);
285 }
286
287 static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
288 {
289         return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
290 }
291
292 static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
293 {
294         return crypto_shash_alg(tfm)->digestsize;
295 }
296
297 static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
298 {
299         return crypto_shash_alg(tfm)->statesize;
300 }
301
302 static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
303 {
304         return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
305 }
306
307 static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
308 {
309         crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
310 }
311
312 static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
313 {
314         crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
315 }
316
317 static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
318 {
319         return tfm->descsize;
320 }
321
322 static inline void *shash_desc_ctx(struct shash_desc *desc)
323 {
324         return desc->__ctx;
325 }
326
327 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
328                         unsigned int keylen);
329 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
330                         unsigned int len, u8 *out);
331
332 static inline int crypto_shash_export(struct shash_desc *desc, void *out)
333 {
334         return crypto_shash_alg(desc->tfm)->export(desc, out);
335 }
336
337 static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
338 {
339         return crypto_shash_alg(desc->tfm)->import(desc, in);
340 }
341
342 static inline int crypto_shash_init(struct shash_desc *desc)
343 {
344         return crypto_shash_alg(desc->tfm)->init(desc);
345 }
346
347 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
348                         unsigned int len);
349 int crypto_shash_final(struct shash_desc *desc, u8 *out);
350 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
351                        unsigned int len, u8 *out);
352
353 #endif  /* _CRYPTO_HASH_H */