Simplify, clean up

Author: durch

Cargo.toml

@@ -246,6 +246,7 @@ criterion = "0.5"
 csv = "1.3.1"
 ctr = "0.9.1"
 cupid = "0.6.1"
+curve25519-dalek = "4.1.3"
 dashmap = "5.5.3"
 # We want https://github.com/DefGuard/wireguard-rs/pull/64 , but there's no crates.io release being pushed out anymore
 defguard_wireguard_rs = { git = "https://github.com/DefGuard/wireguard-rs.git", rev = "v0.4.7" }

common/nym-lp/src/codec.rs

@@ -1,7 +1,7 @@
 // Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::message::{ClientHelloData, LpMessage, MessageType};
+use crate::message::{ClientHelloData, EncryptedDataPayload, HandshakeData, LpMessage, MessageType};
 use crate::packet::{LpHeader, LpPacket, TRAILER_LEN};
 use crate::LpError;
 use bytes::BytesMut;
@@ -43,18 +43,18 @@ pub fn parse_lp_packet(src: &[u8]) -> Result<LpPacket, LpError> {
             if message_size != 0 {
                 return Err(LpError::InvalidPayloadSize {
                     expected: 0,
-                    actual: message_size,
+                    actual: message_size,   
                 });
             }
             LpMessage::Busy
         }
         MessageType::Handshake => {
             // No size validation needed here for Handshake, it's variable
-            LpMessage::Handshake(payload_slice.to_vec())
+            LpMessage::Handshake(HandshakeData(payload_slice.to_vec()))
         }
         MessageType::EncryptedData => {
             // No size validation needed here for EncryptedData, it's variable
-            LpMessage::EncryptedData(payload_slice.to_vec())
+            LpMessage::EncryptedData(EncryptedDataPayload(payload_slice.to_vec()))
         }
         MessageType::ClientHello => {
             // ClientHello has structured data
@@ -105,7 +105,7 @@ mod tests {
     // Import standalone functions
     use super::{parse_lp_packet, serialize_lp_packet};
     // Keep necessary imports
-    use crate::message::{LpMessage, MessageType};
+    use crate::message::{EncryptedDataPayload, HandshakeData, LpMessage, MessageType};
     use crate::packet::{LpHeader, LpPacket, TRAILER_LEN};
     use crate::LpError;
     use bytes::BytesMut;
@@ -120,6 +120,7 @@ mod tests {
         let packet = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42,
                 counter: 123,
             },
@@ -150,10 +151,11 @@ mod tests {
         let packet = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42,
                 counter: 123,
             },
-            message: LpMessage::Handshake(payload.clone()),
+            message: LpMessage::Handshake(HandshakeData(payload.clone())),
             trailer: [0; TRAILER_LEN],
         };
 
@@ -171,7 +173,7 @@ mod tests {
         // Verify message type and data
         match decoded.message {
             LpMessage::Handshake(decoded_payload) => {
-                assert_eq!(decoded_payload, payload);
+                assert_eq!(decoded_payload, HandshakeData(payload));
             }
             _ => panic!("Expected Handshake message"),
         }
@@ -187,10 +189,11 @@ mod tests {
         let packet = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42,
                 counter: 123,
             },
-            message: LpMessage::EncryptedData(payload.clone()),
+            message: LpMessage::EncryptedData(EncryptedDataPayload(payload.clone())),
             trailer: [0; TRAILER_LEN],
         };
 
@@ -208,7 +211,7 @@ mod tests {
         // Verify message type and data
         match decoded.message {
             LpMessage::EncryptedData(decoded_payload) => {
-                assert_eq!(decoded_payload, payload);
+                assert_eq!(decoded_payload, EncryptedDataPayload(payload));
             }
             _ => panic!("Expected EncryptedData message"),
         }
@@ -387,18 +390,17 @@ mod tests {
 
         // Create ClientHelloData
         let client_key = [42u8; 32];
-        let protocol_version = 1u8;
         let salt = [99u8; 32];
         let hello_data = ClientHelloData {
             client_lp_public_key: client_key,
-            protocol_version,
             salt,
         };
 
         // Create a ClientHello message packet
         let packet = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42,
                 counter: 123,
             },
@@ -421,7 +423,6 @@ mod tests {
         match decoded.message {
             LpMessage::ClientHello(decoded_data) => {
                 assert_eq!(decoded_data.client_lp_public_key, client_key);
-                assert_eq!(decoded_data.protocol_version, protocol_version);
                 assert_eq!(decoded_data.salt, salt);
             }
             _ => panic!("Expected ClientHello message"),
@@ -437,12 +438,13 @@ mod tests {
 
         // Create ClientHelloData with fresh salt
         let client_key = [7u8; 32];
-        let hello_data = ClientHelloData::new_with_fresh_salt(client_key, 1);
+        let hello_data = ClientHelloData::new_with_fresh_salt(client_key);
 
         // Create a ClientHello message packet
         let packet = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 100,
                 counter: 200,
             },
@@ -460,7 +462,6 @@ mod tests {
         match decoded.message {
             LpMessage::ClientHello(decoded_data) => {
                 assert_eq!(decoded_data.client_lp_public_key, client_key);
-                assert_eq!(decoded_data.protocol_version, 1);
                 assert_eq!(decoded_data.salt, hello_data.salt);
 
                 // Verify timestamp can be extracted
@@ -531,13 +532,13 @@ mod tests {
 
             let hello_data = ClientHelloData {
                 client_lp_public_key: [version; 32],
-                protocol_version: version,
                 salt: [version.wrapping_add(1); 32],
             };
 
             let packet = LpPacket {
                 header: LpHeader {
                     protocol_version: 1,
+                    reserved: 0,
                     session_id: version as u32,
                     counter: version as u64,
                 },
@@ -550,7 +551,6 @@ mod tests {
 
             match decoded.message {
                 LpMessage::ClientHello(decoded_data) => {
-                    assert_eq!(decoded_data.protocol_version, version);
                     assert_eq!(decoded_data.client_lp_public_key, [version; 32]);
                 }
                 _ => panic!("Expected ClientHello message for version {}", version),

common/nym-lp/src/lib.rs

@@ -124,6 +124,7 @@ mod tests {
         let packet1 = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42, // Matches session's sending_index assumption for this test
                 counter: 0,
             },
@@ -152,6 +153,7 @@ mod tests {
         let packet2 = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42,
                 counter: 0, // Same counter as before (replay)
             },
@@ -181,6 +183,7 @@ mod tests {
         let packet3 = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: 42,
                 counter: 1, // Incremented counter
             },
@@ -241,6 +244,7 @@ mod tests {
         let packet1 = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: lp_id,
                 counter: 0,
             },
@@ -273,6 +277,7 @@ mod tests {
         let packet2 = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: lp_id,
                 counter: 1,
             },
@@ -300,6 +305,7 @@ mod tests {
         let packet3 = LpPacket {
             header: LpHeader {
                 protocol_version: 1,
+                reserved: 0,
                 session_id: lp_id,
                 counter: 0, // Replay of first packet
             },

common/nym-lp/src/message.rs

@@ -10,8 +10,6 @@ use serde::{Deserialize, Serialize};
 pub struct ClientHelloData {
     /// Client's LP x25519 public key (32 bytes)
     pub client_lp_public_key: [u8; 32],
-    /// Protocol version for future compatibility
-    pub protocol_version: u8,
     /// Salt for PSK derivation (32 bytes: 8-byte timestamp + 24-byte nonce)
     pub salt: [u8; 32],
 }
@@ -24,7 +22,7 @@ impl ClientHelloData {
     /// # Arguments
     /// * `client_lp_public_key` - Client's x25519 public key
     /// * `protocol_version` - Protocol version number
-    pub fn new_with_fresh_salt(client_lp_public_key: [u8; 32], protocol_version: u8) -> Self {
+    pub fn new_with_fresh_salt(client_lp_public_key: [u8; 32]) -> Self {
         use std::time::{SystemTime, UNIX_EPOCH};
 
         // Generate salt: timestamp + nonce
@@ -43,7 +41,6 @@ impl ClientHelloData {
 
         Self {
             client_lp_public_key,
-            protocol_version,
             salt,
         }
     }
@@ -89,11 +86,17 @@ impl MessageType {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HandshakeData(pub Vec<u8>);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EncryptedDataPayload(pub Vec<u8>);
+
 #[derive(Debug, Clone)]
 pub enum LpMessage {
     Busy,
-    Handshake(Vec<u8>),
-    EncryptedData(Vec<u8>),
+    Handshake(HandshakeData),
+    EncryptedData(EncryptedDataPayload),
     ClientHello(ClientHelloData),
 }
 
@@ -112,26 +115,26 @@ impl LpMessage {
     pub fn payload(&self) -> &[u8] {
         match self {
             LpMessage::Busy => &[],
-            LpMessage::Handshake(payload) => payload,
-            LpMessage::EncryptedData(payload) => payload,
-            LpMessage::ClientHello(_) => &[], // Structured data, serialized in encode_content
+            LpMessage::Handshake(payload) => payload.0.as_slice(),
+            LpMessage::EncryptedData(payload) => payload.0.as_slice(),
+            LpMessage::ClientHello(_) => unimplemented!(), // Structured data, serialized in encode_content
         }
     }
 
     pub fn is_empty(&self) -> bool {
         match self {
             LpMessage::Busy => true,
-            LpMessage::Handshake(payload) => payload.is_empty(),
-            LpMessage::EncryptedData(payload) => payload.is_empty(),
+            LpMessage::Handshake(payload) => payload.0.is_empty(),
+            LpMessage::EncryptedData(payload) => payload.0.is_empty(),
             LpMessage::ClientHello(_) => false, // Always has data
         }
     }
 
     pub fn len(&self) -> usize {
         match self {
             LpMessage::Busy => 0,
-            LpMessage::Handshake(payload) => payload.len(),
-            LpMessage::EncryptedData(payload) => payload.len(),
+            LpMessage::Handshake(payload) => payload.0.len(),
+            LpMessage::EncryptedData(payload) => payload.0.len(),
             LpMessage::ClientHello(_) => 65, // 32 bytes key + 1 byte version + 32 bytes salt
         }
     }
@@ -149,10 +152,10 @@ impl LpMessage {
         match self {
             LpMessage::Busy => { /* No content */ }
             LpMessage::Handshake(payload) => {
-                dst.put_slice(payload);
+                dst.put_slice(&payload.0);
             }
             LpMessage::EncryptedData(payload) => {
-                dst.put_slice(payload);
+                dst.put_slice(&payload.0);
             }
             LpMessage::ClientHello(data) => {
                 // Serialize ClientHelloData using bincode
@@ -172,10 +175,11 @@ mod tests {
 
     #[test]
     fn encoding() {
-        let message = LpMessage::EncryptedData(vec![11u8; 124]);
+        let message = LpMessage::EncryptedData(EncryptedDataPayload(vec![11u8; 124]));
 
         let resp_header = LpHeader {
             protocol_version: 1,
+            reserved: 0,
             session_id: 0,
             counter: 0,
         };
@@ -195,7 +199,7 @@ mod tests {
         // Verify correct data in message
         match &packet.message {
             LpMessage::EncryptedData(data) => {
-                assert_eq!(*data, vec![11u8; 124]);
+                assert_eq!(*data, EncryptedDataPayload(vec![11u8; 124]));
             }
             _ => panic!("Wrong message type"),
         }
@@ -204,8 +208,8 @@ mod tests {
     #[test]
     fn test_client_hello_salt_generation() {
         let client_key = [1u8; 32];
-        let hello1 = ClientHelloData::new_with_fresh_salt(client_key, 1);
-        let hello2 = ClientHelloData::new_with_fresh_salt(client_key, 1);
+        let hello1 = ClientHelloData::new_with_fresh_salt(client_key);
+        let hello2 = ClientHelloData::new_with_fresh_salt(client_key);
 
         // Different salts should be generated
         assert_ne!(hello1.salt, hello2.salt);
@@ -219,7 +223,7 @@ mod tests {
     #[test]
     fn test_client_hello_timestamp_extraction() {
         let client_key = [2u8; 32];
-        let hello = ClientHelloData::new_with_fresh_salt(client_key, 1);
+        let hello = ClientHelloData::new_with_fresh_salt(client_key);
 
         let timestamp = hello.extract_timestamp();
         let now = std::time::SystemTime::now()
@@ -234,7 +238,7 @@ mod tests {
     #[test]
     fn test_client_hello_salt_format() {
         let client_key = [3u8; 32];
-        let hello = ClientHelloData::new_with_fresh_salt(client_key, 1);
+        let hello = ClientHelloData::new_with_fresh_salt(client_key);
 
         // First 8 bytes should be non-zero timestamp
         let timestamp_bytes = &hello.salt[..8];

common/nym-lp/src/packet.rs

@@ -126,7 +126,7 @@ impl LpPacket {
 #[derive(Debug, Clone)]
 pub struct LpHeader {
     pub protocol_version: u8,
-
+    pub reserved: u16,
     pub session_id: u32,
     pub counter: u64,
 }
@@ -139,6 +139,7 @@ impl LpHeader {
     pub fn new(session_id: u32, counter: u64) -> Self {
         Self {
             protocol_version: 1,
+            reserved: 0,
             session_id,
             counter,
         }
@@ -176,6 +177,7 @@ impl LpHeader {
 
         Ok(LpHeader {
             protocol_version,
+            reserved: 0,
             session_id,
             counter,
         })