crypto/rsa/rsa_chk.c:144: error: INTEGER_OVERFLOW_L2
  (0 - [0, max(1, `key->e->top`)]):unsigned64 by call to `BN_mod_mul`.
Showing all 19 steps of the trace


crypto/rsa/rsa_chk.c:19:1: Parameter `key->e->top`
17.   }
18.   
19. > int RSA_check_key_ex(const RSA *key, BN_GENCB *cb)
20.   {
21.       BIGNUM *i, *j, *k, *l, *m;

crypto/rsa/rsa_chk.c:55:9: Call
53.       }
54.   
55.       if (BN_is_one(key->e)) {
              ^
56.           ret = 0;
57.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_BAD_E_VALUE);

crypto/bn/bn_lib.c:857:1: Parameter `a->top`
  855.   }
  856.   
  857. > int BN_is_one(const BIGNUM *a)
  858.   {
  859.       return BN_abs_is_word(a, 1) && !a->neg;

crypto/bn/bn_lib.c:859:12: Call
  857.   int BN_is_one(const BIGNUM *a)
  858.   {
  859.       return BN_abs_is_word(a, 1) && !a->neg;
                    ^
  860.   }
  861.   

crypto/bn/bn_lib.c:847:1: Parameter `a->top`
    845.   }
    846.   
    847. > int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w)
    848.   {
    849.       return ((a->top == 1) && (a->d[0] == w)) || ((w == 0) && (a->top == 0));

crypto/rsa/rsa_chk.c:59:10: Call
57.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_BAD_E_VALUE);
58.       }
59.       if (!BN_is_odd(key->e)) {
               ^
60.           ret = 0;
61.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_BAD_E_VALUE);

crypto/bn/bn_lib.c:867:1: Parameter `a->top`
  865.   }
  866.   
  867. > int BN_is_odd(const BIGNUM *a)
  868.   {
  869.       return (a->top > 0) && (a->d[0] & 1);

crypto/rsa/rsa_chk.c:144:10: Call
142.           goto err;
143.       }
144.       if (!BN_mod_mul(i, key->d, key->e, k, ctx)) {
                ^
145.           ret = -1;
146.           goto err;

crypto/bn/bn_mod.c:193:1: Parameter `b->top`
  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: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 `b->top`
    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 `b->top`
      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:525:5: Assignment
      523.   
      524.       al = a->top;
      525.       bl = b->top;
                 ^
      526.   
      527.       if ((al == 0) || (bl == 0)) {

crypto/bn/bn_mul.c:574:21: Call
      572.               }
      573.               if (i == -1) {
      574.                   j = BN_num_bits_word((BN_ULONG)bl);
                                 ^
      575.               }
      576.               j = 1 << (j - 1);

crypto/bn/bn_lib.c:90:1: <RHS trace>
88.   }
89.   
90. > int BN_num_bits_word(BN_ULONG l)
91.   {
92.       BN_ULONG x, mask;

crypto/bn/bn_lib.c:90:1: Parameter `l`
        88.   }
        89.   
        90. > int BN_num_bits_word(BN_ULONG l)
        91.   {
        92.       BN_ULONG x, mask;

crypto/bn/bn_lib.c:96:5: Assignment
        94.   
        95.   #if BN_BITS2 > 32
        96.       x = l >> 32;
                  ^
        97.       mask = (0 - x) & BN_MASK2;
        98.       mask = (0 - (mask >> (BN_BITS2 - 1)));

crypto/bn/bn_lib.c:97:5: Binary operation: (0 - [0, max(1, key->e->top)]):unsigned64 by call to `BN_mod_mul` 
        95.   #if BN_BITS2 > 32
        96.       x = l >> 32;
        97.       mask = (0 - x) & BN_MASK2;
                   ^
        98.       mask = (0 - (mask >> (BN_BITS2 - 1)));
        99.       bits += 32 & mask;
