crypto/rsa/rsa_eay.c:287: error: BUFFER_OVERRUN_L3
  Offset: [4, +oo] (⇐ [1, +oo] + 3) Size: [0, +oo] by call to `BN_BLINDING_convert`.
Showing all 16 steps of the trace


crypto/rsa/rsa_eay.c:282:6: Call
280.   
281.   	/* make data into a big number */
282.   	if (BN_bin2bn(from,(int)flen,&f) == NULL) goto err;
            ^
283.   
284.   	if ((rsa->flags & RSA_FLAG_BLINDING) && (rsa->blinding == NULL))

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;

crypto/rsa/rsa_eay.c:287:8: Call
285.   		RSA_blinding_on(rsa,ctx);
286.   	if (rsa->flags & RSA_FLAG_BLINDING)
287.   		if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
              ^
288.   
289.   	/* do the decrypt */

crypto/bn/bn_blind.c:115:1: Parameter `*n->d`
  113.   	}
  114.   
  115. > int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
  116.   	{
  117.   	bn_check_top(n);

crypto/bn/bn_blind.c:124:9: Call
  122.   		return(0);
  123.   		}
  124.   	return(BN_mod_mul(n,n,b->A,b->mod,ctx));
                 ^
  125.   	}
  126.   

crypto/bn/bn_exp.c:66:1: Parameter `*a->d`
    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:77:10: Call
    75.   	t= &(ctx->bn[ctx->tos++]);
    76.   	if (a == b)
    77.   		{ if (!BN_sqr(t,a,ctx)) goto err; }
                   ^
    78.   	else
    79.   		{ if (!BN_mul(t,a,b,ctx)) goto err; }

crypto/bn/bn_sqr.c:65:1: Parameter `*a->d`
      63.   /* r must not be a */
      64.   /* I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96 */
      65. > int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx)
      66.   	{
      67.   	int max,al;

crypto/bn/bn_sqr.c:130:5: Call
      128.   				{
      129.   				if (bn_wexpand(tmp,max) == NULL) return(0);
      130.   				bn_sqr_normal(rr->d,a->d,al,tmp->d);
                 ^
      131.   				}
      132.   			}

crypto/bn/bn_sqr.c:146:1: Parameter `*a`
        144.   
        145.   /* tmp must have 2*n words */
        146. > void bn_sqr_normal(BN_ULONG *r, BN_ULONG *a, int n, BN_ULONG *tmp)
        147.   	{
        148.   	int i,j,max;

crypto/bn/bn_sqr.c:152:2: Assignment
        150.   
        151.   	max=n*2;
        152.   	ap=a;
                ^
        153.   	rp=r;
        154.   	rp[0]=rp[max-1]=0;

crypto/bn/bn_sqr.c:168:3: Assignment
        166.   		{
        167.   		j--;
        168.   		ap++;
                 ^
        169.   		rp[j]=bn_mul_add_words(rp,ap,j,ap[-1]);
        170.   		rp+=2;

crypto/bn/bn_sqr.c:169:9: Call
        167.   		j--;
        168.   		ap++;
        169.   		rp[j]=bn_mul_add_words(rp,ap,j,ap[-1]);
                       ^
        170.   		rp+=2;
        171.   		}

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: [4, +oo] (⇐ [1, +oo] + 3) Size: [0, +oo] by call to `BN_BLINDING_convert` 
          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;
