test/bntest.c:829: error: BUFFER_OVERRUN_L3
  Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `BN_to_montgomery`.
Showing all 19 steps of the trace


test/bntest.c:805:9: Call
803.   
804.       BN_zero(n);
805.       if (BN_MONT_CTX_set(mont, n, ctx)) {
               ^
806.           fprintf(stderr, "BN_MONT_CTX_set succeeded for zero modulus!\n");
807.           return 0;

crypto/bn/bn_mont.c:349:1: Parameter `*mont->RR.d`
  347.   }
  348.   
  349. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
  350.   {
  351.       int ret = 0;

test/bntest.c:829:9: Call
827.           BN_nnmod(b, b, n, ctx);
828.   
829.           BN_to_montgomery(A, a, mont, ctx);
               ^
830.           BN_to_montgomery(B, b, mont, ctx);
831.   

crypto/bn/bn_lib.c:924:1: Parameter `*mont->RR.d`
  922.   }
  923.   
  924. > int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
  925.                        BN_CTX *ctx)
  926.   {

crypto/bn/bn_lib.c:927:12: Call
  925.                        BN_CTX *ctx)
  926.   {
  927.       return BN_mod_mul_montgomery(r, a, &(mont->RR), mont, ctx);
                    ^
  928.   }
  929.   

crypto/bn/bn_mont.c:128:1: Parameter `*b->d`
    126.   #endif
    127.   
    128. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
    129.                             BN_MONT_CTX *mont, BN_CTX *ctx)
    130.   {

crypto/bn/bn_mont.c:158:14: Call
    156.               goto err;
    157.       } else {
    158.           if (!BN_mul(tmp, a, b, ctx))
                        ^
    159.               goto err;
    160.       }

crypto/bn/bn_mul.c:883:1: Parameter `*b->d`
      881.   #endif                          /* BN_RECURSION */
      882.   
      883. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
      884.   {
      885.       int ret = 0;

crypto/bn/bn_mul.c:964:17: Call
      962.                   if (bn_wexpand(rr, k * 4) == NULL)
      963.                       goto err;
      964.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                             ^
      965.                                         j, al - j, bl - j, t->d);
      966.               } else {            /* al <= j || bl <= j */

crypto/bn/bn_mul.c:534:1: Parameter `n`
        532.    */
        533.   /* tnX may not be negative but less than n */
        534. > void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
        535.                              int tna, int tnb, BN_ULONG *t)
        536.   {

crypto/bn/bn_mul.c:548:10: Call
        546.       /* r=(a[0]-a[1])*(b[1]-b[0]) */
        547.       c1 = bn_cmp_part_words(a, &(a[n]), tna, n - tna);
        548.       c2 = bn_cmp_part_words(&(b[n]), b, tnb, tnb - n);
                        ^
        549.       neg = 0;
        550.       switch (c1 * 3 + c2) {

crypto/bn/bn_lib.c:782:1: Parameter `cl`
          780.    */
          781.   
          782. > int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b, int cl, int dl)
          783.   {
          784.       int n, i;

crypto/bn/bn_lib.c:799:12: Call
          797.           }
          798.       }
          799.       return bn_cmp_words(a, b, cl);
                            ^
          800.   }
          801.   

crypto/bn/bn_lib.c:755:1: <Offset trace>
753.   }
754.   
755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
756.   {
757.       int i;

crypto/bn/bn_lib.c:755:1: Parameter `n`
            753.   }
            754.   
            755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
            756.   {
            757.       int i;

crypto/bn/bn_lib.c:764:10: Assignment
            762.       if (aa != bb)
            763.           return ((aa > bb) ? 1 : -1);
            764.       for (i = n - 2; i >= 0; i--) {
                            ^
            765.           aa = a[i];
            766.           bb = b[i];

crypto/bn/bn_lib.c:755:1: <Length trace>
753.   }
754.   
755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
756.   {
757.       int i;

crypto/bn/bn_lib.c:755:1: Parameter `*a`
            753.   }
            754.   
            755. > int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n)
            756.   {
            757.       int i;

crypto/bn/bn_lib.c:765:14: Array access: Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `BN_to_montgomery` 
            763.           return ((aa > bb) ? 1 : -1);
            764.       for (i = n - 2; i >= 0; i--) {
            765.           aa = a[i];
                                ^
            766.           bb = b[i];
            767.           if (aa != bb)
