Line data Source code
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 compl,
242 : void *data)
243 : {
244 : req->base.complete = compl;
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 0 : 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 5966186 : 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 */
|
