encipher 0.1.3

A fast session-data cipher for Rust
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

use rand::SeedableRng;
use rand::rngs::ChaCha20Rng;
use rand::seq::SliceRandom;



/// A substitution cipher lookup table for a single encryption layer.
///
/// Contains two precomputed tables:
/// - `enc`: maps plaintext bytes to ciphertext bytes.
/// - `dec`: maps ciphertext bytes back to plaintext bytes.
#[derive(Debug)]
pub struct CipherList {
    pub enc: [u8; 256],
    pub dec: [u8; 256],
}

impl CipherList {
    /// Builds an encrypt/decrypt lookup table using a seeded RNG and a step offset.
    ///
    /// `enc` and `dec` are precomputed substitution tables to guarantee
    /// O(1) encryption and decryption per byte at runtime.
    pub fn new(rng: &mut ChaCha20Rng, step: u8) -> Self {
        let mut forward: [u8; 256] = core::array::from_fn(|i| i as u8);
        forward.shuffle(rng);

        let step = step as usize;
        let mut reverse = [0u8; 256];

        for (i, &v) in forward.iter().enumerate() {
            reverse[v as usize] = i as u8;
        }

        let enc = core::array::from_fn(|i| {
            forward[(reverse[i] as usize + step) % 256]
        });

        let dec = core::array::from_fn(|i| {
            forward[(256 + reverse[i] as usize - step) % 256]
        });

        
        #[cfg(debug_assertions)]
        for byte in 0u8..=255 {
            debug_assert_eq!(
                dec[enc[byte as usize] as usize],
                byte,
                "List error when byte={}", byte
            );
        }

        CipherList { enc, dec }
    }
}



/// Generates 100 substitution lists from a fixed key.
/// Count is fixed in the type signature for performance
/// and to avoid unnecessary heap allocation.
pub fn generate_lists(key: u64, step: u8) -> Box<[CipherList; 100]> {
    let mut rng = ChaCha20Rng::seed_from_u64(key);
    let lists: Vec<CipherList> = (0..100).map(|_| CipherList::new(&mut rng, step)).collect();
    lists.try_into().unwrap()
}