pmv_encryption_rs 0.1.0

Implementation of PersonalMediaVault encrypted storage model. This library allows to encrypt and decrypt data, and also read ans write files in the same format PersonalMediaVault uses.
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

// Encryption and packaging of multiple small files in one file

mod read;
pub use read::*;

mod read_error;
pub use read_error::*;

mod write;
pub use write::*;

mod write_error;
pub use write_error::*;

#[cfg(test)]
mod tests {
    use rand::{RngCore, SeedableRng, rngs::SmallRng};
    use tempdir::TempDir;

    use super::*;

    #[test]
    fn test_multi_file_pack() {
        // Mock files
        let mut rng = SmallRng::from_rng(&mut rand::rng());

        let mut mock_file_1: Vec<u8> = vec![0; 100 * 1024];
        rng.fill_bytes(&mut mock_file_1);

        let mut mock_file_2: Vec<u8> = vec![0; 200 * 1024];
        rng.fill_bytes(&mut mock_file_2);

        let mut mock_file_3: Vec<u8> = vec![0; 300 * 1024];
        rng.fill_bytes(&mut mock_file_3);

        // Temp file to store the packed files
        let dir = TempDir::new("test_pmv_encryption_rs").unwrap();
        let file_path = dir.path().join("m_1.pma");

        // Write the files in order

        let mut write_stream = MultiFilePackWriteStream::new(&file_path, 3).unwrap();

        write_stream.write_file(&mock_file_1).unwrap();
        write_stream.write_file(&mock_file_2).unwrap();
        write_stream.write_file(&mock_file_3).unwrap();
        write_stream.close();

        // Read the files (any order)

        let mut read_stream = MultiFilePackReadStream::new(&file_path).unwrap();

        assert_eq!(read_stream.get_file_count(), 3);

        let mock_file_2_r = read_stream.get_file(1).unwrap();
        assert!(mock_file_2.iter().eq(mock_file_2_r.iter()));

        let mock_file_1_r = read_stream.get_file(0).unwrap();
        assert!(mock_file_1.iter().eq(mock_file_1_r.iter()));

        let mock_file_3_r = read_stream.get_file(2).unwrap();
        assert!(mock_file_3.iter().eq(mock_file_3_r.iter()));

        assert!(matches!(
            read_stream.get_file(3),
            Err(MultiFilePackReadError::IndexOutOfBounds)
        ));

        read_stream.close();
    }
}