Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-or-later */
2 : : /*
3 : : * Hash algorithms.
4 : : *
5 : : * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
6 : : */
7 : :
8 : : #ifndef _CRYPTO_INTERNAL_HASH_H
9 : : #define _CRYPTO_INTERNAL_HASH_H
10 : :
11 : : #include <crypto/algapi.h>
12 : : #include <crypto/hash.h>
13 : :
14 : : struct ahash_request;
15 : : struct scatterlist;
16 : :
17 : : struct crypto_hash_walk {
18 : : char *data;
19 : :
20 : : unsigned int offset;
21 : : unsigned int alignmask;
22 : :
23 : : struct page *pg;
24 : : unsigned int entrylen;
25 : :
26 : : unsigned int total;
27 : : struct scatterlist *sg;
28 : :
29 : : unsigned int flags;
30 : : };
31 : :
32 : : struct ahash_instance {
33 : : struct ahash_alg alg;
34 : : };
35 : :
36 : : struct shash_instance {
37 : : struct shash_alg alg;
38 : : };
39 : :
40 : : struct crypto_ahash_spawn {
41 : : struct crypto_spawn base;
42 : : };
43 : :
44 : : struct crypto_shash_spawn {
45 : : struct crypto_spawn base;
46 : : };
47 : :
48 : : extern const struct crypto_type crypto_ahash_type;
49 : :
50 : : int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
51 : : int crypto_hash_walk_first(struct ahash_request *req,
52 : : struct crypto_hash_walk *walk);
53 : : int crypto_ahash_walk_first(struct ahash_request *req,
54 : : struct crypto_hash_walk *walk);
55 : :
56 : : static inline int crypto_ahash_walk_done(struct crypto_hash_walk *walk,
57 : : int err)
58 : : {
59 : : return crypto_hash_walk_done(walk, err);
60 : : }
61 : :
62 : : static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
63 : : {
64 : 0 : return !(walk->entrylen | walk->total);
65 : : }
66 : :
67 : : static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
68 : : {
69 : : return crypto_hash_walk_last(walk);
70 : : }
71 : :
72 : : int crypto_register_ahash(struct ahash_alg *alg);
73 : : int crypto_unregister_ahash(struct ahash_alg *alg);
74 : : int crypto_register_ahashes(struct ahash_alg *algs, int count);
75 : : void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
76 : : int ahash_register_instance(struct crypto_template *tmpl,
77 : : struct ahash_instance *inst);
78 : : void ahash_free_instance(struct crypto_instance *inst);
79 : :
80 : : int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
81 : : unsigned int keylen);
82 : :
83 : : static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
84 : : {
85 : 1035 : return alg->setkey != shash_no_setkey;
86 : : }
87 : :
88 : : bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);
89 : :
90 : : int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
91 : : struct hash_alg_common *alg,
92 : : struct crypto_instance *inst);
93 : :
94 : : static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
95 : : {
96 : : crypto_drop_spawn(&spawn->base);
97 : : }
98 : :
99 : : struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
100 : :
101 : : int crypto_register_shash(struct shash_alg *alg);
102 : : int crypto_unregister_shash(struct shash_alg *alg);
103 : : int crypto_register_shashes(struct shash_alg *algs, int count);
104 : : int crypto_unregister_shashes(struct shash_alg *algs, int count);
105 : : int shash_register_instance(struct crypto_template *tmpl,
106 : : struct shash_instance *inst);
107 : : void shash_free_instance(struct crypto_instance *inst);
108 : :
109 : : int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
110 : : struct shash_alg *alg,
111 : : struct crypto_instance *inst);
112 : :
113 : : static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
114 : : {
115 : : crypto_drop_spawn(&spawn->base);
116 : : }
117 : :
118 : : struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
119 : :
120 : : int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
121 : : int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
122 : : int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
123 : :
124 : : int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
125 : :
126 : : static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
127 : : {
128 : : return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
129 : : }
130 : :
131 : : static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
132 : : {
133 : : return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
134 : : halg);
135 : : }
136 : :
137 : : static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
138 : : unsigned int reqsize)
139 : : {
140 : : tfm->reqsize = reqsize;
141 : : }
142 : :
143 : : static inline struct crypto_instance *ahash_crypto_instance(
144 : : struct ahash_instance *inst)
145 : : {
146 : 0 : return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
147 : : }
148 : :
149 : : static inline struct ahash_instance *ahash_instance(
150 : : struct crypto_instance *inst)
151 : : {
152 : 0 : return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
153 : : }
154 : :
155 : : static inline void *ahash_instance_ctx(struct ahash_instance *inst)
156 : : {
157 : : return crypto_instance_ctx(ahash_crypto_instance(inst));
158 : : }
159 : :
160 : : static inline unsigned int ahash_instance_headroom(void)
161 : : {
162 : : return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
163 : : }
164 : :
165 : : static inline struct ahash_instance *ahash_alloc_instance(
166 : : const char *name, struct crypto_alg *alg)
167 : : {
168 : : return crypto_alloc_instance(name, alg, ahash_instance_headroom());
169 : : }
170 : :
171 : : static inline void ahash_request_complete(struct ahash_request *req, int err)
172 : : {
173 : : req->base.complete(&req->base, err);
174 : : }
175 : :
176 : : static inline u32 ahash_request_flags(struct ahash_request *req)
177 : : {
178 : : return req->base.flags;
179 : : }
180 : :
181 : : static inline struct crypto_ahash *crypto_spawn_ahash(
182 : : struct crypto_ahash_spawn *spawn)
183 : : {
184 : : return crypto_spawn_tfm2(&spawn->base);
185 : : }
186 : :
187 : : static inline int ahash_enqueue_request(struct crypto_queue *queue,
188 : : struct ahash_request *request)
189 : : {
190 : : return crypto_enqueue_request(queue, &request->base);
191 : : }
192 : :
193 : : static inline struct ahash_request *ahash_dequeue_request(
194 : : struct crypto_queue *queue)
195 : : {
196 : : return ahash_request_cast(crypto_dequeue_request(queue));
197 : : }
198 : :
199 : : static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
200 : : {
201 : : return crypto_tfm_ctx(&tfm->base);
202 : : }
203 : :
204 : : static inline struct crypto_instance *shash_crypto_instance(
205 : : struct shash_instance *inst)
206 : : {
207 : 0 : return container_of(&inst->alg.base, struct crypto_instance, alg);
208 : : }
209 : :
210 : : static inline struct shash_instance *shash_instance(
211 : : struct crypto_instance *inst)
212 : : {
213 : : return container_of(__crypto_shash_alg(&inst->alg),
214 : : struct shash_instance, alg);
215 : : }
216 : :
217 : : static inline void *shash_instance_ctx(struct shash_instance *inst)
218 : : {
219 : : return crypto_instance_ctx(shash_crypto_instance(inst));
220 : : }
221 : :
222 : : static inline struct shash_instance *shash_alloc_instance(
223 : : const char *name, struct crypto_alg *alg)
224 : : {
225 : 0 : return crypto_alloc_instance(name, alg,
226 : : sizeof(struct shash_alg) - sizeof(*alg));
227 : : }
228 : :
229 : : static inline struct crypto_shash *crypto_spawn_shash(
230 : : struct crypto_shash_spawn *spawn)
231 : : {
232 : 0 : return crypto_spawn_tfm2(&spawn->base);
233 : : }
234 : :
235 : : static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
236 : : {
237 : : return crypto_tfm_ctx_aligned(&tfm->base);
238 : : }
239 : :
240 : : static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
241 : : {
242 : : return container_of(tfm, struct crypto_shash, base);
243 : : }
244 : :
245 : : #endif /* _CRYPTO_INTERNAL_HASH_H */
246 : :
|
