ecb 0.2.1

Generic implementation of the ECB (Electronic Codebook) block cipher mode of operation
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Test vectors from CAVP "AES Multiblock Message Test (MMT) Sample Vectors":
//! <https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Block-Ciphers>
use aes::*;
use cipher::{BlockModeDecrypt, BlockModeEncrypt, InOutBuf, KeyInit};
use ecb::{Decryptor, Encryptor};

const MAX_LEN: usize = 256;

#[derive(Debug, Clone, Copy)]
struct TestVector {
    pub key: &'static [u8],
    pub plaintext: &'static [u8],
    pub ciphertext: &'static [u8],
}

#[test]
fn aes128_ecb_cavp() {
    cipher::dev::blobby::parse_into_structs!(
        include_bytes!("data/aes128.blb");
        static TEST_VECTORS: &[TestVector { key, plaintext, ciphertext }];
    );

    for tv in TEST_VECTORS.iter() {
        encrypt::<Encryptor<Aes128>>(tv).unwrap();
        encrypt::<Encryptor<Aes128Enc>>(tv).unwrap();
        decrypt::<Decryptor<Aes128>>(tv).unwrap();
        decrypt::<Decryptor<Aes128Dec>>(tv).unwrap();
    }
}

#[test]
fn aes192_ecb_cavp() {
    cipher::dev::blobby::parse_into_structs!(
        include_bytes!("data/aes192.blb");
        static TEST_VECTORS: &[TestVector { key, plaintext, ciphertext }];
    );

    for tv in TEST_VECTORS.iter() {
        encrypt::<Encryptor<Aes192>>(tv).unwrap();
        encrypt::<Encryptor<Aes192Enc>>(tv).unwrap();
        decrypt::<Decryptor<Aes192>>(tv).unwrap();
        decrypt::<Decryptor<Aes192Dec>>(tv).unwrap();
    }
}

#[test]
fn aes256_ecb_cavp() {
    cipher::dev::blobby::parse_into_structs!(
        include_bytes!("data/aes256.blb");
        static TEST_VECTORS: &[TestVector { key, plaintext, ciphertext }];
    );

    for tv in TEST_VECTORS.iter() {
        encrypt::<Encryptor<Aes256>>(tv).unwrap();
        encrypt::<Encryptor<Aes256Enc>>(tv).unwrap();
        decrypt::<Decryptor<Aes256>>(tv).unwrap();
        decrypt::<Decryptor<Aes256Dec>>(tv).unwrap();
    }
}

fn encrypt<C: BlockModeEncrypt + KeyInit>(tv: &TestVector) -> Result<(), &'static str> {
    let mut buf = [0u8; MAX_LEN];
    let Some(out) = buf.get_mut(..tv.ciphertext.len()) else {
        return Err("ciphertext is bigger than MAX_MSG_LEN bytes");
    };
    let Ok(mut buf) = InOutBuf::new(tv.plaintext, out) else {
        return Err("plaintext/ciphertext length mismatch");
    };
    let (blocks, tail) = buf.reborrow().into_chunks();
    if !tail.is_empty() {
        return Err("plaintext/ciphertext length is not multiple of block size");
    }

    let Ok(mut cipher) = C::new_from_slice(tv.key) else {
        return Err("cipher initialization failure");
    };
    for block in blocks {
        cipher.encrypt_block_inout(block);
    }
    if buf.get_out() != tv.ciphertext {
        return Err("single block encryption failure");
    }

    // test multi-block processing
    let Ok(mut cipher) = C::new_from_slice(tv.key) else {
        return Err("cipher initialization failure");
    };
    buf.get_out().fill(0);
    let (blocks, _) = buf.reborrow().into_chunks();
    cipher.encrypt_blocks_inout(blocks);
    if buf.get_out() != tv.ciphertext {
        return Err("multi-block encryption failure");
    }
    Ok(())
}

fn decrypt<C: BlockModeDecrypt + KeyInit>(tv: &TestVector) -> Result<(), &'static str> {
    let mut buf = [0u8; MAX_LEN];
    let Some(out) = buf.get_mut(..tv.plaintext.len()) else {
        return Err("plaintext is bigger than MAX_MSG_LEN bytes");
    };
    let Ok(mut buf) = InOutBuf::new(tv.ciphertext, out) else {
        return Err("plaintext/ciphertext length mismatch");
    };
    let (blocks, tail) = buf.reborrow().into_chunks();
    if !tail.is_empty() {
        return Err("plaintext/ciphertext length is not multiple of block size");
    }

    let Ok(mut cipher) = C::new_from_slice(tv.key) else {
        return Err("cipher initialization failure");
    };
    for block in blocks {
        cipher.decrypt_block_inout(block);
    }
    if buf.get_out() != tv.plaintext {
        return Err("single block decryption failure");
    }

    // test multi-block processing
    let Ok(mut cipher) = C::new_from_slice(tv.key) else {
        return Err("cipher initialization failure");
    };
    buf.get_out().fill(0);
    let (blocks, _) = buf.reborrow().into_chunks();
    cipher.decrypt_blocks_inout(blocks);
    if buf.get_out() != tv.plaintext {
        return Err("multi-block decryption failure");
    }
    Ok(())
}