crypto/dh/dh_ameth.c:295: error: MEMORY_LEAK
  memory dynamically allocated by call to `ASN1_STRING_new()` at line 260, column 14 is not reachable after line 295, column 5.
Showing all 59 steps of the trace


crypto/dh/dh_ameth.c:253:1: start of procedure dh_priv_encode()
251.   }
252.   
253. > static int dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
254.   {
255.       ASN1_STRING *params = NULL;

crypto/dh/dh_ameth.c:255:5: 
253.   static int dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
254.   {
255. >     ASN1_STRING *params = NULL;
256.       ASN1_INTEGER *prkey = NULL;
257.       unsigned char *dp = NULL;

crypto/dh/dh_ameth.c:256:5: 
254.   {
255.       ASN1_STRING *params = NULL;
256. >     ASN1_INTEGER *prkey = NULL;
257.       unsigned char *dp = NULL;
258.       int dplen;

crypto/dh/dh_ameth.c:257:5: 
255.       ASN1_STRING *params = NULL;
256.       ASN1_INTEGER *prkey = NULL;
257. >     unsigned char *dp = NULL;
258.       int dplen;
259.   

crypto/dh/dh_ameth.c:260:5: 
258.       int dplen;
259.   
260. >     params = ASN1_STRING_new();
261.   
262.       if (params == NULL) {

crypto/asn1/asn1_lib.c:343:1: start of procedure ASN1_STRING_new()
  341.   }
  342.   
  343. > ASN1_STRING *ASN1_STRING_new(void)
  344.   {
  345.       return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));

crypto/asn1/asn1_lib.c:345:5: 
  343.   ASN1_STRING *ASN1_STRING_new(void)
  344.   {
  345. >     return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
  346.   }
  347.   

crypto/asn1/asn1_lib.c:348:1: start of procedure ASN1_STRING_type_new()
    346.   }
    347.   
    348. > ASN1_STRING *ASN1_STRING_type_new(int type)
    349.   {
    350.       ASN1_STRING *ret;

crypto/asn1/asn1_lib.c:352:5: 
    350.       ASN1_STRING *ret;
    351.   
    352. >     ret = OPENSSL_zalloc(sizeof(*ret));
    353.       if (ret == NULL) {
    354.           ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);

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/asn1/asn1_lib.c:353:9: Taking false branch
    351.   
    352.       ret = OPENSSL_zalloc(sizeof(*ret));
    353.       if (ret == NULL) {
                   ^
    354.           ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);
    355.           return (NULL);

crypto/asn1/asn1_lib.c:357:5: 
    355.           return (NULL);
    356.       }
    357. >     ret->type = type;
    358.       return (ret);
    359.   }

crypto/asn1/asn1_lib.c:358:5: 
    356.       }
    357.       ret->type = type;
    358. >     return (ret);
    359.   }
    360.   

crypto/asn1/asn1_lib.c:359:1: return from a call to ASN1_STRING_type_new
    357.       ret->type = type;
    358.       return (ret);
    359. > }
    360.   
    361.   void ASN1_STRING_free(ASN1_STRING *a)

crypto/asn1/asn1_lib.c:346:1: return from a call to ASN1_STRING_new
  344.   {
  345.       return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
  346. > }
  347.   
  348.   ASN1_STRING *ASN1_STRING_type_new(int type)

crypto/dh/dh_ameth.c:262:9: Taking false branch
260.       params = ASN1_STRING_new();
261.   
262.       if (params == NULL) {
               ^
263.           DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
264.           goto err;

crypto/dh/dh_ameth.c:267:5: 
265.       }
266.   
267. >     params->length = i2d_dhp(pkey, pkey->pkey.dh, &params->data);
268.       if (params->length <= 0) {
269.           DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);

crypto/dh/dh_ameth.c:84:1: start of procedure i2d_dhp()
  82.   }
  83.   
  84. > static int i2d_dhp(const EVP_PKEY *pkey, const DH *a, unsigned char **pp)
  85.   {
  86.       if (pkey->ameth == &dhx_asn1_meth)

crypto/dh/dh_ameth.c:86:9: Taking false branch
  84.   static int i2d_dhp(const EVP_PKEY *pkey, const DH *a, unsigned char **pp)
  85.   {
  86.       if (pkey->ameth == &dhx_asn1_meth)
                ^
  87.           return i2d_DHxparams(a, pp);
  88.       return i2d_DHparams(a, pp);

crypto/dh/dh_ameth.c:88:5: 
  86.       if (pkey->ameth == &dhx_asn1_meth)
  87.           return i2d_DHxparams(a, pp);
  88. >     return i2d_DHparams(a, pp);
  89.   }
  90.   

crypto/dh/dh_asn1.c:89:1: start of procedure i2d_DHparams()
    87.   } static_ASN1_SEQUENCE_END_cb(DH, DHparams)
    88.   
    89. > IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(DH, DHparams, DHparams)
    90.   
    91.   /*

crypto/asn1/tasn_enc.c:91:1: start of procedure ASN1_item_i2d()
      89.   }
      90.   
      91. > int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it)
      92.   {
      93.       return asn1_item_flags_i2d(val, out, it, 0);

crypto/asn1/tasn_enc.c:93:5: 
      91.   int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it)
      92.   {
      93. >     return asn1_item_flags_i2d(val, out, it, 0);
      94.   }
      95.   

crypto/asn1/tasn_enc.c:103:1: start of procedure asn1_item_flags_i2d()
        101.    */
        102.   
        103. > static int asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out,
        104.                                  const ASN1_ITEM *it, int flags)
        105.   {

crypto/asn1/tasn_enc.c:106:9: Taking true branch
        104.                                  const ASN1_ITEM *it, int flags)
        105.   {
        106.       if (out && !*out) {
                       ^
        107.           unsigned char *p, *buf;
        108.           int len;

crypto/asn1/tasn_enc.c:106:17: Taking false branch
        104.                                  const ASN1_ITEM *it, int flags)
        105.   {
        106.       if (out && !*out) {
                               ^
        107.           unsigned char *p, *buf;
        108.           int len;

crypto/asn1/tasn_enc.c:121:5: Skipping ASN1_item_ex_i2d(): empty list of specs
        119.       }
        120.   
        121.       return ASN1_item_ex_i2d(&val, out, it, -1, flags);
                   ^
        122.   }
        123.   

crypto/asn1/tasn_enc.c:122:1: return from a call to asn1_item_flags_i2d
        120.   
        121.       return ASN1_item_ex_i2d(&val, out, it, -1, flags);
        122. > }
        123.   
        124.   /*

crypto/asn1/tasn_enc.c:94:1: return from a call to ASN1_item_i2d
      92.   {
      93.       return asn1_item_flags_i2d(val, out, it, 0);
      94. > }
      95.   
      96.   /*

crypto/dh/dh_asn1.c:89:1: return from a call to i2d_DHparams
    87.   } static_ASN1_SEQUENCE_END_cb(DH, DHparams)
    88.   
    89. > IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(DH, DHparams, DHparams)
    90.   
    91.   /*

crypto/dh/dh_ameth.c:89:1: return from a call to i2d_dhp
  87.           return i2d_DHxparams(a, pp);
  88.       return i2d_DHparams(a, pp);
  89. > }
  90.   
  91.   static void int_dh_free(EVP_PKEY *pkey)

crypto/dh/dh_ameth.c:268:9: Taking true branch
266.   
267.       params->length = i2d_dhp(pkey, pkey->pkey.dh, &params->data);
268.       if (params->length <= 0) {
               ^
269.           DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
270.           goto err;

crypto/dh/dh_ameth.c:269:9: Skipping ERR_put_error(): empty list of specs
267.       params->length = i2d_dhp(pkey, pkey->pkey.dh, &params->data);
268.       if (params->length <= 0) {
269.           DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
               ^
270.           goto err;
271.       }

crypto/dh/dh_ameth.c:293:2: 
291.       return 1;
292.   
293. >  err:
294.       OPENSSL_free(dp);
295.       ASN1_STRING_free(params);

crypto/dh/dh_ameth.c:294:5: 
292.   
293.    err:
294. >     OPENSSL_free(dp);
295.       ASN1_STRING_free(params);
296.       ASN1_STRING_clear_free(prkey);

crypto/mem.c:233:1: start of procedure CRYPTO_free()
  231.   }
  232.   
  233. > void CRYPTO_free(void *str)
  234.   {
  235.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG

crypto/mem.c:244:5: 
  242.       }
  243.   #else
  244. >     free(str);
  245.   #endif
  246.   }

crypto/mem.c:246:1: return from a call to CRYPTO_free
  244.       free(str);
  245.   #endif
  246. > }
  247.   
  248.   void CRYPTO_clear_free(void *str, size_t num)

crypto/dh/dh_ameth.c:295:5: 
293.    err:
294.       OPENSSL_free(dp);
295. >     ASN1_STRING_free(params);
296.       ASN1_STRING_clear_free(prkey);
297.       return 0;

crypto/asn1/asn1_lib.c:361:1: start of procedure ASN1_STRING_free()
  359.   }
  360.   
  361. > void ASN1_STRING_free(ASN1_STRING *a)
  362.   {
  363.       if (a == NULL)

crypto/asn1/asn1_lib.c:363:9: Taking false branch
  361.   void ASN1_STRING_free(ASN1_STRING *a)
  362.   {
  363.       if (a == NULL)
                 ^
  364.           return;
  365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))

crypto/asn1/asn1_lib.c:365:11: Taking false branch
  363.       if (a == NULL)
  364.           return;
  365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
                   ^
  366.           OPENSSL_free(a->data);
  367.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))

crypto/asn1/asn1_lib.c:367:11: Taking false branch
  365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
  366.           OPENSSL_free(a->data);
  367.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))
                   ^
  368.           OPENSSL_free(a);
  369.   }

crypto/asn1/asn1_lib.c:367:5: 
  365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
  366.           OPENSSL_free(a->data);
  367. >     if (!(a->flags & ASN1_STRING_FLAG_EMBED))
  368.           OPENSSL_free(a);
  369.   }

crypto/asn1/asn1_lib.c:369:1: return from a call to ASN1_STRING_free
  367.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))
  368.           OPENSSL_free(a);
  369. > }
  370.   
  371.   void ASN1_STRING_clear_free(ASN1_STRING *a)
