eck 0.0.4

A fast, simple file & folder encryption manager, written in Rust
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::encryption::encryption_flow::{decrypt_stream, encrypt_stream};
use crate::encryption::encryption_primitives::generate_nonce;
use crate::encryption::file::read_file;
use crate::errors::EnkryptitError;
use crate::key::EnkryptitKey;
use crate::metadatas::{ArchiveHeader, MetaDatas};
use crate::types::CompressionType;
use gradient_bar::GradientProgressBar;
use std::io::{BufWriter, Write};
use std::io::{Seek, SeekFrom};
use zeroize::Zeroize;

/// Public function that encrypts a file (it also resolves the key and keytype) - single thread
pub fn encrypt_file_single(
    path: &str,
    compression: CompressionType,
    enkryptit_key: EnkryptitKey,
) -> Result<String, EnkryptitError> {
    // Opens the file
    let file = read_file(path)?;

    // Generates the nonce
    let mut master_nonce = generate_nonce();

    // Builds the metadata, and serialize it
    let metadata = MetaDatas::new(
        enkryptit_key.key_type_as_ref().clone(),
        compression,
        master_nonce,
    )
    .pack()?;

    let encrypted_path = format!("{}.encky", path);

    // Creates the `cipherfile` placeholder
    let cipherfile = std::fs::File::create(&encrypted_path)?;

    let mut writer = BufWriter::new(cipherfile);

    let actual_meta_len = metadata.len() as u32;

    // Creates and pack the header
    let header = ArchiveHeader::new(false, actual_meta_len).pack()?;

    // First, we write the header's len
    writer.write_all(&[header.len() as u8])?;

    // Then, we write the serialized header
    writer.write_all(&header)?;

    // And the metadata
    writer.write_all(&metadata)?;

    let progress_bar = GradientProgressBar::with_total_bytes(file.len, "Encrypting...");

    // We encrypt the stream in place
    let _ = encrypt_stream(
        &mut writer,
        file.reader,
        master_nonce,
        enkryptit_key.key_as_ref(),
        compression,
        Some(progress_bar),
    )?;

    // And finally, we `zeroize` the master nonce (key is automatically dropped and Zeroized).
    master_nonce.zeroize();

    writer.flush()?;

    Ok(encrypted_path)
}

/// Public function that decrypts a file (single-thread)
pub fn decrypt_file_single(
    path: &str,
    payload_offset: u64,
    enkryptit_key: EnkryptitKey,
    master_nonce: [u8; 24],
    compression: CompressionType,
) -> Result<String, EnkryptitError> {
    // We open the file
    let mut file = read_file(path)?;

    let plain_path = path.strip_suffix(".encky").unwrap_or(path);
    // Create a placeholder for the new file
    let new_file = std::fs::File::create(plain_path)?;
    let mut writer = BufWriter::new(new_file);

    file.reader.seek(SeekFrom::Start(payload_offset))?;

    let progress_bar = GradientProgressBar::with_total_bytes(file.len, "Decrypting...");

    // Decrypts the stream in-place
    let _ = decrypt_stream(
        &mut writer,
        file.reader,
        enkryptit_key.key_as_ref(),
        compression,
        master_nonce,
        Some(progress_bar),
    )?;

    writer.flush()?;

    Ok(plain_path.to_string())
}