forge_crypter 0.1.2

extern crate rand;
use super::Crypter;
use crypto::buffer::{BufferResult, ReadBuffer, WriteBuffer};
use crypto::{aes, blockmodes, buffer};

pub struct Aes {
    key: Vec<u8>,
    iv: Vec<u8>,
}

impl Crypter for Aes {
    fn encrypt(&self, message: &[u8]) -> Vec<u8> {
        let mut encrypter = aes::cbc_encryptor(
            aes::KeySize::KeySize256,
            &self.key,
            &self.iv,
            blockmodes::PkcsPadding,
        );
        let mut read_buffer = buffer::RefReadBuffer::new(message);
        let mut buffer = [0; 4096];
        let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);
        let mut final_result = Vec::<u8>::new();

        loop {
            let result = encrypter
                .encrypt(&mut read_buffer, &mut write_buffer, true)
                .expect(&format!("aes encrypt failed, msg {:?}", message));

            final_result.extend(
                write_buffer
                    .take_read_buffer()
                    .take_remaining()
                    .iter()
                    .map(|&i| i),
            );

            match result {
                BufferResult::BufferUnderflow => break,
                BufferResult::BufferOverflow => {}
            }
        }

        final_result
    }

    fn decrypt(&self, message: &[u8]) -> Vec<u8> {
        let mut decryptor = aes::cbc_decryptor(
            aes::KeySize::KeySize256,
            &self.key,
            &self.iv,
            blockmodes::PkcsPadding,
        );

        let mut read_buffer = buffer::RefReadBuffer::new(message);
        let mut buffer = [0; 4096];
        let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);
        let mut final_result = Vec::<u8>::new();

        loop {
            let result = decryptor
                .decrypt(&mut read_buffer, &mut write_buffer, true)
                .expect(&format!("aes decrypt failed, msg {:?}", message));
            final_result.extend(
                write_buffer
                    .take_read_buffer()
                    .take_remaining()
                    .iter()
                    .map(|&i| i),
            );
            match result {
                BufferResult::BufferUnderflow => break,
                BufferResult::BufferOverflow => {}
            }
        }

        final_result
    }
}

impl Default for Aes {
    fn default() -> Self {
        Self {
            key: [0u8; 32].to_vec(),
            iv: [0u8; 16].to_vec(),
        }
    }
}

#[test]
fn test_aes() {
    let message = "hello, rust crypter";
    let aes = Aes::default();

    let encrypted_data = aes.encrypt(message.as_bytes());
    let message_bytes = message.as_bytes();

    let decrypted_data = aes.decrypt(&encrypted_data[..]);
    assert!(message_bytes == &decrypted_data[..]);

    let the_string = std::str::from_utf8(&decrypted_data).expect("not UTF-8");
    assert!(message == the_string);
}