crypto/bn/bn_sqrt.c:146: error: BUFFER_OVERRUN_L2
  Offset: [3+min(-3, `ctx->depth`), 14+max(-2, `ctx->depth`)] Size: 12 by call to `BN_mod_exp`.
Showing all 63 steps of the trace


crypto/bn/bn_sqrt.c:62:1: Parameter `ctx->depth`
60.   
61.   
62. > BIGNUM *BN_mod_sqrt(BIGNUM *in, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx) 
63.   /* Returns 'ret' such that
64.    *      ret^2 == a (mod p),

crypto/bn/bn_sqrt.c:112:2: Call
110.   		}
111.   
112.   	BN_CTX_start(ctx);
        ^
113.   	A = BN_CTX_get(ctx);
114.   	b = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:133:1: Parameter `ctx->depth`
  131.   	}
  132.   
  133. > void BN_CTX_start(BN_CTX *ctx)
  134.   	{
  135.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:137:2: Assignment
  135.   	if (ctx->depth < BN_CTX_NUM_POS)
  136.   		ctx->pos[ctx->depth] = ctx->tos;
  137.   	ctx->depth++;
          ^
  138.   	}
  139.   

crypto/bn/bn_sqrt.c:113:6: Call
111.   
112.   	BN_CTX_start(ctx);
113.   	A = BN_CTX_get(ctx);
            ^
114.   	b = BN_CTX_get(ctx);
115.   	q = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
  139.   
  140.   
  141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  142.   	{
  143.   	BIGNUM *ret;

crypto/bn/bn_sqrt.c:114:6: Call
112.   	BN_CTX_start(ctx);
113.   	A = BN_CTX_get(ctx);
114.   	b = BN_CTX_get(ctx);
            ^
115.   	q = BN_CTX_get(ctx);
116.   	t = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
  139.   
  140.   
  141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  142.   	{
  143.   	BIGNUM *ret;

crypto/bn/bn_sqrt.c:115:6: Call
113.   	A = BN_CTX_get(ctx);
114.   	b = BN_CTX_get(ctx);
115.   	q = BN_CTX_get(ctx);
            ^
116.   	t = BN_CTX_get(ctx);
117.   	x = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
  139.   
  140.   
  141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  142.   	{
  143.   	BIGNUM *ret;

crypto/bn/bn_sqrt.c:116:6: Call
114.   	b = BN_CTX_get(ctx);
115.   	q = BN_CTX_get(ctx);
116.   	t = BN_CTX_get(ctx);
            ^
117.   	x = BN_CTX_get(ctx);
118.   	y = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
  139.   
  140.   
  141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  142.   	{
  143.   	BIGNUM *ret;

crypto/bn/bn_sqrt.c:117:6: Call
115.   	q = BN_CTX_get(ctx);
116.   	t = BN_CTX_get(ctx);
117.   	x = BN_CTX_get(ctx);
            ^
118.   	y = BN_CTX_get(ctx);
119.   	if (y == NULL) goto end;

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
  139.   
  140.   
  141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  142.   	{
  143.   	BIGNUM *ret;

crypto/bn/bn_sqrt.c:118:6: Call
116.   	t = BN_CTX_get(ctx);
117.   	x = BN_CTX_get(ctx);
118.   	y = BN_CTX_get(ctx);
            ^
119.   	if (y == NULL) goto end;
120.   	

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
  139.   
  140.   
  141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  142.   	{
  143.   	BIGNUM *ret;

crypto/bn/bn_sqrt.c:126:7: Call
124.   
125.   	/* A = a mod p */
126.   	if (!BN_nnmod(A, a, p, ctx)) goto end;
             ^
127.   
128.   	/* now write  |p| - 1  as  2^e*q  where  q  is odd */

crypto/bn/bn_mod.c:127:1: Parameter `ctx->depth`
  125.   
  126.   
  127. > int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
  128.   	{
  129.   	/* like BN_mod, but returns non-negative remainder

crypto/bn/bn_mod.c:132:8: Call
  130.   	 * (i.e.,  0 <= r < |d|  always holds) */
  131.   
  132.   	if (!(BN_mod(r,m,d,ctx)))
                ^
  133.   		return 0;
  134.   	if (!r->neg)

crypto/bn/bn_div.c:179:1: Parameter `ctx->depth`
    177.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
    178.    */
    179. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
    180.   	   BN_CTX *ctx)
    181.   	{

crypto/bn/bn_sqrt.c:146:8: Call
144.   		q->neg = 0;
145.   		if (!BN_add_word(q, 1)) goto end;
146.   		if (!BN_mod_exp(ret, A, q, p, ctx)) goto end;
              ^
147.   		err = 0;
148.   		goto vrfy;

crypto/bn/bn_exp.c:155:1: Parameter `ctx->depth`
  153.   
  154.   
  155. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  156.   	       BN_CTX *ctx)
  157.   	{

crypto/bn/bn_exp.c:215:8: Call
  213.   		else
  214.   #  endif
  215.   			ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL);
                ^
  216.   		}
  217.   	else

crypto/bn/bn_exp.c:358:1: Parameter `ctx->depth`
    356.   
    357.   
    358. > int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
    359.   		    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
    360.   	{

crypto/bn/bn_exp.c:385:2: Call
    383.   		}
    384.   
    385.   	BN_CTX_start(ctx);
            ^
    386.   	d = BN_CTX_get(ctx);
    387.   	r = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:133:1: Parameter `ctx->depth`
      131.   	}
      132.   
      133. > void BN_CTX_start(BN_CTX *ctx)
      134.   	{
      135.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:137:2: Assignment
      135.   	if (ctx->depth < BN_CTX_NUM_POS)
      136.   		ctx->pos[ctx->depth] = ctx->tos;
      137.   	ctx->depth++;
              ^
      138.   	}
      139.   

crypto/bn/bn_exp.c:386:6: Call
    384.   
    385.   	BN_CTX_start(ctx);
    386.   	d = BN_CTX_get(ctx);
                ^
    387.   	r = BN_CTX_get(ctx);
    388.   	if (d == NULL || r == NULL) goto err;

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
      139.   
      140.   
      141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      142.   	{
      143.   	BIGNUM *ret;

crypto/bn/bn_exp.c:387:6: Call
    385.   	BN_CTX_start(ctx);
    386.   	d = BN_CTX_get(ctx);
    387.   	r = BN_CTX_get(ctx);
                ^
    388.   	if (d == NULL || r == NULL) goto err;
    389.   

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
      139.   
      140.   
      141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
      142.   	{
      143.   	BIGNUM *ret;

crypto/bn/bn_exp.c:417:7: Call
    415.   		goto err;
    416.   		}
    417.   	if (!BN_to_montgomery(&(val[0]),aa,mont,ctx)) goto err; /* 1 */
                 ^
    418.   
    419.   	window = BN_window_bits_for_exponent_size(bits);

crypto/bn/bn_mont.c:72:1: Parameter `ctx->depth`
      70.   #define MONT_WORD /* use the faster word-based algorithm */
      71.   
      72. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
      73.   			  BN_MONT_CTX *mont, BN_CTX *ctx)
      74.   	{

crypto/bn/bn_mont.c:78:2: Call
      76.   	int ret=0;
      77.   
      78.   	BN_CTX_start(ctx);
             ^
      79.   	tmp = BN_CTX_get(ctx);
      80.   	if (tmp == NULL) goto err;

crypto/bn/bn_ctx.c:133:1: Parameter `ctx->depth`
        131.   	}
        132.   
        133. > void BN_CTX_start(BN_CTX *ctx)
        134.   	{
        135.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:137:2: Assignment
        135.   	if (ctx->depth < BN_CTX_NUM_POS)
        136.   		ctx->pos[ctx->depth] = ctx->tos;
        137.   	ctx->depth++;
                ^
        138.   	}
        139.   

crypto/bn/bn_mont.c:79:8: Call
      77.   
      78.   	BN_CTX_start(ctx);
      79.   	tmp = BN_CTX_get(ctx);
                   ^
      80.   	if (tmp == NULL) goto err;
      81.   

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
        139.   
        140.   
        141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        142.   	{
        143.   	BIGNUM *ret;

crypto/bn/bn_mont.c:96:2: Call
      94.   	ret=1;
      95.   err:
      96.   	BN_CTX_end(ctx);
             ^
      97.   	return(ret);
      98.   	}

crypto/bn/bn_ctx.c:165:1: Parameter `ctx->depth`
        163.   	}
        164.   
        165. > void BN_CTX_end(BN_CTX *ctx)
        166.   	{
        167.   	if (ctx == NULL) return;

crypto/bn/bn_exp.c:422:8: Call
    420.   	if (window > 1)
    421.   		{
    422.   		if (!BN_mod_mul_montgomery(d,&(val[0]),&(val[0]),mont,ctx)) goto err; /* 2 */
                  ^
    423.   		j=1<<(window-1);
    424.   		for (i=1; i<j; i++)

crypto/bn/bn_mont.c:72:1: Parameter `ctx->depth`
      70.   #define MONT_WORD /* use the faster word-based algorithm */
      71.   
      72. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
      73.   			  BN_MONT_CTX *mont, BN_CTX *ctx)
      74.   	{

crypto/bn/bn_mont.c:78:2: Call
      76.   	int ret=0;
      77.   
      78.   	BN_CTX_start(ctx);
             ^
      79.   	tmp = BN_CTX_get(ctx);
      80.   	if (tmp == NULL) goto err;

crypto/bn/bn_ctx.c:133:1: Parameter `ctx->depth`
        131.   	}
        132.   
        133. > void BN_CTX_start(BN_CTX *ctx)
        134.   	{
        135.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:137:2: Assignment
        135.   	if (ctx->depth < BN_CTX_NUM_POS)
        136.   		ctx->pos[ctx->depth] = ctx->tos;
        137.   	ctx->depth++;
                ^
        138.   	}
        139.   

crypto/bn/bn_mont.c:79:8: Call
      77.   
      78.   	BN_CTX_start(ctx);
      79.   	tmp = BN_CTX_get(ctx);
                   ^
      80.   	if (tmp == NULL) goto err;
      81.   

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
        139.   
        140.   
        141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        142.   	{
        143.   	BIGNUM *ret;

crypto/bn/bn_mont.c:85:8: Call
      83.   	if (a == b)
      84.   		{
      85.   		if (!BN_sqr(tmp,a,ctx)) goto err;
                   ^
      86.   		}
      87.   	else

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_mont.c:92:7: Call
      90.   		}
      91.   	/* reduce from aRR to aR */
      92.   	if (!BN_from_montgomery(r,tmp,mont,ctx)) goto err;
                  ^
      93.   	bn_check_top(r);
      94.   	ret=1;

crypto/bn/bn_mont.c:100:1: Parameter `ctx->depth`
        98.   	}
        99.   
        100. > int BN_from_montgomery(BIGNUM *ret, const BIGNUM *a, BN_MONT_CTX *mont,
        101.   	     BN_CTX *ctx)
        102.   	{

crypto/bn/bn_mont.c:110:2: Call
        108.   	int al,nl,max,i,x,ri;
        109.   
        110.   	BN_CTX_start(ctx);
                ^
        111.   	if ((r = BN_CTX_get(ctx)) == NULL) goto err;
        112.   

crypto/bn/bn_ctx.c:133:1: Parameter `ctx->depth`
          131.   	}
          132.   
          133. > void BN_CTX_start(BN_CTX *ctx)
          134.   	{
          135.   	if (ctx->depth < BN_CTX_NUM_POS)

crypto/bn/bn_ctx.c:137:2: Assignment
          135.   	if (ctx->depth < BN_CTX_NUM_POS)
          136.   		ctx->pos[ctx->depth] = ctx->tos;
          137.   	ctx->depth++;
                  ^
          138.   	}
          139.   

crypto/bn/bn_mont.c:111:11: Call
        109.   
        110.   	BN_CTX_start(ctx);
        111.   	if ((r = BN_CTX_get(ctx)) == NULL) goto err;
                         ^
        112.   
        113.   	if (!BN_copy(r,a)) goto err;

crypto/bn/bn_ctx.c:141:1: Parameter `ctx->depth`
          139.   
          140.   
          141. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
          142.   	{
          143.   	BIGNUM *ret;

crypto/bn/bn_mont.c:235:2: Call
        233.   	bn_check_top(ret);
        234.    err:
        235.   	BN_CTX_end(ctx);
                ^
        236.   	return(retn);
        237.   	}

crypto/bn/bn_ctx.c:165:1: <Offset trace>
163.   	}
164.   
165. > void BN_CTX_end(BN_CTX *ctx)
166.   	{
167.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:165:1: Parameter `ctx->depth`
          163.   	}
          164.   
          165. > void BN_CTX_end(BN_CTX *ctx)
          166.   	{
          167.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:176:2: Assignment
          174.   
          175.   	ctx->too_many = 0;
          176.   	ctx->depth--;
                  ^
          177.   	if (ctx->depth < BN_CTX_NUM_POS)
          178.   #ifndef BN_DEBUG

crypto/bn/bn_ctx.c:165:1: <Length trace>
163.   	}
164.   
165. > void BN_CTX_end(BN_CTX *ctx)
166.   	{
167.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:165:1: Parameter `ctx->pos[*]`
          163.   	}
          164.   
          165. > void BN_CTX_end(BN_CTX *ctx)
          166.   	{
          167.   	if (ctx == NULL) return;

crypto/bn/bn_ctx.c:179:14: Array access: Offset: [3+min(-3, ctx->depth), 14+max(-2, ctx->depth)] Size: 12 by call to `BN_mod_exp` 
          177.   	if (ctx->depth < BN_CTX_NUM_POS)
          178.   #ifndef BN_DEBUG
          179.   		ctx->tos = ctx->pos[ctx->depth];
                              ^
          180.   #else
          181.   		while(ctx->tos > ctx->pos[ctx->depth])
