apps/speed.c:1289: error: USE_AFTER_FREE
  call to `EVP_DigestVerify()` eventually accesses memory that was invalidated by call to `free()` on line 1289 indirectly during the call to `EVP_DigestVerify()`.
Showing all 24 steps of the trace


apps/speed.c:1279:1: invalidation part of the trace starts here
1277.   }
1278.   
1279. > static int EdDSA_verify_loop(void *args)
1280.   {
1281.       loopargs_t *tempargs = *(loopargs_t **) args;

apps/speed.c:1279:1: parameter `args` of EdDSA_verify_loop
  1277.   }
  1278.   
  1279. > static int EdDSA_verify_loop(void *args)
  1280.   {
  1281.       loopargs_t *tempargs = *(loopargs_t **) args;

apps/speed.c:1281:5: assigned
  1279.   static int EdDSA_verify_loop(void *args)
  1280.   {
  1281.       loopargs_t *tempargs = *(loopargs_t **) args;
              ^
  1282.       unsigned char *buf = tempargs->buf;
  1283.       EVP_MD_CTX **edctx = tempargs->eddsa_ctx;

apps/speed.c:1283:5: assigned
  1281.       loopargs_t *tempargs = *(loopargs_t **) args;
  1282.       unsigned char *buf = tempargs->buf;
  1283.       EVP_MD_CTX **edctx = tempargs->eddsa_ctx;
              ^
  1284.       unsigned char *eddsasig = tempargs->buf2;
  1285.       size_t eddsasigsize = tempargs->sigsize;

apps/speed.c:1289:15: when calling `EVP_DigestVerify` here
  1287.   
  1288.       for (count = 0; COND(eddsa_c[testnum][1]); count++) {
  1289.           ret = EVP_DigestVerify(edctx[testnum], eddsasig, eddsasigsize, buf, 20);
                        ^
  1290.           if (ret != 1) {
  1291.               BIO_printf(bio_err, "EdDSA verify failure\n");

crypto/evp/m_sigver.c:210:1: parameter `ctx` of EVP_DigestVerify
    208.   }
    209.   
    210. > int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,
    211.                        size_t siglen, const unsigned char *tbs, size_t tbslen)
    212.   {

crypto/evp/m_sigver.c:217:12: when calling `EVP_DigestVerifyFinal` here
    215.       if (EVP_DigestVerifyUpdate(ctx, tbs, tbslen) <= 0)
    216.           return -1;
    217.       return EVP_DigestVerifyFinal(ctx, sigret, siglen);
                      ^
    218.   }

crypto/evp/m_sigver.c:173:1: parameter `ctx` of EVP_DigestVerifyFinal
      171.   }
      172.   
      173. > int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
      174.                             size_t siglen)
      175.   {

crypto/evp/m_sigver.c:189:17: when calling `EVP_DigestFinal_ex` here
      187.               r = ctx->pctx->pmeth->verifyctx(ctx->pctx, sig, siglen, ctx);
      188.           else
      189.               r = EVP_DigestFinal_ex(ctx, md, &mdlen);
                             ^
      190.       } else {
      191.           EVP_MD_CTX *tmp_ctx = EVP_MD_CTX_new();

crypto/evp/digest.c:311:1: parameter `ctx` of EVP_DigestFinal_ex
        309.   
        310.   /* The caller can assume that this removes any secret data from the context */
        311. > int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *isize)
        312.   {
        313.       int ret;

crypto/evp/digest.c:336:5: when calling `EVP_MD_CTX_reset` here
        334.       }
        335.   
        336.       EVP_MD_CTX_reset(ctx);
                   ^
        337.   
        338.       return ret;

crypto/evp/digest.c:20:1: parameter `ctx` of EVP_MD_CTX_reset
          18.   
          19.   /* This call frees resources associated with the context */
          20. > int EVP_MD_CTX_reset(EVP_MD_CTX *ctx)
          21.   {
          22.       if (ctx == NULL)

crypto/evp/digest.c:52:9: when calling `CRYPTO_clear_free` here
          50.       if (ctx->digest && ctx->digest->ctx_size && ctx->md_data
          51.           && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE)) {
          52.           OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
                        ^
          53.       }
          54.       /*

crypto/mem.c:316:1: parameter `str` of CRYPTO_clear_free
            314.   }
            315.   
            316. > void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)
            317.   {
            318.       if (str == NULL)

crypto/mem.c:322:5: when calling `CRYPTO_free` here
            320.       if (num)
            321.           OPENSSL_cleanse(str, num);
            322.       CRYPTO_free(str, file, line);
                       ^
            323.   }

crypto/mem.c:295:1: parameter `str` of CRYPTO_free
              293.   }
              294.   
              295. > void CRYPTO_free(void *str, const char *file, int line)
              296.   {
              297.       INCREMENT(free_count);

crypto/mem.c:312:5: was invalidated by call to `free()`
              310.       }
              311.   #else
              312.       free(str);
                         ^
              313.   #endif
              314.   }

apps/speed.c:1279:1: use-after-lifetime part of the trace starts here
1277.   }
1278.   
1279. > static int EdDSA_verify_loop(void *args)
1280.   {
1281.       loopargs_t *tempargs = *(loopargs_t **) args;

apps/speed.c:1279:1: parameter `args` of EdDSA_verify_loop
  1277.   }
  1278.   
  1279. > static int EdDSA_verify_loop(void *args)
  1280.   {
  1281.       loopargs_t *tempargs = *(loopargs_t **) args;

apps/speed.c:1281:5: assigned
  1279.   static int EdDSA_verify_loop(void *args)
  1280.   {
  1281.       loopargs_t *tempargs = *(loopargs_t **) args;
              ^
  1282.       unsigned char *buf = tempargs->buf;
  1283.       EVP_MD_CTX **edctx = tempargs->eddsa_ctx;

apps/speed.c:1283:5: assigned
  1281.       loopargs_t *tempargs = *(loopargs_t **) args;
  1282.       unsigned char *buf = tempargs->buf;
  1283.       EVP_MD_CTX **edctx = tempargs->eddsa_ctx;
              ^
  1284.       unsigned char *eddsasig = tempargs->buf2;
  1285.       size_t eddsasigsize = tempargs->sigsize;

apps/speed.c:1289:15: when calling `EVP_DigestVerify` here
  1287.   
  1288.       for (count = 0; COND(eddsa_c[testnum][1]); count++) {
  1289.           ret = EVP_DigestVerify(edctx[testnum], eddsasig, eddsasigsize, buf, 20);
                        ^
  1290.           if (ret != 1) {
  1291.               BIO_printf(bio_err, "EdDSA verify failure\n");

crypto/mem.c:295:1: parameter `str` of CRYPTO_free
    293.   }
    294.   
    295. > void CRYPTO_free(void *str, const char *file, int line)
    296.   {
    297.       INCREMENT(free_count);

crypto/mem.c:312:5: invalid access occurs here
    310.       }
    311.   #else
    312.       free(str);
               ^
    313.   #endif
    314.   }

void CRYPTO_free(void *str, const char *file, int line)
{
    INCREMENT(free_count);
    if (free_impl != NULL && free_impl != &CRYPTO_free) {
        free_impl(str, file, line);
        return;
    }
#if !defined(OPENSSL_NO_CRYPTO_MDEBUG) && !defined(FIPS_MODE)
    if (call_malloc_debug) {
        CRYPTO_mem_debug_free(str, 0, file, line);
        free(str);
        CRYPTO_mem_debug_free(str, 1, file, line);
    } else {
        free(str);
    }
#else
    free(str);
#endif
}
['static int EdDSA_verify_loop(void *args)\n{\n    loopargs_t *tempargs = *(loopargs_t **) args;\n    unsigned char *buf = tempargs->buf;\n    EVP_MD_CTX **edctx = tempargs->eddsa_ctx;\n    unsigned char *eddsasig = tempargs->buf2;\n    size_t eddsasigsize = tempargs->sigsize;\n    int ret, count;\n    for (count = 0; COND(eddsa_c[testnum][1]); count++) {\n        ret = EVP_DigestVerify(edctx[testnum], eddsasig, eddsasigsize, buf, 20);\n        if (ret != 1) {\n            BIO_printf(bio_err, "EdDSA verify failure\\n");\n            ERR_print_errors(bio_err);\n            count = -1;\n            break;\n        }\n    }\n    return count;\n}', 'int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,\n                     size_t siglen, const unsigned char *tbs, size_t tbslen)\n{\n    if (ctx->pctx->pmeth->digestverify != NULL)\n        return ctx->pctx->pmeth->digestverify(ctx, sigret, siglen, tbs, tbslen);\n    if (EVP_DigestVerifyUpdate(ctx, tbs, tbslen) <= 0)\n        return -1;\n    return EVP_DigestVerifyFinal(ctx, sigret, siglen);\n}', 'int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,\n                          size_t siglen)\n{\n    unsigned char md[EVP_MAX_MD_SIZE];\n    int r = 0;\n    unsigned int mdlen = 0;\n    int vctx = 0;\n    if (ctx->pctx->pmeth->verifyctx)\n        vctx = 1;\n    else\n        vctx = 0;\n    if (ctx->flags & EVP_MD_CTX_FLAG_FINALISE) {\n        if (vctx)\n            r = ctx->pctx->pmeth->verifyctx(ctx->pctx, sig, siglen, ctx);\n        else\n            r = EVP_DigestFinal_ex(ctx, md, &mdlen);\n    } else {\n        EVP_MD_CTX *tmp_ctx = EVP_MD_CTX_new();\n        if (tmp_ctx == NULL)\n            return -1;\n        if (!EVP_MD_CTX_copy_ex(tmp_ctx, ctx)) {\n            EVP_MD_CTX_free(tmp_ctx);\n            return -1;\n        }\n        if (vctx)\n            r = tmp_ctx->pctx->pmeth->verifyctx(tmp_ctx->pctx,\n                                                sig, siglen, tmp_ctx);\n        else\n            r = EVP_DigestFinal_ex(tmp_ctx, md, &mdlen);\n        EVP_MD_CTX_free(tmp_ctx);\n    }\n    if (vctx || !r)\n        return r;\n    return EVP_PKEY_verify(ctx->pctx, sig, siglen, md, mdlen);\n}', 'int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *isize)\n{\n    int ret;\n    size_t size = 0;\n    size_t mdsize = EVP_MD_size(ctx->digest);\n    if (ctx->digest == NULL || ctx->digest->prov == NULL)\n        goto legacy;\n    if (ctx->digest->dfinal == NULL) {\n        EVPerr(EVP_F_EVP_DIGESTFINAL_EX, EVP_R_FINAL_ERROR);\n        return 0;\n    }\n    ret = ctx->digest->dfinal(ctx->provctx, md, &size, mdsize);\n    if (isize != NULL) {\n        if (size <= UINT_MAX) {\n            *isize = (int)size;\n        } else {\n            EVPerr(EVP_F_EVP_DIGESTFINAL_EX, EVP_R_FINAL_ERROR);\n            ret = 0;\n        }\n    }\n    EVP_MD_CTX_reset(ctx);\n    return ret;\n legacy:\n    OPENSSL_assert(mdsize <= EVP_MAX_MD_SIZE);\n    ret = ctx->digest->final(ctx, md);\n    if (isize != NULL)\n        *isize = mdsize;\n    if (ctx->digest->cleanup) {\n        ctx->digest->cleanup(ctx);\n        EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);\n    }\n    OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);\n    return ret;\n}', 'int EVP_MD_CTX_reset(EVP_MD_CTX *ctx)\n{\n    if (ctx == NULL)\n        return 1;\n    if (ctx->digest == NULL || ctx->digest->prov == NULL)\n        goto legacy;\n    if (ctx->provctx != NULL) {\n        if (ctx->digest->freectx != NULL)\n            ctx->digest->freectx(ctx->provctx);\n        ctx->provctx = NULL;\n        EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);\n    }\n    if (ctx->pctx != NULL)\n        goto legacy;\n    return 1;\n legacy:\n    if (ctx->digest && ctx->digest->cleanup\n        && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_CLEANED))\n        ctx->digest->cleanup(ctx);\n    if (ctx->digest && ctx->digest->ctx_size && ctx->md_data\n        && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE)) {\n        OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);\n    }\n#ifndef FIPS_MODE\n    if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX))\n        EVP_PKEY_CTX_free(ctx->pctx);\n# ifndef OPENSSL_NO_ENGINE\n    ENGINE_finish(ctx->engine);\n# endif\n#endif\n    OPENSSL_cleanse(ctx, sizeof(*ctx));\n    return 1;\n}', 'void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)\n{\n    if (str == NULL)\n        return;\n    if (num)\n        OPENSSL_cleanse(str, num);\n    CRYPTO_free(str, file, line);\n}', 'void CRYPTO_free(void *str, const char *file, int line)\n{\n    INCREMENT(free_count);\n    if (free_impl != NULL && free_impl != &CRYPTO_free) {\n        free_impl(str, file, line);\n        return;\n    }\n#if !defined(OPENSSL_NO_CRYPTO_MDEBUG) && !defined(FIPS_MODE)\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_free(str, 0, file, line);\n        free(str);\n        CRYPTO_mem_debug_free(str, 1, file, line);\n    } else {\n        free(str);\n    }\n#else\n    free(str);\n#endif\n}']