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 /* 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             return 0;
 240         type = provmd;
 241         EVP_MD_free(ctx->fetched_digest);
 242         ctx->fetched_digest = provmd;
 243 #endif
 244     }
 245
 246     if (ctx->provctx != NULL && ctx->digest != NULL && ctx->digest != type) {
 247         if (ctx->digest->freectx != NULL)
 248             ctx->digest->freectx(ctx->provctx);
 249         ctx->provctx = NULL;
 250     }
 251     ctx->digest = type;
 252     if (ctx->provctx == NULL) {
 253         ctx->provctx = ctx->digest->newctx(ossl_provider_ctx(type->prov));
 254         if (ctx->provctx == NULL) {
 255             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 256             return 0;
 257         }
 258     }
 259
 260     if (ctx->digest->dinit == NULL) {
 261         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 262         return 0;
 263     }
 264
 265     return ctx->digest->dinit(ctx->provctx);
 266
 267     /* TODO(3.0): Remove legacy code below */
 268  legacy:
 269
 270 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 271     if (type) {
 272         if (impl != NULL) {
 273             if (!ENGINE_init(impl)) {
 274                 ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 275                 return 0;
 276             }
 277         } else {
 278             /* Ask if an ENGINE is reserved for this job */
 279             impl = tmpimpl;
 280         }
 281         if (impl != NULL) {
 282             /* There's an ENGINE for this job ... (apparently) */
 283             const EVP_MD *d = ENGINE_get_digest(impl, type->type);
 284
 285             if (d == NULL) {
 286                 ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 287                 ENGINE_finish(impl);
 288                 return 0;
 289             }
 290             /* We'll use the ENGINE's private digest definition */
 291             type = d;
 292             /*
 293              * Store the ENGINE functional reference so we know 'type' came
 294              * from an ENGINE and we need to release it when done.
 295              */
 296             ctx->engine = impl;
 297         } else
 298             ctx->engine = NULL;
 299     }
 300 #endif
 301     if (ctx->digest != type) {
 302         if (ctx->digest && ctx->digest->ctx_size) {
 303             OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
 304             ctx->md_data = NULL;
 305         }
 306         ctx->digest = type;
 307         if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) && type->ctx_size) {
 308             ctx->update = type->update;
 309             ctx->md_data = OPENSSL_zalloc(type->ctx_size);
 310             if (ctx->md_data == NULL) {
 311                 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
 312                 return 0;
 313             }
 314         }
 315     }
 316 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 317  skip_to_init:
 318 #endif
 319 #ifndef FIPS_MODULE
 320     /*
 321      * TODO(3.0): Temporarily no support for EVP_DigestSign* inside FIPS module
 322      * or when using providers.
 323      */
 324     if (ctx->pctx != NULL
 325             && (!EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx->pctx)
 326                  || ctx->pctx->op.sig.signature == NULL)) {
 327         int r;
 328         r = EVP_PKEY_CTX_ctrl(ctx->pctx, -1, EVP_PKEY_OP_TYPE_SIG,
 329                               EVP_PKEY_CTRL_DIGESTINIT, 0, ctx);
 330         if (r <= 0 && (r != -2))
 331             return 0;
 332     }
 333 #endif
 334     if (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT)
 335         return 1;
 336     return ctx->digest->init(ctx);
 337 }
 338
 339 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
 340 {
 341     if (count == 0)
 342         return 1;
 343
 344     if (ctx->pctx != NULL
 345             && EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx->pctx)
 346             && ctx->pctx->op.sig.sigprovctx != NULL) {
 347         /*
 348          * Prior to OpenSSL 3.0 EVP_DigestSignUpdate() and
 349          * EVP_DigestVerifyUpdate() were just macros for EVP_DigestUpdate().
 350          * Some code calls EVP_DigestUpdate() directly even when initialised
 351          * with EVP_DigestSignInit_ex() or
 352          * EVP_DigestVerifyInit_ex(), so we detect that and redirect to
 353          * the correct EVP_Digest*Update() function
 354          */
 355         if (ctx->pctx->operation == EVP_PKEY_OP_SIGNCTX)
 356             return EVP_DigestSignUpdate(ctx, data, count);
 357         if (ctx->pctx->operation == EVP_PKEY_OP_VERIFYCTX)
 358             return EVP_DigestVerifyUpdate(ctx, data, count);
 359         ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
 360         return 0;
 361     }
 362
 363     if (ctx->digest == NULL
 364             || ctx->digest->prov == NULL
 365             || (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) != 0)
 366         goto legacy;
 367
 368     if (ctx->digest->dupdate == NULL) {
 369         ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
 370         return 0;
 371     }
 372     return ctx->digest->dupdate(ctx->provctx, data, count);
 373
 374     /* TODO(3.0): Remove legacy code below */
 375  legacy:
 376     return ctx->update(ctx, data, count);
 377 }
 378
 379 /* The caller can assume that this removes any secret data from the context */
 380 int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
 381 {
 382     int ret;
 383     ret = EVP_DigestFinal_ex(ctx, md, size);
 384     EVP_MD_CTX_reset(ctx);
 385     return ret;
 386 }
 387
 388 /* The caller can assume that this removes any secret data from the context */
 389 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *isize)
 390 {
 391     int ret, sz;
 392     size_t size = 0;
 393     size_t mdsize = 0;
 394
 395     if (ctx->digest == NULL)
 396         return 0;
 397
 398     sz = EVP_MD_size(ctx->digest);
 399     if (sz < 0)
 400         return 0;
 401     mdsize = sz;
 402     if (ctx->digest->prov == NULL)
 403         goto legacy;
 404
 405     if (ctx->digest->dfinal == NULL) {
 406         ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 407         return 0;
 408     }
 409
 410     ret = ctx->digest->dfinal(ctx->provctx, md, &size, mdsize);
 411
 412     if (isize != NULL) {
 413         if (size <= UINT_MAX) {
 414             *isize = (int)size;
 415         } else {
 416             ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 417             ret = 0;
 418         }
 419     }
 420
 421     return ret;
 422
 423     /* TODO(3.0): Remove legacy code below */
 424  legacy:
 425     OPENSSL_assert(mdsize <= EVP_MAX_MD_SIZE);
 426     ret = ctx->digest->final(ctx, md);
 427     if (isize != NULL)
 428         *isize = mdsize;
 429     if (ctx->digest->cleanup) {
 430         ctx->digest->cleanup(ctx);
 431         EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
 432     }
 433     OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
 434     return ret;
 435 }
 436
 437 int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md, size_t size)
 438 {
 439     int ret = 0;
 440     OSSL_PARAM params[2];
 441     size_t i = 0;
 442
 443     if (ctx->digest == NULL || ctx->digest->prov == NULL)
 444         goto legacy;
 445
 446     if (ctx->digest->dfinal == NULL) {
 447         ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
 448         return 0;
 449     }
 450
 451     params[i++] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &size);
 452     params[i++] = OSSL_PARAM_construct_end();
 453
 454     if (EVP_MD_CTX_set_params(ctx, params) > 0)
 455         ret = ctx->digest->dfinal(ctx->provctx, md, &size, size);
 456
 457     return ret;
 458
 459 legacy:
 460     if (ctx->digest->flags & EVP_MD_FLAG_XOF
 461         && size <= INT_MAX
 462         && ctx->digest->md_ctrl(ctx, EVP_MD_CTRL_XOF_LEN, (int)size, NULL)) {
 463         ret = ctx->digest->final(ctx, md);
 464         if (ctx->digest->cleanup != NULL) {
 465             ctx->digest->cleanup(ctx);
 466             EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
 467         }
 468         OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
 469     } else {
 470         ERR_raise(ERR_LIB_EVP, EVP_R_NOT_XOF_OR_INVALID_LENGTH);
 471     }
 472
 473     return ret;
 474 }
 475
 476 int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
 477 {
 478     EVP_MD_CTX_reset(out);
 479     return EVP_MD_CTX_copy_ex(out, in);
 480 }
 481
 482 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
 483 {
 484     unsigned char *tmp_buf;
 485
 486     if (in == NULL || in->digest == NULL) {
 487         ERR_raise(ERR_LIB_EVP, EVP_R_INPUT_NOT_INITIALIZED);
 488         return 0;
 489     }
 490
 491     if (in->digest->prov == NULL
 492             || (in->flags & EVP_MD_CTX_FLAG_NO_INIT) != 0)
 493         goto legacy;
 494
 495     if (in->digest->dupctx == NULL) {
 496         ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX);
 497         return 0;
 498     }
 499
 500     EVP_MD_CTX_reset(out);
 501     if (out->fetched_digest != NULL)
 502         EVP_MD_free(out->fetched_digest);
 503     *out = *in;
 504     /* NULL out pointers in case of error */
 505     out->pctx = NULL;
 506     out->provctx = NULL;
 507
 508     if (in->fetched_digest != NULL)
 509         EVP_MD_up_ref(in->fetched_digest);
 510
 511     if (in->provctx != NULL) {
 512         out->provctx = in->digest->dupctx(in->provctx);
 513         if (out->provctx == NULL) {
 514             ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX);
 515             return 0;
 516         }
 517     }
 518
 519     /* copied EVP_MD_CTX should free the copied EVP_PKEY_CTX */
 520     EVP_MD_CTX_clear_flags(out, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
 521 #ifndef FIPS_MODULE
 522     /* TODO(3.0): Temporarily no support for EVP_DigestSign* in FIPS module */
 523     if (in->pctx != NULL) {
 524         out->pctx = EVP_PKEY_CTX_dup(in->pctx);
 525         if (out->pctx == NULL) {
 526             ERR_raise(ERR_LIB_EVP, EVP_R_NOT_ABLE_TO_COPY_CTX);
 527             EVP_MD_CTX_reset(out);
 528             return 0;
 529         }
 530     }
 531 #endif
 532
 533     return 1;
 534
 535     /* TODO(3.0): Remove legacy code below */
 536  legacy:
 537 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 538     /* Make sure it's safe to copy a digest context using an ENGINE */
 539     if (in->engine && !ENGINE_init(in->engine)) {
 540         ERR_raise(ERR_LIB_EVP, ERR_R_ENGINE_LIB);
 541         return 0;
 542     }
 543 #endif
 544
 545     if (out->digest == in->digest) {
 546         tmp_buf = out->md_data;
 547         EVP_MD_CTX_set_flags(out, EVP_MD_CTX_FLAG_REUSE);
 548     } else
 549         tmp_buf = NULL;
 550     EVP_MD_CTX_reset(out);
 551     memcpy(out, in, sizeof(*out));
 552
 553     /* copied EVP_MD_CTX should free the copied EVP_PKEY_CTX */
 554     EVP_MD_CTX_clear_flags(out, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
 555
 556     /* Null these variables, since they are getting fixed up
 557      * properly below.  Anything else may cause a memleak and/or
 558      * double free if any of the memory allocations below fail
 559      */
 560     out->md_data = NULL;
 561     out->pctx = NULL;
 562
 563     if (in->md_data && out->digest->ctx_size) {
 564         if (tmp_buf)
 565             out->md_data = tmp_buf;
 566         else {
 567             out->md_data = OPENSSL_malloc(out->digest->ctx_size);
 568             if (out->md_data == NULL) {
 569                 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
 570                 return 0;
 571             }
 572         }
 573         memcpy(out->md_data, in->md_data, out->digest->ctx_size);
 574     }
 575
 576     out->update = in->update;
 577
 578 #ifndef FIPS_MODULE
 579     /* TODO(3.0): Temporarily no support for EVP_DigestSign* in FIPS module */
 580     if (in->pctx) {
 581         out->pctx = EVP_PKEY_CTX_dup(in->pctx);
 582         if (!out->pctx) {
 583             EVP_MD_CTX_reset(out);
 584             return 0;
 585         }
 586     }
 587 #endif
 588
 589     if (out->digest->copy)
 590         return out->digest->copy(out, in);
 591
 592     return 1;
 593 }
 594
 595 int EVP_Digest(const void *data, size_t count,
 596                unsigned char *md, unsigned int *size, const EVP_MD *type,
 597                ENGINE *impl)
 598 {
 599     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
 600     int ret;
 601
 602     if (ctx == NULL)
 603         return 0;
 604     EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT);
 605     ret = EVP_DigestInit_ex(ctx, type, impl)
 606         && EVP_DigestUpdate(ctx, data, count)
 607         && EVP_DigestFinal_ex(ctx, md, size);
 608     EVP_MD_CTX_free(ctx);
 609
 610     return ret;
 611 }
 612
 613 int EVP_MD_get_params(const EVP_MD *digest, OSSL_PARAM params[])
 614 {
 615     if (digest != NULL && digest->get_params != NULL)
 616         return digest->get_params(params);
 617     return 0;
 618 }
 619
 620 const OSSL_PARAM *EVP_MD_gettable_params(const EVP_MD *digest)
 621 {
 622     if (digest != NULL && digest->gettable_params != NULL)
 623         return digest->gettable_params(
 624                            ossl_provider_ctx(EVP_MD_provider(digest)));
 625     return NULL;
 626 }
 627
 628 int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[])
 629 {
 630     EVP_PKEY_CTX *pctx = ctx->pctx;
 631
 632     /* If we have a pctx then we should try that first */
 633     if (pctx != NULL
 634             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
 635                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
 636             && pctx->op.sig.sigprovctx != NULL
 637             && pctx->op.sig.signature->set_ctx_md_params != NULL)
 638         return pctx->op.sig.signature->set_ctx_md_params(pctx->op.sig.sigprovctx,
 639                                                          params);
 640
 641     if (ctx->digest != NULL && ctx->digest->set_ctx_params != NULL)
 642         return ctx->digest->set_ctx_params(ctx->provctx, params);
 643
 644     return 0;
 645 }
 646
 647 const OSSL_PARAM *EVP_MD_settable_ctx_params(const EVP_MD *md)
 648 {
 649     if (md != NULL && md->settable_ctx_params != NULL)
 650         return md->settable_ctx_params(ossl_provider_ctx(EVP_MD_provider(md)));
 651     return NULL;
 652 }
 653
 654 const OSSL_PARAM *EVP_MD_CTX_settable_params(EVP_MD_CTX *ctx)
 655 {
 656     EVP_PKEY_CTX *pctx;
 657
 658     if (ctx == NULL)
 659         return NULL;
 660
 661     /* If we have a pctx then we should try that first */
 662     pctx = ctx->pctx;
 663     if (pctx != NULL
 664             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
 665                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
 666             && pctx->op.sig.sigprovctx != NULL
 667             && pctx->op.sig.signature->settable_ctx_md_params != NULL)
 668         return pctx->op.sig.signature->settable_ctx_md_params(
 669                    pctx->op.sig.sigprovctx);
 670
 671     if (ctx->digest != NULL && ctx->digest->settable_ctx_params != NULL)
 672         return ctx->digest->settable_ctx_params(
 673                   ossl_provider_ctx(EVP_MD_provider(ctx->digest)));
 674
 675     return NULL;
 676 }
 677
 678 int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[])
 679 {
 680     EVP_PKEY_CTX *pctx = ctx->pctx;
 681
 682     /* If we have a pctx then we should try that first */
 683     if (pctx != NULL
 684             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
 685                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
 686             && pctx->op.sig.sigprovctx != NULL
 687             && pctx->op.sig.signature->get_ctx_md_params != NULL)
 688         return pctx->op.sig.signature->get_ctx_md_params(pctx->op.sig.sigprovctx,
 689                                                          params);
 690
 691     if (ctx->digest != NULL && ctx->digest->get_params != NULL)
 692         return ctx->digest->get_ctx_params(ctx->provctx, params);
 693
 694     return 0;
 695 }
 696
 697 const OSSL_PARAM *EVP_MD_gettable_ctx_params(const EVP_MD *md)
 698 {
 699     if (md != NULL && md->gettable_ctx_params != NULL)
 700         return md->gettable_ctx_params(ossl_provider_ctx(EVP_MD_provider(md)));
 701     return NULL;
 702 }
 703
 704 const OSSL_PARAM *EVP_MD_CTX_gettable_params(EVP_MD_CTX *ctx)
 705 {
 706     EVP_PKEY_CTX *pctx;
 707
 708     if (ctx == NULL)
 709         return NULL;
 710
 711     /* If we have a pctx then we should try that first */
 712     pctx = ctx->pctx;
 713     if (pctx != NULL
 714             && (pctx->operation == EVP_PKEY_OP_VERIFYCTX
 715                 || pctx->operation == EVP_PKEY_OP_SIGNCTX)
 716             && pctx->op.sig.sigprovctx != NULL
 717             && pctx->op.sig.signature->gettable_ctx_md_params != NULL)
 718         return pctx->op.sig.signature->gettable_ctx_md_params(
 719                     pctx->op.sig.sigprovctx);
 720
 721     if (ctx->digest != NULL
 722             && ctx->digest->gettable_ctx_params != NULL)
 723         return ctx->digest->gettable_ctx_params(
 724                    ossl_provider_ctx(EVP_MD_provider(ctx->digest)));
 725
 726     return NULL;
 727 }
 728
 729 /* TODO(3.0): Remove legacy code below - only used by engines & DigestSign */
 730 int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)
 731 {
 732     int ret = EVP_CTRL_RET_UNSUPPORTED;
 733     int set_params = 1;
 734     size_t sz;
 735     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
 736
 737     if (ctx == NULL) {
 738         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_NULL_PARAMETER);
 739         return 0;
 740     }
 741
 742     if (ctx->digest != NULL && ctx->digest->prov == NULL)
 743         goto legacy;
 744
 745     switch (cmd) {
 746     case EVP_MD_CTRL_XOF_LEN:
 747         sz = (size_t)p1;
 748         params[0] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &sz);
 749         break;
 750     case EVP_MD_CTRL_MICALG:
 751         set_params = 0;
 752         params[0] = OSSL_PARAM_construct_utf8_string(OSSL_DIGEST_PARAM_MICALG,
 753                                                      p2, p1 ? p1 : 9999);
 754         break;
 755     case EVP_CTRL_SSL3_MASTER_SECRET:
 756         params[0] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
 757                                                       p2, p1);
 758         break;
 759     default:
 760         goto conclude;
 761     }
 762
 763     if (set_params)
 764         ret = EVP_MD_CTX_set_params(ctx, params);
 765     else
 766         ret = EVP_MD_CTX_get_params(ctx, params);
 767     goto conclude;
 768
 769
 770 /* TODO(3.0): Remove legacy code below */
 771  legacy:
 772     if (ctx->digest->md_ctrl == NULL) {
 773         ERR_raise(ERR_LIB_EVP, EVP_R_CTRL_NOT_IMPLEMENTED);
 774         return 0;
 775     }
 776
 777     ret = ctx->digest->md_ctrl(ctx, cmd, p1, p2);
 778  conclude:
 779     if (ret <= 0)
 780         return 0;
 781     return ret;
 782 }
 783
 784 EVP_MD *evp_md_new(void)
 785 {
 786     EVP_MD *md = OPENSSL_zalloc(sizeof(*md));
 787
 788     if (md != NULL) {
 789         md->lock = CRYPTO_THREAD_lock_new();
 790         if (md->lock == NULL) {
 791             OPENSSL_free(md);
 792             return NULL;
 793         }
 794         md->refcnt = 1;
 795     }
 796     return md;
 797 }
 798
 799 /*
 800  * FIPS module note: since internal fetches will be entirely
 801  * provider based, we know that none of its code depends on legacy
 802  * NIDs or any functionality that use them.
 803  */
 804 #ifndef FIPS_MODULE
 805 /* TODO(3.x) get rid of the need for legacy NIDs */
 806 static void set_legacy_nid(const char *name, void *vlegacy_nid)
 807 {
 808     int nid;
 809     int *legacy_nid = vlegacy_nid;
 810     /*
 811      * We use lowest level function to get the associated method, because
 812      * higher level functions such as EVP_get_digestbyname() have changed
 813      * to look at providers too.
 814      */
 815     const void *legacy_method = OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
 816
 817     if (*legacy_nid == -1)       /* We found a clash already */
 818         return;
 819
 820     if (legacy_method == NULL)
 821         return;
 822     nid = EVP_MD_nid(legacy_method);
 823     if (*legacy_nid != NID_undef && *legacy_nid != nid) {
 824         *legacy_nid = -1;
 825         return;
 826     }
 827     *legacy_nid = nid;
 828 }
 829 #endif
 830
 831 static int evp_md_cache_constants(EVP_MD *md)
 832 {
 833     int ok, xof = 0, algid_absent = 0;
 834     size_t blksz = 0;
 835     size_t mdsize = 0;
 836     OSSL_PARAM params[5];
 837
 838     params[0] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_BLOCK_SIZE, &blksz);
 839     params[1] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_SIZE, &mdsize);
 840     params[2] = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_XOF, &xof);
 841     params[3] = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_ALGID_ABSENT,
 842                                          &algid_absent);
 843     params[4] = OSSL_PARAM_construct_end();
 844     ok = evp_do_md_getparams(md, params);
 845     if (mdsize > INT_MAX || blksz > INT_MAX)
 846         ok = 0;
 847     if (ok) {
 848         md->block_size = (int)blksz;
 849         md->md_size = (int)mdsize;
 850         if (xof)
 851             md->flags |= EVP_MD_FLAG_XOF;
 852         if (algid_absent)
 853             md->flags |= EVP_MD_FLAG_DIGALGID_ABSENT;
 854     }
 855     return ok;
 856 }
 857
 858 static void *evp_md_from_dispatch(int name_id,
 859                                   const OSSL_DISPATCH *fns,
 860                                   OSSL_PROVIDER *prov)
 861 {
 862     EVP_MD *md = NULL;
 863     int fncnt = 0;
 864
 865     /* EVP_MD_fetch() will set the legacy NID if available */
 866     if ((md = evp_md_new()) == NULL) {
 867         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
 868         return NULL;
 869     }
 870
 871 #ifndef FIPS_MODULE
 872     /* TODO(3.x) get rid of the need for legacy NIDs */
 873     md->type = NID_undef;
 874     evp_names_do_all(prov, name_id, set_legacy_nid, &md->type);
 875     if (md->type == -1) {
 876         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 877         EVP_MD_free(md);
 878         return NULL;
 879     }
 880 #endif
 881
 882     md->name_id = name_id;
 883
 884     for (; fns->function_id != 0; fns++) {
 885         switch (fns->function_id) {
 886         case OSSL_FUNC_DIGEST_NEWCTX:
 887             if (md->newctx == NULL) {
 888                 md->newctx = OSSL_FUNC_digest_newctx(fns);
 889                 fncnt++;
 890             }
 891             break;
 892         case OSSL_FUNC_DIGEST_INIT:
 893             if (md->dinit == NULL) {
 894                 md->dinit = OSSL_FUNC_digest_init(fns);
 895                 fncnt++;
 896             }
 897             break;
 898         case OSSL_FUNC_DIGEST_UPDATE:
 899             if (md->dupdate == NULL) {
 900                 md->dupdate = OSSL_FUNC_digest_update(fns);
 901                 fncnt++;
 902             }
 903             break;
 904         case OSSL_FUNC_DIGEST_FINAL:
 905             if (md->dfinal == NULL) {
 906                 md->dfinal = OSSL_FUNC_digest_final(fns);
 907                 fncnt++;
 908             }
 909             break;
 910         case OSSL_FUNC_DIGEST_DIGEST:
 911             if (md->digest == NULL)
 912                 md->digest = OSSL_FUNC_digest_digest(fns);
 913             /* We don't increment fnct for this as it is stand alone */
 914             break;
 915         case OSSL_FUNC_DIGEST_FREECTX:
 916             if (md->freectx == NULL) {
 917                 md->freectx = OSSL_FUNC_digest_freectx(fns);
 918                 fncnt++;
 919             }
 920             break;
 921         case OSSL_FUNC_DIGEST_DUPCTX:
 922             if (md->dupctx == NULL)
 923                 md->dupctx = OSSL_FUNC_digest_dupctx(fns);
 924             break;
 925         case OSSL_FUNC_DIGEST_GET_PARAMS:
 926             if (md->get_params == NULL)
 927                 md->get_params = OSSL_FUNC_digest_get_params(fns);
 928             break;
 929         case OSSL_FUNC_DIGEST_SET_CTX_PARAMS:
 930             if (md->set_ctx_params == NULL)
 931                 md->set_ctx_params = OSSL_FUNC_digest_set_ctx_params(fns);
 932             break;
 933         case OSSL_FUNC_DIGEST_GET_CTX_PARAMS:
 934             if (md->get_ctx_params == NULL)
 935                 md->get_ctx_params = OSSL_FUNC_digest_get_ctx_params(fns);
 936             break;
 937         case OSSL_FUNC_DIGEST_GETTABLE_PARAMS:
 938             if (md->gettable_params == NULL)
 939                 md->gettable_params = OSSL_FUNC_digest_gettable_params(fns);
 940             break;
 941         case OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS:
 942             if (md->settable_ctx_params == NULL)
 943                 md->settable_ctx_params =
 944                     OSSL_FUNC_digest_settable_ctx_params(fns);
 945             break;
 946         case OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS:
 947             if (md->gettable_ctx_params == NULL)
 948                 md->gettable_ctx_params =
 949                     OSSL_FUNC_digest_gettable_ctx_params(fns);
 950             break;
 951         }
 952     }
 953     if ((fncnt != 0 && fncnt != 5)
 954         || (fncnt == 0 && md->digest == NULL)) {
 955         /*
 956          * In order to be a consistent set of functions we either need the
 957          * whole set of init/update/final etc functions or none of them.
 958          * The "digest" function can standalone. We at least need one way to
 959          * generate digests.
 960          */
 961         EVP_MD_free(md);
 962         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
 963         return NULL;
 964     }
 965     md->prov = prov;
 966     if (prov != NULL)
 967         ossl_provider_up_ref(prov);
 968
 969     if (!evp_md_cache_constants(md)) {
 970         EVP_MD_free(md);
 971         ERR_raise(ERR_LIB_EVP, EVP_R_CACHE_CONSTANTS_FAILED);
 972         md = NULL;
 973     }
 974
 975     return md;
 976 }
 977
 978 static int evp_md_up_ref(void *md)
 979 {
 980     return EVP_MD_up_ref(md);
 981 }
 982
 983 static void evp_md_free(void *md)
 984 {
 985     EVP_MD_free(md);
 986 }
 987
 988 EVP_MD *EVP_MD_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
 989                      const char *properties)
 990 {
 991     EVP_MD *md =
 992         evp_generic_fetch(ctx, OSSL_OP_DIGEST, algorithm, properties,
 993                           evp_md_from_dispatch, evp_md_up_ref, evp_md_free);
 994
 995     return md;
 996 }
 997
 998 int EVP_MD_up_ref(EVP_MD *md)
 999 {
1000     int ref = 0;
1001
1002     CRYPTO_UP_REF(&md->refcnt, &ref, md->lock);
1003     return 1;
1004 }
1005
1006 void EVP_MD_free(EVP_MD *md)
1007 {
1008     int i;
1009
1010     if (md == NULL)
1011         return;
1012
1013     CRYPTO_DOWN_REF(&md->refcnt, &i, md->lock);
1014     if (i > 0)
1015         return;
1016     ossl_provider_free(md->prov);
1017     CRYPTO_THREAD_lock_free(md->lock);
1018     OPENSSL_free(md);
1019 }
1020
1021 void EVP_MD_do_all_provided(OSSL_LIB_CTX *libctx,
1022                             void (*fn)(EVP_MD *mac, void *arg),
1023                             void *arg)
1024 {
1025     evp_generic_do_all(libctx, OSSL_OP_DIGEST,
1026                        (void (*)(void *, void *))fn, arg,
1027                        evp_md_from_dispatch, evp_md_free);
1028 }