Add rust to cmake build system

.gitignore

@@ -39,5 +39,6 @@ prof.h
 
 # rust outputs
 target/
+rust-hashes/**.out
 
 *.swp

CMakeLists.txt

@@ -630,6 +630,58 @@ endif()
 # "${CMAKE_CURRENT_SOURCE_DIR}/fanom_hash.h") set(CMAKE_CXX_FLAGS
 # "${CMAKE_CXX_FLAGS} -DHAVE_FANOM_HASH") ENDIF()
 
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(not_debug false)
+else()
+  set(not_debug true)
+endif()
+
+set(RUST_ENABLED true CACHE boolean "enable rust support (requires cargo)")
+set(RUST_TARGET "" CACHE string "set target for cross compiling (blank for current)")
+set(RUST_SIMD not_debug CACHE boolean "enable native features (non-portable SIMD instructions)")
+
+if(RUST_ENABLED)
+  message(STATUS "Rust enabled")
+  set(rust_toolchain "") # use the default
+  set(cargo_path "--manifest-path=${CMAKE_CURRENT_SOURCE_DIR}/rust-hashes/Cargo.toml")
+  set(rust_lib_path "${CMAKE_CURRENT_SOURCE_DIR}/rust-hashes/target")
+
+  if(NOT RUST_TARGET STREQUAL "") # set target arch if needed
+    message(STATUS "Cross compiling Rust to ${RUST_TARGET}")
+    set(cargo_target "--target=${RUST_TARGET}")
+    set(rust_lib_path "${rust_lib_path}/${RUST_TARGET}")
+  endif()
+
+  if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(cargo_profile "--release")
+    set(rust_lib_path "${rust_lib_path}/release")
+  else()
+    set(rust_lib_path "${rust_lib_path}/debug")
+  endif()
+
+  if(CMAKE_BUILD_TYPE STREQUAL "asan")
+    set(ENV{RUSTFLAGS} "${RUSTFLAGS} -Zsanitizer=address")
+    set(rust_toolchain "+nightly") # sanitizers are unstable and require nightly
+  endif()
+
+  if(RUST_SIMD) # enable all CPU features
+    message(STATUS "Buidling Rust with target-cpu=native")
+    set(ENV{RUSTFLAGS} "${RUSTFLAGS} -Ctarget-cpu=native")
+  endif()
+
+  # enable the faster dependency protocol for < 1.70 (no runtime effect)
+  set(ENV{CARGO_REGISTRIES_CRATES_IO_PROTOCOL} "sparse")
+  set(rust_lib_path "${rust_lib_path}/librust_hashes.a")
+
+  add_custom_target(
+    librust_hashes
+    COMMAND cargo ${rust_toolchain} build --quiet ${cargo_path}
+            ${cargo_target} ${cargo_profile}
+  )
+
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DRUST_ENABLED")
+endif()
+
 if((CMAKE_MAJOR_VERSION EQUAL 3 AND CMAKE_MINOR_VERSION GREATER_EQUAL 9)
    AND (CMAKE_BUILD_TYPE STREQUAL "Release"))
   cmake_policy(SET CMP0069 NEW)
@@ -735,6 +787,11 @@ target_link_libraries(SMHasher SMHasherSupport
                       ${HIGHWAY_LIB} ${BLAKE3_LIB} ${AHASH_C_LIB}
                       ${CMAKE_THREAD_LIBS_INIT})
 
+if (RUST_ENABLED)
+  add_dependencies(SMHasher librust_hashes)
+  target_link_libraries(SMHasher ${rust_lib_path})
+endif()
+
 SET(exectargets ${exectargets} SMHasher)
 # add_executable( bittest bittest.cpp )
 #

main.cpp

@@ -6,6 +6,9 @@
 #include "AvalancheTest.h"
 #include "DifferentialTest.h"
 #include "HashMapTest.h"
+#ifdef RUST_ENABLED
+#include "rust-hashes/rust_hashes.h"
+#endif
 
 #if NCPU > 1 // disable with -DNCPU=0 or 1
 #include <thread>
@@ -757,6 +760,53 @@ HashInfo g_hashes[] =
 #endif
 { komihash_test,        64, 0x8157FF6D, "komihash",    "komihash 5.7", GOOD, {} },
 { polymur_test,         64, 0x4F894810, "polymur",     "github.com/orlp/polymur-hash v1", GOOD, {} },
+#ifdef RUST_ENABLED
+{ adler_rstest,         32, 0x00000000, "Adler_rs",           "Adler-32 checksum implementation (used by `zlib`, crate `adler`)", GOOD, {} },
+{ ahash_rstest,         64, 0x00000000, "aHash_rs",           "aHash keyed hash function (crate `ahash`)", GOOD, {} },
+{ blake2b512_rstest,   512, 0x00000000, "BLAKE2b-512_rs",     "BLAKE2b-512 (crate `blake2`)", GOOD , {} },
+{ blake2s256_rstest,   256, 0x00000000, "BLAKE2s-256_rs",     "BLAKE2s-256 (crate `blake2`)", GOOD, {} },
+{ blake3_rstest,       256, 0x00000000, "BLAKE3_rs",          "BLAKE3 (crate `blake3`)", GOOD, {} },
+{ crc32fast_rstest,     32, 0x00000000, "CRC32_rs",           "CRC32 (crate `crc32fast`)", GOOD, {} },
+{ fnvhash_rstest,       64, 0x00000000, "FNV_rs",             "Fowler-Noll-Vo hash function (crate `fnv`)", GOOD, {} },
+{ fxhash32_rstest,      32, 0x00000000, "FxHash32",           "FxHash (FireFox hash) with 32 bits (crate `fxhash`)", GOOD, {} },
+{ fxhash64_rstest,      64, 0x00000000, "FxHash64",           "FxHash (FireFox hash) with 64 bits (crate `fxhash`)", GOOD, {} },
+{ hash_hasher_rstest,   64, 0x00000000, "hash_hasher_rs",     "A hasher designed to work on already hashed or hash-like data (crate `hash_hasher`)", GOOD, {} },
+{ highway_rstest,       64, 0x00000000, "Highway_rs",         "An implementation of Google's HighwayHash (crate `highway`)", GOOD, {} },
+{ md5_rstest,          128, 0x00000000, "MD5_rs",             "MD5 algorithm (crate `md-5`)", GOOD, {} },
+{ sha1_rstest,         160, 0x00000000, "SHA-1_rs",           "SHA-1 algorithm (crate `sha1`)", GOOD, {} },
+{ sha224_rstest,       224, 0x00000000, "SHA-224_rs",         "SHA-224 algorithm (crate `sha2`)", GOOD, {} },
+{ sha256_rstest,       256, 0x00000000, "SHA-256_rs",         "SHA-256 algorithm (crate `sha2`)", GOOD, {} },
+{ sha384_rstest,       384, 0x00000000, "SHA-384_rs",         "SHA-384 algorithm (crate `sha2`)", GOOD, {} },
+{ sha512_rstest,       512, 0x00000000, "SHA-512_rs",         "SHA-512 algorithm (crate `sha2`)", GOOD, {} },
+{ sha512_224_rstest,   224, 0x00000000, "SHA-512/224_rs",     "SHA-512 algorithm with 224-bit output (crate `sha2`)", GOOD, {} },
+{ sha512_256_rstest,   256, 0x00000000, "SHA-512/256_rs",     "SHA-512 algorithm with 256-bit output (crate `sha2`)", GOOD, {} },
+{ cshake128_rstest,    128, 0x00000000, "CSHAKE128_rs",       "CSHAKE128 algorithm with variable-length output (128 bits for test, crate `sha3`)", GOOD, {} },
+{ cshake256_rstest,    256, 0x00000000, "CSHAKE256_rs",       "CSHAKE256 algorithm with variable-length output (256 bits for test, crate `sha3`)", GOOD, {} },
+{ keccak224_rstest,    224, 0x00000000, "Keccak-224_rs",      "Keccak-224 algorithm (crate `sha3`)", GOOD, {} },
+{ keccak256_rstest,    256, 0x00000000, "Keccak-256_rs",      "Keccak-256 algorithm (crate `sha3`)", GOOD, {} },
+{ keccak256full_rstest,1600,0x00000000, "Keccak-256_CryptoNight_rs","Keccak-256 hash algorithm, SHA-3 CryptoNight with 1600-bit output (crate `sha3`)", GOOD, {} },
+{ keccak384_rstest,    384, 0x00000000, "Keccak-384_rs",      "Keccak-384 algorithm (crate `sha3`)", GOOD, {} },
+{ keccak512_rstest,    512, 0x00000000, "Keccak-512_rs",      "Keccak-512 algorithm (crate `sha3`)", GOOD, {} },
+{ sha3_224_rstest,     224, 0x00000000, "SHA-3-224_rs",       "SHA-3 algorithm with 224-bit output (crate `sha3`)", GOOD, {} },
+{ sha3_256_rstest,     256, 0x00000000, "SHA-3-256_rs",       "SHA-3 algorithm with 256-bit output (crate `sha3`)", GOOD, {} },
+{ sha3_384_rstest,     384, 0x00000000, "SHA-3-384_rs",       "SHA-3 algorithm with 384-bit output (crate `sha3`)", GOOD, {} },
+{ sha3_512_rstest,     512, 0x00000000, "SHA-3-512_rs",       "SHA-3 algorithm with 512-bit output (crate `sha3`)", GOOD, {} },
+{ shake128_rstest,     123, 0x00000000, "SHAKE128_rs",        "SHAKE128 algorithm with variable-length output (128 bits for test, crate `sha3`)", GOOD, {} },
+{ shake256_rstest,     256, 0x00000000, "SHAKE256_rs",        "SHAKE256 algorithm with variable-length output (256 bits for test, crate `sha3`)", GOOD, {} },
+{ turboshake128_1f_rstest,128,0x00000000,"TurboSHAKE128_rs",  "turboshake128 algorithm with variable-length output (128 bits for test, domain separation 0x1f, crate `sha3`)", GOOD, {} },
+{ turboshake256_1f_rstest,256,0x00000000,"TurboSHAKE256_rs",  "turboshake256 algorithm with variable-length output (256 bits for test, domain separation 0x1f, crate `sha3`)", GOOD, {} },
+{ twox_xxhash32_rstest, 32, 0x00000000, "xxHash32_twox_rs",   "32-bit xxHash implementation (crate `twox_hash`)", GOOD, {} },
+{ twox_xxhash64_rstest, 64, 0x00000000, "xxHash64_twox_rs",   "64-bit xxHash implementation (crate `twox_hash`)", GOOD, {} },
+{ siphash13_rstest,     64, 0x00000000, "SipHash_1-3_rs",     "SipHash with 1 round and 3 finalization rounds (crate `siphasher`)", GOOD, {} },
+{ siphash24_rstest,     64, 0x00000000, "SipHash_2-4_rs",     "SipHash with 2 rounds and 4 finalization rounds (crate `siphasher`)", GOOD, {} },
+{ siphash128_13_rstest, 64, 0x00000000, "SipHash128_1-3_rs",  "SipHash128 with 1 round and 3 finalization rounds (crate `siphasher`)", GOOD, {} },
+{ siphash128_24_rstest, 64, 0x00000000, "SipHash128_2-4_rs",  "SipHash128 with 2 rounds and 4 finalization rounds (crate `siphasher`)", GOOD, {} },
+{ wyhash_rstest,        64, 0x00000000, "WyHash_rs",          "WyHash algorithm", GOOD, {} },
+{ xxhash3_rstest,       64, 0x00000000, "xxHash3_rs",         "64-bit xxHash implementation (crate `xxhash-rust`)", GOOD, {} },
+{ xxhash128_rstest,    128, 0x00000000, "xxHash128_rs",       "128-bit xxHash implementation (crate `xxhash-rust`)", GOOD, {} },
+{ xxhash32_rstest,      32, 0x00000000, "xxHash32_rs",        "32-bit xxHash implementation (crate `xxhash-rust`)", GOOD, {} },
+{ xxhash64_rstest,      64, 0x00000000, "xxHash64_rs",        "64-bit xxHash implementation (crate `xxhash-rust`)", GOOD, {} },
+#endif
 };
 
 HashInfo * findHash ( const char * name )

rust-hashes/test-bindings.c

@@ -0,0 +1,43 @@
+/*
+* Quick file to test the bindings to C without building the whole project
+* Run with `cargo build && gcc test-bindings.c target/debug/librust_hashes.a && ./a.out`
+* Make sure to generate hashes if bindings have changes
+* (`RUST_GENERATE_HASHES=1 cargo +nightly build`)
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "rust_hashes.h"
+
+int print_clear(char* name, char* out, int bits) {
+  printf("%s: ", name);
+
+  for(int i=0; i < (bits >> 3); ++i) {
+    printf("%02x", out[i] & 0xff);
+    out[i] = 0;
+  }
+
+  printf("\n");
+}
+
+int main() {
+  char *x = "Hello, world!";
+  char out[1000] = {0};
+
+  printf("hashing '%s' (len %ld)\n", x, strlen(x));
+
+  ahash_rstest(x, strlen(x), 0, out);
+  print_clear("ahash", out, 64);
+
+  sha256_rstest(x, strlen(x), 0, &out);
+  print_clear("sha256", out, 256);
+
+  blake2s256_rstest(x, strlen(x), 0, &out);
+  print_clear("blake2s256", out, 256);
+
+  blake3_rstest(x, strlen(x), 0, &out);
+  print_clear("blake3", out, 256);
+
+  keccak256full_rstest(x, strlen(x), 0, &out);
+  print_clear("keccak256_full", out, 1600);
+}