crypto/rsa/rsa_chk.c:155: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_mod_mul`.
Showing all 40 steps of the trace


crypto/rsa/rsa_chk.c:76:9: Call
74.   
75.       /* p prime? */
76.       if (BN_is_prime_ex(key->p, BN_prime_checks, NULL, cb) != 1) {
              ^
77.           ret = 0;
78.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_P_NOT_PRIME);

crypto/bn/bn_prime.c:196:1: Parameter `ctx_passed->stack.depth`
  194.   #endif
  195.   
  196. > int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed,
  197.                      BN_GENCB *cb)
  198.   {

crypto/bn/bn_prime.c:199:12: Call
  197.                      BN_GENCB *cb)
  198.   {
  199.       return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);
                    ^
  200.   }
  201.   

crypto/bn/bn_prime.c:203:1: Parameter `ctx->stack.depth`
    201.   
    202.   /* See FIPS 186-4 C.3.1 Miller Rabin Probabilistic Primality Test. */
    203. > int BN_is_prime_fasttest_ex(const BIGNUM *w, int checks, BN_CTX *ctx,
    204.                               int do_trial_division, BN_GENCB *cb)
    205.   {

crypto/rsa/rsa_chk.c:82:9: Call
80.   
81.       /* q prime? */
82.       if (BN_is_prime_ex(key->q, BN_prime_checks, NULL, cb) != 1) {
              ^
83.           ret = 0;
84.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_Q_NOT_PRIME);

crypto/bn/bn_prime.c:196:1: Parameter `ctx_passed->stack.depth`
  194.   #endif
  195.   
  196. > int BN_is_prime_ex(const BIGNUM *a, int checks, BN_CTX *ctx_passed,
  197.                      BN_GENCB *cb)
  198.   {

crypto/bn/bn_prime.c:199:12: Call
  197.                      BN_GENCB *cb)
  198.   {
  199.       return BN_is_prime_fasttest_ex(a, checks, ctx_passed, 0, cb);
                    ^
  200.   }
  201.   

crypto/bn/bn_prime.c:203:1: Parameter `ctx->stack.depth`
    201.   
    202.   /* See FIPS 186-4 C.3.1 Miller Rabin Probabilistic Primality Test. */
    203. > int BN_is_prime_fasttest_ex(const BIGNUM *w, int checks, BN_CTX *ctx,
    204.                               int do_trial_division, BN_GENCB *cb)
    205.   {

crypto/rsa/rsa_chk.c:97:10: Call
95.   
96.       /* n = p*q * r_3...r_i? */
97.       if (!BN_mul(i, key->p, key->q, ctx)) {
                ^
98.           ret = -1;
99.           goto err;

crypto/bn/bn_mul.c:497:1: Parameter `ctx->stack.depth`
  495.   #endif                          /* BN_RECURSION */
  496.   
  497. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  498.   {
  499.       int ret = bn_mul_fixed_top(r, a, b, ctx);

crypto/bn/bn_mul.c:499:15: Call
  497.   int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  498.   {
  499.       int ret = bn_mul_fixed_top(r, a, b, ctx);
                       ^
  500.   
  501.       bn_correct_top(r);

crypto/bn/bn_mul.c:507:1: Parameter `ctx->stack.depth`
    505.   }
    506.   
    507. > int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    508.   {
    509.       int ret = 0;

crypto/rsa/rsa_chk.c:128:10: Call
126.   
127.       /* now compute k = \lambda(n) = LCM(i, j, r_3 - 1...) */
128.       if (!BN_mul(l, i, j, ctx)) {
                ^
129.           ret = -1;
130.           goto err;

crypto/bn/bn_mul.c:497:1: Parameter `ctx->stack.depth`
  495.   #endif                          /* BN_RECURSION */
  496.   
  497. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  498.   {
  499.       int ret = bn_mul_fixed_top(r, a, b, ctx);

crypto/bn/bn_mul.c:499:15: Call
  497.   int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  498.   {
  499.       int ret = bn_mul_fixed_top(r, a, b, ctx);
                       ^
  500.   
  501.       bn_correct_top(r);

crypto/bn/bn_mul.c:507:1: Parameter `ctx->stack.depth`
    505.   }
    506.   
    507. > int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    508.   {
    509.       int ret = 0;

crypto/rsa/rsa_chk.c:132:10: Call
130.           goto err;
131.       }
132.       if (!BN_gcd(m, i, j, ctx)) {
                ^
133.           ret = -1;
134.           goto err;

crypto/bn/bn_gcd.c:15:1: Parameter `ctx->stack.depth`
  13.   static BIGNUM *euclid(BIGNUM *a, BIGNUM *b);
  14.   
  15. > int BN_gcd(BIGNUM *r, const BIGNUM *in_a, const BIGNUM *in_b, BN_CTX *ctx)
  16.   {
  17.       BIGNUM *a, *b, *t;

crypto/bn/bn_gcd.c:23:5: Call
  21.       bn_check_top(in_b);
  22.   
  23.       BN_CTX_start(ctx);
            ^
  24.       a = BN_CTX_get(ctx);
  25.       b = BN_CTX_get(ctx);

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
    192.   }
    193.   
    194. > void BN_CTX_start(BN_CTX *ctx)
    195.   {
    196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_gcd.c:49:5: Call
  47.       ret = 1;
  48.    err:
  49.       BN_CTX_end(ctx);
            ^
  50.       bn_check_top(r);
  51.       return ret;

crypto/bn/bn_ctx.c:208:1: Parameter `ctx->stack.depth`
    206.   }
    207.   
    208. > void BN_CTX_end(BN_CTX *ctx)
    209.   {
    210.       if (ctx == NULL)

crypto/rsa/rsa_chk.c:151:10: Call
149.           }
150.       }
151.       if (!BN_div(k, NULL, l, m, ctx)) { /* remainder is 0 */
                ^
152.           ret = -1;
153.           goto err;

crypto/bn/bn_div.c:209:1: Parameter `ctx->stack.depth`
  207.    * If 'dv' or 'rm' is NULL, the respective value is not returned.
  208.    */
  209. > int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
  210.              BN_CTX *ctx)
  211.   {

crypto/rsa/rsa_chk.c:155:10: Call
153.           goto err;
154.       }
155.       if (!BN_mod_mul(i, key->d, key->e, k, ctx)) {
                ^
156.           ret = -1;
157.           goto err;

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:194:1: Parameter `ctx->stack.depth`
    192.   }
    193.   
    194. > void BN_CTX_start(BN_CTX *ctx)
    195.   {
    196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mod.c:210:14: Call
  208.               goto err;
  209.       } else {
  210.           if (!BN_mul(t, a, b, ctx))
                      ^
  211.               goto err;
  212.       }

crypto/bn/bn_mul.c:497:1: Parameter `ctx->stack.depth`
    495.   #endif                          /* BN_RECURSION */
    496.   
    497. > int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    498.   {
    499.       int ret = bn_mul_fixed_top(r, a, b, ctx);

crypto/bn/bn_mul.c:499:15: Call
    497.   int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
    498.   {
    499.       int ret = bn_mul_fixed_top(r, a, b, ctx);
                         ^
    500.   
    501.       bn_correct_top(r);

crypto/bn/bn_mul.c:507:1: Parameter `ctx->stack.depth`
      505.   }
      506.   
      507. > int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
      508.   {
      509.       int ret = 0;

crypto/bn/bn_mul.c:533:5: Call
      531.       top = al + bl;
      532.   
      533.       BN_CTX_start(ctx);
                 ^
      534.       if ((r == a) || (r == b)) {
      535.           if ((rr = BN_CTX_get(ctx)) == NULL)

crypto/bn/bn_ctx.c:194:1: Parameter `ctx->stack.depth`
        192.   }
        193.   
        194. > void BN_CTX_start(BN_CTX *ctx)
        195.   {
        196.       CTXDBG("ENTER BN_CTX_start()", ctx);

crypto/bn/bn_mul.c:618:5: Call
      616.    err:
      617.       bn_check_top(r);
      618.       BN_CTX_end(ctx);
                 ^
      619.       return ret;
      620.   }

crypto/bn/bn_ctx.c:208:1: Parameter `ctx->stack.depth`
        206.   }
        207.   
        208. > void BN_CTX_end(BN_CTX *ctx)
        209.   {
        210.       if (ctx == NULL)

crypto/bn/bn_ctx.c:216:27: Call
        214.           ctx->err_stack--;
        215.       else {
        216.           unsigned int fp = BN_STACK_pop(&ctx->stack);
                                         ^
        217.           /* Does this stack frame have anything to release? */
        218.           if (fp < ctx->used)

crypto/bn/bn_ctx.c:298:1: <LHS trace>
296.   }
297.   
298. > static unsigned int BN_STACK_pop(BN_STACK *st)
299.   {
300.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:298:1: Parameter `st->depth`
          296.   }
          297.   
          298. > static unsigned int BN_STACK_pop(BN_STACK *st)
          299.   {
          300.       return st->indexes[--(st->depth)];

crypto/bn/bn_ctx.c:300:12: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_mod_mul` 
          298.   static unsigned int BN_STACK_pop(BN_STACK *st)
          299.   {
          300.       return st->indexes[--(st->depth)];
                            ^
          301.   }
          302.   
