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 | /* Set this bit to handle partial blocks in the API. */ |
15 | #define CRYPTO_AHASH_ALG_BLOCK_ONLY 0x01000000 |
16 | |
17 | /* Set this bit if final requires at least one byte. */ |
18 | #define CRYPTO_AHASH_ALG_FINAL_NONZERO 0x02000000 |
19 | |
20 | /* Set this bit if finup can deal with multiple blocks. */ |
21 | #define CRYPTO_AHASH_ALG_FINUP_MAX 0x04000000 |
22 | |
23 | /* This bit is set by the Crypto API if export_core is not supported. */ |
24 | #define CRYPTO_AHASH_ALG_NO_EXPORT_CORE 0x08000000 |
25 | |
26 | #define HASH_FBREQ_ON_STACK(name, req) \ |
27 | char __##name##_req[sizeof(struct ahash_request) + \ |
28 | MAX_SYNC_HASH_REQSIZE] CRYPTO_MINALIGN_ATTR; \ |
29 | struct ahash_request *name = ahash_fbreq_on_stack_init( \ |
30 | __##name##_req, (req)) |
31 | |
32 | struct ahash_request; |
33 | |
34 | struct ahash_instance { |
35 | void (*free)(struct ahash_instance *inst); |
36 | union { |
37 | struct { |
38 | char head[offsetof(struct ahash_alg, halg.base)]; |
39 | struct crypto_instance base; |
40 | } s; |
41 | struct ahash_alg alg; |
42 | }; |
43 | }; |
44 | |
45 | struct shash_instance { |
46 | void (*free)(struct shash_instance *inst); |
47 | union { |
48 | struct { |
49 | char head[offsetof(struct shash_alg, base)]; |
50 | struct crypto_instance base; |
51 | } s; |
52 | struct shash_alg alg; |
53 | }; |
54 | }; |
55 | |
56 | struct crypto_ahash_spawn { |
57 | struct crypto_spawn base; |
58 | }; |
59 | |
60 | struct crypto_shash_spawn { |
61 | struct crypto_spawn base; |
62 | }; |
63 | |
64 | int crypto_register_ahash(struct ahash_alg *alg); |
65 | void crypto_unregister_ahash(struct ahash_alg *alg); |
66 | int crypto_register_ahashes(struct ahash_alg *algs, int count); |
67 | void crypto_unregister_ahashes(struct ahash_alg *algs, int count); |
68 | int ahash_register_instance(struct crypto_template *tmpl, |
69 | struct ahash_instance *inst); |
70 | void ahash_free_singlespawn_instance(struct ahash_instance *inst); |
71 | |
72 | int shash_no_setkey(struct crypto_shash *tfm, const u8 *key, |
73 | unsigned int keylen); |
74 | |
75 | static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg) |
76 | { |
77 | return alg->setkey != shash_no_setkey; |
78 | } |
79 | |
80 | bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg); |
81 | |
82 | static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg) |
83 | { |
84 | return crypto_shash_alg_has_setkey(alg) && |
85 | !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY); |
86 | } |
87 | |
88 | static inline bool crypto_hash_alg_needs_key(struct hash_alg_common *alg) |
89 | { |
90 | return crypto_hash_alg_has_setkey(halg: alg) && |
91 | !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY); |
92 | } |
93 | |
94 | int crypto_grab_ahash(struct crypto_ahash_spawn *spawn, |
95 | struct crypto_instance *inst, |
96 | const char *name, u32 type, u32 mask); |
97 | |
98 | static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn) |
99 | { |
100 | crypto_drop_spawn(spawn: &spawn->base); |
101 | } |
102 | |
103 | static inline struct hash_alg_common *crypto_spawn_ahash_alg( |
104 | struct crypto_ahash_spawn *spawn) |
105 | { |
106 | return __crypto_hash_alg_common(alg: spawn->base.alg); |
107 | } |
108 | |
109 | int crypto_register_shash(struct shash_alg *alg); |
110 | void crypto_unregister_shash(struct shash_alg *alg); |
111 | int crypto_register_shashes(struct shash_alg *algs, int count); |
112 | void crypto_unregister_shashes(struct shash_alg *algs, int count); |
113 | int shash_register_instance(struct crypto_template *tmpl, |
114 | struct shash_instance *inst); |
115 | void shash_free_singlespawn_instance(struct shash_instance *inst); |
116 | |
117 | int crypto_grab_shash(struct crypto_shash_spawn *spawn, |
118 | struct crypto_instance *inst, |
119 | const char *name, u32 type, u32 mask); |
120 | |
121 | static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn) |
122 | { |
123 | crypto_drop_spawn(spawn: &spawn->base); |
124 | } |
125 | |
126 | static inline struct shash_alg *crypto_spawn_shash_alg( |
127 | struct crypto_shash_spawn *spawn) |
128 | { |
129 | return __crypto_shash_alg(alg: spawn->base.alg); |
130 | } |
131 | |
132 | int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc); |
133 | int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc); |
134 | int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc); |
135 | |
136 | static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm) |
137 | { |
138 | return crypto_tfm_ctx(tfm: crypto_ahash_tfm(tfm)); |
139 | } |
140 | |
141 | static inline void *crypto_ahash_ctx_dma(struct crypto_ahash *tfm) |
142 | { |
143 | return crypto_tfm_ctx_dma(tfm: crypto_ahash_tfm(tfm)); |
144 | } |
145 | |
146 | static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg) |
147 | { |
148 | return container_of(__crypto_hash_alg_common(alg), struct ahash_alg, |
149 | halg); |
150 | } |
151 | |
152 | static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash) |
153 | { |
154 | return container_of(crypto_hash_alg_common(hash), struct ahash_alg, |
155 | halg); |
156 | } |
157 | |
158 | static inline void crypto_ahash_set_statesize(struct crypto_ahash *tfm, |
159 | unsigned int size) |
160 | { |
161 | tfm->statesize = size; |
162 | } |
163 | |
164 | static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm, |
165 | unsigned int reqsize) |
166 | { |
167 | tfm->reqsize = reqsize; |
168 | } |
169 | |
170 | static inline void crypto_ahash_set_reqsize_dma(struct crypto_ahash *ahash, |
171 | unsigned int reqsize) |
172 | { |
173 | reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1); |
174 | ahash->reqsize = reqsize; |
175 | } |
176 | |
177 | static inline struct crypto_instance *ahash_crypto_instance( |
178 | struct ahash_instance *inst) |
179 | { |
180 | return &inst->s.base; |
181 | } |
182 | |
183 | static inline struct ahash_instance *ahash_instance( |
184 | struct crypto_instance *inst) |
185 | { |
186 | return container_of(inst, struct ahash_instance, s.base); |
187 | } |
188 | |
189 | static inline struct ahash_instance *ahash_alg_instance( |
190 | struct crypto_ahash *ahash) |
191 | { |
192 | return ahash_instance(inst: crypto_tfm_alg_instance(tfm: &ahash->base)); |
193 | } |
194 | |
195 | static inline void *ahash_instance_ctx(struct ahash_instance *inst) |
196 | { |
197 | return crypto_instance_ctx(inst: ahash_crypto_instance(inst)); |
198 | } |
199 | |
200 | static inline void *ahash_request_ctx_dma(struct ahash_request *req) |
201 | { |
202 | unsigned int align = crypto_dma_align(); |
203 | |
204 | if (align <= crypto_tfm_ctx_alignment()) |
205 | align = 1; |
206 | |
207 | return PTR_ALIGN(ahash_request_ctx(req), align); |
208 | } |
209 | |
210 | static inline void ahash_request_complete(struct ahash_request *req, int err) |
211 | { |
212 | crypto_request_complete(req: &req->base, err); |
213 | } |
214 | |
215 | static inline u32 ahash_request_flags(struct ahash_request *req) |
216 | { |
217 | return crypto_request_flags(req: &req->base) & ~CRYPTO_AHASH_REQ_PRIVATE; |
218 | } |
219 | |
220 | static inline struct crypto_ahash *crypto_spawn_ahash( |
221 | struct crypto_ahash_spawn *spawn) |
222 | { |
223 | return crypto_spawn_tfm2(spawn: &spawn->base); |
224 | } |
225 | |
226 | static inline int ahash_enqueue_request(struct crypto_queue *queue, |
227 | struct ahash_request *request) |
228 | { |
229 | return crypto_enqueue_request(queue, request: &request->base); |
230 | } |
231 | |
232 | static inline struct ahash_request *ahash_dequeue_request( |
233 | struct crypto_queue *queue) |
234 | { |
235 | return ahash_request_cast(req: crypto_dequeue_request(queue)); |
236 | } |
237 | |
238 | static inline void *crypto_shash_ctx(struct crypto_shash *tfm) |
239 | { |
240 | return crypto_tfm_ctx(tfm: &tfm->base); |
241 | } |
242 | |
243 | static inline struct crypto_instance *shash_crypto_instance( |
244 | struct shash_instance *inst) |
245 | { |
246 | return &inst->s.base; |
247 | } |
248 | |
249 | static inline struct shash_instance *shash_instance( |
250 | struct crypto_instance *inst) |
251 | { |
252 | return container_of(inst, struct shash_instance, s.base); |
253 | } |
254 | |
255 | static inline struct shash_instance *shash_alg_instance( |
256 | struct crypto_shash *shash) |
257 | { |
258 | return shash_instance(inst: crypto_tfm_alg_instance(tfm: &shash->base)); |
259 | } |
260 | |
261 | static inline void *shash_instance_ctx(struct shash_instance *inst) |
262 | { |
263 | return crypto_instance_ctx(inst: shash_crypto_instance(inst)); |
264 | } |
265 | |
266 | static inline struct crypto_shash *crypto_spawn_shash( |
267 | struct crypto_shash_spawn *spawn) |
268 | { |
269 | return crypto_spawn_tfm2(spawn: &spawn->base); |
270 | } |
271 | |
272 | static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm) |
273 | { |
274 | return container_of(tfm, struct crypto_shash, base); |
275 | } |
276 | |
277 | static inline bool ahash_request_isvirt(struct ahash_request *req) |
278 | { |
279 | return req->base.flags & CRYPTO_AHASH_REQ_VIRT; |
280 | } |
281 | |
282 | static inline bool crypto_ahash_req_virt(struct crypto_ahash *tfm) |
283 | { |
284 | return crypto_tfm_req_virt(tfm: &tfm->base); |
285 | } |
286 | |
287 | static inline struct crypto_ahash *crypto_ahash_fb(struct crypto_ahash *tfm) |
288 | { |
289 | return __crypto_ahash_cast(tfm: crypto_ahash_tfm(tfm)->fb); |
290 | } |
291 | |
292 | static inline struct ahash_request *ahash_fbreq_on_stack_init( |
293 | char *buf, struct ahash_request *old) |
294 | { |
295 | struct crypto_ahash *tfm = crypto_ahash_reqtfm(req: old); |
296 | struct ahash_request *req = (void *)buf; |
297 | |
298 | crypto_stack_request_init(req: &req->base, |
299 | tfm: crypto_ahash_tfm(tfm: crypto_ahash_fb(tfm))); |
300 | ahash_request_set_callback(req, flags: ahash_request_flags(req: old), NULL, NULL); |
301 | req->base.flags &= ~CRYPTO_AHASH_REQ_PRIVATE; |
302 | req->base.flags |= old->base.flags & CRYPTO_AHASH_REQ_PRIVATE; |
303 | req->src = old->src; |
304 | req->result = old->result; |
305 | req->nbytes = old->nbytes; |
306 | |
307 | return req; |
308 | } |
309 | |
310 | /* Return the state size without partial block for block-only algorithms. */ |
311 | static inline unsigned int crypto_shash_coresize(struct crypto_shash *tfm) |
312 | { |
313 | return crypto_shash_statesize(tfm) - crypto_shash_blocksize(tfm) - 1; |
314 | } |
315 | |
316 | /* This can only be used if the request was never cloned. */ |
317 | #define HASH_REQUEST_ZERO(name) \ |
318 | memzero_explicit(__##name##_req, sizeof(__##name##_req)) |
319 | |
320 | /** |
321 | * crypto_ahash_export_core() - extract core state for message digest |
322 | * @req: reference to the ahash_request handle whose state is exported |
323 | * @out: output buffer of sufficient size that can hold the hash state |
324 | * |
325 | * Export the hash state without the partial block buffer. |
326 | * |
327 | * Context: Softirq or process context. |
328 | * Return: 0 if the export creation was successful; < 0 if an error occurred |
329 | */ |
330 | int crypto_ahash_export_core(struct ahash_request *req, void *out); |
331 | |
332 | /** |
333 | * crypto_ahash_import_core() - import core state |
334 | * @req: reference to ahash_request handle the state is imported into |
335 | * @in: buffer holding the state |
336 | * |
337 | * Import the hash state without the partial block buffer. |
338 | * |
339 | * Context: Softirq or process context. |
340 | * Return: 0 if the import was successful; < 0 if an error occurred |
341 | */ |
342 | int crypto_ahash_import_core(struct ahash_request *req, const void *in); |
343 | |
344 | /** |
345 | * crypto_shash_export_core() - extract core state for message digest |
346 | * @desc: reference to the operational state handle whose state is exported |
347 | * @out: output buffer of sufficient size that can hold the hash state |
348 | * |
349 | * Export the hash state without the partial block buffer. |
350 | * |
351 | * Context: Softirq or process context. |
352 | * Return: 0 if the export creation was successful; < 0 if an error occurred |
353 | */ |
354 | int crypto_shash_export_core(struct shash_desc *desc, void *out); |
355 | |
356 | /** |
357 | * crypto_shash_import_core() - import core state |
358 | * @desc: reference to the operational state handle the state imported into |
359 | * @in: buffer holding the state |
360 | * |
361 | * Import the hash state without the partial block buffer. |
362 | * |
363 | * Context: Softirq or process context. |
364 | * Return: 0 if the import was successful; < 0 if an error occurred |
365 | */ |
366 | int crypto_shash_import_core(struct shash_desc *desc, const void *in); |
367 | |
368 | #endif /* _CRYPTO_INTERNAL_HASH_H */ |
369 | |
370 |
Definitions
- ahash_instance
- shash_instance
- crypto_ahash_spawn
- crypto_shash_spawn
- crypto_shash_alg_has_setkey
- crypto_shash_alg_needs_key
- crypto_hash_alg_needs_key
- crypto_drop_ahash
- crypto_spawn_ahash_alg
- crypto_drop_shash
- crypto_spawn_shash_alg
- crypto_ahash_ctx
- crypto_ahash_ctx_dma
- __crypto_ahash_alg
- crypto_ahash_alg
- crypto_ahash_set_statesize
- crypto_ahash_set_reqsize
- crypto_ahash_set_reqsize_dma
- ahash_crypto_instance
- ahash_instance
- ahash_alg_instance
- ahash_instance_ctx
- ahash_request_ctx_dma
- ahash_request_complete
- ahash_request_flags
- crypto_spawn_ahash
- ahash_enqueue_request
- ahash_dequeue_request
- crypto_shash_ctx
- shash_crypto_instance
- shash_instance
- shash_alg_instance
- shash_instance_ctx
- crypto_spawn_shash
- __crypto_shash_cast
- ahash_request_isvirt
- crypto_ahash_req_virt
- crypto_ahash_fb
- ahash_fbreq_on_stack_init
Improve your Profiling and Debugging skills
Find out more