crypto/bn/bntest.c:584: error: BUFFER_OVERRUN_L1
  Offset: [7, +oo] (⇐ [0, +oo] + 7) Size: 4 by call to `BN_mod_mul`.
Showing all 17 steps of the trace


crypto/bn/bntest.c:585:3: Call
583.   			}
584.   		BN_mod_mul(&d,&a,&b,&n,ctx);
585.   		BN_sub(&d,&d,&A);
         ^
586.   		if(!BN_is_zero(&d))
587.   		    {

crypto/bn/bn_add.c:258:1: Parameter `a->top`
  256.   	}
  257.   
  258. > int BN_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b)
  259.   	{
  260.   	int max;

crypto/bn/bntest.c:584:3: Call
582.   			BIO_puts(bp,"\n");
583.   			}
584.   		BN_mod_mul(&d,&a,&b,&n,ctx);
         ^
585.   		BN_sub(&d,&d,&A);
586.   		if(!BN_is_zero(&d))

crypto/bn/bn_exp.c:66:1: Parameter `ret->top`
  64.   
  65.   /* slow but works */
  66. > int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, BIGNUM *m, BN_CTX *ctx)
  67.   	{
  68.   	BIGNUM *t;

crypto/bn/bn_exp.c:80:7: Call
  78.   	else
  79.   		{ if (!BN_mul(t,a,b,ctx)) goto err; }
  80.   	if (!BN_mod(ret,t,m,ctx)) goto err;
              ^
  81.   	r=1;
  82.   err:

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

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

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

crypto/bn/bn_div.c:275:3: Call
      273.   	if (rm != NULL)
      274.   		{
      275.   		BN_rshift(rm,snum,norm_shift);
               ^
      276.   		rm->neg=num->neg;
      277.   		}

crypto/bn/bn_shift.c:156:1: Parameter `r->top`
        154.   	}
        155.   
        156. > int BN_rshift(BIGNUM *r, BIGNUM *a, int n)
        157.   	{
        158.   	int i,j,nw,lb,rb;

crypto/bn/bn_shift.c:167:3: Call
        165.   	if (nw > a->top)
        166.   		{
        167.   		BN_zero(r);
                 ^
        168.   		return(1);
        169.   		}

crypto/bn/bn_lib.c:567:1: Parameter `a->top`
          565.   	}
          566.   
          567. > int BN_set_word(BIGNUM *a, BN_ULONG w)
          568.   	{
          569.   	int i,n;

crypto/bn/bn_lib.c:570:6: Call
          568.   	{
          569.   	int i,n;
          570.   	if (bn_expand(a,sizeof(BN_ULONG)*8) == NULL) return(0);
                      ^
          571.   
          572.   	n=sizeof(BN_ULONG)/BN_BYTES;

crypto/bn/bn_lib.c:344:1: <Length trace>
342.   	}
343.   
344. > BIGNUM *bn_expand2(BIGNUM *b, int words)
345.   	{
346.   	BN_ULONG *A,*a;

crypto/bn/bn_lib.c:344:1: Parameter `b->top`
            342.   	}
            343.   
            344. > BIGNUM *bn_expand2(BIGNUM *b, int words)
            345.   	{
            346.   	BN_ULONG *A,*a;

crypto/bn/bn_lib.c:466:3: Assignment
            464.   		/* Now need to zero any data between b->top and b->max */
            465.   
            466.   		A= &(b->d[b->top]);
                     ^
            467.   		for (i=(b->max - b->top)>>3; i>0; i--,A+=8)
            468.   			{

crypto/bn/bn_lib.c:470:28: Array access: Offset: [7, +oo] (⇐ [0, +oo] + 7) Size: 4 by call to `BN_mod_mul` 
            468.   			{
            469.   			A[0]=0; A[1]=0; A[2]=0; A[3]=0;
            470.   			A[4]=0; A[5]=0; A[6]=0; A[7]=0;
                                              ^
            471.   			}
            472.   		for (i=(b->max - b->top)&7; i>0; i--,A++)
