crypto/pem/pvkfmt.c:324: error: BUFFER_OVERRUN_L3
  Offset: [4, +oo] (⇐ [0, +oo] + 4) Size: [0, 8388607] by call to `BN_mod_exp`.
Showing all 19 steps of the trace


crypto/pem/pvkfmt.c:316:14: Call
314.               goto memerr;
315.       } else {
316.           if (!read_lebn(&p, 20, &dsa->priv_key))
                    ^
317.               goto memerr;
318.           /* Calculate public key */

crypto/pem/pvkfmt.c:106:10: Call
  104.       for (i = 0; i < nbyte; i++)
  105.           *q++ = *p--;
  106.       *r = BN_bin2bn(tmpbuf, nbyte, NULL);
                  ^
  107.       OPENSSL_free(tmpbuf);
  108.       if (*r) {

crypto/bn/bn_lib.c:542:1: Parameter `*ret->d`
    540.   }
    541.   
    542. > BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret)
    543.   {
    544.       unsigned int i, m;

crypto/pem/pvkfmt.c:324:14: Call
322.               goto memerr;
323.   
324.           if (!BN_mod_exp(dsa->pub_key, dsa->g, dsa->priv_key, dsa->p, ctx))
                    ^
325.               goto memerr;
326.           BN_CTX_free(ctx);

crypto/bn/bn_exp.c:191:1: Parameter `*a->d`
  189.   }
  190.   
  191. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  192.                  BN_CTX *ctx)
  193.   {

crypto/bn/bn_exp.c:251:19: Call
  249.           } else
  250.   # endif
  251.               ret = BN_mod_exp_mont(r, a, p, m, ctx, NULL);
                           ^
  252.       } else
  253.   #endif

crypto/bn/bn_exp.c:401:1: Parameter `*a->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 `*a->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 `*a->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 `*a->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 `*a`
            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` 
              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;
