jolokia 0.7.0

Simple, strong encryption.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

pub mod cli;
pub mod ui;

use std::io::{Read, Write};

use jolokia::base64::{Base64Sink, Base64Source};
use jolokia::traits::{Base64Decode, Base64Encode, Cipher, GeneratedKey};

#[allow(clippy::unnecessary_wraps)] // Keep return type consistent.
pub fn genkey(cipher: &dyn Cipher, add_newline: bool) -> Result<(), String> {
    match cipher.generate_key() {
        GeneratedKey::Symmetric(key) => {
            print!("{}", key.base64_encode());
        }
        GeneratedKey::Asymmetric { private, public } => {
            eprintln!("Private:");
            println!("{}", private.base64_encode());
            eprintln!("Public:");
            print!("{}", public.base64_encode());
        }
        GeneratedKey::None => {
            return Err("The selected algorithm does not generate keys.".to_string());
        }
    }
    if add_newline {
        println!();
    }
    Ok(())
}

pub fn encrypt<R: Read, W: Write>(
    cipher: &dyn Cipher,
    key: &[u8],
    mut plaintext: R,
    mut output: W,
    from_raw_bytes: bool,
    add_newline: bool,
) -> Result<(), String> {
    let key = decode_base64_key(key)?;

    let mut sink: Box<dyn Write> = if from_raw_bytes {
        Box::new(&mut output)
    } else {
        Box::new(Base64Sink::new(&mut output))
    };

    cipher
        .encrypt_stream(&key, &mut plaintext, &mut sink)
        .map_err(|e| e.to_string())?;

    sink.flush().map_err(|e| e.to_string())?;

    if add_newline {
        // Explicit drop needed to reborrow `&mut output`.
        std::mem::drop(sink);
        _ = writeln!(output);
    }

    Ok(())
}

pub fn decrypt<R: Read, W: Write>(
    cipher: &dyn Cipher,
    key: &[u8],
    mut ciphertext: R,
    mut output: W,
    to_raw_bytes: bool,
) -> Result<(), String> {
    let key = decode_base64_key(key)?;

    let mut source: Box<dyn Read> = if to_raw_bytes {
        Box::new(&mut ciphertext)
    } else {
        Box::new(Base64Source::new(&mut ciphertext))
    };

    cipher
        .decrypt_stream(&key, &mut source, &mut output)
        .map_err(|e| e.to_string())?;

    Ok(())
}

fn decode_base64_key(key: &[u8]) -> Result<Vec<u8>, String> {
    match key.base64_decode() {
        Ok(key) => Ok(key),
        Err(reason) => Err(reason.to_string()),
    }
}