Branch data 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 : 0 : 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 : 0 : 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 : 0 : 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 : 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 : 0 : 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 : 0 : 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 : 0 : 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 : 0 : 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 : 0 : return crypto_shash_alg(desc->tfm)->import(desc, in);
340 : : }
341 : :
342 : : static inline int crypto_shash_init(struct shash_desc *desc)
343 : : {
344 : 0 : 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 */
|
