crypto/bn/bn_exp.c:687: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_mul_montgomery`.
Showing all 23 steps of the trace


crypto/bn/bn_exp.c:585:1: Parameter `ctx->stack.depth`
583.    * http://www.daemonology.net/hyperthreading-considered-harmful/)
584.    */
585. > int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
586.   		    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
587.   	{

crypto/bn/bn_exp.c:618:2: Call
616.   
617.    	/* Initialize BIGNUM context and allocate intermediate result */
618.   	BN_CTX_start(ctx);
        ^
619.   	r = BN_CTX_get(ctx);
620.   	if (r == NULL) goto err;

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:676:8: Call
674.   	 * once each for a^0 and intermediate result.
675.   	 */
676.    	if (!BN_to_montgomery(r,BN_value_one(),mont,ctx)) goto err;
              ^
677.   
678.   	/* Initialize computeTemp as a^1 with montgomery precalcs */

crypto/bn/bn_mont.c:131:1: Parameter `ctx->stack.depth`
  129.   #endif
  130.   
  131. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
  132.   			  BN_MONT_CTX *mont, BN_CTX *ctx)
  133.   	{

crypto/bn/bn_mont.c:152:2: Call
  150.   #endif
  151.   
  152.   	BN_CTX_start(ctx);
          ^
  153.   	tmp = BN_CTX_get(ctx);
  154.   	if (tmp == NULL) goto err;

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_mont.c:174:2: Call
  172.   	ret=1;
  173.   err:
  174.   	BN_CTX_end(ctx);
          ^
  175.   	return(ret);
  176.   	}

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_exp.c:687:12: Call
685.   		if (!BN_to_montgomery(am,am,mont,ctx))	goto err;
686.   		}
687.   	else	if (!BN_to_montgomery(am,a,mont,ctx))	goto err;
                  ^
688.   
689.   	if (!BN_copy(&computeTemp, am)) goto err;

crypto/bn/bn_mont.c:131:1: Parameter `ctx->stack.depth`
  129.   #endif
  130.   
  131. > int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
  132.   			  BN_MONT_CTX *mont, BN_CTX *ctx)
  133.   	{

crypto/bn/bn_mont.c:152:2: Call
  150.   #endif
  151.   
  152.   	BN_CTX_start(ctx);
          ^
  153.   	tmp = BN_CTX_get(ctx);
  154.   	if (tmp == NULL) goto err;

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_mont.c:163:8: Call
  161.   	else
  162.   		{
  163.   		if (!BN_mul(tmp,a,b,ctx)) goto err;
                ^
  164.   		}
  165.   	/* reduce from aRR to aR */

crypto/bn/bn_mul.c:943:1: Parameter `ctx->stack.depth`
    941.   #endif /* BN_RECURSION */
    942.   
    943. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    944.   	{
    945.   	int ret=0;

crypto/bn/bn_mul.c:974:2: Call
    972.   	top=al+bl;
    973.   
    974.   	BN_CTX_start(ctx);
            ^
    975.   	if ((r == a) || (r == b))
    976.   		{

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_mul.c:1100:2: Call
    1098.   err:
    1099.   	bn_check_top(r);
    1100.   	BN_CTX_end(ctx);
             ^
    1101.   	return(ret);
    1102.   	}

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