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


crypto/rsa/rsa_eay.c:263:6: Call
261.   	BN_init(&f);
262.   	BN_init(&ret);
263.   	ctx=BN_CTX_new();
            ^
264.   	if (ctx == NULL) goto err;
265.   

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:305:8: Call
303.   
304.   	if (rsa->flags & RSA_FLAG_BLINDING)
305.   		if (!BN_BLINDING_invert(&ret,rsa->blinding,ctx)) goto err;
              ^
306.   
307.   	p=buf;

crypto/bn/bn_blind.c:127:1: Parameter `ctx->depth`
  125.   	}
  126.   
  127. > int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
  128.   	{
  129.   	int ret;

crypto/bn/bn_blind.c:137:11: Call
  135.   		return(0);
  136.   		}
  137.   	if ((ret=BN_mod_mul(n,n,b->Ai,b->mod,ctx)) >= 0)
                   ^
  138.   		{
  139.   		if (!BN_BLINDING_update(b,ctx))

crypto/bn/bn_exp.c:120:1: Parameter `ctx->depth`
    118.   
    119.   /* slow but works */
    120. > int BN_mod_mul(BIGNUM *ret, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
    121.   	BN_CTX *ctx)
    122.   	{

crypto/bn/bn_exp.c:130:2: Call
    128.   	bn_check_top(m);
    129.   
    130.   	BN_CTX_start(ctx);
            ^
    131.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
    132.   	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:131:11: Call
    129.   
    130.   	BN_CTX_start(ctx);
    131.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
                     ^
    132.   	if (a == b)
    133.   		{ if (!BN_sqr(t,a,ctx)) goto err; }

crypto/bn/bn_ctx.c:116:1: Parameter `ctx->depth`
      114.   
      115.   
      116. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      117.   	{
      118.   	/* Note: If BN_CTX_get is ever changed to allocate BIGNUMs dynamically,

crypto/bn/bn_exp.c:133:10: Call
    131.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
    132.   	if (a == b)
    133.   		{ if (!BN_sqr(t,a,ctx)) goto err; }
                    ^
    134.   	else
    135.   		{ if (!BN_mul(t,a,b,ctx)) goto err; }

crypto/bn/bn_sqr.c:65:1: Parameter `ctx->depth`
      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, const BIGNUM *a, BN_CTX *ctx)
      66.   	{
      67.   	int max,al;

crypto/bn/bn_sqr.c:83:2: Call
      81.   		}
      82.   
      83.   	BN_CTX_start(ctx);
             ^
      84.   	rr=(a != r) ? r : BN_CTX_get(ctx);
      85.   	tmp=BN_CTX_get(ctx);

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_sqr.c:85:6: Call
      83.   	BN_CTX_start(ctx);
      84.   	rr=(a != r) ? r : BN_CTX_get(ctx);
      85.   	tmp=BN_CTX_get(ctx);
                 ^
      86.   	if (tmp == NULL) goto err;
      87.   

crypto/bn/bn_ctx.c:116:1: Parameter `ctx->depth`
        114.   
        115.   
        116. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        117.   	{
        118.   	/* Note: If BN_CTX_get is ever changed to allocate BIGNUMs dynamically,

crypto/bn/bn_sqr.c:147:2: Call
      145.   	ret = 1;
      146.    err:
      147.   	BN_CTX_end(ctx);
              ^
      148.   	return(ret);
      149.   	}

crypto/bn/bn_ctx.c:136:1: <Offset trace>
134.   	}
135.   
136. > void BN_CTX_end(BN_CTX *ctx)
137.   	{
138.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:136:1: Parameter `ctx->depth`
        134.   	}
        135.   
        136. > void BN_CTX_end(BN_CTX *ctx)
        137.   	{
        138.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:147:2: Assignment
        145.   
        146.   	ctx->too_many = 0;
        147.   	ctx->depth--;
                ^
        148.   	if (ctx->depth < BN_CTX_NUM_POS)
        149.   		ctx->tos = ctx->pos[ctx->depth];

crypto/bn/bn_ctx.c:136:1: <Length trace>
134.   	}
135.   
136. > void BN_CTX_end(BN_CTX *ctx)
137.   	{
138.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:136:1: Parameter `ctx->pos[*]`
        134.   	}
        135.   
        136. > void BN_CTX_end(BN_CTX *ctx)
        137.   	{
        138.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:149:14: Array access: Offset: [-1, +oo] Size: 12 by call to `BN_BLINDING_invert` 
        147.   	ctx->depth--;
        148.   	if (ctx->depth < BN_CTX_NUM_POS)
        149.   		ctx->tos = ctx->pos[ctx->depth];
                            ^
        150.   	}
