#![no_std]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc(
html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg",
html_favicon_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg"
)]
#![forbid(unsafe_code)]
#![warn(missing_docs, rust_2018_idioms, missing_debug_implementations)]
#[cfg(feature = "std")]
extern crate std;
#[cfg(feature = "getrandom")]
pub use getrandom;
#[cfg(feature = "rand_core")]
pub use rand_core;
pub use hybrid_array as array;
pub use hybrid_array::typenum;
use core::fmt;
use hybrid_array::{
typenum::{Diff, Sum, Unsigned},
Array, ArraySize,
};
#[cfg(feature = "rand_core")]
use rand_core::CryptoRngCore;
mod serializable_state;
pub use serializable_state::{
AddSerializedStateSize, DeserializeStateError, SerializableState, SerializedState,
SubSerializedStateSize,
};
pub type Block<B> = Array<u8, <B as BlockSizeUser>::BlockSize>;
pub type ParBlocks<T> = Array<Block<T>, <T as ParBlocksSizeUser>::ParBlocksSize>;
pub type Output<T> = Array<u8, <T as OutputSizeUser>::OutputSize>;
pub type Key<B> = Array<u8, <B as KeySizeUser>::KeySize>;
pub type Iv<B> = Array<u8, <B as IvSizeUser>::IvSize>;
pub type AddBlockSize<T, B> = Sum<T, <B as BlockSizeUser>::BlockSize>;
pub type SubBlockSize<T, B> = Diff<T, <B as BlockSizeUser>::BlockSize>;
pub trait BlockSizeUser {
type BlockSize: BlockSizes;
#[inline(always)]
fn block_size() -> usize {
Self::BlockSize::USIZE
}
}
impl<T: BlockSizeUser> BlockSizeUser for &T {
type BlockSize = T::BlockSize;
}
impl<T: BlockSizeUser> BlockSizeUser for &mut T {
type BlockSize = T::BlockSize;
}
pub trait BlockSizes: ArraySize + sealed::BlockSizes {}
impl<T: ArraySize + sealed::BlockSizes> BlockSizes for T {}
mod sealed {
use crate::typenum::{Gr, IsGreater, IsLess, Le, NonZero, Unsigned, U0, U256};
pub trait BlockSizes {}
impl<T: Unsigned> BlockSizes for T
where
Self: IsLess<U256> + IsGreater<U0>,
Le<Self, U256>: NonZero,
Gr<Self, U0>: NonZero,
{
}
}
pub trait ParBlocksSizeUser: BlockSizeUser {
type ParBlocksSize: ArraySize;
}
pub trait OutputSizeUser {
type OutputSize: ArraySize;
#[inline(always)]
fn output_size() -> usize {
Self::OutputSize::USIZE
}
}
pub trait KeySizeUser {
type KeySize: ArraySize;
#[inline(always)]
fn key_size() -> usize {
Self::KeySize::USIZE
}
}
pub trait IvSizeUser {
type IvSize: ArraySize;
#[inline(always)]
fn iv_size() -> usize {
Self::IvSize::USIZE
}
}
pub trait InnerUser {
type Inner;
}
pub trait Reset {
fn reset(&mut self);
}
pub trait AlgorithmName {
fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result;
}
pub trait KeyInit: KeySizeUser + Sized {
fn new(key: &Key<Self>) -> Self;
#[inline]
fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> {
<&Key<Self>>::try_from(key)
.map(Self::new)
.map_err(|_| InvalidLength)
}
#[cfg(feature = "getrandom")]
#[inline]
fn generate_key() -> Result<Key<Self>, getrandom::Error> {
let mut key = Key::<Self>::default();
getrandom::getrandom(&mut key)?;
Ok(key)
}
#[cfg(feature = "rand_core")]
#[inline]
fn generate_key_with_rng(rng: &mut impl CryptoRngCore) -> Result<Key<Self>, rand_core::Error> {
let mut key = Key::<Self>::default();
rng.try_fill_bytes(&mut key)?;
Ok(key)
}
}
pub trait KeyIvInit: KeySizeUser + IvSizeUser + Sized {
fn new(key: &Key<Self>, iv: &Iv<Self>) -> Self;
#[inline]
fn new_from_slices(key: &[u8], iv: &[u8]) -> Result<Self, InvalidLength> {
let key = <&Key<Self>>::try_from(key).map_err(|_| InvalidLength)?;
let iv = <&Iv<Self>>::try_from(iv).map_err(|_| InvalidLength)?;
Ok(Self::new(key, iv))
}
#[cfg(feature = "getrandom")]
#[inline]
fn generate_key() -> Result<Key<Self>, getrandom::Error> {
let mut key = Key::<Self>::default();
getrandom::getrandom(&mut key)?;
Ok(key)
}
#[cfg(feature = "rand_core")]
#[inline]
fn generate_key_with_rng(rng: &mut impl CryptoRngCore) -> Result<Key<Self>, rand_core::Error> {
let mut key = Key::<Self>::default();
rng.try_fill_bytes(&mut key)?;
Ok(key)
}
#[cfg(feature = "getrandom")]
#[inline]
fn generate_iv() -> Result<Iv<Self>, getrandom::Error> {
let mut iv = Iv::<Self>::default();
getrandom::getrandom(&mut iv)?;
Ok(iv)
}
#[cfg(feature = "rand_core")]
#[inline]
fn generate_iv_with_rng(rng: &mut impl CryptoRngCore) -> Result<Iv<Self>, rand_core::Error> {
let mut iv = Iv::<Self>::default();
rng.try_fill_bytes(&mut iv)?;
Ok(iv)
}
#[cfg(feature = "getrandom")]
#[inline]
fn generate_key_iv() -> Result<(Key<Self>, Iv<Self>), getrandom::Error> {
let key = Self::generate_key()?;
let iv = Self::generate_iv()?;
Ok((key, iv))
}
#[cfg(feature = "rand_core")]
#[inline]
fn generate_key_iv_with_rng(
rng: &mut impl CryptoRngCore,
) -> Result<(Key<Self>, Iv<Self>), rand_core::Error> {
let key = Self::generate_key_with_rng(rng)?;
let iv = Self::generate_iv_with_rng(rng)?;
Ok((key, iv))
}
}
pub trait InnerInit: InnerUser + Sized {
fn inner_init(inner: Self::Inner) -> Self;
}
pub trait InnerIvInit: InnerUser + IvSizeUser + Sized {
fn inner_iv_init(inner: Self::Inner, iv: &Iv<Self>) -> Self;
#[inline]
fn inner_iv_slice_init(inner: Self::Inner, iv: &[u8]) -> Result<Self, InvalidLength> {
let iv = <&Iv<Self>>::try_from(iv).map_err(|_| InvalidLength)?;
Ok(Self::inner_iv_init(inner, iv))
}
#[cfg(feature = "getrandom")]
#[inline]
fn generate_iv() -> Result<Iv<Self>, getrandom::Error> {
let mut iv = Iv::<Self>::default();
getrandom::getrandom(&mut iv)?;
Ok(iv)
}
#[cfg(feature = "rand_core")]
#[inline]
fn generate_iv_with_rng(rng: &mut impl CryptoRngCore) -> Result<Iv<Self>, rand_core::Error> {
let mut iv = Iv::<Self>::default();
rng.try_fill_bytes(&mut iv)?;
Ok(iv)
}
}
impl<T> KeySizeUser for T
where
T: InnerUser,
T::Inner: KeySizeUser,
{
type KeySize = <T::Inner as KeySizeUser>::KeySize;
}
impl<T> KeyIvInit for T
where
T: InnerIvInit,
T::Inner: KeyInit,
{
#[inline]
fn new(key: &Key<Self>, iv: &Iv<Self>) -> Self {
Self::inner_iv_init(T::Inner::new(key), iv)
}
#[inline]
fn new_from_slices(key: &[u8], iv: &[u8]) -> Result<Self, InvalidLength> {
T::Inner::new_from_slice(key).and_then(|i| T::inner_iv_slice_init(i, iv))
}
}
impl<T> KeyInit for T
where
T: InnerInit,
T::Inner: KeyInit,
{
#[inline]
fn new(key: &Key<Self>) -> Self {
Self::inner_init(T::Inner::new(key))
}
#[inline]
fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> {
T::Inner::new_from_slice(key)
.map_err(|_| InvalidLength)
.map(Self::inner_init)
}
}
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct InvalidLength;
impl fmt::Display for InvalidLength {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
f.write_str("Invalid Length")
}
}
#[cfg(feature = "std")]
impl std::error::Error for InvalidLength {}