crypto/dsa/dsa_gen.c:600: error: BUFFER_OVERRUN_L3
  Offset: [8, +oo] (⇐ [8, +oo] + [0, +oo]) Size: [0, 8388607] by call to `BN_mod_exp_mont`.
Showing all 22 steps of the trace


crypto/dsa/dsa_gen.c:457:17: Call
455.   
456.               /* step 4 */
457.               r = BN_is_prime_fasttest_ex(q, DSS_prime_checks, ctx,
                       ^
458.                                           seed_in ? 1 : 0, cb);
459.               if (r > 0)

crypto/bn/bn_prime.c:377:10: Call
  375.       if (mont == NULL)
  376.           goto err;
  377.       if (!BN_MONT_CTX_set(mont, A, ctx))
                  ^
  378.           goto err;
  379.   

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;

crypto/dsa/dsa_gen.c:600:14: Call
598.           }
599.           /* g=test^r0%p */
600.           if (!BN_mod_exp_mont(g, test, r0, p, ctx, mont))
                    ^
601.               goto err;
602.           if (!BN_is_one(g))

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:467:10: Call
  465.           goto err;
  466.       }
  467.       if (!BN_to_montgomery(val[0], aa, mont, ctx))
                  ^
  468.           goto err;               /* 1 */
  469.   

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_mod_exp_mont` 
              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)
