#![cfg_attr(not(feature = "std"), no_std)]
extern crate alloc;
mod ciphers;
mod errors;
mod functions;
mod macros;
mod secure_bit;
mod traits;
use alloc::vec::Vec;
#[cfg(feature = "std")]
use std::io::{Read, Write};
#[cfg(feature = "std")]
use std::ops::Add;
pub use ciphers::{
aes128::MagicCrypt128, aes192::MagicCrypt192, aes256::MagicCrypt256, des64::MagicCrypt64,
};
pub use digest::generic_array;
pub use errors::MagicCryptError;
#[cfg(feature = "std")]
use generic_array::typenum::{IsGreaterOrEqual, PartialDiv, True, B1, U16};
#[cfg(feature = "std")]
use generic_array::ArrayLength;
pub use secure_bit::SecureBit;
pub use traits::MagicCryptTrait;
#[derive(Debug, Clone)]
enum MagicCryptCipher {
DES64(MagicCrypt64),
AES128(MagicCrypt128),
AES192(MagicCrypt192),
AES256(MagicCrypt256),
}
#[derive(Debug, Clone)]
pub struct MagicCrypt {
cipher: MagicCryptCipher,
}
impl MagicCrypt {
pub fn new<S: AsRef<[u8]>, V: AsRef<[u8]>>(
key: S,
bit: SecureBit,
iv: Option<V>,
) -> MagicCrypt {
let cipher = match bit {
SecureBit::Bit64 => MagicCryptCipher::DES64(MagicCrypt64::new(key, iv)),
SecureBit::Bit128 => MagicCryptCipher::AES128(MagicCrypt128::new(key, iv)),
SecureBit::Bit192 => MagicCryptCipher::AES192(MagicCrypt192::new(key, iv)),
SecureBit::Bit256 => MagicCryptCipher::AES256(MagicCrypt256::new(key, iv)),
};
MagicCrypt {
cipher,
}
}
}
impl MagicCryptTrait for MagicCrypt {
#[inline]
fn new<S: AsRef<[u8]>, V: AsRef<[u8]>>(key: S, iv: Option<V>) -> MagicCrypt {
MagicCrypt::new(key, SecureBit::default(), iv)
}
#[inline]
fn encrypt_to_bytes<T: ?Sized + AsRef<[u8]>>(&self, data: &T) -> Vec<u8> {
match &self.cipher {
MagicCryptCipher::DES64(mc) => mc.encrypt_to_bytes(data),
MagicCryptCipher::AES128(mc) => mc.encrypt_to_bytes(data),
MagicCryptCipher::AES192(mc) => mc.encrypt_to_bytes(data),
MagicCryptCipher::AES256(mc) => mc.encrypt_to_bytes(data),
}
}
#[cfg(feature = "std")]
#[inline]
fn encrypt_reader_to_bytes(&self, reader: &mut dyn Read) -> Result<Vec<u8>, MagicCryptError> {
match &self.cipher {
MagicCryptCipher::DES64(mc) => mc.encrypt_reader_to_bytes(reader),
MagicCryptCipher::AES128(mc) => mc.encrypt_reader_to_bytes(reader),
MagicCryptCipher::AES192(mc) => mc.encrypt_reader_to_bytes(reader),
MagicCryptCipher::AES256(mc) => mc.encrypt_reader_to_bytes(reader),
}
}
#[cfg(feature = "std")]
#[inline]
fn encrypt_reader_to_writer2<
N: ArrayLength<u8> + PartialDiv<U16> + IsGreaterOrEqual<U16, Output = True>,
>(
&self,
reader: &mut dyn Read,
writer: &mut dyn Write,
) -> Result<(), MagicCryptError> {
match &self.cipher {
MagicCryptCipher::DES64(mc) => mc.encrypt_reader_to_writer2::<N>(reader, writer),
MagicCryptCipher::AES128(mc) => mc.encrypt_reader_to_writer2::<N>(reader, writer),
MagicCryptCipher::AES192(mc) => mc.encrypt_reader_to_writer2::<N>(reader, writer),
MagicCryptCipher::AES256(mc) => mc.encrypt_reader_to_writer2::<N>(reader, writer),
}
}
#[inline]
fn decrypt_bytes_to_bytes<T: ?Sized + AsRef<[u8]>>(
&self,
bytes: &T,
) -> Result<Vec<u8>, MagicCryptError> {
match &self.cipher {
MagicCryptCipher::DES64(mc) => mc.decrypt_bytes_to_bytes(bytes),
MagicCryptCipher::AES128(mc) => mc.decrypt_bytes_to_bytes(bytes),
MagicCryptCipher::AES192(mc) => mc.decrypt_bytes_to_bytes(bytes),
MagicCryptCipher::AES256(mc) => mc.decrypt_bytes_to_bytes(bytes),
}
}
#[cfg(feature = "std")]
#[inline]
fn decrypt_reader_to_bytes(&self, reader: &mut dyn Read) -> Result<Vec<u8>, MagicCryptError> {
match &self.cipher {
MagicCryptCipher::DES64(mc) => mc.decrypt_reader_to_bytes(reader),
MagicCryptCipher::AES128(mc) => mc.decrypt_reader_to_bytes(reader),
MagicCryptCipher::AES192(mc) => mc.decrypt_reader_to_bytes(reader),
MagicCryptCipher::AES256(mc) => mc.decrypt_reader_to_bytes(reader),
}
}
#[cfg(feature = "std")]
#[inline]
fn decrypt_reader_to_writer2<
N: ArrayLength<u8> + PartialDiv<U16> + IsGreaterOrEqual<U16, Output = True> + Add<B1>,
>(
&self,
reader: &mut dyn Read,
writer: &mut dyn Write,
) -> Result<(), MagicCryptError>
where
<N as Add<B1>>::Output: ArrayLength<u8>, {
match &self.cipher {
MagicCryptCipher::DES64(mc) => mc.decrypt_reader_to_writer(reader, writer),
MagicCryptCipher::AES128(mc) => mc.decrypt_reader_to_writer(reader, writer),
MagicCryptCipher::AES192(mc) => mc.decrypt_reader_to_writer(reader, writer),
MagicCryptCipher::AES256(mc) => mc.decrypt_reader_to_writer(reader, writer),
}
}
}