Enable sha2 AArch64 extension on Linux

The feature gate is specific to glibc on Linux, using getauxval() to
check the CPU flags, so it’s currently not used on other systems.
Patches welcome. :)

The sha2 extension only provides SHA-256 instructions, so keep using the
plain Rust implementation for SHA-512 until someone adds sha512
extension assembly (I have no computer to test that with).

Author: linkmauve

sha2/Cargo.toml

@@ -15,6 +15,7 @@ block-buffer = "0.7"
 fake-simd = "0.1"
 opaque-debug = "0.2"
 sha2-asm = { version="0.5", optional=true }
+libc = { version = "0.2", optional = true }
 
 [dev-dependencies]
 digest = { version = "0.8", features = ["dev"] }
@@ -25,5 +26,9 @@ default = ["std"]
 std = ["digest/std"]
 asm = ["sha2-asm"]
 
+# TODO: Remove this feature once is_aarch64_feature_detected!() is stabilised.
+# Only used on AArch64 Linux systems.
+asm-aarch64 = ["asm", "libc"]
+
 [badges]
 travis-ci = { repository = "RustCrypto/hashes" }

sha2/src/aarch64.rs

@@ -0,0 +1,9 @@
+// TODO: Add those to the libc crate.
+const AT_HWCAP: u64 = 16;
+const HWCAP_SHA2: u64 = 64;
+
+#[inline(always)]
+pub fn sha2_supported() -> bool {
+    let hwcaps: u64 = unsafe { ::libc::getauxval(AT_HWCAP) };
+    (hwcaps & HWCAP_SHA2) != 0
+}

sha2/src/lib.rs

@@ -57,6 +57,15 @@
 #![no_std]
 #![doc(html_logo_url =
     "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
+
+// Give relevant error messages if the user tries to enable AArch64 asm on unsupported platforms.
+#[cfg(all(feature = "asm-aarch64", target_arch = "aarch64", not(target_os = "linux")))]
+compile_error!("Your OS isn’t yet supported for runtime-checking of AArch64 features.");
+#[cfg(all(feature = "asm-aarch64", target_os = "linux", not(target_arch = "aarch64")))]
+compile_error!("Enable the \"asm\" feature instead of \"asm-aarch64\" on non-AArch64 Linux systems.");
+#[cfg(all(not(feature = "asm-aarch64"), feature = "asm", target_arch = "aarch64", target_os = "linux"))]
+compile_error!("Enable the \"asm-aarch64\" feature on AArch64 if you want to use asm.");
+
 extern crate block_buffer;
 extern crate fake_simd as simd;
 #[macro_use] extern crate opaque_debug;
@@ -65,12 +74,16 @@ extern crate fake_simd as simd;
 extern crate sha2_asm;
 #[cfg(feature = "std")]
 extern crate std;
+#[cfg(feature = "asm-aarch64")]
+extern crate libc;
 
 mod consts;
-#[cfg(not(feature = "asm"))]
+#[cfg(any(not(feature = "asm"), feature = "asm-aarch64"))]
 mod sha256_utils;
-#[cfg(not(feature = "asm"))]
+#[cfg(any(not(feature = "asm"), feature = "asm-aarch64"))]
 mod sha512_utils;
+#[cfg(feature = "asm-aarch64")]
+mod aarch64;
 mod sha256;
 mod sha512;
 

sha2/src/sha256.rs

@@ -24,10 +24,24 @@ struct Engine256State {
 impl Engine256State {
     fn new(h: &[u32; STATE_LEN]) -> Engine256State { Engine256State { h: *h } }
 
+    #[cfg(not(feature = "asm-aarch64"))]
     pub fn process_block(&mut self, block: &Block) {
         let block = unsafe { &*(block.as_ptr() as *const [u8; 64]) };
         compress256(&mut self.h, block);
     }
+
+    #[cfg(feature = "asm-aarch64")]
+    pub fn process_block(&mut self, block: &Block) {
+        let block = unsafe { &*(block.as_ptr() as *const [u8; 64]) };
+        // TODO: Replace this platform-specific call with is_aarch64_feature_detected!("sha2") once
+        // that macro is stabilised and https://github.com/rust-lang/rfcs/pull/2725 is implemented
+        // to let us use it on no_std.
+        if ::aarch64::sha2_supported() {
+            compress256(&mut self.h, block);
+        } else {
+            ::sha256_utils::compress256(&mut self.h, block);
+        }
+    }
 }
 
 /// A structure that keeps track of the state of the Sha-256 operation and

sha2/src/sha512.rs

@@ -6,9 +6,9 @@ use block_buffer::byteorder::{BE, ByteOrder};
 
 use consts::{STATE_LEN, H384, H512, H512_TRUNC_224, H512_TRUNC_256};
 
-#[cfg(not(feature = "asm"))]
+#[cfg(any(not(feature = "asm"), feature = "asm-aarch64"))]
 use sha512_utils::compress512;
-#[cfg(feature = "asm")]
+#[cfg(all(feature = "asm", not(feature = "asm-aarch64")))]
 use sha2_asm::compress512;
 
 type BlockSize = U128;