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


crypto/srp/srp_lib.c:270:7: Call
268.   		goto err;
269.   	
270.   	if (!BN_mod_exp(tmp,g,x,N,bn_ctx))
             ^
271.   		goto err;
272.   	if (!(k = srp_Calc_k(N,g)))

crypto/bn/bn_exp.c:165:1: Parameter `ctx->stack.depth`
  163.   
  164.   
  165. > int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
  166.   	       BN_CTX *ctx)
  167.   	{

crypto/bn/bn_exp.c:230:9: Call
  228.   #endif
  229.   #ifdef RECP_MUL_MOD
  230.   		{ ret=BN_mod_exp_recp(r,a,p,m,ctx); }
                 ^
  231.   #else
  232.   		{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }

crypto/bn/bn_exp.c:240:1: Parameter `ctx->stack.depth`
    238.   
    239.   
    240. > int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    241.   		    const BIGNUM *m, BN_CTX *ctx)
    242.   	{

crypto/bn/bn_exp.c:265:2: Call
    263.   		}
    264.   
    265.   	BN_CTX_start(ctx);
            ^
    266.   	aa = BN_CTX_get(ctx);
    267.   	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:283:7: Call
    281.   		}
    282.   
    283.   	if (!BN_nnmod(val[0],a,m,ctx)) goto err;		/* 1 */
                 ^
    284.   	if (BN_is_zero(val[0]))
    285.   		{

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.   static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
        182.           const BIGNUM *divisor, BN_CTX *ctx);
        183. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
        184.   	   BN_CTX *ctx)
        185.   	{

crypto/bn/bn_div.c:205:10: Call
        203.   	if ((BN_get_flags(num, BN_FLG_CONSTTIME) != 0) || (BN_get_flags(divisor, BN_FLG_CONSTTIME) != 0))
        204.   		{
        205.   		return BN_div_no_branch(dv, rm, num, divisor, ctx);
                        ^
        206.   		}
        207.   

crypto/bn/bn_div.c:428:1: Parameter `ctx->stack.depth`
          426.    * branches that may leak sensitive information.
          427.    */
          428. > static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, 
          429.   	const BIGNUM *divisor, BN_CTX *ctx)
          430.   	{

crypto/bn/bn_div.c:448:2: Call
          446.   		}
          447.   
          448.   	BN_CTX_start(ctx);
                  ^
          449.   	tmp=BN_CTX_get(ctx);
          450.   	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:644:2: Call
          642.   		}
          643.   	bn_correct_top(res);
          644.   	BN_CTX_end(ctx);
                  ^
          645.   	return(1);
          646.   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.   
