aes-ndlr 0.0.2

An implementation of AES
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

extern crate aes_ndlr as aes;

use std::ops::Range;

use aes::{AESEncryptionOptions, BlockCipherMode, decrypt_aes_128, encrypt_aes_128, pad::Padding};
use aes::key::Key;
use generate::{generate_bytes_for_length, generate_iv, generate_key};

mod generate;

const BLOCK_SIZE: usize = 16;
const TEST_CASES: Range<usize> = 0..100;

#[test]
fn encrypt_and_decrypt_ecb() {
    for _ in TEST_CASES {
        let raw_size = generate::random_byte() as usize * BLOCK_SIZE;
        let raw: &[u8] = &generate_bytes_for_length(raw_size)[..];
        let key = &generate_key();
        let iv = &generate_iv();

        let cipher = encrypt_aes_128(
            &raw,
            key,
            &AESEncryptionOptions::new(
                &BlockCipherMode::CBC(iv),
                &Padding::None,
            ),
        );
        let actual_deciphered = decrypt_aes_128(&cipher, key, &BlockCipherMode::CBC(iv));

        assert_eq!(raw, &actual_deciphered[..]);
    }
}

#[test]
fn encrypt_and_decrypt_cbc() {
    for _ in TEST_CASES {
        let raw_size = generate::random_byte() as usize * BLOCK_SIZE;
        let raw: &[u8] = &generate_bytes_for_length(raw_size)[..];
        let key = &generate_key();
        let iv = &generate_iv();

        let cipher = encrypt_aes_128(
            &raw,
            key,
            &AESEncryptionOptions::new(
                &BlockCipherMode::CBC(iv),
                &Padding::None,
            ),
        );
        let actual_deciphered = decrypt_aes_128(&cipher, key, &BlockCipherMode::CBC(iv));

        assert_eq!(raw, &actual_deciphered[..]);
    }
}

#[test]
fn encrypt_and_decrypt_ctr() {
    for _ in TEST_CASES {
        let raw_size = generate::random_byte() as usize * BLOCK_SIZE;
        let raw: &[u8] = &generate_bytes_for_length(raw_size)[..];
        let key = &generate_key();
        let generated_bytes = generate_bytes_for_length(8);
        let nonce = [
            generated_bytes[0],
            generated_bytes[1],
            generated_bytes[2],
            generated_bytes[3],
            generated_bytes[4],
            generated_bytes[5],
            generated_bytes[6],
            generated_bytes[7],
        ];
        let mode = BlockCipherMode::CTR(&nonce);
        let options = &AESEncryptionOptions::new(
            &mode,
            &Padding::None,
        );

        let ciphered = encrypt_aes_128(&raw, &key, &options);
        let deciphered = encrypt_aes_128(&ciphered, &key, &options);

        assert_eq!(deciphered, raw);
    }
}