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
61#define SHASH_DESC_ON_STACK(shash, ctx)				  \
62	char __##shash##_desc[sizeof(struct shash_desc) +	  \
63		crypto_shash_descsize(ctx)] CRYPTO_MINALIGN_ATTR; \
64	struct shash_desc *shash = (struct shash_desc *)__##shash##_desc
65
66struct shash_alg {
67	int (*init)(struct shash_desc *desc);
68	int (*update)(struct shash_desc *desc, const u8 *data,
69		      unsigned int len);
70	int (*final)(struct shash_desc *desc, u8 *out);
71	int (*finup)(struct shash_desc *desc, const u8 *data,
72		     unsigned int len, u8 *out);
73	int (*digest)(struct shash_desc *desc, const u8 *data,
74		      unsigned int len, u8 *out);
75	int (*export)(struct shash_desc *desc, void *out);
76	int (*import)(struct shash_desc *desc, const void *in);
77	int (*setkey)(struct crypto_shash *tfm, const u8 *key,
78		      unsigned int keylen);
79
80	unsigned int descsize;
81
82	/* These fields must match hash_alg_common. */
83	unsigned int digestsize
84		__attribute__ ((aligned(__alignof__(struct hash_alg_common))));
85	unsigned int statesize;
86
87	struct crypto_alg base;
88};
89
90struct crypto_ahash {
91	int (*init)(struct ahash_request *req);
92	int (*update)(struct ahash_request *req);
93	int (*final)(struct ahash_request *req);
94	int (*finup)(struct ahash_request *req);
95	int (*digest)(struct ahash_request *req);
96	int (*export)(struct ahash_request *req, void *out);
97	int (*import)(struct ahash_request *req, const void *in);
98	int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
99		      unsigned int keylen);
100
101	unsigned int reqsize;
102	struct crypto_tfm base;
103};
104
105struct crypto_shash {
106	unsigned int descsize;
107	struct crypto_tfm base;
108};
109
110static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
111{
112	return container_of(tfm, struct crypto_ahash, base);
113}
114
115struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
116					u32 mask);
117
118static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
119{
120	return &tfm->base;
121}
122
123static inline void crypto_free_ahash(struct crypto_ahash *tfm)
124{
125	crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
126}
127
128static inline unsigned int crypto_ahash_alignmask(
129	struct crypto_ahash *tfm)
130{
131	return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
132}
133
134static inline struct hash_alg_common *__crypto_hash_alg_common(
135	struct crypto_alg *alg)
136{
137	return container_of(alg, struct hash_alg_common, base);
138}
139
140static inline struct hash_alg_common *crypto_hash_alg_common(
141	struct crypto_ahash *tfm)
142{
143	return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);
144}
145
146static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
147{
148	return crypto_hash_alg_common(tfm)->digestsize;
149}
150
151static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
152{
153	return crypto_hash_alg_common(tfm)->statesize;
154}
155
156static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
157{
158	return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
159}
160
161static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
162{
163	crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
164}
165
166static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
167{
168	crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
169}
170
171static inline struct crypto_ahash *crypto_ahash_reqtfm(
172	struct ahash_request *req)
173{
174	return __crypto_ahash_cast(req->base.tfm);
175}
176
177static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
178{
179	return tfm->reqsize;
180}
181
182static inline void *ahash_request_ctx(struct ahash_request *req)
183{
184	return req->__ctx;
185}
186
187int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
188			unsigned int keylen);
189int crypto_ahash_finup(struct ahash_request *req);
190int crypto_ahash_final(struct ahash_request *req);
191int crypto_ahash_digest(struct ahash_request *req);
192
193static inline int crypto_ahash_export(struct ahash_request *req, void *out)
194{
195	return crypto_ahash_reqtfm(req)->export(req, out);
196}
197
198static inline int crypto_ahash_import(struct ahash_request *req, const void *in)
199{
200	return crypto_ahash_reqtfm(req)->import(req, in);
201}
202
203static inline int crypto_ahash_init(struct ahash_request *req)
204{
205	return crypto_ahash_reqtfm(req)->init(req);
206}
207
208static inline int crypto_ahash_update(struct ahash_request *req)
209{
210	return crypto_ahash_reqtfm(req)->update(req);
211}
212
213static inline void ahash_request_set_tfm(struct ahash_request *req,
214					 struct crypto_ahash *tfm)
215{
216	req->base.tfm = crypto_ahash_tfm(tfm);
217}
218
219static inline struct ahash_request *ahash_request_alloc(
220	struct crypto_ahash *tfm, gfp_t gfp)
221{
222	struct ahash_request *req;
223
224	req = kmalloc(sizeof(struct ahash_request) +
225		      crypto_ahash_reqsize(tfm), gfp);
226
227	if (likely(req))
228		ahash_request_set_tfm(req, tfm);
229
230	return req;
231}
232
233static inline void ahash_request_free(struct ahash_request *req)
234{
235	kzfree(req);
236}
237
238static inline struct ahash_request *ahash_request_cast(
239	struct crypto_async_request *req)
240{
241	return container_of(req, struct ahash_request, base);
242}
243
244static inline void ahash_request_set_callback(struct ahash_request *req,
245					      u32 flags,
246					      crypto_completion_t compl,
247					      void *data)
248{
249	req->base.complete = compl;
250	req->base.data = data;
251	req->base.flags = flags;
252}
253
254static inline void ahash_request_set_crypt(struct ahash_request *req,
255					   struct scatterlist *src, u8 *result,
256					   unsigned int nbytes)
257{
258	req->src = src;
259	req->nbytes = nbytes;
260	req->result = result;
261}
262
263struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
264					u32 mask);
265
266static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
267{
268	return &tfm->base;
269}
270
271static inline void crypto_free_shash(struct crypto_shash *tfm)
272{
273	crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
274}
275
276static inline unsigned int crypto_shash_alignmask(
277	struct crypto_shash *tfm)
278{
279	return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
280}
281
282static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
283{
284	return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
285}
286
287static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
288{
289	return container_of(alg, struct shash_alg, base);
290}
291
292static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
293{
294	return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
295}
296
297static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
298{
299	return crypto_shash_alg(tfm)->digestsize;
300}
301
302static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
303{
304	return crypto_shash_alg(tfm)->statesize;
305}
306
307static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
308{
309	return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
310}
311
312static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
313{
314	crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
315}
316
317static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
318{
319	crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
320}
321
322static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
323{
324	return tfm->descsize;
325}
326
327static inline void *shash_desc_ctx(struct shash_desc *desc)
328{
329	return desc->__ctx;
330}
331
332int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
333			unsigned int keylen);
334int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
335			unsigned int len, u8 *out);
336
337static inline int crypto_shash_export(struct shash_desc *desc, void *out)
338{
339	return crypto_shash_alg(desc->tfm)->export(desc, out);
340}
341
342static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
343{
344	return crypto_shash_alg(desc->tfm)->import(desc, in);
345}
346
347static inline int crypto_shash_init(struct shash_desc *desc)
348{
349	return crypto_shash_alg(desc->tfm)->init(desc);
350}
351
352int crypto_shash_update(struct shash_desc *desc, const u8 *data,
353			unsigned int len);
354int crypto_shash_final(struct shash_desc *desc, u8 *out);
355int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
356		       unsigned int len, u8 *out);
357
358#endif	/* _CRYPTO_HASH_H */
359