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


crypto/rsa/rsa_eay.c:273:6: Call
271.   
272.   	/* make data into a big number */
273.   	if (BN_bin2bn(from,(int)flen,&f) == NULL) goto err;
            ^
274.   
275.   	if ((rsa->flags & RSA_FLAG_BLINDING) && (rsa->blinding == NULL))

crypto/bn/bn_lib.c:595:1: Parameter `*ret->d`
  593.   
  594.   /* ignore negative */
  595. > BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret)
  596.   	{
  597.   	unsigned int i,m;

crypto/rsa/rsa_eay.c:278:8: Call
276.   		RSA_blinding_on(rsa,ctx);
277.   	if (rsa->flags & RSA_FLAG_BLINDING)
278.   		if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
              ^
279.   
280.   	/* 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 `*ret->d`
    64.   
    65.   /* slow but works */
    66. > int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const 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:287:1: Parameter `*rem->d`
      285.   
      286.   /* rem != m */
      287. > int BN_mod(BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
      288.   	{
      289.   #if 0 /* The old slow way */

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

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

crypto/bn/bn_div.c:142:10: Call
        140.   		{
        141.   		if (rm != NULL)
        142.   			{ if (BN_copy(rm,num) == NULL) return(0); }
                        ^
        143.   		if (dv != NULL) BN_zero(dv);
        144.   		return(1);

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

crypto/bn/bn_lib.c:508:6: Call
          506.   
          507.   	if (a == b) return(a);
          508.   	if (bn_wexpand(a,b->top) == NULL) return(NULL);
                      ^
          509.   
          510.   #if 1

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->d`
            342.   	}
            343.   
            344. > BIGNUM *bn_expand2(BIGNUM *b, int words)
            345.   	{
            346.   	BN_ULONG *A,*a;

crypto/bn/bn_lib.c:367:3: Assignment
            365.   			}
            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:447:35: Array access: Offset: [3, +oo] (⇐ [0, +oo] + 3) Size: [0, +oo] by call to `BN_BLINDING_convert` 
            445.   				 */
            446.   				BN_ULONG a0,a1,a2,a3;
            447.   				a0=B[0]; a1=B[1]; a2=B[2]; a3=B[3];
                                                     ^
            448.   				A[0]=a0; A[1]=a1; A[2]=a2; A[3]=a3;
            449.   				}
