From cd6bbd3eda8cf59f4df20de4e3ca4a9712a69138 Mon Sep 17 00:00:00 2001
From: Isabelle L <me@izzabelle.dev>
Date: Sat, 16 May 2020 16:00:17 -0500
Subject: [PATCH] starting to impl encryption

---
 src/asymmetric_key.rs | 33 +++++++++++++++++++++++++++++++++
 src/lib.rs            | 41 ++++++++++++++++++++++++++++++-----------
 src/message.rs        | 10 ++--------
 3 files changed, 65 insertions(+), 19 deletions(-)
 create mode 100644 src/asymmetric_key.rs

diff --git a/src/asymmetric_key.rs b/src/asymmetric_key.rs
new file mode 100644
index 0000000..bc80016
--- /dev/null
+++ b/src/asymmetric_key.rs
@@ -0,0 +1,33 @@
+use crate::{Packet, PacketKind, Result};
+use chrono::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AsymmetricKey {
+    pub timestamp: i64,
+    pub public_key: Vec<u8>,
+}
+
+impl AsymmetricKey {
+    pub fn new(public_key: Vec<u8>) -> AsymmetricKey {
+        let timestamp = Utc::now().timestamp();
+        AsymmetricKey {
+            public_key,
+            timestamp,
+        }
+    }
+}
+
+impl crate::Sendable for AsymmetricKey {
+    fn to_packet(&self) -> Result<Packet> {
+        let contents: Vec<u8> = serde_json::to_string(&self)?.into_bytes();
+        let kind = PacketKind::AsymmetricKey;
+        Ok(Packet::new(kind, contents))
+    }
+
+    fn from_packet(packet: Packet) -> Result<AsymmetricKey> {
+        let contents = &String::from_utf8(packet.contents)?;
+        let asymmetric_key: AsymmetricKey = serde_json::from_str(contents)?;
+        Ok(asymmetric_key)
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 47e7ad3..8438dcd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,15 +14,17 @@
 //! | `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::digest;
 use std::convert::TryInto;
 use std::marker::Unpin;
 use thiserror::Error;
 
-mod message;
-pub use message::Message;
-
 pub type Result<T> = std::result::Result<T, IlmpError>;
 
 struct NetworkPacket(Vec<u8>);
@@ -44,7 +46,11 @@ impl Packet {
     /// create a new `Packet`
     pub fn new(kind: PacketKind, contents: Vec<u8>) -> Packet {
         let integrity_hash = digest::digest(&digest::SHA256, &contents).as_ref().to_vec();
-        Packet { kind, integrity_hash, contents }
+        Packet {
+            kind,
+            integrity_hash,
+            contents,
+        }
     }
 
     // generate a checksum from the packet
@@ -82,12 +88,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())
         }
     }
 
@@ -107,14 +119,16 @@ impl Packet {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
 pub enum PacketKind {
-    Message = 0,
+    Message = 0x00,
+    AsymmetricKey = 0xff,
 }
 
 impl PacketKind {
     /// returns `Option<PacketKind> given valid matching variant
     pub fn from_u8(kind: u8) -> Option<PacketKind> {
         match kind {
-            0 => Some(PacketKind::Message),
+            0x00 => Some(PacketKind::Message),
+            0xff => Some(PacketKind::AsymmetricKey),
             _ => None,
         }
     }
@@ -127,8 +141,8 @@ pub enum IlmpError {
     BadChecksumIntegrity { expected: u32, found: u32 },
     #[error("hash integrity check failed: (expected {expected:?} found {found:?})")]
     BadHashIntegrity { expected: Vec<u8>, found: Vec<u8> },
-    #[error("std::io error")]
     // external error conversions
+    #[error("std::io error")]
     StdIo(#[from] std::io::Error),
     #[error("serde_json error")]
     SerdeJson(#[from] serde_json::error::Error),
@@ -159,9 +173,14 @@ where
     let mut contents: Vec<u8> = vec![0; length];
     stream.read(&mut contents).await?;
 
-    let packet = Packet { kind, contents, integrity_hash };
-    packet.verify_integrity()?;
+    let packet = Packet {
+        kind,
+        contents,
+        integrity_hash,
+    };
+
     packet.verify_checksum(checksum)?;
+    packet.verify_integrity()?;
 
     Ok(Some(packet))
 }
diff --git a/src/message.rs b/src/message.rs
index 57c2b1e..6db198a 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,6 +1,5 @@
 use crate::{Packet, PacketKind, Result};
 use chrono::prelude::*;
-use ring::digest;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
@@ -31,15 +30,10 @@ impl Message {
 impl crate::Sendable for Message {
     fn to_packet(&self) -> Result<Packet> {
         let contents: Vec<u8> = serde_json::to_string(&self)?.into_bytes();
-        let integrity_hash = digest::digest(&digest::SHA256, &contents).as_ref().to_vec();
         let kind = PacketKind::Message;
-
-        Ok(Packet {
-            kind,
-            integrity_hash,
-            contents,
-        })
+        Ok(Packet::new(kind, contents))
     }
+
     fn from_packet(packet: Packet) -> Result<Self> {
         let contents = &String::from_utf8(packet.contents)?;
         let message: Message = serde_json::from_str(contents)?;