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_FUNC_digest_newctx(fns);
 785                 fncnt++;
 786             }
 787             break;
 788         case OSSL_FUNC_DIGEST_INIT:
 789             if (md->dinit == NULL) {
 790                 md->dinit = OSSL_FUNC_digest_init(fns);
 791                 fncnt++;
 792             }
 793             break;
 794         case OSSL_FUNC_DIGEST_UPDATE:
 795             if (md->dupdate == NULL) {
 796                 md->dupdate = OSSL_FUNC_digest_update(fns);
 797                 fncnt++;
 798             }
 799             break;
 800         case OSSL_FUNC_DIGEST_FINAL:
 801             if (md->dfinal == NULL) {
 802                 md->dfinal = OSSL_FUNC_digest_final(fns);
 803                 fncnt++;
 804             }
 805             break;
 806         case OSSL_FUNC_DIGEST_DIGEST:
 807             if (md->digest == NULL)
 808                 md->digest = OSSL_FUNC_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_FUNC_digest_freectx(fns);
 814                 fncnt++;
 815             }
 816             break;
 817         case OSSL_FUNC_DIGEST_DUPCTX:
 818             if (md->dupctx == NULL)
 819                 md->dupctx = OSSL_FUNC_digest_dupctx(fns);
 820             break;
 821         case OSSL_FUNC_DIGEST_GET_PARAMS:
 822             if (md->get_params == NULL)
 823                 md->get_params = OSSL_FUNC_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_FUNC_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_FUNC_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_FUNC_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_FUNC_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_FUNC_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 }