apps/s_client.c:421: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_exp`.
Showing all 26 steps of the trace


apps/s_client.c:413:3: Call
411.   	int ret =
412.   		g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) &&
413.   		BN_is_prime_ex(N, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) &&
         ^
414.   		p != NULL && BN_rshift1(p, N) &&
415.   

crypto/bn/bn_prime.c:238:1: Parameter `ctx_passed->stack.depth`
  236.   	}
  237.   
  238. > int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed, BN_GENCB *cb)
  239.   	{
  240.   	return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);

crypto/bn/bn_prime.c:240:9: Call
  238.   int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed, BN_GENCB *cb)
  239.   	{
  240.   	return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);
                 ^
  241.   	}
  242.   

crypto/bn/bn_prime.c:243:1: Parameter `ctx_passed->stack.depth`
    241.   	}
    242.   
    243. > int BN_is_prime_fasttest_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed,
    244.   		int do_trial_division, BN_GENCB *cb)
    245.   	{

apps/s_client.c:417:3: Call
415.   
416.   		/* p = (N-1)/2 */
417.   		BN_is_prime_ex(p, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) &&
         ^
418.   		r != NULL &&
419.   

crypto/bn/bn_prime.c:238:1: Parameter `ctx_passed->stack.depth`
  236.   	}
  237.   
  238. > int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed, BN_GENCB *cb)
  239.   	{
  240.   	return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);

crypto/bn/bn_prime.c:240:9: Call
  238.   int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed, BN_GENCB *cb)
  239.   	{
  240.   	return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);
                 ^
  241.   	}
  242.   

crypto/bn/bn_prime.c:243:1: Parameter `ctx_passed->stack.depth`
    241.   	}
    242.   
    243. > int BN_is_prime_fasttest_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed,
    244.   		int do_trial_division, BN_GENCB *cb)
    245.   	{

apps/s_client.c:421:3: Call
419.   
420.   		/* verify g^((N-1)/2) == -1 (mod N) */
421.   		BN_mod_exp(r, g, p, N, bn_ctx) &&
         ^
422.   		BN_add_word(r, 1) &&
423.   		BN_cmp(r, N) == 0;

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.   
