crypto/evp/evp_pkey.c:172: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: [0, +oo] by call to `BN_mod_exp`.
Showing all 16 steps of the trace


crypto/evp/evp_pkey.c:161:24: Call
159.   		}
160.   		/* Calculate public key (ouch!) */
161.   		if (!(dsa->pub_key = BN_new())) {
                              ^
162.   			EVPerr(EVP_F_EVP_PKCS82PKEY,ERR_R_MALLOC_FAILURE);
163.   			DSA_free (dsa);

crypto/bn/bn_lib.c:300:2: Assignment
  298.   		}
  299.   	ret->flags=BN_FLG_MALLOCED;
  300.   	ret->top=0;
          ^
  301.   	ret->neg=0;
  302.   	ret->max=0;

crypto/evp/evp_pkey.c:172:8: Call
170.   		}
171.   			
172.   		if (!BN_mod_exp(dsa->pub_key, dsa->g,
              ^
173.   						 dsa->priv_key, dsa->p, ctx)) {
174.   			

crypto/bn/bn_exp.c:157:1: Parameter `*m->d`
  155.   	}
  156.   
  157. > int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  158.   	       BN_CTX *ctx)
  159.   	{

crypto/bn/bn_exp.c:174:9: Call
  172.   
  173.   	if (BN_is_odd(m))
  174.   		{ ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL); }
                 ^
  175.   	else
  176.   #endif

crypto/bn/bn_exp.c:301:1: Parameter `*m->d`
    299.   
    300.   /* #ifdef MONT_MUL_MOD */
    301. > int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
    302.   		    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
    303.   	{

crypto/bn/bn_exp.c:346:3: Call
    344.   	if (BN_ucmp(a,m) >= 0)
    345.   		{
    346.   		BN_mod(&(val[0]),a,m,ctx);
             ^
    347.   		aa= &(val[0]);
    348.   		}

crypto/bn/bn_div.c:287:1: Parameter `*d->d`
      285.   
      286.   /* rem != m */
      287. > int BN_mod(BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
      288.   	{
      289.   #if 0 /* The old slow way */

crypto/bn/bn_div.c:313:9: Call
      311.   	return(1);
      312.   #else
      313.   	return(BN_div(NULL,rem,m,d,ctx));
                     ^
      314.   #endif
      315.   	}

crypto/bn/bn_div.c:121:1: Parameter `*divisor->d`
        119.   #else
        120.   
        121. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
        122.   	   BN_CTX *ctx)
        123.   	{

crypto/bn/bn_div.c:156:24: Call
        154.   
        155.   	/* First we normalise the numbers */
        156.   	norm_shift=BN_BITS2-((BN_num_bits(divisor))%BN_BITS2);
                                      ^
        157.   	BN_lshift(sdiv,divisor,norm_shift);
        158.   	sdiv->neg=0;

crypto/bn/bn_lib.c:238:1: <Offset trace>
236.   	}
237.   
238. > int BN_num_bits(const BIGNUM *a)
239.   	{
240.   	BN_ULONG l;

crypto/bn/bn_lib.c:238:1: Parameter `a->top`
          236.   	}
          237.   
          238. > int BN_num_bits(const BIGNUM *a)
          239.   	{
          240.   	BN_ULONG l;

crypto/bn/bn_lib.c:238:1: <Length trace>
236.   	}
237.   
238. > int BN_num_bits(const BIGNUM *a)
239.   	{
240.   	BN_ULONG l;

crypto/bn/bn_lib.c:238:1: Parameter `*a->d`
          236.   	}
          237.   
          238. > int BN_num_bits(const BIGNUM *a)
          239.   	{
          240.   	BN_ULONG l;

crypto/bn/bn_lib.c:246:4: Array access: Offset: [-1, +oo] Size: [0, +oo] by call to `BN_mod_exp` 
          244.   
          245.   	if (a->top == 0) return(0);
          246.   	l=a->d[a->top-1];
                    ^
          247.   	i=(a->top-1)*BN_BITS2;
          248.   	if (l == 0)
