2/3 of packets pass tests

1 files changed, 318 insertions, 24 deletions

diff --git a/src/packet.rs b/src/packet.rs
index dd43130..269835a 100644
--- a/src/packet.rs
+++ b/src/packet.rs
@@ -4,7 +4,7 @@ use chrono::{DateTime, Local, Utc};
 use hex::decode;
 use tokio_util::bytes::{Buf, Bytes};
 use structdiff::{Difference, StructDiff};
-use crate::{crypto::SharedSecret, crypto::PublicKey};
+use crate::crypto::{PrivateKey, PublicKey, SharedSecret};
 
 #[derive(PartialEq, Debug, Clone, Difference)]
 #[difference(expose)]
@@ -125,39 +125,99 @@ impl From<u8> for NodeType {
     }
 }
 
+#[derive(PartialEq, Debug, Clone, Difference)]
+#[difference(expose)]
+struct PeerToPeerCipher {
+    destination: u8,
+    source: u8,
+    mac: u16,
+    ciphertext: Bytes
+}
+
+impl From<Bytes> for PeerToPeerCipher {
+    fn from(value: Bytes) -> Self {
+        let mut bytes = value;
+
+        let mut response = PeerToPeerCipher {
+            destination: 0x00,
+            source: 0x00,
+            mac: 0x0000,
+            ciphertext: Bytes::new()
+        };
+
+        // Just check for the whole fixed-size part at once
+        if bytes.len() < 4 { return response }
+        response.destination = bytes.get_u8();
+        response.source = bytes.get_u8();
+        response.mac = bytes.get_u16();
+
+        response.ciphertext = bytes;
+
+        response
+    }
+}
+
+impl PeerToPeerCipher {
+    pub fn attempt_decrypt(&mut self, secret: SharedSecret) -> Option<(Bytes, PublicKey, PrivateKey)> {
+        None
+    }
+}
+
 #[derive(PartialEq, Debug, Clone)]
-struct Request {}
+struct Request {
+    cipher: PeerToPeerCipher,
+}
 
 impl From<Bytes> for Request {
     fn from(value: Bytes) -> Self {
-        todo!()
+        let request = Request {
+            cipher: PeerToPeerCipher::from(value)
+        };
+
+        request
     }
 }
 
-#[derive(PartialEq, Debug, Clone)]
-struct Response {}
+#[derive(PartialEq, Debug, Clone, Difference)]
+#[difference(expose)]
+struct Response {
+    cipher: PeerToPeerCipher,
+}
 
 impl From<Bytes> for Response {
     fn from(value: Bytes) -> Self {
-        todo!()
+        let response = Response {
+            cipher: PeerToPeerCipher::from(value)
+        };
+
+        response
     }
 }
 
 #[derive(PartialEq, Debug, Clone)]
-struct Text {}
+struct Text {
+    cipher: PeerToPeerCipher,
+}
 
 impl From<Bytes> for Text {
     fn from(value: Bytes) -> Self {
-        todo!()
+        let mut text = Text {
+            cipher: PeerToPeerCipher::from(value)
+        };
+
+        text
     }
 }
 
 #[derive(PartialEq, Debug, Clone)]
-struct Ack {}
+struct Ack {
+    checksum: u32
+}
 
 impl From<Bytes> for Ack {
     fn from(value: Bytes) -> Self {
-        todo!()
+        let mut bytes = value;
+        Ack { checksum: bytes.get_u32() }
     }
 }
 
@@ -251,11 +311,36 @@ impl From<Bytes> for Advert {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-struct GroupText {}
+struct GroupText {
+    hash: u8,
+    mac: u16,
+    ciphertext: Bytes,
+
+    cleartext: Option<String>,
+
+    incomplete: bool
+}
 
 impl From<Bytes> for GroupText {
     fn from(value: Bytes) -> Self {
-        todo!()
+        let mut bytes = value;
+
+        let mut group_text = GroupText {
+            hash: 0x00,
+            mac: 0x0000,
+            ciphertext: Bytes::new(),
+            cleartext: None,
+            incomplete: true,
+        };
+
+        // Just check for the whole fixed-size part at once
+        if bytes.len() < 3 { return group_text }
+        group_text.hash = bytes.get_u8();
+        group_text.mac = bytes.get_u16();
+
+        group_text.ciphertext = bytes;
+        group_text.incomplete = false;
+        group_text
     }
 }
 
@@ -278,7 +363,9 @@ impl From<Bytes> for AnonReq {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-struct Path {}
+struct Path {
+    cipher: PeerToPeerCipher,
+}
 
 impl From<Bytes> for Path {
     fn from(value: Bytes) -> Self {
@@ -287,11 +374,37 @@ impl From<Bytes> for Path {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-struct Trace {}
+struct Trace {
+    tag: u32,
+    auth: u32,
+    flags: u8,
+    path_snr: Vec<f32>,
+    invalid: bool,
+
+    temp_path: Vec<u8>
+}
 
 impl From<Bytes> for Trace {
     fn from(value: Bytes) -> Self {
-        todo!()
+        let mut bytes = value;
+
+        let mut trace = Trace {
+            tag: 0,
+            auth: 0,
+            flags: 0,
+            path_snr: vec![],
+            invalid: true,
+            temp_path: vec![]
+        };
+
+        if bytes.len() < 10 { return trace; }
+
+        trace.tag       = bytes.get_u32();
+        trace.auth      = bytes.get_u32();
+        trace.flags     = bytes.get_u8();
+        trace.temp_path = bytes.iter().map(|s| *s).collect();
+        trace.invalid   = false;
+        trace
     }
 }
 
@@ -388,6 +501,24 @@ impl From<Bytes> for Packet {
 
         packet.content = PacketContent::new(header, bytes);
 
+        // Unfortunately, the trace packet is a bit weird.
+        // So, if this is a trace packet, move things back into the right place.
+        match packet.content {
+            PacketContent::Trace(trace) => {
+                let mut trace = trace;
+                let path_snr = packet.path;
+                packet.path = trace.temp_path.iter().map(|i| *i as u16).collect();
+                trace.path_snr = path_snr.iter().map( |u| {
+                    let i = *u as i8;
+                    let f = i as f32;
+                    f / 4.0
+                }).collect();
+                trace.temp_path = vec![];
+                packet.content = PacketContent::Trace(trace);
+            },
+            _ => {}
+        }
+        
         // Mark the packet as complete and valid
         packet.incomplete = false;
 
@@ -395,13 +526,6 @@ impl From<Bytes> for Packet {
     }
 }
 
-impl Packet {
-    pub fn attempt_decrypt(&mut self, secret: SharedSecret) -> bool {
-        false
-    }
-
-}
-
 impl Default for Packet {
     fn default() -> Self {
         Packet {
@@ -463,7 +587,7 @@ mod tests {
     }
 
     fn print_compare(lhs: Packet, rhs: Packet) -> String {
-        let mut output_string = format!("Differences between packets: \n");
+        let mut output_string = format!("Left hand side: \n{:#?}\nRight hand side: \n{:#?}\nDifferences: \n", lhs, rhs);
         
         for diff in lhs.diff(&rhs) {
             output_string.push_str(&format!("{:#?}", diff));
@@ -519,7 +643,7 @@ mod tests {
     }
 
     #[test]
-    fn advert() {
+    fn advert_with_lat_lon() {
         // Real sample packet from the air
         let sample = "110c015f7e9b60661da0f2671512460728508c17ef336412a223144d3a623215162682045c44fef7241af0161923d3af0769d2d976b687a506dd5325ef526bf3eb52ae687277fcbde9969a5b0087e0eb0f7c1760a50c6a88bec13cc30a2a9b681d713166515e3bbc2bc27f20c0e4d7b67e08910c29dc02c468b8f8484f574c";
 
@@ -551,7 +675,177 @@ mod tests {
     }
 
     #[test]
+    fn advert() {
+        // Another on-air sample
+        let sample = "12007890b8573a6ba4a05b173d6ccfdfa73ac8ec4a12bf3c745ace636e1d191e132a4eb407695601f50907999735f3699a3c73ace2d8acc385ed209606abef6b914a346fbb88648c540ae794586b4d54eb08b473c8571a00c6b8d3dbcc77699afa169811fa098168707578373335";
+
+        let mut signature_slice = [0 as u8; 64];
+        hex::decode_to_slice("5601f50907999735f3699a3c73ace2d8acc385ed209606abef6b914a346fbb88648c540ae794586b4d54eb08b473c8571a00c6b8d3dbcc77699afa169811fa09", &mut signature_slice).unwrap();
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Direct,
+            version: PayloadVersion::VersionOne,
+            path: vec![],
+            transport: [0x00, 0x00],
+            raw_content: Bytes::copy_from_slice(&decode("7890b8573a6ba4a05b173d6ccfdfa73ac8ec4a12bf3c745ace636e1d191e132a4eb407695601f50907999735f3699a3c73ace2d8acc385ed209606abef6b914a346fbb88648c540ae794586b4d54eb08b473c8571a00c6b8d3dbcc77699afa169811fa098168707578373335").unwrap()),
+            content: PacketContent::Advert(Advert {
+                public_key: PublicKey::from_str("7890b8573a6ba4a05b173d6ccfdfa73ac8ec4a12bf3c745ace636e1d191e132a").unwrap(),
+                timestamp: DateTime::from_timestamp(1762112590, 0).unwrap(),
+                signature: signature_slice,
+                node_type: NodeType::Chat,
+                latitude: None,
+                longitude: None,
+                feature1: None,
+                feature2: None,
+                name: "hpux735".to_owned(),
+            }),
+            incomplete: false,            
+        };
+
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
+    }
+
+    #[test]
+    fn response() {
+        let sample = "06003412b9000cf1641739f7e4d49bff88bf5695b304111b15277de3a6031b9af3a2b6371cf75615ffefe7dcc0bbea2856c4e798a72d5b989d6de1aa646c1e2eef4cf13e6f92";
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Direct,
+            version: PayloadVersion::VersionOne,
+            path: vec![],
+            transport: [0, 0],
+            raw_content: Bytes::copy_from_slice(&decode("3412b9000cf1641739f7e4d49bff88bf5695b304111b15277de3a6031b9af3a2b6371cf75615ffefe7dcc0bbea2856c4e798a72d5b989d6de1aa646c1e2eef4cf13e6f92").unwrap()),
+            content: PacketContent::Response(Response {
+                cipher: PeerToPeerCipher {
+                destination: 0x34,
+                source: 0x12,
+                mac: 0xb900,
+                ciphertext: Bytes::copy_from_slice(&decode("0cf1641739f7e4d49bff88bf5695b304111b15277de3a6031b9af3a2b6371cf75615ffefe7dcc0bbea2856c4e798a72d5b989d6de1aa646c1e2eef4cf13e6f92").unwrap())
+            }}),
+            incomplete: false,
+        };
+
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
+    }
+
+    #[test]
     fn request() {
+        let sample = "020012341d87ccaac89563cbb39d2333b725e407a1a6";
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Direct,
+            version: PayloadVersion::VersionOne,
+            path: vec![],
+            transport: [0, 0],
+            raw_content: Bytes::copy_from_slice(&decode("12341d87ccaac89563cbb39d2333b725e407a1a6").unwrap()),
+            content: PacketContent::Request(Request {
+                cipher: PeerToPeerCipher {
+                destination: 0x12,
+                source: 0x34,
+                mac: 0x1d87,
+                ciphertext: Bytes::copy_from_slice(&decode("ccaac89563cbb39d2333b725e407a1a6").unwrap())
+            }}),
+            incomplete: false,
+        };
+
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
+    }
+
+    #[test]
+    fn text() {
+        let sample = "0a001234e91c8eb2b815e0eccf6781a3ff1820d0fb130fcfc87b914244fae227d4ad4c752fb9";
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Direct,
+            version: PayloadVersion::VersionOne,
+            path: vec![],
+            transport: [0, 0],
+            raw_content: Bytes::copy_from_slice(&decode("1234e91c8eb2b815e0eccf6781a3ff1820d0fb130fcfc87b914244fae227d4ad4c752fb9").unwrap()),
+            content: PacketContent::Text(Text {
+                cipher: PeerToPeerCipher {
+                destination: 0x12,
+                source: 0x34,
+                mac: 0xe91c,
+                ciphertext: Bytes::copy_from_slice(&decode("8eb2b815e0eccf6781a3ff1820d0fb130fcfc87b914244fae227d4ad4c752fb9").unwrap())
+            }}),
+            incomplete: false,
+        };
+
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
+    }
+
+    #[test]
+    fn ack() {
+        let sample = "0D0E78B5561B03CD70DA326066B8A0CF24F3214D";
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Flood,
+            version: PayloadVersion::VersionOne,
+            path: vec![0x78, 0xB5, 0x56, 0x1B, 0x03, 0xCD, 0x70, 0xDA, 0x32, 0x60, 0x66, 0xB8, 0xA0, 0xCF],
+            transport: [0, 0],
+            raw_content: Bytes::copy_from_slice(&decode("24F3214D").unwrap()),
+            content: PacketContent::Ack(Ack {
+                checksum: 0x24F3214D
+           }),
+           incomplete: false
+        };
 
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
     }
+
+    #[test]
+    fn trace() {
+        let sample = "26032CE0F149EB5B240000000000ACA079";
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Direct,
+            version: PayloadVersion::VersionOne,
+            path: vec![0xAC, 0xA0, 0x79],
+            transport: [0, 0],
+            raw_content: Bytes::copy_from_slice(&decode("49EB5B240000000000ACA079").unwrap()),
+            content: PacketContent::Trace(Trace {
+                tag: 0x49EB5B24,
+                auth: 0x00000000,
+                flags: 0x00,
+                path_snr: vec![11.0, -8.0, -3.75],
+                invalid: false,
+                temp_path: vec![]
+            }
+           ),
+           incomplete: false
+        };
+
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
+    }
+
+    #[test]
+    fn group_text() {
+        let sample = "15107B2CF1A31C03E8AACD7E6066B8A0ACB71176B87DDF8FE67B33E7A63036E015311EE39232F094FAAD13C4442947947DD098886BC677DE2B6F456149D0A1B05C72F0EECC20DC07EDF163D9D63EBC9BC29A7C79AF";
+
+        let lhs_packet = Packet {
+            route_type: RouteType::Flood,
+            version: PayloadVersion::VersionOne,
+            path: vec![0x7B, 0x2C, 0xF1, 0xA3, 0x1C, 0x03, 0xE8, 0xAA, 0xCD, 0x7E, 0x60, 0x66, 0xB8, 0xA0, 0xAC, 0xB7],
+            transport: [0, 0],
+            raw_content: Bytes::copy_from_slice(&decode("1176B87DDF8FE67B33E7A63036E015311EE39232F094FAAD13C4442947947DD098886BC677DE2B6F456149D0A1B05C72F0EECC20DC07EDF163D9D63EBC9BC29A7C79AF").unwrap()),
+            content: PacketContent::GroupText(GroupText {
+                hash: 0x11,
+                mac: 0x76B8,
+                ciphertext: Bytes::copy_from_slice(&decode("7DDF8FE67B33E7A63036E015311EE39232F094FAAD13C4442947947DD098886BC677DE2B6F456149D0A1B05C72F0EECC20DC07EDF163D9D63EBC9BC29A7C79AF").unwrap()),
+                cleartext: None, // "Just need some more high repeaters".to_owned()
+                incomplete: false
+            }),
+           incomplete: false
+        };
+
+        let rhs_packet = Packet::from_str(sample).unwrap();
+        assert!(lhs_packet == rhs_packet, "{}", print_compare(lhs_packet, rhs_packet));
+    }
+
 }
\ No newline at end of file