crypto/err/err.c:520: error: BUFFER_OVERRUN_L3
  Offset: [16, +oo] Size: [1, +oo] by call to `lh_ERR_STRING_DATA_insert`.
Showing all 18 steps of the trace


crypto/err/err.c:515:12: Call
513.   
514.       CRYPTO_w_lock(CRYPTO_LOCK_ERR);
515.       hash = get_hash(1, 0);
                  ^
516.       if (hash) {
517.           for (; str->error; str++) {

crypto/err/err.c:279:26: Call
  277.           CRYPTO_w_lock(CRYPTO_LOCK_ERR);
  278.       if (!int_error_hash && create) {
  279.           int_error_hash = lh_ERR_STRING_DATA_new(err_string_data_hash,
                                  ^
  280.                                                   err_string_data_cmp);
  281.       }

include/openssl/err.h:325:1: Call
    323.   } ERR_STRING_DATA;
    324.   
    325. > DEFINE_LHASH_OF(ERR_STRING_DATA);
    326.   
    327.   void ERR_put_error(int lib, int func, int reason, const char *file, int line);

crypto/lhash/lhash.c:123:5: Assignment
      121.       ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
      122.       ret->num_nodes = MIN_NODES / 2;
      123.       ret->num_alloc_nodes = MIN_NODES;
                 ^
      124.       ret->pmax = MIN_NODES / 2;
      125.       ret->up_load = UP_LOAD;

crypto/err/err.c:520:19: Call
518.               if (lib)
519.                   str->error |= ERR_PACK(lib, 0, 0);
520.               (void)lh_ERR_STRING_DATA_insert(hash, str);
                         ^
521.           }
522.       }

include/openssl/err.h:325:1: Parameter `lh->num_alloc_nodes`
  323.   } ERR_STRING_DATA;
  324.   
  325. > DEFINE_LHASH_OF(ERR_STRING_DATA);
  326.   
  327.   void ERR_put_error(int lib, int func, int reason, const char *file, int line);

include/openssl/err.h:325:1: Call
  323.   } ERR_STRING_DATA;
  324.   
  325. > DEFINE_LHASH_OF(ERR_STRING_DATA);
  326.   
  327.   void ERR_put_error(int lib, int func, int reason, const char *file, int line);

crypto/lhash/lhash.c:155:1: Parameter `lh->num_alloc_nodes`
    153.   }
    154.   
    155. > void *lh_insert(_LHASH *lh, void *data)
    156.   {
    157.       unsigned long hash;

crypto/lhash/lhash.c:163:9: Call
    161.       lh->error = 0;
    162.       if (lh->up_load <= (lh->num_items * LH_LOAD_MULT / lh->num_nodes))
    163.           expand(lh);
                   ^
    164.   
    165.       rn = getrn(lh, data, &hash);

crypto/lhash/lhash.c:278:1: <Offset trace>
276.   }
277.   
278. > static void expand(_LHASH *lh)
279.   {
280.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:278:1: Parameter `lh->num_alloc_nodes`
      276.   }
      277.   
      278. > static void expand(_LHASH *lh)
      279.   {
      280.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:304:9: Assignment
      302.   
      303.       if ((lh->p) >= lh->pmax) {
      304.           j = (int)lh->num_alloc_nodes * 2;
                     ^
      305.           n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
      306.           if (n == NULL) {

crypto/lhash/lhash.c:278:1: <Length trace>
276.   }
277.   
278. > static void expand(_LHASH *lh)
279.   {
280.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:278:1: Parameter `*lh->b`
      276.   }
      277.   
      278. > static void expand(_LHASH *lh)
      279.   {
      280.       LHASH_NODE **n, **n1, **n2, *np;

crypto/lhash/lhash.c:305:13: Call
      303.       if ((lh->p) >= lh->pmax) {
      304.           j = (int)lh->num_alloc_nodes * 2;
      305.           n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
                         ^
      306.           if (n == NULL) {
      307.               /* fputs("realloc error in lhash",stderr); */

crypto/mem.c:178:9: Assignment
        176.       if (num == 0) {
        177.           CRYPTO_free(str, file, line);
        178.           return NULL;
                       ^
        179.       }
        180.   

crypto/lhash/lhash.c:305:9: Assignment
      303.       if ((lh->p) >= lh->pmax) {
      304.           j = (int)lh->num_alloc_nodes * 2;
      305.           n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
                     ^
      306.           if (n == NULL) {
      307.               /* fputs("realloc error in lhash",stderr); */

crypto/lhash/lhash.c:313:13: Array access: Offset: [16, +oo] Size: [1, +oo] by call to `lh_ERR_STRING_DATA_insert` 
      311.           }
      312.           for (i = (int)lh->num_alloc_nodes; i < j; i++) /* 26/02/92 eay */
      313.               n[i] = NULL;        /* 02/03/92 eay */
                         ^
      314.           lh->pmax = lh->num_alloc_nodes;
      315.           lh->num_alloc_nodes = j;
