Add a precompiled wasm lib

Also the pure Rust fallback now works even on non x86_64/aarch64
targets. This greatly simplifies everything, allows the same
set of features to be supported by all targets.

benches/benchmark.rs

@@ -1,31 +1,16 @@
 use aegis::aegis128l::Aegis128L;
 use aegis::aegis256::Aegis256;
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 use aegis::aegis128x2::Aegis128X2;
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 use aegis::aegis128x4::Aegis128X4;
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 use aegis::aegis256x2::Aegis256X2;
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 use aegis::aegis256x4::Aegis256X4;
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    any(target_arch = "wasm32", target_arch = "wasm64")
-)))]
+#[cfg(not(feature = "pure-rust",))]
 use aegis::{aegis128l::Aegis128LMac, aegis128x2::Aegis128X2Mac, aegis128x4::Aegis128X4Mac};
 
 use aes_gcm::{
@@ -96,21 +81,15 @@ fn test_aegis128l(m: &mut [u8]) {
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 fn test_aegis128x2(m: &mut [u8]) {
     let key = [0u8; 16];
     let nonce = [0u8; 16];
     let state = Aegis128X2::<16>::new(&nonce, &key);
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 fn test_aegis128x4(m: &mut [u8]) {
     let key = [0u8; 16];
     let nonce = [0u8; 16];
@@ -125,52 +104,37 @@ fn test_aegis256(m: &mut [u8]) {
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust",))]
 fn test_aegis256x2(m: &mut [u8]) {
     let key = [0u8; 32];
     let nonce = [0u8; 32];
     let state = Aegis256X2::<16>::new(&nonce, &key);
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust"))]
 fn test_aegis256x4(m: &mut [u8]) {
     let key = [0u8; 32];
     let nonce = [0u8; 32];
     let state = Aegis256X4::<16>::new(&nonce, &key);
     state.encrypt_in_place(m, &[]);
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    any(target_arch = "wasm32", target_arch = "wasm64")
-)))]
+#[cfg(not(feature = "pure-rust",))]
 fn test_aegis128l_mac(state: &Aegis128LMac<32>, m: &[u8]) {
     let mut state = state.clone();
     state.update(m);
     state.finalize();
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    any(target_arch = "wasm32", target_arch = "wasm64")
-)))]
+#[cfg(not(feature = "pure-rust",))]
 fn test_aegis128x2_mac(state: &Aegis128X2Mac<32>, m: &[u8]) {
     let mut state = state.clone();
     state.update(m);
     state.finalize();
 }
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    any(target_arch = "wasm32", target_arch = "wasm64")
-)))]
+#[cfg(not(feature = "pure-rust",))]
 fn test_aegis128x4_mac(state: &Aegis128X4Mac<32>, m: &[u8]) {
     let mut state = state.clone();
     state.update(m);
@@ -198,10 +162,7 @@ fn main() {
         ..Default::default()
     };
 
-    #[cfg(not(any(
-        feature = "pure-rust",
-        any(target_arch = "wasm32", target_arch = "wasm64")
-    )))]
+    #[cfg(not(feature = "pure-rust",))]
     {
         let m = vec![0xd0u8; 65536];
 
@@ -242,10 +203,7 @@ fn main() {
     println!("* Encryption:");
     println!();
 
-    #[cfg(not(any(
-        feature = "pure-rust",
-        not(any(target_arch = "x86_64", target_arch = "aarch64"))
-    )))]
+    #[cfg(not(feature = "pure-rust"))]
     {
         let res = bench.run(options, || test_aegis128x4(&mut m));
         println!("aegis128x4          : {}", res.throughput(m.len() as _));
@@ -257,10 +215,7 @@ fn main() {
     let res = bench.run(options, || test_aegis128l(&mut m));
     println!("aegis128l           : {}", res.throughput(m.len() as _));
 
-    #[cfg(not(any(
-        feature = "pure-rust",
-        not(any(target_arch = "x86_64", target_arch = "aarch64"))
-    )))]
+    #[cfg(not(feature = "pure-rust",))]
     {
         let res = bench.run(options, || test_aegis256x2(&mut m));
         println!("aegis256x2          : {}", res.throughput(m.len() as _));

build.rs

@@ -6,9 +6,11 @@ fn main() {
         return;
     }
     let arch = env::var("CARGO_CFG_TARGET_ARCH").expect("No target arch");
-    match &*arch {
-        "x86_64" | "aarch64" => {}
-        _ => return,
+    if arch == "wasm32" {
+        let src_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+        println!("cargo:rustc-link-lib=static=aegis");
+        println!("cargo:rustc-link-search=native={}/wasm-libs", src_dir);
+        return;
     }
     cc::Build::new()
         .opt_level(3)

src/lib.rs

@@ -4,26 +4,14 @@
 #[cfg(feature = "std")]
 use std::fmt;
 
-#[cfg(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-))]
+#[cfg(feature = "pure-rust")]
 mod pure_rust;
-#[cfg(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-))]
+#[cfg(feature = "pure-rust")]
 pub use pure_rust::*;
 
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust"))]
 mod c;
-#[cfg(not(any(
-    feature = "pure-rust",
-    not(any(target_arch = "x86_64", target_arch = "aarch64"))
-)))]
+#[cfg(not(feature = "pure-rust"))]
 pub use c::*;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]