engines/e_aep.c:826: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `aep_mod_exp`.
Showing all 23 steps of the trace


engines/e_aep.c:815:1: Parameter `ctx->stack.depth`
813.   
814.   #ifndef OPENSSL_NO_DSA
815. > static int aep_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
816.   	BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
817.   	BN_CTX *ctx, BN_MONT_CTX *in_mont)

engines/e_aep.c:824:7: Call
822.   
823.   	/* let rr = a1 ^ p1 mod m */
824.   	if (!aep_mod_exp(rr,a1,p1,m,ctx)) goto end;
             ^
825.   	/* let t = a2 ^ p2 mod m */
826.   	if (!aep_mod_exp(&t,a2,p2,m,ctx)) goto end;

engines/e_aep.c:602:1: Parameter `ctx->stack.depth`
  600.   	}
  601.   
  602. > static int aep_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
  603.   	const BIGNUM *m, BN_CTX *ctx)
  604.   	{

engines/e_aep.c:826:7: Call
824.   	if (!aep_mod_exp(rr,a1,p1,m,ctx)) goto end;
825.   	/* let t = a2 ^ p2 mod m */
826.   	if (!aep_mod_exp(&t,a2,p2,m,ctx)) goto end;
             ^
827.   	/* let rr = rr * t mod m */
828.   	if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end;

engines/e_aep.c:602:1: Parameter `ctx->stack.depth`
  600.   	}
  601.   
  602. > static int aep_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
  603.   	const BIGNUM *m, BN_CTX *ctx)
  604.   	{

engines/e_aep.c:616:10: Call
  614.   	if (r_len > max_key_len){
  615.   		AEPHKerr(AEPHK_F_AEP_MOD_EXP, AEPHK_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
  616.   		return BN_mod_exp(r, a, p, m, ctx);
                  ^
  617.   	} 
  618.   

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 `aep_mod_exp` 
              353.   static unsigned int BN_STACK_pop(BN_STACK *st)
              354.   	{
              355.   	return st->indexes[--(st->depth)];
                             ^
              356.   	}
              357.   
