h_encrypt 0.2.3

A simple encrpytion/decryption library.
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

use crate::{encrypt_bytes, decrypt_bytes, encrypt_stream, decrypt_stream};
use crate::table::{many_tables, is_random};
use std::fs::{File, self};
use std::io::{Read, Write};

pub fn test_files() -> Vec<String> {
    vec![
        "./test_data/lorem.txt".to_string(),
        "./test_data/lorem2.txt".to_string(),
        "./test_data/empty.txt".to_string(),
        "./test_data/hangul.txt".to_string(),
    ]
}

pub fn encrypted_files() -> Vec<String> {
    vec![
        "./test_data/lorem.txt.e".to_string(),
        "./test_data/lorem2.txt.e".to_string(),
        "./test_data/empty.txt.e".to_string(),
        "./test_data/hangul.txt.e".to_string(),
    ]
}

pub fn passwords() -> Vec<Vec<u8>> {
    vec![
        vec!['p' as u8, 'a' as u8, 's' as u8, 's' as u8, 'w' as u8, 'o' as u8, 'r' as u8, 'd' as u8],
        vec![],
        vec![0],
        many_tables()[0].0.clone()
    ]
}

#[test]
fn enc_dec_id() {

    for bytes in many_tables().iter() {

        for password in many_tables().iter() {
            assert_eq!(decrypt_bytes(&encrypt_bytes(&bytes.0, &password.0), &password.0).unwrap(), bytes.0);
        }

    }

}

#[test]
fn stream_bytes_id() {
    let test_files = test_files();
    let encrypted_files = encrypted_files();
    let passwords = passwords();

    for i in 0..test_files.len() {
        let mut f = File::open(&test_files[i]).unwrap();
        let mut original_data = vec![0; 1048576];
        let count = f.read(&mut original_data).unwrap();
        original_data = original_data[0..count].to_vec();

        for password in passwords.iter() {
            let encrypted = encrypt_bytes(&original_data, password);
            let mut save_enc = File::create("./tmp.e").unwrap();
            save_enc.write_all(&encrypted).unwrap();

            let mut decrypted = decrypt_bytes(&encrypted, password).unwrap();
            assert_eq!(decrypted, original_data);

            encrypt_stream(&test_files[i], &encrypted_files[i], password, 32).unwrap();  // I'm intentionally giving a small `block_size`
            let mut read_enc = File::open(&encrypted_files[i]).unwrap();
            decrypted = vec![0; 1048576];
            let count = read_enc.read(&mut decrypted).unwrap();
            decrypted = decrypted[0..count].to_vec();
            decrypted = decrypt_bytes(&decrypted, password).unwrap();
            assert_eq!(decrypted, original_data);

            decrypt_stream(&encrypted_files[i], "./tmp2.e", password, 32).unwrap();
            let mut read_dec = File::open("./tmp2.e").unwrap();
            decrypted = vec![0; 1048576];
            let count = read_dec.read(&mut decrypted).unwrap();
            decrypted = decrypted[0..count].to_vec();
            assert_eq!(decrypted, original_data);

            decrypt_stream("./tmp.e", "./tmp2.e", password, 32).unwrap();
            let mut read_dec = File::open("./tmp2.e").unwrap();
            decrypted = vec![0; 1048576];
            let count = read_dec.read(&mut decrypted).unwrap();
            decrypted = decrypted[0..count].to_vec();
            assert_eq!(decrypted, original_data);
        }

    }

    fs::remove_file("./tmp.e").unwrap();
    fs::remove_file("./tmp2.e").unwrap();
}

#[test]
fn output_random() {

    for password in many_tables().iter() {

        for i in 0..=255 {
            assert!(is_random(&encrypt_bytes(&[i;256], &password.0)));
        }

        assert!(is_random(&encrypt_bytes(&(0..=255).collect::<Vec<u8>>(), &password.0)));
    }

}