ssl/s3_srvr.c:1376: error: BUFFER_OVERRUN_L3
  Offset: [1, +oo] Size: [0, +oo] by call to `DH_compute_key`.
Showing all 18 steps of the trace


ssl/s3_srvr.c:1369:7: Call
1367.   			}
1368.   
1369.   		pub=BN_bin2bn(p,i,NULL);
              ^
1370.   		if (pub == NULL)
1371.   			{

crypto/bn/bn_lib.c:574:1: Parameter `*ret->d`
  572.   
  573.   /* ignore negative */
  574. > BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret)
  575.   	{
  576.   	unsigned int i,m;

ssl/s3_srvr.c:1376:5: Call
1374.   			}
1375.   
1376.   		i=DH_compute_key(p,pub,dh_srvr);
            ^
1377.   
1378.   		if (i <= 0)

crypto/dh/dh_key.c:121:1: Parameter `*pub_key->d`
  119.   	}
  120.   
  121. > int DH_compute_key(unsigned char *key, BIGNUM *pub_key, DH *dh)
  122.   	{
  123.   	BN_CTX ctx;

crypto/dh/dh_key.c:144:7: Call
  142.   
  143.   	mont=(BN_MONT_CTX *)dh->method_mont_p;
  144.   	if (!BN_mod_exp_mont(tmp,pub_key,dh->priv_key,dh->p,&ctx,mont))
               ^
  145.   		{
  146.   		DHerr(DH_F_DH_COMPUTE_KEY,ERR_R_BN_LIB);

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

crypto/bn/bn_div.c:286:1: Parameter `*rem->d`
      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->d`
        118.   #else
        119.   
        120. > int BN_div(BIGNUM *dv, BIGNUM *rm, BIGNUM *num, BIGNUM *divisor,
        121.   	     BN_CTX *ctx)
        122.   	{

crypto/bn/bn_exp.c:364:8: Call
    362.   		{
    363.   		BN_init(&(val[i]));
    364.   		if (!BN_mod_mul_montgomery(&(val[i]),&(val[i-1]),d,mont,ctx))
                  ^
    365.   			goto err;
    366.   		}

crypto/bn/bn_mont.c:71:1: Parameter `*r->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:184:8: <Offset trace>
182.   		ret->top=al;
183.   		al-=4;
184.   		for (i=0; i<al; i+=4)
              ^
185.   			{
186.   			BN_ULONG t1,t2,t3,t4;

crypto/bn/bn_mont.c:184:8: Assignment
        182.   		ret->top=al;
        183.   		al-=4;
        184.   		for (i=0; i<al; i+=4)
                      ^
        185.   			{
        186.   			BN_ULONG t1,t2,t3,t4;

crypto/bn/bn_mont.c:108:1: <Length trace>
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:108:1: Parameter `*ret->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:176:3: Assignment
        174.   #else
        175.   		x=ri;
        176.   		rp=ret->d;
                 ^
        177.   		ap= &(r->d[x]);
        178.   		if (r->top < x)

crypto/bn/bn_mont.c:193:4: Array access: Offset: [1, +oo] Size: [0, +oo] by call to `DH_compute_key` 
        191.   			t4=ap[i+3];
        192.   			rp[i+0]=t1;
        193.   			rp[i+1]=t2;
                  ^
        194.   			rp[i+2]=t3;
        195.   			rp[i+3]=t4;
