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


crypto/dsa/dsa_ossl.c:332:1: Parameter `dsa->method_mont_p->RR.d`
330.   }
331.   
332. > static int dsa_do_verify(const unsigned char *dgst, int dgst_len,
333.                            DSA_SIG *sig, DSA *dsa)
334.   {

crypto/dsa/dsa_ossl.c:405:5: Call
403.       }
404.   
405.       DSA_MOD_EXP(goto err, dsa, t1, dsa->g, u1, dsa->pub_key, u2, dsa->p, ctx,
           ^
406.                   mont);
407.       /* BN_copy(&u1,&t1); */

crypto/bn/bn_exp2.c:118:1: Parameter `*in_mont->RR.d`
  116.   #define TABLE_SIZE      32
  117.   
  118. > int BN_mod_exp2_mont(BIGNUM *rr, const BIGNUM *a1, const BIGNUM *p1,
  119.                        const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
  120.                        BN_CTX *ctx, BN_MONT_CTX *in_mont)

crypto/bn/bn_exp2.c:236:10: Call
  234.                                    * second window */
  235.   
  236.       if (!BN_to_montgomery(r, BN_value_one(), mont, ctx))
                  ^
  237.           goto err;
  238.       for (b = bits - 1; b >= 0; b--) {

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_exp2_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;
