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


test/bntest.c:1910:5: Call
1908.               || !TEST_ptr(r = BN_new()))
1909.           goto err;
1910.       BN_zero(zero);
            ^
1911.   
1912.       if (!TEST_true(BN_mod_exp(r, a, zero, BN_value_one(), NULL))

crypto/bn/bn_lib.c:387:1: Parameter `*a->d`
  385.   }
  386.   
  387. > int BN_set_word(BIGNUM *a, BN_ULONG w)
  388.   {
  389.       bn_check_top(a);

crypto/bn/bn_lib.c:390:9: Call
  388.   {
  389.       bn_check_top(a);
  390.       if (bn_expand(a, (int)sizeof(BN_ULONG) * 8) == NULL)
                 ^
  391.           return 0;
  392.       a->neg = 0;

crypto/bn/bn_lcl.h:651:1: Parameter `*a->d`
    649.                            const BIGNUM *add, const BIGNUM *rem, BN_CTX *ctx);
    650.   
    651. > static ossl_inline BIGNUM *bn_expand(BIGNUM *a, int bits)
    652.   {
    653.       if (bits > (INT_MAX - BN_BITS2 + 1))

test/bntest.c:1912:10: Call
1910.       BN_zero(zero);
1911.   
1912.       if (!TEST_true(BN_mod_exp(r, a, zero, BN_value_one(), NULL))
                 ^
1913.               || !TEST_BN_eq_zero(r)
1914.               || !TEST_true(BN_mod_exp_mont(r, a, zero, BN_value_one(),

crypto/bn/bn_exp.c:89:1: Parameter `*a->d`
  87.   }
  88.   
  89. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  90.                  BN_CTX *ctx)
  91.   {

crypto/bn/bn_exp.c:144:19: Call
  142.           } else
  143.   # endif
  144.               ret = BN_mod_exp_mont(r, a, p, m, ctx, NULL);
                           ^
  145.       } else
  146.   #endif

crypto/bn/bn_exp.c:296:1: Parameter `*a->d`
    294.   }
    295.   
    296. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
    297.                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
    298.   {

crypto/bn/bn_exp.c:310:16: Call
    308.               || BN_get_flags(a, BN_FLG_CONSTTIME) != 0
    309.               || BN_get_flags(m, BN_FLG_CONSTTIME) != 0) {
    310.           return BN_mod_exp_mont_consttime(rr, a, p, m, ctx, in_mont);
                          ^
    311.       }
    312.   

crypto/bn/bn_exp.c:598:1: Parameter `*a->d`
      596.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
      597.    */
      598. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
      599.                                 const BIGNUM *m, BN_CTX *ctx,
      600.                                 BN_MONT_CTX *in_mont)

crypto/bn/bn_exp.c:755:17: Call
      753.           if (!BN_to_montgomery(&am, &am, mont, ctx))
      754.               goto err;
      755.       } else if (!BN_to_montgomery(&am, a, mont, ctx))
                             ^
      756.           goto err;
      757.   

crypto/bn/bn_lib.c:869:1: Parameter `*a->d`
        867.   }
        868.   
        869. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
        870.                        BN_CTX *ctx)
        871.   {

crypto/bn/bn_lib.c:872:12: Call
        870.                        BN_CTX *ctx)
        871.   {
        872.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                          ^
        873.   }
        874.   

crypto/bn/bn_mont.c:26:1: Parameter `*a->d`
          24.   #endif
          25.   
          26. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
          27.                             BN_MONT_CTX *mont, BN_CTX *ctx)
          28.   {

crypto/bn/bn_mont.c:56:14: Call
          54.               goto err;
          55.       } else {
          56.           if (!BN_mul(tmp, a, b, ctx))
                             ^
          57.               goto err;
          58.       }

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

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

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

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

crypto/bn/bn_mul.c:612:1: <Length trace>
610.   }
611.   
612. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
613.   {
614.       BN_ULONG *rr;

crypto/bn/bn_mul.c:612:1: Parameter `*b`
                610.   }
                611.   
                612. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
                613.   {
                614.       BN_ULONG *rr;

crypto/bn/bn_mul.c:647:50: Array access: Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mod_exp` 
                645.           if (--nb <= 0)
                646.               return;
                647.           rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]);
                                                                        ^
                648.           rr += 4;
                649.           r += 4;
