crypto/evp/digest.c

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