crypto/bn/exptest.c:95: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp`.
Showing all 18 steps of the trace


crypto/bn/exptest.c:95:2: Call
93.   	r = BN_new();
94.   	if(!r) goto err;
95.   	BN_mod_exp(r, a, p, m, ctx);
       ^
96.   	BN_CTX_free(ctx);
97.   

crypto/bn/bn_exp.c:194:1: Parameter `ctx->stack.depth`
  192.   
  193.   
  194. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  195.   	       BN_CTX *ctx)
  196.   	{

crypto/bn/bn_exp.c:259:9: Call
  257.   #endif
  258.   #ifdef RECP_MUL_MOD
  259.   		{ ret=BN_mod_exp_recp(r,a,p,m,ctx); }
                 ^
  260.   #else
  261.   		{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }

crypto/bn/bn_exp.c:269:1: Parameter `ctx->stack.depth`
    267.   
    268.   
    269. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    270.   		    const BIGNUM *m, BN_CTX *ctx)
    271.   	{

crypto/bn/bn_exp.c:294:2: Call
    292.   		}
    293.   
    294.   	BN_CTX_start(ctx);
            ^
    295.   	aa = BN_CTX_get(ctx);
    296.   	val[0] = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:256:1: Parameter `ctx->stack.depth`
      254.   	}
      255.   
      256. > void BN_CTX_start(BN_CTX *ctx)
      257.   	{
      258.   	CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_exp.c:312:7: Call
    310.   		}
    311.   
    312.   	if (!BN_nnmod(val[0],a,m,ctx)) goto err;		/* 1 */
                 ^
    313.   	if (BN_is_zero(val[0]))
    314.   		{

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

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

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

crypto/bn/bn_div.c:227:2: Call
        225.   		}
        226.   
        227.   	BN_CTX_start(ctx);
                ^
        228.   	tmp=BN_CTX_get(ctx);
        229.   	snum=BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:256:1: Parameter `ctx->stack.depth`
          254.   	}
          255.   
          256. > void BN_CTX_start(BN_CTX *ctx)
          257.   	{
          258.   	CTXDBG_ENTRY("BN_CTX_start", ctx);

crypto/bn/bn_div.c:442:2: Call
        440.   		}
        441.   	if (no_branch)	bn_correct_top(res);
        442.   	BN_CTX_end(ctx);
                ^
        443.   	return(1);
        444.   err:

crypto/bn/bn_ctx.c:271:1: Parameter `ctx->stack.depth`
          269.   	}
          270.   
          271. > void BN_CTX_end(BN_CTX *ctx)
          272.   	{
          273.   	CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:278:21: Call
          276.   	else
          277.   		{
          278.   		unsigned int fp = BN_STACK_pop(&ctx->stack);
                                     ^
          279.   		/* Does this stack frame have anything to release? */
          280.   		if(fp < ctx->used)

crypto/bn/bn_ctx.c:352:1: <LHS trace>
350.   	}
351.   
352. > static unsigned int BN_STACK_pop(BN_STACK *st)
353.   	{
354.   	return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:352:1: Parameter `st->depth`
            350.   	}
            351.   
            352. > static unsigned int BN_STACK_pop(BN_STACK *st)
            353.   	{
            354.   	return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:354:9: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp` 
            352.   static unsigned int BN_STACK_pop(BN_STACK *st)
            353.   	{
            354.   	return st->indexes[--(st->depth)];
                           ^
            355.   	}
            356.   
