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