react-native-quick-crypto 1.0.19 → 1.1.1

package/deps/blake3/src/ffi_neon.rs

@@ -1,82 +0,0 @@
-use crate::{CVWords, IncrementCounter, BLOCK_LEN, OUT_LEN};
-
-// Unsafe because this may only be called on platforms supporting NEON.
-pub unsafe fn hash_many<const N: usize>(
-    inputs: &[&[u8; N]],
-    key: &CVWords,
-    counter: u64,
-    increment_counter: IncrementCounter,
-    flags: u8,
-    flags_start: u8,
-    flags_end: u8,
-    out: &mut [u8],
-) {
-    // The Rust hash_many implementations do bounds checking on the `out`
-    // array, but the C implementations don't. Even though this is an unsafe
-    // function, assert the bounds here.
-    assert!(out.len() >= inputs.len() * OUT_LEN);
-    ffi::blake3_hash_many_neon(
-        inputs.as_ptr() as *const *const u8,
-        inputs.len(),
-        N / BLOCK_LEN,
-        key.as_ptr(),
-        counter,
-        increment_counter.yes(),
-        flags,
-        flags_start,
-        flags_end,
-        out.as_mut_ptr(),
-    )
-}
-
-// blake3_neon.c normally depends on blake3_portable.c, because the NEON
-// implementation only provides 4x compression, and it relies on the portable
-// implementation for 1x compression. However, we expose the portable Rust
-// implementation here instead, to avoid linking in unnecessary code.
-#[no_mangle]
-pub extern "C" fn blake3_compress_in_place_portable(
-    cv: *mut u32,
-    block: *const u8,
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-) {
-    unsafe {
-        crate::portable::compress_in_place(
-            &mut *(cv as *mut [u32; 8]),
-            &*(block as *const [u8; 64]),
-            block_len,
-            counter,
-            flags,
-        )
-    }
-}
-
-pub mod ffi {
-    extern "C" {
-        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,
-        );
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_hash_many() {
-        // This entire file is gated on feature="neon", so NEON support is
-        // assumed here.
-        crate::test::test_hash_many_fn(hash_many, hash_many);
-    }
-}

package/deps/blake3/src/ffi_sse2.rs

@@ -1,126 +0,0 @@
-use crate::{CVWords, IncrementCounter, BLOCK_LEN, OUT_LEN};
-
-// Unsafe because this may only be called on platforms supporting SSE2.
-pub unsafe fn compress_in_place(
-    cv: &mut CVWords,
-    block: &[u8; BLOCK_LEN],
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-) {
-    unsafe {
-        ffi::blake3_compress_in_place_sse2(
-            cv.as_mut_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-        )
-    }
-}
-
-// Unsafe because this may only be called on platforms supporting SSE2.
-pub unsafe fn compress_xof(
-    cv: &CVWords,
-    block: &[u8; BLOCK_LEN],
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-) -> [u8; 64] {
-    unsafe {
-        let mut out = [0u8; 64];
-        ffi::blake3_compress_xof_sse2(
-            cv.as_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-            out.as_mut_ptr(),
-        );
-        out
-    }
-}
-
-// Unsafe because this may only be called on platforms supporting SSE2.
-pub unsafe fn hash_many<const N: usize>(
-    inputs: &[&[u8; N]],
-    key: &CVWords,
-    counter: u64,
-    increment_counter: IncrementCounter,
-    flags: u8,
-    flags_start: u8,
-    flags_end: u8,
-    out: &mut [u8],
-) {
-    unsafe {
-        // The Rust hash_many implementations do bounds checking on the `out`
-        // array, but the C implementations don't. Even though this is an unsafe
-        // function, assert the bounds here.
-        assert!(out.len() >= inputs.len() * OUT_LEN);
-        ffi::blake3_hash_many_sse2(
-            inputs.as_ptr() as *const *const u8,
-            inputs.len(),
-            N / BLOCK_LEN,
-            key.as_ptr(),
-            counter,
-            increment_counter.yes(),
-            flags,
-            flags_start,
-            flags_end,
-            out.as_mut_ptr(),
-        )
-    }
-}
-
-pub mod ffi {
-    extern "C" {
-        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,
-        );
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_compress() {
-        if !crate::platform::sse2_detected() {
-            return;
-        }
-        crate::test::test_compress_fn(compress_in_place, compress_xof);
-    }
-
-    #[test]
-    fn test_hash_many() {
-        if !crate::platform::sse2_detected() {
-            return;
-        }
-        crate::test::test_hash_many_fn(hash_many, hash_many);
-    }
-}

package/deps/blake3/src/ffi_sse41.rs

@@ -1,126 +0,0 @@
-use crate::{CVWords, IncrementCounter, BLOCK_LEN, OUT_LEN};
-
-// Unsafe because this may only be called on platforms supporting SSE4.1.
-pub unsafe fn compress_in_place(
-    cv: &mut CVWords,
-    block: &[u8; BLOCK_LEN],
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-) {
-    unsafe {
-        ffi::blake3_compress_in_place_sse41(
-            cv.as_mut_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-        )
-    }
-}
-
-// Unsafe because this may only be called on platforms supporting SSE4.1.
-pub unsafe fn compress_xof(
-    cv: &CVWords,
-    block: &[u8; BLOCK_LEN],
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-) -> [u8; 64] {
-    unsafe {
-        let mut out = [0u8; 64];
-        ffi::blake3_compress_xof_sse41(
-            cv.as_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-            out.as_mut_ptr(),
-        );
-        out
-    }
-}
-
-// Unsafe because this may only be called on platforms supporting SSE4.1.
-pub unsafe fn hash_many<const N: usize>(
-    inputs: &[&[u8; N]],
-    key: &CVWords,
-    counter: u64,
-    increment_counter: IncrementCounter,
-    flags: u8,
-    flags_start: u8,
-    flags_end: u8,
-    out: &mut [u8],
-) {
-    unsafe {
-        // The Rust hash_many implementations do bounds checking on the `out`
-        // array, but the C implementations don't. Even though this is an unsafe
-        // function, assert the bounds here.
-        assert!(out.len() >= inputs.len() * OUT_LEN);
-        ffi::blake3_hash_many_sse41(
-            inputs.as_ptr() as *const *const u8,
-            inputs.len(),
-            N / BLOCK_LEN,
-            key.as_ptr(),
-            counter,
-            increment_counter.yes(),
-            flags,
-            flags_start,
-            flags_end,
-            out.as_mut_ptr(),
-        )
-    }
-}
-
-pub mod ffi {
-    extern "C" {
-        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,
-        );
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_compress() {
-        if !crate::platform::sse41_detected() {
-            return;
-        }
-        crate::test::test_compress_fn(compress_in_place, compress_xof);
-    }
-
-    #[test]
-    fn test_hash_many() {
-        if !crate::platform::sse41_detected() {
-            return;
-        }
-        crate::test::test_hash_many_fn(hash_many, hash_many);
-    }
-}

package/deps/blake3/src/guts.rs

@@ -1,60 +0,0 @@
-//! Deprecated in favor of [`hazmat`](crate::hazmat)
-
-pub use crate::{BLOCK_LEN, CHUNK_LEN};
-
-#[derive(Clone, Debug)]
-pub struct ChunkState(crate::ChunkState);
-
-impl ChunkState {
-    // Currently this type only supports the regular hash mode. If an
-    // incremental user needs keyed_hash or derive_key, we can add that.
-    pub fn new(chunk_counter: u64) -> Self {
-        Self(crate::ChunkState::new(
-            crate::IV,
-            chunk_counter,
-            0,
-            crate::platform::Platform::detect(),
-        ))
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.count()
-    }
-
-    #[inline]
-    pub fn update(&mut self, input: &[u8]) -> &mut Self {
-        self.0.update(input);
-        self
-    }
-
-    pub fn finalize(&self, is_root: bool) -> crate::Hash {
-        let output = self.0.output();
-        if is_root {
-            output.root_hash()
-        } else {
-            output.chaining_value().into()
-        }
-    }
-}
-
-// As above, this currently assumes the regular hash mode. If an incremental
-// user needs keyed_hash or derive_key, we can add that.
-pub fn parent_cv(
-    left_child: &crate::Hash,
-    right_child: &crate::Hash,
-    is_root: bool,
-) -> crate::Hash {
-    let output = crate::parent_node_output(
-        left_child.as_bytes(),
-        right_child.as_bytes(),
-        crate::IV,
-        0,
-        crate::platform::Platform::detect(),
-    );
-    if is_root {
-        output.root_hash()
-    } else {
-        output.chaining_value().into()
-    }
-}