crypto/bn/bn_exp.c:209: error: BUFFER_OVERRUN_L1
  Offset: [7, +oo] (⇐ [0, +oo] + 7) Size: 4 by call to `BN_mod_mul_reciprocal`.
Showing all 19 steps of the trace


crypto/bn/bn_exp.c:203:6: Call
201.   		}
202.   	BN_RECP_CTX_init(&recp);
203.   	if (BN_RECP_CTX_set(&recp,m,ctx) <= 0) goto err;
            ^
204.   
205.   	BN_init(&(val[0]));

crypto/bn/bn_recp.c:94:1: Parameter `*recp->Nr.d`
  92.   	}
  93.   
  94. > int BN_RECP_CTX_set(BN_RECP_CTX *recp, BIGNUM *d, BN_CTX *ctx)
  95.   	{
  96.   	BN_copy(&(recp->N),d);

crypto/bn/bn_recp.c:97:2: Call
  95.   	{
  96.   	BN_copy(&(recp->N),d);
  97.   	BN_zero(&(recp->Nr));
          ^
  98.   	recp->num_bits=BN_num_bits(d);
  99.   	recp->shift=0;

crypto/bn/bn_lib.c:548:1: Parameter `*a->d`
    546.   	}
    547.   
    548. > int BN_set_word(BIGNUM *a, BN_ULONG w)
    549.   	{
    550.   	int i,n;

crypto/bn/bn_exp.c:209:7: Call
207.   
208.   	if (!BN_mod(&(val[0]),a,m,ctx)) goto err;		/* 1 */
209.   	if (!BN_mod_mul_reciprocal(aa,&(val[0]),&(val[0]),&recp,ctx))
             ^
210.   		goto err;				/* 2 */
211.   

crypto/bn/bn_recp.c:103:1: Parameter `*recp->Nr.d`
  101.   	}
  102.   
  103. > int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *x, BIGNUM *y, BN_RECP_CTX *recp,
  104.   	     BN_CTX *ctx)
  105.   	{

crypto/bn/bn_recp.c:120:2: Call
  118.   		a=x; /* Just do the mod */
  119.   
  120.   	BN_div_recp(NULL,r,a,recp,ctx);
          ^
  121.   	ret=1;
  122.   err:

crypto/bn/bn_recp.c:127:1: Parameter `*recp->Nr.d`
    125.   	}
    126.   
    127. > int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BN_RECP_CTX *recp,
    128.   	     BN_CTX *ctx)
    129.   	{

crypto/bn/bn_recp.c:174:15: Call
    172.   
    173.   	if (i != recp->shift)
    174.   		recp->shift=BN_reciprocal(&(recp->Nr),&(recp->N),
                         ^
    175.   			i,ctx);
    176.   

crypto/bn/bn_recp.c:211:1: Parameter `*r->d`
      209.    * we can do faster division if the remainder is not required.
      210.    */
      211. > int BN_reciprocal(BIGNUM *r, BIGNUM *m, int len, BN_CTX *ctx)
      212.   	{
      213.   	int ret= -1;

crypto/bn/bn_recp.c:221:7: Call
      219.   	if (!BN_set_bit(&t,len)) goto err;
      220.   
      221.   	if (!BN_div(r,NULL,&t,m,ctx)) goto err;
                   ^
      222.   	ret=len;
      223.   err:

crypto/bn/bn_div.c:120:1: Parameter `*dv->d`
        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:142:19: Call
        140.   		if (rm != NULL)
        141.   			{ if (BN_copy(rm,num) == NULL) return(0); }
        142.   		if (dv != NULL) BN_zero(dv);
                                 ^
        143.   		return(1);
        144.   		}

crypto/bn/bn_lib.c:548:1: Parameter `*a->d`
          546.   	}
          547.   
          548. > int BN_set_word(BIGNUM *a, BN_ULONG w)
          549.   	{
          550.   	int i,n;

crypto/bn/bn_lib.c:551:6: Call
          549.   	{
          550.   	int i,n;
          551.   	if (bn_expand(a,sizeof(BN_ULONG)*8) == NULL) return(0);
                      ^
          552.   
          553.   	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,*B,*a;

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

crypto/bn/bn_lib.c:367:3: Assignment
            365.   memset(A,0x5c,sizeof(BN_ULONG)*(words+1));
            366.   #if 1
            367.   		B=b->d;
                     ^
            368.   		/* Check if the previous number needs to be copied */
            369.   		if (B != NULL)

crypto/bn/bn_lib.c:377:43: Array access: Offset: [7, +oo] (⇐ [0, +oo] + 7) Size: 4 by call to `BN_mod_mul_reciprocal` 
            375.   				{
            376.   				A[0]=B[0]; A[1]=B[1]; A[2]=B[2]; A[3]=B[3];
            377.   				A[4]=B[4]; A[5]=B[5]; A[6]=B[6]; A[7]=B[7];
                                                             ^
            378.   				A+=8;
            379.   				B+=8;
