crypto/evp/pmeth_lib.c:180: error: MEMORY_LEAK
  memory dynamically allocated by call to `CRYPTO_zalloc()` at line 162, column 11 is not reachable after line 180, column 13.
Showing all 97 steps of the trace


crypto/evp/pmeth_lib.c:125:1: start of procedure int_ctx_new()
123.   }
124.   
125. > static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
126.   {
127.       EVP_PKEY_CTX *ret;

crypto/evp/pmeth_lib.c:129:9: Taking true branch
127.       EVP_PKEY_CTX *ret;
128.       const EVP_PKEY_METHOD *pmeth;
129.       if (id == -1) {
               ^
130.           if (!pkey || !pkey->ameth)
131.               return NULL;

crypto/evp/pmeth_lib.c:130:14: Taking false branch
128.       const EVP_PKEY_METHOD *pmeth;
129.       if (id == -1) {
130.           if (!pkey || !pkey->ameth)
                    ^
131.               return NULL;
132.           id = pkey->ameth->pkey_id;

crypto/evp/pmeth_lib.c:130:23: Taking false branch
128.       const EVP_PKEY_METHOD *pmeth;
129.       if (id == -1) {
130.           if (!pkey || !pkey->ameth)
                             ^
131.               return NULL;
132.           id = pkey->ameth->pkey_id;

crypto/evp/pmeth_lib.c:132:9: 
130.           if (!pkey || !pkey->ameth)
131.               return NULL;
132. >         id = pkey->ameth->pkey_id;
133.       }
134.   #ifndef OPENSSL_NO_ENGINE

crypto/evp/pmeth_lib.c:135:9: Taking true branch
133.       }
134.   #ifndef OPENSSL_NO_ENGINE
135.       if (pkey && pkey->engine)
               ^
136.           e = pkey->engine;
137.       /* Try to find an ENGINE which implements this method */

crypto/evp/pmeth_lib.c:135:17: Taking false branch
133.       }
134.   #ifndef OPENSSL_NO_ENGINE
135.       if (pkey && pkey->engine)
                       ^
136.           e = pkey->engine;
137.       /* Try to find an ENGINE which implements this method */

crypto/evp/pmeth_lib.c:138:9: Taking false branch
136.           e = pkey->engine;
137.       /* Try to find an ENGINE which implements this method */
138.       if (e) {
               ^
139.           if (!ENGINE_init(e)) {
140.               EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);

crypto/evp/pmeth_lib.c:144:9: 
142.           }
143.       } else
144. >         e = ENGINE_get_pkey_meth_engine(id);
145.   
146.       /*

crypto/engine/tb_pkmeth.c:116:1: start of procedure ENGINE_get_pkey_meth_engine()
  114.    * references) for a given pkey_meth 'nid'
  115.    */
  116. > ENGINE *ENGINE_get_pkey_meth_engine(int nid)
  117.   {
  118.       return engine_table_select(&pkey_meth_table, nid);

crypto/engine/tb_pkmeth.c:118:5: 
  116.   ENGINE *ENGINE_get_pkey_meth_engine(int nid)
  117.   {
  118. >     return engine_table_select(&pkey_meth_table, nid);
  119.   }
  120.   

crypto/engine/eng_table.c:233:1: start of procedure engine_table_select()
    231.   /* return a functional reference for a given 'nid' */
    232.   #ifndef ENGINE_TABLE_DEBUG
    233. > ENGINE *engine_table_select(ENGINE_TABLE **table, int nid)
    234.   #else
    235.   ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f,

crypto/engine/eng_table.c:239:5: 
    237.   #endif
    238.   {
    239. >     ENGINE *ret = NULL;
    240.       ENGINE_PILE tmplate, *fnd = NULL;
    241.       int initres, loop = 0;

crypto/engine/eng_table.c:240:5: 
    238.   {
    239.       ENGINE *ret = NULL;
    240. >     ENGINE_PILE tmplate, *fnd = NULL;
    241.       int initres, loop = 0;
    242.   

crypto/engine/eng_table.c:241:5: 
    239.       ENGINE *ret = NULL;
    240.       ENGINE_PILE tmplate, *fnd = NULL;
    241. >     int initres, loop = 0;
    242.   
    243.       if (!(*table)) {

crypto/engine/eng_table.c:243:11: 
    241.       int initres, loop = 0;
    242.   
    243. >     if (!(*table)) {
    244.   #ifdef ENGINE_TABLE_DEBUG
    245.           fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, nothing "

crypto/engine/eng_table.c:243:10: Taking true branch
    241.       int initres, loop = 0;
    242.   
    243.       if (!(*table)) {
                    ^
    244.   #ifdef ENGINE_TABLE_DEBUG
    245.           fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, nothing "

crypto/engine/eng_table.c:248:9: 
    246.                   "registered!\n", f, l, nid);
    247.   #endif
    248. >         return NULL;
    249.       }
    250.       ERR_set_mark();

crypto/engine/eng_table.c:329:1: return from a call to engine_table_select
    327.       ERR_pop_to_mark();
    328.       return ret;
    329. > }
    330.   
    331.   /* Table enumeration */

crypto/engine/tb_pkmeth.c:119:1: return from a call to ENGINE_get_pkey_meth_engine
  117.   {
  118.       return engine_table_select(&pkey_meth_table, nid);
  119. > }
  120.   
  121.   /* Obtains a pkey_meth implementation from an ENGINE functional reference */

crypto/evp/pmeth_lib.c:151:9: Taking false branch
149.        */
150.   
151.       if (e)
               ^
152.           pmeth = ENGINE_get_pkey_meth(e, id);
153.       else

crypto/evp/pmeth_lib.c:155:9: 
153.       else
154.   #endif
155. >         pmeth = EVP_PKEY_meth_find(id);
156.   
157.       if (pmeth == NULL) {

crypto/evp/pmeth_lib.c:106:1: start of procedure EVP_PKEY_meth_find()
  104.                                pmeth);
  105.   
  106. > const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
  107.   {
  108.       EVP_PKEY_METHOD tmp;

crypto/evp/pmeth_lib.c:109:5: 
  107.   {
  108.       EVP_PKEY_METHOD tmp;
  109. >     const EVP_PKEY_METHOD *t = &tmp, **ret;
  110.       tmp.pkey_id = type;
  111.       if (app_pkey_methods) {

crypto/evp/pmeth_lib.c:110:5: 
  108.       EVP_PKEY_METHOD tmp;
  109.       const EVP_PKEY_METHOD *t = &tmp, **ret;
  110. >     tmp.pkey_id = type;
  111.       if (app_pkey_methods) {
  112.           int idx;

crypto/evp/pmeth_lib.c:111:9: Taking true branch
  109.       const EVP_PKEY_METHOD *t = &tmp, **ret;
  110.       tmp.pkey_id = type;
  111.       if (app_pkey_methods) {
                 ^
  112.           int idx;
  113.           idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);

crypto/evp/pmeth_lib.c:113:9: 
  111.       if (app_pkey_methods) {
  112.           int idx;
  113. >         idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
  114.           if (idx >= 0)
  115.               return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);

crypto/include/internal/evp_int.h:122:1: start of procedure sk_EVP_PKEY_METHOD_find()
    120.   } /* EVP_PKEY_METHOD */ ;
    121.   
    122. > DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD)
    123.   
    124.   void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);

crypto/stack/stack.c:248:1: start of procedure sk_find()
      246.   }
      247.   
      248. > int sk_find(_STACK *st, void *data)
      249.   {
      250.       return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);

crypto/stack/stack.c:250:5: 
      248.   int sk_find(_STACK *st, void *data)
      249.   {
      250. >     return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
      251.   }
      252.   

crypto/stack/stack.c:224:1: start of procedure internal_find()
        222.   }
        223.   
        224. > static int internal_find(_STACK *st, void *data, int ret_val_options)
        225.   {
        226.       const void *const *r;

crypto/stack/stack.c:229:9: Taking false branch
        227.       int i;
        228.   
        229.       if (st == NULL)
                       ^
        230.           return -1;
        231.   

crypto/stack/stack.c:232:9: Taking true branch
        230.           return -1;
        231.   
        232.       if (st->comp == NULL) {
                       ^
        233.           for (i = 0; i < st->num; i++)
        234.               if (st->data[i] == data)

crypto/stack/stack.c:233:14: 
        231.   
        232.       if (st->comp == NULL) {
        233. >         for (i = 0; i < st->num; i++)
        234.               if (st->data[i] == data)
        235.                   return (i);

crypto/stack/stack.c:233:21: Loop condition is true. Entering loop body
        231.   
        232.       if (st->comp == NULL) {
        233.           for (i = 0; i < st->num; i++)
                                   ^
        234.               if (st->data[i] == data)
        235.                   return (i);

crypto/stack/stack.c:234:17: Taking true branch
        232.       if (st->comp == NULL) {
        233.           for (i = 0; i < st->num; i++)
        234.               if (st->data[i] == data)
                               ^
        235.                   return (i);
        236.           return (-1);

crypto/stack/stack.c:235:17: 
        233.           for (i = 0; i < st->num; i++)
        234.               if (st->data[i] == data)
        235. >                 return (i);
        236.           return (-1);
        237.       }

crypto/stack/stack.c:246:1: return from a call to internal_find
        244.           return (-1);
        245.       return (int)((char **)r - st->data);
        246. > }
        247.   
        248.   int sk_find(_STACK *st, void *data)

crypto/stack/stack.c:251:1: return from a call to sk_find
      249.   {
      250.       return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
      251. > }
      252.   
      253.   int sk_find_ex(_STACK *st, void *data)

crypto/include/internal/evp_int.h:122:1: return from a call to sk_EVP_PKEY_METHOD_find
    120.   } /* EVP_PKEY_METHOD */ ;
    121.   
    122. > DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD)
    123.   
    124.   void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);

crypto/evp/pmeth_lib.c:114:13: Taking true branch
  112.           int idx;
  113.           idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
  114.           if (idx >= 0)
                     ^
  115.               return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
  116.       }

crypto/evp/pmeth_lib.c:115:13: 
  113.           idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
  114.           if (idx >= 0)
  115. >             return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
  116.       }
  117.       ret = OBJ_bsearch_pmeth(&t, standard_methods,

crypto/include/internal/evp_int.h:122:1: start of procedure sk_EVP_PKEY_METHOD_value()
    120.   } /* EVP_PKEY_METHOD */ ;
    121.   
    122. > DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD)
    123.   
    124.   void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);

crypto/stack/stack.c:323:1: start of procedure sk_value()
      321.   }
      322.   
      323. > void *sk_value(const _STACK *st, int i)
      324.   {
      325.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:325:10: Taking false branch
      323.   void *sk_value(const _STACK *st, int i)
      324.   {
      325.       if (!st || (i < 0) || (i >= st->num))
                      ^
      326.           return NULL;
      327.       return st->data[i];

crypto/stack/stack.c:325:17: Taking false branch
      323.   void *sk_value(const _STACK *st, int i)
      324.   {
      325.       if (!st || (i < 0) || (i >= st->num))
                             ^
      326.           return NULL;
      327.       return st->data[i];

crypto/stack/stack.c:325:28: Taking false branch
      323.   void *sk_value(const _STACK *st, int i)
      324.   {
      325.       if (!st || (i < 0) || (i >= st->num))
                                        ^
      326.           return NULL;
      327.       return st->data[i];

crypto/stack/stack.c:327:5: 
      325.       if (!st || (i < 0) || (i >= st->num))
      326.           return NULL;
      327. >     return st->data[i];
      328.   }
      329.   

crypto/stack/stack.c:328:1: return from a call to sk_value
      326.           return NULL;
      327.       return st->data[i];
      328. > }
      329.   
      330.   void *sk_set(_STACK *st, int i, void *value)

crypto/include/internal/evp_int.h:122:1: return from a call to sk_EVP_PKEY_METHOD_value
    120.   } /* EVP_PKEY_METHOD */ ;
    121.   
    122. > DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD)
    123.   
    124.   void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);

crypto/evp/pmeth_lib.c:123:1: return from a call to EVP_PKEY_meth_find
  121.           return NULL;
  122.       return *ret;
  123. > }
  124.   
  125.   static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)

crypto/evp/pmeth_lib.c:157:9: Taking false branch
155.           pmeth = EVP_PKEY_meth_find(id);
156.   
157.       if (pmeth == NULL) {
               ^
158.           EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
159.           return NULL;

crypto/evp/pmeth_lib.c:162:5: 
160.       }
161.   
162. >     ret = OPENSSL_zalloc(sizeof(*ret));
163.       if (ret == NULL) {
164.   #ifndef OPENSSL_NO_ENGINE

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/evp/pmeth_lib.c:163:9: Taking false branch
161.   
162.       ret = OPENSSL_zalloc(sizeof(*ret));
163.       if (ret == NULL) {
               ^
164.   #ifndef OPENSSL_NO_ENGINE
165.           if (e)

crypto/evp/pmeth_lib.c:171:5: 
169.           return NULL;
170.       }
171. >     ret->engine = e;
172.       ret->pmeth = pmeth;
173.       ret->operation = EVP_PKEY_OP_UNDEFINED;

crypto/evp/pmeth_lib.c:172:5: 
170.       }
171.       ret->engine = e;
172. >     ret->pmeth = pmeth;
173.       ret->operation = EVP_PKEY_OP_UNDEFINED;
174.       ret->pkey = pkey;

crypto/evp/pmeth_lib.c:173:5: 
171.       ret->engine = e;
172.       ret->pmeth = pmeth;
173. >     ret->operation = EVP_PKEY_OP_UNDEFINED;
174.       ret->pkey = pkey;
175.       if (pkey)

crypto/evp/pmeth_lib.c:174:5: 
172.       ret->pmeth = pmeth;
173.       ret->operation = EVP_PKEY_OP_UNDEFINED;
174. >     ret->pkey = pkey;
175.       if (pkey)
176.           CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);

crypto/evp/pmeth_lib.c:175:9: Taking true branch
173.       ret->operation = EVP_PKEY_OP_UNDEFINED;
174.       ret->pkey = pkey;
175.       if (pkey)
               ^
176.           CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
177.   

crypto/evp/pmeth_lib.c:176:9: 
174.       ret->pkey = pkey;
175.       if (pkey)
176. >         CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
177.   
178.       if (pmeth->init) {

crypto/lock.c:456:1: start of procedure CRYPTO_add_lock()
  454.   }
  455.   
  456. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
  457.                       int line)
  458.   {

crypto/lock.c:459:5: 
  457.                       int line)
  458.   {
  459. >     int ret = 0;
  460.   
  461.       if (add_lock_callback != NULL) {

crypto/lock.c:461:9: Taking false branch
  459.       int ret = 0;
  460.   
  461.       if (add_lock_callback != NULL) {
                 ^
  462.   #ifdef LOCK_DEBUG
  463.           int before = *pointer;

crypto/lock.c:477:9: 
  475.   #endif
  476.       } else {
  477. >         CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);
  478.   
  479.           ret = *pointer + amount;

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
    412.   }
    413.   
    414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
    415.   {
    416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
    439.       }
    440.   #endif
    441.       if (type < 0) {
                   ^
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking false branch
    450.               CRYPTO_destroy_dynlockid(type);
    451.           }
    452.       } else if (locking_callback != NULL)
                          ^
    453.           locking_callback(mode, type, file, line);
    454.   }

crypto/lock.c:441:5: 
    439.       }
    440.   #endif
    441. >     if (type < 0) {
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
    452.       } else if (locking_callback != NULL)
    453.           locking_callback(mode, type, file, line);
    454. > }
    455.   
    456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/lock.c:479:9: 
  477.           CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);
  478.   
  479. >         ret = *pointer + amount;
  480.   #ifdef LOCK_DEBUG
  481.           {

crypto/lock.c:490:9: 
  488.           }
  489.   #endif
  490. >         *pointer = ret;
  491.           CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
  492.       }

crypto/lock.c:491:9: 
  489.   #endif
  490.           *pointer = ret;
  491. >         CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
  492.       }
  493.       return (ret);

crypto/lock.c:414:1: start of procedure CRYPTO_lock()
    412.   }
    413.   
    414. > void CRYPTO_lock(int mode, int type, const char *file, int line)
    415.   {
    416.   #ifdef LOCK_DEBUG

crypto/lock.c:441:9: Taking false branch
    439.       }
    440.   #endif
    441.       if (type < 0) {
                   ^
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:452:16: Taking false branch
    450.               CRYPTO_destroy_dynlockid(type);
    451.           }
    452.       } else if (locking_callback != NULL)
                          ^
    453.           locking_callback(mode, type, file, line);
    454.   }

crypto/lock.c:441:5: 
    439.       }
    440.   #endif
    441. >     if (type < 0) {
    442.           if (dynlock_lock_callback != NULL) {
    443.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:1: return from a call to CRYPTO_lock
    452.       } else if (locking_callback != NULL)
    453.           locking_callback(mode, type, file, line);
    454. > }
    455.   
    456.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/lock.c:493:5: 
  491.           CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
  492.       }
  493. >     return (ret);
  494.   }
  495.   

crypto/lock.c:494:1: return from a call to CRYPTO_add_lock
  492.       }
  493.       return (ret);
  494. > }
  495.   
  496.   const char *CRYPTO_get_lock_name(int type)

crypto/evp/pmeth_lib.c:178:9: Taking true branch
176.           CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
177.   
178.       if (pmeth->init) {
               ^
179.           if (pmeth->init(ret) <= 0) {
180.               EVP_PKEY_CTX_free(ret);

crypto/evp/pmeth_lib.c:179:13: Taking true branch
177.   
178.       if (pmeth->init) {
179.           if (pmeth->init(ret) <= 0) {
                   ^
180.               EVP_PKEY_CTX_free(ret);
181.               return NULL;

crypto/evp/pmeth_lib.c:180:13: Skipping EVP_PKEY_CTX_free(): empty list of specs
178.       if (pmeth->init) {
179.           if (pmeth->init(ret) <= 0) {
180.               EVP_PKEY_CTX_free(ret);
                   ^
181.               return NULL;
182.           }
