test/bntest.c:1795: error: BUFFER_OVERRUN_L3
  Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mul`.
Showing all 12 steps of the trace


test/bntest.c:1791:10: Call
1789.   
1790.       /* Test that BN_mul never gives negative zero. */
1791.       if (!TEST_true(BN_set_word(a, 1)))
                 ^
1792.           goto err;
1793.       BN_set_negative(a, 1);

crypto/bn/bn_lib.c:395:1: Parameter `*a->d`
  393.   }
  394.   
  395. > int BN_set_word(BIGNUM *a, BN_ULONG w)
  396.   {
  397.       bn_check_top(a);

crypto/bn/bn_lib.c:398:9: Call
  396.   {
  397.       bn_check_top(a);
  398.       if (bn_expand(a, (int)sizeof(BN_ULONG) * 8) == NULL)
                 ^
  399.           return (0);
  400.       a->neg = 0;

crypto/bn/bn_lcl.h:660:1: Parameter `*a->d`
    658.                            const BIGNUM *add, const BIGNUM *rem, BN_CTX *ctx);
    659.   
    660. > static ossl_inline BIGNUM *bn_expand(BIGNUM *a, int bits)
    661.   {
    662.       if (bits > (INT_MAX - BN_BITS2 + 1))

test/bntest.c:1795:10: Call
1793.       BN_set_negative(a, 1);
1794.       BN_zero(b);
1795.       if (!TEST_true(BN_mul(c, a, b, ctx)))
                 ^
1796.           goto err;
1797.       if (!TEST_BN_eq_zero(c)

crypto/bn/bn_mul.c:495:1: Parameter `*b->d`
  493.   #endif                          /* BN_RECURSION */
  494.   
  495. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  496.   {
  497.       int ret = 0;

crypto/bn/bn_mul.c:575:17: Call
  573.                   if (bn_wexpand(rr, k * 4) == NULL)
  574.                       goto err;
  575.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                         ^
  576.                                         j, al - j, bl - j, t->d);
  577.               } else {            /* al <= j || bl <= j */

crypto/bn/bn_mul.c:320:1: Parameter `*b`
    318.    */
    319.   /* tnX may not be negative but less than n */
    320. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
    321.                              int tna, int tnb, BN_ULONG *t)
    322.   {

crypto/bn/bn_mul.c:328:9: Call
    326.   
    327.       if (n < 8) {
    328.           bn_mul_normal(r, a, n + tna, b, n + tnb);
                   ^
    329.           return;
    330.       }

crypto/bn/bn_mul.c:650:1: <Length trace>
648.   }
649.   
650. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
651.   {
652.       BN_ULONG *rr;

crypto/bn/bn_mul.c:650:1: Parameter `*b`
      648.   }
      649.   
      650. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
      651.   {
      652.       BN_ULONG *rr;

crypto/bn/bn_mul.c:685:50: Array access: Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mul` 
      683.           if (--nb <= 0)
      684.               return;
      685.           rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]);
                                                              ^
      686.           rr += 4;
      687.           r += 4;
