aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--configure.ac30
-rw-r--r--doc/design/assumeutxo.md4
-rw-r--r--doc/developer-notes.md7
-rw-r--r--doc/fuzzing.md7
-rw-r--r--src/Makefile.am12
-rw-r--r--src/compat/byteswap.h66
-rw-r--r--src/compat/endian.h241
-rw-r--r--src/crypto/common.h53
-rw-r--r--src/crypto/sha256.cpp8
-rw-r--r--src/i2p.cpp2
-rw-r--r--src/random.h3
-rw-r--r--src/serialize.h28
-rw-r--r--src/test/bswap_tests.cpp6
-rw-r--r--src/test/crypto_tests.cpp22
-rw-r--r--src/test/fuzz/integer.cpp1
-rw-r--r--src/test/fuzz/net.cpp37
-rw-r--r--src/test/validation_tests.cpp1
-rw-r--r--src/util/asmap.cpp6
-rw-r--r--test/functional/test_framework/crypto/bip324_cipher.py8
19 files changed, 167 insertions, 375 deletions
diff --git a/configure.ac b/configure.ac
index 078d968b0c..4f71515873 100644
--- a/configure.ac
+++ b/configure.ac
@@ -249,16 +249,6 @@ AC_ARG_ENABLE([threadlocal],
[use_thread_local=$enableval],
[use_thread_local=auto])
-AC_ARG_ENABLE([asm],
- [AS_HELP_STRING([--disable-asm],
- [disable assembly routines (enabled by default)])],
- [use_asm=$enableval],
- [use_asm=yes])
-
-if test "$use_asm" = "yes"; then
- AC_DEFINE([USE_ASM], [1], [Define this symbol to build in assembly routines])
-fi
-
AC_ARG_ENABLE([zmq],
[AS_HELP_STRING([--disable-zmq],
[disable ZMQ notifications])],
@@ -460,8 +450,6 @@ enable_sse41=no
enable_avx2=no
enable_x86_shani=no
-if test "$use_asm" = "yes"; then
-
dnl Check for optional instruction set support. Enabling these does _not_ imply that all code will
dnl be compiled with them, rather that specific objects/libs may use them after checking for runtime
dnl compatibility.
@@ -600,8 +588,6 @@ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
)
CXXFLAGS="$TEMP_CXXFLAGS"
-fi
-
CORE_CPPFLAGS="$CORE_CPPFLAGS -DHAVE_BUILD_INFO"
AC_ARG_WITH([utils],
@@ -972,7 +958,7 @@ if test "$TARGET_OS" = "darwin"; then
AX_CHECK_LINK_FLAG([-Wl,-fixup_chains], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-fixup_chains"], [], [$LDFLAG_WERROR])
fi
-AC_CHECK_HEADERS([endian.h sys/endian.h byteswap.h sys/select.h sys/prctl.h sys/sysctl.h vm/vm_param.h sys/vmmeter.h sys/resources.h])
+AC_CHECK_HEADERS([sys/select.h sys/prctl.h sys/sysctl.h vm/vm_param.h sys/vmmeter.h sys/resources.h])
AC_CHECK_DECLS([getifaddrs, freeifaddrs],[CHECK_SOCKET],,
[#include <sys/types.h>
@@ -987,18 +973,6 @@ AC_CHECK_DECLS([pipe2])
AC_CHECK_FUNCS([timingsafe_bcmp])
-AC_CHECK_DECLS([le16toh, le32toh, le64toh, htole16, htole32, htole64, be16toh, be32toh, be64toh, htobe16, htobe32, htobe64],,,
- [#if HAVE_ENDIAN_H
- #include <endian.h>
- #elif HAVE_SYS_ENDIAN_H
- #include <sys/endian.h>
- #endif])
-
-AC_CHECK_DECLS([bswap_16, bswap_32, bswap_64],,,
- [#if HAVE_BYTESWAP_H
- #include <byteswap.h>
- #endif])
-
AC_MSG_CHECKING([for __builtin_clzl])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
(void) __builtin_clzl(0);
@@ -1817,7 +1791,6 @@ AM_CONDITIONAL([ENABLE_AVX2], [test "$enable_avx2" = "yes"])
AM_CONDITIONAL([ENABLE_X86_SHANI], [test "$enable_x86_shani" = "yes"])
AM_CONDITIONAL([ENABLE_ARM_CRC], [test "$enable_arm_crc" = "yes"])
AM_CONDITIONAL([ENABLE_ARM_SHANI], [test "$enable_arm_shani" = "yes"])
-AM_CONDITIONAL([USE_ASM], [test "$use_asm" = "yes"])
AM_CONDITIONAL([WORDS_BIGENDIAN], [test "$ac_cv_c_bigendian" = "yes"])
AM_CONDITIONAL([USE_NATPMP], [test "$use_natpmp" = "yes"])
AM_CONDITIONAL([USE_UPNP], [test "$use_upnp" = "yes"])
@@ -1972,7 +1945,6 @@ echo " with fuzz binary = $enable_fuzz_binary"
echo " with bench = $use_bench"
echo " with upnp = $use_upnp"
echo " with natpmp = $use_natpmp"
-echo " use asm = $use_asm"
echo " USDT tracing = $use_usdt"
echo " sanitizers = $use_sanitizers"
echo " debug enabled = $enable_debug"
diff --git a/doc/design/assumeutxo.md b/doc/design/assumeutxo.md
index 66962a629d..abb623fc69 100644
--- a/doc/design/assumeutxo.md
+++ b/doc/design/assumeutxo.md
@@ -21,7 +21,7 @@ minimum and uses at least 1100 MiB.
As the background sync continues there will be temporarily two chainstate
directories, each multiple gigabytes in size (likely growing larger than the
-the downloaded snapshot).
+downloaded snapshot).
### Indexes
@@ -145,7 +145,7 @@ sequentially.
Once the tip of the background chainstate hits the base block of the snapshot
chainstate, we stop use of the background chainstate by setting `m_disabled`, in
-`CompleteSnapshotValidation()`, which is checked in `ActivateBestChain()`). We hash the
+`MaybeCompleteSnapshotValidation()`, which is checked in `ActivateBestChain()`). We hash the
background chainstate's UTXO set contents and ensure it matches the compiled value in
`CMainParams::m_assumeutxo_data`.
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index 8c3845c66c..13b9016d40 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -577,13 +577,6 @@ export UBSAN_OPTIONS="suppressions=$(pwd)/test/sanitizer_suppressions/ubsan:prin
See the CI config for more examples, and upstream documentation for more information
about any additional options.
-There are a number of known problems when using the `address` sanitizer. The
-address sanitizer is known to fail in
-[sha256_sse4::Transform](/src/crypto/sha256_sse4.cpp) which makes it unusable
-unless you also use `--disable-asm` when running configure. We would like to fix
-sanitizer issues, so please send pull requests if you can fix any errors found
-by the address sanitizer (or any other sanitizer).
-
Not all sanitizer options can be enabled at the same time, e.g. trying to build
with `--with-sanitizers=address,thread` will fail in the configure script as
these sanitizers are mutually incompatible. Refer to your compiler manual to
diff --git a/doc/fuzzing.md b/doc/fuzzing.md
index a4b0198dd9..c9fb918c8f 100644
--- a/doc/fuzzing.md
+++ b/doc/fuzzing.md
@@ -127,11 +127,6 @@ The default Clang/LLVM version supplied by Apple on macOS does not include
fuzzing libraries, so macOS users will need to install a full version, for
example using `brew install llvm`.
-Should you run into problems with the address sanitizer, it is possible you
-may need to run `./configure` with `--disable-asm` to avoid errors
-with certain assembly code from Bitcoin Core's code. See [developer notes on sanitizers](https://github.com/bitcoin/bitcoin/blob/master/doc/developer-notes.md#sanitizers)
-for more information.
-
You may also need to take care of giving the correct path for `clang` and
`clang++`, like `CC=/path/to/clang CXX=/path/to/clang++` if the non-systems
`clang` does not come first in your path.
@@ -139,7 +134,7 @@ You may also need to take care of giving the correct path for `clang` and
Full configure that was tested on macOS with `brew` installed `llvm`:
```sh
-./configure --enable-fuzz --with-sanitizers=fuzzer,address,undefined --disable-asm CC=$(brew --prefix llvm)/bin/clang CXX=$(brew --prefix llvm)/bin/clang++
+./configure --enable-fuzz --with-sanitizers=fuzzer,address,undefined CC=$(brew --prefix llvm)/bin/clang CXX=$(brew --prefix llvm)/bin/clang++
```
Read the [libFuzzer documentation](https://llvm.org/docs/LibFuzzer.html) for more information. This [libFuzzer tutorial](https://github.com/google/fuzzing/blob/master/tutorial/libFuzzerTutorial.md) might also be of interest.
diff --git a/src/Makefile.am b/src/Makefile.am
index 3e8870c828..b5d5c4652a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -50,10 +50,6 @@ LIBBITCOIN_WALLET_TOOL=libbitcoin_wallet_tool.a
endif
LIBBITCOIN_CRYPTO = $(LIBBITCOIN_CRYPTO_BASE)
-if USE_ASM
-LIBBITCOIN_CRYPTO_SSE4 = crypto/libbitcoin_crypto_sse4.la
-LIBBITCOIN_CRYPTO += $(LIBBITCOIN_CRYPTO_SSE4)
-endif
if ENABLE_SSE41
LIBBITCOIN_CRYPTO_SSE41 = crypto/libbitcoin_crypto_sse41.la
LIBBITCOIN_CRYPTO += $(LIBBITCOIN_CRYPTO_SSE41)
@@ -584,6 +580,7 @@ crypto_libbitcoin_crypto_base_la_SOURCES = \
crypto/sha1.h \
crypto/sha256.cpp \
crypto/sha256.h \
+ crypto/sha256_sse4.cpp \
crypto/sha3.cpp \
crypto/sha3.h \
crypto/sha512.cpp \
@@ -593,13 +590,6 @@ crypto_libbitcoin_crypto_base_la_SOURCES = \
# See explanation for -static in crypto_libbitcoin_crypto_base_la's LDFLAGS and
# CXXFLAGS above
-crypto_libbitcoin_crypto_sse4_la_LDFLAGS = $(AM_LDFLAGS) -static
-crypto_libbitcoin_crypto_sse4_la_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) -static
-crypto_libbitcoin_crypto_sse4_la_CPPFLAGS = $(AM_CPPFLAGS)
-crypto_libbitcoin_crypto_sse4_la_SOURCES = crypto/sha256_sse4.cpp
-
-# See explanation for -static in crypto_libbitcoin_crypto_base_la's LDFLAGS and
-# CXXFLAGS above
crypto_libbitcoin_crypto_sse41_la_LDFLAGS = $(AM_LDFLAGS) -static
crypto_libbitcoin_crypto_sse41_la_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) -static
crypto_libbitcoin_crypto_sse41_la_CPPFLAGS = $(AM_CPPFLAGS)
diff --git a/src/compat/byteswap.h b/src/compat/byteswap.h
index 9ee71ef267..0d0b079230 100644
--- a/src/compat/byteswap.h
+++ b/src/compat/byteswap.h
@@ -5,44 +5,66 @@
#ifndef BITCOIN_COMPAT_BYTESWAP_H
#define BITCOIN_COMPAT_BYTESWAP_H
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
+#include <cstdint>
+#ifdef _MSC_VER
+#include <cstdlib>
#endif
-#include <cstdint>
-#if defined(HAVE_BYTESWAP_H)
-#include <byteswap.h>
-#endif
+// All internal_bswap_* functions can be replaced with std::byteswap once we
+// require c++23. Both libstdc++ and libc++ implement std::byteswap via these
+// builtins.
-#if defined(MAC_OSX)
+#ifndef DISABLE_BUILTIN_BSWAPS
+# if defined __has_builtin
+# if __has_builtin(__builtin_bswap16)
+# define bitcoin_builtin_bswap16(x) __builtin_bswap16(x)
+# endif
+# if __has_builtin(__builtin_bswap32)
+# define bitcoin_builtin_bswap32(x) __builtin_bswap32(x)
+# endif
+# if __has_builtin(__builtin_bswap64)
+# define bitcoin_builtin_bswap64(x) __builtin_bswap64(x)
+# endif
+# elif defined(_MSC_VER)
+# define bitcoin_builtin_bswap16(x) _byteswap_ushort(x)
+# define bitcoin_builtin_bswap32(x) _byteswap_ulong(x)
+# define bitcoin_builtin_bswap64(x) _byteswap_uint64(x)
+# endif
+#endif
-#include <libkern/OSByteOrder.h>
-#define bswap_16(x) OSSwapInt16(x)
-#define bswap_32(x) OSSwapInt32(x)
-#define bswap_64(x) OSSwapInt64(x)
+// MSVC's _byteswap_* functions are not constexpr
+#ifndef _MSC_VER
+#define BSWAP_CONSTEXPR constexpr
#else
-// Non-MacOS / non-Darwin
+#define BSWAP_CONSTEXPR
+#endif
-#if HAVE_DECL_BSWAP_16 == 0
-inline uint16_t bswap_16(uint16_t x)
+inline BSWAP_CONSTEXPR uint16_t internal_bswap_16(uint16_t x)
{
+#ifdef bitcoin_builtin_bswap16
+ return bitcoin_builtin_bswap16(x);
+#else
return (x >> 8) | (x << 8);
+#endif
}
-#endif // HAVE_DECL_BSWAP16 == 0
-#if HAVE_DECL_BSWAP_32 == 0
-inline uint32_t bswap_32(uint32_t x)
+inline BSWAP_CONSTEXPR uint32_t internal_bswap_32(uint32_t x)
{
+#ifdef bitcoin_builtin_bswap32
+ return bitcoin_builtin_bswap32(x);
+#else
return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >> 8) |
((x & 0x0000ff00U) << 8) | ((x & 0x000000ffU) << 24));
+#endif
}
-#endif // HAVE_DECL_BSWAP32 == 0
-#if HAVE_DECL_BSWAP_64 == 0
-inline uint64_t bswap_64(uint64_t x)
+inline BSWAP_CONSTEXPR uint64_t internal_bswap_64(uint64_t x)
{
+#ifdef bitcoin_builtin_bswap64
+ return bitcoin_builtin_bswap64(x);
+#else
return (((x & 0xff00000000000000ull) >> 56)
| ((x & 0x00ff000000000000ull) >> 40)
| ((x & 0x0000ff0000000000ull) >> 24)
@@ -51,9 +73,7 @@ inline uint64_t bswap_64(uint64_t x)
| ((x & 0x0000000000ff0000ull) << 24)
| ((x & 0x000000000000ff00ull) << 40)
| ((x & 0x00000000000000ffull) << 56));
+#endif
}
-#endif // HAVE_DECL_BSWAP64 == 0
-
-#endif // defined(MAC_OSX)
#endif // BITCOIN_COMPAT_BYTESWAP_H
diff --git a/src/compat/endian.h b/src/compat/endian.h
index 882de2dbf0..4f58428153 100644
--- a/src/compat/endian.h
+++ b/src/compat/endian.h
@@ -5,237 +5,70 @@
#ifndef BITCOIN_COMPAT_ENDIAN_H
#define BITCOIN_COMPAT_ENDIAN_H
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
#include <compat/byteswap.h>
+#include <bit>
#include <cstdint>
-#if defined(HAVE_ENDIAN_H)
-#include <endian.h>
-#elif defined(HAVE_SYS_ENDIAN_H)
-#include <sys/endian.h>
-#endif
-
-#ifndef HAVE_CONFIG_H
-// While not technically a supported configuration, defaulting to defining these
-// DECLs when we were compiled without autotools makes it easier for other build
-// systems to build things like libbitcoinconsensus for strange targets.
-#ifdef htobe16
-#define HAVE_DECL_HTOBE16 1
-#endif
-#ifdef htole16
-#define HAVE_DECL_HTOLE16 1
-#endif
-#ifdef be16toh
-#define HAVE_DECL_BE16TOH 1
-#endif
-#ifdef le16toh
-#define HAVE_DECL_LE16TOH 1
-#endif
-
-#ifdef htobe32
-#define HAVE_DECL_HTOBE32 1
-#endif
-#ifdef htole32
-#define HAVE_DECL_HTOLE32 1
-#endif
-#ifdef be32toh
-#define HAVE_DECL_BE32TOH 1
-#endif
-#ifdef le32toh
-#define HAVE_DECL_LE32TOH 1
-#endif
-
-#ifdef htobe64
-#define HAVE_DECL_HTOBE64 1
-#endif
-#ifdef htole64
-#define HAVE_DECL_HTOLE64 1
-#endif
-#ifdef be64toh
-#define HAVE_DECL_BE64TOH 1
-#endif
-#ifdef le64toh
-#define HAVE_DECL_LE64TOH 1
-#endif
-
-#endif // HAVE_CONFIG_H
-
-#if defined(WORDS_BIGENDIAN)
-
-#if HAVE_DECL_HTOBE16 == 0
-inline uint16_t htobe16(uint16_t host_16bits)
-{
- return host_16bits;
-}
-#endif // HAVE_DECL_HTOBE16
-
-#if HAVE_DECL_HTOLE16 == 0
-inline uint16_t htole16(uint16_t host_16bits)
-{
- return bswap_16(host_16bits);
-}
-#endif // HAVE_DECL_HTOLE16
-
-#if HAVE_DECL_BE16TOH == 0
-inline uint16_t be16toh(uint16_t big_endian_16bits)
-{
- return big_endian_16bits;
-}
-#endif // HAVE_DECL_BE16TOH
-
-#if HAVE_DECL_LE16TOH == 0
-inline uint16_t le16toh(uint16_t little_endian_16bits)
-{
- return bswap_16(little_endian_16bits);
-}
-#endif // HAVE_DECL_LE16TOH
-
-#if HAVE_DECL_HTOBE32 == 0
-inline uint32_t htobe32(uint32_t host_32bits)
-{
- return host_32bits;
-}
-#endif // HAVE_DECL_HTOBE32
-
-#if HAVE_DECL_HTOLE32 == 0
-inline uint32_t htole32(uint32_t host_32bits)
-{
- return bswap_32(host_32bits);
-}
-#endif // HAVE_DECL_HTOLE32
-
-#if HAVE_DECL_BE32TOH == 0
-inline uint32_t be32toh(uint32_t big_endian_32bits)
-{
- return big_endian_32bits;
-}
-#endif // HAVE_DECL_BE32TOH
-
-#if HAVE_DECL_LE32TOH == 0
-inline uint32_t le32toh(uint32_t little_endian_32bits)
+inline BSWAP_CONSTEXPR uint16_t htobe16_internal(uint16_t host_16bits)
{
- return bswap_32(little_endian_32bits);
+ if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(host_16bits);
+ else return host_16bits;
}
-#endif // HAVE_DECL_LE32TOH
-
-#if HAVE_DECL_HTOBE64 == 0
-inline uint64_t htobe64(uint64_t host_64bits)
-{
- return host_64bits;
-}
-#endif // HAVE_DECL_HTOBE64
-
-#if HAVE_DECL_HTOLE64 == 0
-inline uint64_t htole64(uint64_t host_64bits)
-{
- return bswap_64(host_64bits);
-}
-#endif // HAVE_DECL_HTOLE64
-
-#if HAVE_DECL_BE64TOH == 0
-inline uint64_t be64toh(uint64_t big_endian_64bits)
-{
- return big_endian_64bits;
-}
-#endif // HAVE_DECL_BE64TOH
-
-#if HAVE_DECL_LE64TOH == 0
-inline uint64_t le64toh(uint64_t little_endian_64bits)
-{
- return bswap_64(little_endian_64bits);
-}
-#endif // HAVE_DECL_LE64TOH
-
-#else // WORDS_BIGENDIAN
-
-#if HAVE_DECL_HTOBE16 == 0
-inline uint16_t htobe16(uint16_t host_16bits)
+inline BSWAP_CONSTEXPR uint16_t htole16_internal(uint16_t host_16bits)
{
- return bswap_16(host_16bits);
+ if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
+ else return host_16bits;
}
-#endif // HAVE_DECL_HTOBE16
-
-#if HAVE_DECL_HTOLE16 == 0
-inline uint16_t htole16(uint16_t host_16bits)
+inline BSWAP_CONSTEXPR uint16_t be16toh_internal(uint16_t big_endian_16bits)
{
- return host_16bits;
+ if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(big_endian_16bits);
+ else return big_endian_16bits;
}
-#endif // HAVE_DECL_HTOLE16
-
-#if HAVE_DECL_BE16TOH == 0
-inline uint16_t be16toh(uint16_t big_endian_16bits)
+inline BSWAP_CONSTEXPR uint16_t le16toh_internal(uint16_t little_endian_16bits)
{
- return bswap_16(big_endian_16bits);
+ if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
+ else return little_endian_16bits;
}
-#endif // HAVE_DECL_BE16TOH
-
-#if HAVE_DECL_LE16TOH == 0
-inline uint16_t le16toh(uint16_t little_endian_16bits)
+inline BSWAP_CONSTEXPR uint32_t htobe32_internal(uint32_t host_32bits)
{
- return little_endian_16bits;
+ if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
+ else return host_32bits;
}
-#endif // HAVE_DECL_LE16TOH
-
-#if HAVE_DECL_HTOBE32 == 0
-inline uint32_t htobe32(uint32_t host_32bits)
-{
- return bswap_32(host_32bits);
-}
-#endif // HAVE_DECL_HTOBE32
-
-#if HAVE_DECL_HTOLE32 == 0
-inline uint32_t htole32(uint32_t host_32bits)
+inline BSWAP_CONSTEXPR uint32_t htole32_internal(uint32_t host_32bits)
{
- return host_32bits;
+ if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
+ else return host_32bits;
}
-#endif // HAVE_DECL_HTOLE32
-
-#if HAVE_DECL_BE32TOH == 0
-inline uint32_t be32toh(uint32_t big_endian_32bits)
+inline BSWAP_CONSTEXPR uint32_t be32toh_internal(uint32_t big_endian_32bits)
{
- return bswap_32(big_endian_32bits);
+ if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
+ else return big_endian_32bits;
}
-#endif // HAVE_DECL_BE32TOH
-
-#if HAVE_DECL_LE32TOH == 0
-inline uint32_t le32toh(uint32_t little_endian_32bits)
+inline BSWAP_CONSTEXPR uint32_t le32toh_internal(uint32_t little_endian_32bits)
{
- return little_endian_32bits;
+ if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
+ else return little_endian_32bits;
}
-#endif // HAVE_DECL_LE32TOH
-
-#if HAVE_DECL_HTOBE64 == 0
-inline uint64_t htobe64(uint64_t host_64bits)
+inline BSWAP_CONSTEXPR uint64_t htobe64_internal(uint64_t host_64bits)
{
- return bswap_64(host_64bits);
+ if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
+ else return host_64bits;
}
-#endif // HAVE_DECL_HTOBE64
-
-#if HAVE_DECL_HTOLE64 == 0
-inline uint64_t htole64(uint64_t host_64bits)
+inline BSWAP_CONSTEXPR uint64_t htole64_internal(uint64_t host_64bits)
{
- return host_64bits;
+ if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
+ else return host_64bits;
}
-#endif // HAVE_DECL_HTOLE64
-
-#if HAVE_DECL_BE64TOH == 0
-inline uint64_t be64toh(uint64_t big_endian_64bits)
+inline BSWAP_CONSTEXPR uint64_t be64toh_internal(uint64_t big_endian_64bits)
{
- return bswap_64(big_endian_64bits);
+ if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(big_endian_64bits);
+ else return big_endian_64bits;
}
-#endif // HAVE_DECL_BE64TOH
-
-#if HAVE_DECL_LE64TOH == 0
-inline uint64_t le64toh(uint64_t little_endian_64bits)
+inline BSWAP_CONSTEXPR uint64_t le64toh_internal(uint64_t little_endian_64bits)
{
- return little_endian_64bits;
+ if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
+ else return little_endian_64bits;
}
-#endif // HAVE_DECL_LE64TOH
-
-#endif // WORDS_BIGENDIAN
#endif // BITCOIN_COMPAT_ENDIAN_H
diff --git a/src/crypto/common.h b/src/crypto/common.h
index 6ae5d4cd24..1dc4f3f55c 100644
--- a/src/crypto/common.h
+++ b/src/crypto/common.h
@@ -5,51 +5,47 @@
#ifndef BITCOIN_CRYPTO_COMMON_H
#define BITCOIN_CRYPTO_COMMON_H
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
-#include <stdint.h>
-#include <string.h>
-
#include <compat/endian.h>
+#include <cstdint>
+#include <cstring>
+
uint16_t static inline ReadLE16(const unsigned char* ptr)
{
uint16_t x;
memcpy(&x, ptr, 2);
- return le16toh(x);
+ return le16toh_internal(x);
}
uint32_t static inline ReadLE32(const unsigned char* ptr)
{
uint32_t x;
memcpy(&x, ptr, 4);
- return le32toh(x);
+ return le32toh_internal(x);
}
uint64_t static inline ReadLE64(const unsigned char* ptr)
{
uint64_t x;
memcpy(&x, ptr, 8);
- return le64toh(x);
+ return le64toh_internal(x);
}
void static inline WriteLE16(unsigned char* ptr, uint16_t x)
{
- uint16_t v = htole16(x);
+ uint16_t v = htole16_internal(x);
memcpy(ptr, &v, 2);
}
void static inline WriteLE32(unsigned char* ptr, uint32_t x)
{
- uint32_t v = htole32(x);
+ uint32_t v = htole32_internal(x);
memcpy(ptr, &v, 4);
}
void static inline WriteLE64(unsigned char* ptr, uint64_t x)
{
- uint64_t v = htole64(x);
+ uint64_t v = htole64_internal(x);
memcpy(ptr, &v, 8);
}
@@ -57,54 +53,33 @@ uint16_t static inline ReadBE16(const unsigned char* ptr)
{
uint16_t x;
memcpy(&x, ptr, 2);
- return be16toh(x);
+ return be16toh_internal(x);
}
uint32_t static inline ReadBE32(const unsigned char* ptr)
{
uint32_t x;
memcpy(&x, ptr, 4);
- return be32toh(x);
+ return be32toh_internal(x);
}
uint64_t static inline ReadBE64(const unsigned char* ptr)
{
uint64_t x;
memcpy(&x, ptr, 8);
- return be64toh(x);
+ return be64toh_internal(x);
}
void static inline WriteBE32(unsigned char* ptr, uint32_t x)
{
- uint32_t v = htobe32(x);
+ uint32_t v = htobe32_internal(x);
memcpy(ptr, &v, 4);
}
void static inline WriteBE64(unsigned char* ptr, uint64_t x)
{
- uint64_t v = htobe64(x);
+ uint64_t v = htobe64_internal(x);
memcpy(ptr, &v, 8);
}
-/** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */
-uint64_t static inline CountBits(uint64_t x)
-{
-#if HAVE_BUILTIN_CLZL
- if (sizeof(unsigned long) >= sizeof(uint64_t)) {
- return x ? 8 * sizeof(unsigned long) - __builtin_clzl(x) : 0;
- }
-#endif
-#if HAVE_BUILTIN_CLZLL
- if (sizeof(unsigned long long) >= sizeof(uint64_t)) {
- return x ? 8 * sizeof(unsigned long long) - __builtin_clzll(x) : 0;
- }
-#endif
- int ret = 0;
- while (x) {
- x >>= 1;
- ++ret;
- }
- return ret;
-}
-
#endif // BITCOIN_CRYPTO_COMMON_H
diff --git a/src/crypto/sha256.cpp b/src/crypto/sha256.cpp
index 36ef6d9a1a..4c7bb6f20f 100644
--- a/src/crypto/sha256.cpp
+++ b/src/crypto/sha256.cpp
@@ -26,13 +26,11 @@
#endif
#if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
-#if defined(USE_ASM)
namespace sha256_sse4
{
void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks);
}
#endif
-#endif
namespace sha256d64_sse41
{
@@ -574,7 +572,7 @@ bool SelfTest() {
}
#if !defined(DISABLE_OPTIMIZED_SHA256)
-#if defined(USE_ASM) && (defined(__x86_64__) || defined(__amd64__) || defined(__i386__))
+#if (defined(__x86_64__) || defined(__amd64__) || defined(__i386__))
/** Check whether the OS has enabled AVX registers. */
bool AVXEnabled()
{
@@ -597,7 +595,7 @@ std::string SHA256AutoDetect(sha256_implementation::UseImplementation use_implem
TransformD64_8way = nullptr;
#if !defined(DISABLE_OPTIMIZED_SHA256)
-#if defined(USE_ASM) && defined(HAVE_GETCPUID)
+#if defined(HAVE_GETCPUID)
bool have_sse4 = false;
bool have_xsave = false;
bool have_avx = false;
@@ -654,7 +652,7 @@ std::string SHA256AutoDetect(sha256_implementation::UseImplementation use_implem
ret += ",avx2(8way)";
}
#endif
-#endif // defined(USE_ASM) && defined(HAVE_GETCPUID)
+#endif // defined(HAVE_GETCPUID)
#if defined(ENABLE_ARM_SHANI)
bool have_arm_shani = false;
diff --git a/src/i2p.cpp b/src/i2p.cpp
index c891562d00..4b79a6826b 100644
--- a/src/i2p.cpp
+++ b/src/i2p.cpp
@@ -392,7 +392,7 @@ Binary Session::MyDestination() const
}
memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
- cert_len = be16toh(cert_len);
+ cert_len = be16toh_internal(cert_len);
const size_t dest_len = DEST_LEN_BASE + cert_len;
diff --git a/src/random.h b/src/random.h
index 76bae5838d..f7c20ee4b0 100644
--- a/src/random.h
+++ b/src/random.h
@@ -11,6 +11,7 @@
#include <span.h>
#include <uint256.h>
+#include <bit>
#include <cassert>
#include <chrono>
#include <cstdint>
@@ -203,7 +204,7 @@ public:
{
assert(range);
--range;
- int bits = CountBits(range);
+ int bits = std::bit_width(range);
while (true) {
uint64_t ret = randbits(bits);
if (ret <= range) return ret;
diff --git a/src/serialize.h b/src/serialize.h
index ab57376a57..2f13fba582 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -57,27 +57,27 @@ template<typename Stream> inline void ser_writedata8(Stream &s, uint8_t obj)
}
template<typename Stream> inline void ser_writedata16(Stream &s, uint16_t obj)
{
- obj = htole16(obj);
+ obj = htole16_internal(obj);
s.write(AsBytes(Span{&obj, 1}));
}
template<typename Stream> inline void ser_writedata16be(Stream &s, uint16_t obj)
{
- obj = htobe16(obj);
+ obj = htobe16_internal(obj);
s.write(AsBytes(Span{&obj, 1}));
}
template<typename Stream> inline void ser_writedata32(Stream &s, uint32_t obj)
{
- obj = htole32(obj);
+ obj = htole32_internal(obj);
s.write(AsBytes(Span{&obj, 1}));
}
template<typename Stream> inline void ser_writedata32be(Stream &s, uint32_t obj)
{
- obj = htobe32(obj);
+ obj = htobe32_internal(obj);
s.write(AsBytes(Span{&obj, 1}));
}
template<typename Stream> inline void ser_writedata64(Stream &s, uint64_t obj)
{
- obj = htole64(obj);
+ obj = htole64_internal(obj);
s.write(AsBytes(Span{&obj, 1}));
}
template<typename Stream> inline uint8_t ser_readdata8(Stream &s)
@@ -90,31 +90,31 @@ template<typename Stream> inline uint16_t ser_readdata16(Stream &s)
{
uint16_t obj;
s.read(AsWritableBytes(Span{&obj, 1}));
- return le16toh(obj);
+ return le16toh_internal(obj);
}
template<typename Stream> inline uint16_t ser_readdata16be(Stream &s)
{
uint16_t obj;
s.read(AsWritableBytes(Span{&obj, 1}));
- return be16toh(obj);
+ return be16toh_internal(obj);
}
template<typename Stream> inline uint32_t ser_readdata32(Stream &s)
{
uint32_t obj;
s.read(AsWritableBytes(Span{&obj, 1}));
- return le32toh(obj);
+ return le32toh_internal(obj);
}
template<typename Stream> inline uint32_t ser_readdata32be(Stream &s)
{
uint32_t obj;
s.read(AsWritableBytes(Span{&obj, 1}));
- return be32toh(obj);
+ return be32toh_internal(obj);
}
template<typename Stream> inline uint64_t ser_readdata64(Stream &s)
{
uint64_t obj;
s.read(AsWritableBytes(Span{&obj, 1}));
- return le64toh(obj);
+ return le64toh_internal(obj);
}
@@ -548,10 +548,10 @@ struct CustomUintFormatter
{
if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
if (BigEndian) {
- uint64_t raw = htobe64(v);
+ uint64_t raw = htobe64_internal(v);
s.write(AsBytes(Span{&raw, 1}).last(Bytes));
} else {
- uint64_t raw = htole64(v);
+ uint64_t raw = htole64_internal(v);
s.write(AsBytes(Span{&raw, 1}).first(Bytes));
}
}
@@ -563,10 +563,10 @@ struct CustomUintFormatter
uint64_t raw = 0;
if (BigEndian) {
s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
- v = static_cast<I>(be64toh(raw));
+ v = static_cast<I>(be64toh_internal(raw));
} else {
s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
- v = static_cast<I>(le64toh(raw));
+ v = static_cast<I>(le64toh_internal(raw));
}
}
};
diff --git a/src/test/bswap_tests.cpp b/src/test/bswap_tests.cpp
index 2be7122fc1..fe48e39c41 100644
--- a/src/test/bswap_tests.cpp
+++ b/src/test/bswap_tests.cpp
@@ -16,9 +16,9 @@ BOOST_AUTO_TEST_CASE(bswap_tests)
uint16_t e1 = 0x3412;
uint32_t e2 = 0xbc9a7856;
uint64_t e3 = 0xbc9a78563412f0de;
- BOOST_CHECK(bswap_16(u1) == e1);
- BOOST_CHECK(bswap_32(u2) == e2);
- BOOST_CHECK(bswap_64(u3) == e3);
+ BOOST_CHECK(internal_bswap_16(u1) == e1);
+ BOOST_CHECK(internal_bswap_32(u2) == e2);
+ BOOST_CHECK(internal_bswap_64(u3) == e3);
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
index 0a6378adf4..46acc6fc9f 100644
--- a/src/test/crypto_tests.cpp
+++ b/src/test/crypto_tests.cpp
@@ -1060,28 +1060,6 @@ BOOST_AUTO_TEST_CASE(hkdf_hmac_sha256_l32_tests)
"8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d");
}
-BOOST_AUTO_TEST_CASE(countbits_tests)
-{
- FastRandomContext ctx;
- for (unsigned int i = 0; i <= 64; ++i) {
- if (i == 0) {
- // Check handling of zero.
- BOOST_CHECK_EQUAL(CountBits(0), 0U);
- } else if (i < 10) {
- for (uint64_t j = uint64_t{1} << (i - 1); (j >> i) == 0; ++j) {
- // Exhaustively test up to 10 bits
- BOOST_CHECK_EQUAL(CountBits(j), i);
- }
- } else {
- for (int k = 0; k < 1000; k++) {
- // Randomly test 1000 samples of each length above 10 bits.
- uint64_t j = (uint64_t{1}) << (i - 1) | ctx.randbits(i - 1);
- BOOST_CHECK_EQUAL(CountBits(j), i);
- }
- }
- }
-}
-
BOOST_AUTO_TEST_CASE(sha256d64)
{
for (int i = 0; i <= 32; ++i) {
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
index 2577f9e97a..db246bb84e 100644
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -80,7 +80,6 @@ FUZZ_TARGET(integer, .init = initialize_integer)
static const uint256 u256_max(uint256S("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
const std::vector<uint256> v256{u256, u256_min, u256_max};
(void)ComputeMerkleRoot(v256);
- (void)CountBits(u64);
(void)DecompressAmount(u64);
{
if (std::optional<CAmount> parsed = ParseMoney(FormatMoney(i64))) {
diff --git a/src/test/fuzz/net.cpp b/src/test/fuzz/net.cpp
index c882bd766a..e8b1480c5b 100644
--- a/src/test/fuzz/net.cpp
+++ b/src/test/fuzz/net.cpp
@@ -77,3 +77,40 @@ FUZZ_TARGET(net, .init = initialize_net)
(void)node.HasPermission(net_permission_flags);
(void)node.ConnectedThroughNetwork();
}
+
+FUZZ_TARGET(local_address, .init = initialize_net)
+{
+ FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+ CService service{ConsumeService(fuzzed_data_provider)};
+ CNode node{ConsumeNode(fuzzed_data_provider)};
+ {
+ LOCK(g_maplocalhost_mutex);
+ mapLocalHost.clear();
+ }
+ LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
+ CallOneOf(
+ fuzzed_data_provider,
+ [&] {
+ service = ConsumeService(fuzzed_data_provider);
+ },
+ [&] {
+ const bool added{AddLocal(service, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, LOCAL_MAX - 1))};
+ if (!added) return;
+ assert(service.IsRoutable());
+ assert(IsLocal(service));
+ assert(SeenLocal(service));
+ },
+ [&] {
+ (void)RemoveLocal(service);
+ },
+ [&] {
+ (void)SeenLocal(service);
+ },
+ [&] {
+ (void)IsLocal(service);
+ },
+ [&] {
+ (void)GetLocalAddress(node);
+ });
+ }
+}
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index c6f6ac3bdb..93a884be6d 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -233,7 +233,6 @@ BOOST_AUTO_TEST_CASE(block_malleation)
// Block with two transactions is mutated if any node is duplicate.
{
block.vtx[1] = block.vtx[0];
- BOOST_CHECK(is_mutated(block, /*check_witness_root=*/false));
HashWriter hasher;
hasher.write(block.vtx[0]->GetHash());
hasher.write(block.vtx[1]->GetHash());
diff --git a/src/util/asmap.cpp b/src/util/asmap.cpp
index 360573cbae..f50cd8a28c 100644
--- a/src/util/asmap.cpp
+++ b/src/util/asmap.cpp
@@ -5,13 +5,13 @@
#include <util/asmap.h>
#include <clientversion.h>
-#include <crypto/common.h>
#include <logging.h>
#include <serialize.h>
#include <streams.h>
#include <util/fs.h>
#include <algorithm>
+#include <bit>
#include <cassert>
#include <cstdio>
#include <utility>
@@ -111,7 +111,7 @@ uint32_t Interpret(const std::vector<bool> &asmap, const std::vector<bool> &ip)
} else if (opcode == Instruction::MATCH) {
match = DecodeMatch(pos, endpos);
if (match == INVALID) break; // Match bits straddle EOF
- matchlen = CountBits(match) - 1;
+ matchlen = std::bit_width(match) - 1;
if (bits < matchlen) break; // Not enough input bits
for (uint32_t bit = 0; bit < matchlen; bit++) {
if ((ip[ip.size() - bits]) != ((match >> (matchlen - 1 - bit)) & 1)) {
@@ -175,7 +175,7 @@ bool SanityCheckASMap(const std::vector<bool>& asmap, int bits)
} else if (opcode == Instruction::MATCH) {
uint32_t match = DecodeMatch(pos, endpos);
if (match == INVALID) return false; // Match bits straddle EOF
- int matchlen = CountBits(match) - 1;
+ int matchlen = std::bit_width(match) - 1;
if (prevopcode != Instruction::MATCH) had_incomplete_match = false;
if (matchlen < 8 && had_incomplete_match) return false; // Within a sequence of matches only at most one should be incomplete
had_incomplete_match = (matchlen < 8);
diff --git a/test/functional/test_framework/crypto/bip324_cipher.py b/test/functional/test_framework/crypto/bip324_cipher.py
index 56190647f2..c9f0fa0151 100644
--- a/test/functional/test_framework/crypto/bip324_cipher.py
+++ b/test/functional/test_framework/crypto/bip324_cipher.py
@@ -25,6 +25,8 @@ def pad16(x):
def aead_chacha20_poly1305_encrypt(key, nonce, aad, plaintext):
"""Encrypt a plaintext using ChaCha20Poly1305."""
+ if plaintext is None:
+ return None
ret = bytearray()
msg_len = len(plaintext)
for i in range((msg_len + 63) // 64):
@@ -42,7 +44,7 @@ def aead_chacha20_poly1305_encrypt(key, nonce, aad, plaintext):
def aead_chacha20_poly1305_decrypt(key, nonce, aad, ciphertext):
"""Decrypt a ChaCha20Poly1305 ciphertext."""
- if len(ciphertext) < 16:
+ if ciphertext is None or len(ciphertext) < 16:
return None
msg_len = len(ciphertext) - 16
poly1305 = Poly1305(chacha20_block(key, nonce, 0)[:32])
@@ -191,11 +193,11 @@ class TestFrameworkAEAD(unittest.TestCase):
dec_aead = FSChaCha20Poly1305(key)
for _ in range(msg_idx):
- enc_aead.encrypt(b"", b"")
+ enc_aead.encrypt(b"", None)
ciphertext = enc_aead.encrypt(aad, plain)
self.assertEqual(hex_cipher, ciphertext.hex())
for _ in range(msg_idx):
- dec_aead.decrypt(b"", bytes(16))
+ dec_aead.decrypt(b"", None)
plaintext = dec_aead.decrypt(aad, ciphertext)
self.assertEqual(plain, plaintext)
generated by cgit v1.2.3 (git 2.26.2) at 2024-10-13 03:22:22 +0000