crypto/dsa/dsa_ossl.c:305: error: BUFFER_OVERRUN_L3
  Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mod_exp_mont`.
Showing all 17 steps of the trace


crypto/dsa/dsa_ossl.c:230:1: Parameter `dsa->method_mont_p->RR.d`
228.   }
229.   
230. > static int dsa_sign_setup(DSA *dsa, BN_CTX *ctx_in,
231.                             BIGNUM **kinvp, BIGNUM **rp,
232.                             const unsigned char *dgst, int dlen)

crypto/dsa/dsa_ossl.c:305:5: Call
303.           K = k;
304.       }
305.       DSA_BN_MOD_EXP(goto err, dsa, r, dsa->g, K, dsa->p, ctx,
           ^
306.                      dsa->method_mont_p);
307.       if (!BN_mod(r, r, dsa->q, ctx))

crypto/bn/bn_exp.c:401:1: Parameter `*in_mont->RR.d`
  399.   }
  400.   
  401. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
  402.                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
  403.   {

crypto/bn/bn_exp.c:413:16: Call
  411.   
  412.       if (BN_get_flags(p, BN_FLG_CONSTTIME) != 0) {
  413.           return BN_mod_exp_mont_consttime(rr, a, p, m, ctx, in_mont);
                        ^
  414.       }
  415.   

crypto/bn/bn_exp.c:655:1: Parameter `*in_mont->RR.d`
    653.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
    654.    */
    655. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
    656.                                 const BIGNUM *m, BN_CTX *ctx,
    657.                                 BN_MONT_CTX *in_mont)

crypto/bn/bn_exp.c:803:10: Call
    801.       } else
    802.   #endif
    803.       if (!BN_to_montgomery(&tmp, BN_value_one(), mont, ctx))
                    ^
    804.           goto err;
    805.   

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 `*b`
            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:542:9: Call
            540.   
            541.       if (n < 8) {
            542.           bn_mul_normal(r, a, n + tna, b, n + tnb);
                           ^
            543.           return;
            544.       }

crypto/bn/bn_mul.c:1037:1: <Length trace>
1035.   }
1036.   
1037. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
1038.   {
1039.       BN_ULONG *rr;

crypto/bn/bn_mul.c:1037:1: Parameter `*b`
              1035.   }
              1036.   
              1037. > void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
              1038.   {
              1039.       BN_ULONG *rr;

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