Implement much faster sha256 and sha512.

sha2/Cargo.toml

@@ -10,5 +10,8 @@ keywords = ["crypto", "sha2", "asm"]
 categories = ["cryptography", "no-std"]
 edition = "2018"
 
+[dependencies]
+cpufeatures = "0.2"
+
 [build-dependencies]
 cc = "1.0"

sha2/build.rs

@@ -3,27 +3,37 @@ fn main() {
 
     let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
     let target_vendor = env::var("CARGO_CFG_TARGET_VENDOR").unwrap_or_default();
-
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
     let mut build256 = cc::Build::new();
-    let (sha256_path, sha512_path) = if target_arch == "x86" {
-        ("src/sha256_x86.S", "src/sha512_x86.S")
+    let (sha256_path, sha512_path): (&[&str], &[&str]) = if target_arch == "x86" {
+        (&["src/sha256_x86.S"], &["src/sha512_x86.S"])
     } else if target_arch == "x86_64" {
-        ("src/sha256_x64.S", "src/sha512_x64.S")
+        if target_os == "linux" {
+            (
+                &["src/sha256_x64_avx2.S", "src/sha256_x64.S"],
+                &["src/sha512_x64_avx2.S", "src/sha512_x64.S"],
+            )
+        } else {
+            (&["src/sha256_x64.S"], &["src/sha512_x64.S"])
+        }
     } else if target_arch == "aarch64" && target_vendor == "apple" {
         build256.flag("-march=armv8-a+crypto");
-        ("src/sha256_aarch64_apple.S", "")
+        (&["src/sha256_aarch64_apple.S"], &[""])
     } else if target_arch == "aarch64" {
         build256.flag("-march=armv8-a+crypto");
-        ("src/sha256_aarch64.S", "")
+        (&["src/sha256_aarch64.S"], &[""])
     } else {
         panic!("Unsupported target architecture");
     };
 
     if target_arch != "aarch64" {
         cc::Build::new()
             .flag("-c")
-            .file(sha512_path)
+            .files(sha512_path)
             .compile("libsha512.a");
     }
-    build256.flag("-c").file(sha256_path).compile("libsha256.a");
+    build256
+        .flag("-c")
+        .files(sha256_path)
+        .compile("libsha256.a");
 }

sha2/src/lib.rs

@@ -13,23 +13,37 @@
 #[cfg(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")))]
 compile_error!("crate can only be used on x86, x86-64 and aarch64 architectures");
 
+cpufeatures::new!(cpuid_avx2, "avx2");
+
 #[link(name = "sha256", kind = "static")]
+#[allow(dead_code)]
 extern "C" {
     fn sha256_compress(state: &mut [u32; 8], block: &[u8; 64]);
+    fn sha256_transform_rorx(state: &mut [u32; 8], block: *const [u8; 64], num_blocks: u64);
 }
 
 /// Safe wrapper around assembly implementation of SHA256 compression function
+///
 #[inline]
 pub fn compress256(state: &mut [u32; 8], blocks: &[[u8; 64]]) {
-    for block in blocks {
-        unsafe { sha256_compress(state, block) }
+    let token: cpuid_avx2::InitToken = cpuid_avx2::init();
+
+    if token.get() {
+        if !blocks.is_empty() {
+            unsafe { sha256_transform_rorx(state, blocks.as_ptr(), blocks.len() as u64) }
+        }
+    } else {
+        for block in blocks {
+            unsafe { sha256_compress(state, block) }
+        }
     }
 }
 
 #[cfg(not(target_arch = "aarch64"))]
 #[link(name = "sha512", kind = "static")]
 extern "C" {
     fn sha512_compress(state: &mut [u64; 8], block: &[u8; 128]);
+    fn sha512_transform_rorx(state: &mut [u64; 8], block: *const [u8; 128], num_blocks: usize);
 }
 
 /// Safe wrapper around assembly implementation of SHA512 compression function
@@ -38,7 +52,14 @@ extern "C" {
 #[cfg(not(target_arch = "aarch64"))]
 #[inline]
 pub fn compress512(state: &mut [u64; 8], blocks: &[[u8; 128]]) {
-    for block in blocks {
-        unsafe { sha512_compress(state, block) }
+    let token: cpuid_avx2::InitToken = cpuid_avx2::init();
+    if token.get() {
+        if !blocks.is_empty() {
+            unsafe { sha512_transform_rorx(state, blocks.as_ptr(), blocks.len()) }
+        }
+    } else {
+        for block in blocks {
+            unsafe { sha512_compress(state, block) }
+        }
     }
 }