crypto/dh/dh_check.c:97: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp`.
Showing all 20 steps of the trace


crypto/dh/dh_check.c:83:2: Call
81.   	ctx=BN_CTX_new();
82.   	if (ctx == NULL) goto err;
83.   	BN_CTX_start(ctx);
       ^
84.   	t1=BN_CTX_get(ctx);
85.   	t2=BN_CTX_get(ctx);

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

crypto/dh/dh_check.c:97:9: Call
95.   			{
96.   			/* Check g^q == 1 mod p */
97.   			if (!BN_mod_exp(t1, dh->g, dh->q, dh->p, ctx))
               ^
98.   				goto err;
99.   			if (!BN_is_one(t1))

crypto/bn/bn_exp.c:177:1: Parameter `ctx->stack.depth`
  175.   
  176.   
  177. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  178.   	       BN_CTX *ctx)
  179.   	{

crypto/bn/bn_exp.c:242:9: Call
  240.   #endif
  241.   #ifdef RECP_MUL_MOD
  242.   		{ ret=BN_mod_exp_recp(r,a,p,m,ctx); }
                 ^
  243.   #else
  244.   		{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }

crypto/bn/bn_exp.c:252:1: Parameter `ctx->stack.depth`
    250.   
    251.   
    252. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    253.   		    const BIGNUM *m, BN_CTX *ctx)
    254.   	{

crypto/bn/bn_exp.c:277:2: Call
    275.   		}
    276.   
    277.   	BN_CTX_start(ctx);
            ^
    278.   	aa = BN_CTX_get(ctx);
    279.   	val[0] = BN_CTX_get(ctx);

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

crypto/bn/bn_exp.c:295:7: Call
    293.   		}
    294.   
    295.   	if (!BN_nnmod(val[0],a,m,ctx)) goto err;		/* 1 */
                 ^
    296.   	if (BN_is_zero(val[0]))
    297.   		{

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:183:1: Parameter `ctx->stack.depth`
        181.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
        182.    */
        183. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
        184.   	   BN_CTX *ctx)
        185.   	{

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

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

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

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

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

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

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

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