serpent-cipher 0.1.2

A naive pure Rust implementation of the Serpent block cipher.
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// #[macro_use]
// use serpent::generic_array;
// use block_cipher_trait::BlockCipher;

fn nibble_value(b: u8) -> u8 {
    match b {
        b'0'..=b'9' => b - b'0',
        b'a'..=b'f' => b - b'a' + 10,
        b'A'..=b'F' => b - b'A' + 10,
        _ => unreachable!(),
    }
}

fn bytes_from_hex_str(s: &str) -> Option<Vec<u8>> {
    let bytes = s.as_bytes();
    if bytes.is_empty() || bytes.len() % 2 == 1 || bytes.iter().any(|b| !b.is_ascii_hexdigit()) {
        return None;
    }

    Some(
        bytes
            .chunks_exact(2)
            .rev()
            .map(|chunk| nibble_value(chunk[0]) << 4 | nibble_value(chunk[1]))
            .collect(),
    )
}

fn block_from_bytes(bytes: &[u8]) -> u128 {
    use std::convert::TryInto;
    u128::from_le_bytes(bytes.try_into().unwrap())
}

#[test]
fn variable_key() {
    let vk_txt = include_str!("ecb_vk.txt");
    let mut pt = None;
    let mut key = None;
    for line in vk_txt.lines() {
        let mut parts = line.splitn(2, '=');
        match (parts.next(), parts.next()) {
            (Some("PT"), Some(v)) => pt = bytes_from_hex_str(v),
            (Some("KEY"), Some(v)) => key = Some(v),
            (Some("CT"), Some(v)) => {
                let ct = bytes_from_hex_str(v).unwrap();
                let cipher = serpent::Serpent::with_text_key(key.unwrap()).unwrap();
                let plain = block_from_bytes(pt.as_ref().unwrap());
                let truth = block_from_bytes(&ct);
                let encrypted = cipher.encrypt_block(plain);
                let decrypted = cipher.decrypt_block(encrypted);
                assert_eq!(encrypted, truth);
                assert_eq!(decrypted, plain);
            }
            _ => {}
        }
    }
}

#[test]
fn variable_text() {
    let vt_txt = include_str!("ecb_vt.txt");
    let mut pt = None;
    let mut key = None;
    for line in vt_txt.lines() {
        let mut parts = line.splitn(2, '=');
        match (parts.next(), parts.next()) {
            (Some("PT"), Some(v)) => pt = bytes_from_hex_str(v),
            (Some("KEY"), Some(v)) => key = Some(v),
            (Some("CT"), Some(v)) => {
                let ct = bytes_from_hex_str(v).unwrap();
                let cipher = serpent::Serpent::with_text_key(key.unwrap()).unwrap();
                let plain = block_from_bytes(pt.as_ref().unwrap());
                let truth = block_from_bytes(&ct);
                let encrypted = cipher.encrypt_block(plain);
                let decrypted = cipher.decrypt_block(encrypted);
                assert_eq!(encrypted, truth);
                assert_eq!(decrypted, plain);
            }
            _ => {}
        }
    }
}

#[test]
fn tables() {
    let vt_txt = include_str!("ecb_tbl.txt");
    let mut pt = None;
    let mut key = None;
    for line in vt_txt.lines() {
        let mut parts = line.splitn(2, '=');
        match (parts.next(), parts.next()) {
            (Some("PT"), Some(v)) => pt = bytes_from_hex_str(v),
            (Some("KEY"), Some(v)) => key = Some(v),
            (Some("CT"), Some(v)) => {
                let ct = bytes_from_hex_str(v).unwrap();
                let cipher = serpent::Serpent::with_text_key(key.unwrap()).unwrap();
                let plain = block_from_bytes(pt.as_ref().unwrap());
                let truth = block_from_bytes(&ct);
                let encrypted = cipher.encrypt_block(plain);
                let decrypted = cipher.decrypt_block(encrypted);
                assert_eq!(encrypted, truth);
                assert_eq!(decrypted, plain);
            }
            _ => {}
        }
    }
}