You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
331 lines
9.1 KiB
331 lines
9.1 KiB
//! 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;
|
|
const NAME: &'static str = "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>
|
|
{
|
|
let text = serialise::into_text(self)
|
|
.wrap_err_with(|| eyre::eyre!("Failed to serialise header to text"))
|
|
.with_section(|| format!("{:?}", self).header("Header was"))?;
|
|
|
|
let mut written=0;
|
|
for bytes in text.as_bytes().chunks(16) {
|
|
out.write_all(bytes).await?;
|
|
out.write_u8(b'\n').await?;
|
|
written += bytes.len() + 1;
|
|
}
|
|
out.write_all(b"---").await?;
|
|
Ok(written + 4)
|
|
}
|
|
/// Read a superheader as text bytes from this stream
|
|
#[instrument(err, skip(input))]
|
|
pub async fn read_text<T: AsyncBufRead+Unpin+?Sized>(input: &mut T) -> Result<Self, eyre::Report>
|
|
{
|
|
let (mut tx, mut rx) = mpsc::channel(1);
|
|
let line_sender = async move { //this is actually kinda overkill for this...
|
|
let mut buffer = String::new();
|
|
while input.read_line(&mut buffer).await? != 0 {
|
|
tx.send(buffer.clone()).await?;
|
|
buffer.clear();
|
|
}
|
|
Ok::<(), eyre::Report>(())
|
|
};
|
|
let line_reader = async {
|
|
let mut enc = String::new();
|
|
let mut had_delim =false;
|
|
while let Some(line) = rx.recv().await {
|
|
let line = line.trim();
|
|
if line == "---" {
|
|
had_delim=true;
|
|
break;
|
|
} else if line.len()>0 {
|
|
enc.push_str(line)
|
|
}
|
|
}
|
|
if !had_delim {
|
|
warn!("Buffer contained no end-of-entry delimiter");
|
|
}
|
|
//let = take_one!("Expected header line");
|
|
|
|
Ok::<Self, eyre::Report>(serialise::from_text(&enc[..])
|
|
.wrap_err_with(|| eyre::eyre!("Failed to deserialise string"))
|
|
.with_section(|| enc.header("Read string was"))?)
|
|
};
|
|
tokio::pin!(line_sender);
|
|
tokio::pin!(line_reader);
|
|
let (sres, rres) = tokio::join!(line_sender, line_reader);
|
|
sres?;
|
|
Ok(rres?)
|
|
}
|
|
/// 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()
|
|
{
|
|
color_eyre::install().unwrap();
|
|
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>
|
|
{
|
|
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>
|
|
{
|
|
|
|
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 read = &mut read;
|
|
let reads = SuperHeader::read_text(read).await?;
|
|
println!("Read super: {:?}", reads);
|
|
let readheader = KeyHeader::read_text(read).await?;
|
|
println!("Read real: {:?}", readheader);
|
|
|
|
reads.verify_for(&header)?;
|
|
reads.verify_for(&readheader)?;
|
|
assert_eq!(readheader, header);
|
|
assert_eq!(reads, superheader);
|
|
|
|
//panic!("\n{}\n",std::str::from_utf8(&ser[..]).unwrap());
|
|
Ok(())
|
|
}
|
|
}
|