tox_encryptsave 0.1.0

Encryptsave part of tox
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

use tox_encryptsave::*;
use tox_crypto::*;

#[test]
fn is_encrypted_test() {
    crypto_init().unwrap();
    assert!(!is_encrypted(b"Hello world.\n"));
    assert!(is_encrypted(MAGIC_NUMBER));
    assert!(is_encrypted(include_bytes!("ciphertext")));
}


#[test]
fn pass_encrypt_error_test() {
    crypto_init().unwrap();
    // empty data
    assert_eq!(pass_encrypt(&[], &[0]), Err(EncryptionError::Null));

    // empty passphrase
    assert_eq!(pass_encrypt(&[0], &[]), Err(KeyDerivationError::Null.into()));
}

#[test]
fn pass_encrypt_test() {
    crypto_init().unwrap();
    let plaintext = [42; 16];
    let passphrase = [53; 16];

    let encrypted = pass_encrypt(&plaintext, &passphrase).unwrap();
    assert!(is_encrypted(&encrypted));

    assert_eq!(plaintext.len() + EXTRA_LENGTH, encrypted.len());
    assert_eq!(&plaintext as &[u8], &pass_decrypt(&encrypted, &passphrase).unwrap() as &[u8]);

    let encrypted2 = pass_encrypt(&plaintext, &passphrase).unwrap();
    assert_ne!(encrypted, encrypted2);
}

#[test]
fn pass_decrypt_error_null_test() {
    crypto_init().unwrap();
    // empty data
    assert_eq!(pass_decrypt(&[], &[0]), Err(DecryptionError::Null));
}

#[test]
fn pass_decrypt_error_invalid_length_test() {
    crypto_init().unwrap();
    // not enough data
    assert_eq!(pass_decrypt(&[0], &[]), Err(DecryptionError::InvalidLength));
}

#[test]
fn pass_decrypt_error_key_derivation_test() {
    crypto_init().unwrap();
    // empty passphrase
    let ciphertext = include_bytes!("ciphertext");
    assert_eq!(pass_decrypt(ciphertext, &[]), Err(KeyDerivationError::Null.into()));
}

#[test]
fn pass_decrypt_error_bad_format_test() {
    crypto_init().unwrap();
    // one of `MAGIC_NUMBER` bytes is wrong
    let ciphertext = include_bytes!("ciphertext");
    let mut bad_ciphertext = Vec::with_capacity(MAGIC_LENGTH + SALT_LENGTH);
    bad_ciphertext.extend_from_slice(&[0; MAGIC_LENGTH]);
    bad_ciphertext.extend_from_slice(&ciphertext[MAGIC_LENGTH..]);
    assert_eq!(pass_decrypt(&bad_ciphertext, &[]), Err(DecryptionError::BadFormat));
}

#[test]
fn pass_decrypt_error_failed_test() {
    crypto_init().unwrap();
    // a data byte is wrong
    let ciphertext = include_bytes!("ciphertext");
    let mut bad_ciphertext = Vec::with_capacity(EXTRA_LENGTH + 123);
    bad_ciphertext.extend_from_slice(&ciphertext[..EXTRA_LENGTH]);
    bad_ciphertext.extend_from_slice(&[42; 123]);
    assert_eq!(pass_decrypt(&bad_ciphertext, b"encryptsave"), Err(DecryptionError::Failed));
}

#[test]
fn pass_decrypt_test() {
    crypto_init().unwrap();
    let passphrase = b"encryptsave";
    let plaintext = b"Hello world.\n";
    let ciphertext = include_bytes!("ciphertext");

    assert_eq!(
        pass_decrypt(ciphertext, passphrase).unwrap(),
        plaintext
    );
}

#[test]
fn get_salt_test() {
    crypto_init().unwrap();
    let ciphertext = include_bytes!("ciphertext");
    let salt = &ciphertext[MAGIC_LENGTH .. MAGIC_LENGTH + SALT_LENGTH];

    assert_eq!(get_salt(ciphertext).unwrap().0, salt);
}

#[test]
fn get_salt_wrong_magic_test() {
    crypto_init().unwrap();
    let ciphertext = include_bytes!("ciphertext");

    let mut bad_ciphertext = Vec::with_capacity(MAGIC_LENGTH + SALT_LENGTH);
    bad_ciphertext.extend_from_slice(&[0; MAGIC_LENGTH]);
    bad_ciphertext.extend_from_slice(&ciphertext[MAGIC_LENGTH..]);

    assert_eq!(get_salt(&bad_ciphertext), None);
}