c8c79878c08239e5978d80a2b75d88bd64263a0b
[pandora-kernel.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         bool has_setkey;
98         struct crypto_tfm base;
99 };
100
101 struct crypto_shash {
102         unsigned int descsize;
103         struct crypto_tfm base;
104 };
105
106 static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
107 {
108         return container_of(tfm, struct crypto_ahash, base);
109 }
110
111 struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
112                                         u32 mask);
113
114 static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
115 {
116         return &tfm->base;
117 }
118
119 static inline void crypto_free_ahash(struct crypto_ahash *tfm)
120 {
121         crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
122 }
123
124 static inline unsigned int crypto_ahash_alignmask(
125         struct crypto_ahash *tfm)
126 {
127         return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
128 }
129
130 static inline struct hash_alg_common *__crypto_hash_alg_common(
131         struct crypto_alg *alg)
132 {
133         return container_of(alg, struct hash_alg_common, base);
134 }
135
136 static inline struct hash_alg_common *crypto_hash_alg_common(
137         struct crypto_ahash *tfm)
138 {
139         return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);
140 }
141
142 static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
143 {
144         return crypto_hash_alg_common(tfm)->digestsize;
145 }
146
147 static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
148 {
149         return crypto_hash_alg_common(tfm)->statesize;
150 }
151
152 static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
153 {
154         return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
155 }
156
157 static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
158 {
159         crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
160 }
161
162 static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
163 {
164         crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
165 }
166
167 static inline struct crypto_ahash *crypto_ahash_reqtfm(
168         struct ahash_request *req)
169 {
170         return __crypto_ahash_cast(req->base.tfm);
171 }
172
173 static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
174 {
175         return tfm->reqsize;
176 }
177
178 static inline void *ahash_request_ctx(struct ahash_request *req)
179 {
180         return req->__ctx;
181 }
182
183 int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
184                         unsigned int keylen);
185 static inline bool crypto_ahash_has_setkey(struct crypto_ahash *tfm)
186 {
187         return tfm->has_setkey;
188 }
189
190 int crypto_ahash_finup(struct ahash_request *req);
191 int crypto_ahash_final(struct ahash_request *req);
192 int crypto_ahash_digest(struct ahash_request *req);
193
194 static inline int crypto_ahash_export(struct ahash_request *req, void *out)
195 {
196         return crypto_ahash_reqtfm(req)->export(req, out);
197 }
198
199 static inline int crypto_ahash_import(struct ahash_request *req, const void *in)
200 {
201         return crypto_ahash_reqtfm(req)->import(req, in);
202 }
203
204 static inline int crypto_ahash_init(struct ahash_request *req)
205 {
206         return crypto_ahash_reqtfm(req)->init(req);
207 }
208
209 static inline int crypto_ahash_update(struct ahash_request *req)
210 {
211         return crypto_ahash_reqtfm(req)->update(req);
212 }
213
214 static inline void ahash_request_set_tfm(struct ahash_request *req,
215                                          struct crypto_ahash *tfm)
216 {
217         req->base.tfm = crypto_ahash_tfm(tfm);
218 }
219
220 static inline struct ahash_request *ahash_request_alloc(
221         struct crypto_ahash *tfm, gfp_t gfp)
222 {
223         struct ahash_request *req;
224
225         req = kmalloc(sizeof(struct ahash_request) +
226                       crypto_ahash_reqsize(tfm), gfp);
227
228         if (likely(req))
229                 ahash_request_set_tfm(req, tfm);
230
231         return req;
232 }
233
234 static inline void ahash_request_free(struct ahash_request *req)
235 {
236         kzfree(req);
237 }
238
239 static inline struct ahash_request *ahash_request_cast(
240         struct crypto_async_request *req)
241 {
242         return container_of(req, struct ahash_request, base);
243 }
244
245 static inline void ahash_request_set_callback(struct ahash_request *req,
246                                               u32 flags,
247                                               crypto_completion_t complete,
248                                               void *data)
249 {
250         req->base.complete = complete;
251         req->base.data = data;
252         req->base.flags = flags;
253 }
254
255 static inline void ahash_request_set_crypt(struct ahash_request *req,
256                                            struct scatterlist *src, u8 *result,
257                                            unsigned int nbytes)
258 {
259         req->src = src;
260         req->nbytes = nbytes;
261         req->result = result;
262 }
263
264 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
265                                         u32 mask);
266
267 static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
268 {
269         return &tfm->base;
270 }
271
272 static inline void crypto_free_shash(struct crypto_shash *tfm)
273 {
274         crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
275 }
276
277 static inline unsigned int crypto_shash_alignmask(
278         struct crypto_shash *tfm)
279 {
280         return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
281 }
282
283 static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
284 {
285         return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
286 }
287
288 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
289 {
290         return container_of(alg, struct shash_alg, base);
291 }
292
293 static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
294 {
295         return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
296 }
297
298 static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
299 {
300         return crypto_shash_alg(tfm)->digestsize;
301 }
302
303 static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
304 {
305         return crypto_shash_alg(tfm)->statesize;
306 }
307
308 static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
309 {
310         return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
311 }
312
313 static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
314 {
315         crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
316 }
317
318 static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
319 {
320         crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
321 }
322
323 static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
324 {
325         return tfm->descsize;
326 }
327
328 static inline void *shash_desc_ctx(struct shash_desc *desc)
329 {
330         return desc->__ctx;
331 }
332
333 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
334                         unsigned int keylen);
335 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
336                         unsigned int len, u8 *out);
337
338 static inline int crypto_shash_export(struct shash_desc *desc, void *out)
339 {
340         return crypto_shash_alg(desc->tfm)->export(desc, out);
341 }
342
343 static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
344 {
345         return crypto_shash_alg(desc->tfm)->import(desc, in);
346 }
347
348 static inline int crypto_shash_init(struct shash_desc *desc)
349 {
350         return crypto_shash_alg(desc->tfm)->init(desc);
351 }
352
353 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
354                         unsigned int len);
355 int crypto_shash_final(struct shash_desc *desc, u8 *out);
356 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
357                        unsigned int len, u8 *out);
358
359 #endif  /* _CRYPTO_HASH_H */