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
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

use crate::diagnostic::EnkryptitOutput;
use crate::errors::EnkryptitError;
use crate::frontend::cli::show_params;
use crate::frontend::tui::input::TuiInput;
use crate::parameters::params::{EnkryptitParams, load_params, save_params};
use crate::types::CompressionType::{self, Lz4, NoComp, Xz};
use crate::types::KeyParams::{File, Os, PassWord};
use crate::types::ParallelismType;
use colored::*;

/// Launch the params UI
pub fn launch_params(input: &impl TuiInput) -> Result<(), EnkryptitError> {
    println!("\n{}", "Parameters Panel".cyan().bold());

    loop {
        let choices = vec![
            "Change compression type",
            "Change key type",
            "Change parallelism type",
            "Show current parameters",
            "Back to main menu",
        ];

        match input.select("What do you want to configure?", &choices) {
            Ok(choice) if choice == "Change compression type" => change_compression(input)?,
            Ok(choice) if choice == "Change key type" => change_key_type(input)?,
            Ok(choice) if choice == "Change parallelism type" => change_parallelism(input)?,
            Ok(choice) if choice == "Show current parameters" => show_current_params()?,
            Ok(choice) if choice == "Back to main menu" => break,
            Err(_) => {
                // EnkryptitOutput::info("Selection cancelled").display(); replaced by :
                tracing::info!("Selection cancelled");
            }
            _ => continue,
        }
    }

    EnkryptitOutput::success("Parameters updated !").display();

    Ok(())
}

/// Private helper for changing compression
fn change_compression(input: &impl TuiInput) -> Result<(), EnkryptitError> {
    let old_params = load_params()?;

    let choices = vec![
        "Auto (automatically choosed by Enkryptit!)",
        "Zstd (balanced)",
        "Lz4 (fastest)",
        "Xz (best compression)",
        "No compression",
    ];

    let choice = input.select("Select compression type:", &choices)?;

    let compression = match choice.as_str() {
        "Auto (automatically choosed by Enkryptit!)" => CompressionType::Auto,
        "Zstd (balanced)" => CompressionType::Zstd,
        "Lz4 (fastest)" => Lz4,
        "Xz (best compression)" => Xz,
        "No compression" => NoComp,
        _ => CompressionType::Zstd,
    };

    let params = EnkryptitParams::new(old_params.key_params, compression, old_params.parallelism);
    save_params(&params)?;

    EnkryptitOutput::success(format!("Compression changed to {:?}", compression)).display();

    Ok(())
}

/// Private helper for changing key type
fn change_key_type(input: &impl TuiInput) -> Result<(), EnkryptitError> {
    let old_params = load_params()?;

    let choices = vec!["Password (Argon2id)", "OS Keyring", "Key File"];

    let choice = input.select("Select key type:", &choices)?;

    let kt = match choice.as_str() {
        "Password (Argon2id)" => PassWord,
        "OS Keyring" => Os,
        "Key File" => File,
        _ => PassWord,
    };

    let params = EnkryptitParams::new(kt.clone(), old_params.compression, old_params.parallelism);
    save_params(&params)?;

    EnkryptitOutput::success(format!("Key type changed to {:?}", kt)).display();

    Ok(())
}

/// Private helper for changing parallelism type
fn change_parallelism(input: &impl TuiInput) -> Result<(), EnkryptitError> {
    let old_params = load_params()?;

    let choices = vec![
        "Auto (automatically choosed by Enkryptit!)",
        "Single",
        "MultiThread",
    ];

    let choice = input.select("Select parallelism type:", &choices)?;

    let pt = match choice.as_str() {
        "Auto (automatically choosed by Enkryptit!)" => ParallelismType::Auto,
        "Single" => ParallelismType::Single,
        "MultiThread" => ParallelismType::MultiThread(choose_threads(input)?),
        _ => ParallelismType::Single,
    };

    let params = EnkryptitParams::new(old_params.key_params, old_params.compression, pt);
    save_params(&params)?;

    EnkryptitOutput::success(format!("Parallelism type changed to {:?}", pt)).display();

    Ok(())
}

/// Private helper for choosing number of threads
fn choose_threads(input: &impl TuiInput) -> Result<u8, EnkryptitError> {
    let choosed =
        input.custom_counter("Enter the number of threads you want (recommended : 4-16) :")?;

    Ok(choosed)
}

/// Private helper for printing current parameters
fn show_current_params() -> Result<(), EnkryptitError> {
    let params = load_params()?;
    show_params(&params.key_params, &params.compression, &params.parallelism);
    Ok(())
}