crypto/rsa/rsa_eay.c:208: error: BUFFER_OVERRUN_L3
  Offset: [-1, +oo] Size: 12 by call to `BN_BLINDING_convert`.
Showing all 24 steps of the trace


crypto/rsa/rsa_eay.c:180:11: Call
178.   	BN_init(&ret);
179.   
180.   	if ((ctx=BN_CTX_new()) == NULL) goto err;
                 ^
181.   	num=BN_num_bytes(rsa->n);
182.   	if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)

crypto/bn/bn_ctx.c:79:2: Call
  77.   		}
  78.   
  79.   	BN_CTX_init(ret);
         ^
  80.   	ret->flags=BN_FLG_MALLOCED;
  81.   	return(ret);

crypto/bn/bn_ctx.c:89:2: Assignment
    87.   	ctx->tos = 0;
    88.   	ctx->flags = 0;
    89.   	ctx->depth = 0;
           ^
    90.   	ctx->too_many = 0;
    91.   	for (i = 0; i < BN_CTX_NUM; i++)

crypto/rsa/rsa_eay.c:208:8: Call
206.   		RSA_blinding_on(rsa,ctx);
207.   	if (rsa->flags & RSA_FLAG_BLINDING)
208.   		if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
              ^
209.   
210.   	if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||

crypto/bn/bn_blind.c:115:1: Parameter `ctx->depth`
  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:127:1: Parameter `ctx->depth`
    125.   
    126.   /* slow but works */
    127. > int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
    128.   	{
    129.   	BIGNUM *t;

crypto/bn/bn_exp.c:136:2: Call
    134.   	bn_check_top(m);
    135.   
    136.   	BN_CTX_start(ctx);
            ^
    137.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
    138.   	if (a == b)

crypto/bn/bn_ctx.c:108:1: Parameter `ctx->depth`
      106.   	}
      107.   
      108. > void BN_CTX_start(BN_CTX *ctx)
      109.   	{
      110.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:112:2: Assignment
      110.   	if (ctx->depth < BN_CTX_NUM_POS)
      111.   		ctx->pos[ctx->depth] = ctx->tos;
      112.   	ctx->depth++;
              ^
      113.   	}
      114.   

crypto/bn/bn_exp.c:137:11: Call
    135.   
    136.   	BN_CTX_start(ctx);
    137.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
                     ^
    138.   	if (a == b)
    139.   		{ if (!BN_sqr(t,a,ctx)) goto err; }

crypto/bn/bn_ctx.c:115:1: Parameter `ctx->depth`
      113.   	}
      114.   
      115. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      116.   	{
      117.   	if (ctx->depth > BN_CTX_NUM_POS || ctx->tos >= BN_CTX_NUM)

crypto/bn/bn_exp.c:141:10: Call
    139.   		{ if (!BN_sqr(t,a,ctx)) goto err; }
    140.   	else
    141.   		{ if (!BN_mul(t,a,b,ctx)) goto err; }
                    ^
    142.   	if (!BN_mod(ret,t,m,ctx)) goto err;
    143.   	r=1;

crypto/bn/bn_mul.c:611:1: Parameter `ctx->depth`
      609.   #endif /* BN_RECURSION */
      610.   
      611. > int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
      612.   	{
      613.   	int top,al,bl;

crypto/bn/bn_mul.c:643:2: Call
      641.   	top=al+bl;
      642.   
      643.   	BN_CTX_start(ctx);
              ^
      644.   	if ((r == a) || (r == b))
      645.   		{

crypto/bn/bn_ctx.c:108:1: Parameter `ctx->depth`
        106.   	}
        107.   
        108. > void BN_CTX_start(BN_CTX *ctx)
        109.   	{
        110.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:112:2: Assignment
        110.   	if (ctx->depth < BN_CTX_NUM_POS)
        111.   		ctx->pos[ctx->depth] = ctx->tos;
        112.   	ctx->depth++;
                ^
        113.   	}
        114.   

crypto/bn/bn_mul.c:734:2: Call
      732.   	ret=1;
      733.   err:
      734.   	BN_CTX_end(ctx);
              ^
      735.   	return(ret);
      736.   	}

crypto/bn/bn_ctx.c:130:1: <Offset trace>
128.   	}
129.   
130. > void BN_CTX_end(BN_CTX *ctx)
131.   	{
132.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:130:1: Parameter `ctx->depth`
        128.   	}
        129.   
        130. > void BN_CTX_end(BN_CTX *ctx)
        131.   	{
        132.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:141:2: Assignment
        139.   
        140.   	ctx->too_many = 0;
        141.   	ctx->depth--;
                ^
        142.   	if (ctx->depth < BN_CTX_NUM_POS)
        143.   		ctx->tos = ctx->pos[ctx->depth];

crypto/bn/bn_ctx.c:130:1: <Length trace>
128.   	}
129.   
130. > void BN_CTX_end(BN_CTX *ctx)
131.   	{
132.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:130:1: Parameter `ctx->pos[*]`
        128.   	}
        129.   
        130. > void BN_CTX_end(BN_CTX *ctx)
        131.   	{
        132.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:143:14: Array access: Offset: [-1, +oo] Size: 12 by call to `BN_BLINDING_convert` 
        141.   	ctx->depth--;
        142.   	if (ctx->depth < BN_CTX_NUM_POS)
        143.   		ctx->tos = ctx->pos[ctx->depth];
                            ^
        144.   	}
