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 flags; |
22 | |
23 | struct page *pg; |
24 | unsigned int entrylen; |
25 | |
26 | unsigned int total; |
27 | struct scatterlist *sg; |
28 | }; |
29 | |
30 | struct ahash_instance { |
31 | void (*free)(struct ahash_instance *inst); |
32 | union { |
33 | struct { |
34 | char head[offsetof(struct ahash_alg, halg.base)]; |
35 | struct crypto_instance base; |
36 | } s; |
37 | struct ahash_alg alg; |
38 | }; |
39 | }; |
40 | |
41 | struct shash_instance { |
42 | void (*free)(struct shash_instance *inst); |
43 | union { |
44 | struct { |
45 | char head[offsetof(struct shash_alg, base)]; |
46 | struct crypto_instance base; |
47 | } s; |
48 | struct shash_alg alg; |
49 | }; |
50 | }; |
51 | |
52 | struct crypto_ahash_spawn { |
53 | struct crypto_spawn base; |
54 | }; |
55 | |
56 | struct crypto_shash_spawn { |
57 | struct crypto_spawn base; |
58 | }; |
59 | |
60 | int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err); |
61 | int crypto_hash_walk_first(struct ahash_request *req, |
62 | struct crypto_hash_walk *walk); |
63 | |
64 | static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk) |
65 | { |
66 | return !(walk->entrylen | walk->total); |
67 | } |
68 | |
69 | int crypto_register_ahash(struct ahash_alg *alg); |
70 | void crypto_unregister_ahash(struct ahash_alg *alg); |
71 | int crypto_register_ahashes(struct ahash_alg *algs, int count); |
72 | void crypto_unregister_ahashes(struct ahash_alg *algs, int count); |
73 | int ahash_register_instance(struct crypto_template *tmpl, |
74 | struct ahash_instance *inst); |
75 | |
76 | int shash_no_setkey(struct crypto_shash *tfm, const u8 *key, |
77 | unsigned int keylen); |
78 | |
79 | static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg) |
80 | { |
81 | return alg->setkey != shash_no_setkey; |
82 | } |
83 | |
84 | static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg) |
85 | { |
86 | return crypto_shash_alg_has_setkey(alg) && |
87 | !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY); |
88 | } |
89 | |
90 | bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg); |
91 | |
92 | int crypto_grab_ahash(struct crypto_ahash_spawn *spawn, |
93 | struct crypto_instance *inst, |
94 | const char *name, u32 type, u32 mask); |
95 | |
96 | static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn) |
97 | { |
98 | crypto_drop_spawn(spawn: &spawn->base); |
99 | } |
100 | |
101 | static inline struct hash_alg_common *crypto_spawn_ahash_alg( |
102 | struct crypto_ahash_spawn *spawn) |
103 | { |
104 | return __crypto_hash_alg_common(alg: spawn->base.alg); |
105 | } |
106 | |
107 | int crypto_register_shash(struct shash_alg *alg); |
108 | void crypto_unregister_shash(struct shash_alg *alg); |
109 | int crypto_register_shashes(struct shash_alg *algs, int count); |
110 | void crypto_unregister_shashes(struct shash_alg *algs, int count); |
111 | int shash_register_instance(struct crypto_template *tmpl, |
112 | struct shash_instance *inst); |
113 | void shash_free_singlespawn_instance(struct shash_instance *inst); |
114 | |
115 | int crypto_grab_shash(struct crypto_shash_spawn *spawn, |
116 | struct crypto_instance *inst, |
117 | const char *name, u32 type, u32 mask); |
118 | |
119 | static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn) |
120 | { |
121 | crypto_drop_spawn(spawn: &spawn->base); |
122 | } |
123 | |
124 | static inline struct shash_alg *crypto_spawn_shash_alg( |
125 | struct crypto_shash_spawn *spawn) |
126 | { |
127 | return __crypto_shash_alg(alg: spawn->base.alg); |
128 | } |
129 | |
130 | int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc); |
131 | int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc); |
132 | int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc); |
133 | |
134 | static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm) |
135 | { |
136 | return crypto_tfm_ctx(tfm: crypto_ahash_tfm(tfm)); |
137 | } |
138 | |
139 | static inline void *crypto_ahash_ctx_dma(struct crypto_ahash *tfm) |
140 | { |
141 | return crypto_tfm_ctx_dma(tfm: crypto_ahash_tfm(tfm)); |
142 | } |
143 | |
144 | static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg) |
145 | { |
146 | return container_of(__crypto_hash_alg_common(alg), struct ahash_alg, |
147 | halg); |
148 | } |
149 | |
150 | static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash) |
151 | { |
152 | return container_of(crypto_hash_alg_common(hash), struct ahash_alg, |
153 | halg); |
154 | } |
155 | |
156 | static inline void crypto_ahash_set_statesize(struct crypto_ahash *tfm, |
157 | unsigned int size) |
158 | { |
159 | tfm->statesize = size; |
160 | } |
161 | |
162 | static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm, |
163 | unsigned int reqsize) |
164 | { |
165 | tfm->reqsize = reqsize; |
166 | } |
167 | |
168 | static inline void crypto_ahash_set_reqsize_dma(struct crypto_ahash *ahash, |
169 | unsigned int reqsize) |
170 | { |
171 | reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1); |
172 | ahash->reqsize = reqsize; |
173 | } |
174 | |
175 | static inline struct crypto_instance *ahash_crypto_instance( |
176 | struct ahash_instance *inst) |
177 | { |
178 | return &inst->s.base; |
179 | } |
180 | |
181 | static inline struct ahash_instance *ahash_instance( |
182 | struct crypto_instance *inst) |
183 | { |
184 | return container_of(inst, struct ahash_instance, s.base); |
185 | } |
186 | |
187 | static inline struct ahash_instance *ahash_alg_instance( |
188 | struct crypto_ahash *ahash) |
189 | { |
190 | return ahash_instance(inst: crypto_tfm_alg_instance(tfm: &ahash->base)); |
191 | } |
192 | |
193 | static inline void *ahash_instance_ctx(struct ahash_instance *inst) |
194 | { |
195 | return crypto_instance_ctx(inst: ahash_crypto_instance(inst)); |
196 | } |
197 | |
198 | static inline void *ahash_request_ctx_dma(struct ahash_request *req) |
199 | { |
200 | unsigned int align = crypto_dma_align(); |
201 | |
202 | if (align <= crypto_tfm_ctx_alignment()) |
203 | align = 1; |
204 | |
205 | return PTR_ALIGN(ahash_request_ctx(req), align); |
206 | } |
207 | |
208 | static inline void ahash_request_complete(struct ahash_request *req, int err) |
209 | { |
210 | crypto_request_complete(req: &req->base, err); |
211 | } |
212 | |
213 | static inline u32 ahash_request_flags(struct ahash_request *req) |
214 | { |
215 | return req->base.flags; |
216 | } |
217 | |
218 | static inline struct crypto_ahash *crypto_spawn_ahash( |
219 | struct crypto_ahash_spawn *spawn) |
220 | { |
221 | return crypto_spawn_tfm2(spawn: &spawn->base); |
222 | } |
223 | |
224 | static inline int ahash_enqueue_request(struct crypto_queue *queue, |
225 | struct ahash_request *request) |
226 | { |
227 | return crypto_enqueue_request(queue, request: &request->base); |
228 | } |
229 | |
230 | static inline struct ahash_request *ahash_dequeue_request( |
231 | struct crypto_queue *queue) |
232 | { |
233 | return ahash_request_cast(req: crypto_dequeue_request(queue)); |
234 | } |
235 | |
236 | static inline void *crypto_shash_ctx(struct crypto_shash *tfm) |
237 | { |
238 | return crypto_tfm_ctx(tfm: &tfm->base); |
239 | } |
240 | |
241 | static inline struct crypto_instance *shash_crypto_instance( |
242 | struct shash_instance *inst) |
243 | { |
244 | return &inst->s.base; |
245 | } |
246 | |
247 | static inline struct shash_instance *shash_instance( |
248 | struct crypto_instance *inst) |
249 | { |
250 | return container_of(inst, struct shash_instance, s.base); |
251 | } |
252 | |
253 | static inline struct shash_instance *shash_alg_instance( |
254 | struct crypto_shash *shash) |
255 | { |
256 | return shash_instance(inst: crypto_tfm_alg_instance(tfm: &shash->base)); |
257 | } |
258 | |
259 | static inline void *shash_instance_ctx(struct shash_instance *inst) |
260 | { |
261 | return crypto_instance_ctx(inst: shash_crypto_instance(inst)); |
262 | } |
263 | |
264 | static inline struct crypto_shash *crypto_spawn_shash( |
265 | struct crypto_shash_spawn *spawn) |
266 | { |
267 | return crypto_spawn_tfm2(spawn: &spawn->base); |
268 | } |
269 | |
270 | static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm) |
271 | { |
272 | return container_of(tfm, struct crypto_shash, base); |
273 | } |
274 | |
275 | #endif /* _CRYPTO_INTERNAL_HASH_H */ |
276 | |
277 | |