pmv_encryption_rs 0.1.0

// Encryption of large files

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 std::io::SeekFrom;

    use rand::{RngCore, SeedableRng, rngs::SmallRng};
    use tempdir::TempDir;

    use super::*;

    const MOCK_DATA_SIZE: usize = 1 * 1024 * 1024;
    const MOCK_BLOCK_SIZE: u64 = 128 * 1024;

    const MOCK_DATA_READ_SIZE: usize = 300 * 1024;
    const MOCK_DATA_READ_OFFSET: usize = 500 * 1024;

    #[test]
    fn test_file_block_streams() {
        // Mock key
        let key: &[u8] = &[0x01; 32];

        // Mock data
        let mut mock_data: Vec<u8> = vec![0; MOCK_DATA_SIZE];
        let mut rng = SmallRng::from_rng(&mut rand::rng());
        rng.fill_bytes(&mut mock_data);
        let file_size = mock_data.len() as u64;

        // Mock file
        let dir = TempDir::new("test_pmv_encryption_rs").unwrap();
        let file_path = dir.path().join("s_1.pma");

        // Write the data

        let mut write_stream =
            FileBlockEncryptWriteStream::new(&file_path, key.to_vec(), file_size, MOCK_BLOCK_SIZE)
                .unwrap();

        let block_count = write_stream.get_block_count();

        write_stream.write(&mock_data).unwrap();
        write_stream.close();

        // Read the data

        let mut read_stream = FileBlockEncryptReadStream::new(&file_path, key.to_vec()).unwrap();

        assert_eq!(read_stream.get_file_size(), MOCK_DATA_SIZE as u64);
        assert_eq!(read_stream.get_block_size(), MOCK_BLOCK_SIZE);
        assert_eq!(read_stream.get_block_count(), block_count);

        let mut mock_data_read_buf: Vec<u8> = vec![0; MOCK_DATA_READ_SIZE];

        let seek_pos = read_stream
            .seek(SeekFrom::Start(MOCK_DATA_READ_OFFSET as u64))
            .unwrap();

        assert_eq!(seek_pos, MOCK_DATA_READ_OFFSET as u64);
        assert_eq!(seek_pos, read_stream.get_cursor());

        let read_size = read_stream.read(&mut mock_data_read_buf).unwrap();

        assert_eq!(read_size, MOCK_DATA_READ_SIZE);

        assert!(
            mock_data_read_buf.iter().eq(mock_data
                .iter()
                .skip(MOCK_DATA_READ_OFFSET)
                .take(MOCK_DATA_READ_SIZE))
        );

        read_stream.close();
    }
}