chacha20 0.10.0

The ChaCha20 stream cipher (RFC 8439) implemented in pure Rust using traits from the RustCrypto `cipher` crate, with optional architecture-specific hardware acceleration (AVX2, SSE2). Additionally provides the ChaCha8, ChaCha12, XChaCha20, XChaCha12 and XChaCha8 stream ciphers, and also optional rand_core-compatible RNGs based on those ciphers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! ChaCha variant-specific configurations.

mod sealed {
    pub trait Sealed {}
}

/// A trait that distinguishes some ChaCha variants. Contains configurations
/// for "Legacy" DJB variant and the IETF variant.
pub trait Variant: sealed::Sealed {
    /// The counter's type.
    #[cfg(not(feature = "cipher"))]
    type Counter: Copy;

    /// The counter's type.
    #[cfg(feature = "cipher")]
    type Counter: cipher::StreamCipherCounter;

    /// Takes a slice of `state[12..NONCE_INDEX]` to convert it into
    /// `Self::Counter`.
    fn get_block_pos(row: &[u32]) -> Self::Counter;

    /// Breaks down the `Self::Counter` type into a u32 array for setting the
    /// block pos.
    fn set_block_pos(row: &mut [u32], pos: Self::Counter);

    /// A helper method for calculating the remaining blocks using these types
    fn remaining_blocks(block_pos: Self::Counter) -> Option<usize>;
}

/// IETF ChaCha configuration to use a 32-bit counter and 96-bit nonce.
#[derive(Clone, Copy, Debug)]
pub enum Ietf {}

impl sealed::Sealed for Ietf {}

impl Variant for Ietf {
    type Counter = u32;

    #[inline(always)]
    fn get_block_pos(row: &[u32]) -> u32 {
        row[0]
    }

    #[inline(always)]
    fn set_block_pos(row: &mut [u32], pos: u32) {
        row[0] = pos;
    }

    #[inline(always)]
    fn remaining_blocks(block_pos: u32) -> Option<usize> {
        let remaining = u32::MAX - block_pos;
        remaining.try_into().ok()
    }
}

/// DJB variant specific features: 64-bit counter and 64-bit nonce.
#[cfg(any(feature = "legacy", feature = "rng"))]
#[derive(Clone, Copy, Debug)]
pub enum Legacy {}

#[cfg(any(feature = "legacy", feature = "rng"))]
impl sealed::Sealed for Legacy {}

#[cfg(any(feature = "legacy", feature = "rng"))]
impl Variant for Legacy {
    type Counter = u64;

    #[inline(always)]
    fn get_block_pos(row: &[u32]) -> u64 {
        (u64::from(row[1]) << 32) | u64::from(row[0])
    }

    #[inline(always)]
    fn set_block_pos(row: &mut [u32], pos: u64) {
        row[0] = (pos & 0xFFFF_FFFF) as u32;
        row[1] = (pos >> 32) as u32;
    }

    #[inline(always)]
    fn remaining_blocks(block_pos: u64) -> Option<usize> {
        let remaining = u64::MAX - block_pos;
        remaining.try_into().ok()
    }
}