crypto/evp/digest.c

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