test/exptest.c:161: error: BUFFER_OVERRUN_L3
  Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mod_exp_mont`.
Showing all 20 steps of the trace


test/exptest.c:149:5: Call
147.       RAND_bytes(&c, 1);
148.       c = (c % BN_BITS) - BN_BITS2;
149.       BN_rand(a, NUM_BITS + c, BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ANY);
           ^
150.   
151.       RAND_bytes(&c, 1);

crypto/bn/bn_rand.c:97:1: Parameter `*rnd->d`
  95.   }
  96.   
  97. > int BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
  98.   {
  99.       return bnrand(NORMAL, rnd, bits, top, bottom);

crypto/bn/bn_rand.c:99:12: Call
  97.   int BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
  98.   {
  99.       return bnrand(NORMAL, rnd, bits, top, bottom);
                    ^
  100.   }
  101.   

crypto/bn/bn_rand.c:21:1: Parameter `*rnd->d`
    19.   } BNRAND_FLAG;
    20.   
    21. > static int bnrand(BNRAND_FLAG flag, BIGNUM *rnd, int bits, int top, int bottom)
    22.   {
    23.       unsigned char *buf = NULL;

test/exptest.c:161:13: Call
159.       if (!TEST_true(BN_mod(a, a, m, ctx))
160.           || !TEST_true(BN_mod(b, b, m, ctx))
161.           || !TEST_true(BN_mod_exp_mont(r_mont, a, b, m, ctx, NULL))
                   ^
162.           || !TEST_true(BN_mod_exp_recp(r_recp, a, b, m, ctx))
163.           || !TEST_true(BN_mod_exp_simple(r_simple, a, b, m, ctx))

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:592:1: Parameter `*a->d`
    590.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
    591.    */
    592. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
    593.                                 const BIGNUM *m, BN_CTX *ctx,
    594.                                 BN_MONT_CTX *in_mont)

crypto/bn/bn_exp.c:757:10: Call
    755.   
    756.       /* prepare a^1 in Montgomery domain */
    757.       if (!bn_to_mont_fixed_top(&am, a, mont, ctx))
                    ^
    758.           goto err;
    759.   

crypto/bn/bn_mont.c:222:1: Parameter `*a->d`
      220.   }
      221.   
      222. > int bn_to_mont_fixed_top(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
      223.                            BN_CTX *ctx)
      224.   {

crypto/bn/bn_mont.c:225:12: Call
      223.                            BN_CTX *ctx)
      224.   {
      225.       return bn_mul_mont_fixed_top(r, a, &(mont->RR), mont, ctx);
                        ^
      226.   }
      227.   

crypto/bn/bn_mont.c:37:1: Parameter `*a->d`
        35.   }
        36.   
        37. > int bn_mul_mont_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
        38.                             BN_MONT_CTX *mont, BN_CTX *ctx)
        39.   {

crypto/bn/bn_mont.c:70:14: Call
        68.               goto err;
        69.       } else {
        70.           if (!bn_mul_fixed_top(tmp, a, b, ctx))
                           ^
        71.               goto err;
        72.       }

crypto/bn/bn_mul.c:507:1: Parameter `*a->d`
          505.   }
          506.   
          507. > int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
          508.   {
          509.       int ret = 0;

crypto/bn/bn_mul.c:587:17: Call
          585.                   if (bn_wexpand(rr, k * 4) == NULL)
          586.                       goto err;
          587.                   bn_mul_part_recursive(rr->d, a->d, b->d,
                                 ^
          588.                                         j, al - j, bl - j, t->d);
          589.               } 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:622:1: <Length trace>
620.   }
621.   
622. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
623.   {
624.       BN_ULONG *rr;

crypto/bn/bn_mul.c:622:1: Parameter `*b`
              620.   }
              621.   
              622. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
              623.   {
              624.       BN_ULONG *rr;

crypto/bn/bn_mul.c:657:50: Array access: Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mod_exp_mont` 
              655.           if (--nb <= 0)
              656.               return;
              657.           rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]);
                                                                      ^
              658.           rr += 4;
              659.           r += 4;
