async_io_crypto 0.1.2

A rust library for handling AsyncRead with ciphering / deciphering.
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
132
133
134
135
136
137
138
139
140

use chacha20poly1305::{ChaCha20Poly1305, Key, KeyInit};
use rand::SeedableRng;

use async_io_crypto::{CipherRead, DecipherRead};
use tokio::io::{AsyncBufReadExt, AsyncReadExt, BufReader};

#[tokio::test]
async fn it_can_cipher_and_decipher() {
    let value = "some_data";
    let data = value.as_bytes();
    let secret = b"super_secret_aaaaaaaaaaaaaaaaaaa";
    let key = Key::from_slice(secret);
    let cipher: ChaCha20Poly1305 = ChaCha20Poly1305::new(key);

    let mut csprng = rand_chacha::ChaCha20Rng::from_entropy();
    let (ci_reader, nonce) = CipherRead::new(data, cipher.clone(), &mut csprng);

    let deci_reader = DecipherRead::new(ci_reader, cipher, nonce.as_slice());

    let buf_reader = BufReader::new(deci_reader);
    let mut lines = buf_reader.lines();
    let mut lc = 0;
    let mut output = Vec::new();
    while let Some(r) = lines.next_line().await.unwrap() {
        lc += 1;
        output.push(r);
    }

    assert_eq!(lc, 1);
    assert_eq!(output[0], value.to_string());
}

#[tokio::test]
async fn it_can_cipher_then_decipher() {
    let value = "some_data";
    let data = value.as_bytes();
    let secret = b"super_secret_aaaaaaaaaaaaaaaaaaa";
    let key = Key::from_slice(secret);
    let cipher: ChaCha20Poly1305 = ChaCha20Poly1305::new(key);

    let mut csprng = rand_chacha::ChaCha20Rng::from_entropy();
    let (mut ci_reader, nonce) = CipherRead::new(data, cipher.clone(), &mut csprng);

    let mut vec = Vec::new();
    ci_reader.read_to_end(&mut vec).await.unwrap();
    assert!(!vec.is_empty());

    let mut deci_reader = DecipherRead::new(vec.as_slice(), cipher, nonce.as_slice());

    let mut vec_out = Vec::new();
    deci_reader.read_to_end(&mut vec_out).await.unwrap();

    assert_eq!(vec_out, data.to_vec());
}

#[tokio::test]
async fn it_can_cipher_files() {
    let value = tokio::fs::File::open("tests/data/lorem.txt").await.unwrap();
    let metadata = value.metadata().await.unwrap();
    let secret = b"super_secret_aaaaaaaaaaaaaaaaaaa";
    let key = Key::from_slice(secret);
    let cipher: ChaCha20Poly1305 = ChaCha20Poly1305::new(key);

    let mut csprng = rand_chacha::ChaCha20Rng::from_entropy();
    let (mut ci_reader, _) = CipherRead::new(value, cipher.clone(), &mut csprng);

    let mut vec = Vec::with_capacity(1000000);
    ci_reader.read_to_end(&mut vec).await.unwrap();
    assert!(vec.len() as u64 >= metadata.len());
}

#[tokio::test]
async fn it_can_cipher_then_decipher_files() {
    let value = tokio::fs::File::open("tests/data/lorem.txt").await.unwrap();
    let metadata = value.metadata().await.unwrap();
    let secret = b"super_secret_aaaaaaaaaaaaaaaaaaa";
    let key = Key::from_slice(secret);
    let cipher: ChaCha20Poly1305 = ChaCha20Poly1305::new(key);

    let mut csprng = rand_chacha::ChaCha20Rng::from_entropy();
    let (mut ci_reader, nonce) = CipherRead::new(value, cipher.clone(), &mut csprng);

    let mut vec = Vec::with_capacity(65000);
    ci_reader.read_to_end(&mut vec).await.unwrap();
    assert!(vec.len() as u64 >= metadata.len());

    let deci_reader = DecipherRead::new(vec.as_slice(), cipher, nonce.as_slice());

    let mut br = BufReader::new(deci_reader).lines();
    let mut lc = 0;
    while br.next_line().await.unwrap().is_some() {
        lc += 1;
    }
    assert_eq!(lc, 35);
}

#[tokio::test]
async fn it_can_cipher_big_files() {
    let value = tokio::fs::File::open("tests/data/lorem_big.txt")
        .await
        .unwrap();
    let metadata = value.metadata().await.unwrap();
    let secret = b"super_secret_aaaaaaaaaaaaaaaaaaa";
    let key = Key::from_slice(secret);
    let cipher: ChaCha20Poly1305 = ChaCha20Poly1305::new(key);

    let mut csprng = rand_chacha::ChaCha20Rng::from_entropy();
    let (mut ci_reader, _) = CipherRead::new(value, cipher.clone(), &mut csprng);

    let mut vec = Vec::with_capacity(1000000);
    ci_reader.read_to_end(&mut vec).await.unwrap();
    assert!(vec.len() as u64 >= metadata.len());
}

#[tokio::test]
async fn it_can_cipher_then_decipher_big_files() {
    let value = tokio::fs::File::open("tests/data/lorem_big.txt")
        .await
        .unwrap();
    let metadata = value.metadata().await.unwrap();
    let secret = b"super_secret_aaaaaaaaaaaaaaaaaaa";
    let key = Key::from_slice(secret);
    let cipher: ChaCha20Poly1305 = ChaCha20Poly1305::new(key);

    let mut csprng = rand_chacha::ChaCha20Rng::from_entropy();
    let (mut ci_reader, nonce) = CipherRead::new(value, cipher.clone(), &mut csprng);

    let mut vec = Vec::with_capacity(65000);
    ci_reader.read_to_end(&mut vec).await.unwrap();
    assert!(vec.len() as u64 >= metadata.len());

    let deci_reader = DecipherRead::new(vec.as_slice(), cipher, nonce.as_slice());

    let mut br = BufReader::new(deci_reader).lines();
    let mut lc = 0;
    while br.next_line().await.unwrap().is_some() {
        lc += 1;
    }
    assert_eq!(lc, 325);
}