Rename FIPS_MODE to FIPS_MODULE
[openssl.git] / crypto / evp / digest.c
1 /*
2  * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <openssl/objects.h>
12 #include <openssl/evp.h>
13 #include <openssl/engine.h>
14 #include <openssl/params.h>
15 #include <openssl/core_names.h>
16 #include "internal/cryptlib.h"
17 #include "crypto/evp.h"
18 #include "internal/provider.h"
19 #include "evp_local.h"
20
21 /* This call frees resources associated with the context */
22 int EVP_MD_CTX_reset(EVP_MD_CTX *ctx)
23 {
24     if (ctx == NULL)
25         return 1;
26
27 #ifndef FIPS_MODULE
28     /* TODO(3.0): Temporarily no support for EVP_DigestSign* in FIPS module */
29     /*
30      * pctx should be freed by the user of EVP_MD_CTX
31      * if EVP_MD_CTX_FLAG_KEEP_PKEY_CTX is set
32      */
33     if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX))
34         EVP_PKEY_CTX_free(ctx->pctx);
35 #endif
36
37     EVP_MD_free(ctx->fetched_digest);
38     ctx->fetched_digest = NULL;
39     ctx->reqdigest = NULL;
40
41     if (ctx->provctx != NULL) {
42         if (ctx->digest->freectx != NULL)
43             ctx->digest->freectx(ctx->provctx);
44         ctx->provctx = NULL;
45         EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
46     }
47
48     /* TODO(3.0): Remove legacy code below */
49
50     /*
51      * Don't assume ctx->md_data was cleaned in EVP_Digest_Final, because
52      * sometimes only copies of the context are ever finalised.
53      */
54     if (ctx->digest && ctx->digest->cleanup
55         && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_CLEANED))
56         ctx->digest->cleanup(ctx);
57     if (ctx->digest && ctx->digest->ctx_size && ctx->md_data
58         && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE)) {
59         OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
60     }
61
62 #if !defined(FIPS_MODULE) && !defined(OPENSSL_NO_ENGINE)
63     ENGINE_finish(ctx->engine);
64 #endif
65
66     /* TODO(3.0): End of legacy code */
67
68     OPENSSL_cleanse(ctx, sizeof(*ctx));
69
70     return 1;
71 }
72
73 EVP_MD_CTX *EVP_MD_CTX_new(void)
74 {
75     return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
76 }
77
78 void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
79 {
80     if (ctx == NULL)
81         return;
82
83     EVP_MD_CTX_reset(ctx);
84
85     OPENSSL_free(ctx);
86     return;
87 }
88
89 int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
90 {
91     EVP_MD_CTX_reset(ctx);
92     return EVP_DigestInit_ex(ctx, type, NULL);
93 }
94
95 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
96 {
97 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
98     ENGINE *tmpimpl = NULL;
99 #endif
100
101     EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
102
103     if (ctx->provctx != NULL) {
104         if (!ossl_assert(ctx->digest != NULL)) {
105             EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
106             return 0;
107         }
108         if (ctx->digest->freectx != NULL)
109             ctx->digest->freectx(ctx->provctx);
110         ctx->provctx = NULL;
111     }
112
113     if (type != NULL)
114         ctx->reqdigest = type;
115
116     /* TODO(3.0): Legacy work around code below. Remove this */
117 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
118     /*
119      * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
120      * this context may already have an ENGINE! Try to avoid releasing the
121      * previous handle, re-querying for an ENGINE, and having a
122      * reinitialisation, when it may all be unnecessary.
123      */
124     if (ctx->engine && ctx->digest &&
125         (type == NULL || (type->type == ctx->digest->type)))
126         goto skip_to_init;
127
128     if (type != NULL) {
129         /*
130          * Ensure an ENGINE left lying around from last time is cleared (the
131          * previous check attempted to avoid this if the same ENGINE and
132          * EVP_MD could be used).
133          */
134         ENGINE_finish(ctx->engine);
135         ctx->engine = NULL;
136     }
137
138     if (type != NULL && impl == NULL)
139         tmpimpl = ENGINE_get_digest_engine(type->type);
140 #endif
141
142     /*
143      * If there are engines involved or EVP_MD_CTX_FLAG_NO_INIT is set then we
144      * should use legacy handling for now.
145      */
146     if (ctx->engine != NULL
147             || impl != NULL
148 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
149             || tmpimpl != NULL
150 #endif
151             || (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) != 0) {
152         if (ctx->digest == ctx->fetched_digest)
153             ctx->digest = NULL;
154         EVP_MD_free(ctx->fetched_digest);
155         ctx->fetched_digest = NULL;
156         goto legacy;
157     }
158
159     if (ctx->digest != NULL && ctx->digest->ctx_size > 0) {
160         OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
161         ctx->md_data = NULL;
162     }
163
164     /* TODO(3.0): Start of non-legacy code below */
165
166     if (type->prov == NULL) {
167 #ifdef FIPS_MODULE
168         /* We only do explicit fetches inside the FIPS module */
169         EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
170         return 0;
171 #else
172         EVP_MD *provmd = EVP_MD_fetch(NULL, OBJ_nid2sn(type->type), "");
173
174         if (provmd == NULL) {
175             EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
176             return 0;
177         }
178         type = provmd;
179         EVP_MD_free(ctx->fetched_digest);
180         ctx->fetched_digest = provmd;
181 #endif
182     }
183
184     if (ctx->provctx != NULL && ctx->digest != NULL && ctx->digest != type) {
185         if (ctx->digest->freectx != NULL)
186             ctx->digest->freectx(ctx->provctx);
187         ctx->provctx = NULL;
188     }
189     ctx->digest = type;
190     if (ctx->provctx == NULL) {
191         ctx->provctx = ctx->digest->newctx(ossl_provider_ctx(type->prov));
192         if (ctx->provctx == NULL) {
193             EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
194             return 0;
195         }
196     }
197
198     if (ctx->digest->dinit == NULL) {
199         EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
200         return 0;
201     }
202
203     return ctx->digest->dinit(ctx->provctx);
204
205     /* TODO(3.0): Remove legacy code below */
206  legacy:
207
208 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
209     if (type) {
210         if (impl != NULL) {
211             if (!ENGINE_init(impl)) {
212                 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
213                 return 0;
214             }
215         } else {
216             /* Ask if an ENGINE is reserved for this job */
217             impl = tmpimpl;
218         }
219         if (impl != NULL) {
220             /* There's an ENGINE for this job ... (apparently) */
221             const EVP_MD *d = ENGINE_get_digest(impl, type->type);
222
223             if (d == NULL) {
224                 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
225                 ENGINE_finish(impl);
226                 return 0;
227             }
228             /* We'll use the ENGINE's private digest definition */
229             type = d;
230             /*
231              * Store the ENGINE functional reference so we know 'type' came
232              * from an ENGINE and we need to release it when done.
233              */
234             ctx->engine = impl;
235         } else
236             ctx->engine = NULL;
237     } else {
238         if (!ctx->digest) {
239             EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_NO_DIGEST_SET);
240             return 0;
241         }
242         type = ctx->digest;
243     }
244 #endif
245     if (ctx->digest != type) {
246         if (ctx->digest && ctx->digest->ctx_size) {
247             OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
248             ctx->md_data = NULL;
249         }
250         ctx->digest = type;
251         if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) && type->ctx_size) {
252             ctx->update = type->update;
253             ctx->md_data = OPENSSL_zalloc(type->ctx_size);
254             if (ctx->md_data == NULL) {
255                 EVPerr(EVP_F_EVP_DIGESTINIT_EX, ERR_R_MALLOC_FAILURE);
256                 return 0;
257             }
258         }
259     }
260 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
261  skip_to_init:
262 #endif
263 #ifndef FIPS_MODULE
264     /*
265      * TODO(3.0): Temporarily no support for EVP_DigestSign* inside FIPS module
266      * or when using providers.
267      */
268     if (ctx->pctx != NULL
269             && (!EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx->pctx)
270                  || ctx->pctx->op.sig.signature == NULL)) {
271         int r;
272         r = EVP_PKEY_CTX_ctrl(ctx->pctx, -1, EVP_PKEY_OP_TYPE_SIG,
273                               EVP_PKEY_CTRL_DIGESTINIT, 0, ctx);
274         if (r <= 0 && (r != -2))
275             return 0;
276     }
277 #endif
278     if (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT)
279         return 1;
280     return ctx->digest->init(ctx);
281 }
282
283 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
284 {
285     if (count == 0)
286         return 1;
287
288     if (ctx->pctx != NULL
289             && EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx->pctx)
290             && ctx->pctx->op.sig.sigprovctx != NULL) {
291         /*
292          * Prior to OpenSSL 3.0 EVP_DigestSignUpdate() and
293          * EVP_DigestVerifyUpdate() were just macros for EVP_DigestUpdate().
294          * Some code calls EVP_DigestUpdate() directly even when initialised
295          * with EVP_DigestSignInit_ex() or EVP_DigestVerifyInit_ex(), so we
296          * detect that and redirect to the correct EVP_Digest*Update() function
297          */
298         if (ctx->pctx->operation == EVP_PKEY_OP_SIGNCTX)
299             return EVP_DigestSignUpdate(ctx, data, count);
300         if (ctx->pctx->operation == EVP_PKEY_OP_VERIFYCTX)
301             return EVP_DigestVerifyUpdate(ctx, data, count);
302         EVPerr(EVP_F_EVP_DIGESTUPDATE, EVP_R_UPDATE_ERROR);
303         return 0;
304     }
305
306     if (ctx->digest == NULL
307             || ctx->digest->prov == NULL
308             || (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) != 0)
309         goto legacy;
310
311     if (ctx->digest->dupdate == NULL) {
312         EVPerr(EVP_F_EVP_DIGESTUPDATE, EVP_R_UPDATE_ERROR);
313         return 0;
314     }
315     return ctx->digest->dupdate(ctx->provctx, data, count);
316
317     /* TODO(3.0): Remove legacy code below */
318  legacy:
319     return ctx->update(ctx, data, count);
320 }
321
322 /* The caller can assume that this removes any secret data from the context */
323 int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
324 {
325     int ret;
326     ret = EVP_DigestFinal_ex(ctx, md, size);
327     EVP_MD_CTX_reset(ctx);
328     return ret;
329 }
330
331 /* The caller can assume that this removes any secret data from the context */
332 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *isize)
333 {
334     int ret;
335     size_t size = 0;
336     size_t mdsize = EVP_MD_size(ctx->digest);
337
338     if (ctx->digest == NULL || ctx->digest->prov == NULL)
339         goto legacy;
340
341     if (ctx->digest->dfinal == NULL) {
342         EVPerr(EVP_F_EVP_DIGESTFINAL_EX, EVP_R_FINAL_ERROR);
343         return 0;
344     }
345
346     ret = ctx->digest->dfinal(ctx->provctx, md, &size, mdsize);
347
348     if (isize != NULL) {
349         if (size <= UINT_MAX) {
350             *isize = (int)size;
351         } else {
352             EVPerr(EVP_F_EVP_DIGESTFINAL_EX, EVP_R_FINAL_ERROR);
353             ret = 0;
354         }
355     }
356
357     return ret;
358
359     /* TODO(3.0): Remove legacy code below */
360  legacy:
361     OPENSSL_assert(mdsize <= EVP_MAX_MD_SIZE);
362     ret = ctx->digest->final(ctx, md);
363     if (isize != NULL)
364         *isize = mdsize;
365     if (ctx->digest->cleanup) {
366         ctx->digest->cleanup(ctx);
367         EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
368     }
369     OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
370     return ret;
371 }
372
373 int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md, size_t size)
374 {
375     int ret = 0;
376     OSSL_PARAM params[2];
377     size_t i = 0;
378
379     if (ctx->digest == NULL || ctx->digest->prov == NULL)
380         goto legacy;
381
382     if (ctx->digest->dfinal == NULL) {
383         EVPerr(EVP_F_EVP_DIGESTFINALXOF, EVP_R_FINAL_ERROR);
384         return 0;
385     }
386
387     params[i++] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &size);
388     params[i++] = OSSL_PARAM_construct_end();
389
390     if (EVP_MD_CTX_set_params(ctx, params) > 0)
391         ret = ctx->digest->dfinal(ctx->provctx, md, &size, size);
392     EVP_MD_CTX_reset(ctx);
393     return ret;
394
395 legacy:
396     if (ctx->digest->flags & EVP_MD_FLAG_XOF
397         && size <= INT_MAX
398         && ctx->digest->md_ctrl(ctx, EVP_MD_CTRL_XOF_LEN, (int)size, NULL)) {
399         ret = ctx->digest->final(ctx, md);
400         if (ctx->digest->cleanup != NULL) {
401             ctx->digest->cleanup(ctx);
402             EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
403         }
404         OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
405     } else {
406         EVPerr(EVP_F_EVP_DIGESTFINALXOF, EVP_R_NOT_XOF_OR_INVALID_LENGTH);
407     }
408
409     return ret;
410 }
411
412 int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
413 {
414     EVP_MD_CTX_reset(out);
415     return EVP_MD_CTX_copy_ex(out, in);
416 }
417
418 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
419 {
420     unsigned char *tmp_buf;
421
422     if (in == NULL || in->digest == NULL) {
423         EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, EVP_R_INPUT_NOT_INITIALIZED);
424         return 0;
425     }
426
427     if (in->digest->prov == NULL
428             || (in->flags & EVP_MD_CTX_FLAG_NO_INIT) != 0)
429         goto legacy;
430
431     if (in->digest->dupctx == NULL) {
432         EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, EVP_R_NOT_ABLE_TO_COPY_CTX);
433         return 0;
434     }
435
436     EVP_MD_CTX_reset(out);
437     if (out->fetched_digest != NULL)
438         EVP_MD_free(out->fetched_digest);
439     *out = *in;
440     /* NULL out pointers in case of error */
441     out->pctx = NULL;
442     out->provctx = NULL;
443
444     if (in->fetched_digest != NULL)
445         EVP_MD_up_ref(in->fetched_digest);
446
447     out->provctx = in->digest->dupctx(in->provctx);
448     if (out->provctx == NULL) {
449         EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, EVP_R_NOT_ABLE_TO_COPY_CTX);
450         return 0;
451     }
452
453     /* copied EVP_MD_CTX should free the copied EVP_PKEY_CTX */
454     EVP_MD_CTX_clear_flags(out, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
455 #ifndef FIPS_MODULE
456     /* TODO(3.0): Temporarily no support for EVP_DigestSign* in FIPS module */
457     if (in->pctx != NULL) {
458         out->pctx = EVP_PKEY_CTX_dup(in->pctx);
459         if (out->pctx == NULL) {
460             EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, EVP_R_NOT_ABLE_TO_COPY_CTX);
461             EVP_MD_CTX_reset(out);
462             return 0;
463         }
464     }
465 #endif
466
467     return 1;
468
469     /* TODO(3.0): Remove legacy code below */
470  legacy:
471 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
472     /* Make sure it's safe to copy a digest context using an ENGINE */
473     if (in->engine && !ENGINE_init(in->engine)) {
474         EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, ERR_R_ENGINE_LIB);
475         return 0;
476     }
477 #endif
478
479     if (out->digest == in->digest) {
480         tmp_buf = out->md_data;
481         EVP_MD_CTX_set_flags(out, EVP_MD_CTX_FLAG_REUSE);
482     } else
483         tmp_buf = NULL;
484     EVP_MD_CTX_reset(out);
485     memcpy(out, in, sizeof(*out));
486
487     /* copied EVP_MD_CTX should free the copied EVP_PKEY_CTX */
488     EVP_MD_CTX_clear_flags(out, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
489
490     /* Null these variables, since they are getting fixed up
491      * properly below.  Anything else may cause a memleak and/or
492      * double free if any of the memory allocations below fail
493      */
494     out->md_data = NULL;
495     out->pctx = NULL;
496
497     if (in->md_data && out->digest->ctx_size) {
498         if (tmp_buf)
499             out->md_data = tmp_buf;
500         else {
501             out->md_data = OPENSSL_malloc(out->digest->ctx_size);
502             if (out->md_data == NULL) {
503                 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, ERR_R_MALLOC_FAILURE);
504                 return 0;
505             }
506         }
507         memcpy(out->md_data, in->md_data, out->digest->ctx_size);
508     }
509
510     out->update = in->update;
511
512 #ifndef FIPS_MODULE
513     /* TODO(3.0): Temporarily no support for EVP_DigestSign* in FIPS module */
514     if (in->pctx) {
515         out->pctx = EVP_PKEY_CTX_dup(in->pctx);
516         if (!out->pctx) {
517             EVP_MD_CTX_reset(out);
518             return 0;
519         }
520     }
521 #endif
522
523     if (out->digest->copy)
524         return out->digest->copy(out, in);
525
526     return 1;
527 }
528
529 int EVP_Digest(const void *data, size_t count,
530                unsigned char *md, unsigned int *size, const EVP_MD *type,
531                ENGINE *impl)
532 {
533     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
534     int ret;
535
536     if (ctx == NULL)
537         return 0;
538     EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT);
539     ret = EVP_DigestInit_ex(ctx, type, impl)
540         && EVP_DigestUpdate(ctx, data, count)
541         && EVP_DigestFinal_ex(ctx, md, size);
542     EVP_MD_CTX_free(ctx);
543
544     return ret;
545 }
546
547 int EVP_MD_get_params(const EVP_MD *digest, OSSL_PARAM params[])
548 {
549     if (digest != NULL && digest->get_params != NULL)
550         return digest->get_params(params);
551     return 0;
552 }
553
554 const OSSL_PARAM *EVP_MD_gettable_params(const EVP_MD *digest)
555 {
556     if (digest != NULL && digest->gettable_params != NULL)
557         return digest->gettable_params();
558     return NULL;
559 }
560
561 int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[])
562 {
563     EVP_PKEY_CTX *pctx = ctx->pctx;
564
565     if (ctx->digest != NULL && ctx->digest->set_ctx_params != NULL)
566         return ctx->digest->set_ctx_params(ctx->provctx, params);
567
568     if (pctx != NULL
569             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
570                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
571             && pctx->op.sig.sigprovctx != NULL
572             && pctx->op.sig.signature->set_ctx_md_params != NULL)
573         return pctx->op.sig.signature->set_ctx_md_params(pctx->op.sig.sigprovctx,
574                                                          params);
575     return 0;
576 }
577
578 const OSSL_PARAM *EVP_MD_settable_ctx_params(const EVP_MD *md)
579 {
580     if (md != NULL && md->settable_ctx_params != NULL)
581         return md->settable_ctx_params();
582     return NULL;
583 }
584
585 const OSSL_PARAM *EVP_MD_CTX_settable_params(EVP_MD_CTX *ctx)
586 {
587     EVP_PKEY_CTX *pctx;
588
589     if (ctx != NULL
590             && ctx->digest != NULL
591             && ctx->digest->settable_ctx_params != NULL)
592         return ctx->digest->settable_ctx_params();
593
594     pctx = ctx->pctx;
595     if (pctx != NULL
596             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
597                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
598             && pctx->op.sig.sigprovctx != NULL
599             && pctx->op.sig.signature->settable_ctx_md_params != NULL)
600         return pctx->op.sig.signature->settable_ctx_md_params(
601                    pctx->op.sig.sigprovctx);
602
603     return NULL;
604 }
605
606 int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[])
607 {
608     EVP_PKEY_CTX *pctx = ctx->pctx;
609
610     if (ctx->digest != NULL && ctx->digest->get_params != NULL)
611         return ctx->digest->get_ctx_params(ctx->provctx, params);
612
613     if (pctx != NULL
614             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
615                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
616             && pctx->op.sig.sigprovctx != NULL
617             && pctx->op.sig.signature->get_ctx_md_params != NULL)
618         return pctx->op.sig.signature->get_ctx_md_params(pctx->op.sig.sigprovctx,
619                                                          params);
620
621     return 0;
622 }
623
624 const OSSL_PARAM *EVP_MD_gettable_ctx_params(const EVP_MD *md)
625 {
626     if (md != NULL && md->gettable_ctx_params != NULL)
627         return md->gettable_ctx_params();
628     return NULL;
629 }
630
631 const OSSL_PARAM *EVP_MD_CTX_gettable_params(EVP_MD_CTX *ctx)
632 {
633     EVP_PKEY_CTX *pctx;
634
635     if (ctx != NULL
636             && ctx->digest != NULL
637             && ctx->digest->gettable_ctx_params != NULL)
638         return ctx->digest->gettable_ctx_params();
639
640     pctx = ctx->pctx;
641     if (pctx != NULL
642             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
643                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
644             && pctx->op.sig.sigprovctx != NULL
645             && pctx->op.sig.signature->gettable_ctx_md_params != NULL)
646         return pctx->op.sig.signature->gettable_ctx_md_params(
647                     pctx->op.sig.sigprovctx);
648
649     return NULL;
650 }
651
652 /* TODO(3.0): Remove legacy code below - only used by engines & DigestSign */
653 int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)
654 {
655     int ret = EVP_CTRL_RET_UNSUPPORTED;
656     int set_params = 1;
657     size_t sz;
658     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
659
660     if (ctx == NULL) {
661         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
662         return 0;
663     }
664
665     if (ctx->digest != NULL && ctx->digest->prov == NULL)
666         goto legacy;
667
668     switch (cmd) {
669     case EVP_MD_CTRL_XOF_LEN:
670         sz = (size_t)p1;
671         params[0] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &sz);
672         break;
673     case EVP_MD_CTRL_MICALG:
674         set_params = 0;
675         params[0] = OSSL_PARAM_construct_utf8_string(OSSL_DIGEST_PARAM_MICALG,
676                                                      p2, p1 ? p1 : 9999);
677         break;
678     case EVP_CTRL_SSL3_MASTER_SECRET:
679         params[0] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
680                                                       p2, p1);
681         break;
682     default:
683         goto conclude;
684     }
685
686     if (set_params)
687         ret = EVP_MD_CTX_set_params(ctx, params);
688     else
689         ret = EVP_MD_CTX_get_params(ctx, params);
690     goto conclude;
691
692
693 /* TODO(3.0): Remove legacy code below */
694  legacy:
695     if (ctx->digest->md_ctrl == NULL) {
696         ERR_raise(ERR_LIB_EVP, EVP_R_CTRL_NOT_IMPLEMENTED);
697         return 0;
698     }
699
700     ret = ctx->digest->md_ctrl(ctx, cmd, p1, p2);
701  conclude:
702     if (ret <= 0)
703         return 0;
704     return ret;
705 }
706
707 EVP_MD *evp_md_new(void)
708 {
709     EVP_MD *md = OPENSSL_zalloc(sizeof(*md));
710
711     if (md != NULL) {
712         md->lock = CRYPTO_THREAD_lock_new();
713         if (md->lock == NULL) {
714             OPENSSL_free(md);
715             return NULL;
716         }
717         md->refcnt = 1;
718     }
719     return md;
720 }
721
722 /*
723  * FIPS module note: since internal fetches will be entirely
724  * provider based, we know that none of its code depends on legacy
725  * NIDs or any functionality that use them.
726  */
727 #ifndef FIPS_MODULE
728 /* TODO(3.x) get rid of the need for legacy NIDs */
729 static void set_legacy_nid(const char *name, void *vlegacy_nid)
730 {
731     int nid;
732     int *legacy_nid = vlegacy_nid;
733     /*
734      * We use lowest level function to get the associated method, because
735      * higher level functions such as EVP_get_digestbyname() have changed
736      * to look at providers too.
737      */
738     const void *legacy_method = OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
739
740     if (*legacy_nid == -1)       /* We found a clash already */
741         return;
742
743     if (legacy_method == NULL)
744         return;
745     nid = EVP_MD_nid(legacy_method);
746     if (*legacy_nid != NID_undef && *legacy_nid != nid) {
747         *legacy_nid = -1;
748         return;
749     }
750     *legacy_nid = nid;
751 }
752 #endif
753
754 static void *evp_md_from_dispatch(int name_id,
755                                   const OSSL_DISPATCH *fns,
756                                   OSSL_PROVIDER *prov)
757 {
758     EVP_MD *md = NULL;
759     int fncnt = 0;
760
761     /* EVP_MD_fetch() will set the legacy NID if available */
762     if ((md = evp_md_new()) == NULL) {
763         EVPerr(0, ERR_R_MALLOC_FAILURE);
764         return NULL;
765     }
766
767 #ifndef FIPS_MODULE
768     /* TODO(3.x) get rid of the need for legacy NIDs */
769     md->type = NID_undef;
770     evp_names_do_all(prov, name_id, set_legacy_nid, &md->type);
771     if (md->type == -1) {
772         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
773         EVP_MD_free(md);
774         return NULL;
775     }
776 #endif
777
778     md->name_id = name_id;
779
780     for (; fns->function_id != 0; fns++) {
781         switch (fns->function_id) {
782         case OSSL_FUNC_DIGEST_NEWCTX:
783             if (md->newctx == NULL) {
784                 md->newctx = OSSL_get_OP_digest_newctx(fns);
785                 fncnt++;
786             }
787             break;
788         case OSSL_FUNC_DIGEST_INIT:
789             if (md->dinit == NULL) {
790                 md->dinit = OSSL_get_OP_digest_init(fns);
791                 fncnt++;
792             }
793             break;
794         case OSSL_FUNC_DIGEST_UPDATE:
795             if (md->dupdate == NULL) {
796                 md->dupdate = OSSL_get_OP_digest_update(fns);
797                 fncnt++;
798             }
799             break;
800         case OSSL_FUNC_DIGEST_FINAL:
801             if (md->dfinal == NULL) {
802                 md->dfinal = OSSL_get_OP_digest_final(fns);
803                 fncnt++;
804             }
805             break;
806         case OSSL_FUNC_DIGEST_DIGEST:
807             if (md->digest == NULL)
808                 md->digest = OSSL_get_OP_digest_digest(fns);
809             /* We don't increment fnct for this as it is stand alone */
810             break;
811         case OSSL_FUNC_DIGEST_FREECTX:
812             if (md->freectx == NULL) {
813                 md->freectx = OSSL_get_OP_digest_freectx(fns);
814                 fncnt++;
815             }
816             break;
817         case OSSL_FUNC_DIGEST_DUPCTX:
818             if (md->dupctx == NULL)
819                 md->dupctx = OSSL_get_OP_digest_dupctx(fns);
820             break;
821         case OSSL_FUNC_DIGEST_GET_PARAMS:
822             if (md->get_params == NULL)
823                 md->get_params = OSSL_get_OP_digest_get_params(fns);
824             break;
825         case OSSL_FUNC_DIGEST_SET_CTX_PARAMS:
826             if (md->set_ctx_params == NULL)
827                 md->set_ctx_params = OSSL_get_OP_digest_set_ctx_params(fns);
828             break;
829         case OSSL_FUNC_DIGEST_GET_CTX_PARAMS:
830             if (md->get_ctx_params == NULL)
831                 md->get_ctx_params = OSSL_get_OP_digest_get_ctx_params(fns);
832             break;
833         case OSSL_FUNC_DIGEST_GETTABLE_PARAMS:
834             if (md->gettable_params == NULL)
835                 md->gettable_params = OSSL_get_OP_digest_gettable_params(fns);
836             break;
837         case OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS:
838             if (md->settable_ctx_params == NULL)
839                 md->settable_ctx_params =
840                     OSSL_get_OP_digest_settable_ctx_params(fns);
841             break;
842         case OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS:
843             if (md->gettable_ctx_params == NULL)
844                 md->gettable_ctx_params =
845                     OSSL_get_OP_digest_gettable_ctx_params(fns);
846             break;
847         }
848     }
849     if ((fncnt != 0 && fncnt != 5)
850         || (fncnt == 0 && md->digest == NULL)) {
851         /*
852          * In order to be a consistent set of functions we either need the
853          * whole set of init/update/final etc functions or none of them.
854          * The "digest" function can standalone. We at least need one way to
855          * generate digests.
856          */
857         EVP_MD_free(md);
858         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
859         return NULL;
860     }
861     md->prov = prov;
862     if (prov != NULL)
863         ossl_provider_up_ref(prov);
864
865     return md;
866 }
867
868 static int evp_md_up_ref(void *md)
869 {
870     return EVP_MD_up_ref(md);
871 }
872
873 static void evp_md_free(void *md)
874 {
875     EVP_MD_free(md);
876 }
877
878 EVP_MD *EVP_MD_fetch(OPENSSL_CTX *ctx, const char *algorithm,
879                      const char *properties)
880 {
881     EVP_MD *md =
882         evp_generic_fetch(ctx, OSSL_OP_DIGEST, algorithm, properties,
883                           evp_md_from_dispatch, evp_md_up_ref, evp_md_free);
884
885     return md;
886 }
887
888 int EVP_MD_up_ref(EVP_MD *md)
889 {
890     int ref = 0;
891
892     CRYPTO_UP_REF(&md->refcnt, &ref, md->lock);
893     return 1;
894 }
895
896 void EVP_MD_free(EVP_MD *md)
897 {
898     int i;
899
900     if (md == NULL)
901         return;
902
903     CRYPTO_DOWN_REF(&md->refcnt, &i, md->lock);
904     if (i > 0)
905         return;
906     ossl_provider_free(md->prov);
907     CRYPTO_THREAD_lock_free(md->lock);
908     OPENSSL_free(md);
909 }
910
911 void EVP_MD_do_all_provided(OPENSSL_CTX *libctx,
912                             void (*fn)(EVP_MD *mac, void *arg),
913                             void *arg)
914 {
915     evp_generic_do_all(libctx, OSSL_OP_DIGEST,
916                        (void (*)(void *, void *))fn, arg,
917                        evp_md_from_dispatch, evp_md_free);
918 }