react-native-quick-crypto 1.0.19 → 1.1.1

package/deps/blake3/c/blake3_c_rust_bindings/build.rs

@@ -1,253 +0,0 @@
-use std::env;
-
-fn defined(var: &str) -> bool {
-    env::var_os(var).is_some()
-}
-
-fn target_components() -> Vec<String> {
-    let target = env::var("TARGET").unwrap();
-    target.split("-").map(|s| s.to_string()).collect()
-}
-
-fn is_x86_64() -> bool {
-    target_components()[0] == "x86_64"
-}
-
-fn is_windows_target() -> bool {
-    env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows"
-}
-
-fn use_msvc_asm() -> bool {
-    const MSVC_NAMES: &[&str] = &["", "cl", "cl.exe"];
-    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
-    let target_env = env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
-    let target_windows_msvc = target_os == "windows" && target_env == "msvc";
-    let host_triple = env::var("HOST").unwrap_or_default();
-    let target_triple = env::var("TARGET").unwrap_or_default();
-    let cross_compiling = host_triple != target_triple;
-    let cc = env::var("CC").unwrap_or_default().to_ascii_lowercase();
-    if !target_windows_msvc {
-        // We are not building for Windows with the MSVC toolchain.
-        false
-    } else if !cross_compiling && MSVC_NAMES.contains(&&*cc) {
-        // We are building on Windows with the MSVC toolchain (and not cross-compiling for another architecture or target).
-        true
-    } else {
-        // We are cross-compiling to Windows with the MSVC toolchain.
-        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 cc = env::var(format!("CC_{target_arch}_{target_vendor}_windows_msvc"))
-            .unwrap_or_default()
-            .to_ascii_lowercase();
-        // Check if we are using the MSVC compiler.
-        MSVC_NAMES.contains(&&*cc)
-    }
-}
-
-fn is_x86_32() -> bool {
-    let arch = &target_components()[0];
-    arch == "i386" || arch == "i586" || arch == "i686"
-}
-
-fn is_armv7() -> bool {
-    target_components()[0] == "armv7"
-}
-
-fn is_aarch64() -> bool {
-    target_components()[0] == "aarch64"
-}
-
-// Windows targets may be using the MSVC toolchain or the GNU toolchain. The
-// right compiler flags to use depend on the toolchain. (And we don't want to
-// use flag_if_supported, because we don't want features to be silently
-// disabled by old compilers.)
-fn is_windows_msvc() -> bool {
-    // Some targets are only two components long, so check in steps.
-    target_components()[1] == "pc"
-        && target_components()[2] == "windows"
-        && target_components()[3] == "msvc"
-}
-
-fn new_build() -> cc::Build {
-    let mut build = cc::Build::new();
-    if !is_windows_msvc() {
-        build.flag("-std=c11");
-    }
-    build
-}
-
-fn new_cpp_build() -> cc::Build {
-    let mut build = cc::Build::new();
-    build.cpp(true);
-    if is_windows_msvc() {
-        build.flag("/std:c++20");
-        build.flag("/EHs-c-");
-        build.flag("/GR-");
-    } else {
-        build.flag("-std=c++20");
-        build.flag("-fno-exceptions");
-        build.flag("-fno-rtti");
-    }
-    build
-}
-
-fn c_dir_path(filename: &str) -> String {
-    // The `cross` tool doesn't support reading files in parent directories. As a hacky workaround
-    // in `cross_test.sh`, we move the c/ directory around and set BLAKE3_C_DIR_OVERRIDE. Regular
-    // building and testing doesn't require this.
-    if let Ok(c_dir_override) = env::var("BLAKE3_C_DIR_OVERRIDE") {
-        c_dir_override + "/" + filename
-    } else {
-        "../".to_string() + filename
-    }
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut base_build = new_build();
-    base_build.file(c_dir_path("blake3.c"));
-    base_build.file(c_dir_path("blake3_dispatch.c"));
-    base_build.file(c_dir_path("blake3_portable.c"));
-    if cfg!(feature = "tbb") {
-        base_build.define("BLAKE3_USE_TBB", "1");
-    }
-    base_build.compile("blake3_base");
-
-    if cfg!(feature = "tbb") {
-        let mut tbb_build = new_cpp_build();
-        tbb_build.define("BLAKE3_USE_TBB", "1");
-        tbb_build.file(c_dir_path("blake3_tbb.cpp"));
-        tbb_build.compile("blake3_tbb");
-        println!("cargo::rustc-link-lib=tbb");
-    }
-
-    if is_x86_64() && !defined("CARGO_FEATURE_PREFER_INTRINSICS") {
-        // On 64-bit, use the assembly implementations, unless the
-        // "prefer_intrinsics" feature is enabled.
-        if is_windows_target() {
-            if use_msvc_asm() {
-                let mut build = new_build();
-                build.file(c_dir_path("blake3_sse2_x86-64_windows_msvc.asm"));
-                build.file(c_dir_path("blake3_sse41_x86-64_windows_msvc.asm"));
-                build.file(c_dir_path("blake3_avx2_x86-64_windows_msvc.asm"));
-                build.file(c_dir_path("blake3_avx512_x86-64_windows_msvc.asm"));
-                build.compile("blake3_asm");
-            } else {
-                let mut build = new_build();
-                build.file(c_dir_path("blake3_sse2_x86-64_windows_gnu.S"));
-                build.file(c_dir_path("blake3_sse41_x86-64_windows_gnu.S"));
-                build.file(c_dir_path("blake3_avx2_x86-64_windows_gnu.S"));
-                build.file(c_dir_path("blake3_avx512_x86-64_windows_gnu.S"));
-                build.compile("blake3_asm");
-            }
-        } else {
-            // All non-Windows implementations are assumed to support
-            // Linux-style assembly. These files do contain a small
-            // explicit workaround for macOS also.
-            let mut build = new_build();
-            build.file(c_dir_path("blake3_sse2_x86-64_unix.S"));
-            build.file(c_dir_path("blake3_sse41_x86-64_unix.S"));
-            build.file(c_dir_path("blake3_avx2_x86-64_unix.S"));
-            build.file(c_dir_path("blake3_avx512_x86-64_unix.S"));
-            build.compile("blake3_asm");
-        }
-    } else if is_x86_64() || is_x86_32() {
-        // Assembly implementations are only for 64-bit. On 32-bit, or if
-        // the "prefer_intrinsics" feature is enabled, use the
-        // intrinsics-based C implementations. These each need to be
-        // compiled separately, with the corresponding instruction set
-        // extension explicitly enabled in the compiler.
-
-        let mut sse2_build = new_build();
-        sse2_build.file(c_dir_path("blake3_sse2.c"));
-        if is_windows_msvc() {
-            // /arch:SSE2 is the default on x86 and undefined on x86_64:
-            // https://docs.microsoft.com/en-us/cpp/build/reference/arch-x86
-            // It also includes SSE4.1 intrinsics:
-            // https://stackoverflow.com/a/32183222/823869
-        } else {
-            sse2_build.flag("-msse2");
-        }
-        sse2_build.compile("blake3_sse2");
-
-        let mut sse41_build = new_build();
-        sse41_build.file(c_dir_path("blake3_sse41.c"));
-        if is_windows_msvc() {
-            // /arch:SSE2 is the default on x86 and undefined on x86_64:
-            // https://docs.microsoft.com/en-us/cpp/build/reference/arch-x86
-            // It also includes SSE4.1 intrinsics:
-            // https://stackoverflow.com/a/32183222/823869
-        } else {
-            sse41_build.flag("-msse4.1");
-        }
-        sse41_build.compile("blake3_sse41");
-
-        let mut avx2_build = new_build();
-        avx2_build.file(c_dir_path("blake3_avx2.c"));
-        if is_windows_msvc() {
-            avx2_build.flag("/arch:AVX2");
-        } else {
-            avx2_build.flag("-mavx2");
-        }
-        avx2_build.compile("blake3_avx2");
-
-        let mut avx512_build = new_build();
-        avx512_build.file(c_dir_path("blake3_avx512.c"));
-        if is_windows_msvc() {
-            // Note that a lot of versions of MSVC don't support /arch:AVX512,
-            // and they'll discard it with a warning, hopefully leading to a
-            // build error.
-            avx512_build.flag("/arch:AVX512");
-        } else {
-            avx512_build.flag("-mavx512f");
-            avx512_build.flag("-mavx512vl");
-        }
-        avx512_build.compile("blake3_avx512");
-    }
-
-    // We only build NEON code here if
-    // 1) it's requested
-    // and 2) the root crate is not already building it.
-    // The only time this will really happen is if you build this
-    // crate by hand with the "neon" feature for some reason.
-    //
-    // In addition, 3) if the target is aarch64, NEON is on by default.
-    if defined("CARGO_FEATURE_NEON") || is_aarch64() {
-        let mut neon_build = new_build();
-        neon_build.file(c_dir_path("blake3_neon.c"));
-        // ARMv7 platforms that support NEON generally need the following
-        // flags. AArch64 supports NEON by default and does not support -mpfu.
-        if is_armv7() {
-            neon_build.flag("-mfpu=neon-vfpv4");
-            neon_build.flag("-mfloat-abi=hard");
-        }
-        neon_build.compile("blake3_neon");
-    }
-
-    // The `cc` crate does not automatically emit rerun-if directives for the
-    // environment variables it supports, in particular for $CC. We expect to
-    // do a lot of benchmarking across different compilers, so we explicitly
-    // add the variables that we're likely to need.
-    println!("cargo:rerun-if-env-changed=CC");
-    println!("cargo:rerun-if-env-changed=CFLAGS");
-
-    // Ditto for source files, though these shouldn't change as often. `ignore::Walk` respects
-    // .gitignore, so this doesn't traverse target/.
-    for result in ignore::Walk::new("..") {
-        let result = result?;
-        let path = result.path();
-        if path.is_file() {
-            println!("cargo:rerun-if-changed={}", path.to_str().unwrap());
-        }
-    }
-
-    // When compiling with clang-cl for windows, it adds .asm files to the root
-    // which we need to delete so cargo doesn't get angry
-    if is_windows_target() && !use_msvc_asm() {
-        let _ = std::fs::remove_file("blake3_avx2_x86-64_windows_gnu.asm");
-        let _ = std::fs::remove_file("blake3_avx512_x86-64_windows_gnu.asm");
-        let _ = std::fs::remove_file("blake3_sse2_x86-64_windows_gnu.asm");
-        let _ = std::fs::remove_file("blake3_sse41_x86-64_windows_gnu.asm");
-    }
-
-    Ok(())
-}

package/deps/blake3/c/blake3_c_rust_bindings/cross_test.sh

@@ -1,31 +0,0 @@
-#! /usr/bin/env bash
-
-# This hacky script works around the fact that `cross test` does not support
-# path dependencies. (It uses a docker shared folder to let the guest access
-# project files, so parent directories aren't available.) Solve this problem by
-# copying the entire project to a temp dir and rearranging paths to put "c" and
-# "reference_impl" underneath "blake3_c_rust_bindings", so that everything is
-# accessible. Hopefully this will just run on CI forever and no one will ever
-# read this and discover my deep shame.
-
-set -e -u -o pipefail
-
-project_root="$(realpath "$(dirname "$BASH_SOURCE")/../..")"
-tmpdir="$(mktemp -d)"
-echo "Running cross tests in $tmpdir"
-cd "$tmpdir"
-git clone "$project_root" blake3
-mv blake3/c/blake3_c_rust_bindings .
-mv blake3/reference_impl blake3_c_rust_bindings
-mv blake3/c blake3_c_rust_bindings
-cd blake3_c_rust_bindings
-sed -i 's|reference_impl = { path = "../../reference_impl" }|reference_impl = { path = "reference_impl" }|' Cargo.toml
-
-export BLAKE3_C_DIR_OVERRIDE="./c"
-cat > Cross.toml << EOF
-[build.env]
-passthrough = [
-    "BLAKE3_C_DIR_OVERRIDE",
-]
-EOF
-cross test "$@"

package/deps/blake3/c/blake3_c_rust_bindings/src/lib.rs

@@ -1,333 +0,0 @@
-//! These are Rust bindings for the C implementation of BLAKE3. As there is a
-//! native (and faster) Rust implementation of BLAKE3 provided in this same
-//! repo, these bindings are not expected to be used in production. They're
-//! intended for testing and benchmarking.
-
-use std::ffi::{c_void, CString};
-use std::mem::MaybeUninit;
-
-#[cfg(test)]
-mod test;
-
-pub const BLOCK_LEN: usize = 64;
-pub const CHUNK_LEN: usize = 1024;
-pub const OUT_LEN: usize = 32;
-
-// Feature detection functions for tests and benchmarks. Note that the C code
-// does its own feature detection in blake3_dispatch.c.
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn sse2_detected() -> bool {
-    is_x86_feature_detected!("sse2")
-}
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn sse41_detected() -> bool {
-    is_x86_feature_detected!("sse4.1")
-}
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn avx2_detected() -> bool {
-    is_x86_feature_detected!("avx2")
-}
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn avx512_detected() -> bool {
-    is_x86_feature_detected!("avx512f") && is_x86_feature_detected!("avx512vl")
-}
-
-#[derive(Clone)]
-pub struct Hasher(ffi::blake3_hasher);
-
-impl Hasher {
-    pub fn new() -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        unsafe {
-            ffi::blake3_hasher_init(c_state.as_mut_ptr());
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn new_keyed(key: &[u8; 32]) -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        unsafe {
-            ffi::blake3_hasher_init_keyed(c_state.as_mut_ptr(), key.as_ptr());
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn new_derive_key(context: &str) -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        let context_c_string = CString::new(context).expect("valid C string, no null bytes");
-        unsafe {
-            ffi::blake3_hasher_init_derive_key(c_state.as_mut_ptr(), context_c_string.as_ptr());
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn new_derive_key_raw(context: &[u8]) -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        unsafe {
-            ffi::blake3_hasher_init_derive_key_raw(
-                c_state.as_mut_ptr(),
-                context.as_ptr() as *const _,
-                context.len(),
-            );
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn update(&mut self, input: &[u8]) {
-        unsafe {
-            ffi::blake3_hasher_update(&mut self.0, input.as_ptr() as *const c_void, input.len());
-        }
-    }
-
-    #[cfg(feature = "tbb")]
-    pub fn update_tbb(&mut self, input: &[u8]) {
-        unsafe {
-            ffi::blake3_hasher_update_tbb(
-                &mut self.0,
-                input.as_ptr() as *const c_void,
-                input.len(),
-            );
-        }
-    }
-
-    pub fn finalize(&self, output: &mut [u8]) {
-        unsafe {
-            ffi::blake3_hasher_finalize(&self.0, output.as_mut_ptr(), output.len());
-        }
-    }
-
-    pub fn finalize_seek(&self, seek: u64, output: &mut [u8]) {
-        unsafe {
-            ffi::blake3_hasher_finalize_seek(&self.0, seek, output.as_mut_ptr(), output.len());
-        }
-    }
-
-    pub fn reset(&mut self) {
-        unsafe {
-            ffi::blake3_hasher_reset(&mut self.0);
-        }
-    }
-}
-
-pub mod ffi {
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub struct blake3_chunk_state {
-        pub cv: [u32; 8usize],
-        pub chunk_counter: u64,
-        pub buf: [u8; 64usize],
-        pub buf_len: u8,
-        pub blocks_compressed: u8,
-        pub flags: u8,
-    }
-
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub struct blake3_hasher {
-        pub key: [u32; 8usize],
-        pub chunk: blake3_chunk_state,
-        pub cv_stack_len: u8,
-        pub cv_stack: [u8; 1728usize],
-    }
-
-    extern "C" {
-        // public interface
-        pub fn blake3_hasher_init(self_: *mut blake3_hasher);
-        pub fn blake3_hasher_init_keyed(self_: *mut blake3_hasher, key: *const u8);
-        pub fn blake3_hasher_init_derive_key(
-            self_: *mut blake3_hasher,
-            context: *const ::std::os::raw::c_char,
-        );
-        pub fn blake3_hasher_init_derive_key_raw(
-            self_: *mut blake3_hasher,
-            context: *const ::std::os::raw::c_void,
-            context_len: usize,
-        );
-        pub fn blake3_hasher_update(
-            self_: *mut blake3_hasher,
-            input: *const ::std::os::raw::c_void,
-            input_len: usize,
-        );
-        #[cfg(feature = "tbb")]
-        pub fn blake3_hasher_update_tbb(
-            self_: *mut blake3_hasher,
-            input: *const ::std::os::raw::c_void,
-            input_len: usize,
-        );
-        pub fn blake3_hasher_finalize(self_: *const blake3_hasher, out: *mut u8, out_len: usize);
-        pub fn blake3_hasher_finalize_seek(
-            self_: *const blake3_hasher,
-            seek: u64,
-            out: *mut u8,
-            out_len: usize,
-        );
-        pub fn blake3_hasher_reset(self_: *mut blake3_hasher);
-
-        // portable low-level functions
-        pub fn blake3_compress_in_place_portable(
-            cv: *mut u32,
-            block: *const u8,
-            block_len: u8,
-            counter: u64,
-            flags: u8,
-        );
-        pub fn blake3_compress_xof_portable(
-            cv: *const u32,
-            block: *const u8,
-            block_len: u8,
-            counter: u64,
-            flags: u8,
-            out: *mut u8,
-        );
-        pub fn blake3_hash_many_portable(
-            inputs: *const *const u8,
-            num_inputs: usize,
-            blocks: usize,
-            key: *const u32,
-            counter: u64,
-            increment_counter: bool,
-            flags: u8,
-            flags_start: u8,
-            flags_end: u8,
-            out: *mut u8,
-        );
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    pub mod x86 {
-        extern "C" {
-            // SSE2 low level functions
-            pub fn blake3_compress_in_place_sse2(
-                cv: *mut u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-            );
-            pub fn blake3_compress_xof_sse2(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-            );
-            pub fn blake3_hash_many_sse2(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-
-            // SSE4.1 low level functions
-            pub fn blake3_compress_in_place_sse41(
-                cv: *mut u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-            );
-            pub fn blake3_compress_xof_sse41(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-            );
-            pub fn blake3_hash_many_sse41(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-
-            // AVX2 low level functions
-            pub fn blake3_hash_many_avx2(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-
-            // AVX-512 low level functions
-            pub fn blake3_compress_xof_avx512(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-            );
-            pub fn blake3_compress_in_place_avx512(
-                cv: *mut u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-            );
-            pub fn blake3_hash_many_avx512(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-            #[cfg(unix)]
-            pub fn blake3_xof_many_avx512(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-                outblocks: usize,
-            );
-        }
-    }
-
-    #[cfg(feature = "neon")]
-    pub mod neon {
-        extern "C" {
-            // NEON low level functions
-            pub fn blake3_hash_many_neon(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-        }
-    }
-}