rae/src/format/key/mod.rs

//! Keyiles format
use super::*;
use crypto::sha256::Sha256Hash;
use futures::{
    future::FutureExt,
};
use std::{
    fmt,
    error,
    convert::{TryFrom, TryInto,},
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord,PartialOrd, Hash, Serialize, Deserialize)]
#[repr(u8)]
pub enum KeyHeaderKind
{
    Aes,
    RsaPrivate,
    RsaPublic,
}

#[derive(Debug)]
pub struct ParsingError;

impl error::Error for ParsingError{}

impl fmt::Display for ParsingError
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
    {
	write!(f, "failed to parse key header kind from byte")
    }
}


impl TryFrom<u8> for KeyHeaderKind
{
    type Error = ParsingError;

    fn try_from(from: u8) -> Result<Self, Self::Error>
    {
	macro_rules! branches {
	    ($($num:path),*) => {
		match from {
		    $(
			x if x == $num as u8 => $num,
		    )*
			_ => return Err(ParsingError),
		}
	    }
	}

	Ok(branches! {
	    Self::Aes,
	    Self::RsaPrivate,
	    Self::RsaPublic
	})
    }
}


#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
pub struct KeyHeader
{
    kind: KeyHeaderKind,
    info: config::op::KeyDescription,
    hash: Sha256Hash,
    timestamp: i64,
}

impl Header for KeyHeader
{
    const CHECK: u16 = CHECK_KEY;
    fn hash(&self) -> Sha256Hash
    {
	let mut output = Vec::new();
	self.write_bytes(&mut output).now_or_never().unwrap().expect("Failed to write bytes to in-memory buffer");
	crypto::sha256::compute_slice(output)
    }
}

impl KeyHeader
{
    /// Create a new key header from these values
    pub const fn new(kind: KeyHeaderKind, info: config::op::KeyDescription, hash: Sha256Hash, timestamp: i64) -> Self
    {
	Self {
	    kind,
	    info,
	    hash,
	    timestamp,
	}
    }
    /// Create a new key header from these values with the current timestamp
    pub fn new_now(kind: KeyHeaderKind, info: config::op::KeyDescription, hash: Sha256Hash) -> Self
    {
	Self {
	    timestamp: timestamp::now(),
	    ..Self::new(kind,info,hash,0)
	}
    }

    /// Write this superheader as text bytes to this stream
    #[instrument(err, skip(out))]
    pub async fn write_text<T: AsyncWrite+Unpin+?Sized>(&self, out: &mut T) -> Result<usize, eyre::Report>
    {
	todo!()
    }
    /// Read a superheader as text bytes from this stream
    #[instrument(err, skip(input))]
    pub async fn read_text<T: AsyncRead+Unpin+?Sized>(input: &mut T) -> Result<Self, eyre::Report>
    {
	todo!()
    }
    /// Write this key header as bytes to this stream
    #[instrument(err, skip(out))]
    pub async fn write_bytes<T: AsyncWrite+Unpin+?Sized>(&self, out: &mut T) -> Result<usize, eyre::Report>
    {
	out.write_u8(self.kind as u8).await?;
	let desc = {
	    let buf = serde_cbor::to_vec(&self.info)
		.wrap_err_with(|| eyre::eyre!("Failed to serialise key info into bytes"))
		.with_section(|| format!("{:?}", self.info).header("Key info was"))?;
	    out.write_u64(buf.len().try_into()
			  .wrap_err_with(|| eyre::eyre!("Failed to represent key info size as 64 bit integer. Something is very wrong"))
			  .with_section(|| buf.len().to_string().header("Buffer size was"))?).await?;
	    out.write_all(&buf[..]).await?;
	    buf.len()
	};
	out.write_all(self.hash.as_ref()).await?;
	out.write_i64(self.timestamp).await?;
	Ok(1 + std::mem::size_of::<Sha256Hash>() + 8 + desc)
    }
    
    /// Read a key header as bytes from this stream
    #[instrument(err, skip(input))]
    pub async fn read_bytes<T: AsyncRead+Unpin+?Sized>(input: &mut T) -> Result<Self, eyre::Report>
    {
	let kind = {
	    let byte = input.read_u8().await?;
	    byte.try_into().
		with_section(|| [byte].to_hex_string().header("Invalid byte was"))?
	};
	let info = {
	    let read = input.read_u64().await?;
	    let read = usize::try_from(read)
		.wrap_err_with(|| eyre::eyre!("Read buffer size does not fit into usize (u64 -> u{}).", std::mem::size_of::<usize>()*8))
		.with_section(|| read.to_string().header("Read size was"))
		.with_note(|| "This is a likely indication of file corruption")?;
	    let mut buffer = vec![0u8; read];
	    input.read_exact(&mut buffer[..]).await?;
	    serde_cbor::from_reader(&buffer[..])
		.wrap_err_with(|| eyre::eyre!("Failed to deserialise key info from byte buffer"))
		.with_section(|| read.to_string().header("Byte buffer's valid read size was"))
		.with_section(|| format!("{}", buffer.fmt_view()).header("Byte buffer was"))?
	};
	let hash = {
	    let mut hash = Sha256Hash::empty();
	    input.read_exact(hash.as_mut()).await?;
	    hash
	};
	let timestamp = input.read_i64().await?;

	Ok(Self {
	    kind,
	    info,
	    hash,
	    timestamp
	})
    }
}

#[cfg(test)]
mod tests
{
    use super::*;
    #[test]
    fn now_or_never()
    {
	let mut vec = Vec::new();
	use tokio::{
	    prelude::*,
	    io::AsyncWrite,
	};
	use futures::future::FutureExt;
	async {
	    vec.write_all(&[0u8,1,2,3]).await.unwrap();
	    vec.write_all(&[4u8,5,6,7]).await.unwrap();
	}.now_or_never().unwrap();

	assert_eq!(&vec[..], &[0,1,2,3,4,5,6,7]);
    }

    #[tokio::test]
    async fn serde_with_super() -> Result<(), eyre::Report>
    {
	//color_eyre::install()?;

	let header = KeyHeader::new_now(KeyHeaderKind::Aes, Default::default(), Default::default());
	let mut ser = Vec::new();
	let superheader = SuperHeader::<KeyHeader>::new_for(&header);
	println!("Writing: {:?} + {:?}", superheader, header);
	let written = superheader.write_bytes(&mut ser).await? +
	    header.write_bytes(&mut ser).await?;
	println!("Wrote {} bytes", written);
	println!("{}\n", ser.fmt_view());

	let mut read = &ser[..];
	let reads = SuperHeader::read_bytes(&mut read).await?;
	println!("Read super: {:?}", reads);
	let readheader = KeyHeader::read_bytes(&mut read).await?;
	println!("Read real: {:?}", readheader);

	reads.verify_for(&header)?;
	reads.verify_for(&readheader)?;
	assert_eq!(readheader, header);
	assert_eq!(reads, superheader);

	Ok(())
    }
    #[tokio::test]
    async fn serde() -> Result<(), eyre::Report>
    {
	let header = KeyHeader::new_now(KeyHeaderKind::Aes, Default::default(), Default::default());
	let mut ser = Vec::new();
	println!("Writing {:?}", header);
	let val = header.write_bytes(&mut ser).await?;
	println!("Wrote {} bytes:", val);
	println!("{}\n", ser.fmt_view());

	let reader = KeyHeader::read_bytes(&mut &ser[..]).await?;
	println!("Read: {:?}", reader);
	assert_eq!(reader, header);
	
	Ok(())
    }

    #[tokio::test]
    async fn serde_text() -> Result<(), eyre::Report>
    {
	color_eyre::install()?;
	
	let header = KeyHeader::new_now(KeyHeaderKind::Aes, Default::default(), Default::default());
	let mut ser = Vec::new();
	println!("Writing {:?}", header);
	let val = header.write_text(&mut ser).await?;
	println!("Wrote {} bytes:", val);
	println!("{}\n", ser.fmt_view());

	let reader = KeyHeader::read_text(&mut &ser[..]).await?;
	println!("Read: {:?}", reader);
	assert_eq!(reader, header);
	
	Ok(())
    }
    
    #[tokio::test]
    async fn serde_text_with_super() -> Result<(), eyre::Report>
    {
	//color_eyre::install()?;

	panic!("We're going to have to write our own text serialisation to get around the `read_whole_buffer` thingy...");
/*
	let header = KeyHeader::new_now(KeyHeaderKind::Aes, Default::default(), Default::default());
	let mut ser = Vec::new();
	let superheader = SuperHeader::<KeyHeader>::new_for(&header);
	println!("Writing: {:?} + {:?}", superheader, header);
	let written = superheader.write_text(&mut ser).await? +
	    header.write_text(&mut ser).await?;
	println!("Wrote {} bytes", written);
	println!("{}\n", ser.fmt_view());

	let mut read = &ser[..];
	let reads = SuperHeader::read_text(&mut read).await?;
	println!("Read super: {:?}", reads);
	let readheader = KeyHeader::read_text(&mut read).await?;
	println!("Read real: {:?}", readheader);

	reads.verify_for(&header)?;
	reads.verify_for(&readheader)?;
	assert_eq!(readheader, header);
	assert_eq!(reads, superheader);

	Ok(())*/
    }
}