Merge pull request #5032 from randombit/jack/clang-tidy-implicit-bool-conversion

Fix some readability-implict-bool-conversion warnings from clang-tidy

Author: randombit

src/fuzzer/tls_server.cpp

@@ -171,7 +171,7 @@ void fuzz(std::span<const uint8_t> in) {
    auto creds = std::make_shared<Fuzzer_TLS_Server_Creds>();
    auto callbacks = std::make_shared<Fuzzer_TLS_Server_Callbacks>();
 
-   const bool is_datagram = in[0] & 1;
+   const bool is_datagram = (in[0] & 1) == 1;
 
    Botan::TLS::Server server(callbacks, session_manager, creds, policy, fuzzer_rng_as_shared(), is_datagram);
 

src/lib/asn1/ber_dec.cpp

@@ -469,7 +469,9 @@ BER_Decoder& BER_Decoder::decode(BigInt& out, ASN1_Type type_tag, ASN1_Class cla
       if(negative) {
          secure_vector<uint8_t> vec(obj.bits(), obj.bits() + obj.length());
          for(size_t i = obj.length(); i > 0; --i) {
-            if(vec[i - 1]--) {
+            const bool gt0 = (vec[i - 1] > 0);
+            vec[i - 1] -= 1;
+            if(gt0) {
                break;
             }
          }

src/lib/filters/pipe.cpp

@@ -194,11 +194,11 @@ void Pipe::find_endpoints(Filter* f) {
 * Remove the SecureQueues attached to the Filter
 */
 void Pipe::clear_endpoints(Filter* f) {
-   if(!f) {
+   if(f == nullptr) {
       return;
    }
    for(size_t j = 0; j != f->total_ports(); ++j) {
-      if(f->m_next[j] && dynamic_cast<SecureQueue*>(f->m_next[j])) {
+      if(f->m_next[j] != nullptr && dynamic_cast<SecureQueue*>(f->m_next[j]) != nullptr) {
          f->m_next[j] = nullptr;
       }
       clear_endpoints(f->m_next[j]);
@@ -233,10 +233,10 @@ void Pipe::prepend_filter(Filter* filter) {
 * Append a Filter to the Pipe
 */
 void Pipe::do_append(Filter* filter) {
-   if(!filter) {
+   if(filter == nullptr) {
       return;
    }
-   if(dynamic_cast<SecureQueue*>(filter)) {
+   if(dynamic_cast<SecureQueue*>(filter) != nullptr) {
       throw Invalid_Argument("Pipe::append: SecureQueue cannot be used");
    }
    if(filter->m_owned) {
@@ -249,7 +249,7 @@ void Pipe::do_append(Filter* filter) {
 
    filter->m_owned = true;
 
-   if(!m_pipe) {
+   if(m_pipe == nullptr) {
       m_pipe = filter;
    } else {
       m_pipe->attach(filter);
@@ -263,10 +263,10 @@ void Pipe::do_prepend(Filter* filter) {
    if(m_inside_msg) {
       throw Invalid_State("Cannot prepend to a Pipe while it is processing");
    }
-   if(!filter) {
+   if(filter == nullptr) {
       return;
    }
-   if(dynamic_cast<SecureQueue*>(filter)) {
+   if(dynamic_cast<SecureQueue*>(filter) != nullptr) {
       throw Invalid_Argument("Pipe::prepend: SecureQueue cannot be used");
    }
    if(filter->m_owned) {
@@ -275,7 +275,7 @@ void Pipe::do_prepend(Filter* filter) {
 
    filter->m_owned = true;
 
-   if(m_pipe) {
+   if(m_pipe != nullptr) {
       filter->attach(m_pipe);
    }
    m_pipe = filter;
@@ -289,7 +289,7 @@ void Pipe::pop() {
       throw Invalid_State("Cannot pop off a Pipe while it is processing");
    }
 
-   if(!m_pipe) {
+   if(m_pipe == nullptr) {
       return;
    }
 

src/lib/math/numbertheory/numthry.cpp

@@ -224,7 +224,7 @@ BigInt gcd(const BigInt& a, const BigInt& b) {
       auto both_odd = CT::Mask<word>::expand_bool(u.is_odd()) & CT::Mask<word>::expand_bool(v.is_odd());
 
       // Subtract the smaller from the larger if both are odd
-      auto u_gt_v = CT::Mask<word>::expand(bigint_cmp(u._data(), u.size(), v._data(), v.size()) > 0);
+      auto u_gt_v = CT::Mask<word>::expand_bool(bigint_cmp(u._data(), u.size(), v._data(), v.size()) > 0);
       bigint_sub_abs(tmp.mutable_data(), u._data(), v._data(), sz, ws.data());
       u.ct_cond_assign((u_gt_v & both_odd).as_bool(), tmp);
       v.ct_cond_assign((~u_gt_v & both_odd).as_bool(), tmp);

src/lib/misc/roughtime/roughtime.cpp

@@ -193,7 +193,7 @@ Response Response::from_bits(const std::vector<uint8_t>& response, const Nonce&
    const size_t size = path.size();
    const size_t levels = size / 64;
 
-   if(size % 64) {
+   if(size % 64 != 0) {
       throw Roughtime_Error("Merkle tree path size must be multiple of 64 bytes");
    }
    if(indx >= (1U << levels)) {
@@ -204,7 +204,7 @@ Response Response::from_bits(const std::vector<uint8_t>& response, const Nonce&
    auto hash = hashLeaf(nonce.get_nonce());
    auto index = indx;
    for(std::size_t level = 0; level < levels; ++level) {
-      hashNode(hash, slicer.take<64>(), index & 1);
+      hashNode(hash, slicer.take<64>(), index % 2 == 1);
       index >>= 1;
    }
 
@@ -291,9 +291,9 @@ Chain::Chain(std::string_view str) {
 
 std::vector<Response> Chain::responses() const {
    std::vector<Response> responses;
-   for(unsigned i = 0; i < m_links.size(); ++i) {
+   for(size_t i = 0; i < m_links.size(); ++i) {
       const auto& l = m_links[i];
-      const auto nonce = i ? nonce_from_blind(m_links[i - 1].response(), l.nonce_or_blind()) : l.nonce_or_blind();
+      const auto nonce = i > 0 ? nonce_from_blind(m_links[i - 1].response(), l.nonce_or_blind()) : l.nonce_or_blind();
       const auto response = Response::from_bits(l.response(), nonce);
       if(!response.validate(l.public_key())) {
          throw Roughtime_Error("Invalid signature or public key");
@@ -365,7 +365,7 @@ std::vector<uint8_t> online_request(std::string_view uri, const Nonce& nonce, st
                                       //add one additional byte to be able to differentiate if datagram got truncated
    const auto n = socket->read(buffer.data(), buffer.size());
 
-   if(!n || std::chrono::system_clock::now() - start_time > timeout) {
+   if(n == 0 || std::chrono::system_clock::now() - start_time > timeout) {
       throw System_Error("Timeout waiting for response");
    }
 

src/lib/modes/aead/ccm/ccm.cpp

@@ -132,7 +132,9 @@ void CCM_Mode::encode_length(uint64_t len, uint8_t out[]) {
 
 void CCM_Mode::inc(secure_vector<uint8_t>& C) {
    for(size_t i = 0; i != C.size(); ++i) {
-      if(++C[C.size() - i - 1]) {
+      uint8_t& b = C[C.size() - i - 1];
+      b += 1;
+      if(b > 0) {
          break;
       }
    }

src/lib/pubkey/curve448/ed448/ed448_internal.cpp

@@ -205,8 +205,8 @@ Ed448Point Ed448Point::scalar_mul(const Scalar448& s) const {
 
 bool Ed448Point::operator==(const Ed448Point& other) const {
    // Note that the operator== of of Gf448Elem is constant time
-   const auto mask_x = CT::Mask<uint8_t>::expand(x() == other.x());
-   const auto mask_y = CT::Mask<uint8_t>::expand(y() == other.y());
+   const auto mask_x = CT::Mask<uint8_t>::expand_bool(x() == other.x());
+   const auto mask_y = CT::Mask<uint8_t>::expand_bool(y() == other.y());
 
    return (mask_x & mask_y).as_bool();
 }

src/lib/pubkey/dilithium/dilithium_common/dilithium_algos.cpp

@@ -861,7 +861,7 @@ DilithiumPolyVec make_hint(const DilithiumPolyVec& z, const DilithiumPolyVec& r,
 
    for(size_t i = 0; i < r.size(); ++i) {
       for(size_t j = 0; j < r[i].size(); ++j) {
-         hint[i][j] = make_hint(z[i][j], r[i][j]).as_bool();
+         hint[i][j] = static_cast<int>(make_hint(z[i][j], r[i][j]).as_bool());
       }
    }
 

src/lib/pubkey/ec_group/legacy_ec_point/ec_point.cpp

@@ -502,7 +502,7 @@ EC_Point EC_Point::mul(const BigInt& scalar) const {
    EC_Point R[2] = {this->zero(), *this};
 
    for(size_t i = scalar_bits; i > 0; i--) {
-      const size_t b = scalar.get_bit(i - 1);
+      const size_t b = scalar.get_bit(i - 1) ? 1 : 0;
       R[b ^ 1].add(R[b], ws);
       R[b].mult2(ws);
    }

src/lib/pubkey/ecies/ecies.cpp

@@ -117,7 +117,7 @@ PK_Key_Agreement create_key_agreement(const PK_Key_Agreement_Key& private_key,
       throw Invalid_Argument("ECIES: cofactor, old cofactor and check mode are only supported for ECDH_PrivateKey");
    }
 
-   if(ecdh_key && (for_encryption || !ecies_params.cofactor_mode())) {
+   if(ecdh_key != nullptr && (for_encryption || !ecies_params.cofactor_mode())) {
       // ECDH_KA_Operation uses cofactor mode: use own key agreement method if cofactor should not be used.
       return PK_Key_Agreement(ECIES_PrivateKey(*ecdh_key), rng, "Raw");
    }
@@ -427,7 +427,7 @@ secure_vector<uint8_t> ECIES_Decryptor::do_decrypt(uint8_t& valid_mask, const ui
    const secure_vector<uint8_t> calculated_mac = m_mac->final();
    valid_mask = CT::is_equal(mac_data.data(), calculated_mac.data(), mac_data.size()).value();
 
-   if(valid_mask) {
+   if(valid_mask == 0xFF) {
       // decrypt data
 
       m_cipher->set_key(SymmetricKey(secret_key.begin(), m_params.dem_keylen()));