From eab569fd03895b0f3b52f1f25f94d908480c03d5 Mon Sep 17 00:00:00 2001 From: Isabelle L Date: Fri, 29 May 2020 23:40:24 -0500 Subject: [PATCH] removed `PacketKind` enum in favor of just using a u8 --- README.md | 19 ++++++++++++++-- src/agreement.rs | 8 +++++-- src/lib.rs | 57 +++++++++++++++++++++++++++++++++--------------- src/message.rs | 15 ++++++++++--- 4 files changed, 74 insertions(+), 25 deletions(-) diff --git a/README.md b/README.md index aa10273..86cc894 100644 --- a/README.md +++ b/README.md @@ -3,13 +3,28 @@ ### 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 +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 | +| 1 byte | u8 encrypt flag | | 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 | + +### packet kind + +packet kind has defined values for packets but leaves many open for user defined packets to be added to the protocol + +| byte | packet kind | +|--------|-------------------------------------------------------| +| `0x00` | message - a simple text packet | +| `0xff` | agreement - used to help generate an aggreed upon key | + +### encrypt flag + +encrypt flag can be `0x00` for no encrypt or `0xff` for ring AEAD symmetric encrypt + + diff --git a/src/agreement.rs b/src/agreement.rs index 508923e..c5687df 100644 --- a/src/agreement.rs +++ b/src/agreement.rs @@ -1,5 +1,5 @@ // namespacing -use crate::{Packet, PacketKind, Result}; +use crate::{Packet, Result}; use chrono::prelude::*; use serde::{Deserialize, Serialize}; use uuid::Uuid; @@ -29,7 +29,7 @@ impl Agreement { impl crate::Sendable for Agreement { fn to_packet(&self, encrypt_kind: crate::EncryptKind) -> Result { let contents: Vec = serde_json::to_string(&self)?.into_bytes(); - let kind = PacketKind::Agreement; + let kind = 0xff; Ok(Packet::new(kind, contents, encrypt_kind)) } @@ -38,4 +38,8 @@ impl crate::Sendable for Agreement { let agreement: Agreement = serde_json::from_str(contents)?; Ok(agreement) } + + fn packet_kind(&self) -> u8 { + 0xff + } } diff --git a/src/lib.rs b/src/lib.rs index 369425c..d9809f7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -8,7 +8,7 @@ //! | segment size | usage | //! |--------------|--------------------------------------------| //! | 1 byte | u8 packet kind | -//! | 1 byte | u8 encrypt kind | +//! | 1 byte | u8 encrypt flag | //! | 8 byte | u64 length of the packet contents | //! | 4 byte | CRC32 packet contents checksum | //! | 32 byte | SHA256 packet contents integrity check | @@ -41,25 +41,32 @@ struct NetworkPacket(Vec); /// a type of data that can be sent pub trait Sendable: Sized { /// create a packet from the struct - fn to_packet(&self, encrypt_kind: EncryptKind) -> Result; + fn to_packet(&self, encrypt_flag: EncryptKind) -> Result; /// create the struct from a packet fn from_packet(packet: Packet) -> Result; + /// returns the sendable's packet kind + fn packet_kind(&self) -> u8; } /// data to be sent #[derive(Debug, Clone)] pub struct Packet { - pub kind: PacketKind, - pub encrypt_kind: EncryptKind, + pub kind: u8, + pub encrypt_flag: EncryptKind, pub integrity_hash: Vec, pub contents: Vec, } impl Packet { /// create a new `Packet` - pub fn new(kind: PacketKind, contents: Vec, encrypt_kind: EncryptKind) -> Packet { + pub fn new(kind: u8, contents: Vec, encrypt_flag: EncryptKind) -> Packet { let integrity_hash = digest::digest(&digest::SHA256, &contents).as_ref().to_vec(); - Packet { kind, integrity_hash, contents, encrypt_kind } + Packet { + kind, + integrity_hash, + contents, + encrypt_flag, + } } // generate a checksum from the packet @@ -82,7 +89,7 @@ impl Packet { contents.push(self.kind as u8); // write encrypt kind byte - contents.push(self.encrypt_kind as u8); + contents.push(self.encrypt_flag as u8); // write the packet length let contents_length = self.contents.len() as u64; @@ -101,12 +108,18 @@ impl Packet { /// verifies SHA256 integrity pub fn verify_integrity(&self) -> Result<()> { - let expected = digest::digest(&digest::SHA256, &self.contents).as_ref().to_vec(); + let expected = digest::digest(&digest::SHA256, &self.contents) + .as_ref() + .to_vec(); if expected == self.integrity_hash { Ok(()) } else { - Err(IlmpError::BadHashIntegrity { found: self.integrity_hash.clone(), expected }.into()) + Err(IlmpError::BadHashIntegrity { + found: self.integrity_hash.clone(), + expected, + } + .into()) } } @@ -122,7 +135,7 @@ impl Packet { } } -/// kinds of packets that can be sent +/*/// kinds of packets that can be sent #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(u8)] pub enum PacketKind { @@ -140,7 +153,7 @@ impl PacketKind { } } } - +*/ /// ilmp's error type #[derive(Error, Debug)] pub enum IlmpError { @@ -175,8 +188,8 @@ where return Ok(None); } - let kind = PacketKind::from_u8(info_buf[0]).unwrap(); - let encrypt_kind = EncryptKind::from_u8(info_buf[1]).unwrap(); + let kind = info_buf[0]; + let encrypt_flag = 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()); @@ -186,12 +199,17 @@ where let mut contents: Vec = vec![0; length]; stream.read(&mut contents).await?; - let mut packet = Packet { kind, contents, integrity_hash, encrypt_kind }; + let mut packet = Packet { + kind, + contents, + integrity_hash, + encrypt_flag, + }; packet.verify_checksum(checksum)?; packet.verify_integrity()?; - if packet.encrypt_kind == EncryptKind::Symmetric { + if packet.encrypt_flag == EncryptKind::Symmetric { encryption.decrypt(&mut packet)?; } Ok(Some(packet)) @@ -256,7 +274,9 @@ where crate::write(write, agree_packet, &encrypt::NoEncrypt::new()).await?; // receive peer's pub key - let packet = crate::read(read, &encrypt::NoEncrypt::new()).await?.unwrap(); + let packet = crate::read(read, &encrypt::NoEncrypt::new()) + .await? + .unwrap(); let agree_packet = Agreement::from_packet(packet)?; let peer_pub_key = agree::UnparsedPublicKey::new(&agree::X25519, agree_packet.public_key); @@ -266,8 +286,9 @@ where &peer_pub_key, IlmpError::Ring(ring::error::Unspecified), |key_material| { - let key_material = - digest::digest(&digest::SHA256, key_material.as_ref().into()).as_ref().to_vec(); + let key_material = digest::digest(&digest::SHA256, key_material.as_ref().into()) + .as_ref() + .to_vec(); Ok(aead::SecretKey::from_slice(&key_material)?) }, ) diff --git a/src/message.rs b/src/message.rs index c82f4ec..bf725a7 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,4 +1,4 @@ -use crate::{Packet, PacketKind, Result}; +use crate::{Packet, Result}; use chrono::prelude::*; use serde::{Deserialize, Serialize}; use uuid::Uuid; @@ -18,14 +18,19 @@ impl Message { let timestamp = Utc::now().timestamp(); let message_id = Uuid::new_v4().as_u128(); - Message { username, message_id, timestamp, contents } + Message { + username, + message_id, + timestamp, + contents, + } } } impl crate::Sendable for Message { fn to_packet(&self, encrypt_kind: crate::EncryptKind) -> Result { let contents: Vec = serde_json::to_string(&self)?.into_bytes(); - let kind = PacketKind::Message; + let kind = 0x00; Ok(Packet::new(kind, contents, encrypt_kind)) } @@ -34,4 +39,8 @@ impl crate::Sendable for Message { let message: Message = serde_json::from_str(contents)?; Ok(message) } + + fn packet_kind(&self) -> u8 { + 0x00 + } }