crypto: hash - prevent using keyed hashes without setting key
[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         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         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
196
197         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
198                 return -ENOKEY;
199
200         return tfm->import(req, in);
201 }
202
203 static inline int crypto_ahash_init(struct ahash_request *req)
204 {
205         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
206
207         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
208                 return -ENOKEY;
209
210         return tfm->init(req);
211 }
212
213 static inline int crypto_ahash_update(struct ahash_request *req)
214 {
215         return crypto_ahash_reqtfm(req)->update(req);
216 }
217
218 static inline void ahash_request_set_tfm(struct ahash_request *req,
219                                          struct crypto_ahash *tfm)
220 {
221         req->base.tfm = crypto_ahash_tfm(tfm);
222 }
223
224 static inline struct ahash_request *ahash_request_alloc(
225         struct crypto_ahash *tfm, gfp_t gfp)
226 {
227         struct ahash_request *req;
228
229         req = kmalloc(sizeof(struct ahash_request) +
230                       crypto_ahash_reqsize(tfm), gfp);
231
232         if (likely(req))
233                 ahash_request_set_tfm(req, tfm);
234
235         return req;
236 }
237
238 static inline void ahash_request_free(struct ahash_request *req)
239 {
240         kzfree(req);
241 }
242
243 static inline struct ahash_request *ahash_request_cast(
244         struct crypto_async_request *req)
245 {
246         return container_of(req, struct ahash_request, base);
247 }
248
249 static inline void ahash_request_set_callback(struct ahash_request *req,
250                                               u32 flags,
251                                               crypto_completion_t complete,
252                                               void *data)
253 {
254         req->base.complete = complete;
255         req->base.data = data;
256         req->base.flags = flags;
257 }
258
259 static inline void ahash_request_set_crypt(struct ahash_request *req,
260                                            struct scatterlist *src, u8 *result,
261                                            unsigned int nbytes)
262 {
263         req->src = src;
264         req->nbytes = nbytes;
265         req->result = result;
266 }
267
268 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
269                                         u32 mask);
270
271 static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
272 {
273         return &tfm->base;
274 }
275
276 static inline void crypto_free_shash(struct crypto_shash *tfm)
277 {
278         crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
279 }
280
281 static inline unsigned int crypto_shash_alignmask(
282         struct crypto_shash *tfm)
283 {
284         return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
285 }
286
287 static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
288 {
289         return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
290 }
291
292 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
293 {
294         return container_of(alg, struct shash_alg, base);
295 }
296
297 static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
298 {
299         return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
300 }
301
302 static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
303 {
304         return crypto_shash_alg(tfm)->digestsize;
305 }
306
307 static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
308 {
309         return crypto_shash_alg(tfm)->statesize;
310 }
311
312 static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
313 {
314         return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
315 }
316
317 static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
318 {
319         crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
320 }
321
322 static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
323 {
324         crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
325 }
326
327 static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
328 {
329         return tfm->descsize;
330 }
331
332 static inline void *shash_desc_ctx(struct shash_desc *desc)
333 {
334         return desc->__ctx;
335 }
336
337 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
338                         unsigned int keylen);
339 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
340                         unsigned int len, u8 *out);
341
342 static inline int crypto_shash_export(struct shash_desc *desc, void *out)
343 {
344         return crypto_shash_alg(desc->tfm)->export(desc, out);
345 }
346
347 static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
348 {
349         struct crypto_shash *tfm = desc->tfm;
350
351         if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
352                 return -ENOKEY;
353
354         return crypto_shash_alg(tfm)->import(desc, in);
355 }
356
357 static inline int crypto_shash_init(struct shash_desc *desc)
358 {
359         struct crypto_shash *tfm = desc->tfm;
360
361         if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
362                 return -ENOKEY;
363
364         return crypto_shash_alg(tfm)->init(desc);
365 }
366
367 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
368                         unsigned int len);
369 int crypto_shash_final(struct shash_desc *desc, u8 *out);
370 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
371                        unsigned int len, u8 *out);
372
373 #endif  /* _CRYPTO_HASH_H */