crypto/bn/bn_prime.c:119: error: BUFFER_OVERRUN_L3
  Offset: [3, +oo] (⇐ [0, +oo] + 3) Size: [2, +oo] by call to `BN_is_prime`.
Showing all 19 steps of the trace


crypto/bn/bn_prime.c:105:9: Call
103.   		if (strong)
104.   			{
105.   			if (!probable_prime_dh_strong(rnd,bits,add,rem,ctx))
               ^
106.   				 goto err;
107.   			}

crypto/bn/bn_prime.c:334:1: Parameter `p->top`
  332.   	}
  333.   
  334. > static int probable_prime_dh_strong(BIGNUM *p, int bits, BIGNUM *padd,
  335.   	     BIGNUM *rem, BN_CTX *ctx)
  336.   	{

crypto/bn/bn_prime.c:119:5: Call
117.   	if (!strong)
118.   		{
119.   		i=BN_is_prime(rnd,BN_prime_checks,callback,ctx,cb_arg);
           ^
120.   		if (i == -1) goto err;
121.   		if (i == 0) goto loop;

crypto/bn/bn_prime.c:154:1: Parameter `a->top`
  152.   	}
  153.   
  154. > int BN_is_prime(BIGNUM *a, int checks, void (*callback)(int,int,char *),
  155.   	     BN_CTX *ctx_passed, char *cb_arg)
  156.   	{

crypto/bn/bn_prime.c:175:7: Call
  173.   
  174.   	/* Setup the montgomery structure */
  175.   	if (!BN_MONT_CTX_set(mont,a,ctx2)) goto err;
               ^
  176.   
  177.   	for (i=0; i<checks; i++)

crypto/bn/bn_mont.c:301:1: Parameter `*mont->N.d`
    299.   	}
    300.   
    301. > int BN_MONT_CTX_set(BN_MONT_CTX *mont, BIGNUM *mod, BN_CTX *ctx)
    302.   	{
    303.   	BIGNUM Ri,*R;

crypto/bn/bn_mont.c:307:2: Call
    305.   	BN_init(&Ri);
    306.   	R= &(mont->RR);					/* grab RR as a temp */
    307.   	BN_copy(&(mont->N),mod);			/* Set N */
            ^
    308.   
    309.   #ifdef BN_RECURSION_MONT

crypto/bn/bn_lib.c:499:1: Parameter `*a->d`
      497.   	}
      498.   
      499. > BIGNUM *BN_copy(BIGNUM *a, BIGNUM *b)
      500.   	{
      501.   	int i;

crypto/bn/bn_prime.c:180:5: Call
  178.   		{
  179.   		if (!BN_rand(check,BN_num_bits(a)-1,0,0)) goto err;
  180.   		j=witness(check,a,ctx,ctx2,mont);
             ^
  181.   		if (j == -1) goto err;
  182.   		if (j)

crypto/bn/bn_prime.c:203:1: Parameter `*mont->N.d`
    201.   #define RECP_MUL_MOD
    202.   
    203. > static int witness(BIGNUM *a, BIGNUM *n, BN_CTX *ctx, BN_CTX *ctx2,
    204.   	     BN_MONT_CTX *mont)
    205.   	{

crypto/bn/bn_prime.c:226:7: Call
    224.   	k=BN_num_bits(n1);
    225.   
    226.   	if (!BN_to_montgomery(mont_one,BN_value_one(),mont,ctx2)) goto err;
                 ^
    227.   	if (!BN_to_montgomery(mont_n1,n1,mont,ctx2)) goto err;
    228.   	if (!BN_to_montgomery(mont_a,a,mont,ctx2)) goto err;

crypto/bn/bn_mont.c:71:1: Parameter `*mont->N.d`
      69.   #define MONT_WORD
      70.   
      71. > int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_MONT_CTX *mont,
      72.   	     BN_CTX *ctx)
      73.   	{

crypto/bn/bn_mont.c:101:7: Call
      99.   		}
      100.   	/* reduce from aRR to aR */
      101.   	if (!BN_from_montgomery(r,tmp,mont,ctx)) goto err;
                   ^
      102.   	ctx->tos-=2;
      103.   	return(1);

crypto/bn/bn_mont.c:108:1: Parameter `*mont->N.d`
        106.   	}
        107.   
        108. > int BN_from_montgomery(BIGNUM *ret, BIGNUM *a, BN_MONT_CTX *mont,
        109.   	     BN_CTX *ctx)
        110.   	{

crypto/bn/bn_mont.c:137:3: Assignment
        135.   
        136.   		r->neg=a->neg^n->neg;
        137.   		np=n->d;
                 ^
        138.   		rp=r->d;
        139.   		nrp= &(r->d[nl]);

crypto/bn/bn_mont.c:157:6: Call
        155.   		for (i=0; i<nl; i++)
        156.   			{
        157.   			v=bn_mul_add_words(rp,np,nl,(rp[0]*n0)&BN_MASK2);
                    ^
        158.   			nrp++;
        159.   			rp++;

crypto/bn/bn_asm.c:143:1: <Length trace>
141.   #else
142.   
143. > BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
144.   	{
145.   	BN_ULONG c=0;

crypto/bn/bn_asm.c:143:1: Parameter `*ap`
          141.   #else
          142.   
          143. > BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
          144.   	{
          145.   	BN_ULONG c=0;

crypto/bn/bn_asm.c:162:3: Array access: Offset: [3, +oo] (⇐ [0, +oo] + 3) Size: [2, +oo] by call to `BN_is_prime` 
          160.   		mul_add(rp[2],ap[2],bl,bh,c);
          161.   		if (--num == 0) break;
          162.   		mul_add(rp[3],ap[3],bl,bh,c);
                   ^
          163.   		if (--num == 0) break;
          164.   		ap+=4;
