oxismet 1.0.0

A mass encryption tool for servers
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
72
73

use std::{fs::File, io::Write, process::ExitCode};

use smet::{GcmNonce, Salt};

use crate::VERSION;

pub fn encrypt_with_password(
    password: &str,
    bytes: &[u8],
    buffer: &mut File,
) -> Result<(), ExitCode> {
    let (encrypted_data, salt) = smet::encrypt_with_password(bytes, password).map_err(|_| {
        eprintln!("Error in Encryption. No further info available.");
        ExitCode::FAILURE
    })?;
    buffer.write_all(&VERSION.to_be_bytes()).map_err(|e| {
        eprintln!("Error: Failed to write version to output file: {e}");
        ExitCode::FAILURE
    })?;
    buffer
        .write_all(encrypted_data.nonce.as_slice())
        .map_err(|e| {
            eprintln!("Error: Failed to write nonce to output file: {e}");
            ExitCode::FAILURE
        })?;
    buffer.write_all(salt.as_slice()).map_err(|e| {
        eprintln!("Error: Failed to write salt to output file: {e}");
        ExitCode::FAILURE
    })?;
    buffer.write_all(&encrypted_data.bytes).map_err(|e| {
        eprintln!("Error: Failed to write ciphertext to output file: {e}");
        ExitCode::FAILURE
    })?;
    Ok(())
}
pub fn decrypt_with_password(
    password: &str,
    bytes: &[u8],
    buffer: &mut File,
) -> Result<(), ExitCode> {
    let Some((version_bytes, rest)) = bytes.split_first_chunk::<8>() else {
        eprintln!("Error: Input file too short to contain a version header.");
        return Err(ExitCode::FAILURE);
    };
    let version = u64::from_be_bytes(*version_bytes);
    if version != VERSION {
        eprintln!("Error: Unsupported File Version: {version}.");
        return Err(ExitCode::FAILURE);
    }
    let Some((nonce_bytes, rest)) = rest.split_first_chunk::<12>() else {
        eprintln!("Error: Input file too short to contain a nonce.");
        return Err(ExitCode::FAILURE);
    };
    let Some((salt_bytes, ciphertext)) = rest.split_first_chunk::<16>() else {
        eprintln!("Error: Input file too short to contain a salt.");
        return Err(ExitCode::FAILURE);
    };
    let plaintext = smet::decrypt_with_password(
        ciphertext,
        password,
        &Salt::from_slice(salt_bytes),
        &GcmNonce::from_slice(nonce_bytes),
    )
    .map_err(|_| {
        eprintln!("Error in Decryption. No further info available.");
        ExitCode::FAILURE
    })?;
    buffer.write_all(plaintext.as_slice()).map_err(|e| {
        eprintln!("Error: Failed to write plaintext to output file: {e}");
        ExitCode::FAILURE
    })?;
    Ok(())
}