crypto/ec/ec_lib.c:1083: error: MEMORY_LEAK
  memory dynamically allocated to `group->mont_data` by call to `BN_MONT_CTX_new()` at line 1077, column 24 is not reachable after line 1083, column 9.
Showing all 65 steps of the trace


crypto/ec/ec_lib.c:1066:1: start of procedure ec_precompute_mont_data()
1064.    * returns one on success. On error it returns zero.
1065.    */
1066. > int ec_precompute_mont_data(EC_GROUP *group)
1067.   {
1068.       BN_CTX *ctx = BN_CTX_new();

crypto/ec/ec_lib.c:1068:5: 
1066.   int ec_precompute_mont_data(EC_GROUP *group)
1067.   {
1068. >     BN_CTX *ctx = BN_CTX_new();
1069.       int ret = 0;
1070.   

crypto/bn/bn_ctx.c:189:1: start of procedure BN_CTX_new()
  187.   
  188.   
  189. > BN_CTX *BN_CTX_new(void)
  190.   {
  191.       BN_CTX *ret;

crypto/bn/bn_ctx.c:193:9: 
  191.       BN_CTX *ret;
  192.   
  193. >     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
  194.           BNerr(BN_F_BN_CTX_NEW, ERR_R_MALLOC_FAILURE);
  195.           return NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crypto/bn/bn_ctx.c:193:9: Taking false branch
  191.       BN_CTX *ret;
  192.   
  193.       if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
                 ^
  194.           BNerr(BN_F_BN_CTX_NEW, ERR_R_MALLOC_FAILURE);
  195.           return NULL;

crypto/bn/bn_ctx.c:198:5: 
  196.       }
  197.       /* Initialise the structure */
  198. >     BN_POOL_init(&ret->pool);
  199.       BN_STACK_init(&ret->stack);
  200.       return ret;

crypto/bn/bn_ctx.c:335:1: start of procedure BN_POOL_init()
    333.   /***********/
    334.   
    335. > static void BN_POOL_init(BN_POOL *p)
    336.   {
    337.       p->head = p->current = p->tail = NULL;

crypto/bn/bn_ctx.c:337:5: 
    335.   static void BN_POOL_init(BN_POOL *p)
    336.   {
    337. >     p->head = p->current = p->tail = NULL;
    338.       p->used = p->size = 0;
    339.   }

crypto/bn/bn_ctx.c:338:5: 
    336.   {
    337.       p->head = p->current = p->tail = NULL;
    338. >     p->used = p->size = 0;
    339.   }
    340.   

crypto/bn/bn_ctx.c:339:1: return from a call to BN_POOL_init
    337.       p->head = p->current = p->tail = NULL;
    338.       p->used = p->size = 0;
    339. > }
    340.   
    341.   static void BN_POOL_finish(BN_POOL *p)

crypto/bn/bn_ctx.c:199:5: 
  197.       /* Initialise the structure */
  198.       BN_POOL_init(&ret->pool);
  199. >     BN_STACK_init(&ret->stack);
  200.       return ret;
  201.   }

crypto/bn/bn_ctx.c:294:1: start of procedure BN_STACK_init()
    292.   /************/
    293.   
    294. > static void BN_STACK_init(BN_STACK *st)
    295.   {
    296.       st->indexes = NULL;

crypto/bn/bn_ctx.c:296:5: 
    294.   static void BN_STACK_init(BN_STACK *st)
    295.   {
    296. >     st->indexes = NULL;
    297.       st->depth = st->size = 0;
    298.   }

crypto/bn/bn_ctx.c:297:5: 
    295.   {
    296.       st->indexes = NULL;
    297. >     st->depth = st->size = 0;
    298.   }
    299.   

crypto/bn/bn_ctx.c:298:1: return from a call to BN_STACK_init
    296.       st->indexes = NULL;
    297.       st->depth = st->size = 0;
    298. > }
    299.   
    300.   static void BN_STACK_finish(BN_STACK *st)

crypto/bn/bn_ctx.c:200:5: 
  198.       BN_POOL_init(&ret->pool);
  199.       BN_STACK_init(&ret->stack);
  200. >     return ret;
  201.   }
  202.   

crypto/bn/bn_ctx.c:201:1: return from a call to BN_CTX_new
  199.       BN_STACK_init(&ret->stack);
  200.       return ret;
  201. > }
  202.   
  203.   BN_CTX *BN_CTX_secure_new(void)

crypto/ec/ec_lib.c:1069:5: 
1067.   {
1068.       BN_CTX *ctx = BN_CTX_new();
1069. >     int ret = 0;
1070.   
1071.       BN_MONT_CTX_free(group->mont_data);

crypto/ec/ec_lib.c:1071:5: Skipping BN_MONT_CTX_free(): empty list of specs
1069.       int ret = 0;
1070.   
1071.       BN_MONT_CTX_free(group->mont_data);
            ^
1072.       group->mont_data = NULL;
1073.   

crypto/ec/ec_lib.c:1072:5: 
1070.   
1071.       BN_MONT_CTX_free(group->mont_data);
1072. >     group->mont_data = NULL;
1073.   
1074.       if (ctx == NULL)

crypto/ec/ec_lib.c:1074:9: Taking false branch
1072.       group->mont_data = NULL;
1073.   
1074.       if (ctx == NULL)
                ^
1075.           goto err;
1076.   

crypto/ec/ec_lib.c:1077:5: 
1075.           goto err;
1076.   
1077. >     group->mont_data = BN_MONT_CTX_new();
1078.       if (group->mont_data == NULL)
1079.           goto err;

crypto/bn/bn_mont.c:315:1: start of procedure BN_MONT_CTX_new()
  313.   }
  314.   
  315. > BN_MONT_CTX *BN_MONT_CTX_new(void)
  316.   {
  317.       BN_MONT_CTX *ret;

crypto/bn/bn_mont.c:319:9: 
  317.       BN_MONT_CTX *ret;
  318.   
  319. >     if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
  320.           return (NULL);
  321.   

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

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

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

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

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

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

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

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

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

crypto/bn/bn_mont.c:319:9: Taking false branch
  317.       BN_MONT_CTX *ret;
  318.   
  319.       if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
                 ^
  320.           return (NULL);
  321.   

crypto/bn/bn_mont.c:322:5: 
  320.           return (NULL);
  321.   
  322. >     BN_MONT_CTX_init(ret);
  323.       ret->flags = BN_FLG_MALLOCED;
  324.       return (ret);

crypto/bn/bn_mont.c:327:1: start of procedure BN_MONT_CTX_init()
    325.   }
    326.   
    327. > void BN_MONT_CTX_init(BN_MONT_CTX *ctx)
    328.   {
    329.       ctx->ri = 0;

crypto/bn/bn_mont.c:329:5: 
    327.   void BN_MONT_CTX_init(BN_MONT_CTX *ctx)
    328.   {
    329. >     ctx->ri = 0;
    330.       bn_init(&(ctx->RR));
    331.       bn_init(&(ctx->N));

crypto/bn/bn_mont.c:330:5: Skipping bn_init(): empty list of specs
    328.   {
    329.       ctx->ri = 0;
    330.       bn_init(&(ctx->RR));
               ^
    331.       bn_init(&(ctx->N));
    332.       bn_init(&(ctx->Ni));

crypto/bn/bn_mont.c:331:5: Skipping bn_init(): empty list of specs
    329.       ctx->ri = 0;
    330.       bn_init(&(ctx->RR));
    331.       bn_init(&(ctx->N));
               ^
    332.       bn_init(&(ctx->Ni));
    333.       ctx->n0[0] = ctx->n0[1] = 0;

crypto/bn/bn_mont.c:332:5: Skipping bn_init(): empty list of specs
    330.       bn_init(&(ctx->RR));
    331.       bn_init(&(ctx->N));
    332.       bn_init(&(ctx->Ni));
               ^
    333.       ctx->n0[0] = ctx->n0[1] = 0;
    334.       ctx->flags = 0;

crypto/bn/bn_mont.c:333:5: 
    331.       bn_init(&(ctx->N));
    332.       bn_init(&(ctx->Ni));
    333. >     ctx->n0[0] = ctx->n0[1] = 0;
    334.       ctx->flags = 0;
    335.   }

crypto/bn/bn_mont.c:334:5: 
    332.       bn_init(&(ctx->Ni));
    333.       ctx->n0[0] = ctx->n0[1] = 0;
    334. >     ctx->flags = 0;
    335.   }
    336.   

crypto/bn/bn_mont.c:335:1: return from a call to BN_MONT_CTX_init
    333.       ctx->n0[0] = ctx->n0[1] = 0;
    334.       ctx->flags = 0;
    335. > }
    336.   
    337.   void BN_MONT_CTX_free(BN_MONT_CTX *mont)

crypto/bn/bn_mont.c:323:5: 
  321.   
  322.       BN_MONT_CTX_init(ret);
  323. >     ret->flags = BN_FLG_MALLOCED;
  324.       return (ret);
  325.   }

crypto/bn/bn_mont.c:324:5: 
  322.       BN_MONT_CTX_init(ret);
  323.       ret->flags = BN_FLG_MALLOCED;
  324. >     return (ret);
  325.   }
  326.   

crypto/bn/bn_mont.c:325:1: return from a call to BN_MONT_CTX_new
  323.       ret->flags = BN_FLG_MALLOCED;
  324.       return (ret);
  325. > }
  326.   
  327.   void BN_MONT_CTX_init(BN_MONT_CTX *ctx)

crypto/ec/ec_lib.c:1078:9: Taking false branch
1076.   
1077.       group->mont_data = BN_MONT_CTX_new();
1078.       if (group->mont_data == NULL)
                ^
1079.           goto err;
1080.   

crypto/ec/ec_lib.c:1081:10: Taking true branch
1079.           goto err;
1080.   
1081.       if (!BN_MONT_CTX_set(group->mont_data, group->order, ctx)) {
                 ^
1082.           BN_MONT_CTX_free(group->mont_data);
1083.           group->mont_data = NULL;

crypto/ec/ec_lib.c:1082:9: Skipping BN_MONT_CTX_free(): empty list of specs
1080.   
1081.       if (!BN_MONT_CTX_set(group->mont_data, group->order, ctx)) {
1082.           BN_MONT_CTX_free(group->mont_data);
                ^
1083.           group->mont_data = NULL;
1084.           goto err;

crypto/ec/ec_lib.c:1083:9: 
1081.       if (!BN_MONT_CTX_set(group->mont_data, group->order, ctx)) {
1082.           BN_MONT_CTX_free(group->mont_data);
1083. >         group->mont_data = NULL;
1084.           goto err;
1085.       }
