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 | int crypto_grab_ahash(struct crypto_ahash_spawn *spawn, |
91 | struct crypto_instance *inst, |
92 | const char *name, u32 type, u32 mask); |
93 | |
94 | static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn) |
95 | { |
96 | crypto_drop_spawn(spawn: &spawn->base); |
97 | } |
98 | |
99 | static inline struct hash_alg_common *crypto_spawn_ahash_alg( |
100 | struct crypto_ahash_spawn *spawn) |
101 | { |
102 | return __crypto_hash_alg_common(alg: spawn->base.alg); |
103 | } |
104 | |
105 | int crypto_register_shash(struct shash_alg *alg); |
106 | void crypto_unregister_shash(struct shash_alg *alg); |
107 | int crypto_register_shashes(struct shash_alg *algs, int count); |
108 | void crypto_unregister_shashes(struct shash_alg *algs, int count); |
109 | int shash_register_instance(struct crypto_template *tmpl, |
110 | struct shash_instance *inst); |
111 | void shash_free_singlespawn_instance(struct shash_instance *inst); |
112 | |
113 | int crypto_grab_shash(struct crypto_shash_spawn *spawn, |
114 | struct crypto_instance *inst, |
115 | const char *name, u32 type, u32 mask); |
116 | |
117 | static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn) |
118 | { |
119 | crypto_drop_spawn(spawn: &spawn->base); |
120 | } |
121 | |
122 | static inline struct shash_alg *crypto_spawn_shash_alg( |
123 | struct crypto_shash_spawn *spawn) |
124 | { |
125 | return __crypto_shash_alg(alg: spawn->base.alg); |
126 | } |
127 | |
128 | int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc); |
129 | int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc); |
130 | int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc); |
131 | |
132 | static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm) |
133 | { |
134 | return crypto_tfm_ctx(tfm: crypto_ahash_tfm(tfm)); |
135 | } |
136 | |
137 | static inline void *crypto_ahash_ctx_dma(struct crypto_ahash *tfm) |
138 | { |
139 | return crypto_tfm_ctx_dma(tfm: crypto_ahash_tfm(tfm)); |
140 | } |
141 | |
142 | static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg) |
143 | { |
144 | return container_of(__crypto_hash_alg_common(alg), struct ahash_alg, |
145 | halg); |
146 | } |
147 | |
148 | static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash) |
149 | { |
150 | return container_of(crypto_hash_alg_common(hash), struct ahash_alg, |
151 | halg); |
152 | } |
153 | |
154 | static inline void crypto_ahash_set_statesize(struct crypto_ahash *tfm, |
155 | unsigned int size) |
156 | { |
157 | tfm->statesize = size; |
158 | } |
159 | |
160 | static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm, |
161 | unsigned int reqsize) |
162 | { |
163 | tfm->reqsize = reqsize; |
164 | } |
165 | |
166 | static inline void crypto_ahash_set_reqsize_dma(struct crypto_ahash *ahash, |
167 | unsigned int reqsize) |
168 | { |
169 | reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1); |
170 | ahash->reqsize = reqsize; |
171 | } |
172 | |
173 | static inline struct crypto_instance *ahash_crypto_instance( |
174 | struct ahash_instance *inst) |
175 | { |
176 | return &inst->s.base; |
177 | } |
178 | |
179 | static inline struct ahash_instance *ahash_instance( |
180 | struct crypto_instance *inst) |
181 | { |
182 | return container_of(inst, struct ahash_instance, s.base); |
183 | } |
184 | |
185 | static inline struct ahash_instance *ahash_alg_instance( |
186 | struct crypto_ahash *ahash) |
187 | { |
188 | return ahash_instance(inst: crypto_tfm_alg_instance(tfm: &ahash->base)); |
189 | } |
190 | |
191 | static inline void *ahash_instance_ctx(struct ahash_instance *inst) |
192 | { |
193 | return crypto_instance_ctx(inst: ahash_crypto_instance(inst)); |
194 | } |
195 | |
196 | static inline void *ahash_request_ctx_dma(struct ahash_request *req) |
197 | { |
198 | unsigned int align = crypto_dma_align(); |
199 | |
200 | if (align <= crypto_tfm_ctx_alignment()) |
201 | align = 1; |
202 | |
203 | return PTR_ALIGN(ahash_request_ctx(req), align); |
204 | } |
205 | |
206 | static inline void ahash_request_complete(struct ahash_request *req, int err) |
207 | { |
208 | crypto_request_complete(req: &req->base, err); |
209 | } |
210 | |
211 | static inline u32 ahash_request_flags(struct ahash_request *req) |
212 | { |
213 | return req->base.flags; |
214 | } |
215 | |
216 | static inline struct crypto_ahash *crypto_spawn_ahash( |
217 | struct crypto_ahash_spawn *spawn) |
218 | { |
219 | return crypto_spawn_tfm2(spawn: &spawn->base); |
220 | } |
221 | |
222 | static inline int ahash_enqueue_request(struct crypto_queue *queue, |
223 | struct ahash_request *request) |
224 | { |
225 | return crypto_enqueue_request(queue, request: &request->base); |
226 | } |
227 | |
228 | static inline struct ahash_request *ahash_dequeue_request( |
229 | struct crypto_queue *queue) |
230 | { |
231 | return ahash_request_cast(req: crypto_dequeue_request(queue)); |
232 | } |
233 | |
234 | static inline void *crypto_shash_ctx(struct crypto_shash *tfm) |
235 | { |
236 | return crypto_tfm_ctx(tfm: &tfm->base); |
237 | } |
238 | |
239 | static inline struct crypto_instance *shash_crypto_instance( |
240 | struct shash_instance *inst) |
241 | { |
242 | return &inst->s.base; |
243 | } |
244 | |
245 | static inline struct shash_instance *shash_instance( |
246 | struct crypto_instance *inst) |
247 | { |
248 | return container_of(inst, struct shash_instance, s.base); |
249 | } |
250 | |
251 | static inline struct shash_instance *shash_alg_instance( |
252 | struct crypto_shash *shash) |
253 | { |
254 | return shash_instance(inst: crypto_tfm_alg_instance(tfm: &shash->base)); |
255 | } |
256 | |
257 | static inline void *shash_instance_ctx(struct shash_instance *inst) |
258 | { |
259 | return crypto_instance_ctx(inst: shash_crypto_instance(inst)); |
260 | } |
261 | |
262 | static inline struct crypto_shash *crypto_spawn_shash( |
263 | struct crypto_shash_spawn *spawn) |
264 | { |
265 | return crypto_spawn_tfm2(spawn: &spawn->base); |
266 | } |
267 | |
268 | static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm) |
269 | { |
270 | return container_of(tfm, struct crypto_shash, base); |
271 | } |
272 | |
273 | #endif /* _CRYPTO_INTERNAL_HASH_H */ |
274 | |
275 | |