crypto/rsa/rsa_sp800_56b_check.c:179: error: INTEGER_OVERFLOW_L2
  ([0, 6+max(0, `ctx->stack.depth`)] - 1):unsigned32 by call to `BN_mod_mul`.
Showing all 37 steps of the trace


crypto/rsa/rsa_sp800_56b_check.c:157:1: Parameter `ctx->stack.depth`
155.    *     (Step 6b) 1 = (d*e) mod LCM(p–1, q–1)
156.    */
157. > int rsa_check_private_exponent(const RSA *rsa, int nbits, BN_CTX *ctx)
158.   {
159.       int ret;

crypto/rsa/rsa_sp800_56b_check.c:166:5: Call
164.           return 0;
165.   
166.       BN_CTX_start(ctx);
           ^
167.       r = BN_CTX_get(ctx);
168.       p1 = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
  169.   }
  170.   
  171. > void BN_CTX_start(BN_CTX *ctx)
  172.   {
  173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/rsa/rsa_sp800_56b_check.c:167:9: Call
165.   
166.       BN_CTX_start(ctx);
167.       r = BN_CTX_get(ctx);
               ^
168.       p1 = BN_CTX_get(ctx);
169.       q1 = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/rsa/rsa_sp800_56b_check.c:168:10: Call
166.       BN_CTX_start(ctx);
167.       r = BN_CTX_get(ctx);
168.       p1 = BN_CTX_get(ctx);
                ^
169.       q1 = BN_CTX_get(ctx);
170.       lcm = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/rsa/rsa_sp800_56b_check.c:169:10: Call
167.       r = BN_CTX_get(ctx);
168.       p1 = BN_CTX_get(ctx);
169.       q1 = BN_CTX_get(ctx);
                ^
170.       lcm = BN_CTX_get(ctx);
171.       p1q1 = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/rsa/rsa_sp800_56b_check.c:170:11: Call
168.       p1 = BN_CTX_get(ctx);
169.       q1 = BN_CTX_get(ctx);
170.       lcm = BN_CTX_get(ctx);
                 ^
171.       p1q1 = BN_CTX_get(ctx);
172.       gcd = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/rsa/rsa_sp800_56b_check.c:171:12: Call
169.       q1 = BN_CTX_get(ctx);
170.       lcm = BN_CTX_get(ctx);
171.       p1q1 = BN_CTX_get(ctx);
                  ^
172.       gcd = BN_CTX_get(ctx);
173.       ret = (gcd != NULL

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/rsa/rsa_sp800_56b_check.c:172:11: Call
170.       lcm = BN_CTX_get(ctx);
171.       p1q1 = BN_CTX_get(ctx);
172.       gcd = BN_CTX_get(ctx);
                 ^
173.       ret = (gcd != NULL
174.             /* LCM(p - 1, q - 1) */

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
  200.   }
  201.   
  202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
  203.   {
  204.       BIGNUM *ret;

crypto/rsa/rsa_sp800_56b_check.c:175:15: Call
173.       ret = (gcd != NULL
174.             /* LCM(p - 1, q - 1) */
175.             && (rsa_get_lcm(ctx, rsa->p, rsa->q, lcm, gcd, p1, q1, p1q1) == 1)
                     ^
176.             /* (Step 6a) d < LCM(p - 1, q - 1) */
177.             && (BN_cmp(rsa->d, lcm) < 0)

crypto/rsa/rsa_sp800_56b_check.c:220:1: Parameter `ctx->stack.depth`
  218.   
  219.   /* return LCM(p-1, q-1) */
  220. > int rsa_get_lcm(BN_CTX *ctx, const BIGNUM *p, const BIGNUM *q,
  221.                   BIGNUM *lcm, BIGNUM *gcd, BIGNUM *p1, BIGNUM *q1,
  222.                   BIGNUM *p1q1)

crypto/rsa/rsa_sp800_56b_check.c:179:14: Call
177.             && (BN_cmp(rsa->d, lcm) < 0)
178.             /* (Step 6b) 1 = (e . d) mod LCM(p - 1, q - 1) */
179.             && BN_mod_mul(r, rsa->e, rsa->d, lcm, ctx)
                    ^
180.             && BN_is_one(r));
181.   

crypto/bn/bn_mod.c:193:1: Parameter `ctx->stack.depth`
  191.   
  192.   /* slow but works */
  193. > int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
  194.                  BN_CTX *ctx)
  195.   {

crypto/bn/bn_mod.c:203:5: Call
  201.       bn_check_top(m);
  202.   
  203.       BN_CTX_start(ctx);
             ^
  204.       if ((t = BN_CTX_get(ctx)) == NULL)
  205.           goto err;

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
    169.   }
    170.   
    171. > void BN_CTX_start(BN_CTX *ctx)
    172.   {
    173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mod.c:204:14: Call
  202.   
  203.       BN_CTX_start(ctx);
  204.       if ((t = BN_CTX_get(ctx)) == NULL)
                      ^
  205.           goto err;
  206.       if (a == b) {

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
    200.   }
    201.   
    202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
    203.   {
    204.       BIGNUM *ret;

crypto/bn/bn_mod.c:207:14: Call
  205.           goto err;
  206.       if (a == b) {
  207.           if (!BN_sqr(t, a, ctx))
                      ^
  208.               goto err;
  209.       } else {

crypto/bn/bn_sqr.c:17:1: Parameter `ctx->stack.depth`
    15.    * I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96
    16.    */
    17. > int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
    18.   {
    19.       int ret = bn_sqr_fixed_top(r, a, ctx);

crypto/bn/bn_sqr.c:19:15: Call
    17.   int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
    18.   {
    19.       int ret = bn_sqr_fixed_top(r, a, ctx);
                        ^
    20.   
    21.       bn_correct_top(r);

crypto/bn/bn_sqr.c:27:1: Parameter `ctx->stack.depth`
      25.   }
      26.   
      27. > int bn_sqr_fixed_top(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx)
      28.   {
      29.       int max, al;

crypto/bn/bn_sqr.c:42:5: Call
      40.       }
      41.   
      42.       BN_CTX_start(ctx);
                ^
      43.       rr = (a != r) ? r : BN_CTX_get(ctx);
      44.       tmp = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:171:1: Parameter `ctx->stack.depth`
        169.   }
        170.   
        171. > void BN_CTX_start(BN_CTX *ctx)
        172.   {
        173.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_sqr.c:44:11: Call
      42.       BN_CTX_start(ctx);
      43.       rr = (a != r) ? r : BN_CTX_get(ctx);
      44.       tmp = BN_CTX_get(ctx);
                      ^
      45.       if (rr == NULL || tmp == NULL)
      46.           goto err;

crypto/bn/bn_ctx.c:202:1: Parameter `ctx->stack.depth`
        200.   }
        201.   
        202. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        203.   {
        204.       BIGNUM *ret;

crypto/bn/bn_sqr.c:104:5: Call
      102.       bn_check_top(rr);
      103.       bn_check_top(tmp);
      104.       BN_CTX_end(ctx);
                 ^
      105.       return ret;
      106.   }

crypto/bn/bn_ctx.c:185:1: Parameter `ctx->stack.depth`
        183.   }
        184.   
        185. > void BN_CTX_end(BN_CTX *ctx)
        186.   {
        187.       CTXDBG("ENTER BN_CTX_end()", ctx);

crypto/bn/bn_ctx.c:191:27: Call
        189.           ctx->err_stack--;
        190.       else {
        191.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                         ^
        192.           /* Does this stack frame have anything to release? */
        193.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:266:1: <LHS trace>
264.   }
265.   
266. > static unsigned int BN_STACK_pop(BN_STACK *st)
267.   {
268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:266:1: Parameter `st->depth`
          264.   }
          265.   
          266. > static unsigned int BN_STACK_pop(BN_STACK *st)
          267.   {
          268.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:268:12: Binary operation: ([0, 6+max(0, ctx->stack.depth)] - 1):unsigned32 by call to `BN_mod_mul` 
          266.   static unsigned int BN_STACK_pop(BN_STACK *st)
          267.   {
          268.       return st->indexes[--(st->depth)];
                            ^
          269.   }
          270.   
