librage 1.1.0

A safe, simple, and complete Rust wrapper for the rage (age) encryption library.
Documentation
use crate::handler::error::LibrageError;
use age::{Decryptor, Encryptor};
use std::io::{BufReader, Read, Write};

pub(crate) fn encrypt_to_writer<W: Write>(
    plaintext: &[u8],
    recipients: &[Box<dyn age::Recipient>],
    mut writer: W,
) -> Result<W, LibrageError> {
    let encryptor = Encryptor::with_recipients(recipients.iter().map(|r| r.as_ref()))
        .map_err(LibrageError::from)?;
    let mut encrypt_writer = encryptor
        .wrap_output(&mut writer)
        .map_err(LibrageError::from)?;
    encrypt_writer.write_all(plaintext)?;
    encrypt_writer.finish().map_err(LibrageError::from)?;
    Ok(writer)
}

pub(crate) fn decrypt_to_vec<R: Read>(
    reader: R,
    identities: &[Box<dyn age::Identity>],
) -> Result<Vec<u8>, LibrageError> {
    use std::io::BufReader;
    let decryptor = Decryptor::new_buffered(BufReader::new(reader)).map_err(LibrageError::from)?;
    let mut plaintext = Vec::new();
    let mut plain_reader = decryptor
        .decrypt(identities.iter().map(|i| i.as_ref()))
        .map_err(LibrageError::from)?;
    plain_reader.read_to_end(&mut plaintext)?;
    Ok(plaintext)
}

pub(crate) fn encrypt_stream_to_writer<R: Read, W: Write>(
    mut reader: R,
    writer: W,
    recipients: &[Box<dyn age::Recipient>],
) -> Result<(), LibrageError> {
    let encryptor = Encryptor::with_recipients(recipients.iter().map(|r| r.as_ref()))
        .map_err(LibrageError::from)?;
    let mut encrypt_writer = encryptor.wrap_output(writer).map_err(LibrageError::from)?;
    std::io::copy(&mut reader, &mut encrypt_writer)?;
    encrypt_writer.finish().map_err(LibrageError::from)?;
    Ok(())
}

pub(crate) fn decrypt_stream_to_writer<R: Read, W: Write>(
    reader: R,
    mut writer: W,
    identities: &[Box<dyn age::Identity>],
) -> Result<(), LibrageError> {
    let decryptor = Decryptor::new_buffered(BufReader::new(reader)).map_err(LibrageError::from)?;
    let mut plain_reader = decryptor
        .decrypt(identities.iter().map(|i| i.as_ref()))
        .map_err(LibrageError::from)?;
    std::io::copy(&mut plain_reader, &mut writer)?;
    Ok(())
}

pub(crate) fn encrypt_stream_to_armored_writer<R: Read, W: Write>(
    mut reader: R,
    writer: W,
    recipients: &[Box<dyn age::Recipient>],
) -> Result<(), LibrageError> {
    let encryptor = Encryptor::with_recipients(recipients.iter().map(|r| r.as_ref()))
        .map_err(LibrageError::from)?;
    let armored_writer =
        age::armor::ArmoredWriter::wrap_output(writer, age::armor::Format::AsciiArmor)
            .map_err(|e| LibrageError::EncryptionFailed(e.to_string()))?;
    let mut encrypt_writer = encryptor
        .wrap_output(armored_writer)
        .map_err(LibrageError::from)?;
    std::io::copy(&mut reader, &mut encrypt_writer)?;
    let armored_writer = encrypt_writer.finish().map_err(LibrageError::from)?;
    armored_writer.finish().map_err(LibrageError::from)?;
    Ok(())
}