crypto/evp/digest.c:307: error: USE_AFTER_FREE
  call to `EVP_MD_CTX_reset()` eventually accesses memory that was invalidated by call to `free()` on line 306 indirectly during the call to `EVP_DigestFinal_ex()`.
Showing all 16 steps of the trace


crypto/evp/digest.c:303:1: invalidation part of the trace starts here
301.   
302.   /* The caller can assume that this removes any secret data from the context */
303. > int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
304.   {
305.       int ret;

crypto/evp/digest.c:303:1: parameter `ctx` of EVP_DigestFinal
  301.   
  302.   /* The caller can assume that this removes any secret data from the context */
  303. > int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
  304.   {
  305.       int ret;

crypto/evp/digest.c:306:11: when calling `EVP_DigestFinal_ex` here
  304.   {
  305.       int ret;
  306.       ret = EVP_DigestFinal_ex(ctx, md, size);
                   ^
  307.       EVP_MD_CTX_reset(ctx);
  308.       return ret;

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

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

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

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

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.   }

crypto/evp/digest.c:303:1: use-after-lifetime part of the trace starts here
301.   
302.   /* The caller can assume that this removes any secret data from the context */
303. > int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
304.   {
305.       int ret;

crypto/evp/digest.c:303:1: parameter `ctx` of EVP_DigestFinal
  301.   
  302.   /* The caller can assume that this removes any secret data from the context */
  303. > int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
  304.   {
  305.       int ret;

crypto/evp/digest.c:307:5: when calling `EVP_MD_CTX_reset` here
  305.       int ret;
  306.       ret = EVP_DigestFinal_ex(ctx, md, size);
  307.       EVP_MD_CTX_reset(ctx);
             ^
  308.       return ret;
  309.   }

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
}
['int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)\n{\n    int ret;\n    ret = EVP_DigestFinal_ex(ctx, md, size);\n    EVP_MD_CTX_reset(ctx);\n    return ret;\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}']