crypto/jpake/jpaketest.c:24: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `JPAKE_STEP1_generate`.
Showing all 24 steps of the trace


crypto/jpake/jpaketest.c:24:5: Call
22.       puts("A->B s1");
23.       JPAKE_STEP1_init(&alice_s1);
24.       JPAKE_STEP1_generate(&alice_s1, alice);
          ^
25.       if(!JPAKE_STEP1_process(bob, &alice_s1))
26.   	{

crypto/jpake/jpake.c:277:1: Parameter `ctx->ctx->stack.depth`
  275.       }
  276.   
  277. > int JPAKE_STEP1_generate(JPAKE_STEP1 *send, JPAKE_CTX *ctx)
  278.       {
  279.       genrand(ctx);

crypto/jpake/jpake.c:280:5: Call
  278.       {
  279.       genrand(ctx);
  280.       generate_step_part(&send->p1, ctx->xa, ctx->p.g, ctx);
             ^
  281.       generate_step_part(&send->p2, ctx->xb, ctx->p.g, ctx);
  282.   

crypto/jpake/jpake.c:248:1: Parameter `ctx->ctx->stack.depth`
    246.       }    
    247.   
    248. > static void generate_step_part(JPAKE_STEP_PART *p, const BIGNUM *x,
    249.   			       const BIGNUM *g, JPAKE_CTX *ctx)
    250.       {

crypto/jpake/jpake.c:251:5: Call
    249.   			       const BIGNUM *g, JPAKE_CTX *ctx)
    250.       {
    251.       BN_mod_exp(p->gx, g, x, ctx->p.p, ctx->ctx);
               ^
    252.       generate_zkp(p, x, g, ctx);
    253.       }

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

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

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

crypto/bn/bn_exp.c:263:2: Call
        261.   		}
        262.   
        263.   	BN_CTX_start(ctx);
                ^
        264.   	aa = BN_CTX_get(ctx);
        265.   	val[0] = BN_CTX_get(ctx);

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

crypto/bn/bn_exp.c:281:7: Call
        279.   		}
        280.   
        281.   	if (!BN_nnmod(val[0],a,m,ctx)) goto err;		/* 1 */
                     ^
        282.   	if (BN_is_zero(val[0]))
        283.   		{

crypto/bn/bn_mod.c:127:1: Parameter `ctx->stack.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:181:1: Parameter `ctx->stack.depth`
            179.   static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
            180.           const BIGNUM *divisor, BN_CTX *ctx);
            181. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
            182.   	   BN_CTX *ctx)
            183.   	{

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

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

crypto/bn/bn_div.c:445:2: Call
              443.   		}
              444.   
              445.   	BN_CTX_start(ctx);
                      ^
              446.   	tmp=BN_CTX_get(ctx);
              447.   	snum=BN_CTX_get(ctx);

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

crypto/bn/bn_div.c:641:2: Call
              639.   		}
              640.   	bn_correct_top(res);
              641.   	BN_CTX_end(ctx);
                      ^
              642.   	return(1);
              643.   err:

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

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

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

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

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