ilmp/src/lib.rs

//! # Isabelle's Lazy Message Protocol
//!
//! ### network packet protocol
//!
//! I don't know whether or not this is a super practical way of doing things
//! but i'm lazy and it seems to work so gonna roll with it lol
//!
//! | segment size | usage                                      |
//! |--------------|--------------------------------------------|
//! | 1 byte       | u8 packet kind                             |
//! | 1 byte       | u8 encrypt kind                            |
//! | 8 byte       | u64 length of the packet contents          |
//! | 4 byte       | CRC32 packet contents checksum             |
//! | 32 byte      | SHA256 packet contents integrity check     |
//! | `u64::MAX`   | packet contents                            |
//!

mod message;
pub use message::Message;
mod asymmetric_key;
pub use asymmetric_key::AsymmetricKey;

use futures_util::io::{AsyncReadExt, AsyncWriteExt};
use ring::{rand, signature::{self, KeyPair},digest};
use std::convert::TryInto;
use std::marker::Unpin;
use thiserror::Error;

pub type Result<T> = std::result::Result<T, IlmpError>;

struct NetworkPacket(Vec<u8>);

/// a type of data that can be sent
pub trait Sendable: Sized {
    fn to_packet(&self, encrypt_kind: EncryptKind) -> Result<Packet>;
    fn from_packet(packet: Packet) -> Result<Self>;
}

/// data to be sent
pub struct Packet {
    pub kind: PacketKind,
    pub encrypt_kind: EncryptKind,
    integrity_hash: Vec<u8>,
    contents: Vec<u8>,
}

impl Packet {
    /// create a new `Packet`
    pub fn new(kind: PacketKind, contents: Vec<u8>, encrypt_kind: EncryptKind) -> Packet {
        let integrity_hash = digest::digest(&digest::SHA256, &contents).as_ref().to_vec();
        Packet { kind, integrity_hash, contents, encrypt_kind }
    }

    // generate a checksum from the packet
    fn generate_checksum(&self) -> u32 {
        // combine integrity hash and contents
        let mut hash_and_contents = self.integrity_hash.clone();
        hash_and_contents.extend_from_slice(&self.contents);

        // generate checksum
        let mut hasher = crc32fast::Hasher::new();
        hasher.update(hash_and_contents.as_ref());
        hasher.finalize()
    }

    fn to_network_packet(&self) -> NetworkPacket {
        let mut contents: Vec<u8> = Vec::new();

        // write packet kind byte
        contents.push(self.kind as u8);

        // write encrypt kind byte
        contents.push(self.encrypt_kind as u8);

        // write the packet length
        let contents_length = self.contents.len() as u64;
        contents.extend_from_slice(&contents_length.to_le_bytes());

        // write checksum
        let checksum = self.generate_checksum();
        contents.extend_from_slice(&checksum.to_le_bytes());

        // write hash and contents
        contents.extend_from_slice(&self.integrity_hash);
        contents.extend_from_slice(&self.contents);

        NetworkPacket(contents)
    }

    /// verifies SHA256 integrity
    pub fn verify_integrity(&self) -> Result<()> {
        let expected = digest::digest(&digest::SHA256, &self.contents).as_ref().to_vec();

        if expected == self.integrity_hash {
            Ok(())
        } else {
            println!("bad integrity");
            Err(IlmpError::BadHashIntegrity { found: self.integrity_hash.clone(), expected }.into())
        }
    }

    /// verifies CRC32 checksum
    pub fn verify_checksum(&self, expected: u32) -> Result<()> {
        let found = self.generate_checksum();

        if found == expected {
            Ok(())
        } else {
            println!("bad checksum");
            Err(IlmpError::BadChecksumIntegrity { expected, found })
        }
    }
}

/// kinds of packets that can be sent
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum PacketKind {
    Message = 0x00,
    AsymmetricKey = 0xff,
}

impl PacketKind {
    /// returns `Option<PacketKind> given valid matching variant
    pub fn from_u8(kind: u8) -> Option<PacketKind> {
        match kind {
            0x00 => Some(PacketKind::Message),
            0xff => Some(PacketKind::AsymmetricKey),
            _ => None,
        }
    }
}

pub trait Encryption {
    fn kind(&self) -> EncryptKind;
    fn key(&self) -> Option<Vec<u8>>;
}

pub struct AsymmetricEncrypt(Vec<u8>);

impl Encryption for AsymmetricEncrypt {
    fn kind(&self) -> EncryptKind {
        EncryptKind::Asymmetric
    }

    fn key(&self) -> Option<Vec<u8>> {
        Some(self.0.clone())
    }
}

impl AsymmetricEncrypt {
    pub fn new(key: Vec<u8>) -> AsymmetricEncrypt {
        AsymmetricEncrypt(key)
    }
}

pub struct SymmetricEncrypt(Vec<u8>);

impl Encryption for SymmetricEncrypt {
    fn kind(&self) -> EncryptKind {
        EncryptKind::Symmetric
    }

    fn key(&self) -> Option<Vec<u8>> {
        Some(self.0.clone())
    }
}

impl SymmetricEncrypt {
    pub fn new(key: Vec<u8>) -> SymmetricEncrypt {
        SymmetricEncrypt(key)
    }
}

pub struct NoEncrypt;

impl Encryption for NoEncrypt {
    fn kind(&self) -> EncryptKind {
        EncryptKind::None
    }

    fn key(&self) -> Option<Vec<u8>> {
        None
    }
}

impl NoEncrypt {
    pub fn new() -> NoEncrypt {
        NoEncrypt
    }
}

/// encryption kind
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum EncryptKind {
    None = 0x00,
    Asymmetric = 0x80,
    Symmetric = 0xff,
}

impl EncryptKind {
    /// returns `EncryptKind` from u8 if returned value is valid
    pub fn from_u8(kind: u8) -> Option<EncryptKind> {
        match kind {
            0x00 => Some(EncryptKind::None),
            0x80 => Some(EncryptKind::Asymmetric),
            0xff => Some(EncryptKind::Symmetric),
            _ => None,
        }
    }
}

/// ilmp's error type
#[derive(Error, Debug)]
pub enum IlmpError {
    #[error("checksum integrity check failed: (expected {expected:?} found {found:?})")]
    BadChecksumIntegrity { expected: u32, found: u32 },
    #[error("hash integrity check failed: (expected {expected:?} found {found:?})")]
    BadHashIntegrity { expected: Vec<u8>, found: Vec<u8> },
    // external error conversions
    #[error("std::io error")]
    StdIo(#[from] std::io::Error),
    #[error("serde_json error")]
    SerdeJson(#[from] serde_json::error::Error),
    #[error("string parsing error")]
    StringParse(#[from] std::string::FromUtf8Error),
}

/// reads a `Packet` from a stream
///
/// if `Ok(None)` is returned the stream has been disconnected.
pub async fn read<S>(stream: &mut S) -> Result<Option<Packet>>
where
    S: AsyncReadExt + Unpin,
{
    let mut info_buf = [0u8; 14];
    let check = stream.read(&mut info_buf).await?;
    if check == 0 {
        return Ok(None);
    }

    let kind = PacketKind::from_u8(info_buf[0]).unwrap();
    let encrypt_kind = EncryptKind::from_u8(info_buf[1]).unwrap();
    let length = u64::from_le_bytes(info_buf[2..10].try_into().unwrap()) as usize;
    let checksum = u32::from_le_bytes(info_buf[10..14].try_into().unwrap());

    let mut integrity_hash: Vec<u8> = vec![0; 32];
    stream.read(&mut integrity_hash).await?;

    let mut contents: Vec<u8> = vec![0; length];
    stream.read(&mut contents).await?;

    let packet = Packet { kind, contents, integrity_hash, encrypt_kind };

    packet.verify_checksum(checksum)?;
    packet.verify_integrity()?;

    Ok(Some(packet))
}

/// writes a `Sendable` packet to a stream
pub async fn write<S, P, E>(stream: &mut S, packet: P, encryption: E) -> Result<()>
where
    S: AsyncWriteExt + Unpin,
    P: Sendable,
    E: Encryption,
{
    match encryption.kind() {
        EncryptKind::None => {
            let network_packet = packet.to_packet(encryption.kind())?.to_network_packet();
            stream.write(&network_packet.0).await?;
            Ok(())
        }
        EncryptKind::Asymmetric => {
            let 
            let mut packet = packet;
            packet.contents
        },
        EncryptKind::Symmetric => todo!(),
    }
}