crypto/rsa/rsa_chk.c:157: 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:25:1: Parameter `key->e->top`
23.    *      rsa_sp800_56b_check_keypair.
24.    */
25. > int RSA_check_key_ex(const RSA *key, BN_GENCB *cb)
26.   {
27.   #ifdef FIPS_MODE

crypto/rsa/rsa_chk.c:68:9: Call
66.       }
67.   
68.       if (BN_is_one(key->e)) {
              ^
69.           ret = 0;
70.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_BAD_E_VALUE);

crypto/bn/bn_lib.c:869:1: Parameter `a->top`
  867.   }
  868.   
  869. > int BN_is_one(const BIGNUM *a)
  870.   {
  871.       return BN_abs_is_word(a, 1) && !a->neg;

crypto/bn/bn_lib.c:871:12: Call
  869.   int BN_is_one(const BIGNUM *a)
  870.   {
  871.       return BN_abs_is_word(a, 1) && !a->neg;
                    ^
  872.   }
  873.   

crypto/bn/bn_lib.c:859:1: Parameter `a->top`
    857.   }
    858.   
    859. > int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w)
    860.   {
    861.       return ((a->top == 1) && (a->d[0] == w)) || ((w == 0) && (a->top == 0));

crypto/rsa/rsa_chk.c:72:10: Call
70.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_BAD_E_VALUE);
71.       }
72.       if (!BN_is_odd(key->e)) {
               ^
73.           ret = 0;
74.           RSAerr(RSA_F_RSA_CHECK_KEY_EX, RSA_R_BAD_E_VALUE);

crypto/bn/bn_lib.c:879:1: Parameter `a->top`
  877.   }
  878.   
  879. > int BN_is_odd(const BIGNUM *a)
  880.   {
  881.       return (a->top > 0) && (a->d[0] & 1);

crypto/rsa/rsa_chk.c:157:10: Call
155.           goto err;
156.       }
157.       if (!BN_mod_mul(i, key->d, key->e, k, ctx)) {
                ^
158.           ret = -1;
159.           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;
