librage 1.1.0

A safe, simple, and complete Rust wrapper for the rage (age) encryption library.
Documentation
use crate::LibrageError;
use crate::core::helpers;
use crate::handler::types::{DecryptOutput, LibrageResponse};
use age::armor::ArmoredReader;
use std::io::{Read, Write};

pub fn decrypt(ciphertext: &[u8], secret_key: &str) -> LibrageResponse<DecryptOutput> {
    let identity = match secret_key.parse::<age::x25519::Identity>() {
        Ok(id) => Box::new(id) as Box<dyn age::Identity>,
        Err(e) => {
            return LibrageResponse::err(LibrageError::InvalidSecretKey(e.to_string()).into());
        }
    };
    let reader = ArmoredReader::new(ciphertext);
    match helpers::decrypt_to_vec(reader, &[identity]) {
        Ok(plaintext) => LibrageResponse::ok(DecryptOutput::new(plaintext)),
        Err(e) => LibrageResponse::err(e.into()),
    }
}

pub fn decrypt_armored(ciphertext: &[u8], secret_key: &str) -> LibrageResponse<DecryptOutput> {
    decrypt(ciphertext, secret_key)
}

pub fn decrypt_with_identities(
    ciphertext: &[u8],
    identities: &[Box<dyn age::Identity>],
) -> LibrageResponse<DecryptOutput> {
    let reader = ArmoredReader::new(ciphertext);
    match helpers::decrypt_to_vec(reader, identities) {
        Ok(plaintext) => LibrageResponse::ok(DecryptOutput::new(plaintext)),
        Err(e) => LibrageResponse::err(e.into()),
    }
}

pub fn decrypt_stream<R: Read, W: Write>(
    reader: R,
    writer: W,
    secret_key: &str,
) -> LibrageResponse<()> {
    let identity = match secret_key.parse::<age::x25519::Identity>() {
        Ok(id) => Box::new(id) as Box<dyn age::Identity>,
        Err(e) => {
            return LibrageResponse::err(LibrageError::InvalidSecretKey(e.to_string()).into());
        }
    };
    let armored_reader = ArmoredReader::new(reader);
    match helpers::decrypt_stream_to_writer(armored_reader, writer, &[identity]) {
        Ok(()) => LibrageResponse::ok(()),
        Err(e) => LibrageResponse::err(e.into()),
    }
}

pub fn decrypt_stream_with_identities<R: Read, W: Write>(
    reader: R,
    writer: W,
    identities: &[Box<dyn age::Identity>],
) -> LibrageResponse<()> {
    let armored_reader = ArmoredReader::new(reader);
    match helpers::decrypt_stream_to_writer(armored_reader, writer, identities) {
        Ok(()) => LibrageResponse::ok(()),
        Err(e) => LibrageResponse::err(e.into()),
    }
}