diff --git a/configure.ac b/configure.ac index 11f4fe2c215b..6bf3a3205718 100644 --- a/configure.ac +++ b/configure.ac @@ -378,6 +378,9 @@ if test "$enable_debug" = "yes"; then AX_CHECK_PREPROC_FLAG([-DABORT_ON_FAILED_ASSUME], [DEBUG_CPPFLAGS="$DEBUG_CPPFLAGS -DABORT_ON_FAILED_ASSUME"], [], [$CXXFLAG_WERROR]) AX_CHECK_COMPILE_FLAG([-ftrapv], [DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -ftrapv"], [], [$CXXFLAG_WERROR]) else + dnl If not debugging, enable more aggressive optimizations for sphlib sources + AX_CHECK_COMPILE_FLAG([-O3], [SPHLIB_CFLAGS="$SPHLIB_CFLAGS -O3"], [], [$CXXFLAG_WERROR]) + # We always enable at at least -g1 debug info to support proper stacktraces in crash infos # Stacktraces will be suboptimal due to optimization, but better than nothing. Also, -fno-omit-frame-pointer # mitigates this a little bit @@ -1874,6 +1877,7 @@ AC_SUBST(PIC_FLAGS) AC_SUBST(PIE_FLAGS) AC_SUBST(SANITIZER_CXXFLAGS) AC_SUBST(SANITIZER_LDFLAGS) +AC_SUBST(SPHLIB_CFLAGS) AC_SUBST(SSE42_CXXFLAGS) AC_SUBST(SSE41_CXXFLAGS) AC_SUBST(CLMUL_CXXFLAGS) diff --git a/src/Makefile.am b/src/Makefile.am index fff2e0bbba19..95b97a17789d 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -73,6 +73,8 @@ LIBBITCOIN_WALLET_TOOL=libbitcoin_wallet_tool.a endif LIBBITCOIN_CRYPTO = $(LIBBITCOIN_CRYPTO_BASE) +LIBBITCOIN_CRYPTO_SPH = crypto/libbitcoin_crypto_sph.la +LIBBITCOIN_CRYPTO += $(LIBBITCOIN_CRYPTO_SPH) if ENABLE_SSE41 LIBBITCOIN_CRYPTO_SSE41 = crypto/libbitcoin_crypto_sse41.la LIBBITCOIN_CRYPTO += $(LIBBITCOIN_CRYPTO_SSE41) @@ -718,8 +720,16 @@ crypto_libbitcoin_crypto_avx2_la_CXXFLAGS += $(AVX2_CXXFLAGS) crypto_libbitcoin_crypto_avx2_la_CPPFLAGS += -DENABLE_AVX2 crypto_libbitcoin_crypto_avx2_la_SOURCES = crypto/sha256_avx2.cpp -# x11 -crypto_libbitcoin_crypto_base_la_SOURCES += \ +# See explanation for -static in crypto_libbitcoin_crypto_base_la's LDFLAGS and +# CXXFLAGS above +crypto_libbitcoin_crypto_sph_la_LDFLAGS = $(AM_LDFLAGS) -static +crypto_libbitcoin_crypto_sph_la_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) -static +crypto_libbitcoin_crypto_sph_la_CPPFLAGS = $(AM_CPPFLAGS) +crypto_libbitcoin_crypto_sph_la_CFLAGS = $(SPHLIB_CFLAGS) +crypto_libbitcoin_crypto_sph_la_CPPFLAGS += \ + -DSPH_SMALL_FOOTPRINT_CUBEHASH=1 \ + -DSPH_SMALL_FOOTPRINT_JH=1 +crypto_libbitcoin_crypto_sph_la_SOURCES = \ crypto/x11/aes_helper.c \ crypto/x11/blake.c \ crypto/x11/bmw.c \ @@ -1009,7 +1019,7 @@ endif # dashconsensus library # if BUILD_BITCOIN_LIBS include_HEADERS = script/bitcoinconsensus.h -libdashconsensus_la_SOURCES = support/cleanse.cpp $(crypto_libbitcoin_crypto_base_la_SOURCES) $(libbitcoin_consensus_a_SOURCES) +libdashconsensus_la_SOURCES = support/cleanse.cpp $(crypto_libbitcoin_crypto_base_la_SOURCES) $(crypto_libbitcoin_crypto_sph_la_SOURCES) $(libbitcoin_consensus_a_SOURCES) libdashconsensus_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS) libdashconsensus_la_LIBADD = $(LIBDASHBLS) $(LIBSECP256K1) $(GMP_LIBS) diff --git a/src/Makefile.bench.include b/src/Makefile.bench.include index a6ffeb1c2107..1169d922984c 100644 --- a/src/Makefile.bench.include +++ b/src/Makefile.bench.include @@ -43,6 +43,7 @@ bench_bench_dash_SOURCES = \ bench/nanobench.cpp \ bench/peer_eviction.cpp \ bench/pool.cpp \ + bench/pow_hash.cpp \ bench/rpc_blockchain.cpp \ bench/rpc_mempool.cpp \ bench/strencodings.cpp \ diff --git a/src/bench/crypto_hash.cpp b/src/bench/crypto_hash.cpp index d184bdc8bf8b..9db0703c6d1e 100644 --- a/src/bench/crypto_hash.cpp +++ b/src/bench/crypto_hash.cpp @@ -295,15 +295,6 @@ static void DSHA256_1M(benchmark::Bench& bench) }); } -static void X11_1M(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(BUFFER_SIZE,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - /* Hash different number of bytes via DSHA256 */ static void DSHA256_0032b_single(benchmark::Bench& bench) { @@ -359,63 +350,7 @@ static void DSHA256_2048b_single(benchmark::Bench& bench) }); } -/* Hash different number of bytes via X11 */ -static void X11_0032b_single(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(32,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - -static void X11_0080b_single(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(80,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - -static void X11_0128b_single(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(128,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - -static void X11_0512b_single(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(512,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - -static void X11_1024b_single(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(1024,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - -static void X11_2048b_single(benchmark::Bench& bench) -{ - uint256 hash; - std::vector in(2048,0); - bench.batch(in.size()).unit("byte").run([&] { - hash = HashX11(in.begin(), in.end()); - }); -} - BENCHMARK(DSHA256_1M); -BENCHMARK(X11_1M); BENCHMARK(DSHA256_0032b_single); BENCHMARK(DSHA256_0080b_single); @@ -423,10 +358,3 @@ BENCHMARK(DSHA256_0128b_single); BENCHMARK(DSHA256_0512b_single); BENCHMARK(DSHA256_1024b_single); BENCHMARK(DSHA256_2048b_single); - -BENCHMARK(X11_0032b_single); -BENCHMARK(X11_0080b_single); -BENCHMARK(X11_0128b_single); -BENCHMARK(X11_0512b_single); -BENCHMARK(X11_1024b_single); -BENCHMARK(X11_2048b_single); diff --git a/src/bench/pow_hash.cpp b/src/bench/pow_hash.cpp new file mode 100644 index 000000000000..d5f9c17f9808 --- /dev/null +++ b/src/bench/pow_hash.cpp @@ -0,0 +1,359 @@ +// Copyright (c) 2025 The Dash Core developers +// Distributed under the MIT software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +//! Bytes to hash per iteration +static constexpr size_t BUFFER_SIZE{1000*1000}; +//! Bytes required to represent 512-bit unsigned integers (uint512) +static constexpr size_t OUTPUT_SIZE{64}; + +inline void Pow_X11(benchmark::Bench& bench, const size_t bytes) +{ + uint256 hash{}; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + hash = HashX11(in.begin(), in.end()); + }); +} + +inline void Pow_Blake512(benchmark::Bench& bench, const size_t bytes) +{ + sph_blake512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_blake512_init(&ctx); + sph_blake512(&ctx, in.data(), in.size()); + sph_blake512_close(&ctx, &hash); + }); +} + +inline void Pow_Bmw512(benchmark::Bench& bench, const size_t bytes) +{ + sph_bmw512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_bmw512_init(&ctx); + sph_bmw512(&ctx, in.data(), in.size()); + sph_bmw512_close(&ctx, &hash); + }); +} + +inline void Pow_Cubehash512(benchmark::Bench& bench, const size_t bytes) +{ + sph_cubehash512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_cubehash512_init(&ctx); + sph_cubehash512(&ctx, in.data(), in.size()); + sph_cubehash512_close(&ctx, &hash); + }); +} + +inline void Pow_Echo512(benchmark::Bench& bench, const size_t bytes) +{ + sph_echo512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_echo512_init(&ctx); + sph_echo512(&ctx, in.data(), in.size()); + sph_echo512_close(&ctx, &hash); + }); +} + +inline void Pow_Groestl512(benchmark::Bench& bench, const size_t bytes) +{ + sph_groestl512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_groestl512_init(&ctx); + sph_groestl512(&ctx, in.data(), in.size()); + sph_groestl512_close(&ctx, &hash); + }); +} + +inline void Pow_Jh512(benchmark::Bench& bench, const size_t bytes) +{ + sph_jh512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_jh512_init(&ctx); + sph_jh512(&ctx, in.data(), in.size()); + sph_jh512_close(&ctx, &hash); + }); +} + +inline void Pow_Keccak512(benchmark::Bench& bench, const size_t bytes) +{ + sph_keccak512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_keccak512_init(&ctx); + sph_keccak512(&ctx, in.data(), in.size()); + sph_keccak512_close(&ctx, &hash); + }); +} + +inline void Pow_Luffa512(benchmark::Bench& bench, const size_t bytes) +{ + sph_luffa512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_luffa512_init(&ctx); + sph_luffa512(&ctx, in.data(), in.size()); + sph_luffa512_close(&ctx, &hash); + }); +} + +inline void Pow_Shavite512(benchmark::Bench& bench, const size_t bytes) +{ + sph_shavite512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_shavite512_init(&ctx); + sph_shavite512(&ctx, in.data(), in.size()); + sph_shavite512_close(&ctx, &hash); + }); +} + +inline void Pow_Simd512(benchmark::Bench& bench, const size_t bytes) +{ + sph_simd512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_simd512_init(&ctx); + sph_simd512(&ctx, in.data(), in.size()); + sph_simd512_close(&ctx, &hash); + }); +} + +inline void Pow_Skein512(benchmark::Bench& bench, const size_t bytes) +{ + sph_skein512_context ctx; + uint8_t hash[OUTPUT_SIZE]; + std::vector in(bytes, 0); + bench.batch(in.size()).unit("byte").run([&] { + sph_skein512_init(&ctx); + sph_skein512(&ctx, in.data(), in.size()); + sph_skein512_close(&ctx, &hash); + }); +} +} // anonymous namespace + +static void Pow_X11_0032b(benchmark::Bench& bench) { return Pow_X11(bench, 32); } +static void Pow_X11_0080b(benchmark::Bench& bench) { return Pow_X11(bench, 80); } +static void Pow_X11_0128b(benchmark::Bench& bench) { return Pow_X11(bench, 128); } +static void Pow_X11_0512b(benchmark::Bench& bench) { return Pow_X11(bench, 512); } +static void Pow_X11_1024b(benchmark::Bench& bench) { return Pow_X11(bench, 1024); } +static void Pow_X11_2048b(benchmark::Bench& bench) { return Pow_X11(bench, 2048); } +static void Pow_X11_1M(benchmark::Bench& bench) { return Pow_X11(bench, BUFFER_SIZE); } + +static void Pow_Blake512_0032b(benchmark::Bench& bench) { return Pow_Blake512(bench, 32); } +static void Pow_Blake512_0080b(benchmark::Bench& bench) { return Pow_Blake512(bench, 80); } +static void Pow_Blake512_0128b(benchmark::Bench& bench) { return Pow_Blake512(bench, 128); } +static void Pow_Blake512_0512b(benchmark::Bench& bench) { return Pow_Blake512(bench, 512); } +static void Pow_Blake512_1024b(benchmark::Bench& bench) { return Pow_Blake512(bench, 1024); } +static void Pow_Blake512_2048b(benchmark::Bench& bench) { return Pow_Blake512(bench, 2048); } +static void Pow_Blake512_1M(benchmark::Bench& bench) { return Pow_Blake512(bench, BUFFER_SIZE); } + +static void Pow_Bmw512_0032b(benchmark::Bench& bench) { return Pow_Bmw512(bench, 32); } +static void Pow_Bmw512_0080b(benchmark::Bench& bench) { return Pow_Bmw512(bench, 80); } +static void Pow_Bmw512_0128b(benchmark::Bench& bench) { return Pow_Bmw512(bench, 128); } +static void Pow_Bmw512_0512b(benchmark::Bench& bench) { return Pow_Bmw512(bench, 512); } +static void Pow_Bmw512_1024b(benchmark::Bench& bench) { return Pow_Bmw512(bench, 1024); } +static void Pow_Bmw512_2048b(benchmark::Bench& bench) { return Pow_Bmw512(bench, 2048); } +static void Pow_Bmw512_1M(benchmark::Bench& bench) { return Pow_Bmw512(bench, BUFFER_SIZE); } + +static void Pow_Cubehash512_0032b(benchmark::Bench& bench) { return Pow_Cubehash512(bench, 32); } +static void Pow_Cubehash512_0080b(benchmark::Bench& bench) { return Pow_Cubehash512(bench, 80); } +static void Pow_Cubehash512_0128b(benchmark::Bench& bench) { return Pow_Cubehash512(bench, 128); } +static void Pow_Cubehash512_0512b(benchmark::Bench& bench) { return Pow_Cubehash512(bench, 512); } +static void Pow_Cubehash512_1024b(benchmark::Bench& bench) { return Pow_Cubehash512(bench, 1024); } +static void Pow_Cubehash512_2048b(benchmark::Bench& bench) { return Pow_Cubehash512(bench, 2048); } +static void Pow_Cubehash512_1M(benchmark::Bench& bench) { return Pow_Cubehash512(bench, BUFFER_SIZE); } + +static void Pow_Echo512_0032b(benchmark::Bench& bench) { return Pow_Echo512(bench, 32); } +static void Pow_Echo512_0080b(benchmark::Bench& bench) { return Pow_Echo512(bench, 80); } +static void Pow_Echo512_0128b(benchmark::Bench& bench) { return Pow_Echo512(bench, 128); } +static void Pow_Echo512_0512b(benchmark::Bench& bench) { return Pow_Echo512(bench, 512); } +static void Pow_Echo512_1024b(benchmark::Bench& bench) { return Pow_Echo512(bench, 1024); } +static void Pow_Echo512_2048b(benchmark::Bench& bench) { return Pow_Echo512(bench, 2048); } +static void Pow_Echo512_1M(benchmark::Bench& bench) { return Pow_Echo512(bench, BUFFER_SIZE); } + +static void Pow_Groestl512_0032b(benchmark::Bench& bench) { return Pow_Groestl512(bench, 32); } +static void Pow_Groestl512_0080b(benchmark::Bench& bench) { return Pow_Groestl512(bench, 80); } +static void Pow_Groestl512_0128b(benchmark::Bench& bench) { return Pow_Groestl512(bench, 128); } +static void Pow_Groestl512_0512b(benchmark::Bench& bench) { return Pow_Groestl512(bench, 512); } +static void Pow_Groestl512_1024b(benchmark::Bench& bench) { return Pow_Groestl512(bench, 1024); } +static void Pow_Groestl512_2048b(benchmark::Bench& bench) { return Pow_Groestl512(bench, 2048); } +static void Pow_Groestl512_1M(benchmark::Bench& bench) { return Pow_Groestl512(bench, BUFFER_SIZE); } + +static void Pow_Jh512_0032b(benchmark::Bench& bench) { return Pow_Jh512(bench, 32); } +static void Pow_Jh512_0080b(benchmark::Bench& bench) { return Pow_Jh512(bench, 80); } +static void Pow_Jh512_0128b(benchmark::Bench& bench) { return Pow_Jh512(bench, 128); } +static void Pow_Jh512_0512b(benchmark::Bench& bench) { return Pow_Jh512(bench, 512); } +static void Pow_Jh512_1024b(benchmark::Bench& bench) { return Pow_Jh512(bench, 1024); } +static void Pow_Jh512_2048b(benchmark::Bench& bench) { return Pow_Jh512(bench, 2048); } +static void Pow_Jh512_1M(benchmark::Bench& bench) { return Pow_Jh512(bench, BUFFER_SIZE); } + +static void Pow_Keccak512_0032b(benchmark::Bench& bench) { return Pow_Keccak512(bench, 32); } +static void Pow_Keccak512_0080b(benchmark::Bench& bench) { return Pow_Keccak512(bench, 80); } +static void Pow_Keccak512_0128b(benchmark::Bench& bench) { return Pow_Keccak512(bench, 128); } +static void Pow_Keccak512_0512b(benchmark::Bench& bench) { return Pow_Keccak512(bench, 512); } +static void Pow_Keccak512_1024b(benchmark::Bench& bench) { return Pow_Keccak512(bench, 1024); } +static void Pow_Keccak512_2048b(benchmark::Bench& bench) { return Pow_Keccak512(bench, 2048); } +static void Pow_Keccak512_1M(benchmark::Bench& bench) { return Pow_Keccak512(bench, BUFFER_SIZE); } + +static void Pow_Luffa512_0032b(benchmark::Bench& bench) { return Pow_Luffa512(bench, 32); } +static void Pow_Luffa512_0080b(benchmark::Bench& bench) { return Pow_Luffa512(bench, 80); } +static void Pow_Luffa512_0128b(benchmark::Bench& bench) { return Pow_Luffa512(bench, 128); } +static void Pow_Luffa512_0512b(benchmark::Bench& bench) { return Pow_Luffa512(bench, 512); } +static void Pow_Luffa512_1024b(benchmark::Bench& bench) { return Pow_Luffa512(bench, 1024); } +static void Pow_Luffa512_2048b(benchmark::Bench& bench) { return Pow_Luffa512(bench, 2048); } +static void Pow_Luffa512_1M(benchmark::Bench& bench) { return Pow_Luffa512(bench, BUFFER_SIZE); } + +static void Pow_Shavite512_0032b(benchmark::Bench& bench) { return Pow_Shavite512(bench, 32); } +static void Pow_Shavite512_0080b(benchmark::Bench& bench) { return Pow_Shavite512(bench, 80); } +static void Pow_Shavite512_0128b(benchmark::Bench& bench) { return Pow_Shavite512(bench, 128); } +static void Pow_Shavite512_0512b(benchmark::Bench& bench) { return Pow_Shavite512(bench, 512); } +static void Pow_Shavite512_1024b(benchmark::Bench& bench) { return Pow_Shavite512(bench, 1024); } +static void Pow_Shavite512_2048b(benchmark::Bench& bench) { return Pow_Shavite512(bench, 2048); } +static void Pow_Shavite512_1M(benchmark::Bench& bench) { return Pow_Shavite512(bench, BUFFER_SIZE); } + +static void Pow_Simd512_0032b(benchmark::Bench& bench) { return Pow_Simd512(bench, 32); } +static void Pow_Simd512_0080b(benchmark::Bench& bench) { return Pow_Simd512(bench, 80); } +static void Pow_Simd512_0128b(benchmark::Bench& bench) { return Pow_Simd512(bench, 128); } +static void Pow_Simd512_0512b(benchmark::Bench& bench) { return Pow_Simd512(bench, 512); } +static void Pow_Simd512_1024b(benchmark::Bench& bench) { return Pow_Simd512(bench, 1024); } +static void Pow_Simd512_2048b(benchmark::Bench& bench) { return Pow_Simd512(bench, 2048); } +static void Pow_Simd512_1M(benchmark::Bench& bench) { return Pow_Simd512(bench, BUFFER_SIZE); } + +static void Pow_Skein512_0032b(benchmark::Bench& bench) { return Pow_Skein512(bench, 32); } +static void Pow_Skein512_0080b(benchmark::Bench& bench) { return Pow_Skein512(bench, 80); } +static void Pow_Skein512_0128b(benchmark::Bench& bench) { return Pow_Skein512(bench, 128); } +static void Pow_Skein512_0512b(benchmark::Bench& bench) { return Pow_Skein512(bench, 512); } +static void Pow_Skein512_1024b(benchmark::Bench& bench) { return Pow_Skein512(bench, 1024); } +static void Pow_Skein512_2048b(benchmark::Bench& bench) { return Pow_Skein512(bench, 2048); } +static void Pow_Skein512_1M(benchmark::Bench& bench) { return Pow_Skein512(bench, BUFFER_SIZE); } + +BENCHMARK(Pow_X11_0032b); +BENCHMARK(Pow_X11_0080b); +BENCHMARK(Pow_X11_0128b); +BENCHMARK(Pow_X11_0512b); +BENCHMARK(Pow_X11_1024b); +BENCHMARK(Pow_X11_2048b); +BENCHMARK(Pow_X11_1M); + +BENCHMARK(Pow_Blake512_0032b); +BENCHMARK(Pow_Blake512_0080b); +BENCHMARK(Pow_Blake512_0128b); +BENCHMARK(Pow_Blake512_0512b); +BENCHMARK(Pow_Blake512_1024b); +BENCHMARK(Pow_Blake512_2048b); +BENCHMARK(Pow_Blake512_1M); + +BENCHMARK(Pow_Bmw512_0032b); +BENCHMARK(Pow_Bmw512_0080b); +BENCHMARK(Pow_Bmw512_0128b); +BENCHMARK(Pow_Bmw512_0512b); +BENCHMARK(Pow_Bmw512_1024b); +BENCHMARK(Pow_Bmw512_2048b); +BENCHMARK(Pow_Bmw512_1M); + +BENCHMARK(Pow_Cubehash512_0032b); +BENCHMARK(Pow_Cubehash512_0080b); +BENCHMARK(Pow_Cubehash512_0128b); +BENCHMARK(Pow_Cubehash512_0512b); +BENCHMARK(Pow_Cubehash512_1024b); +BENCHMARK(Pow_Cubehash512_2048b); +BENCHMARK(Pow_Cubehash512_1M); + +BENCHMARK(Pow_Echo512_0032b); +BENCHMARK(Pow_Echo512_0080b); +BENCHMARK(Pow_Echo512_0128b); +BENCHMARK(Pow_Echo512_0512b); +BENCHMARK(Pow_Echo512_1024b); +BENCHMARK(Pow_Echo512_2048b); +BENCHMARK(Pow_Echo512_1M); + +BENCHMARK(Pow_Groestl512_0032b); +BENCHMARK(Pow_Groestl512_0080b); +BENCHMARK(Pow_Groestl512_0128b); +BENCHMARK(Pow_Groestl512_0512b); +BENCHMARK(Pow_Groestl512_1024b); +BENCHMARK(Pow_Groestl512_2048b); +BENCHMARK(Pow_Groestl512_1M); + +BENCHMARK(Pow_Jh512_0032b); +BENCHMARK(Pow_Jh512_0080b); +BENCHMARK(Pow_Jh512_0128b); +BENCHMARK(Pow_Jh512_0512b); +BENCHMARK(Pow_Jh512_1024b); +BENCHMARK(Pow_Jh512_2048b); +BENCHMARK(Pow_Jh512_1M); + +BENCHMARK(Pow_Keccak512_0032b); +BENCHMARK(Pow_Keccak512_0080b); +BENCHMARK(Pow_Keccak512_0128b); +BENCHMARK(Pow_Keccak512_0512b); +BENCHMARK(Pow_Keccak512_1024b); +BENCHMARK(Pow_Keccak512_2048b); +BENCHMARK(Pow_Keccak512_1M); + +BENCHMARK(Pow_Luffa512_0032b); +BENCHMARK(Pow_Luffa512_0080b); +BENCHMARK(Pow_Luffa512_0128b); +BENCHMARK(Pow_Luffa512_0512b); +BENCHMARK(Pow_Luffa512_1024b); +BENCHMARK(Pow_Luffa512_2048b); +BENCHMARK(Pow_Luffa512_1M); + +BENCHMARK(Pow_Shavite512_0032b); +BENCHMARK(Pow_Shavite512_0080b); +BENCHMARK(Pow_Shavite512_0128b); +BENCHMARK(Pow_Shavite512_0512b); +BENCHMARK(Pow_Shavite512_1024b); +BENCHMARK(Pow_Shavite512_2048b); +BENCHMARK(Pow_Shavite512_1M); + +BENCHMARK(Pow_Simd512_0032b); +BENCHMARK(Pow_Simd512_0080b); +BENCHMARK(Pow_Simd512_0128b); +BENCHMARK(Pow_Simd512_0512b); +BENCHMARK(Pow_Simd512_1024b); +BENCHMARK(Pow_Simd512_2048b); +BENCHMARK(Pow_Simd512_1M); + +BENCHMARK(Pow_Skein512_0032b); +BENCHMARK(Pow_Skein512_0080b); +BENCHMARK(Pow_Skein512_0128b); +BENCHMARK(Pow_Skein512_0512b); +BENCHMARK(Pow_Skein512_1024b); +BENCHMARK(Pow_Skein512_2048b); +BENCHMARK(Pow_Skein512_1M); diff --git a/src/crypto/x11/blake.c b/src/crypto/x11/blake.c index c7624cfdfb8d..cdd4589974d2 100644 --- a/src/crypto/x11/blake.c +++ b/src/crypto/x11/blake.c @@ -43,7 +43,7 @@ extern "C"{ #define SPH_SMALL_FOOTPRINT_BLAKE 1 #endif -#if SPH_64 && (SPH_SMALL_FOOTPRINT_BLAKE || !SPH_64_TRUE) +#if SPH_SMALL_FOOTPRINT_BLAKE #define SPH_COMPACT_BLAKE_64 1 #endif @@ -51,8 +51,6 @@ extern "C"{ #pragma warning (disable: 4146) #endif -#if SPH_64 - static const sph_u64 IV512[8] = { SPH_C64(0x6A09E667F3BCC908), SPH_C64(0xBB67AE8584CAA73B), SPH_C64(0x3C6EF372FE94F82B), SPH_C64(0xA54FF53A5F1D36F1), @@ -60,8 +58,6 @@ static const sph_u64 IV512[8] = { SPH_C64(0x1F83D9ABFB41BD6B), SPH_C64(0x5BE0CD19137E2179) }; -#endif - #if SPH_COMPACT_BLAKE_64 static const unsigned sigma[16][16] = { @@ -271,8 +267,6 @@ static const unsigned sigma[16][16] = { #define Mx_(n) Mx__(n) #define Mx__(n) M ## n -#if SPH_64 - #define CBx(r, i) CBx_(Z ## r ## i) #define CBx_(n) CBx__(n) #define CBx__(n) CB ## n @@ -309,10 +303,6 @@ static const sph_u64 CB[16] = { #endif -#endif - -#if SPH_64 - #define GB(m0, m1, c0, c1, a, b, c, d) do { \ a = SPH_T64(a + b + (m0 ^ c1)); \ d = SPH_ROTR64(d ^ a, 32); \ @@ -360,10 +350,6 @@ static const sph_u64 CB[16] = { #endif -#endif - -#if SPH_64 - #define DECL_STATE64 \ sph_u64 H0, H1, H2, H3, H4, H5, H6, H7; \ sph_u64 S0, S1, S2, S3, T0, T1; @@ -520,10 +506,6 @@ static const sph_u64 CB[16] = { #endif -#endif - -#if SPH_64 - static const sph_u64 salt_zero_big[4] = { 0, 0, 0, 0 }; static void @@ -627,10 +609,6 @@ blake64_close(sph_blake_big_context *sc, sph_enc64be(out + (k << 3), sc->H[k]); } -#endif - -#if SPH_64 - /* see sph_blake.h */ void sph_blake512_init(void *cc) @@ -660,8 +638,6 @@ sph_blake512_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst) sph_blake512_init(cc); } -#endif - #ifdef __cplusplus } #endif diff --git a/src/crypto/x11/bmw.c b/src/crypto/x11/bmw.c index 26134c7966f9..5a7455d18587 100644 --- a/src/crypto/x11/bmw.c +++ b/src/crypto/x11/bmw.c @@ -47,8 +47,6 @@ extern "C"{ #pragma warning (disable: 4146) #endif -#if SPH_64 - static const sph_u64 IV512[] = { SPH_C64(0x8081828384858687), SPH_C64(0x88898A8B8C8D8E8F), SPH_C64(0x9091929394959697), SPH_C64(0x98999A9B9C9D9E9F), @@ -60,11 +58,6 @@ static const sph_u64 IV512[] = { SPH_C64(0xF0F1F2F3F4F5F6F7), SPH_C64(0xF8F9FAFBFCFDFEFF) }; -#endif - -#define XCAT(x, y) XCAT_(x, y) -#define XCAT_(x, y) x ## y - #define LPAR ( #define I16_16 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 @@ -125,38 +118,6 @@ static const sph_u64 IV512[] = { (SPH_T32(SPH_ROTL32(mf(j0m), j1m) + SPH_ROTL32(mf(j3m), j4m) \ - SPH_ROTL32(mf(j10m), j11m) + Ks(j16)) ^ hf(j7m)) -#define expand1s_inner(qf, mf, hf, i16, \ - i0, i1, i2, i3, i4, i5, i6, i7, i8, \ - i9, i10, i11, i12, i13, i14, i15, \ - i0m, i1m, i3m, i4m, i7m, i10m, i11m) \ - SPH_T32(ss1(qf(i0)) + ss2(qf(i1)) + ss3(qf(i2)) + ss0(qf(i3)) \ - + ss1(qf(i4)) + ss2(qf(i5)) + ss3(qf(i6)) + ss0(qf(i7)) \ - + ss1(qf(i8)) + ss2(qf(i9)) + ss3(qf(i10)) + ss0(qf(i11)) \ - + ss1(qf(i12)) + ss2(qf(i13)) + ss3(qf(i14)) + ss0(qf(i15)) \ - + add_elt_s(mf, hf, i0m, i1m, i3m, i4m, i7m, i10m, i11m, i16)) - -#define expand1s(qf, mf, hf, i16) \ - expand1s_(qf, mf, hf, i16, I16_ ## i16, M16_ ## i16) -#define expand1s_(qf, mf, hf, i16, ix, iy) \ - expand1s_inner LPAR qf, mf, hf, i16, ix, iy) - -#define expand2s_inner(qf, mf, hf, i16, \ - i0, i1, i2, i3, i4, i5, i6, i7, i8, \ - i9, i10, i11, i12, i13, i14, i15, \ - i0m, i1m, i3m, i4m, i7m, i10m, i11m) \ - SPH_T32(qf(i0) + rs1(qf(i1)) + qf(i2) + rs2(qf(i3)) \ - + qf(i4) + rs3(qf(i5)) + qf(i6) + rs4(qf(i7)) \ - + qf(i8) + rs5(qf(i9)) + qf(i10) + rs6(qf(i11)) \ - + qf(i12) + rs7(qf(i13)) + ss4(qf(i14)) + ss5(qf(i15)) \ - + add_elt_s(mf, hf, i0m, i1m, i3m, i4m, i7m, i10m, i11m, i16)) - -#define expand2s(qf, mf, hf, i16) \ - expand2s_(qf, mf, hf, i16, I16_ ## i16, M16_ ## i16) -#define expand2s_(qf, mf, hf, i16, ix, iy) \ - expand2s_inner LPAR qf, mf, hf, i16, ix, iy) - -#if SPH_64 - #define sb0(x) (((x) >> 1) ^ SPH_T64((x) << 3) \ ^ SPH_ROTL64(x, 4) ^ SPH_ROTL64(x, 37)) #define sb1(x) (((x) >> 1) ^ SPH_T64((x) << 2) \ @@ -251,14 +212,10 @@ static const sph_u64 Kb_tab[] = { #endif -#endif - #define MAKE_W(tt, i0, op01, i1, op12, i2, op23, i3, op34, i4) \ tt((M(i0) ^ H(i0)) op01 (M(i1) ^ H(i1)) op12 (M(i2) ^ H(i2)) \ op23 (M(i3) ^ H(i3)) op34 (M(i4) ^ H(i4))) -#if SPH_64 - #define Wb0 MAKE_W(SPH_T64, 5, -, 7, +, 10, +, 13, +, 14) #define Wb1 MAKE_W(SPH_T64, 6, -, 8, +, 11, +, 14, -, 15) #define Wb2 MAKE_W(SPH_T64, 0, +, 7, +, 9, -, 12, +, 15) @@ -364,8 +321,6 @@ static const sph_u64 Kb_tab[] = { #define Qb(j) (qt[j]) -#endif - #define FOLD(type, mkQ, tt, rol, mf, qf, dhf) do { \ type qt[32], xl, xh; \ mkQ; \ @@ -407,14 +362,8 @@ static const sph_u64 Kb_tab[] = { + ((xl >> 2) ^ qf(22) ^ qf(15))); \ } while (0) -#if SPH_64 - #define FOLDb FOLD(sph_u64, MAKE_Qb, SPH_T64, SPH_ROTL64, M, Qb, dH) -#endif - -#if SPH_64 - static void compress_big(const unsigned char *data, const sph_u64 h[16], sph_u64 dh[16]) { @@ -540,10 +489,6 @@ bmw64_close(sph_bmw_big_context *sc, unsigned ub, unsigned n, sph_enc64le(out + 8 * u, h1[v]); } -#endif - -#if SPH_64 - /* see sph_bmw.h */ void sph_bmw512_init(void *cc) @@ -573,8 +518,6 @@ sph_bmw512_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst) sph_bmw512_init(cc); } -#endif - #ifdef __cplusplus } #endif diff --git a/src/crypto/x11/echo.c b/src/crypto/x11/echo.c index f0c95f08ab95..ab531bdca5cf 100644 --- a/src/crypto/x11/echo.c +++ b/src/crypto/x11/echo.c @@ -43,36 +43,18 @@ extern "C"{ #define SPH_SMALL_FOOTPRINT_ECHO 1 #endif -/* - * Some measures tend to show that the 64-bit implementation offers - * better performance only on a "64-bit architectures", those which have - * actual 64-bit registers. - */ -#if !defined SPH_ECHO_64 && SPH_64_TRUE -#define SPH_ECHO_64 1 -#endif - /* * We can use a 64-bit implementation only if a 64-bit type is available. */ -#if !SPH_64 -#undef SPH_ECHO_64 -#endif - #ifdef _MSC_VER #pragma warning (disable: 4146) #endif #define T32 SPH_T32 -#define C32 SPH_C32 -#if SPH_64 #define C64 SPH_C64 -#endif #include "aes_helper.c" -#if SPH_ECHO_64 - #define DECL_STATE_BIG \ sph_u64 W[16][2]; @@ -300,253 +282,6 @@ mix_column(sph_u64 W[16][2], int ia, int ib, int ic, int id) FINAL_BIG; \ } while (0) -#else - -#define DECL_STATE_BIG \ - sph_u32 W[16][4]; - -#define INPUT_BLOCK_BIG(sc) do { \ - unsigned u; \ - memcpy(W, sc->u.Vs, 32 * sizeof(sph_u32)); \ - for (u = 0; u < 8; u ++) { \ - W[u + 8][0] = sph_dec32le_aligned( \ - sc->buf + 16 * u); \ - W[u + 8][1] = sph_dec32le_aligned( \ - sc->buf + 16 * u + 4); \ - W[u + 8][2] = sph_dec32le_aligned( \ - sc->buf + 16 * u + 8); \ - W[u + 8][3] = sph_dec32le_aligned( \ - sc->buf + 16 * u + 12); \ - } \ - } while (0) - -#if SPH_SMALL_FOOTPRINT_ECHO - -static void -aes_2rounds_all(sph_u32 W[16][4], - sph_u32 *pK0, sph_u32 *pK1, sph_u32 *pK2, sph_u32 *pK3) -{ - int n; - sph_u32 K0 = *pK0; - sph_u32 K1 = *pK1; - sph_u32 K2 = *pK2; - sph_u32 K3 = *pK3; - - for (n = 0; n < 16; n ++) { - sph_u32 *X = W[n]; - sph_u32 Y0, Y1, Y2, Y3; - AES_ROUND_LE(X[0], X[1], X[2], X[3], - K0, K1, K2, K3, Y0, Y1, Y2, Y3); - AES_ROUND_NOKEY_LE(Y0, Y1, Y2, Y3, X[0], X[1], X[2], X[3]); - if ((K0 = T32(K0 + 1)) == 0) { - if ((K1 = T32(K1 + 1)) == 0) - if ((K2 = T32(K2 + 1)) == 0) - K3 = T32(K3 + 1); - } - } - *pK0 = K0; - *pK1 = K1; - *pK2 = K2; - *pK3 = K3; -} - -#define BIG_SUB_WORDS do { \ - aes_2rounds_all(W, &K0, &K1, &K2, &K3); \ - } while (0) - -#else - -#define AES_2ROUNDS(X) do { \ - sph_u32 Y0, Y1, Y2, Y3; \ - AES_ROUND_LE(X[0], X[1], X[2], X[3], \ - K0, K1, K2, K3, Y0, Y1, Y2, Y3); \ - AES_ROUND_NOKEY_LE(Y0, Y1, Y2, Y3, X[0], X[1], X[2], X[3]); \ - if ((K0 = T32(K0 + 1)) == 0) { \ - if ((K1 = T32(K1 + 1)) == 0) \ - if ((K2 = T32(K2 + 1)) == 0) \ - K3 = T32(K3 + 1); \ - } \ - } while (0) - -#define BIG_SUB_WORDS do { \ - AES_2ROUNDS(W[ 0]); \ - AES_2ROUNDS(W[ 1]); \ - AES_2ROUNDS(W[ 2]); \ - AES_2ROUNDS(W[ 3]); \ - AES_2ROUNDS(W[ 4]); \ - AES_2ROUNDS(W[ 5]); \ - AES_2ROUNDS(W[ 6]); \ - AES_2ROUNDS(W[ 7]); \ - AES_2ROUNDS(W[ 8]); \ - AES_2ROUNDS(W[ 9]); \ - AES_2ROUNDS(W[10]); \ - AES_2ROUNDS(W[11]); \ - AES_2ROUNDS(W[12]); \ - AES_2ROUNDS(W[13]); \ - AES_2ROUNDS(W[14]); \ - AES_2ROUNDS(W[15]); \ - } while (0) - -#endif - -#define SHIFT_ROW1(a, b, c, d) do { \ - sph_u32 tmp; \ - tmp = W[a][0]; \ - W[a][0] = W[b][0]; \ - W[b][0] = W[c][0]; \ - W[c][0] = W[d][0]; \ - W[d][0] = tmp; \ - tmp = W[a][1]; \ - W[a][1] = W[b][1]; \ - W[b][1] = W[c][1]; \ - W[c][1] = W[d][1]; \ - W[d][1] = tmp; \ - tmp = W[a][2]; \ - W[a][2] = W[b][2]; \ - W[b][2] = W[c][2]; \ - W[c][2] = W[d][2]; \ - W[d][2] = tmp; \ - tmp = W[a][3]; \ - W[a][3] = W[b][3]; \ - W[b][3] = W[c][3]; \ - W[c][3] = W[d][3]; \ - W[d][3] = tmp; \ - } while (0) - -#define SHIFT_ROW2(a, b, c, d) do { \ - sph_u32 tmp; \ - tmp = W[a][0]; \ - W[a][0] = W[c][0]; \ - W[c][0] = tmp; \ - tmp = W[b][0]; \ - W[b][0] = W[d][0]; \ - W[d][0] = tmp; \ - tmp = W[a][1]; \ - W[a][1] = W[c][1]; \ - W[c][1] = tmp; \ - tmp = W[b][1]; \ - W[b][1] = W[d][1]; \ - W[d][1] = tmp; \ - tmp = W[a][2]; \ - W[a][2] = W[c][2]; \ - W[c][2] = tmp; \ - tmp = W[b][2]; \ - W[b][2] = W[d][2]; \ - W[d][2] = tmp; \ - tmp = W[a][3]; \ - W[a][3] = W[c][3]; \ - W[c][3] = tmp; \ - tmp = W[b][3]; \ - W[b][3] = W[d][3]; \ - W[d][3] = tmp; \ - } while (0) - -#define SHIFT_ROW3(a, b, c, d) SHIFT_ROW1(d, c, b, a) - -#define BIG_SHIFT_ROWS do { \ - SHIFT_ROW1(1, 5, 9, 13); \ - SHIFT_ROW2(2, 6, 10, 14); \ - SHIFT_ROW3(3, 7, 11, 15); \ - } while (0) - -#if SPH_SMALL_FOOTPRINT_ECHO - -static void -mix_column(sph_u32 W[16][4], int ia, int ib, int ic, int id) -{ - int n; - - for (n = 0; n < 4; n ++) { - sph_u32 a = W[ia][n]; - sph_u32 b = W[ib][n]; - sph_u32 c = W[ic][n]; - sph_u32 d = W[id][n]; - sph_u32 ab = a ^ b; - sph_u32 bc = b ^ c; - sph_u32 cd = c ^ d; - sph_u32 abx = ((ab & C32(0x80808080)) >> 7) * 27U - ^ ((ab & C32(0x7F7F7F7F)) << 1); - sph_u32 bcx = ((bc & C32(0x80808080)) >> 7) * 27U - ^ ((bc & C32(0x7F7F7F7F)) << 1); - sph_u32 cdx = ((cd & C32(0x80808080)) >> 7) * 27U - ^ ((cd & C32(0x7F7F7F7F)) << 1); - W[ia][n] = abx ^ bc ^ d; - W[ib][n] = bcx ^ a ^ cd; - W[ic][n] = cdx ^ ab ^ d; - W[id][n] = abx ^ bcx ^ cdx ^ ab ^ c; - } -} - -#define MIX_COLUMN(a, b, c, d) mix_column(W, a, b, c, d) - -#else - -#define MIX_COLUMN1(ia, ib, ic, id, n) do { \ - sph_u32 a = W[ia][n]; \ - sph_u32 b = W[ib][n]; \ - sph_u32 c = W[ic][n]; \ - sph_u32 d = W[id][n]; \ - sph_u32 ab = a ^ b; \ - sph_u32 bc = b ^ c; \ - sph_u32 cd = c ^ d; \ - sph_u32 abx = ((ab & C32(0x80808080)) >> 7) * 27U \ - ^ ((ab & C32(0x7F7F7F7F)) << 1); \ - sph_u32 bcx = ((bc & C32(0x80808080)) >> 7) * 27U \ - ^ ((bc & C32(0x7F7F7F7F)) << 1); \ - sph_u32 cdx = ((cd & C32(0x80808080)) >> 7) * 27U \ - ^ ((cd & C32(0x7F7F7F7F)) << 1); \ - W[ia][n] = abx ^ bc ^ d; \ - W[ib][n] = bcx ^ a ^ cd; \ - W[ic][n] = cdx ^ ab ^ d; \ - W[id][n] = abx ^ bcx ^ cdx ^ ab ^ c; \ - } while (0) - -#define MIX_COLUMN(a, b, c, d) do { \ - MIX_COLUMN1(a, b, c, d, 0); \ - MIX_COLUMN1(a, b, c, d, 1); \ - MIX_COLUMN1(a, b, c, d, 2); \ - MIX_COLUMN1(a, b, c, d, 3); \ - } while (0) - -#endif - -#define BIG_MIX_COLUMNS do { \ - MIX_COLUMN(0, 1, 2, 3); \ - MIX_COLUMN(4, 5, 6, 7); \ - MIX_COLUMN(8, 9, 10, 11); \ - MIX_COLUMN(12, 13, 14, 15); \ - } while (0) - -#define BIG_ROUND do { \ - BIG_SUB_WORDS; \ - BIG_SHIFT_ROWS; \ - BIG_MIX_COLUMNS; \ - } while (0) - -#define FINAL_BIG do { \ - unsigned u; \ - sph_u32 *VV = &sc->u.Vs[0][0]; \ - sph_u32 *WW = &W[0][0]; \ - for (u = 0; u < 32; u ++) { \ - VV[u] ^= sph_dec32le_aligned(sc->buf + (u * 4)) \ - ^ WW[u] ^ WW[u + 32]; \ - } \ - } while (0) - -#define COMPRESS_BIG(sc) do { \ - sph_u32 K0 = sc->C0; \ - sph_u32 K1 = sc->C1; \ - sph_u32 K2 = sc->C2; \ - sph_u32 K3 = sc->C3; \ - unsigned u; \ - INPUT_BLOCK_BIG(sc); \ - for (u = 0; u < 10; u ++) { \ - BIG_ROUND; \ - } \ - FINAL_BIG; \ - } while (0) - -#endif #define INCR_COUNTER(sc, val) do { \ sc->C0 = T32(sc->C0 + (sph_u32)(val)); \ @@ -560,7 +295,6 @@ mix_column(sph_u32 W[16][4], int ia, int ib, int ic, int id) static void echo_big_init(sph_echo_big_context *sc, unsigned out_len) { -#if SPH_ECHO_64 sc->u.Vb[0][0] = (sph_u64)out_len; sc->u.Vb[0][1] = 0; sc->u.Vb[1][0] = (sph_u64)out_len; @@ -577,24 +311,6 @@ echo_big_init(sph_echo_big_context *sc, unsigned out_len) sc->u.Vb[6][1] = 0; sc->u.Vb[7][0] = (sph_u64)out_len; sc->u.Vb[7][1] = 0; -#else - sc->u.Vs[0][0] = (sph_u32)out_len; - sc->u.Vs[0][1] = sc->u.Vs[0][2] = sc->u.Vs[0][3] = 0; - sc->u.Vs[1][0] = (sph_u32)out_len; - sc->u.Vs[1][1] = sc->u.Vs[1][2] = sc->u.Vs[1][3] = 0; - sc->u.Vs[2][0] = (sph_u32)out_len; - sc->u.Vs[2][1] = sc->u.Vs[2][2] = sc->u.Vs[2][3] = 0; - sc->u.Vs[3][0] = (sph_u32)out_len; - sc->u.Vs[3][1] = sc->u.Vs[3][2] = sc->u.Vs[3][3] = 0; - sc->u.Vs[4][0] = (sph_u32)out_len; - sc->u.Vs[4][1] = sc->u.Vs[4][2] = sc->u.Vs[4][3] = 0; - sc->u.Vs[5][0] = (sph_u32)out_len; - sc->u.Vs[5][1] = sc->u.Vs[5][2] = sc->u.Vs[5][3] = 0; - sc->u.Vs[6][0] = (sph_u32)out_len; - sc->u.Vs[6][1] = sc->u.Vs[6][2] = sc->u.Vs[6][3] = 0; - sc->u.Vs[7][0] = (sph_u32)out_len; - sc->u.Vs[7][1] = sc->u.Vs[7][2] = sc->u.Vs[7][3] = 0; -#endif sc->ptr = 0; sc->C0 = sc->C1 = sc->C2 = sc->C3 = 0; } @@ -653,15 +369,9 @@ echo_big_close(sph_echo_big_context *sc, unsigned ub, unsigned n, union { unsigned char tmp[64]; sph_u32 dummy; -#if SPH_ECHO_64 sph_u64 dummy2; -#endif } u; -#if SPH_ECHO_64 sph_u64 *VV; -#else - sph_u32 *VV; -#endif unsigned k; buf = sc->buf; @@ -690,13 +400,8 @@ echo_big_close(sph_echo_big_context *sc, unsigned ub, unsigned n, sph_enc16le(buf + (sizeof sc->buf) - 18, out_size_w32 << 5); memcpy(buf + (sizeof sc->buf) - 16, u.tmp, 16); echo_big_compress(sc); -#if SPH_ECHO_64 for (VV = &sc->u.Vb[0][0], k = 0; k < ((out_size_w32 + 1) >> 1); k ++) sph_enc64le_aligned(u.tmp + (k << 3), VV[k]); -#else - for (VV = &sc->u.Vs[0][0], k = 0; k < out_size_w32; k ++) - sph_enc32le_aligned(u.tmp + (k << 2), VV[k]); -#endif memcpy(dst, u.tmp, out_size_w32 << 2); echo_big_init(sc, out_size_w32 << 5); } diff --git a/src/crypto/x11/groestl.c b/src/crypto/x11/groestl.c index b010e456e73b..24c31c340949 100644 --- a/src/crypto/x11/groestl.c +++ b/src/crypto/x11/groestl.c @@ -43,22 +43,6 @@ extern "C"{ #define SPH_SMALL_FOOTPRINT_GROESTL 1 #endif -/* - * Apparently, the 32-bit-only version is not faster than the 64-bit - * version unless using the "small footprint" code on a 32-bit machine. - */ -#if !defined SPH_GROESTL_64 -#if SPH_SMALL_FOOTPRINT_GROESTL && !SPH_64_TRUE -#define SPH_GROESTL_64 0 -#else -#define SPH_GROESTL_64 1 -#endif -#endif - -#if !SPH_64 -#undef SPH_GROESTL_64 -#endif - #ifdef _MSC_VER #pragma warning (disable: 4146) #endif @@ -85,7 +69,6 @@ extern "C"{ | ((SPH_C32(x) << 8) & SPH_C32(0x00FF0000)) \ | ((SPH_C32(x) << 24) & SPH_C32(0xFF000000))) #define dec32e_aligned sph_dec32le_aligned -#define enc32e sph_enc32le #define B32_0(x) ((x) & 0xFF) #define B32_1(x) (((x) >> 8) & 0xFF) #define B32_2(x) (((x) >> 16) & 0xFF) @@ -99,7 +82,6 @@ extern "C"{ #define QC32up(j, r) SPH_C32(0xFFFFFFFF) #define QC32dn(j, r) (((sph_u32)(r) << 24) ^ SPH_T32(~((sph_u32)(j) << 24))) -#if SPH_64 #define C64e(x) ((SPH_C64(x) >> 56) \ | ((SPH_C64(x) >> 40) & SPH_C64(0x000000000000FF00)) \ | ((SPH_C64(x) >> 24) & SPH_C64(0x0000000000FF0000)) \ @@ -121,13 +103,11 @@ extern "C"{ #define R64 SPH_ROTL64 #define PC64(j, r) ((sph_u64)((j) + (r))) #define QC64(j, r) (((sph_u64)(r) << 56) ^ SPH_T64(~((sph_u64)(j) << 56))) -#endif #else #define C32e(x) SPH_C32(x) #define dec32e_aligned sph_dec32be_aligned -#define enc32e sph_enc32be #define B32_0(x) ((x) >> 24) #define B32_1(x) (((x) >> 16) & 0xFF) #define B32_2(x) (((x) >> 8) & 0xFF) @@ -141,7 +121,6 @@ extern "C"{ #define QC32up(j, r) SPH_C32(0xFFFFFFFF) #define QC32dn(j, r) ((sph_u32)(r) ^ SPH_T32(~(sph_u32)(j))) -#if SPH_64 #define C64e(x) SPH_C64(x) #define dec64e_aligned sph_dec64be_aligned #define enc64e sph_enc64be @@ -156,12 +135,9 @@ extern "C"{ #define R64 SPH_ROTR64 #define PC64(j, r) ((sph_u64)((j) + (r)) << 56) #define QC64(j, r) ((sph_u64)(r) ^ SPH_T64(~(sph_u64)(j))) -#endif #endif -#if SPH_GROESTL_64 - static const sph_u64 T0[] = { C64e(0xc632f4a5f497a5c6), C64e(0xf86f978497eb84f8), C64e(0xee5eb099b0c799ee), C64e(0xf67a8c8d8cf78df6), @@ -688,8 +664,6 @@ static const sph_u64 T3[] = { C64e(0xdad66d6d0c61d661), C64e(0x583a2c2c624e3a4e) }; -#endif - static const sph_u64 T4[] = { C64e(0xf497a5c6c632f4a5), C64e(0x97eb84f8f86f9784), C64e(0xb0c799eeee5eb099), C64e(0x8cf78df6f67a8c8d), @@ -1218,34 +1192,6 @@ static const sph_u64 T7[] = { #endif -#if SPH_SMALL_FOOTPRINT_GROESTL - -#define RSTT(d, a, b0, b1, b2, b3, b4, b5, b6, b7) do { \ - t[d] = T0[B64_0(a[b0])] \ - ^ R64(T0[B64_1(a[b1])], 8) \ - ^ R64(T0[B64_2(a[b2])], 16) \ - ^ R64(T0[B64_3(a[b3])], 24) \ - ^ T4[B64_4(a[b4])] \ - ^ R64(T4[B64_5(a[b5])], 8) \ - ^ R64(T4[B64_6(a[b6])], 16) \ - ^ R64(T4[B64_7(a[b7])], 24); \ - } while (0) - -#else - -#define RSTT(d, a, b0, b1, b2, b3, b4, b5, b6, b7) do { \ - t[d] = T0[B64_0(a[b0])] \ - ^ T1[B64_1(a[b1])] \ - ^ T2[B64_2(a[b2])] \ - ^ T3[B64_3(a[b3])] \ - ^ T4[B64_4(a[b4])] \ - ^ T5[B64_5(a[b5])] \ - ^ T6[B64_6(a[b6])] \ - ^ T7[B64_7(a[b7])]; \ - } while (0) - -#endif - #define DECL_STATE_BIG \ sph_u64 H[16]; @@ -2044,28 +1990,6 @@ static const sph_u32 T3dn[] = { C32e(0x3d46cb46), C32e(0xb71ffc1f), C32e(0x0c61d661), C32e(0x624e3a4e) }; -#define XCAT(x, y) XCAT_(x, y) -#define XCAT_(x, y) x ## y - -#define RSTT(d0, d1, a, b0, b1, b2, b3, b4, b5, b6, b7) do { \ - t[d0] = T0up[B32_0(a[b0])] \ - ^ T1up[B32_1(a[b1])] \ - ^ T2up[B32_2(a[b2])] \ - ^ T3up[B32_3(a[b3])] \ - ^ T0dn[B32_0(a[b4])] \ - ^ T1dn[B32_1(a[b5])] \ - ^ T2dn[B32_2(a[b6])] \ - ^ T3dn[B32_3(a[b7])]; \ - t[d1] = T0dn[B32_0(a[b0])] \ - ^ T1dn[B32_1(a[b1])] \ - ^ T2dn[B32_2(a[b2])] \ - ^ T3dn[B32_3(a[b3])] \ - ^ T0up[B32_0(a[b4])] \ - ^ T1up[B32_1(a[b5])] \ - ^ T2up[B32_2(a[b6])] \ - ^ T3up[B32_3(a[b7])]; \ - } while (0) - #define DECL_STATE_BIG \ sph_u32 H[32]; @@ -2457,7 +2381,6 @@ groestl_big_init(sph_groestl_big_context *sc, unsigned out_size) size_t u; sc->ptr = 0; -#if SPH_GROESTL_64 for (u = 0; u < 15; u ++) sc->state.wide[u] = 0; #if USE_LE @@ -2466,22 +2389,7 @@ groestl_big_init(sph_groestl_big_context *sc, unsigned out_size) #else sc->state.wide[15] = (sph_u64)out_size; #endif -#else - for (u = 0; u < 31; u ++) - sc->state.narrow[u] = 0; -#if USE_LE - sc->state.narrow[31] = ((sph_u32)(out_size & 0xFF) << 24) - | ((sph_u32)(out_size & 0xFF00) << 8); -#else - sc->state.narrow[31] = (sph_u32)out_size; -#endif -#endif -#if SPH_64 sc->count = 0; -#else - sc->count_high = 0; - sc->count_low = 0; -#endif } static void @@ -2513,12 +2421,7 @@ groestl_big_core(sph_groestl_big_context *sc, const void *data, size_t len) len -= clen; if (ptr == sizeof sc->buf) { COMPRESS_BIG; -#if SPH_64 sc->count ++; -#else - if ((sc->count_low = SPH_T32(sc->count_low + 1)) == 0) - sc->count_high = SPH_T32(sc->count_high + 1); -#endif ptr = 0; } } @@ -2533,11 +2436,7 @@ groestl_big_close(sph_groestl_big_context *sc, unsigned char *buf; unsigned char pad[136]; size_t ptr, pad_len, u; -#if SPH_64 sph_u64 count; -#else - sph_u32 count_high, count_low; -#endif unsigned z; DECL_STATE_BIG @@ -2547,42 +2446,18 @@ groestl_big_close(sph_groestl_big_context *sc, pad[0] = ((ub & -z) | z) & 0xFF; if (ptr < 120) { pad_len = 128 - ptr; -#if SPH_64 count = SPH_T64(sc->count + 1); -#else - count_low = SPH_T32(sc->count_low + 1); - count_high = SPH_T32(sc->count_high); - if (count_low == 0) - count_high = SPH_T32(count_high + 1); -#endif } else { pad_len = 256 - ptr; -#if SPH_64 count = SPH_T64(sc->count + 2); -#else - count_low = SPH_T32(sc->count_low + 2); - count_high = SPH_T32(sc->count_high); - if (count_low <= 1) - count_high = SPH_T32(count_high + 1); -#endif } memset(pad + 1, 0, pad_len - 9); -#if SPH_64 sph_enc64be(pad + pad_len - 8, count); -#else - sph_enc64be(pad + pad_len - 8, count_high); - sph_enc64be(pad + pad_len - 4, count_low); -#endif groestl_big_core(sc, pad, pad_len); READ_STATE_BIG(sc); FINAL_BIG; -#if SPH_GROESTL_64 for (u = 0; u < 8; u ++) enc64e(pad + (u << 3), H[u + 8]); -#else - for (u = 0; u < 16; u ++) - enc32e(pad + (u << 2), H[u + 16]); -#endif memcpy(dst, pad + 64 - out_len, out_len); groestl_big_init(sc, (unsigned)out_len << 3); } diff --git a/src/crypto/x11/jh.c b/src/crypto/x11/jh.c index 6f9136873bd2..85002c7481f3 100644 --- a/src/crypto/x11/jh.c +++ b/src/crypto/x11/jh.c @@ -44,14 +44,6 @@ extern "C"{ #define SPH_SMALL_FOOTPRINT_JH 1 #endif -#if !defined SPH_JH_64 && SPH_64_TRUE -#define SPH_JH_64 1 -#endif - -#if !SPH_64 -#undef SPH_JH_64 -#endif - #ifdef _MSC_VER #pragma warning (disable: 4146) #endif @@ -67,14 +59,6 @@ extern "C"{ #if SPH_LITTLE_ENDIAN -#define C32e(x) ((SPH_C32(x) >> 24) \ - | ((SPH_C32(x) >> 8) & SPH_C32(0x0000FF00)) \ - | ((SPH_C32(x) << 8) & SPH_C32(0x00FF0000)) \ - | ((SPH_C32(x) << 24) & SPH_C32(0xFF000000))) -#define dec32e_aligned sph_dec32le_aligned -#define enc32e sph_enc32le - -#if SPH_64 #define C64e(x) ((SPH_C64(x) >> 56) \ | ((SPH_C64(x) >> 40) & SPH_C64(0x000000000000FF00)) \ | ((SPH_C64(x) >> 24) & SPH_C64(0x0000000000FF0000)) \ @@ -85,18 +69,12 @@ extern "C"{ | ((SPH_C64(x) << 56) & SPH_C64(0xFF00000000000000))) #define dec64e_aligned sph_dec64le_aligned #define enc64e sph_enc64le -#endif #else -#define C32e(x) SPH_C32(x) -#define dec32e_aligned sph_dec32be_aligned -#define enc32e sph_enc32be -#if SPH_64 #define C64e(x) SPH_C64(x) #define dec64e_aligned sph_dec64be_aligned #define enc64e sph_enc64be -#endif #endif @@ -125,8 +103,6 @@ extern "C"{ x3 ^= x4; \ } while (0) -#if SPH_JH_64 - static const sph_u64 C[] = { C64e(0x72d5dea2df15f867), C64e(0x7b84150ab7231557), C64e(0x81abd6904d5a87f6), C64e(0x4e9f4fc5c3d12b40), @@ -332,325 +308,6 @@ static const sph_u64 IV512[] = { C64e(0xe3c2fcdfe68517fb), C64e(0x545a4678cc8cdd4b) }; -#else - -static const sph_u32 C[] = { - C32e(0x72d5dea2), C32e(0xdf15f867), C32e(0x7b84150a), - C32e(0xb7231557), C32e(0x81abd690), C32e(0x4d5a87f6), - C32e(0x4e9f4fc5), C32e(0xc3d12b40), C32e(0xea983ae0), - C32e(0x5c45fa9c), C32e(0x03c5d299), C32e(0x66b2999a), - C32e(0x660296b4), C32e(0xf2bb538a), C32e(0xb556141a), - C32e(0x88dba231), C32e(0x03a35a5c), C32e(0x9a190edb), - C32e(0x403fb20a), C32e(0x87c14410), C32e(0x1c051980), - C32e(0x849e951d), C32e(0x6f33ebad), C32e(0x5ee7cddc), - C32e(0x10ba1392), C32e(0x02bf6b41), C32e(0xdc786515), - C32e(0xf7bb27d0), C32e(0x0a2c8139), C32e(0x37aa7850), - C32e(0x3f1abfd2), C32e(0x410091d3), C32e(0x422d5a0d), - C32e(0xf6cc7e90), C32e(0xdd629f9c), C32e(0x92c097ce), - C32e(0x185ca70b), C32e(0xc72b44ac), C32e(0xd1df65d6), - C32e(0x63c6fc23), C32e(0x976e6c03), C32e(0x9ee0b81a), - C32e(0x2105457e), C32e(0x446ceca8), C32e(0xeef103bb), - C32e(0x5d8e61fa), C32e(0xfd9697b2), C32e(0x94838197), - C32e(0x4a8e8537), C32e(0xdb03302f), C32e(0x2a678d2d), - C32e(0xfb9f6a95), C32e(0x8afe7381), C32e(0xf8b8696c), - C32e(0x8ac77246), C32e(0xc07f4214), C32e(0xc5f4158f), - C32e(0xbdc75ec4), C32e(0x75446fa7), C32e(0x8f11bb80), - C32e(0x52de75b7), C32e(0xaee488bc), C32e(0x82b8001e), - C32e(0x98a6a3f4), C32e(0x8ef48f33), C32e(0xa9a36315), - C32e(0xaa5f5624), C32e(0xd5b7f989), C32e(0xb6f1ed20), - C32e(0x7c5ae0fd), C32e(0x36cae95a), C32e(0x06422c36), - C32e(0xce293543), C32e(0x4efe983d), C32e(0x533af974), - C32e(0x739a4ba7), C32e(0xd0f51f59), C32e(0x6f4e8186), - C32e(0x0e9dad81), C32e(0xafd85a9f), C32e(0xa7050667), - C32e(0xee34626a), C32e(0x8b0b28be), C32e(0x6eb91727), - C32e(0x47740726), C32e(0xc680103f), C32e(0xe0a07e6f), - C32e(0xc67e487b), C32e(0x0d550aa5), C32e(0x4af8a4c0), - C32e(0x91e3e79f), C32e(0x978ef19e), C32e(0x86767281), - C32e(0x50608dd4), C32e(0x7e9e5a41), C32e(0xf3e5b062), - C32e(0xfc9f1fec), C32e(0x4054207a), C32e(0xe3e41a00), - C32e(0xcef4c984), C32e(0x4fd794f5), C32e(0x9dfa95d8), - C32e(0x552e7e11), C32e(0x24c354a5), C32e(0x5bdf7228), - C32e(0xbdfe6e28), C32e(0x78f57fe2), C32e(0x0fa5c4b2), - C32e(0x05897cef), C32e(0xee49d32e), C32e(0x447e9385), - C32e(0xeb28597f), C32e(0x705f6937), C32e(0xb324314a), - C32e(0x5e8628f1), C32e(0x1dd6e465), C32e(0xc71b7704), - C32e(0x51b920e7), C32e(0x74fe43e8), C32e(0x23d4878a), - C32e(0x7d29e8a3), C32e(0x927694f2), C32e(0xddcb7a09), - C32e(0x9b30d9c1), C32e(0x1d1b30fb), C32e(0x5bdc1be0), - C32e(0xda24494f), C32e(0xf29c82bf), C32e(0xa4e7ba31), - C32e(0xb470bfff), C32e(0x0d324405), C32e(0xdef8bc48), - C32e(0x3baefc32), C32e(0x53bbd339), C32e(0x459fc3c1), - C32e(0xe0298ba0), C32e(0xe5c905fd), C32e(0xf7ae090f), - C32e(0x94703412), C32e(0x4290f134), C32e(0xa271b701), - C32e(0xe344ed95), C32e(0xe93b8e36), C32e(0x4f2f984a), - C32e(0x88401d63), C32e(0xa06cf615), C32e(0x47c1444b), - C32e(0x8752afff), C32e(0x7ebb4af1), C32e(0xe20ac630), - C32e(0x4670b6c5), C32e(0xcc6e8ce6), C32e(0xa4d5a456), - C32e(0xbd4fca00), C32e(0xda9d844b), C32e(0xc83e18ae), - C32e(0x7357ce45), C32e(0x3064d1ad), C32e(0xe8a6ce68), - C32e(0x145c2567), C32e(0xa3da8cf2), C32e(0xcb0ee116), - C32e(0x33e90658), C32e(0x9a94999a), C32e(0x1f60b220), - C32e(0xc26f847b), C32e(0xd1ceac7f), C32e(0xa0d18518), - C32e(0x32595ba1), C32e(0x8ddd19d3), C32e(0x509a1cc0), - C32e(0xaaa5b446), C32e(0x9f3d6367), C32e(0xe4046bba), - C32e(0xf6ca19ab), C32e(0x0b56ee7e), C32e(0x1fb179ea), - C32e(0xa9282174), C32e(0xe9bdf735), C32e(0x3b3651ee), - C32e(0x1d57ac5a), C32e(0x7550d376), C32e(0x3a46c2fe), - C32e(0xa37d7001), C32e(0xf735c1af), C32e(0x98a4d842), - C32e(0x78edec20), C32e(0x9e6b6779), C32e(0x41836315), - C32e(0xea3adba8), C32e(0xfac33b4d), C32e(0x32832c83), - C32e(0xa7403b1f), C32e(0x1c2747f3), C32e(0x5940f034), - C32e(0xb72d769a), C32e(0xe73e4e6c), C32e(0xd2214ffd), - C32e(0xb8fd8d39), C32e(0xdc5759ef), C32e(0x8d9b0c49), - C32e(0x2b49ebda), C32e(0x5ba2d749), C32e(0x68f3700d), - C32e(0x7d3baed0), C32e(0x7a8d5584), C32e(0xf5a5e9f0), - C32e(0xe4f88e65), C32e(0xa0b8a2f4), C32e(0x36103b53), - C32e(0x0ca8079e), C32e(0x753eec5a), C32e(0x91689492), - C32e(0x56e8884f), C32e(0x5bb05c55), C32e(0xf8babc4c), - C32e(0xe3bb3b99), C32e(0xf387947b), C32e(0x75daf4d6), - C32e(0x726b1c5d), C32e(0x64aeac28), C32e(0xdc34b36d), - C32e(0x6c34a550), C32e(0xb828db71), C32e(0xf861e2f2), - C32e(0x108d512a), C32e(0xe3db6433), C32e(0x59dd75fc), - C32e(0x1cacbcf1), C32e(0x43ce3fa2), C32e(0x67bbd13c), - C32e(0x02e843b0), C32e(0x330a5bca), C32e(0x8829a175), - C32e(0x7f34194d), C32e(0xb416535c), C32e(0x923b94c3), - C32e(0x0e794d1e), C32e(0x797475d7), C32e(0xb6eeaf3f), - C32e(0xeaa8d4f7), C32e(0xbe1a3921), C32e(0x5cf47e09), - C32e(0x4c232751), C32e(0x26a32453), C32e(0xba323cd2), - C32e(0x44a3174a), C32e(0x6da6d5ad), C32e(0xb51d3ea6), - C32e(0xaff2c908), C32e(0x83593d98), C32e(0x916b3c56), - C32e(0x4cf87ca1), C32e(0x7286604d), C32e(0x46e23ecc), - C32e(0x086ec7f6), C32e(0x2f9833b3), C32e(0xb1bc765e), - C32e(0x2bd666a5), C32e(0xefc4e62a), C32e(0x06f4b6e8), - C32e(0xbec1d436), C32e(0x74ee8215), C32e(0xbcef2163), - C32e(0xfdc14e0d), C32e(0xf453c969), C32e(0xa77d5ac4), - C32e(0x06585826), C32e(0x7ec11416), C32e(0x06e0fa16), - C32e(0x7e90af3d), C32e(0x28639d3f), C32e(0xd2c9f2e3), - C32e(0x009bd20c), C32e(0x5faace30), C32e(0xb7d40c30), - C32e(0x742a5116), C32e(0xf2e03298), C32e(0x0deb30d8), - C32e(0xe3cef89a), C32e(0x4bc59e7b), C32e(0xb5f17992), - C32e(0xff51e66e), C32e(0x048668d3), C32e(0x9b234d57), - C32e(0xe6966731), C32e(0xcce6a6f3), C32e(0x170a7505), - C32e(0xb17681d9), C32e(0x13326cce), C32e(0x3c175284), - C32e(0xf805a262), C32e(0xf42bcbb3), C32e(0x78471547), - C32e(0xff465482), C32e(0x23936a48), C32e(0x38df5807), - C32e(0x4e5e6565), C32e(0xf2fc7c89), C32e(0xfc86508e), - C32e(0x31702e44), C32e(0xd00bca86), C32e(0xf04009a2), - C32e(0x3078474e), C32e(0x65a0ee39), C32e(0xd1f73883), - C32e(0xf75ee937), C32e(0xe42c3abd), C32e(0x2197b226), - C32e(0x0113f86f), C32e(0xa344edd1), C32e(0xef9fdee7), - C32e(0x8ba0df15), C32e(0x762592d9), C32e(0x3c85f7f6), - C32e(0x12dc42be), C32e(0xd8a7ec7c), C32e(0xab27b07e), - C32e(0x538d7dda), C32e(0xaa3ea8de), C32e(0xaa25ce93), - C32e(0xbd0269d8), C32e(0x5af643fd), C32e(0x1a7308f9), - C32e(0xc05fefda), C32e(0x174a19a5), C32e(0x974d6633), - C32e(0x4cfd216a), C32e(0x35b49831), C32e(0xdb411570), - C32e(0xea1e0fbb), C32e(0xedcd549b), C32e(0x9ad063a1), - C32e(0x51974072), C32e(0xf6759dbf), C32e(0x91476fe2) -}; - -#define Ceven_w3(r) (C[((r) << 3) + 0]) -#define Ceven_w2(r) (C[((r) << 3) + 1]) -#define Ceven_w1(r) (C[((r) << 3) + 2]) -#define Ceven_w0(r) (C[((r) << 3) + 3]) -#define Codd_w3(r) (C[((r) << 3) + 4]) -#define Codd_w2(r) (C[((r) << 3) + 5]) -#define Codd_w1(r) (C[((r) << 3) + 6]) -#define Codd_w0(r) (C[((r) << 3) + 7]) - -#define S(x0, x1, x2, x3, cb, r) do { \ - Sb(x0 ## 3, x1 ## 3, x2 ## 3, x3 ## 3, cb ## w3(r)); \ - Sb(x0 ## 2, x1 ## 2, x2 ## 2, x3 ## 2, cb ## w2(r)); \ - Sb(x0 ## 1, x1 ## 1, x2 ## 1, x3 ## 1, cb ## w1(r)); \ - Sb(x0 ## 0, x1 ## 0, x2 ## 0, x3 ## 0, cb ## w0(r)); \ - } while (0) - -#define L(x0, x1, x2, x3, x4, x5, x6, x7) do { \ - Lb(x0 ## 3, x1 ## 3, x2 ## 3, x3 ## 3, \ - x4 ## 3, x5 ## 3, x6 ## 3, x7 ## 3); \ - Lb(x0 ## 2, x1 ## 2, x2 ## 2, x3 ## 2, \ - x4 ## 2, x5 ## 2, x6 ## 2, x7 ## 2); \ - Lb(x0 ## 1, x1 ## 1, x2 ## 1, x3 ## 1, \ - x4 ## 1, x5 ## 1, x6 ## 1, x7 ## 1); \ - Lb(x0 ## 0, x1 ## 0, x2 ## 0, x3 ## 0, \ - x4 ## 0, x5 ## 0, x6 ## 0, x7 ## 0); \ - } while (0) - -#define Wz(x, c, n) do { \ - sph_u32 t = (x ## 3 & (c)) << (n); \ - x ## 3 = ((x ## 3 >> (n)) & (c)) | t; \ - t = (x ## 2 & (c)) << (n); \ - x ## 2 = ((x ## 2 >> (n)) & (c)) | t; \ - t = (x ## 1 & (c)) << (n); \ - x ## 1 = ((x ## 1 >> (n)) & (c)) | t; \ - t = (x ## 0 & (c)) << (n); \ - x ## 0 = ((x ## 0 >> (n)) & (c)) | t; \ - } while (0) - -#define W0(x) Wz(x, SPH_C32(0x55555555), 1) -#define W1(x) Wz(x, SPH_C32(0x33333333), 2) -#define W2(x) Wz(x, SPH_C32(0x0F0F0F0F), 4) -#define W3(x) Wz(x, SPH_C32(0x00FF00FF), 8) -#define W4(x) Wz(x, SPH_C32(0x0000FFFF), 16) -#define W5(x) do { \ - sph_u32 t = x ## 3; \ - x ## 3 = x ## 2; \ - x ## 2 = t; \ - t = x ## 1; \ - x ## 1 = x ## 0; \ - x ## 0 = t; \ - } while (0) -#define W6(x) do { \ - sph_u32 t = x ## 3; \ - x ## 3 = x ## 1; \ - x ## 1 = t; \ - t = x ## 2; \ - x ## 2 = x ## 0; \ - x ## 0 = t; \ - } while (0) - -#define DECL_STATE \ - sph_u32 h03, h02, h01, h00, h13, h12, h11, h10; \ - sph_u32 h23, h22, h21, h20, h33, h32, h31, h30; \ - sph_u32 h43, h42, h41, h40, h53, h52, h51, h50; \ - sph_u32 h63, h62, h61, h60, h73, h72, h71, h70; \ - sph_u32 tmp; - -#define READ_STATE(state) do { \ - h03 = (state)->H.narrow[ 0]; \ - h02 = (state)->H.narrow[ 1]; \ - h01 = (state)->H.narrow[ 2]; \ - h00 = (state)->H.narrow[ 3]; \ - h13 = (state)->H.narrow[ 4]; \ - h12 = (state)->H.narrow[ 5]; \ - h11 = (state)->H.narrow[ 6]; \ - h10 = (state)->H.narrow[ 7]; \ - h23 = (state)->H.narrow[ 8]; \ - h22 = (state)->H.narrow[ 9]; \ - h21 = (state)->H.narrow[10]; \ - h20 = (state)->H.narrow[11]; \ - h33 = (state)->H.narrow[12]; \ - h32 = (state)->H.narrow[13]; \ - h31 = (state)->H.narrow[14]; \ - h30 = (state)->H.narrow[15]; \ - h43 = (state)->H.narrow[16]; \ - h42 = (state)->H.narrow[17]; \ - h41 = (state)->H.narrow[18]; \ - h40 = (state)->H.narrow[19]; \ - h53 = (state)->H.narrow[20]; \ - h52 = (state)->H.narrow[21]; \ - h51 = (state)->H.narrow[22]; \ - h50 = (state)->H.narrow[23]; \ - h63 = (state)->H.narrow[24]; \ - h62 = (state)->H.narrow[25]; \ - h61 = (state)->H.narrow[26]; \ - h60 = (state)->H.narrow[27]; \ - h73 = (state)->H.narrow[28]; \ - h72 = (state)->H.narrow[29]; \ - h71 = (state)->H.narrow[30]; \ - h70 = (state)->H.narrow[31]; \ - } while (0) - -#define WRITE_STATE(state) do { \ - (state)->H.narrow[ 0] = h03; \ - (state)->H.narrow[ 1] = h02; \ - (state)->H.narrow[ 2] = h01; \ - (state)->H.narrow[ 3] = h00; \ - (state)->H.narrow[ 4] = h13; \ - (state)->H.narrow[ 5] = h12; \ - (state)->H.narrow[ 6] = h11; \ - (state)->H.narrow[ 7] = h10; \ - (state)->H.narrow[ 8] = h23; \ - (state)->H.narrow[ 9] = h22; \ - (state)->H.narrow[10] = h21; \ - (state)->H.narrow[11] = h20; \ - (state)->H.narrow[12] = h33; \ - (state)->H.narrow[13] = h32; \ - (state)->H.narrow[14] = h31; \ - (state)->H.narrow[15] = h30; \ - (state)->H.narrow[16] = h43; \ - (state)->H.narrow[17] = h42; \ - (state)->H.narrow[18] = h41; \ - (state)->H.narrow[19] = h40; \ - (state)->H.narrow[20] = h53; \ - (state)->H.narrow[21] = h52; \ - (state)->H.narrow[22] = h51; \ - (state)->H.narrow[23] = h50; \ - (state)->H.narrow[24] = h63; \ - (state)->H.narrow[25] = h62; \ - (state)->H.narrow[26] = h61; \ - (state)->H.narrow[27] = h60; \ - (state)->H.narrow[28] = h73; \ - (state)->H.narrow[29] = h72; \ - (state)->H.narrow[30] = h71; \ - (state)->H.narrow[31] = h70; \ - } while (0) - -#define INPUT_BUF1 \ - sph_u32 m03 = dec32e_aligned(buf + 0); \ - sph_u32 m02 = dec32e_aligned(buf + 4); \ - sph_u32 m01 = dec32e_aligned(buf + 8); \ - sph_u32 m00 = dec32e_aligned(buf + 12); \ - sph_u32 m13 = dec32e_aligned(buf + 16); \ - sph_u32 m12 = dec32e_aligned(buf + 20); \ - sph_u32 m11 = dec32e_aligned(buf + 24); \ - sph_u32 m10 = dec32e_aligned(buf + 28); \ - sph_u32 m23 = dec32e_aligned(buf + 32); \ - sph_u32 m22 = dec32e_aligned(buf + 36); \ - sph_u32 m21 = dec32e_aligned(buf + 40); \ - sph_u32 m20 = dec32e_aligned(buf + 44); \ - sph_u32 m33 = dec32e_aligned(buf + 48); \ - sph_u32 m32 = dec32e_aligned(buf + 52); \ - sph_u32 m31 = dec32e_aligned(buf + 56); \ - sph_u32 m30 = dec32e_aligned(buf + 60); \ - h03 ^= m03; \ - h02 ^= m02; \ - h01 ^= m01; \ - h00 ^= m00; \ - h13 ^= m13; \ - h12 ^= m12; \ - h11 ^= m11; \ - h10 ^= m10; \ - h23 ^= m23; \ - h22 ^= m22; \ - h21 ^= m21; \ - h20 ^= m20; \ - h33 ^= m33; \ - h32 ^= m32; \ - h31 ^= m31; \ - h30 ^= m30; - -#define INPUT_BUF2 \ - h43 ^= m03; \ - h42 ^= m02; \ - h41 ^= m01; \ - h40 ^= m00; \ - h53 ^= m13; \ - h52 ^= m12; \ - h51 ^= m11; \ - h50 ^= m10; \ - h63 ^= m23; \ - h62 ^= m22; \ - h61 ^= m21; \ - h60 ^= m20; \ - h73 ^= m33; \ - h72 ^= m32; \ - h71 ^= m31; \ - h70 ^= m30; - -static const sph_u32 IV512[] = { - C32e(0x6fd14b96), C32e(0x3e00aa17), C32e(0x636a2e05), C32e(0x7a15d543), - C32e(0x8a225e8d), C32e(0x0c97ef0b), C32e(0xe9341259), C32e(0xf2b3c361), - C32e(0x891da0c1), C32e(0x536f801e), C32e(0x2aa9056b), C32e(0xea2b6d80), - C32e(0x588eccdb), C32e(0x2075baa6), C32e(0xa90f3a76), C32e(0xbaf83bf7), - C32e(0x0169e605), C32e(0x41e34a69), C32e(0x46b58a8e), C32e(0x2e6fe65a), - C32e(0x1047a7d0), C32e(0xc1843c24), C32e(0x3b6e71b1), C32e(0x2d5ac199), - C32e(0xcf57f6ec), C32e(0x9db1f856), C32e(0xa706887c), C32e(0x5716b156), - C32e(0xe3c2fcdf), C32e(0xe68517fb), C32e(0x545a4678), C32e(0xcc8cdd4b) -}; - -#endif - #define SL(ro) SLu(r + ro, ro) #define SLu(r, ro) do { \ @@ -665,8 +322,6 @@ static const sph_u32 IV512[] = { #if SPH_SMALL_FOOTPRINT_JH -#if SPH_JH_64 - /* * The "small footprint" 64-bit version just uses a partially unrolled * loop. @@ -687,67 +342,6 @@ static const sph_u32 IV512[] = { #else -#define E8 do { \ - unsigned r, g; \ - for (r = g = 0; r < 42; r ++) { \ - S(h0, h2, h4, h6, Ceven_, r); \ - S(h1, h3, h5, h7, Codd_, r); \ - L(h0, h2, h4, h6, h1, h3, h5, h7); \ - switch (g) { \ - case 0: \ - W0(h1); \ - W0(h3); \ - W0(h5); \ - W0(h7); \ - break; \ - case 1: \ - W1(h1); \ - W1(h3); \ - W1(h5); \ - W1(h7); \ - break; \ - case 2: \ - W2(h1); \ - W2(h3); \ - W2(h5); \ - W2(h7); \ - break; \ - case 3: \ - W3(h1); \ - W3(h3); \ - W3(h5); \ - W3(h7); \ - break; \ - case 4: \ - W4(h1); \ - W4(h3); \ - W4(h5); \ - W4(h7); \ - break; \ - case 5: \ - W5(h1); \ - W5(h3); \ - W5(h5); \ - W5(h7); \ - break; \ - case 6: \ - W6(h1); \ - W6(h3); \ - W6(h5); \ - W6(h7); \ - break; \ - } \ - if (++ g == 7) \ - g = 0; \ - } \ - } while (0) - -#endif - -#else - -#if SPH_JH_64 - /* * On a "true 64-bit" architecture, we can unroll at will. */ @@ -797,46 +391,14 @@ static const sph_u32 IV512[] = { SLu(41, 6); \ } while (0) -#else - -/* - * We are not aiming at a small footprint, but we are still using a - * 32-bit implementation. Full loop unrolling would smash the L1 - * cache on some "big" architectures (32 kB L1 cache). - */ - -#define E8 do { \ - unsigned r; \ - for (r = 0; r < 42; r += 7) { \ - SL(0); \ - SL(1); \ - SL(2); \ - SL(3); \ - SL(4); \ - SL(5); \ - SL(6); \ - } \ - } while (0) - -#endif - #endif static void jh_init(sph_jh_context *sc, const void *iv) { sc->ptr = 0; -#if SPH_JH_64 memcpy(sc->H.wide, iv, sizeof sc->H.wide); -#else - memcpy(sc->H.narrow, iv, sizeof sc->H.narrow); -#endif -#if SPH_64 sc->block_count = 0; -#else - sc->block_count_high = 0; - sc->block_count_low = 0; -#endif } static void @@ -870,13 +432,7 @@ jh_core(sph_jh_context *sc, const void *data, size_t len) INPUT_BUF1; E8; INPUT_BUF2; -#if SPH_64 sc->block_count ++; -#else - if ((sc->block_count_low = SPH_T32( - sc->block_count_low + 1)) == 0) - sc->block_count_high ++; -#endif ptr = 0; } } @@ -891,11 +447,7 @@ jh_close(sph_jh_context *sc, unsigned ub, unsigned n, unsigned z; unsigned char buf[128]; size_t numz, u; -#if SPH_64 sph_u64 l0, l1; -#else - sph_u32 l0, l1, l2, l3; -#endif z = 0x80 >> n; buf[0] = ((ub & -z) | z) & 0xFF; @@ -905,30 +457,13 @@ jh_close(sph_jh_context *sc, unsigned ub, unsigned n, numz = 111 - sc->ptr; } memset(buf + 1, 0, numz); -#if SPH_64 l0 = SPH_T64(sc->block_count << 9) + (sc->ptr << 3) + n; l1 = SPH_T64(sc->block_count >> 55); sph_enc64be(buf + numz + 1, l1); sph_enc64be(buf + numz + 9, l0); -#else - l0 = SPH_T32(sc->block_count_low << 9) + (sc->ptr << 3) + n; - l1 = SPH_T32(sc->block_count_low >> 23) - + SPH_T32(sc->block_count_high << 9); - l2 = SPH_T32(sc->block_count_high >> 23); - l3 = 0; - sph_enc32be(buf + numz + 1, l3); - sph_enc32be(buf + numz + 5, l2); - sph_enc32be(buf + numz + 9, l1); - sph_enc32be(buf + numz + 13, l0); -#endif jh_core(sc, buf, numz + 17); -#if SPH_JH_64 for (u = 0; u < 8; u ++) enc64e(buf + (u << 3), sc->H.wide[u + 8]); -#else - for (u = 0; u < 16; u ++) - enc32e(buf + (u << 2), sc->H.narrow[u + 16]); -#endif memcpy(dst, buf + ((16 - out_size_w32) << 2), out_size_w32 << 2); jh_init(sc, iv); } diff --git a/src/crypto/x11/keccak.c b/src/crypto/x11/keccak.c index 1ac404e9a470..10a136a37ffe 100644 --- a/src/crypto/x11/keccak.c +++ b/src/crypto/x11/keccak.c @@ -42,9 +42,7 @@ extern "C"{ /* * Parameters: * - * SPH_KECCAK_64 use a 64-bit type * SPH_KECCAK_UNROLL number of loops to unroll (0/undef for full unroll) - * SPH_KECCAK_INTERLEAVE use bit-interleaving (32-bit type only) * SPH_KECCAK_NOCOPY do not copy the state into local variables * * If there is no usable 64-bit type, the code automatically switches @@ -88,22 +86,6 @@ extern "C"{ #define SPH_SMALL_FOOTPRINT_KECCAK 1 #endif -/* - * By default, we select the 64-bit implementation if a 64-bit type - * is available, unless a 32-bit x86 is detected. - */ -#if !defined SPH_KECCAK_64 && SPH_64 \ - && !(defined __i386__ || SPH_I386_GCC || SPH_I386_MSVC) -#define SPH_KECCAK_64 1 -#endif - -/* - * If using a 32-bit implementation, we prefer to interleave. - */ -#if !SPH_KECCAK_64 && !defined SPH_KECCAK_INTERLEAVE -#define SPH_KECCAK_INTERLEAVE 1 -#endif - /* * Unroll 8 rounds on big systems, 2 rounds on small systems. */ @@ -131,8 +113,6 @@ extern "C"{ #pragma warning (disable: 4146) #endif -#if SPH_KECCAK_64 - static const sph_u64 RC[] = { SPH_C64(0x0000000000000001), SPH_C64(0x0000000000008082), SPH_C64(0x800000000000808A), SPH_C64(0x8000000080008000), @@ -364,596 +344,6 @@ static const sph_u64 RC[] = { #define ROL64(d, v, n) (d = SPH_ROTL64(v, n)) #define XOR64_IOTA XOR64 -#else - -static const struct { - sph_u32 high, low; -} RC[] = { -#if SPH_KECCAK_INTERLEAVE - { SPH_C32(0x00000000), SPH_C32(0x00000001) }, - { SPH_C32(0x00000089), SPH_C32(0x00000000) }, - { SPH_C32(0x8000008B), SPH_C32(0x00000000) }, - { SPH_C32(0x80008080), SPH_C32(0x00000000) }, - { SPH_C32(0x0000008B), SPH_C32(0x00000001) }, - { SPH_C32(0x00008000), SPH_C32(0x00000001) }, - { SPH_C32(0x80008088), SPH_C32(0x00000001) }, - { SPH_C32(0x80000082), SPH_C32(0x00000001) }, - { SPH_C32(0x0000000B), SPH_C32(0x00000000) }, - { SPH_C32(0x0000000A), SPH_C32(0x00000000) }, - { SPH_C32(0x00008082), SPH_C32(0x00000001) }, - { SPH_C32(0x00008003), SPH_C32(0x00000000) }, - { SPH_C32(0x0000808B), SPH_C32(0x00000001) }, - { SPH_C32(0x8000000B), SPH_C32(0x00000001) }, - { SPH_C32(0x8000008A), SPH_C32(0x00000001) }, - { SPH_C32(0x80000081), SPH_C32(0x00000001) }, - { SPH_C32(0x80000081), SPH_C32(0x00000000) }, - { SPH_C32(0x80000008), SPH_C32(0x00000000) }, - { SPH_C32(0x00000083), SPH_C32(0x00000000) }, - { SPH_C32(0x80008003), SPH_C32(0x00000000) }, - { SPH_C32(0x80008088), SPH_C32(0x00000001) }, - { SPH_C32(0x80000088), SPH_C32(0x00000000) }, - { SPH_C32(0x00008000), SPH_C32(0x00000001) }, - { SPH_C32(0x80008082), SPH_C32(0x00000000) } -#else - { SPH_C32(0x00000000), SPH_C32(0x00000001) }, - { SPH_C32(0x00000000), SPH_C32(0x00008082) }, - { SPH_C32(0x80000000), SPH_C32(0x0000808A) }, - { SPH_C32(0x80000000), SPH_C32(0x80008000) }, - { SPH_C32(0x00000000), SPH_C32(0x0000808B) }, - { SPH_C32(0x00000000), SPH_C32(0x80000001) }, - { SPH_C32(0x80000000), SPH_C32(0x80008081) }, - { SPH_C32(0x80000000), SPH_C32(0x00008009) }, - { SPH_C32(0x00000000), SPH_C32(0x0000008A) }, - { SPH_C32(0x00000000), SPH_C32(0x00000088) }, - { SPH_C32(0x00000000), SPH_C32(0x80008009) }, - { SPH_C32(0x00000000), SPH_C32(0x8000000A) }, - { SPH_C32(0x00000000), SPH_C32(0x8000808B) }, - { SPH_C32(0x80000000), SPH_C32(0x0000008B) }, - { SPH_C32(0x80000000), SPH_C32(0x00008089) }, - { SPH_C32(0x80000000), SPH_C32(0x00008003) }, - { SPH_C32(0x80000000), SPH_C32(0x00008002) }, - { SPH_C32(0x80000000), SPH_C32(0x00000080) }, - { SPH_C32(0x00000000), SPH_C32(0x0000800A) }, - { SPH_C32(0x80000000), SPH_C32(0x8000000A) }, - { SPH_C32(0x80000000), SPH_C32(0x80008081) }, - { SPH_C32(0x80000000), SPH_C32(0x00008080) }, - { SPH_C32(0x00000000), SPH_C32(0x80000001) }, - { SPH_C32(0x80000000), SPH_C32(0x80008008) } -#endif -}; - -#if SPH_KECCAK_INTERLEAVE - -#define INTERLEAVE(xl, xh) do { \ - sph_u32 l, h, t; \ - l = (xl); h = (xh); \ - t = (l ^ (l >> 1)) & SPH_C32(0x22222222); l ^= t ^ (t << 1); \ - t = (h ^ (h >> 1)) & SPH_C32(0x22222222); h ^= t ^ (t << 1); \ - t = (l ^ (l >> 2)) & SPH_C32(0x0C0C0C0C); l ^= t ^ (t << 2); \ - t = (h ^ (h >> 2)) & SPH_C32(0x0C0C0C0C); h ^= t ^ (t << 2); \ - t = (l ^ (l >> 4)) & SPH_C32(0x00F000F0); l ^= t ^ (t << 4); \ - t = (h ^ (h >> 4)) & SPH_C32(0x00F000F0); h ^= t ^ (t << 4); \ - t = (l ^ (l >> 8)) & SPH_C32(0x0000FF00); l ^= t ^ (t << 8); \ - t = (h ^ (h >> 8)) & SPH_C32(0x0000FF00); h ^= t ^ (t << 8); \ - t = (l ^ SPH_T32(h << 16)) & SPH_C32(0xFFFF0000); \ - l ^= t; h ^= t >> 16; \ - (xl) = l; (xh) = h; \ - } while (0) - -#define UNINTERLEAVE(xl, xh) do { \ - sph_u32 l, h, t; \ - l = (xl); h = (xh); \ - t = (l ^ SPH_T32(h << 16)) & SPH_C32(0xFFFF0000); \ - l ^= t; h ^= t >> 16; \ - t = (l ^ (l >> 8)) & SPH_C32(0x0000FF00); l ^= t ^ (t << 8); \ - t = (h ^ (h >> 8)) & SPH_C32(0x0000FF00); h ^= t ^ (t << 8); \ - t = (l ^ (l >> 4)) & SPH_C32(0x00F000F0); l ^= t ^ (t << 4); \ - t = (h ^ (h >> 4)) & SPH_C32(0x00F000F0); h ^= t ^ (t << 4); \ - t = (l ^ (l >> 2)) & SPH_C32(0x0C0C0C0C); l ^= t ^ (t << 2); \ - t = (h ^ (h >> 2)) & SPH_C32(0x0C0C0C0C); h ^= t ^ (t << 2); \ - t = (l ^ (l >> 1)) & SPH_C32(0x22222222); l ^= t ^ (t << 1); \ - t = (h ^ (h >> 1)) & SPH_C32(0x22222222); h ^= t ^ (t << 1); \ - (xl) = l; (xh) = h; \ - } while (0) - -#else - -#define INTERLEAVE(l, h) -#define UNINTERLEAVE(l, h) - -#endif - -#if SPH_KECCAK_NOCOPY - -#define a00l (kc->u.narrow[2 * 0 + 0]) -#define a00h (kc->u.narrow[2 * 0 + 1]) -#define a10l (kc->u.narrow[2 * 1 + 0]) -#define a10h (kc->u.narrow[2 * 1 + 1]) -#define a20l (kc->u.narrow[2 * 2 + 0]) -#define a20h (kc->u.narrow[2 * 2 + 1]) -#define a30l (kc->u.narrow[2 * 3 + 0]) -#define a30h (kc->u.narrow[2 * 3 + 1]) -#define a40l (kc->u.narrow[2 * 4 + 0]) -#define a40h (kc->u.narrow[2 * 4 + 1]) -#define a01l (kc->u.narrow[2 * 5 + 0]) -#define a01h (kc->u.narrow[2 * 5 + 1]) -#define a11l (kc->u.narrow[2 * 6 + 0]) -#define a11h (kc->u.narrow[2 * 6 + 1]) -#define a21l (kc->u.narrow[2 * 7 + 0]) -#define a21h (kc->u.narrow[2 * 7 + 1]) -#define a31l (kc->u.narrow[2 * 8 + 0]) -#define a31h (kc->u.narrow[2 * 8 + 1]) -#define a41l (kc->u.narrow[2 * 9 + 0]) -#define a41h (kc->u.narrow[2 * 9 + 1]) -#define a02l (kc->u.narrow[2 * 10 + 0]) -#define a02h (kc->u.narrow[2 * 10 + 1]) -#define a12l (kc->u.narrow[2 * 11 + 0]) -#define a12h (kc->u.narrow[2 * 11 + 1]) -#define a22l (kc->u.narrow[2 * 12 + 0]) -#define a22h (kc->u.narrow[2 * 12 + 1]) -#define a32l (kc->u.narrow[2 * 13 + 0]) -#define a32h (kc->u.narrow[2 * 13 + 1]) -#define a42l (kc->u.narrow[2 * 14 + 0]) -#define a42h (kc->u.narrow[2 * 14 + 1]) -#define a03l (kc->u.narrow[2 * 15 + 0]) -#define a03h (kc->u.narrow[2 * 15 + 1]) -#define a13l (kc->u.narrow[2 * 16 + 0]) -#define a13h (kc->u.narrow[2 * 16 + 1]) -#define a23l (kc->u.narrow[2 * 17 + 0]) -#define a23h (kc->u.narrow[2 * 17 + 1]) -#define a33l (kc->u.narrow[2 * 18 + 0]) -#define a33h (kc->u.narrow[2 * 18 + 1]) -#define a43l (kc->u.narrow[2 * 19 + 0]) -#define a43h (kc->u.narrow[2 * 19 + 1]) -#define a04l (kc->u.narrow[2 * 20 + 0]) -#define a04h (kc->u.narrow[2 * 20 + 1]) -#define a14l (kc->u.narrow[2 * 21 + 0]) -#define a14h (kc->u.narrow[2 * 21 + 1]) -#define a24l (kc->u.narrow[2 * 22 + 0]) -#define a24h (kc->u.narrow[2 * 22 + 1]) -#define a34l (kc->u.narrow[2 * 23 + 0]) -#define a34h (kc->u.narrow[2 * 23 + 1]) -#define a44l (kc->u.narrow[2 * 24 + 0]) -#define a44h (kc->u.narrow[2 * 24 + 1]) - -#define DECL_STATE -#define READ_STATE(state) -#define WRITE_STATE(state) - -#define INPUT_BUF(size) do { \ - size_t j; \ - for (j = 0; j < (size); j += 8) { \ - sph_u32 tl, th; \ - tl = sph_dec32le_aligned(buf + j + 0); \ - th = sph_dec32le_aligned(buf + j + 4); \ - INTERLEAVE(tl, th); \ - kc->u.narrow[(j >> 2) + 0] ^= tl; \ - kc->u.narrow[(j >> 2) + 1] ^= th; \ - } \ - } while (0) - -#define INPUT_BUF144 INPUT_BUF(144) -#define INPUT_BUF136 INPUT_BUF(136) -#define INPUT_BUF104 INPUT_BUF(104) -#define INPUT_BUF72 INPUT_BUF(72) - -#else - -#define DECL_STATE \ - sph_u32 a00l, a00h, a01l, a01h, a02l, a02h, a03l, a03h, a04l, a04h; \ - sph_u32 a10l, a10h, a11l, a11h, a12l, a12h, a13l, a13h, a14l, a14h; \ - sph_u32 a20l, a20h, a21l, a21h, a22l, a22h, a23l, a23h, a24l, a24h; \ - sph_u32 a30l, a30h, a31l, a31h, a32l, a32h, a33l, a33h, a34l, a34h; \ - sph_u32 a40l, a40h, a41l, a41h, a42l, a42h, a43l, a43h, a44l, a44h; - -#define READ_STATE(state) do { \ - a00l = (state)->u.narrow[2 * 0 + 0]; \ - a00h = (state)->u.narrow[2 * 0 + 1]; \ - a10l = (state)->u.narrow[2 * 1 + 0]; \ - a10h = (state)->u.narrow[2 * 1 + 1]; \ - a20l = (state)->u.narrow[2 * 2 + 0]; \ - a20h = (state)->u.narrow[2 * 2 + 1]; \ - a30l = (state)->u.narrow[2 * 3 + 0]; \ - a30h = (state)->u.narrow[2 * 3 + 1]; \ - a40l = (state)->u.narrow[2 * 4 + 0]; \ - a40h = (state)->u.narrow[2 * 4 + 1]; \ - a01l = (state)->u.narrow[2 * 5 + 0]; \ - a01h = (state)->u.narrow[2 * 5 + 1]; \ - a11l = (state)->u.narrow[2 * 6 + 0]; \ - a11h = (state)->u.narrow[2 * 6 + 1]; \ - a21l = (state)->u.narrow[2 * 7 + 0]; \ - a21h = (state)->u.narrow[2 * 7 + 1]; \ - a31l = (state)->u.narrow[2 * 8 + 0]; \ - a31h = (state)->u.narrow[2 * 8 + 1]; \ - a41l = (state)->u.narrow[2 * 9 + 0]; \ - a41h = (state)->u.narrow[2 * 9 + 1]; \ - a02l = (state)->u.narrow[2 * 10 + 0]; \ - a02h = (state)->u.narrow[2 * 10 + 1]; \ - a12l = (state)->u.narrow[2 * 11 + 0]; \ - a12h = (state)->u.narrow[2 * 11 + 1]; \ - a22l = (state)->u.narrow[2 * 12 + 0]; \ - a22h = (state)->u.narrow[2 * 12 + 1]; \ - a32l = (state)->u.narrow[2 * 13 + 0]; \ - a32h = (state)->u.narrow[2 * 13 + 1]; \ - a42l = (state)->u.narrow[2 * 14 + 0]; \ - a42h = (state)->u.narrow[2 * 14 + 1]; \ - a03l = (state)->u.narrow[2 * 15 + 0]; \ - a03h = (state)->u.narrow[2 * 15 + 1]; \ - a13l = (state)->u.narrow[2 * 16 + 0]; \ - a13h = (state)->u.narrow[2 * 16 + 1]; \ - a23l = (state)->u.narrow[2 * 17 + 0]; \ - a23h = (state)->u.narrow[2 * 17 + 1]; \ - a33l = (state)->u.narrow[2 * 18 + 0]; \ - a33h = (state)->u.narrow[2 * 18 + 1]; \ - a43l = (state)->u.narrow[2 * 19 + 0]; \ - a43h = (state)->u.narrow[2 * 19 + 1]; \ - a04l = (state)->u.narrow[2 * 20 + 0]; \ - a04h = (state)->u.narrow[2 * 20 + 1]; \ - a14l = (state)->u.narrow[2 * 21 + 0]; \ - a14h = (state)->u.narrow[2 * 21 + 1]; \ - a24l = (state)->u.narrow[2 * 22 + 0]; \ - a24h = (state)->u.narrow[2 * 22 + 1]; \ - a34l = (state)->u.narrow[2 * 23 + 0]; \ - a34h = (state)->u.narrow[2 * 23 + 1]; \ - a44l = (state)->u.narrow[2 * 24 + 0]; \ - a44h = (state)->u.narrow[2 * 24 + 1]; \ - } while (0) - -#define WRITE_STATE(state) do { \ - (state)->u.narrow[2 * 0 + 0] = a00l; \ - (state)->u.narrow[2 * 0 + 1] = a00h; \ - (state)->u.narrow[2 * 1 + 0] = a10l; \ - (state)->u.narrow[2 * 1 + 1] = a10h; \ - (state)->u.narrow[2 * 2 + 0] = a20l; \ - (state)->u.narrow[2 * 2 + 1] = a20h; \ - (state)->u.narrow[2 * 3 + 0] = a30l; \ - (state)->u.narrow[2 * 3 + 1] = a30h; \ - (state)->u.narrow[2 * 4 + 0] = a40l; \ - (state)->u.narrow[2 * 4 + 1] = a40h; \ - (state)->u.narrow[2 * 5 + 0] = a01l; \ - (state)->u.narrow[2 * 5 + 1] = a01h; \ - (state)->u.narrow[2 * 6 + 0] = a11l; \ - (state)->u.narrow[2 * 6 + 1] = a11h; \ - (state)->u.narrow[2 * 7 + 0] = a21l; \ - (state)->u.narrow[2 * 7 + 1] = a21h; \ - (state)->u.narrow[2 * 8 + 0] = a31l; \ - (state)->u.narrow[2 * 8 + 1] = a31h; \ - (state)->u.narrow[2 * 9 + 0] = a41l; \ - (state)->u.narrow[2 * 9 + 1] = a41h; \ - (state)->u.narrow[2 * 10 + 0] = a02l; \ - (state)->u.narrow[2 * 10 + 1] = a02h; \ - (state)->u.narrow[2 * 11 + 0] = a12l; \ - (state)->u.narrow[2 * 11 + 1] = a12h; \ - (state)->u.narrow[2 * 12 + 0] = a22l; \ - (state)->u.narrow[2 * 12 + 1] = a22h; \ - (state)->u.narrow[2 * 13 + 0] = a32l; \ - (state)->u.narrow[2 * 13 + 1] = a32h; \ - (state)->u.narrow[2 * 14 + 0] = a42l; \ - (state)->u.narrow[2 * 14 + 1] = a42h; \ - (state)->u.narrow[2 * 15 + 0] = a03l; \ - (state)->u.narrow[2 * 15 + 1] = a03h; \ - (state)->u.narrow[2 * 16 + 0] = a13l; \ - (state)->u.narrow[2 * 16 + 1] = a13h; \ - (state)->u.narrow[2 * 17 + 0] = a23l; \ - (state)->u.narrow[2 * 17 + 1] = a23h; \ - (state)->u.narrow[2 * 18 + 0] = a33l; \ - (state)->u.narrow[2 * 18 + 1] = a33h; \ - (state)->u.narrow[2 * 19 + 0] = a43l; \ - (state)->u.narrow[2 * 19 + 1] = a43h; \ - (state)->u.narrow[2 * 20 + 0] = a04l; \ - (state)->u.narrow[2 * 20 + 1] = a04h; \ - (state)->u.narrow[2 * 21 + 0] = a14l; \ - (state)->u.narrow[2 * 21 + 1] = a14h; \ - (state)->u.narrow[2 * 22 + 0] = a24l; \ - (state)->u.narrow[2 * 22 + 1] = a24h; \ - (state)->u.narrow[2 * 23 + 0] = a34l; \ - (state)->u.narrow[2 * 23 + 1] = a34h; \ - (state)->u.narrow[2 * 24 + 0] = a44l; \ - (state)->u.narrow[2 * 24 + 1] = a44h; \ - } while (0) - -#define READ64(d, off) do { \ - sph_u32 tl, th; \ - tl = sph_dec32le_aligned(buf + (off)); \ - th = sph_dec32le_aligned(buf + (off) + 4); \ - INTERLEAVE(tl, th); \ - d ## l ^= tl; \ - d ## h ^= th; \ - } while (0) - -#define INPUT_BUF144 do { \ - READ64(a00, 0); \ - READ64(a10, 8); \ - READ64(a20, 16); \ - READ64(a30, 24); \ - READ64(a40, 32); \ - READ64(a01, 40); \ - READ64(a11, 48); \ - READ64(a21, 56); \ - READ64(a31, 64); \ - READ64(a41, 72); \ - READ64(a02, 80); \ - READ64(a12, 88); \ - READ64(a22, 96); \ - READ64(a32, 104); \ - READ64(a42, 112); \ - READ64(a03, 120); \ - READ64(a13, 128); \ - READ64(a23, 136); \ - } while (0) - -#define INPUT_BUF136 do { \ - READ64(a00, 0); \ - READ64(a10, 8); \ - READ64(a20, 16); \ - READ64(a30, 24); \ - READ64(a40, 32); \ - READ64(a01, 40); \ - READ64(a11, 48); \ - READ64(a21, 56); \ - READ64(a31, 64); \ - READ64(a41, 72); \ - READ64(a02, 80); \ - READ64(a12, 88); \ - READ64(a22, 96); \ - READ64(a32, 104); \ - READ64(a42, 112); \ - READ64(a03, 120); \ - READ64(a13, 128); \ - } while (0) - -#define INPUT_BUF104 do { \ - READ64(a00, 0); \ - READ64(a10, 8); \ - READ64(a20, 16); \ - READ64(a30, 24); \ - READ64(a40, 32); \ - READ64(a01, 40); \ - READ64(a11, 48); \ - READ64(a21, 56); \ - READ64(a31, 64); \ - READ64(a41, 72); \ - READ64(a02, 80); \ - READ64(a12, 88); \ - READ64(a22, 96); \ - } while (0) - -#define INPUT_BUF72 do { \ - READ64(a00, 0); \ - READ64(a10, 8); \ - READ64(a20, 16); \ - READ64(a30, 24); \ - READ64(a40, 32); \ - READ64(a01, 40); \ - READ64(a11, 48); \ - READ64(a21, 56); \ - READ64(a31, 64); \ - } while (0) - -#define INPUT_BUF(lim) do { \ - READ64(a00, 0); \ - READ64(a10, 8); \ - READ64(a20, 16); \ - READ64(a30, 24); \ - READ64(a40, 32); \ - READ64(a01, 40); \ - READ64(a11, 48); \ - READ64(a21, 56); \ - READ64(a31, 64); \ - if ((lim) == 72) \ - break; \ - READ64(a41, 72); \ - READ64(a02, 80); \ - READ64(a12, 88); \ - READ64(a22, 96); \ - if ((lim) == 104) \ - break; \ - READ64(a32, 104); \ - READ64(a42, 112); \ - READ64(a03, 120); \ - READ64(a13, 128); \ - if ((lim) == 136) \ - break; \ - READ64(a23, 136); \ - } while (0) - -#endif - -#define DECL64(x) sph_u64 x ## l, x ## h -#define MOV64(d, s) (d ## l = s ## l, d ## h = s ## h) -#define XOR64(d, a, b) (d ## l = a ## l ^ b ## l, d ## h = a ## h ^ b ## h) -#define AND64(d, a, b) (d ## l = a ## l & b ## l, d ## h = a ## h & b ## h) -#define OR64(d, a, b) (d ## l = a ## l | b ## l, d ## h = a ## h | b ## h) -#define NOT64(d, s) (d ## l = SPH_T32(~s ## l), d ## h = SPH_T32(~s ## h)) -#define ROL64(d, v, n) ROL64_ ## n(d, v) - -#if SPH_KECCAK_INTERLEAVE - -#define ROL64_odd1(d, v) do { \ - sph_u32 tmp; \ - tmp = v ## l; \ - d ## l = SPH_T32(v ## h << 1) | (v ## h >> 31); \ - d ## h = tmp; \ - } while (0) - -#define ROL64_odd63(d, v) do { \ - sph_u32 tmp; \ - tmp = SPH_T32(v ## l << 31) | (v ## l >> 1); \ - d ## l = v ## h; \ - d ## h = tmp; \ - } while (0) - -#define ROL64_odd(d, v, n) do { \ - sph_u32 tmp; \ - tmp = SPH_T32(v ## l << (n - 1)) | (v ## l >> (33 - n)); \ - d ## l = SPH_T32(v ## h << n) | (v ## h >> (32 - n)); \ - d ## h = tmp; \ - } while (0) - -#define ROL64_even(d, v, n) do { \ - d ## l = SPH_T32(v ## l << n) | (v ## l >> (32 - n)); \ - d ## h = SPH_T32(v ## h << n) | (v ## h >> (32 - n)); \ - } while (0) - -#define ROL64_0(d, v) -#define ROL64_1(d, v) ROL64_odd1(d, v) -#define ROL64_2(d, v) ROL64_even(d, v, 1) -#define ROL64_3(d, v) ROL64_odd( d, v, 2) -#define ROL64_4(d, v) ROL64_even(d, v, 2) -#define ROL64_5(d, v) ROL64_odd( d, v, 3) -#define ROL64_6(d, v) ROL64_even(d, v, 3) -#define ROL64_7(d, v) ROL64_odd( d, v, 4) -#define ROL64_8(d, v) ROL64_even(d, v, 4) -#define ROL64_9(d, v) ROL64_odd( d, v, 5) -#define ROL64_10(d, v) ROL64_even(d, v, 5) -#define ROL64_11(d, v) ROL64_odd( d, v, 6) -#define ROL64_12(d, v) ROL64_even(d, v, 6) -#define ROL64_13(d, v) ROL64_odd( d, v, 7) -#define ROL64_14(d, v) ROL64_even(d, v, 7) -#define ROL64_15(d, v) ROL64_odd( d, v, 8) -#define ROL64_16(d, v) ROL64_even(d, v, 8) -#define ROL64_17(d, v) ROL64_odd( d, v, 9) -#define ROL64_18(d, v) ROL64_even(d, v, 9) -#define ROL64_19(d, v) ROL64_odd( d, v, 10) -#define ROL64_20(d, v) ROL64_even(d, v, 10) -#define ROL64_21(d, v) ROL64_odd( d, v, 11) -#define ROL64_22(d, v) ROL64_even(d, v, 11) -#define ROL64_23(d, v) ROL64_odd( d, v, 12) -#define ROL64_24(d, v) ROL64_even(d, v, 12) -#define ROL64_25(d, v) ROL64_odd( d, v, 13) -#define ROL64_26(d, v) ROL64_even(d, v, 13) -#define ROL64_27(d, v) ROL64_odd( d, v, 14) -#define ROL64_28(d, v) ROL64_even(d, v, 14) -#define ROL64_29(d, v) ROL64_odd( d, v, 15) -#define ROL64_30(d, v) ROL64_even(d, v, 15) -#define ROL64_31(d, v) ROL64_odd( d, v, 16) -#define ROL64_32(d, v) ROL64_even(d, v, 16) -#define ROL64_33(d, v) ROL64_odd( d, v, 17) -#define ROL64_34(d, v) ROL64_even(d, v, 17) -#define ROL64_35(d, v) ROL64_odd( d, v, 18) -#define ROL64_36(d, v) ROL64_even(d, v, 18) -#define ROL64_37(d, v) ROL64_odd( d, v, 19) -#define ROL64_38(d, v) ROL64_even(d, v, 19) -#define ROL64_39(d, v) ROL64_odd( d, v, 20) -#define ROL64_40(d, v) ROL64_even(d, v, 20) -#define ROL64_41(d, v) ROL64_odd( d, v, 21) -#define ROL64_42(d, v) ROL64_even(d, v, 21) -#define ROL64_43(d, v) ROL64_odd( d, v, 22) -#define ROL64_44(d, v) ROL64_even(d, v, 22) -#define ROL64_45(d, v) ROL64_odd( d, v, 23) -#define ROL64_46(d, v) ROL64_even(d, v, 23) -#define ROL64_47(d, v) ROL64_odd( d, v, 24) -#define ROL64_48(d, v) ROL64_even(d, v, 24) -#define ROL64_49(d, v) ROL64_odd( d, v, 25) -#define ROL64_50(d, v) ROL64_even(d, v, 25) -#define ROL64_51(d, v) ROL64_odd( d, v, 26) -#define ROL64_52(d, v) ROL64_even(d, v, 26) -#define ROL64_53(d, v) ROL64_odd( d, v, 27) -#define ROL64_54(d, v) ROL64_even(d, v, 27) -#define ROL64_55(d, v) ROL64_odd( d, v, 28) -#define ROL64_56(d, v) ROL64_even(d, v, 28) -#define ROL64_57(d, v) ROL64_odd( d, v, 29) -#define ROL64_58(d, v) ROL64_even(d, v, 29) -#define ROL64_59(d, v) ROL64_odd( d, v, 30) -#define ROL64_60(d, v) ROL64_even(d, v, 30) -#define ROL64_61(d, v) ROL64_odd( d, v, 31) -#define ROL64_62(d, v) ROL64_even(d, v, 31) -#define ROL64_63(d, v) ROL64_odd63(d, v) - -#else - -#define ROL64_small(d, v, n) do { \ - sph_u32 tmp; \ - tmp = SPH_T32(v ## l << n) | (v ## h >> (32 - n)); \ - d ## h = SPH_T32(v ## h << n) | (v ## l >> (32 - n)); \ - d ## l = tmp; \ - } while (0) - -#define ROL64_0(d, v) 0 -#define ROL64_1(d, v) ROL64_small(d, v, 1) -#define ROL64_2(d, v) ROL64_small(d, v, 2) -#define ROL64_3(d, v) ROL64_small(d, v, 3) -#define ROL64_4(d, v) ROL64_small(d, v, 4) -#define ROL64_5(d, v) ROL64_small(d, v, 5) -#define ROL64_6(d, v) ROL64_small(d, v, 6) -#define ROL64_7(d, v) ROL64_small(d, v, 7) -#define ROL64_8(d, v) ROL64_small(d, v, 8) -#define ROL64_9(d, v) ROL64_small(d, v, 9) -#define ROL64_10(d, v) ROL64_small(d, v, 10) -#define ROL64_11(d, v) ROL64_small(d, v, 11) -#define ROL64_12(d, v) ROL64_small(d, v, 12) -#define ROL64_13(d, v) ROL64_small(d, v, 13) -#define ROL64_14(d, v) ROL64_small(d, v, 14) -#define ROL64_15(d, v) ROL64_small(d, v, 15) -#define ROL64_16(d, v) ROL64_small(d, v, 16) -#define ROL64_17(d, v) ROL64_small(d, v, 17) -#define ROL64_18(d, v) ROL64_small(d, v, 18) -#define ROL64_19(d, v) ROL64_small(d, v, 19) -#define ROL64_20(d, v) ROL64_small(d, v, 20) -#define ROL64_21(d, v) ROL64_small(d, v, 21) -#define ROL64_22(d, v) ROL64_small(d, v, 22) -#define ROL64_23(d, v) ROL64_small(d, v, 23) -#define ROL64_24(d, v) ROL64_small(d, v, 24) -#define ROL64_25(d, v) ROL64_small(d, v, 25) -#define ROL64_26(d, v) ROL64_small(d, v, 26) -#define ROL64_27(d, v) ROL64_small(d, v, 27) -#define ROL64_28(d, v) ROL64_small(d, v, 28) -#define ROL64_29(d, v) ROL64_small(d, v, 29) -#define ROL64_30(d, v) ROL64_small(d, v, 30) -#define ROL64_31(d, v) ROL64_small(d, v, 31) - -#define ROL64_32(d, v) do { \ - sph_u32 tmp; \ - tmp = v ## l; \ - d ## l = v ## h; \ - d ## h = tmp; \ - } while (0) - -#define ROL64_big(d, v, n) do { \ - sph_u32 trl, trh; \ - ROL64_small(tr, v, n); \ - d ## h = trl; \ - d ## l = trh; \ - } while (0) - -#define ROL64_33(d, v) ROL64_big(d, v, 1) -#define ROL64_34(d, v) ROL64_big(d, v, 2) -#define ROL64_35(d, v) ROL64_big(d, v, 3) -#define ROL64_36(d, v) ROL64_big(d, v, 4) -#define ROL64_37(d, v) ROL64_big(d, v, 5) -#define ROL64_38(d, v) ROL64_big(d, v, 6) -#define ROL64_39(d, v) ROL64_big(d, v, 7) -#define ROL64_40(d, v) ROL64_big(d, v, 8) -#define ROL64_41(d, v) ROL64_big(d, v, 9) -#define ROL64_42(d, v) ROL64_big(d, v, 10) -#define ROL64_43(d, v) ROL64_big(d, v, 11) -#define ROL64_44(d, v) ROL64_big(d, v, 12) -#define ROL64_45(d, v) ROL64_big(d, v, 13) -#define ROL64_46(d, v) ROL64_big(d, v, 14) -#define ROL64_47(d, v) ROL64_big(d, v, 15) -#define ROL64_48(d, v) ROL64_big(d, v, 16) -#define ROL64_49(d, v) ROL64_big(d, v, 17) -#define ROL64_50(d, v) ROL64_big(d, v, 18) -#define ROL64_51(d, v) ROL64_big(d, v, 19) -#define ROL64_52(d, v) ROL64_big(d, v, 20) -#define ROL64_53(d, v) ROL64_big(d, v, 21) -#define ROL64_54(d, v) ROL64_big(d, v, 22) -#define ROL64_55(d, v) ROL64_big(d, v, 23) -#define ROL64_56(d, v) ROL64_big(d, v, 24) -#define ROL64_57(d, v) ROL64_big(d, v, 25) -#define ROL64_58(d, v) ROL64_big(d, v, 26) -#define ROL64_59(d, v) ROL64_big(d, v, 27) -#define ROL64_60(d, v) ROL64_big(d, v, 28) -#define ROL64_61(d, v) ROL64_big(d, v, 29) -#define ROL64_62(d, v) ROL64_big(d, v, 30) -#define ROL64_63(d, v) ROL64_big(d, v, 31) - -#endif - -#define XOR64_IOTA(d, s, k) \ - (d ## l = s ## l ^ k.low, d ## h = s ## h ^ k.high) - -#endif #define TH_ELT(t, c0, c1, c2, c3, c4, d0, d1, d2, d3, d4) do { \ DECL64(tt0); \ @@ -1527,7 +917,6 @@ keccak_init(sph_keccak_context *kc, unsigned out_size) { int i; -#if SPH_KECCAK_64 for (i = 0; i < 25; i ++) kc->u.wide[i] = 0; /* @@ -1539,28 +928,7 @@ keccak_init(sph_keccak_context *kc, unsigned out_size) kc->u.wide[12] = SPH_C64(0xFFFFFFFFFFFFFFFF); kc->u.wide[17] = SPH_C64(0xFFFFFFFFFFFFFFFF); kc->u.wide[20] = SPH_C64(0xFFFFFFFFFFFFFFFF); -#else - for (i = 0; i < 50; i ++) - kc->u.narrow[i] = 0; - /* - * Initialization for the "lane complement". - * Note: since we set to all-one full 64-bit words, - * interleaving (if applicable) is a no-op. - */ - kc->u.narrow[ 2] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[ 3] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[ 4] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[ 5] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[16] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[17] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[24] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[25] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[34] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[35] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[40] = SPH_C32(0xFFFFFFFF); - kc->u.narrow[41] = SPH_C32(0xFFFFFFFF); -#endif kc->ptr = 0; kc->lim = 200 - (out_size >> 2); } @@ -1602,8 +970,6 @@ keccak_core(sph_keccak_context *kc, const void *data, size_t len, size_t lim) kc->ptr = ptr; } -#if SPH_KECCAK_64 - #define DEFCLOSE(d, lim) \ static void keccak_close ## d( \ sph_keccak_context *kc, unsigned ub, unsigned n, void *dst) \ @@ -1646,60 +1012,6 @@ keccak_core(sph_keccak_context *kc, const void *data, size_t len, size_t lim) keccak_init(kc, (unsigned)d << 3); \ } \ -#else - -#define DEFCLOSE(d, lim) \ - static void keccak_close ## d( \ - sph_keccak_context *kc, unsigned ub, unsigned n, void *dst) \ - { \ - unsigned eb; \ - union { \ - unsigned char tmp[lim + 1]; \ - sph_u64 dummy; /* for alignment */ \ - } u; \ - size_t j; \ - \ - eb = (0x100 | (ub & 0xFF)) >> (8 - n); \ - if (kc->ptr == (lim - 1)) { \ - if (n == 7) { \ - u.tmp[0] = eb; \ - memset(u.tmp + 1, 0, lim - 1); \ - u.tmp[lim] = 0x80; \ - j = 1 + lim; \ - } else { \ - u.tmp[0] = eb | 0x80; \ - j = 1; \ - } \ - } else { \ - j = lim - kc->ptr; \ - u.tmp[0] = eb; \ - memset(u.tmp + 1, 0, j - 2); \ - u.tmp[j - 1] = 0x80; \ - } \ - keccak_core(kc, u.tmp, j, lim); \ - /* Finalize the "lane complement" */ \ - kc->u.narrow[ 2] = ~kc->u.narrow[ 2]; \ - kc->u.narrow[ 3] = ~kc->u.narrow[ 3]; \ - kc->u.narrow[ 4] = ~kc->u.narrow[ 4]; \ - kc->u.narrow[ 5] = ~kc->u.narrow[ 5]; \ - kc->u.narrow[16] = ~kc->u.narrow[16]; \ - kc->u.narrow[17] = ~kc->u.narrow[17]; \ - kc->u.narrow[24] = ~kc->u.narrow[24]; \ - kc->u.narrow[25] = ~kc->u.narrow[25]; \ - kc->u.narrow[34] = ~kc->u.narrow[34]; \ - kc->u.narrow[35] = ~kc->u.narrow[35]; \ - kc->u.narrow[40] = ~kc->u.narrow[40]; \ - kc->u.narrow[41] = ~kc->u.narrow[41]; \ - /* un-interleave */ \ - for (j = 0; j < 50; j += 2) \ - UNINTERLEAVE(kc->u.narrow[j], kc->u.narrow[j + 1]); \ - for (j = 0; j < d; j += 4) \ - sph_enc32le_aligned(u.tmp + j, kc->u.narrow[j >> 2]); \ - memcpy(dst, u.tmp, d); \ - keccak_init(kc, (unsigned)d << 3); \ - } \ - -#endif DEFCLOSE(64, 72) diff --git a/src/crypto/x11/luffa.c b/src/crypto/x11/luffa.c index 6a04047b67e5..69d37d6d09c6 100644 --- a/src/crypto/x11/luffa.c +++ b/src/crypto/x11/luffa.c @@ -39,9 +39,7 @@ extern "C"{ #endif -#if SPH_64_TRUE && !defined SPH_LUFFA_PARALLEL #define SPH_LUFFA_PARALLEL 1 -#endif #ifdef _MSC_VER #pragma warning (disable: 4146) diff --git a/src/crypto/x11/simd.c b/src/crypto/x11/simd.c index 7bd519eac60b..1531426bf5f3 100644 --- a/src/crypto/x11/simd.c +++ b/src/crypto/x11/simd.c @@ -213,42 +213,6 @@ static const s32 alpha_tab[] = { FFT_LOOP(rb, 32, 4, id); \ } while (0) -#if SPH_SMALL_FOOTPRINT_SIMD - -static void -fft32(unsigned char *x, size_t xs, s32 *q) -{ - size_t xd; - - xd = xs << 1; - FFT16(0, xd, 0); - FFT16(xs, xd, 16); - FFT_LOOP(0, 16, 8, label_); -} - -#define FFT128(xb, xs, rb, id) do { \ - fft32(x + (xb) + ((xs) * 0), (xs) << 2, &q[(rb) + 0]); \ - fft32(x + (xb) + ((xs) * 2), (xs) << 2, &q[(rb) + 32]); \ - FFT_LOOP(rb, 32, 4, XCAT(id, aa)); \ - fft32(x + (xb) + ((xs) * 1), (xs) << 2, &q[(rb) + 64]); \ - fft32(x + (xb) + ((xs) * 3), (xs) << 2, &q[(rb) + 96]); \ - FFT_LOOP((rb) + 64, 32, 4, XCAT(id, ab)); \ - FFT_LOOP(rb, 64, 2, XCAT(id, a)); \ - } while (0) - -#else - -/* - * Output range: |q| <= 4733784 - */ -#define FFT128(xb, xs, rb, id) do { \ - FFT64(xb, (xs) << 1, rb, XCAT(id, a)); \ - FFT64((xb) + (xs), (xs) << 1, (rb) + 64, XCAT(id, b)); \ - FFT_LOOP(rb, 64, 2, id); \ - } while (0) - -#endif - /* * For SIMD-384 / SIMD-512, the fully unrolled FFT yields a compression * function which does not fit in the 32 kB L1 cache of a typical x86 diff --git a/src/crypto/x11/skein.c b/src/crypto/x11/skein.c index 32be99dba41e..ba1d21a08b50 100644 --- a/src/crypto/x11/skein.c +++ b/src/crypto/x11/skein.c @@ -48,8 +48,6 @@ extern "C"{ #pragma warning (disable: 4146) #endif -#if SPH_64 - /* * M9_ ## s ## _ ## i evaluates to s+i mod 9 (0 <= s <= 18, 0 <= i <= 7). */ @@ -705,9 +703,6 @@ sph_skein512_addbits_and_close(void *cc, unsigned ub, unsigned n, void *dst) sph_skein512_init(cc); } -#endif - - #ifdef __cplusplus } #endif diff --git a/src/crypto/x11/sph_blake.h b/src/crypto/x11/sph_blake.h index 137e6e6e7830..a4c0a4b1c392 100644 --- a/src/crypto/x11/sph_blake.h +++ b/src/crypto/x11/sph_blake.h @@ -44,17 +44,11 @@ extern "C"{ #include #include "sph_types.h" -#if SPH_64 - /** * Output size (in bits) for BLAKE-512. */ #define SPH_SIZE_blake512 512 -#endif - -#if SPH_64 - /** * This structure is a context for BLAKE-384 and BLAKE-512 computations: * it contains the intermediate values and some data from the last @@ -79,10 +73,6 @@ typedef struct { */ typedef sph_blake_big_context sph_blake512_context; -#endif - -#if SPH_64 - /** * Initialize a BLAKE-512 context. This process performs no memory allocation. * @@ -128,8 +118,6 @@ void sph_blake512_close(void *cc, void *dst); void sph_blake512_addbits_and_close( void *cc, unsigned ub, unsigned n, void *dst); -#endif - #ifdef __cplusplus } #endif diff --git a/src/crypto/x11/sph_bmw.h b/src/crypto/x11/sph_bmw.h index 39a38cd4804d..0b71492a95e7 100644 --- a/src/crypto/x11/sph_bmw.h +++ b/src/crypto/x11/sph_bmw.h @@ -43,17 +43,11 @@ extern "C"{ #include #include "sph_types.h" -#if SPH_64 - /** * Output size (in bits) for BMW-512. */ #define SPH_SIZE_bmw512 512 -#endif - -#if SPH_64 - /** * This structure is a context for BMW-384 and BMW-512 computations: * it contains the intermediate values and some data from the last @@ -77,10 +71,6 @@ typedef struct { */ typedef sph_bmw_big_context sph_bmw512_context; -#endif - -#if SPH_64 - /** * Initialize a BMW-512 context. This process performs no memory allocation. * @@ -126,8 +116,6 @@ void sph_bmw512_close(void *cc, void *dst); void sph_bmw512_addbits_and_close( void *cc, unsigned ub, unsigned n, void *dst); -#endif - #ifdef __cplusplus } #endif diff --git a/src/crypto/x11/sph_echo.h b/src/crypto/x11/sph_echo.h index 53b63a55ad8a..b8403b3c7073 100644 --- a/src/crypto/x11/sph_echo.h +++ b/src/crypto/x11/sph_echo.h @@ -64,9 +64,7 @@ typedef struct { size_t ptr; union { sph_u32 Vs[8][4]; -#if SPH_64 sph_u64 Vb[8][2]; -#endif } u; sph_u32 C0, C1, C2, C3; } sph_echo_big_context; diff --git a/src/crypto/x11/sph_groestl.h b/src/crypto/x11/sph_groestl.h index 318d315e815c..779bd9f3ff25 100644 --- a/src/crypto/x11/sph_groestl.h +++ b/src/crypto/x11/sph_groestl.h @@ -61,16 +61,10 @@ typedef struct { unsigned char buf[128]; /* first field, for alignment */ size_t ptr; union { -#if SPH_64 sph_u64 wide[16]; -#endif sph_u32 narrow[32]; } state; -#if SPH_64 sph_u64 count; -#else - sph_u32 count_high, count_low; -#endif } sph_groestl_big_context; /** diff --git a/src/crypto/x11/sph_jh.h b/src/crypto/x11/sph_jh.h index e017381fcc6b..06b72c6314d5 100644 --- a/src/crypto/x11/sph_jh.h +++ b/src/crypto/x11/sph_jh.h @@ -62,16 +62,10 @@ typedef struct { unsigned char buf[64]; /* first field, for alignment */ size_t ptr; union { -#if SPH_64 sph_u64 wide[16]; -#endif sph_u32 narrow[32]; } H; -#if SPH_64 sph_u64 block_count; -#else - sph_u32 block_count_high, block_count_low; -#endif } sph_jh_context; /** diff --git a/src/crypto/x11/sph_keccak.h b/src/crypto/x11/sph_keccak.h index 9925c4c15e12..43db8461c2a4 100644 --- a/src/crypto/x11/sph_keccak.h +++ b/src/crypto/x11/sph_keccak.h @@ -62,9 +62,7 @@ typedef struct { unsigned char buf[144]; /* first field, for alignment */ size_t ptr, lim; union { -#if SPH_64 sph_u64 wide[25]; -#endif sph_u32 narrow[50]; } u; } sph_keccak_context; diff --git a/src/crypto/x11/sph_skein.h b/src/crypto/x11/sph_skein.h index e17965df03aa..fd0bc6726b2a 100644 --- a/src/crypto/x11/sph_skein.h +++ b/src/crypto/x11/sph_skein.h @@ -48,8 +48,6 @@ extern "C"{ #include #include "sph_types.h" -#if SPH_64 - /** * Output size (in bits) for Skein-512. */ @@ -122,8 +120,6 @@ void sph_skein512_close(void *cc, void *dst); void sph_skein512_addbits_and_close( void *cc, unsigned ub, unsigned n, void *dst); -#endif - #ifdef __cplusplus } #endif diff --git a/src/crypto/x11/sph_types.h b/src/crypto/x11/sph_types.h index fd935225c34c..cb0066b6c1ba 100644 --- a/src/crypto/x11/sph_types.h +++ b/src/crypto/x11/sph_types.h @@ -57,18 +57,6 @@ #error This code requires 8-bit bytes #endif -/* - * We want to define the types "sph_u32" and "sph_u64" which hold - * unsigned values of at least, respectively, 32 and 64 bits. These - * tests should select appropriate types for most platforms. The - * macro "SPH_64" is defined if the 64-bit is supported. - */ - -#undef SPH_64 -#undef SPH_64_TRUE - -#if defined __STDC__ && __STDC_VERSION__ >= 199901L - /* * On C99 implementations, we can use to get an exact 64-bit * type, if any, or otherwise use a wider type (which must exist, for @@ -84,7 +72,6 @@ typedef int32_t sph_s32; typedef uint_fast32_t sph_u32; typedef int_fast32_t sph_s32; #endif -#if !SPH_NO_64 #ifdef UINT64_MAX typedef uint64_t sph_u64; typedef int64_t sph_s64; @@ -92,87 +79,9 @@ typedef int64_t sph_s64; typedef uint_fast64_t sph_u64; typedef int_fast64_t sph_s64; #endif -#endif #define SPH_C32(x) ((sph_u32)(x)) -#if !SPH_NO_64 #define SPH_C64(x) ((sph_u64)(x)) -#define SPH_64 1 -#endif - -#else - -/* - * On non-C99 systems, we use "unsigned int" if it is wide enough, - * "unsigned long" otherwise. This supports all "reasonable" architectures. - * We have to be cautious: pre-C99 preprocessors handle constants - * differently in '#if' expressions. Hence the shifts to test UINT_MAX. - */ - -#if ((UINT_MAX >> 11) >> 11) >= 0x3FF - -typedef unsigned int sph_u32; -typedef int sph_s32; - -#define SPH_C32(x) ((sph_u32)(x ## U)) - -#else - -typedef unsigned long sph_u32; -typedef long sph_s32; - -#define SPH_C32(x) ((sph_u32)(x ## UL)) - -#endif - -#if !SPH_NO_64 - -/* - * We want a 64-bit type. We use "unsigned long" if it is wide enough (as - * is common on 64-bit architectures such as AMD64, Alpha or Sparcv9), - * "unsigned long long" otherwise, if available. We use ULLONG_MAX to - * test whether "unsigned long long" is available; we also know that - * gcc features this type, even if the libc header do not know it. - */ - -#if ((ULONG_MAX >> 31) >> 31) >= 3 - -typedef unsigned long sph_u64; -typedef long sph_s64; - -#define SPH_C64(x) ((sph_u64)(x ## UL)) - -#define SPH_64 1 - -#elif ((ULLONG_MAX >> 31) >> 31) >= 3 || defined __GNUC__ - -typedef unsigned long long sph_u64; -typedef long long sph_s64; - -#define SPH_C64(x) ((sph_u64)(x ## ULL)) - -#define SPH_64 1 - -#else - -/* - * No 64-bit type... - */ - -#endif - -#endif - -#endif - -/* - * If the "unsigned long" type has length 64 bits or more, then this is - * a "true" 64-bit architectures. This is also true with Visual C on - * amd64, even though the "long" type is limited to 32 bits. - */ -#if SPH_64 && (((ULONG_MAX >> 31) >> 31) >= 3 || defined _M_X64) -#define SPH_64_TRUE 1 -#endif /* * Implementation note: some processors have specific opcodes to perform @@ -184,14 +93,10 @@ typedef long long sph_s64; #define SPH_ROTL32(x, n) SPH_T32(((x) << (n)) | ((x) >> (32 - (n)))) #define SPH_ROTR32(x, n) SPH_ROTL32(x, (32 - (n))) -#if SPH_64 - #define SPH_T64(x) ((x) & SPH_C64(0xFFFFFFFFFFFFFFFF)) #define SPH_ROTL64(x, n) SPH_T64(((x) << (n)) | ((x) >> (64 - (n)))) #define SPH_ROTR64(x, n) SPH_ROTL64(x, (64 - (n))) -#endif - /* * Define SPH_INLINE to be an "inline" qualifier, if available. We define * some small macro-like functions which benefit greatly from being inlined. @@ -333,11 +238,7 @@ typedef long long sph_s64; * it again. */ #if defined __GNUC__ -#if SPH_64_TRUE #define SPH_DETECT_PPC64_GCC 1 -#else -#define SPH_DETECT_PPC32_GCC 1 -#endif #endif #if defined __BIG_ENDIAN__ || defined _BIG_ENDIAN @@ -440,8 +341,6 @@ sph_bswap32(sph_u32 x) return x; } -#if SPH_64 - static SPH_INLINE sph_u64 sph_bswap64(sph_u64 x) { @@ -449,8 +348,6 @@ sph_bswap64(sph_u64 x) | (sph_u64)sph_bswap32((sph_u32)(x >> 32)); } -#endif - #elif SPH_AMD64_GCC && !SPH_NO_ASM /* @@ -465,8 +362,6 @@ sph_bswap32(sph_u32 x) return x; } -#if SPH_64 - static SPH_INLINE sph_u64 sph_bswap64(sph_u64 x) { @@ -474,8 +369,6 @@ sph_bswap64(sph_u64 x) return x; } -#endif - #else static SPH_INLINE sph_u32 @@ -487,8 +380,6 @@ sph_bswap32(sph_u32 x) return x; } -#if SPH_64 - /** * Byte-swap a 64-bit value. * @@ -508,8 +399,6 @@ sph_bswap64(sph_u64 x) #endif -#endif - #if SPH_SPARCV9_GCC && !SPH_NO_ASM /* @@ -830,8 +719,6 @@ sph_dec32le_aligned(const void *src) #endif } -#if SPH_64 - /** * Encode a 64-bit value into the provided buffer (big endian convention). * @@ -1132,5 +1019,3 @@ sph_dec64le_aligned(const void *src) } #endif - -#endif diff --git a/src/hash_x11.h b/src/hash_x11.h index 291e9754db3d..c2858d96c40f 100644 --- a/src/hash_x11.h +++ b/src/hash_x11.h @@ -37,7 +37,7 @@ inline uint256 HashX11(const T1 pbegin, const T1 pend) sph_shavite512_context ctx_shavite; sph_simd512_context ctx_simd; sph_echo512_context ctx_echo; - static unsigned char pblank[1]; + static const unsigned char pblank[1]{}; uint512 hash[11];