use core::fmt::{Display, Formatter};
use tc_asym_cipher::{AsymmetricBlockCipher, AsymmetricBlockCipherInit};
use tc_zeroize::{Zeroize, Zeroizing};
use super::shared;
use crate::{BufferedCipher, BufferedCipherInit, BufferedError, CipherDirection};
pub struct FixedBufferedAsymmetricBlockCipher<C, const N: usize> {
cipher: C,
buffer: Zeroizing<[u8; N]>,
capacity: usize,
buffered: usize,
initialized: bool,
}
impl<C, const N: usize> FixedBufferedAsymmetricBlockCipher<C, N> {
pub fn new(cipher: C) -> Self {
Self {
cipher,
buffer: Zeroizing::new([0; N]),
capacity: 0,
buffered: 0,
initialized: false,
}
}
pub const fn underlying_cipher(&self) -> &C {
&self.cipher
}
fn reset_state(&mut self) {
self.buffer.zeroize();
self.buffered = 0;
}
}
impl<C: Display, const N: usize> Display for FixedBufferedAsymmetricBlockCipher<C, N> {
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
self.cipher.fmt(f)
}
}
impl<C, const N: usize> BufferedCipher for FixedBufferedAsymmetricBlockCipher<C, N>
where
C: AsymmetricBlockCipher,
C::Error: core::error::Error + 'static,
{
type Error = BufferedError<C::Error>;
fn block_size(&self) -> usize {
self.cipher.input_block_size()
}
fn update_output_len(&self, _input_len: usize) -> Result<usize, Self::Error> {
Ok(0)
}
fn output_len(&self, _input_len: usize) -> Result<usize, Self::Error> {
Ok(self.cipher.output_block_size())
}
fn process_bytes(&mut self, input: &[u8], _output: &mut [u8]) -> Result<usize, Self::Error> {
if !self.initialized {
return Err(BufferedError::NotInitialized);
}
shared::process_bytes(&mut self.buffer[..self.capacity], &mut self.buffered, input)
}
fn do_final(&mut self, output: &mut [u8]) -> Result<usize, Self::Error> {
let result = if self.initialized {
shared::do_final(&mut self.cipher, &self.buffer[..self.buffered], output)
} else {
Err(BufferedError::NotInitialized)
};
self.reset_state();
result
}
fn reset(&mut self) {
self.reset_state();
}
}
impl<C, P, const N: usize> BufferedCipherInit<P> for FixedBufferedAsymmetricBlockCipher<C, N>
where
C: AsymmetricBlockCipher + AsymmetricBlockCipherInit<P>,
<C as AsymmetricBlockCipherInit<P>>::Error: 'static,
P: ?Sized,
{
type Error = BufferedError<<C as AsymmetricBlockCipherInit<P>>::Error>;
fn init(&mut self, direction: CipherDirection, params: &P) -> Result<(), Self::Error> {
self.initialized = false;
self.reset_state();
self.cipher
.init(direction.into(), params)
.map_err(BufferedError::Cipher)?;
let required = shared::capacity(&self.cipher, direction);
if required > N {
return Err(BufferedError::BufferTooSmall {
required,
available: N,
});
}
self.capacity = required;
self.initialized = true;
Ok(())
}
}