crypto/ec/ec_key.c:587: error: MEMORY_LEAK
  memory dynamically allocated by call to `BN_secure_new()` at line 582, column 27 is not reachable after line 587, column 5.
Showing all 34 steps of the trace


crypto/ec/ec_key.c:576:1: start of procedure EC_KEY_oct2priv()
574.   }
575.   
576. > int EC_KEY_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len)
577.   {
578.       if (eckey->group == NULL || eckey->group->meth == NULL)

crypto/ec/ec_key.c:578:9: Taking false branch
576.   int EC_KEY_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len)
577.   {
578.       if (eckey->group == NULL || eckey->group->meth == NULL)
               ^
579.           return 0;
580.   

crypto/ec/ec_key.c:578:33: Taking false branch
576.   int EC_KEY_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len)
577.   {
578.       if (eckey->group == NULL || eckey->group->meth == NULL)
                                       ^
579.           return 0;
580.   

crypto/ec/ec_key.c:581:9: Taking true branch
579.           return 0;
580.   
581.       if (eckey->priv_key == NULL)
               ^
582.           eckey->priv_key = BN_secure_new();
583.       if (eckey->priv_key == NULL) {

crypto/ec/ec_key.c:582:9: 
580.   
581.       if (eckey->priv_key == NULL)
582. >         eckey->priv_key = BN_secure_new();
583.       if (eckey->priv_key == NULL) {
584.           ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_MALLOC_FAILURE);

crypto/bn/bn_lib.c:289:2: start of procedure BN_secure_new()
  287.   }
  288.   
  289.    BIGNUM *BN_secure_new(void)
          ^
  290.    {
  291.        BIGNUM *ret = BN_new();

crypto/bn/bn_lib.c:291:6: 
  289.    BIGNUM *BN_secure_new(void)
  290.    {
  291. >      BIGNUM *ret = BN_new();
  292.        if (ret != NULL)
  293.            ret->flags |= BN_FLG_SECURE;

crypto/bn/bn_lib.c:276:1: start of procedure BN_new()
    274.   }
    275.   
    276. > BIGNUM *BN_new(void)
    277.   {
    278.       BIGNUM *ret;

crypto/bn/bn_lib.c:280:9: 
    278.       BIGNUM *ret;
    279.   
    280. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
    281.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
    282.           return (NULL);

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
      154.   }
      155.   
      156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
        117.   }
        118.   
        119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121.       void *ret = NULL;

crypto/mem.c:121:5: 
        119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121. >     void *ret = NULL;
        122.   
        123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
        121.       void *ret = NULL;
        122.   
        123.       if (num <= 0)
                       ^
        124.           return NULL;
        125.   

crypto/mem.c:126:5: 
        124.           return NULL;
        125.   
        126. >     allow_customize = 0;
        127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
        134.       }
        135.   #else
        136. >     (void)file;
        137.       (void)line;
        138.       ret = malloc(num);

crypto/mem.c:137:5: 
        135.   #else
        136.       (void)file;
        137. >     (void)line;
        138.       ret = malloc(num);
        139.   #endif

crypto/mem.c:138:5: 
        136.       (void)file;
        137.       (void)line;
        138. >     ret = malloc(num);
        139.   #endif
        140.   

crypto/mem.c:153:5: 
        151.   #endif
        152.   
        153. >     return ret;
        154.   }
        155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
        152.   
        153.       return ret;
        154. > }
        155.   
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

crypto/mem.c:161:9: 
      159.   
      160.       if (ret != NULL)
      161. >         memset(ret, 0, num);
      162.       return ret;
      163.   }

crypto/mem.c:162:5: 
      160.       if (ret != NULL)
      161.           memset(ret, 0, num);
      162. >     return ret;
      163.   }
      164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
      161.           memset(ret, 0, num);
      162.       return ret;
      163. > }
      164.   
      165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/bn/bn_lib.c:280:9: Taking false branch
    278.       BIGNUM *ret;
    279.   
    280.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
                   ^
    281.           BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);
    282.           return (NULL);

crypto/bn/bn_lib.c:284:5: 
    282.           return (NULL);
    283.       }
    284. >     ret->flags = BN_FLG_MALLOCED;
    285.       bn_check_top(ret);
    286.       return (ret);

crypto/bn/bn_lib.c:286:5: 
    284.       ret->flags = BN_FLG_MALLOCED;
    285.       bn_check_top(ret);
    286. >     return (ret);
    287.   }
    288.   

crypto/bn/bn_lib.c:287:1: return from a call to BN_new
    285.       bn_check_top(ret);
    286.       return (ret);
    287. > }
    288.   
    289.    BIGNUM *BN_secure_new(void)

crypto/bn/bn_lib.c:292:10: Taking true branch
  290.    {
  291.        BIGNUM *ret = BN_new();
  292.        if (ret != NULL)
                  ^
  293.            ret->flags |= BN_FLG_SECURE;
  294.        return (ret);

crypto/bn/bn_lib.c:293:10: 
  291.        BIGNUM *ret = BN_new();
  292.        if (ret != NULL)
  293. >          ret->flags |= BN_FLG_SECURE;
  294.        return (ret);
  295.    }

crypto/bn/bn_lib.c:294:6: 
  292.        if (ret != NULL)
  293.            ret->flags |= BN_FLG_SECURE;
  294. >      return (ret);
  295.    }
  296.   

crypto/bn/bn_lib.c:295:2: return from a call to BN_secure_new
  293.            ret->flags |= BN_FLG_SECURE;
  294.        return (ret);
  295.    }
          ^
  296.   
  297.   /* This is used by bn_expand2() */

crypto/ec/ec_key.c:583:9: Taking false branch
581.       if (eckey->priv_key == NULL)
582.           eckey->priv_key = BN_secure_new();
583.       if (eckey->priv_key == NULL) {
               ^
584.           ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_MALLOC_FAILURE);
585.           return 0;

crypto/ec/ec_key.c:587:5: Skipping BN_bin2bn(): empty list of specs
585.           return 0;
586.       }
587.       eckey->priv_key = BN_bin2bn(buf, len, eckey->priv_key);
           ^
588.       if (eckey->priv_key == NULL) {
589.           ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_BN_LIB);

int EC_KEY_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len)
{
    if (eckey->group == NULL || eckey->group->meth == NULL)
        return 0;
    if (eckey->priv_key == NULL)
        eckey->priv_key = BN_secure_new();
    if (eckey->priv_key == NULL) {
        ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_MALLOC_FAILURE);
        return 0;
    }
    eckey->priv_key = BN_bin2bn(buf, len, eckey->priv_key);
    if (eckey->priv_key == NULL) {
        ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_BN_LIB);
        return 0;
    }
    return 1;
}
['int EC_KEY_oct2priv(EC_KEY *eckey, unsigned char *buf, size_t len)\n{\n    if (eckey->group == NULL || eckey->group->meth == NULL)\n        return 0;\n    if (eckey->priv_key == NULL)\n        eckey->priv_key = BN_secure_new();\n    if (eckey->priv_key == NULL) {\n        ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_MALLOC_FAILURE);\n        return 0;\n    }\n    eckey->priv_key = BN_bin2bn(buf, len, eckey->priv_key);\n    if (eckey->priv_key == NULL) {\n        ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_BN_LIB);\n        return 0;\n    }\n    return 1;\n}', 'BIGNUM *BN_secure_new(void)\n {\n     BIGNUM *ret = BN_new();\n     if (ret != NULL)\n         ret->flags |= BN_FLG_SECURE;\n     return (ret);\n }', 'BIGNUM *BN_new(void)\n{\n    BIGNUM *ret;\n    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {\n        BNerr(BN_F_BN_NEW, ERR_R_MALLOC_FAILURE);\n        return (NULL);\n    }\n    ret->flags = BN_FLG_MALLOCED;\n    bn_check_top(ret);\n    return (ret);\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\n    if (ret != NULL)\n        memset(ret, 0, num);\n    return ret;\n}', 'void *CRYPTO_malloc(size_t num, const char *file, int line)\n{\n    void *ret = NULL;\n    if (num <= 0)\n        return NULL;\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_malloc(NULL, num, 0, file, line);\n        ret = malloc(num);\n        CRYPTO_mem_debug_malloc(ret, num, 1, file, line);\n    } else {\n        ret = malloc(num);\n    }\n#else\n    (void)file;\n    (void)line;\n    ret = malloc(num);\n#endif\n#ifndef OPENSSL_CPUID_OBJ\n    if (ret && (num > 2048)) {\n        extern unsigned char cleanse_ctr;\n        ((unsigned char *)ret)[0] = cleanse_ctr;\n    }\n#endif\n    return ret;\n}']