test/bntest.c:1795: error: BUFFER_OVERRUN_L3
  Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `BN_mul`.
Showing all 17 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 `n`
    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:334:10: Call
    332.       /* r=(a[0]-a[1])*(b[1]-b[0]) */
    333.       c1 = bn_cmp_part_words(a, &(a[n]), tna, n - tna);
    334.       c2 = bn_cmp_part_words(&(b[n]), b, tnb, tnb - n);
                    ^
    335.       neg = 0;
    336.       switch (c1 * 3 + c2) {

crypto/bn/bn_lib.c:735:1: Parameter `cl`
      733.    */
      734.   
      735. > int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b, int cl, int dl)
      736.   {
      737.       int n, i;

crypto/bn/bn_lib.c:752:12: Call
      750.           }
      751.       }
      752.       return bn_cmp_words(a, b, cl);
                        ^
      753.   }
      754.   

crypto/bn/bn_lib.c:708:1: <Offset trace>
706.   }
707.   
708. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
709.   {
710.       int i;

crypto/bn/bn_lib.c:708:1: Parameter `n`
        706.   }
        707.   
        708. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
        709.   {
        710.       int i;

crypto/bn/bn_lib.c:717:10: Assignment
        715.       if (aa != bb)
        716.           return ((aa > bb) ? 1 : -1);
        717.       for (i = n - 2; i >= 0; i--) {
                        ^
        718.           aa = a[i];
        719.           bb = b[i];

crypto/bn/bn_lib.c:708:1: <Length trace>
706.   }
707.   
708. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
709.   {
710.       int i;

crypto/bn/bn_lib.c:708:1: Parameter `*a`
        706.   }
        707.   
        708. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
        709.   {
        710.       int i;

crypto/bn/bn_lib.c:718:14: Array access: Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `BN_mul` 
        716.           return ((aa > bb) ? 1 : -1);
        717.       for (i = n - 2; i >= 0; i--) {
        718.           aa = a[i];
                            ^
        719.           bb = b[i];
        720.           if (aa != bb)
