Merge 9908ab0581 into 66aa6a47bd

src/crypto/chacha20.cpp

@@ -59,7 +59,7 @@ void ChaCha20Aligned::Seek(Nonce96 nonce, uint32_t block_counter) noexcept
 
 inline void ChaCha20Aligned::Keystream(Span<std::byte> output) noexcept
 {
-    unsigned char* c = UCharCast(output.data());
+    std::byte* c = output.data();
     size_t blocks = output.size() / BLOCKLEN;
     assert(blocks * BLOCKLEN == output.size());
 
@@ -161,8 +161,8 @@ inline void ChaCha20Aligned::Keystream(Span<std::byte> output) noexcept
 inline void ChaCha20Aligned::Crypt(Span<const std::byte> in_bytes, Span<std::byte> out_bytes) noexcept
 {
     assert(in_bytes.size() == out_bytes.size());
-    const unsigned char* m = UCharCast(in_bytes.data());
-    unsigned char* c = UCharCast(out_bytes.data());
+    const std::byte* m = in_bytes.data();
+    std::byte* c = out_bytes.data();
     size_t blocks = out_bytes.size() / BLOCKLEN;
     assert(blocks * BLOCKLEN == out_bytes.size());
 

src/crypto/chacha20poly1305.cpp

@@ -56,8 +56,8 @@ void ComputeTag(ChaCha20& chacha20, Span<const std::byte> aad, Span<const std::b
     poly1305.Update(cipher).Update(Span{PADDING}.first(cipher_padding_length));
     // - Process the AAD and plaintext length with Poly1305.
     std::byte length_desc[Poly1305::TAGLEN];
-    WriteLE64(UCharCast(length_desc), aad.size());
-    WriteLE64(UCharCast(length_desc + 8), cipher.size());
+    WriteLE64(length_desc, aad.size());
+    WriteLE64(length_desc + 8, cipher.size());
     poly1305.Update(length_desc);
 
     // Output tag.

src/crypto/common.h

@@ -13,96 +13,84 @@
 #include <cstring>
 
 template <typename B>
-concept ByteType = std::same_as<B, unsigned char> || std::same_as<B, std::byte>;
+concept ByteType = std::same_as<B, uint8_t> || std::same_as<B, std::byte>;
 
-template <ByteType B>
-inline uint16_t ReadLE16(const B* ptr)
+uint16_t ReadLE16(const ByteType auto* ptr) noexcept
 {
     uint16_t x;
-    memcpy(&x, ptr, 2);
+    std::memcpy(&x, ptr, sizeof(x));
     return le16toh_internal(x);
 }
 
-template <ByteType B>
-inline uint32_t ReadLE32(const B* ptr)
+uint32_t ReadLE32(const ByteType auto* ptr) noexcept
 {
     uint32_t x;
-    memcpy(&x, ptr, 4);
+    std::memcpy(&x, ptr, sizeof(x));
     return le32toh_internal(x);
 }
 
-template <ByteType B>
-inline uint64_t ReadLE64(const B* ptr)
+uint64_t ReadLE64(const ByteType auto* ptr) noexcept
 {
     uint64_t x;
-    memcpy(&x, ptr, 8);
+    std::memcpy(&x, ptr, sizeof(x));
     return le64toh_internal(x);
 }
 
-template <ByteType B>
-inline void WriteLE16(B* ptr, uint16_t x)
+void WriteLE16(ByteType auto* ptr, const uint16_t x) noexcept
 {
-    uint16_t v = htole16_internal(x);
-    memcpy(ptr, &v, 2);
+    const uint16_t v{htole16_internal(x)};
+    std::memcpy(ptr, &v, sizeof(v));
 }
 
-template <ByteType B>
-inline void WriteLE32(B* ptr, uint32_t x)
+void WriteLE32(ByteType auto* ptr, const uint32_t x) noexcept
 {
-    uint32_t v = htole32_internal(x);
-    memcpy(ptr, &v, 4);
+    const uint32_t v{htole32_internal(x)};
+    std::memcpy(ptr, &v, sizeof(v));
 }
 
-template <ByteType B>
-inline void WriteLE64(B* ptr, uint64_t x)
+void WriteLE64(ByteType auto* ptr, const uint64_t x) noexcept
 {
-    uint64_t v = htole64_internal(x);
-    memcpy(ptr, &v, 8);
+    const uint64_t v{htole64_internal(x)};
+    std::memcpy(ptr, &v, sizeof(v));
 }
 
-template <ByteType B>
-inline uint16_t ReadBE16(const B* ptr)
+uint16_t ReadBE16(const ByteType auto* ptr) noexcept
 {
     uint16_t x;
-    memcpy(&x, ptr, 2);
+    std::memcpy(&x, ptr, sizeof(x));
     return be16toh_internal(x);
 }
 
-template <ByteType B>
-inline uint32_t ReadBE32(const B* ptr)
+uint32_t ReadBE32(const ByteType auto* ptr) noexcept
 {
     uint32_t x;
-    memcpy(&x, ptr, 4);
+    std::memcpy(&x, ptr, sizeof(x));
     return be32toh_internal(x);
 }
 
-template <ByteType B>
-inline uint64_t ReadBE64(const B* ptr)
+uint64_t ReadBE64(const ByteType auto* ptr) noexcept
 {
     uint64_t x;
-    memcpy(&x, ptr, 8);
+    std::memcpy(&x, ptr, sizeof(x));
     return be64toh_internal(x);
 }
 
-template <ByteType B>
-inline void WriteBE16(B* ptr, uint16_t x)
+void WriteBE16(ByteType auto* ptr, const uint16_t x) noexcept
 {
-    uint16_t v = htobe16_internal(x);
-    memcpy(ptr, &v, 2);
+    const uint16_t v{htobe16_internal(x)};
+    std::memcpy(ptr, &v, sizeof(v));
 }
 
-template <ByteType B>
-inline void WriteBE32(B* ptr, uint32_t x)
+void WriteBE32(ByteType auto* ptr, const uint32_t x) noexcept
 {
-    uint32_t v = htobe32_internal(x);
-    memcpy(ptr, &v, 4);
+    const uint32_t v{htobe32_internal(x)};
+    std::memcpy(ptr, &v, sizeof(v));
 }
 
-template <ByteType B>
-inline void WriteBE64(B* ptr, uint64_t x)
+void WriteBE64(ByteType auto* ptr, const uint64_t x) noexcept
 {
-    uint64_t v = htobe64_internal(x);
-    memcpy(ptr, &v, 8);
+    const uint64_t v{htobe64_internal(x)};
+    std::memcpy(ptr, &v, sizeof(v));
 }
 
 #endif // BITCOIN_CRYPTO_COMMON_H

src/random.h

@@ -268,12 +268,12 @@ public:
     {
         while (span.size() >= 8) {
             uint64_t gen = Impl().rand64();
-            WriteLE64(UCharCast(span.data()), gen);
+            WriteLE64(span.data(), gen);
             span = span.subspan(8);
         }
         if (span.size() >= 4) {
             uint32_t gen = Impl().rand32();
-            WriteLE32(UCharCast(span.data()), gen);
+            WriteLE32(span.data(), gen);
             span = span.subspan(4);
         }
         while (span.size()) {
@@ -397,7 +397,7 @@ public:
         if (requires_seed) RandomSeed();
         std::array<std::byte, 8> buf;
         rng.Keystream(buf);
-        return ReadLE64(UCharCast(buf.data()));
+        return ReadLE64(buf.data());
     }
 
     /** Fill a byte Span with random bytes. This overrides the RandomMixin version. */

src/wallet/migrate.cpp

@@ -603,7 +603,7 @@ void BerkeleyRODatabase::Open()
 
     // Read subdatabase page number
     // It is written as a big endian 32 bit number
-    uint32_t main_db_page = ReadBE32(UCharCast(std::get<DataRecord>(page.records.at(1)).data.data()));
+    uint32_t main_db_page = ReadBE32(std::get<DataRecord>(page.records.at(1)).data.data());
 
     // The main database is in a page that doesn't exist
     if (main_db_page > outer_meta.last_page) {