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


crypto/rsa/rsa_eay.c:256:6: Call
254.   	BN_init(&f);
255.   	BN_init(&ret);
256.   	ctx=BN_CTX_new();
            ^
257.   	if (ctx == NULL) goto err;
258.   

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:298:8: Call
296.   
297.   	if (rsa->flags & RSA_FLAG_BLINDING)
298.   		if (!BN_BLINDING_invert(&ret,rsa->blinding,ctx)) goto err;
              ^
299.   
300.   	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:72:1: Parameter `ctx->depth`
    70.   
    71.   /* slow but works */
    72. > int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
    73.   	{
    74.   	BIGNUM *t;

crypto/bn/bn_exp.c:81:2: Call
    79.   	bn_check_top(m);
    80.   
    81.   	BN_CTX_start(ctx);
           ^
    82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
    83.   	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:82:11: Call
    80.   
    81.   	BN_CTX_start(ctx);
    82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
                    ^
    83.   	if (a == b)
    84.   		{ 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:90:2: Call
    88.   	r=1;
    89.   err:
    90.   	BN_CTX_end(ctx);
           ^
    91.   	return(r);
    92.   	}

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_blind.c:139:8: Call
  137.   	if ((ret=BN_mod_mul(n,n,b->Ai,b->mod,ctx)) >= 0)
  138.   		{
  139.   		if (!BN_BLINDING_update(b,ctx))
                ^
  140.   			return(0);
  141.   		}

crypto/bn/bn_blind.c:97:1: Parameter `ctx->depth`
    95.   	}
    96.   
    97. > int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
    98.   	{
    99.   	int ret=0;

crypto/bn/bn_blind.c:107:7: Call
    105.   		}
    106.   		
    107.   	if (!BN_mod_mul(b->A,b->A,b->A,b->mod,ctx)) goto err;
                 ^
    108.   	if (!BN_mod_mul(b->Ai,b->Ai,b->Ai,b->mod,ctx)) goto err;
    109.   

crypto/bn/bn_exp.c:72:1: Parameter `ctx->depth`
      70.   
      71.   /* slow but works */
      72. > int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
      73.   	{
      74.   	BIGNUM *t;

crypto/bn/bn_exp.c:81:2: Call
      79.   	bn_check_top(m);
      80.   
      81.   	BN_CTX_start(ctx);
             ^
      82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
      83.   	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:82:11: Call
      80.   
      81.   	BN_CTX_start(ctx);
      82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
                      ^
      83.   	if (a == b)
      84.   		{ 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:90:2: Call
      88.   	r=1;
      89.   err:
      90.   	BN_CTX_end(ctx);
             ^
      91.   	return(r);
      92.   	}

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_blind.c:108:7: Call
    106.   		
    107.   	if (!BN_mod_mul(b->A,b->A,b->A,b->mod,ctx)) goto err;
    108.   	if (!BN_mod_mul(b->Ai,b->Ai,b->Ai,b->mod,ctx)) goto err;
                 ^
    109.   
    110.   	ret=1;

crypto/bn/bn_exp.c:72:1: Parameter `ctx->depth`
      70.   
      71.   /* slow but works */
      72. > int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
      73.   	{
      74.   	BIGNUM *t;

crypto/bn/bn_exp.c:81:2: Call
      79.   	bn_check_top(m);
      80.   
      81.   	BN_CTX_start(ctx);
             ^
      82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
      83.   	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:82:11: Call
      80.   
      81.   	BN_CTX_start(ctx);
      82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
                      ^
      83.   	if (a == b)
      84.   		{ 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:84:10: Call
      82.   	if ((t = BN_CTX_get(ctx)) == NULL) goto err;
      83.   	if (a == b)
      84.   		{ if (!BN_sqr(t,a,ctx)) goto err; }
                     ^
      85.   	else
      86.   		{ 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, 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: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_sqr.c:148:2: Call
        146.   	ret = 1;
        147.    err:
        148.   	BN_CTX_end(ctx);
                ^
        149.   	return(ret);
        150.   	}

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_invert` 
          141.   	ctx->depth--;
          142.   	if (ctx->depth < BN_CTX_NUM_POS)
          143.   		ctx->tos = ctx->pos[ctx->depth];
                              ^
          144.   	}
