Root/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
18struct crypto_ahash;
19
20struct hash_alg_common {
21    unsigned int digestsize;
22    unsigned int statesize;
23
24    struct crypto_alg base;
25};
26
27struct 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
40struct 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
54struct shash_desc {
55    struct crypto_shash *tfm;
56    u32 flags;
57
58    void *__ctx[] CRYPTO_MINALIGN_ATTR;
59};
60
61struct 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
85struct 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
100struct crypto_shash {
101    unsigned int descsize;
102    struct crypto_tfm base;
103};
104
105static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
106{
107    return container_of(tfm, struct crypto_ahash, base);
108}
109
110struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
111                    u32 mask);
112
113static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
114{
115    return &tfm->base;
116}
117
118static inline void crypto_free_ahash(struct crypto_ahash *tfm)
119{
120    crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
121}
122
123static inline unsigned int crypto_ahash_alignmask(
124    struct crypto_ahash *tfm)
125{
126    return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
127}
128
129static 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
135static 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
141static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
142{
143    return crypto_hash_alg_common(tfm)->digestsize;
144}
145
146static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
147{
148    return crypto_hash_alg_common(tfm)->statesize;
149}
150
151static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
152{
153    return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
154}
155
156static 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
161static 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
166static inline struct crypto_ahash *crypto_ahash_reqtfm(
167    struct ahash_request *req)
168{
169    return __crypto_ahash_cast(req->base.tfm);
170}
171
172static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
173{
174    return tfm->reqsize;
175}
176
177static inline void *ahash_request_ctx(struct ahash_request *req)
178{
179    return req->__ctx;
180}
181
182int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
183            unsigned int keylen);
184int crypto_ahash_finup(struct ahash_request *req);
185int crypto_ahash_final(struct ahash_request *req);
186int crypto_ahash_digest(struct ahash_request *req);
187
188static inline int crypto_ahash_export(struct ahash_request *req, void *out)
189{
190    return crypto_ahash_reqtfm(req)->export(req, out);
191}
192
193static inline int crypto_ahash_import(struct ahash_request *req, const void *in)
194{
195    return crypto_ahash_reqtfm(req)->import(req, in);
196}
197
198static inline int crypto_ahash_init(struct ahash_request *req)
199{
200    return crypto_ahash_reqtfm(req)->init(req);
201}
202
203static inline int crypto_ahash_update(struct ahash_request *req)
204{
205    return crypto_ahash_reqtfm(req)->update(req);
206}
207
208static 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
214static 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
228static inline void ahash_request_free(struct ahash_request *req)
229{
230    kzfree(req);
231}
232
233static 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
239static 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
249static 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
258struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
259                    u32 mask);
260
261static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
262{
263    return &tfm->base;
264}
265
266static inline void crypto_free_shash(struct crypto_shash *tfm)
267{
268    crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
269}
270
271static inline unsigned int crypto_shash_alignmask(
272    struct crypto_shash *tfm)
273{
274    return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
275}
276
277static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
278{
279    return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
280}
281
282static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
283{
284    return container_of(alg, struct shash_alg, base);
285}
286
287static 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
292static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
293{
294    return crypto_shash_alg(tfm)->digestsize;
295}
296
297static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
298{
299    return crypto_shash_alg(tfm)->statesize;
300}
301
302static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
303{
304    return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
305}
306
307static 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
312static 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
317static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
318{
319    return tfm->descsize;
320}
321
322static inline void *shash_desc_ctx(struct shash_desc *desc)
323{
324    return desc->__ctx;
325}
326
327int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
328            unsigned int keylen);
329int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
330            unsigned int len, u8 *out);
331
332static inline int crypto_shash_export(struct shash_desc *desc, void *out)
333{
334    return crypto_shash_alg(desc->tfm)->export(desc, out);
335}
336
337static 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
342static inline int crypto_shash_init(struct shash_desc *desc)
343{
344    return crypto_shash_alg(desc->tfm)->init(desc);
345}
346
347int crypto_shash_update(struct shash_desc *desc, const u8 *data,
348            unsigned int len);
349int crypto_shash_final(struct shash_desc *desc, u8 *out);
350int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
351               unsigned int len, u8 *out);
352
353#endif /* _CRYPTO_HASH_H */
354

Archive Download this file



interactive