Siphasher

https://docs.rs/siphasher/1.0.2
Admin
Siphasher is a Rust crate that implements the SipHash-2-4 and SipHash-1-3 cryptographic hash...
Tokens:23,585
Snippets:193
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### 128-bit SipHash Incremental Hashing

Source: https://docs.rs/siphasher/1.0.2/siphasher/index.html

Demonstrates incremental hashing with SipHasher13 in 128-bit mode. Use `write` to add data chunks and `finish128` to get the 128-bit tag.

```rust
use core::hash::Hasher;

let array1: &[u8] = &[1, 2, 3];
let array2: &[u8] = &[4, 5, 6];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let mut hasher = SipHasher13::new_with_key(key);
hasher.write(array1);
hasher.write(array2);
let h = hasher.finish128().as_bytes();
```

--------------------------------

### Get SipHasher13 keys

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Retrieves the two 64-bit keys currently used by the SipHasher13 instance.

```rust
pub fn keys(&self) -> (u64, u64) {
        (self.hasher.k0, self.hasher.k1)
    }
```

--------------------------------

### Get SipHasher13 key as a 16-byte array

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Returns the 16-byte key used by the SipHasher13 instance, reconstructed from its internal 64-bit key components.

```rust
pub fn key(&self) -> [u8; 16] {
        let mut bytes = [0u8; 16];
        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
        bytes
    }
```

--------------------------------

### Get SipHasher Keys

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Retrieves the two u64 keys currently used by the SipHasher instance. This can be useful for debugging or understanding the hasher's state.

```rust
pub fn keys(&self) -> (u64, u64)
```

--------------------------------

### Get SipHasher Key as 16-byte Array

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Retrieves the key used by the SipHasher as a 16-byte array. This provides a consolidated view of the hasher's key.

```rust
pub fn key(&self) -> [u8; 16]
```

--------------------------------

### Initialize Hasher with keys

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Creates a new Hasher instance with specified 64-bit keys and resets its internal state.

```rust
fn new_with_keys(key0: u64, key1: u64) -> Hasher<S> {
        let mut state = Hasher {
            k0: key0,
            k1: key1,
            length: 0,
            state: State {
                v0: 0,
                v1: 0,
                v2: 0,
                v3: 0,
            },
            tail: 0,
            ntail: 0,
            _marker: PhantomData,
        };
        state.reset();
        state
    }
```

--------------------------------

### Get Type ID

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Gets the `TypeId` of the current type. This is a blanket implementation for any type that is 'static and sized.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### SipHasher13 Initialization and Hashing

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Details on creating and using SipHasher13, including key management and hashing byte arrays.

```APIDOC
## SipHasher13

### Description
Provides methods for creating and using SipHasher13, including initialization with default or custom keys, retrieving keys, and hashing byte arrays.

### Methods

#### `new()`
Creates a new `SipHasher13` with the two initial keys set to 0.

#### `new_with_keys(key0: u64, key1: u64)`
Creates a `SipHasher13` that is keyed off the provided keys.

#### `new_with_key(key: &[u8; 16])`
Creates a `SipHasher13` from a 16 byte key.

#### `keys()`
Get the keys used by this hasher.
Returns: (u64, u64) - A tuple containing the two keys.

#### `key()`
Get the key used by this hasher as a 16 byte vector.
Returns: [u8; 16] - A 16-byte array representing the key.

#### `hash(bytes: &[u8])`
Hash a byte array - This is the easiest and safest way to use SipHash.
Returns: Hash128 - The 128-bit hash result.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Hash128** (type) - The 128-bit hash result.

#### Response Example
None
```

--------------------------------

### Create SipHasher24 with specified keys

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Initializes a SipHasher24 instance using two provided 64-bit unsigned integers as keys.

```rust
pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher24 {
        SipHasher24 {
            hasher: Hasher::new_with_keys(key0, key1),
        }
    }
```

--------------------------------

### SipHasher Initialization

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Methods for creating and configuring a new SipHasher instance with specific keys.

```APIDOC
## SipHasher Initialization

### Description
Creates a new instance of SipHasher, which is an implementation of SipHash128 2-4. It can be initialized with default keys (0, 0) or custom keys.

### Methods
- **new()**: Creates a new SipHasher with keys set to 0.
- **new_with_keys(key0: u64, key1: u64)**: Creates a SipHasher with the provided 64-bit keys.
- **new_with_key(key: &[u8; 16])**: Creates a SipHasher from a 16-byte array key.

### Parameters
#### Request Parameters
- **key0** (u64) - Required - First 64-bit key.
- **key1** (u64) - Required - Second 64-bit key.
- **key** ([u8; 16]) - Required - 16-byte key array.

### Response
- **SipHasher** (Object) - Returns a configured SipHasher instance.
```

--------------------------------

### Get 128-bit Hash Value

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Returns the computed 128-bit hash value for all data written to the hasher. This method is part of the Hasher128 trait.

```rust
fn finish128(&self) -> Hash128
```

--------------------------------

### SipHasher24 Initialization and Hashing

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher24.html

Methods to create a new SipHasher24 instance and perform hashing on data.

```APIDOC
## SipHasher24 Methods

### new()
Creates a new `SipHasher24` with the two initial keys set to 0.

### new_with_keys(key0: u64, key1: u64)
Creates a `SipHasher24` that is keyed off the provided keys.

### new_with_key(key: &[u8; 16])
Creates a `SipHasher24` from a 16 byte key.

### keys()
Get the keys used by this hasher. Returns `(u64, u64)`.

### key()
Get the key used by this hasher as a 16 byte vector. Returns `[u8; 16]`.

### hash(bytes: &[u8])
Hash a byte array. Returns `Hash128`.
```

--------------------------------

### Get Final Hash Value (u64)

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Returns the computed u64 hash value for all data written to the hasher so far. This is part of the Hasher trait.

```rust
fn finish(&self) -> u64
```

--------------------------------

### SipHasher Initialization and Hashing

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Methods for creating new instances of SipHasher and performing hashing operations.

```APIDOC
## SipHasher Initialization

### new()
Creates a new `SipHasher` with the two initial keys set to 0.

### new_with_keys(key0: u64, key1: u64)
Creates a `SipHasher` that is keyed off the provided keys.

### new_with_key(key: &[u8; 16])
Creates a `SipHasher` from a 16 byte key.

## Hashing Operations

### hash(bytes: &[u8]) -> Hash128
Hash a byte array. This is the easiest and safest way to use SipHash.

### keys() -> (u64, u64)
Get the keys used by this hasher.

### key() -> [u8; 16]
Get the key used by this hasher as a 16 byte vector.
```

--------------------------------

### Implement 64-bit SipHash

Source: https://docs.rs/siphasher/1.0.2/siphasher

Use the sip module for standard 64-bit hashing. Supports both one-shot and incremental hashing patterns.

```rust
use siphasher::sip::{SipHasher, SipHasher13, SipHasher24};

// one-shot:

let array: &[u8] = &[1, 2, 3];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let hasher = SipHasher13::new_with_key(key);
let h = hasher.hash(array);

// incremental:

use core::hash::Hasher;

let array1: &[u8] = &[1, 2, 3];
let array2: &[u8] = &[4, 5, 6];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let mut hasher = SipHasher13::new_with_key(key);
hasher.write(array1);
hasher.write(array2);
let h = hasher.finish();
```

--------------------------------

### Create SipHasher13 with Default Keys

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher13.html

Creates a new SipHasher13 instance with both initial keys set to 0. This is the simplest way to initialize the hasher.

```rust
pub fn new() -> SipHasher13
```

--------------------------------

### Hasher Internal Initialization

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Internal method for initializing the Hasher with keys.

```APIDOC
## Hasher<S: Sip>

### Description
Internal method for initializing the Hasher with keys and resetting its state.

### Method
`new_with_keys(key0: u64, key1: u64)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Hasher<S>** (type) - The initialized Hasher object.

#### Response Example
None
```

--------------------------------

### Create SipHasher24 with a 16-byte key

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Initializes a SipHasher24 instance using a provided 16-byte key. The key is split into two 64-bit unsigned integers.

```rust
pub fn new_with_key(key: &[u8; 16]) -> SipHasher24 {
        let mut b0 = [0u8; 8];
        let mut b1 = [0u8; 8];
        b0.copy_from_slice(&key[0..8]);
        b1.copy_from_slice(&key[8..16]);
        let key0 = u64::from_le_bytes(b0);
        let key1 = u64::from_le_bytes(b1);
        Self::new_with_keys(key0, key1)
    }
```

--------------------------------

### SipHash Compression and Loading Macros

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/common.rs.html

Macros for performing the SipHash compression round and loading integers from byte streams in little-endian order.

```rust
/// Compression round for SipHash algorithm.
macro_rules! compress {
    ($state:expr) => {{
        compress!($state.v0, $state.v1, $state.v2, $state.v3)
    }};
    ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {{
        $v0 = $v0.wrapping_add($v1);
        $v1 = $v1.rotate_left(13);
        $v1 ^= $v0;
        $v0 = $v0.rotate_left(32);
        $v2 = $v2.wrapping_add($v3);
        $v3 = $v3.rotate_left(16);
        $v3 ^= $v2;
        $v0 = $v0.wrapping_add($v3);
        $v3 = $v3.rotate_left(21);
        $v3 ^= $v0;
        $v2 = $v2.wrapping_add($v1);
        $v1 = $v1.rotate_left(17);
        $v1 ^= $v2;
        $v2 = $v2.rotate_left(32);
    }};
}

/// Loads an integer of the desired type from a byte stream, in LE order.
macro_rules! load_int_le {
    ($buf:expr, $i:expr, $int_ty:ident) => {{
        debug_assert!($i + ::core::mem::size_of::<$int_ty>() <= $buf.len());
        let mut data = 0 as $int_ty;
        ::core::ptr::copy_nonoverlapping(
            $buf.as_ptr().add($i),
            &mut data as *mut _ as *mut u8,
            ::core::mem::size_of::<$int_ty>(),
        );
        data.to_le()
    }};
}
```

--------------------------------

### 64-bit SipHash One-Shot Hashing

Source: https://docs.rs/siphasher/1.0.2/siphasher/index.html

Demonstrates one-shot hashing using SipHasher13 in 64-bit mode. Requires a 16-byte key and the data to be hashed as a byte slice.

```rust
use siphasher::sip::{SipHasher, SipHasher13, SipHasher24};

// one-shot:

let array: &[u8] = &[1, 2, 3];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let hasher = SipHasher13::new_with_key(key);
let h = hasher.hash(array);
```

--------------------------------

### Create New SipHasher with Default Keys

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Creates a new SipHasher instance with both initial keys set to 0. This is the simplest way to initialize the hasher if no specific keys are required.

```rust
pub fn new() -> SipHasher
```

--------------------------------

### Create SipHasher24 with default keys

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Initializes a SipHasher24 instance with both internal keys set to 0.

```rust
pub fn new() -> SipHasher24 {
        SipHasher24::new_with_keys(0, 0)
    }
```

--------------------------------

### Siphasher Crate Overview

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/index.html

Provides an overview of the siphasher crate and its core components.

```APIDOC
## Siphasher Crate

An implementation of SipHash.

### Structs

- **SipHasher**: An implementation of SipHash 2-4.
- **SipHasher13**: An implementation of SipHash 1-3.
- **SipHasher24**: An implementation of SipHash 2-4.
```

--------------------------------

### Create SipHasher with Custom Keys

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Creates a SipHasher instance keyed off two provided u64 keys. This allows for custom seeding of the hashing algorithm.

```rust
pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher
```

--------------------------------

### Library Module Definitions and Configuration

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/lib.rs.html

Defines the crate's internal modules, handles no_std configuration, and exposes optional Serde re-exports based on feature flags.

```rust
1#![doc = include_str!("../README.md")]
2#![cfg_attr(not(test), no_std)]
3#![allow(clippy::unreadable_literal)]
4#![allow(clippy::cast_lossless)]
5#![allow(clippy::many_single_char_names)]
6
7mod common;
8pub mod sip;
9pub mod sip128;
10
11#[cfg(test)]
12mod tests;
13
14#[cfg(test)]
15mod tests128;
16
17#[cfg(any(feature = "serde", feature = "serde_std", feature = "serde_no_std"))]
18pub mod reexports {
19    pub use serde;
20    #[cfg(feature = "serde_json")]
21    pub use serde_json;
22}
23
24pub mod prelude {
25    pub use core::hash::Hasher as _;
26
27    pub use sip128::Hasher128 as _;
28
29    pub use crate::{sip, sip128};
30}
```

--------------------------------

### Default Hasher Creation

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Provides a default implementation for creating a Hasher<S> instance with initial keys set to zero. This is useful for basic hashing needs where custom keys are not required.

```rust
impl<S: Sip> Default for Hasher<S> {
    /// Creates a `Hasher<S>` with the two initial keys set to 0.
    #[inline]
    fn default() -> Hasher<S> {
        Hasher::new_with_keys(0, 0)
    }
}
```

--------------------------------

### SipHasher::new_with_key()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Creates a `SipHasher` instance from a 16-byte array key. The key is split into two 64-bit values for initialization.

```rust
/// Creates a `SipHasher` from a 16 byte key.
pub fn new_with_key(key: &[u8; 16]) -> SipHasher {
    let mut b0 = [0u8; 8];
    let mut b1 = [0u8; 8];
    b0.copy_from_slice(&key[0..8]);
    b1.copy_from_slice(&key[8..16]);
    let key0 = u64::from_le_bytes(b0);
    let key1 = u64::from_le_bytes(b1);
    Self::new_with_keys(key0, key1)
}
```

--------------------------------

### Create SipHasher13 with Specific Keys

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher13.html

Creates a SipHasher13 instance using two provided 64-bit unsigned integer keys.

```rust
pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13
```

--------------------------------

### SipHasher13::new_with_keys()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Creates a new SipHasher13 instance using the provided 64-bit keys.

```rust
/// Creates a `SipHasher13` that is keyed off the provided keys.
#[inline]
pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 {
    SipHasher13 {
        hasher: Hasher::new_with_keys(key0, key1),
    }
}

```

--------------------------------

### SipHasher::new_with_keys()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Creates a `SipHasher` instance using the provided two `u64` keys. This allows for custom keying of the hash function.

```rust
/// Creates a `SipHasher` that is keyed off the provided keys.
#[inline]
pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher {
    SipHasher(SipHasher24::new_with_keys(key0, key1))
}
```

--------------------------------

### SipHasher API

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Methods for initializing and using the default SipHasher (SipHash 2-4).

```APIDOC
## SipHasher Initialization and Usage

### Description
Provides methods to create a new SipHasher instance with specific keys and perform hashing on byte arrays.

### Methods
- **new()**: Creates a new SipHasher with keys set to 0.
- **new_with_keys(key0: u64, key1: u64)**: Creates a SipHasher with provided 64-bit keys.
- **new_with_key(key: &[u8; 16])**: Creates a SipHasher from a 16-byte key array.
- **hash(bytes: &[u8]) -> u64**: Hashes the provided byte array using the hasher's keys.

### Response
- **hash result** (u64) - The resulting hash value of the input bytes.
```

--------------------------------

### SipHasher24 Constructors

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher24.html

Provides methods to create new instances of SipHasher24, either with default keys, custom keys, or a 16-byte key.

```APIDOC
## SipHasher24 Constructors

### `new()`

Creates a new `SipHasher24` with the two initial keys set to 0.

### `new_with_keys(key0: u64, key1: u64)`

Creates a `SipHasher24` that is keyed off the provided keys.

### `new_with_key(key: &[u8; 16])`

Creates a `SipHasher24` from a 16 byte key.
```

--------------------------------

### Implement Clone and Default for Hasher

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Provides cloning capabilities and default initialization for the Hasher struct.

```rust
impl<S: Sip> Clone for Hasher<S> {
    #[inline]
    fn clone(&self) -> Hasher<S> {
        Hasher {
            k0: self.k0,
            k1: self.k1,
            length: self.length,
            state: self.state,
            tail: self.tail,
            ntail: self.ntail,
            _marker: self._marker,
        }
    }
}

impl<S: Sip> Default for Hasher<S> {
    /// Creates a `Hasher<S>` with the two initial keys set to 0.
    #[inline]
    fn default() -> Hasher<S> {
        Hasher::new_with_keys(0, 0)
    }
}
```

--------------------------------

### Clone, Debug, Default, and Copy Implementations

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher13.html

Standard trait implementations for SipHasher13.

```APIDOC
## Clone, Debug, Default, and Copy Implementations

### `impl Clone for SipHasher13`

#### `clone(&self) -> SipHasher13`

Returns a duplicate of the value.

#### `clone_from(&mut self, source: &Self)`

Performs copy-assignment from `source`.

### `impl Debug for SipHasher13`

#### `fmt(&self, f: &mut Formatter<'_>) -> Result`

Formats the value using the given formatter.

### `impl Default for SipHasher13`

#### `default() -> SipHasher13`

Returns the default value for a type.

### `impl Copy for SipHasher13`
```

--------------------------------

### Into Trait Implementation

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Documentation for the Into trait which provides a generic conversion method.

```APIDOC
## fn into(self) -> U

### Description
Calls U::from(self). This conversion is defined by the implementation of From<T> for U.

### Method
Function Call

### Parameters
- **self** (T) - Required - The value to be converted.
```

--------------------------------

### Implement Default for SipHasher13

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher13.html

Provides a default value for SipHasher13, typically equivalent to `SipHasher13::new()`.

```rust
fn default() -> SipHasher13
```

--------------------------------

### SipHasher13 API

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Methods for initializing the SipHasher13 variant.

```APIDOC
## SipHasher13 Initialization

### Description
Provides methods to create a new SipHasher13 instance, which implements the SipHash 1-3 algorithm.

### Methods
- **new()**: Creates a new SipHasher13 with keys set to 0.
- **new_with_keys(key0: u64, key1: u64)**: Creates a SipHasher13 with provided 64-bit keys.
```

--------------------------------

### SipHasher::new()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Creates a new `SipHasher` instance with the two initial keys set to 0. This is a convenient constructor for default keying.

```rust
/// Creates a new `SipHasher` with the two initial keys set to 0.
#[inline]
pub fn new() -> SipHasher {
    SipHasher::new_with_keys(0, 0)
}
```

--------------------------------

### SipHasher Constructors

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher.html

Methods for creating new instances of SipHasher.

```APIDOC
## SipHasher Constructors

### `pub fn new() -> SipHasher`
Creates a new `SipHasher` with the two initial keys set to 0.

### `pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher`
Creates a `SipHasher` that is keyed off the provided keys.

### `pub fn new_with_key(key: &[u8; 16]) -> SipHasher`
Creates a `SipHasher` from a 16 byte key.
```

--------------------------------

### SipHasher13 Constructors

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher13.html

Methods for creating new instances of SipHasher13.

```APIDOC
## impl SipHasher13

### pub fn new() -> SipHasher13

Creates a new `SipHasher13` with the two initial keys set to 0.

### pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13

Creates a `SipHasher13` that is keyed off the provided keys.

### pub fn new_with_key(key: &[u8; 16]) -> SipHasher13

Creates a `SipHasher13` from a 16 byte key.
```

--------------------------------

### TryFrom Trait Implementation

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Documentation for the TryFrom trait used for fallible conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a mechanism for fallible type conversion.

### Parameters
- **value** (U) - Required - The value to convert.

### Response
- **Result<T, Error>** - Returns the converted type or an error if the conversion fails.

### Associated Types
- **Error** (Infallible) - The type returned in the event of a conversion error.
```

--------------------------------

### Module sip128 Overview

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/index.html

Provides an implementation of SipHash with a 128-bit output.

```APIDOC
## Module sip128

An implementation of SipHash with a 128-bit output.

### Structs

*   **Hash128**: A 128-bit (2x64) hash output.
*   **SipHasher**: An implementation of SipHash128 2-4.
*   **SipHasher13**: An implementation of SipHash128 1-3.
*   **SipHasher24**: An implementation of SipHash128 2-4.

### Traits

*   **Hasher128**: Trait for 128-bit hashing.
```

--------------------------------

### SipHasher13 Constructors

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher13.html

Provides methods to create new instances of SipHasher13.

```APIDOC
## SipHasher13 Constructors

### `new()`

Creates a new `SipHasher13` with the two initial keys set to 0.

### `new_with_keys(key0: u64, key1: u64)`

Creates a `SipHasher13` that is keyed off the provided keys.

### `new_with_key(key: &[u8; 16])`

Creates a `SipHasher13` from a 16 byte key.
```

--------------------------------

### Hasher Internal State Initialization

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Internal logic for initializing the hasher state with keys and constants.

```rust
impl<S: Sip> Hasher<S> {
    #[inline]
    fn new_with_keys(key0: u64, key1: u64) -> Hasher<S> {
        let mut state = Hasher {
            k0: key0,
            k1: key1,
            length: 0,
            state: State {
                v0: 0,
                v1: 0xee,
                v2: 0,
                v3: 0,
            },
            tail: 0,
            ntail: 0,
            _marker: PhantomData,
        };
        state.reset();
        state
    }

    #[inline]
    fn reset(&mut self) {
        self.length = 0;
        self.state.v0 = self.k0 ^ 0x736f6d6570736575;
        self.state.v1 = self.k1 ^ 0x646f72616e646f83;
        self.state.v2 = self.k0 ^ 0x6c7967656e657261;
        self.state.v3 = self.k1 ^ 0x7465646279746573;
```

--------------------------------

### Write Length Prefix to SipHasher (Nightly)

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Writes a length prefix into the hasher, intended for prefix-free hashing. This is a nightly-only experimental API.

```rust
fn write_length_prefix(&mut self, len: usize)
```

--------------------------------

### SipHasher13::new()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Creates a new SipHasher13 instance with default keys (0, 0).

```rust
/// Creates a new `SipHasher13` with the two initial keys set to 0.
#[inline]
pub fn new() -> SipHasher13 {
    SipHasher13::new_with_keys(0, 0)
}

```

--------------------------------

### SipHasher24 Key Management and Hashing

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Methods for creating, keying, and hashing with the SipHasher24 variant.

```rust
impl SipHasher24 {
    /// Creates a new `SipHasher24` with the two initial keys set to 0.
    #[inline]
    pub fn new() -> SipHasher24 {
        SipHasher24::new_with_keys(0, 0)
    }

    /// Creates a `SipHasher24` that is keyed off the provided keys.
    #[inline]
    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher24 {
        SipHasher24 {
            hasher: Hasher::new_with_keys(key0, key1),
        }
    }

    /// Creates a `SipHasher24` from a 16 byte key.
    pub fn new_with_key(key: &[u8; 16]) -> SipHasher24 {
        let mut b0 = [0u8; 8];
        let mut b1 = [0u8; 8];
        b0.copy_from_slice(&key[0..8]);
        b1.copy_from_slice(&key[8..16]);
        let key0 = u64::from_le_bytes(b0);
        let key1 = u64::from_le_bytes(b1);
        Self::new_with_keys(key0, key1)
    }

    /// Get the keys used by this hasher
    pub fn keys(&self) -> (u64, u64) {
        (self.hasher.k0, self.hasher.k1)
    }

    /// Get the key used by this hasher as a 16 byte vector
    pub fn key(&self) -> [u8; 16] {
        let mut bytes = [0u8; 16];
        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
        bytes
    }

    /// Hash a byte array - This is the easiest and safest way to use SipHash.
    #[inline]
    pub fn hash(&self, bytes: &[u8]) -> Hash128 {
        let mut hasher = self.hasher;
        hasher.write(bytes);
        hasher.finish128()
    }
}

impl Hasher128 for SipHasher24 {
    /// Return a 128-bit hash
    #[inline]
    fn finish128(&self) -> Hash128 {
        self.hasher.finish128()
    }
}
```

--------------------------------

### 128-bit SipHash One-Shot Hashing

Source: https://docs.rs/siphasher/1.0.2/siphasher/index.html

Illustrates one-shot hashing using SipHasher13 in 128-bit mode. The result is a 128-bit tag, which can be accessed as bytes.

```rust
use siphasher::sip128::{Hasher128, SipHasher, SipHasher13, SipHasher24};

// one-shot:

let array: &[u8] = &[1, 2, 3];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let hasher = SipHasher13::new_with_key(key);
let h = hasher.hash(array).as_bytes();
```

--------------------------------

### SipHasher13 Key Management and Hashing

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Methods for creating, keying, and hashing with the SipHasher13 variant.

```rust
impl SipHasher13 {
    /// Creates a new `SipHasher13` with the two initial keys set to 0.
    #[inline]
    pub fn new() -> SipHasher13 {
        SipHasher13::new_with_keys(0, 0)
    }

    /// Creates a `SipHasher13` that is keyed off the provided keys.
    #[inline]
    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 {
        SipHasher13 {
            hasher: Hasher::new_with_keys(key0, key1),
        }
    }

    /// Creates a `SipHasher13` from a 16 byte key.
    pub fn new_with_key(key: &[u8; 16]) -> SipHasher13 {
        let mut b0 = [0u8; 8];
        let mut b1 = [0u8; 8];
        b0.copy_from_slice(&key[0..8]);
        b1.copy_from_slice(&key[8..16]);
        let key0 = u64::from_le_bytes(b0);
        let key1 = u64::from_le_bytes(b1);
        Self::new_with_keys(key0, key1)
    }

    /// Get the keys used by this hasher
    pub fn keys(&self) -> (u64, u64) {
        (self.hasher.k0, self.hasher.k1)
    }

    /// Get the key used by this hasher as a 16 byte vector
    pub fn key(&self) -> [u8; 16] {
        let mut bytes = [0u8; 16];
        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
        bytes
    }

    /// Hash a byte array - This is the easiest and safest way to use SipHash.
    #[inline]
    pub fn hash(&self, bytes: &[u8]) -> Hash128 {
        let mut hasher = self.hasher;
        hasher.write(bytes);
        hasher.finish128()
    }
}

impl Hasher128 for SipHasher13 {
    /// Return a 128-bit hash
    #[inline]
    fn finish128(&self) -> Hash128 {
        self.hasher.finish128()
    }
}
```

--------------------------------

### Create SipHasher13 from 16-byte Key

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher13.html

Creates a SipHasher13 instance from a 16-byte array, which is used as the key for hashing.

```rust
pub fn new_with_key(key: &[u8; 16]) -> SipHasher13
```

--------------------------------

### Add siphasher to Cargo.toml

Source: https://docs.rs/siphasher/1.0.2/siphasher/index.html

Include the siphasher crate as a dependency in your Cargo.toml file. For serde support, enable the 'serde' feature.

```toml
[dependencies]
siphasher = "1"
```

```toml
[dependencies]
siphasher = { version = "1", features = ["serde"] }
```

--------------------------------

### try_into Method

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher24.html

Provides a method to attempt conversion from one type to another, returning a Result.

```APIDOC
## fn try_into

### Description
Performs the conversion from type T to type U.

### Method Signature
```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>;
```

### Returns
- `Ok(U)`: If the conversion is successful, returns the converted value of type U.
- `Err(<U as TryFrom<T>>::Error)`: If the conversion fails, returns the associated error type.
```

--------------------------------

### Write String to SipHasher (Nightly)

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip128/struct.SipHasher.html

Writes a string slice into the hasher. This is a nightly-only experimental API that leverages prefix-free hashing.

```rust
fn write_str(&mut self, s: &str)
```

--------------------------------

### Sip24Rounds Compression Rounds

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Implements the compression rounds for Sip24Rounds. Requires the `compress!` macro.

```rust
#[derive(Debug, Clone, Copy, Default)]
struct Sip24Rounds;

impl Sip for Sip24Rounds {
    #[inline]
    fn c_rounds(state: &mut State) {
        compress!(state);
        compress!(state);
    }

    #[inline]
    fn d_rounds(state: &mut State) {
        compress!(state);
        compress!(state);
        compress!(state);
        compress!(state);
    }
}
```

--------------------------------

### SipHasher13 and SipHasher24 Methods

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Common methods available for both SipHasher13 and SipHasher24 structures to manage keys and perform hashing.

```APIDOC
## SipHasher Methods

### Description
Methods for initializing, retrieving keys, and hashing data using SipHasher13 or SipHasher24.

### Methods
- **new_with_key(key: &[u8; 16])** -> SipHasher: Creates a hasher from a 16-byte key array.
- **new_with_keys(key0: u64, key1: u64)** -> SipHasher: Creates a hasher from two 64-bit keys.
- **keys()** -> (u64, u64): Returns the two 64-bit keys used by the hasher.
- **key()** -> [u8; 16]: Returns the keys as a 16-byte array.
- **hash(bytes: &[u8])** -> u64: Hashes the provided byte array and returns the result.

### Request Example
let hasher = SipHasher13::new_with_key(&[0; 16]);
let result = hasher.hash(b"data");

### Response
- **result** (u64) - The computed hash value.
```

--------------------------------

### Implement Clone for SipHasher13

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher13.html

Allows creating a duplicate of a SipHasher13 instance. This is useful for scenarios where you need to hash multiple byte sequences with the same key independently.

```rust
fn clone(&self) -> SipHasher13
```

--------------------------------

### Implement Copy for SipHasher13

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher13.html

Indicates that SipHasher13 can be copied by value. This means instances can be duplicated easily.

--------------------------------

### Implement write method for Hasher

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Handles input buffering and state updates for the hashing process.

```rust
    #[inline]
    fn write(&mut self, msg: &[u8]) {
        let length = msg.len();
        self.length += length;

        let mut needed = 0;

        if self.ntail != 0 {
            needed = 8 - self.ntail;
            self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << (8 * self.ntail);
            if length < needed {
                self.ntail += length;
                return;
            } else {
                self.state.v3 ^= self.tail;
                S::c_rounds(&mut self.state);
                self.state.v0 ^= self.tail;
                self.ntail = 0;
            }
        }

        // Buffered tail is now flushed, process new input.
        let len = length - needed;
        let left = len & 0x7;

        let mut i = needed;
        while i < len - left {
            let mi = unsafe { load_int_le!(msg, i, u64) };

            self.state.v3 ^= mi;
            S::c_rounds(&mut self.state);
            self.state.v0 ^= mi;

            i += 8;
        }

        self.tail = unsafe { u8to64_le(msg, i, left) };
        self.ntail = left;
    }
```

--------------------------------

### SipHasher::hash()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Hashes a given byte slice using the SipHasher. This is the recommended and safest method for hashing data.

```rust
/// Hash a byte array - This is the easiest and safest way to use SipHash.
#[inline]
pub fn hash(&self, bytes: &[u8]) -> u64 {
    let mut hasher = self.0.hasher;
    hasher.write(bytes);
    hasher.finish()
}

```

--------------------------------

### 64-bit SipHash Incremental Hashing

Source: https://docs.rs/siphasher/1.0.2/siphasher/index.html

Shows incremental hashing with SipHasher13 in 64-bit mode. Data can be written in chunks using the `write` method before finishing.

```rust
use core::hash::Hasher;

let array1: &[u8] = &[1, 2, 3];
let array2: &[u8] = &[4, 5, 6];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let mut hasher = SipHasher13::new_with_key(key);
hasher.write(array1);
hasher.write(array2);
let h = hasher.finish();
```

--------------------------------

### Hash Byte Array with SipHasher13

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher13.html

Hashes a given byte slice using the SipHasher13. This is the simplest and most secure way to use SipHash.

```rust
pub fn hash(&self, bytes: &[u8]) -> u64
```

--------------------------------

### Blanket Implementations

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher.html

Details on blanket implementations that apply to SipHasher.

```APIDOC
## Blanket Implementations for SipHasher

### `impl<T> Any for T`

#### `fn type_id(&self) -> TypeId`
Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`

#### `fn borrow(&self) -> &T`
Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`

#### `fn borrow_mut(&mut self) -> &mut T`
Mutably borrows from an owned value.

### `impl<T> CloneToUninit for T`

#### `unsafe fn clone_to_uninit(&self, dest: *mut u8)`
Performs copy-assignment from `self` to `dest`. (Nightly-only experimental API)

### `impl<T> From<T> for T`

#### `fn from(t: T) -> T`
Returns the argument unchanged.

### `impl<T, U> Into<U> for T`

#### `fn into(self) -> U`
Calls `U::from(self)`.
```

--------------------------------

### Sip13Rounds Compression Rounds

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip.rs.html

Implements the compression rounds for Sip13Rounds. Requires the `compress!` macro.

```rust
#[derive(Debug, Clone, Copy, Default)]
struct Sip13Rounds;

impl Sip for Sip13Rounds {
    #[inline]
    fn c_rounds(state: &mut State) {
        compress!(state);
    }

    #[inline]
    fn d_rounds(state: &mut State) {
        compress!(state);
        compress!(state);
        compress!(state);
    }
}
```

--------------------------------

### Implement 128-bit SipHash

Source: https://docs.rs/siphasher/1.0.2/siphasher

Use the sip128 module for 128-bit output variants. Requires the Hasher128 trait for specific 128-bit operations.

```rust
use siphasher::sip128::{Hasher128, SipHasher, SipHasher13, SipHasher24};

// one-shot:

let array: &[u8] = &[1, 2, 3];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let hasher = SipHasher13::new_with_key(key);
let h = hasher.hash(array).as_bytes();

// incremental:

use core::hash::Hasher;

let array1: &[u8] = &[1, 2, 3];
let array2: &[u8] = &[4, 5, 6];
let key: &[u8; 16] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
let mut hasher = SipHasher13::new_with_key(key);
hasher.write(array1);
hasher.write(array2);
let h = hasher.finish128().as_bytes();
```

--------------------------------

### TryInto Conversion API

Source: https://docs.rs/siphasher/1.0.2/siphasher/sip/struct.SipHasher24.html

Details regarding the conversion process and associated error types for the TryInto trait.

```APIDOC
## TryInto Conversion

### Description
Performs a fallible conversion from one type to another.

### Associated Types
- **Error** (<U as TryFrom<T>>::Error) - The type returned in the event of a conversion error.

### Methods
#### try_into
- **Signature**: fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
- **Description**: Performs the conversion.
```

--------------------------------

### SipHasher::keys()

Source: https://docs.rs/siphasher/1.0.2/src/siphasher/sip128.rs.html

Retrieves the two `u64` keys currently used by the `SipHasher`. This is useful for inspecting the hasher's configuration.

```rust
/// Get the keys used by this hasher
pub fn keys(&self) -> (u64, u64) {
    (self.0.hasher.k0, self.0.hasher.k1)
}
```
Tokens:
Raw