File: | src/lib/libcrypto/evp/evp_digest.c |
Warning: | line 162, column 9 Access to field 'init' results in a dereference of a null pointer (loaded from field 'digest') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: evp_digest.c,v 1.7 2023/12/29 07:22:47 tb Exp $ */ | |||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | |||
3 | * All rights reserved. | |||
4 | * | |||
5 | * This package is an SSL implementation written | |||
6 | * by Eric Young (eay@cryptsoft.com). | |||
7 | * The implementation was written so as to conform with Netscapes SSL. | |||
8 | * | |||
9 | * This library is free for commercial and non-commercial use as long as | |||
10 | * the following conditions are aheared to. The following conditions | |||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | |||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | |||
13 | * included with this distribution is covered by the same copyright terms | |||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | |||
15 | * | |||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | |||
17 | * the code are not to be removed. | |||
18 | * If this package is used in a product, Eric Young should be given attribution | |||
19 | * as the author of the parts of the library used. | |||
20 | * This can be in the form of a textual message at program startup or | |||
21 | * in documentation (online or textual) provided with the package. | |||
22 | * | |||
23 | * Redistribution and use in source and binary forms, with or without | |||
24 | * modification, are permitted provided that the following conditions | |||
25 | * are met: | |||
26 | * 1. Redistributions of source code must retain the copyright | |||
27 | * notice, this list of conditions and the following disclaimer. | |||
28 | * 2. Redistributions in binary form must reproduce the above copyright | |||
29 | * notice, this list of conditions and the following disclaimer in the | |||
30 | * documentation and/or other materials provided with the distribution. | |||
31 | * 3. All advertising materials mentioning features or use of this software | |||
32 | * must display the following acknowledgement: | |||
33 | * "This product includes cryptographic software written by | |||
34 | * Eric Young (eay@cryptsoft.com)" | |||
35 | * The word 'cryptographic' can be left out if the rouines from the library | |||
36 | * being used are not cryptographic related :-). | |||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | |||
38 | * the apps directory (application code) you must include an acknowledgement: | |||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |||
40 | * | |||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | |||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
51 | * SUCH DAMAGE. | |||
52 | * | |||
53 | * The licence and distribution terms for any publically available version or | |||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | |||
55 | * copied and put under another distribution licence | |||
56 | * [including the GNU Public Licence.] | |||
57 | */ | |||
58 | /* ==================================================================== | |||
59 | * Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved. | |||
60 | * | |||
61 | * Redistribution and use in source and binary forms, with or without | |||
62 | * modification, are permitted provided that the following conditions | |||
63 | * are met: | |||
64 | * | |||
65 | * 1. Redistributions of source code must retain the above copyright | |||
66 | * notice, this list of conditions and the following disclaimer. | |||
67 | * | |||
68 | * 2. Redistributions in binary form must reproduce the above copyright | |||
69 | * notice, this list of conditions and the following disclaimer in | |||
70 | * the documentation and/or other materials provided with the | |||
71 | * distribution. | |||
72 | * | |||
73 | * 3. All advertising materials mentioning features or use of this | |||
74 | * software must display the following acknowledgment: | |||
75 | * "This product includes software developed by the OpenSSL Project | |||
76 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | |||
77 | * | |||
78 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |||
79 | * endorse or promote products derived from this software without | |||
80 | * prior written permission. For written permission, please contact | |||
81 | * openssl-core@openssl.org. | |||
82 | * | |||
83 | * 5. Products derived from this software may not be called "OpenSSL" | |||
84 | * nor may "OpenSSL" appear in their names without prior written | |||
85 | * permission of the OpenSSL Project. | |||
86 | * | |||
87 | * 6. Redistributions of any form whatsoever must retain the following | |||
88 | * acknowledgment: | |||
89 | * "This product includes software developed by the OpenSSL Project | |||
90 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | |||
91 | * | |||
92 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |||
93 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |||
94 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |||
95 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |||
96 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||
97 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |||
98 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |||
99 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||
100 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |||
101 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |||
102 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |||
103 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |||
104 | * ==================================================================== | |||
105 | * | |||
106 | * This product includes cryptographic software written by Eric Young | |||
107 | * (eay@cryptsoft.com). This product includes software written by Tim | |||
108 | * Hudson (tjh@cryptsoft.com). | |||
109 | * | |||
110 | */ | |||
111 | ||||
112 | #include <stdio.h> | |||
113 | #include <string.h> | |||
114 | ||||
115 | #include <openssl/opensslconf.h> | |||
116 | ||||
117 | #include <openssl/err.h> | |||
118 | #include <openssl/evp.h> | |||
119 | #include <openssl/objects.h> | |||
120 | ||||
121 | #include "evp_local.h" | |||
122 | ||||
123 | int | |||
124 | EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type) | |||
125 | { | |||
126 | EVP_MD_CTX_init(ctx); | |||
127 | return EVP_DigestInit_ex(ctx, type, NULL((void *)0)); | |||
128 | } | |||
129 | ||||
130 | int | |||
131 | EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl) | |||
132 | { | |||
133 | EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_CLEANED0x0002); | |||
134 | ||||
135 | if (ctx->digest != type) { | |||
136 | if (ctx->digest && ctx->digest->ctx_size && ctx->md_data && | |||
137 | !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE0x0004)) { | |||
138 | freezero(ctx->md_data, ctx->digest->ctx_size); | |||
139 | ctx->md_data = NULL((void *)0); | |||
140 | } | |||
141 | ctx->digest = type; | |||
142 | if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT0x0100) && type->ctx_size) { | |||
143 | ctx->update = type->update; | |||
144 | ctx->md_data = calloc(1, type->ctx_size); | |||
145 | if (ctx->md_data == NULL((void *)0)) { | |||
146 | EVP_PKEY_CTX_free(ctx->pctx); | |||
147 | ctx->pctx = NULL((void *)0); | |||
148 | EVPerror(ERR_R_MALLOC_FAILURE)ERR_put_error(6,(0xfff),((1|64)),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,148); | |||
149 | return 0; | |||
150 | } | |||
151 | } | |||
152 | } | |||
153 | if (ctx->pctx
| |||
154 | int r; | |||
155 | r = EVP_PKEY_CTX_ctrl(ctx->pctx, -1, EVP_PKEY_OP_TYPE_SIG((1<<3) | (1<<4) | (1<<5) | (1<<6) | ( 1<<7)), | |||
156 | EVP_PKEY_CTRL_DIGESTINIT7, 0, ctx); | |||
157 | if (r <= 0 && (r != -2)) | |||
158 | return 0; | |||
159 | } | |||
160 | if (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT0x0100) | |||
161 | return 1; | |||
162 | return ctx->digest->init(ctx); | |||
| ||||
163 | } | |||
164 | ||||
165 | int | |||
166 | EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) | |||
167 | { | |||
168 | return ctx->update(ctx, data, count); | |||
169 | } | |||
170 | ||||
171 | /* The caller can assume that this removes any secret data from the context */ | |||
172 | int | |||
173 | EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size) | |||
174 | { | |||
175 | int ret; | |||
176 | ||||
177 | ret = EVP_DigestFinal_ex(ctx, md, size); | |||
178 | EVP_MD_CTX_cleanup(ctx); | |||
179 | return ret; | |||
180 | } | |||
181 | ||||
182 | /* The caller can assume that this removes any secret data from the context */ | |||
183 | int | |||
184 | EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size) | |||
185 | { | |||
186 | int ret; | |||
187 | ||||
188 | if ((size_t)ctx->digest->md_size > EVP_MAX_MD_SIZE64) { | |||
189 | EVPerror(EVP_R_TOO_LARGE)ERR_put_error(6,(0xfff),(164),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,189); | |||
190 | return 0; | |||
191 | } | |||
192 | ret = ctx->digest->final(ctx, md); | |||
193 | if (size != NULL((void *)0)) | |||
194 | *size = ctx->digest->md_size; | |||
195 | if (ctx->digest->cleanup) { | |||
196 | ctx->digest->cleanup(ctx); | |||
197 | EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED0x0002); | |||
198 | } | |||
199 | memset(ctx->md_data, 0, ctx->digest->ctx_size); | |||
200 | return ret; | |||
201 | } | |||
202 | ||||
203 | int | |||
204 | EVP_Digest(const void *data, size_t count, | |||
205 | unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl) | |||
206 | { | |||
207 | EVP_MD_CTX ctx; | |||
208 | int ret; | |||
209 | ||||
210 | EVP_MD_CTX_init(&ctx); | |||
| ||||
211 | EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_ONESHOT0x0001); | |||
212 | ret = EVP_DigestInit_ex(&ctx, type, NULL((void *)0)) && | |||
213 | EVP_DigestUpdate(&ctx, data, count) && | |||
214 | EVP_DigestFinal_ex(&ctx, md, size); | |||
215 | EVP_MD_CTX_cleanup(&ctx); | |||
216 | ||||
217 | return ret; | |||
218 | } | |||
219 | ||||
220 | EVP_MD_CTX * | |||
221 | EVP_MD_CTX_new(void) | |||
222 | { | |||
223 | return calloc(1, sizeof(EVP_MD_CTX)); | |||
224 | } | |||
225 | ||||
226 | void | |||
227 | EVP_MD_CTX_free(EVP_MD_CTX *ctx) | |||
228 | { | |||
229 | if (ctx == NULL((void *)0)) | |||
230 | return; | |||
231 | ||||
232 | EVP_MD_CTX_cleanup(ctx); | |||
233 | ||||
234 | free(ctx); | |||
235 | } | |||
236 | ||||
237 | EVP_MD_CTX * | |||
238 | EVP_MD_CTX_create(void) | |||
239 | { | |||
240 | return EVP_MD_CTX_new(); | |||
241 | } | |||
242 | ||||
243 | void | |||
244 | EVP_MD_CTX_destroy(EVP_MD_CTX *ctx) | |||
245 | { | |||
246 | EVP_MD_CTX_free(ctx); | |||
247 | } | |||
248 | ||||
249 | void | |||
250 | EVP_MD_CTX_init(EVP_MD_CTX *ctx) | |||
251 | { | |||
252 | memset(ctx, 0, sizeof(*ctx)); | |||
253 | } | |||
254 | ||||
255 | int | |||
256 | EVP_MD_CTX_reset(EVP_MD_CTX *ctx) | |||
257 | { | |||
258 | return EVP_MD_CTX_cleanup(ctx); | |||
259 | } | |||
260 | ||||
261 | /* This call frees resources associated with the context */ | |||
262 | int | |||
263 | EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx) | |||
264 | { | |||
265 | /* | |||
266 | * Don't assume ctx->md_data was cleaned in EVP_Digest_Final, | |||
267 | * because sometimes only copies of the context are ever finalised. | |||
268 | */ | |||
269 | if (ctx->digest && ctx->digest->cleanup && | |||
270 | !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_CLEANED0x0002)) | |||
271 | ctx->digest->cleanup(ctx); | |||
272 | if (ctx->digest && ctx->digest->ctx_size && ctx->md_data && | |||
273 | !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE0x0004)) | |||
274 | freezero(ctx->md_data, ctx->digest->ctx_size); | |||
275 | /* | |||
276 | * If EVP_MD_CTX_FLAG_KEEP_PKEY_CTX is set, EVP_MD_CTX_set_pkey() was | |||
277 | * called and its strange API contract implies we don't own ctx->pctx. | |||
278 | */ | |||
279 | if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX0x0400)) | |||
280 | EVP_PKEY_CTX_free(ctx->pctx); | |||
281 | memset(ctx, 0, sizeof(*ctx)); | |||
282 | ||||
283 | return 1; | |||
284 | } | |||
285 | ||||
286 | int | |||
287 | EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in) | |||
288 | { | |||
289 | EVP_MD_CTX_init(out); | |||
290 | return EVP_MD_CTX_copy_ex(out, in); | |||
291 | } | |||
292 | ||||
293 | int | |||
294 | EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in) | |||
295 | { | |||
296 | unsigned char *tmp_buf; | |||
297 | ||||
298 | if ((in == NULL((void *)0)) || (in->digest == NULL((void *)0))) { | |||
299 | EVPerror(EVP_R_INPUT_NOT_INITIALIZED)ERR_put_error(6,(0xfff),(111),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,299); | |||
300 | return 0; | |||
301 | } | |||
302 | ||||
303 | if (out->digest == in->digest) { | |||
304 | tmp_buf = out->md_data; | |||
305 | EVP_MD_CTX_set_flags(out, EVP_MD_CTX_FLAG_REUSE0x0004); | |||
306 | } else | |||
307 | tmp_buf = NULL((void *)0); | |||
308 | EVP_MD_CTX_cleanup(out); | |||
309 | memcpy(out, in, sizeof *out); | |||
310 | out->md_data = NULL((void *)0); | |||
311 | out->pctx = NULL((void *)0); | |||
312 | ||||
313 | /* | |||
314 | * Because of the EVP_PKEY_CTX_dup() below, EVP_MD_CTX_cleanup() needs | |||
315 | * to free out->pctx in all cases (even if this flag is set on in). | |||
316 | */ | |||
317 | EVP_MD_CTX_clear_flags(out, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX0x0400); | |||
318 | ||||
319 | if (in->md_data && out->digest->ctx_size) { | |||
320 | if (tmp_buf) { | |||
321 | out->md_data = tmp_buf; | |||
322 | } else { | |||
323 | out->md_data = calloc(1, out->digest->ctx_size); | |||
324 | if (out->md_data == NULL((void *)0)) { | |||
325 | EVPerror(ERR_R_MALLOC_FAILURE)ERR_put_error(6,(0xfff),((1|64)),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,325); | |||
326 | return 0; | |||
327 | } | |||
328 | } | |||
329 | memcpy(out->md_data, in->md_data, out->digest->ctx_size); | |||
330 | } | |||
331 | ||||
332 | out->update = in->update; | |||
333 | ||||
334 | if (in->pctx) { | |||
335 | out->pctx = EVP_PKEY_CTX_dup(in->pctx); | |||
336 | if (!out->pctx) { | |||
337 | EVP_MD_CTX_cleanup(out); | |||
338 | return 0; | |||
339 | } | |||
340 | } | |||
341 | ||||
342 | if (out->digest->copy) | |||
343 | return out->digest->copy(out, in); | |||
344 | ||||
345 | return 1; | |||
346 | } | |||
347 | ||||
348 | int | |||
349 | EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr) | |||
350 | { | |||
351 | int ret; | |||
352 | ||||
353 | if (!ctx->digest) { | |||
354 | EVPerror(EVP_R_NO_CIPHER_SET)ERR_put_error(6,(0xfff),(131),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,354); | |||
355 | return 0; | |||
356 | } | |||
357 | ||||
358 | if (!ctx->digest->md_ctrl) { | |||
359 | EVPerror(EVP_R_CTRL_NOT_IMPLEMENTED)ERR_put_error(6,(0xfff),(132),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,359); | |||
360 | return 0; | |||
361 | } | |||
362 | ||||
363 | ret = ctx->digest->md_ctrl(ctx, type, arg, ptr); | |||
364 | if (ret == -1) { | |||
365 | EVPerror(EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED)ERR_put_error(6,(0xfff),(133),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,365); | |||
366 | return 0; | |||
367 | } | |||
368 | return ret; | |||
369 | } | |||
370 | ||||
371 | const EVP_MD * | |||
372 | EVP_MD_CTX_md(const EVP_MD_CTX *ctx) | |||
373 | { | |||
374 | if (!ctx) | |||
375 | return NULL((void *)0); | |||
376 | return ctx->digest; | |||
377 | } | |||
378 | ||||
379 | void | |||
380 | EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags) | |||
381 | { | |||
382 | ctx->flags &= ~flags; | |||
383 | } | |||
384 | ||||
385 | void | |||
386 | EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags) | |||
387 | { | |||
388 | ctx->flags |= flags; | |||
389 | } | |||
390 | ||||
391 | int | |||
392 | EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags) | |||
393 | { | |||
394 | return (ctx->flags & flags); | |||
395 | } | |||
396 | ||||
397 | void * | |||
398 | EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx) | |||
399 | { | |||
400 | return ctx->md_data; | |||
401 | } | |||
402 | ||||
403 | EVP_PKEY_CTX * | |||
404 | EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx) | |||
405 | { | |||
406 | return ctx->pctx; | |||
407 | } | |||
408 | ||||
409 | void | |||
410 | EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx) | |||
411 | { | |||
412 | if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX0x0400)) { | |||
413 | EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX0x0400); | |||
414 | } else { | |||
415 | EVP_PKEY_CTX_free(ctx->pctx); | |||
416 | } | |||
417 | ||||
418 | ctx->pctx = pctx; | |||
419 | ||||
420 | if (pctx != NULL((void *)0)) { | |||
421 | /* | |||
422 | * For unclear reasons it was decided that the caller keeps | |||
423 | * ownership of pctx. So a flag was invented to make sure we | |||
424 | * don't free it in EVP_MD_CTX_cleanup(). We also need to | |||
425 | * unset it in EVP_MD_CTX_copy_ex(). Fortunately, the flag | |||
426 | * isn't public... | |||
427 | */ | |||
428 | EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX0x0400); | |||
429 | } | |||
430 | } | |||
431 | ||||
432 | int | |||
433 | EVP_MD_type(const EVP_MD *md) | |||
434 | { | |||
435 | return md->type; | |||
436 | } | |||
437 | ||||
438 | int | |||
439 | EVP_MD_pkey_type(const EVP_MD *md) | |||
440 | { | |||
441 | return md->pkey_type; | |||
442 | } | |||
443 | ||||
444 | int | |||
445 | EVP_MD_size(const EVP_MD *md) | |||
446 | { | |||
447 | if (!md) { | |||
448 | EVPerror(EVP_R_MESSAGE_DIGEST_IS_NULL)ERR_put_error(6,(0xfff),(159),"/usr/src/lib/libcrypto/evp/evp_digest.c" ,448); | |||
449 | return -1; | |||
450 | } | |||
451 | return md->md_size; | |||
452 | } | |||
453 | ||||
454 | unsigned long | |||
455 | EVP_MD_flags(const EVP_MD *md) | |||
456 | { | |||
457 | return md->flags; | |||
458 | } | |||
459 | ||||
460 | int | |||
461 | EVP_MD_block_size(const EVP_MD *md) | |||
462 | { | |||
463 | return md->block_size; | |||
464 | } | |||
465 | ||||
466 | /* | |||
467 | * XXX - remove everything below in the next bump. | |||
468 | */ | |||
469 | ||||
470 | EVP_MD * | |||
471 | EVP_MD_meth_new(int md_type, int pkey_type) | |||
472 | { | |||
473 | EVP_MD *md; | |||
474 | ||||
475 | if ((md = calloc(1, sizeof(*md))) == NULL((void *)0)) | |||
476 | return NULL((void *)0); | |||
477 | ||||
478 | md->type = md_type; | |||
479 | md->pkey_type = pkey_type; | |||
480 | ||||
481 | return md; | |||
482 | } | |||
483 | ||||
484 | EVP_MD * | |||
485 | EVP_MD_meth_dup(const EVP_MD *md) | |||
486 | { | |||
487 | EVP_MD *to; | |||
488 | ||||
489 | if ((to = EVP_MD_meth_new(md->type, md->pkey_type)) == NULL((void *)0)) | |||
490 | return NULL((void *)0); | |||
491 | ||||
492 | memcpy(to, md, sizeof(*to)); | |||
493 | ||||
494 | return to; | |||
495 | } | |||
496 | ||||
497 | void | |||
498 | EVP_MD_meth_free(EVP_MD *md) | |||
499 | { | |||
500 | freezero(md, sizeof(*md)); | |||
501 | } | |||
502 | ||||
503 | int | |||
504 | EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize) | |||
505 | { | |||
506 | md->block_size = blocksize; | |||
507 | return 1; | |||
508 | } | |||
509 | ||||
510 | int | |||
511 | EVP_MD_meth_set_result_size(EVP_MD *md, int result_size) | |||
512 | { | |||
513 | md->md_size = result_size; | |||
514 | return 1; | |||
515 | } | |||
516 | ||||
517 | int | |||
518 | EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize) | |||
519 | { | |||
520 | md->ctx_size = datasize; | |||
521 | return 1; | |||
522 | } | |||
523 | ||||
524 | int | |||
525 | EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags) | |||
526 | { | |||
527 | md->flags = flags; | |||
528 | return 1; | |||
529 | } | |||
530 | ||||
531 | int | |||
532 | EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx)) | |||
533 | { | |||
534 | md->init = init; | |||
535 | return 1; | |||
536 | } | |||
537 | ||||
538 | int | |||
539 | EVP_MD_meth_set_update(EVP_MD *md, | |||
540 | int (*update)(EVP_MD_CTX *ctx, const void *data, size_t count)) | |||
541 | { | |||
542 | md->update = update; | |||
543 | return 1; | |||
544 | } | |||
545 | ||||
546 | int | |||
547 | EVP_MD_meth_set_final(EVP_MD *md, | |||
548 | int (*final)(EVP_MD_CTX *ctx, unsigned char *md)) | |||
549 | { | |||
550 | md->final = final; | |||
551 | return 1; | |||
552 | } | |||
553 | ||||
554 | int | |||
555 | EVP_MD_meth_set_copy(EVP_MD *md, | |||
556 | int (*copy)(EVP_MD_CTX *to, const EVP_MD_CTX *from)) | |||
557 | { | |||
558 | md->copy = copy; | |||
559 | return 1; | |||
560 | } | |||
561 | ||||
562 | int | |||
563 | EVP_MD_meth_set_cleanup(EVP_MD *md, | |||
564 | int (*cleanup)(EVP_MD_CTX *ctx)) | |||
565 | { | |||
566 | md->cleanup = cleanup; | |||
567 | return 1; | |||
568 | } | |||
569 | ||||
570 | int | |||
571 | EVP_MD_meth_set_ctrl(EVP_MD *md, | |||
572 | int (*ctrl)(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)) | |||
573 | { | |||
574 | md->md_ctrl = ctrl; | |||
575 | return 1; | |||
576 | } |