hctr2 0.2.0

An implementation of the length-preserving encryption HCTR2 algorithm.
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

use aes::{Aes128, Aes192, Aes256};
use cipher::{generic_array::GenericArray, KeyInit};
use hctr2::Cipher;
use serde::{Deserialize, Serialize};
use std::{fs, path::PathBuf};

#[derive(Serialize, Deserialize, Debug)]
pub struct TestVector {
    cipher: TestVectorCipher,
    description: String,
    input: TestVectorInput,
    ciphertext_hex: String,
    plaintext_hex: String,
    hash_hex: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TestVectorCipher {
    blockcipher: TestVectorBlockCipher,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TestVectorBlockCipher {
    cipher: String,
    lengths: TestVectorBlockCipherLengths,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TestVectorBlockCipherLengths {
    block: usize,
    key: usize,
    nonce: Option<usize>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TestVectorInput {
    key_hex: String,
    tweak_hex: String,
    nonce_hex: Option<String>,
}

static MFST_DIR: &str = env!("CARGO_MANIFEST_DIR");

macro_rules! hctr2_test {
    ($name:ident, $C:ident, $fname:expr) => {
        #[test]
        fn $name() {
            let mut path = PathBuf::from(MFST_DIR);
            path.push("tests");
            path.push("testdata");
            path.push($fname);
            let data = fs::read(path).unwrap();

            let vecs: Vec<TestVector> =
                serde_json::from_slice(&data[..]).unwrap();
            for v in &vecs {
                let key = &hex::decode(&v.input.key_hex).unwrap();
                let mut c =
                    Cipher::<$C>::new(GenericArray::from_slice(&key[..]));
                let tweak = hex::decode(&v.input.tweak_hex).unwrap();
                let plaintext = hex::decode(&v.plaintext_hex).unwrap();
                let ciphertext = hex::decode(&v.ciphertext_hex).unwrap();

                let mut got = &mut vec![0u8; plaintext.len()][..];

                c.encrypt(&mut got, &plaintext, &tweak);
                assert_eq!(got, ciphertext);

                c.decrypt(&mut got, &ciphertext, &tweak);
                assert_eq!(got, plaintext);

                c.encrypt_in_place(&mut got, &tweak);
                assert_eq!(got, ciphertext);

                c.decrypt_in_place(&mut got, &tweak);
                assert_eq!(got, plaintext);
            }
        }
    };
}
hctr2_test!(test_hctr2_aes256, Aes256, "HCTR2_AES256.json");
hctr2_test!(test_hctr2_aes192, Aes192, "HCTR2_AES192.json");
hctr2_test!(test_hctr2_aes128, Aes128, "HCTR2_AES128.json");