rasypt-lite-cli 1.0.4

CLI tool for Jasypt-compatible encryption/decryption
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

use clap::{Parser, Subcommand};

const MIN_RECOMMENDED_PASSWORD_LEN: usize = 8;

#[derive(Parser)]
#[command(
    name = "rasypt-lite",
    about = "Jasypt-compatible AES-256 encryption/decryption (PBEWITHHMACSHA512ANDAES_256)"
)]
struct Cli {
    /// Silence non-fatal warnings
    #[arg(short, long, default_value_t = false, global = true)]
    quiet: bool,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Encrypt a plaintext value
    Encrypt {
        #[arg(short, long)]
        input: String,
        #[arg(short, long)]
        password: String,
        /// Wrap output in ENC(...)
        #[arg(long, default_value_t = false)]
        wrap: bool,
    },
    /// Decrypt an encrypted value
    Decrypt {
        /// The Base64-encoded ciphertext (or ENC(...) wrapped)
        #[arg(short, long)]
        input: String,
        #[arg(short, long)]
        password: String,
    },
}

fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Encrypt {
            input,
            password,
            wrap,
        } => {
            warn_if_password_too_short(&password, cli.quiet);
            let encrypted = rasypt_lite_lib::encrypt(&input, &password);
            if wrap {
                println!("ENC({})", encrypted);
            } else {
                println!("{}", encrypted);
            }
        }
        Commands::Decrypt { input, password } => {
            warn_if_password_too_short(&password, cli.quiet);
            let result = if rasypt_lite_lib::is_enc_value(&input) {
                rasypt_lite_lib::decrypt_enc(&input, &password)
            } else {
                rasypt_lite_lib::decrypt(&input, &password)
            };
            match result {
                Ok(plaintext) => println!("{}", plaintext),
                Err(e) => {
                    eprintln!("Decryption failed: {}", e);
                    std::process::exit(1);
                }
            }
        }
    }
}

fn warn_if_password_too_short(password: &str, quiet: bool) {
    if quiet || password.chars().count() >= MIN_RECOMMENDED_PASSWORD_LEN {
        return;
    }

    eprintln!(
        "Warning: password length is below the recommended {} characters; continuing anyway. Use --quiet to suppress this warning.",
        MIN_RECOMMENDED_PASSWORD_LEN
    );
}