crypto/evp/m_sigver.c

   1 /*
   2  * Copyright 2006-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 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/evp.h>
  13 #include <openssl/objects.h>
  14 #include "crypto/evp.h"
  15 #include "internal/provider.h"
  16 #include "internal/numbers.h"   /* includes SIZE_MAX */
  17 #include "evp_local.h"
  18
  19 #ifndef FIPS_MODULE
  20
  21 static int update(EVP_MD_CTX *ctx, const void *data, size_t datalen)
  22 {
  23     ERR_raise(ERR_LIB_EVP, EVP_R_ONLY_ONESHOT_SUPPORTED);
  24     return 0;
  25 }
  26
  27 /*
  28  * If we get the "NULL" md then the name comes back as "UNDEF". We want to use
  29  * NULL for this.
  30  */
  31 static const char *canon_mdname(const char *mdname)
  32 {
  33     if (mdname != NULL && strcmp(mdname, "UNDEF") == 0)
  34         return NULL;
  35
  36     return mdname;
  37 }
  38
  39 static int do_sigver_init(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
  40                           const EVP_MD *type, const char *mdname,
  41                           OSSL_LIB_CTX *libctx, const char *props,
  42                           ENGINE *e, EVP_PKEY *pkey, int ver,
  43                           const OSSL_PARAM params[])
  44 {
  45     EVP_PKEY_CTX *locpctx = NULL;
  46     EVP_SIGNATURE *signature = NULL;
  47     EVP_KEYMGMT *tmp_keymgmt = NULL;
  48     const OSSL_PROVIDER *tmp_prov = NULL;
  49     const char *supported_sig = NULL;
  50     char locmdname[80] = "";     /* 80 chars should be enough */
  51     void *provkey = NULL;
  52     int ret, iter, reinit = 1;
  53
  54     if (!evp_md_ctx_free_algctx(ctx))
  55         return 0;
  56
  57     if (ctx->pctx == NULL) {
  58         reinit = 0;
  59         if (e == NULL)
  60             ctx->pctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, props);
  61         else
  62             ctx->pctx = EVP_PKEY_CTX_new(pkey, e);
  63     }
  64     if (ctx->pctx == NULL)
  65         return 0;
  66
  67     locpctx = ctx->pctx;
  68     ERR_set_mark();
  69
  70     if (evp_pkey_ctx_is_legacy(locpctx))
  71         goto legacy;
  72
  73     /* do not reinitialize if pkey is set or operation is different */
  74     if (reinit
  75         && (pkey != NULL
  76             || locpctx->operation != (ver ? EVP_PKEY_OP_VERIFYCTX
  77                                           : EVP_PKEY_OP_SIGNCTX)
  78             || (signature = locpctx->op.sig.signature) == NULL
  79             || locpctx->op.sig.algctx == NULL))
  80         reinit = 0;
  81
  82     if (props == NULL)
  83         props = locpctx->propquery;
  84
  85     if (locpctx->pkey == NULL) {
  86         ERR_clear_last_mark();
  87         ERR_raise(ERR_LIB_EVP, EVP_R_NO_KEY_SET);
  88         goto err;
  89     }
  90
  91     if (!reinit) {
  92         evp_pkey_ctx_free_old_ops(locpctx);
  93     } else {
  94         if (mdname == NULL && type == NULL)
  95             mdname = canon_mdname(EVP_MD_get0_name(ctx->reqdigest));
  96         goto reinitialize;
  97     }
  98
  99     /*
 100      * Try to derive the supported signature from |locpctx->keymgmt|.
 101      */
 102     if (!ossl_assert(locpctx->pkey->keymgmt == NULL
 103                      || locpctx->pkey->keymgmt == locpctx->keymgmt)) {
 104         ERR_clear_last_mark();
 105         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 106         goto err;
 107     }
 108     supported_sig = evp_keymgmt_util_query_operation_name(locpctx->keymgmt,
 109                                                           OSSL_OP_SIGNATURE);
 110     if (supported_sig == NULL) {
 111         ERR_clear_last_mark();
 112         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 113         goto err;
 114     }
 115
 116     /*
 117      * We perform two iterations:
 118      *
 119      * 1.  Do the normal signature fetch, using the fetching data given by
 120      *     the EVP_PKEY_CTX.
 121      * 2.  Do the provider specific signature fetch, from the same provider
 122      *     as |ctx->keymgmt|
 123      *
 124      * We then try to fetch the keymgmt from the same provider as the
 125      * signature, and try to export |ctx->pkey| to that keymgmt (when
 126      * this keymgmt happens to be the same as |ctx->keymgmt|, the export
 127      * is a no-op, but we call it anyway to not complicate the code even
 128      * more).
 129      * If the export call succeeds (returns a non-NULL provider key pointer),
 130      * we're done and can perform the operation itself.  If not, we perform
 131      * the second iteration, or jump to legacy.
 132      */
 133     for (iter = 1, provkey = NULL; iter < 3 && provkey == NULL; iter++) {
 134         EVP_KEYMGMT *tmp_keymgmt_tofree = NULL;
 135
 136         /*
 137          * If we're on the second iteration, free the results from the first.
 138          * They are NULL on the first iteration, so no need to check what
 139          * iteration we're on.
 140          */
 141         EVP_SIGNATURE_free(signature);
 142         EVP_KEYMGMT_free(tmp_keymgmt);
 143
 144         switch (iter) {
 145         case 1:
 146             signature = EVP_SIGNATURE_fetch(locpctx->libctx, supported_sig,
 147                                             locpctx->propquery);
 148             if (signature != NULL)
 149                 tmp_prov = EVP_SIGNATURE_get0_provider(signature);
 150             break;
 151         case 2:
 152             tmp_prov = EVP_KEYMGMT_get0_provider(locpctx->keymgmt);
 153             signature =
 154                 evp_signature_fetch_from_prov((OSSL_PROVIDER *)tmp_prov,
 155                                               supported_sig, locpctx->propquery);
 156             if (signature == NULL)
 157                 goto legacy;
 158             break;
 159         }
 160         if (signature == NULL)
 161             continue;
 162
 163         /*
 164          * Ensure that the key is provided, either natively, or as a cached
 165          * export.  We start by fetching the keymgmt with the same name as
 166          * |locpctx->pkey|, but from the provider of the signature method, using
 167          * the same property query as when fetching the signature method.
 168          * With the keymgmt we found (if we did), we try to export |locpctx->pkey|
 169          * to it (evp_pkey_export_to_provider() is smart enough to only actually
 170
 171          * export it if |tmp_keymgmt| is different from |locpctx->pkey|'s keymgmt)
 172          */
 173         tmp_keymgmt_tofree = tmp_keymgmt =
 174             evp_keymgmt_fetch_from_prov((OSSL_PROVIDER *)tmp_prov,
 175                                         EVP_KEYMGMT_get0_name(locpctx->keymgmt),
 176                                         locpctx->propquery);
 177         if (tmp_keymgmt != NULL)
 178             provkey = evp_pkey_export_to_provider(locpctx->pkey, locpctx->libctx,
 179                                                   &tmp_keymgmt, locpctx->propquery);
 180         if (tmp_keymgmt == NULL)
 181             EVP_KEYMGMT_free(tmp_keymgmt_tofree);
 182     }
 183
 184     if (provkey == NULL) {
 185         EVP_SIGNATURE_free(signature);
 186         ERR_clear_last_mark();
 187         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 188         goto err;
 189     }
 190
 191     ERR_pop_to_mark();
 192
 193     /* No more legacy from here down to legacy: */
 194
 195     locpctx->op.sig.signature = signature;
 196     locpctx->operation = ver ? EVP_PKEY_OP_VERIFYCTX
 197                              : EVP_PKEY_OP_SIGNCTX;
 198     locpctx->op.sig.algctx
 199         = signature->newctx(ossl_provider_ctx(signature->prov), props);
 200     if (locpctx->op.sig.algctx == NULL) {
 201         ERR_raise(ERR_LIB_EVP,  EVP_R_INITIALIZATION_ERROR);
 202         goto err;
 203     }
 204
 205  reinitialize:
 206     if (pctx != NULL)
 207         *pctx = locpctx;
 208
 209     if (type != NULL) {
 210         ctx->reqdigest = type;
 211         if (mdname == NULL)
 212             mdname = canon_mdname(EVP_MD_get0_name(type));
 213     } else {
 214         if (mdname == NULL && !reinit) {
 215             if (evp_keymgmt_util_get_deflt_digest_name(tmp_keymgmt, provkey,
 216                                                        locmdname,
 217                                                        sizeof(locmdname)) > 0) {
 218                 mdname = canon_mdname(locmdname);
 219             }
 220         }
 221
 222         if (mdname != NULL) {
 223             /*
 224              * We're about to get a new digest so clear anything associated with
 225              * an old digest.
 226              */
 227             evp_md_ctx_clear_digest(ctx, 1, 0);
 228
 229             /* legacy code support for engines */
 230             ERR_set_mark();
 231             /*
 232              * This might be requested by a later call to EVP_MD_CTX_get0_md().
 233              * In that case the "explicit fetch" rules apply for that
 234              * function (as per man pages), i.e. the ref count is not updated
 235              * so the EVP_MD should not be used beyond the lifetime of the
 236              * EVP_MD_CTX.
 237              */
 238             ctx->fetched_digest = EVP_MD_fetch(locpctx->libctx, mdname, props);
 239             if (ctx->fetched_digest != NULL) {
 240                 ctx->digest = ctx->reqdigest = ctx->fetched_digest;
 241             } else {
 242                 /* legacy engine support : remove the mark when this is deleted */
 243                 ctx->reqdigest = ctx->digest = EVP_get_digestbyname(mdname);
 244                 if (ctx->digest == NULL) {
 245                     (void)ERR_clear_last_mark();
 246                     ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 247                     goto err;
 248                 }
 249             }
 250             (void)ERR_pop_to_mark();
 251         }
 252     }
 253
 254     if (ver) {
 255         if (signature->digest_verify_init == NULL) {
 256             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 257             goto err;
 258         }
 259         ret = signature->digest_verify_init(locpctx->op.sig.algctx,
 260                                             mdname, provkey, params);
 261     } else {
 262         if (signature->digest_sign_init == NULL) {
 263             ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 264             goto err;
 265         }
 266         ret = signature->digest_sign_init(locpctx->op.sig.algctx,
 267                                           mdname, provkey, params);
 268     }
 269
 270     /*
 271      * If the operation was not a success and no digest was found, an error
 272      * needs to be raised.
 273      */
 274     if (ret > 0 || mdname != NULL)
 275         goto end;
 276     if (type == NULL)   /* This check is redundant but clarifies matters */
 277         ERR_raise(ERR_LIB_EVP, EVP_R_NO_DEFAULT_DIGEST);
 278
 279  err:
 280     evp_pkey_ctx_free_old_ops(locpctx);
 281     locpctx->operation = EVP_PKEY_OP_UNDEFINED;
 282     EVP_KEYMGMT_free(tmp_keymgmt);
 283     return 0;
 284
 285  legacy:
 286     /*
 287      * If we don't have the full support we need with provided methods,
 288      * let's go see if legacy does.
 289      */
 290     ERR_pop_to_mark();
 291     EVP_KEYMGMT_free(tmp_keymgmt);
 292     tmp_keymgmt = NULL;
 293
 294     if (type == NULL && mdname != NULL)
 295         type = evp_get_digestbyname_ex(locpctx->libctx, mdname);
 296
 297     if (ctx->pctx->pmeth == NULL) {
 298         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 299         return 0;
 300     }
 301
 302     if (!(ctx->pctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM)) {
 303
 304         if (type == NULL) {
 305             int def_nid;
 306             if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) > 0)
 307                 type = EVP_get_digestbynid(def_nid);
 308         }
 309
 310         if (type == NULL) {
 311             ERR_raise(ERR_LIB_EVP, EVP_R_NO_DEFAULT_DIGEST);
 312             return 0;
 313         }
 314     }
 315
 316     if (ver) {
 317         if (ctx->pctx->pmeth->verifyctx_init) {
 318             if (ctx->pctx->pmeth->verifyctx_init(ctx->pctx, ctx) <= 0)
 319                 return 0;
 320             ctx->pctx->operation = EVP_PKEY_OP_VERIFYCTX;
 321         } else if (ctx->pctx->pmeth->digestverify != 0) {
 322             ctx->pctx->operation = EVP_PKEY_OP_VERIFY;
 323             ctx->update = update;
 324         } else if (EVP_PKEY_verify_init(ctx->pctx) <= 0) {
 325             return 0;
 326         }
 327     } else {
 328         if (ctx->pctx->pmeth->signctx_init) {
 329             if (ctx->pctx->pmeth->signctx_init(ctx->pctx, ctx) <= 0)
 330                 return 0;
 331             ctx->pctx->operation = EVP_PKEY_OP_SIGNCTX;
 332         } else if (ctx->pctx->pmeth->digestsign != 0) {
 333             ctx->pctx->operation = EVP_PKEY_OP_SIGN;
 334             ctx->update = update;
 335         } else if (EVP_PKEY_sign_init(ctx->pctx) <= 0) {
 336             return 0;
 337         }
 338     }
 339     if (EVP_PKEY_CTX_set_signature_md(ctx->pctx, type) <= 0)
 340         return 0;
 341     if (pctx)
 342         *pctx = ctx->pctx;
 343     if (ctx->pctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM)
 344         return 1;
 345     if (!EVP_DigestInit_ex(ctx, type, e))
 346         return 0;
 347     /*
 348      * This indicates the current algorithm requires
 349      * special treatment before hashing the tbs-message.
 350      */
 351     ctx->pctx->flag_call_digest_custom = 0;
 352     if (ctx->pctx->pmeth->digest_custom != NULL)
 353         ctx->pctx->flag_call_digest_custom = 1;
 354
 355     ret = 1;
 356
 357  end:
 358 #ifndef FIPS_MODULE
 359     if (ret > 0)
 360         ret = evp_pkey_ctx_use_cached_data(locpctx);
 361 #endif
 362
 363     EVP_KEYMGMT_free(tmp_keymgmt);
 364     return ret > 0 ? 1 : 0;
 365 }
 366
 367 int EVP_DigestSignInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
 368                           const char *mdname, OSSL_LIB_CTX *libctx,
 369                           const char *props, EVP_PKEY *pkey,
 370                           const OSSL_PARAM params[])
 371 {
 372     return do_sigver_init(ctx, pctx, NULL, mdname, libctx, props, NULL, pkey, 0,
 373                           params);
 374 }
 375
 376 int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
 377                        const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey)
 378 {
 379     return do_sigver_init(ctx, pctx, type, NULL, NULL, NULL, e, pkey, 0,
 380                           NULL);
 381 }
 382
 383 int EVP_DigestVerifyInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
 384                             const char *mdname, OSSL_LIB_CTX *libctx,
 385                             const char *props, EVP_PKEY *pkey,
 386                             const OSSL_PARAM params[])
 387 {
 388     return do_sigver_init(ctx, pctx, NULL, mdname, libctx, props, NULL, pkey, 1,
 389                           params);
 390 }
 391
 392 int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
 393                          const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey)
 394 {
 395     return do_sigver_init(ctx, pctx, type, NULL, NULL, NULL, e, pkey, 1,
 396                           NULL);
 397 }
 398 #endif /* FIPS_MDOE */
 399
 400 int EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize)
 401 {
 402     EVP_PKEY_CTX *pctx = ctx->pctx;
 403
 404     if (pctx == NULL
 405             || pctx->operation != EVP_PKEY_OP_SIGNCTX
 406             || pctx->op.sig.algctx == NULL
 407             || pctx->op.sig.signature == NULL)
 408         goto legacy;
 409
 410     if (pctx->op.sig.signature->digest_sign_update == NULL) {
 411         ERR_raise(ERR_LIB_EVP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 412         return 0;
 413     }
 414
 415     return pctx->op.sig.signature->digest_sign_update(pctx->op.sig.algctx,
 416                                                       data, dsize);
 417
 418  legacy:
 419     if (pctx != NULL) {
 420         /* do_sigver_init() checked that |digest_custom| is non-NULL */
 421         if (pctx->flag_call_digest_custom
 422             && !ctx->pctx->pmeth->digest_custom(ctx->pctx, ctx))
 423             return 0;
 424         pctx->flag_call_digest_custom = 0;
 425     }
 426
 427     return EVP_DigestUpdate(ctx, data, dsize);
 428 }
 429
 430 int EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize)
 431 {
 432     EVP_PKEY_CTX *pctx = ctx->pctx;
 433
 434     if (pctx == NULL
 435             || pctx->operation != EVP_PKEY_OP_VERIFYCTX
 436             || pctx->op.sig.algctx == NULL
 437             || pctx->op.sig.signature == NULL)
 438         goto legacy;
 439
 440     if (pctx->op.sig.signature->digest_verify_update == NULL) {
 441         ERR_raise(ERR_LIB_EVP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 442         return 0;
 443     }
 444
 445     return pctx->op.sig.signature->digest_verify_update(pctx->op.sig.algctx,
 446                                                         data, dsize);
 447
 448  legacy:
 449     if (pctx != NULL) {
 450         /* do_sigver_init() checked that |digest_custom| is non-NULL */
 451         if (pctx->flag_call_digest_custom
 452             && !ctx->pctx->pmeth->digest_custom(ctx->pctx, ctx))
 453             return 0;
 454         pctx->flag_call_digest_custom = 0;
 455     }
 456
 457     return EVP_DigestUpdate(ctx, data, dsize);
 458 }
 459
 460 #ifndef FIPS_MODULE
 461 int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
 462                         size_t *siglen)
 463 {
 464     int sctx = 0, r = 0;
 465     EVP_PKEY_CTX *dctx, *pctx = ctx->pctx;
 466
 467     if (pctx == NULL
 468             || pctx->operation != EVP_PKEY_OP_SIGNCTX
 469             || pctx->op.sig.algctx == NULL
 470             || pctx->op.sig.signature == NULL)
 471         goto legacy;
 472
 473     if (sigret == NULL || (ctx->flags & EVP_MD_CTX_FLAG_FINALISE) != 0)
 474         return pctx->op.sig.signature->digest_sign_final(pctx->op.sig.algctx,
 475                                                          sigret, siglen,
 476                                                          sigret == NULL ? 0 : *siglen);
 477     dctx = EVP_PKEY_CTX_dup(pctx);
 478     if (dctx == NULL)
 479         return 0;
 480
 481     r = dctx->op.sig.signature->digest_sign_final(dctx->op.sig.algctx,
 482                                                   sigret, siglen,
 483                                                   *siglen);
 484     EVP_PKEY_CTX_free(dctx);
 485     return r;
 486
 487  legacy:
 488     if (pctx == NULL || pctx->pmeth == NULL) {
 489         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 490         return 0;
 491     }
 492
 493     /* do_sigver_init() checked that |digest_custom| is non-NULL */
 494     if (pctx->flag_call_digest_custom
 495         && !ctx->pctx->pmeth->digest_custom(ctx->pctx, ctx))
 496         return 0;
 497     pctx->flag_call_digest_custom = 0;
 498
 499     if (pctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM) {
 500         if (sigret == NULL)
 501             return pctx->pmeth->signctx(pctx, sigret, siglen, ctx);
 502         if (ctx->flags & EVP_MD_CTX_FLAG_FINALISE)
 503             r = pctx->pmeth->signctx(pctx, sigret, siglen, ctx);
 504         else {
 505             dctx = EVP_PKEY_CTX_dup(pctx);
 506             if (dctx == NULL)
 507                 return 0;
 508             r = dctx->pmeth->signctx(dctx, sigret, siglen, ctx);
 509             EVP_PKEY_CTX_free(dctx);
 510         }
 511         return r;
 512     }
 513     if (pctx->pmeth->signctx != NULL)
 514         sctx = 1;
 515     else
 516         sctx = 0;
 517     if (sigret != NULL) {
 518         unsigned char md[EVP_MAX_MD_SIZE];
 519         unsigned int mdlen = 0;
 520
 521         if (ctx->flags & EVP_MD_CTX_FLAG_FINALISE) {
 522             if (sctx)
 523                 r = pctx->pmeth->signctx(pctx, sigret, siglen, ctx);
 524             else
 525                 r = EVP_DigestFinal_ex(ctx, md, &mdlen);
 526         } else {
 527             EVP_MD_CTX *tmp_ctx = EVP_MD_CTX_new();
 528
 529             if (tmp_ctx == NULL)
 530                 return 0;
 531             if (!EVP_MD_CTX_copy_ex(tmp_ctx, ctx)) {
 532                 EVP_MD_CTX_free(tmp_ctx);
 533                 return 0;
 534             }
 535             if (sctx)
 536                 r = tmp_ctx->pctx->pmeth->signctx(tmp_ctx->pctx,
 537                                                   sigret, siglen, tmp_ctx);
 538             else
 539                 r = EVP_DigestFinal_ex(tmp_ctx, md, &mdlen);
 540             EVP_MD_CTX_free(tmp_ctx);
 541         }
 542         if (sctx || !r)
 543             return r;
 544         if (EVP_PKEY_sign(pctx, sigret, siglen, md, mdlen) <= 0)
 545             return 0;
 546     } else {
 547         if (sctx) {
 548             if (pctx->pmeth->signctx(pctx, sigret, siglen, ctx) <= 0)
 549                 return 0;
 550         } else {
 551             int s = EVP_MD_get_size(ctx->digest);
 552
 553             if (s < 0 || EVP_PKEY_sign(pctx, sigret, siglen, NULL, s) <= 0)
 554                 return 0;
 555         }
 556     }
 557     return 1;
 558 }
 559
 560 int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen,
 561                    const unsigned char *tbs, size_t tbslen)
 562 {
 563     EVP_PKEY_CTX *pctx = ctx->pctx;
 564
 565     if (pctx != NULL
 566             && pctx->operation == EVP_PKEY_OP_SIGNCTX
 567             && pctx->op.sig.algctx != NULL
 568             && pctx->op.sig.signature != NULL) {
 569         if (pctx->op.sig.signature->digest_sign != NULL)
 570             return pctx->op.sig.signature->digest_sign(pctx->op.sig.algctx,
 571                                                        sigret, siglen,
 572                                                        sigret == NULL ? 0 : *siglen,
 573                                                        tbs, tbslen);
 574     } else {
 575         /* legacy */
 576         if (ctx->pctx->pmeth != NULL && ctx->pctx->pmeth->digestsign != NULL)
 577             return ctx->pctx->pmeth->digestsign(ctx, sigret, siglen, tbs, tbslen);
 578     }
 579
 580     if (sigret != NULL && EVP_DigestSignUpdate(ctx, tbs, tbslen) <= 0)
 581         return 0;
 582     return EVP_DigestSignFinal(ctx, sigret, siglen);
 583 }
 584
 585 int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
 586                           size_t siglen)
 587 {
 588     unsigned char md[EVP_MAX_MD_SIZE];
 589     int r = 0;
 590     unsigned int mdlen = 0;
 591     int vctx = 0;
 592     EVP_PKEY_CTX *dctx, *pctx = ctx->pctx;
 593
 594     if (pctx == NULL
 595             || pctx->operation != EVP_PKEY_OP_VERIFYCTX
 596             || pctx->op.sig.algctx == NULL
 597             || pctx->op.sig.signature == NULL)
 598         goto legacy;
 599
 600     if ((ctx->flags & EVP_MD_CTX_FLAG_FINALISE) != 0)
 601         return pctx->op.sig.signature->digest_verify_final(pctx->op.sig.algctx,
 602                                                            sig, siglen);
 603     dctx = EVP_PKEY_CTX_dup(pctx);
 604     if (dctx == NULL)
 605         return 0;
 606
 607     r = dctx->op.sig.signature->digest_verify_final(dctx->op.sig.algctx,
 608                                                     sig, siglen);
 609     EVP_PKEY_CTX_free(dctx);
 610     return r;
 611
 612  legacy:
 613     if (pctx == NULL || pctx->pmeth == NULL) {
 614         ERR_raise(ERR_LIB_EVP, EVP_R_INITIALIZATION_ERROR);
 615         return 0;
 616     }
 617
 618     /* do_sigver_init() checked that |digest_custom| is non-NULL */
 619     if (pctx->flag_call_digest_custom
 620         && !ctx->pctx->pmeth->digest_custom(ctx->pctx, ctx))
 621         return 0;
 622     pctx->flag_call_digest_custom = 0;
 623
 624     if (pctx->pmeth->verifyctx != NULL)
 625         vctx = 1;
 626     else
 627         vctx = 0;
 628     if (ctx->flags & EVP_MD_CTX_FLAG_FINALISE) {
 629         if (vctx)
 630             r = pctx->pmeth->verifyctx(pctx, sig, siglen, ctx);
 631         else
 632             r = EVP_DigestFinal_ex(ctx, md, &mdlen);
 633     } else {
 634         EVP_MD_CTX *tmp_ctx = EVP_MD_CTX_new();
 635         if (tmp_ctx == NULL)
 636             return -1;
 637         if (!EVP_MD_CTX_copy_ex(tmp_ctx, ctx)) {
 638             EVP_MD_CTX_free(tmp_ctx);
 639             return -1;
 640         }
 641         if (vctx)
 642             r = tmp_ctx->pctx->pmeth->verifyctx(tmp_ctx->pctx,
 643                                                 sig, siglen, tmp_ctx);
 644         else
 645             r = EVP_DigestFinal_ex(tmp_ctx, md, &mdlen);
 646         EVP_MD_CTX_free(tmp_ctx);
 647     }
 648     if (vctx || !r)
 649         return r;
 650     return EVP_PKEY_verify(pctx, sig, siglen, md, mdlen);
 651 }
 652
 653 int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,
 654                      size_t siglen, const unsigned char *tbs, size_t tbslen)
 655 {
 656     EVP_PKEY_CTX *pctx = ctx->pctx;
 657
 658     if (pctx != NULL
 659             && pctx->operation == EVP_PKEY_OP_VERIFYCTX
 660             && pctx->op.sig.algctx != NULL
 661             && pctx->op.sig.signature != NULL) {
 662         if (pctx->op.sig.signature->digest_verify != NULL)
 663             return pctx->op.sig.signature->digest_verify(pctx->op.sig.algctx,
 664                                                          sigret, siglen,
 665                                                          tbs, tbslen);
 666     } else {
 667         /* legacy */
 668         if (ctx->pctx->pmeth != NULL && ctx->pctx->pmeth->digestverify != NULL)
 669             return ctx->pctx->pmeth->digestverify(ctx, sigret, siglen, tbs, tbslen);
 670     }
 671
 672     if (EVP_DigestVerifyUpdate(ctx, tbs, tbslen) <= 0)
 673         return -1;
 674     return EVP_DigestVerifyFinal(ctx, sigret, siglen);
 675 }
 676 #endif /* FIPS_MODULE */