f74214a4b01b5240f7bcd5807be4feaaa288d328
[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 shash_desc {
19         struct crypto_shash *tfm;
20         u32 flags;
21
22         void *__ctx[] CRYPTO_MINALIGN_ATTR;
23 };
24
25 struct shash_alg {
26         int (*init)(struct shash_desc *desc);
27         int (*update)(struct shash_desc *desc, const u8 *data,
28                       unsigned int len);
29         int (*final)(struct shash_desc *desc, u8 *out);
30         int (*finup)(struct shash_desc *desc, const u8 *data,
31                      unsigned int len, u8 *out);
32         int (*digest)(struct shash_desc *desc, const u8 *data,
33                       unsigned int len, u8 *out);
34         int (*export)(struct shash_desc *desc, void *out);
35         int (*import)(struct shash_desc *desc, const void *in);
36         int (*setkey)(struct crypto_shash *tfm, const u8 *key,
37                       unsigned int keylen);
38
39         unsigned int descsize;
40         unsigned int digestsize;
41         unsigned int statesize;
42
43         struct crypto_alg base;
44 };
45
46 struct crypto_ahash {
47         struct crypto_tfm base;
48 };
49
50 struct crypto_shash {
51         struct crypto_tfm base;
52 };
53
54 static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
55 {
56         return (struct crypto_ahash *)tfm;
57 }
58
59 static inline struct crypto_ahash *crypto_alloc_ahash(const char *alg_name,
60                                                       u32 type, u32 mask)
61 {
62         type &= ~CRYPTO_ALG_TYPE_MASK;
63         mask &= ~CRYPTO_ALG_TYPE_MASK;
64         type |= CRYPTO_ALG_TYPE_AHASH;
65         mask |= CRYPTO_ALG_TYPE_AHASH_MASK;
66
67         return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, mask));
68 }
69
70 static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
71 {
72         return &tfm->base;
73 }
74
75 static inline void crypto_free_ahash(struct crypto_ahash *tfm)
76 {
77         crypto_free_tfm(crypto_ahash_tfm(tfm));
78 }
79
80 static inline unsigned int crypto_ahash_alignmask(
81         struct crypto_ahash *tfm)
82 {
83         return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
84 }
85
86 static inline struct ahash_tfm *crypto_ahash_crt(struct crypto_ahash *tfm)
87 {
88         return &crypto_ahash_tfm(tfm)->crt_ahash;
89 }
90
91 static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
92 {
93         return crypto_ahash_crt(tfm)->digestsize;
94 }
95
96 static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
97 {
98         return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
99 }
100
101 static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
102 {
103         crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
104 }
105
106 static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
107 {
108         crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
109 }
110
111 static inline struct crypto_ahash *crypto_ahash_reqtfm(
112         struct ahash_request *req)
113 {
114         return __crypto_ahash_cast(req->base.tfm);
115 }
116
117 static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
118 {
119         return crypto_ahash_crt(tfm)->reqsize;
120 }
121
122 static inline void *ahash_request_ctx(struct ahash_request *req)
123 {
124         return req->__ctx;
125 }
126
127 static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
128                                       const u8 *key, unsigned int keylen)
129 {
130         struct ahash_tfm *crt = crypto_ahash_crt(tfm);
131
132         return crt->setkey(tfm, key, keylen);
133 }
134
135 static inline int crypto_ahash_digest(struct ahash_request *req)
136 {
137         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
138         return crt->digest(req);
139 }
140
141 static inline void crypto_ahash_export(struct ahash_request *req, u8 *out)
142 {
143         memcpy(out, ahash_request_ctx(req),
144                crypto_ahash_reqsize(crypto_ahash_reqtfm(req)));
145 }
146
147 int crypto_ahash_import(struct ahash_request *req, const u8 *in);
148
149 static inline int crypto_ahash_init(struct ahash_request *req)
150 {
151         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
152         return crt->init(req);
153 }
154
155 static inline int crypto_ahash_update(struct ahash_request *req)
156 {
157         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
158         return crt->update(req);
159 }
160
161 static inline int crypto_ahash_final(struct ahash_request *req)
162 {
163         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
164         return crt->final(req);
165 }
166
167 static inline void ahash_request_set_tfm(struct ahash_request *req,
168                                          struct crypto_ahash *tfm)
169 {
170         req->base.tfm = crypto_ahash_tfm(tfm);
171 }
172
173 static inline struct ahash_request *ahash_request_alloc(
174         struct crypto_ahash *tfm, gfp_t gfp)
175 {
176         struct ahash_request *req;
177
178         req = kmalloc(sizeof(struct ahash_request) +
179                       crypto_ahash_reqsize(tfm), gfp);
180
181         if (likely(req))
182                 ahash_request_set_tfm(req, tfm);
183
184         return req;
185 }
186
187 static inline void ahash_request_free(struct ahash_request *req)
188 {
189         kzfree(req);
190 }
191
192 static inline struct ahash_request *ahash_request_cast(
193         struct crypto_async_request *req)
194 {
195         return container_of(req, struct ahash_request, base);
196 }
197
198 static inline void ahash_request_set_callback(struct ahash_request *req,
199                                               u32 flags,
200                                               crypto_completion_t complete,
201                                               void *data)
202 {
203         req->base.complete = complete;
204         req->base.data = data;
205         req->base.flags = flags;
206 }
207
208 static inline void ahash_request_set_crypt(struct ahash_request *req,
209                                            struct scatterlist *src, u8 *result,
210                                            unsigned int nbytes)
211 {
212         req->src = src;
213         req->nbytes = nbytes;
214         req->result = result;
215 }
216
217 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
218                                         u32 mask);
219
220 static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
221 {
222         return &tfm->base;
223 }
224
225 static inline void crypto_free_shash(struct crypto_shash *tfm)
226 {
227         crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
228 }
229
230 static inline unsigned int crypto_shash_alignmask(
231         struct crypto_shash *tfm)
232 {
233         return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
234 }
235
236 static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
237 {
238         return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
239 }
240
241 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
242 {
243         return container_of(alg, struct shash_alg, base);
244 }
245
246 static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
247 {
248         return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
249 }
250
251 static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
252 {
253         return crypto_shash_alg(tfm)->digestsize;
254 }
255
256 static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
257 {
258         return crypto_shash_alg(tfm)->statesize;
259 }
260
261 static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
262 {
263         return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
264 }
265
266 static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
267 {
268         crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
269 }
270
271 static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
272 {
273         crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
274 }
275
276 static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
277 {
278         return crypto_shash_alg(tfm)->descsize;
279 }
280
281 static inline void *shash_desc_ctx(struct shash_desc *desc)
282 {
283         return desc->__ctx;
284 }
285
286 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
287                         unsigned int keylen);
288 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
289                         unsigned int len, u8 *out);
290
291 static inline int crypto_shash_export(struct shash_desc *desc, void *out)
292 {
293         return crypto_shash_alg(desc->tfm)->export(desc, out);
294 }
295
296 static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
297 {
298         return crypto_shash_alg(desc->tfm)->import(desc, in);
299 }
300
301 static inline int crypto_shash_init(struct shash_desc *desc)
302 {
303         return crypto_shash_alg(desc->tfm)->init(desc);
304 }
305
306 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
307                         unsigned int len);
308 int crypto_shash_final(struct shash_desc *desc, u8 *out);
309 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
310                        unsigned int len, u8 *out);
311
312 #endif  /* _CRYPTO_HASH_H */