file-crypto 0.3.0

A high performace command line tool for encrypting / decrypting any file
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
141
142
143
144
145
146
147
148
149
150
151
152
153

use super::ctrl::*;
use byteorder::{ByteOrder, BE};
use memmap::{Mmap, MmapMut, MmapOptions};
use std::fs::File;

pub struct FileReader<'a> {
    file: &'a File,
    file_size: usize,
    chunk_size: usize,
    proc_type: ProcessType,
}

impl<'a> FileReader<'a> {
    pub fn new(ctrl: &CipherCtrl) -> FileReader {
        FileReader {
            file: &ctrl.old_meta.file,
            file_size: ctrl.old_meta.size,
            chunk_size: ctrl.old_meta.chunk_size,
            proc_type: ctrl.proc_type,
        }
    }

    pub fn get_chunk(&self, page: usize) -> Option<Chunk> {
        let offset = match self.proc_type {
            ProcessType::Encrypt => page * self.chunk_size,
            ProcessType::Decrypt => page * self.chunk_size + HEADER_LEN,
        };
        if offset >= self.file_size {
            return None;
        }
        let mut mmap_option = MmapOptions::new();
        mmap_option
            .offset(offset as u64)
            .len(std::cmp::min(self.chunk_size, self.file_size - offset) as usize);

        Some(Chunk {
            page: page,
            mmap: unsafe { mmap_option.map(&self.file) }.unwrap(),
        })
    }

    pub fn header(&self) -> Mmap {
        let mut mmap_option = MmapOptions::new();
        mmap_option.len(HEADER_LEN);
        unsafe { mmap_option.map(&self.file) }.unwrap()
    }

    pub fn is_page_available(&self, page: usize) -> bool {
        page * self.chunk_size >= self.file_size
    }
}
pub struct FileWriter<'a> {
    file: &'a File,
    file_size: usize,
    chunk_size: usize,
    proc_type: ProcessType,
}

impl<'a> FileWriter<'a> {
    pub fn new(ctrl: &CipherCtrl) -> FileWriter {
        FileWriter {
            file: &ctrl.new_meta.file,
            file_size: ctrl.new_meta.size,
            chunk_size: ctrl.new_meta.chunk_size,
            proc_type: ctrl.proc_type,
        }
    }

    pub fn get_chunk_mut(&self, page: usize) -> Option<ChunkMut> {
        let offset = match self.proc_type {
            ProcessType::Encrypt => page * self.chunk_size + HEADER_LEN,
            ProcessType::Decrypt => page * self.chunk_size,
        };
        if offset >= self.file_size {
            return None;
        }
        let mut mmap_option = MmapOptions::new();
        mmap_option
            .offset(offset as u64)
            .len(std::cmp::min(self.chunk_size, self.file_size - offset) as usize);

        Some(ChunkMut {
            page: page,
            mmap_mut: unsafe { mmap_option.map_mut(&self.file) }.unwrap(),
        })
    }

    pub fn is_page_available(&self, page: usize) -> bool {
        page * self.chunk_size >= self.file_size
    }

    pub fn header(&self) -> MmapMut {
        let mut mmap_option = MmapOptions::new();
        mmap_option.len(HEADER_LEN);
        unsafe { mmap_option.map_mut(&self.file) }.unwrap()
    }
}

pub struct Header {
    pub file_size: u64,
    pub chunk_size: u64,
    pub signature: [u8; 64],
}

impl Header {
    pub fn new(file_size: u64, chunk_size: u64, signature: [u8; 64]) -> Self {
        Header {
            file_size,
            chunk_size,
            signature,
        }
    }

    pub fn from_slice(buf: &[u8]) -> Self {
        if buf.len() != HEADER_LEN {
            panic!("File format is incorrect.");
        };
        let mut sign = [0u8; 64];
        sign.copy_from_slice(&buf[16..]);
        Header {
            file_size: BE::read_u64(&buf[..8]),
            chunk_size: BE::read_u64(&buf[8..16]),
            signature: sign,
        }
    }

    pub fn from_file(file: &File) -> Self {
        let mut mmap_option = MmapOptions::new();
        mmap_option.len(HEADER_LEN);
        let mmap = unsafe{mmap_option.map(file)}.unwrap();
        Self::from_slice(mmap.as_ref())
    }

    pub fn data(&self) -> [u8; HEADER_LEN] {
        let mut buf = [0u8; HEADER_LEN];
        BE::write_u64(&mut buf[..8], self.file_size);
        BE::write_u64(&mut buf[8..16], self.chunk_size);
        buf[16..].copy_from_slice(&self.signature);
        buf
    }
}

pub struct Chunk {
    pub page: usize,
    pub mmap: Mmap,
}
pub struct ChunkMut {
    pub page: usize,
    pub mmap_mut: MmapMut,
}

pub const TAG_LEN: usize = 16;
pub const HEADER_LEN: usize = 80; // SHA512 / 8 + u64 + u64