wip structures and message signature

client-network/src/messages_structure.rs

@@ -1,50 +1,130 @@
-struct UDPMessage {
-    id: [u8; 4],
+pub struct UDPMessage {
+    id: u32,
     msg_type: u8,
-    length: [u8; 2],
+    length: u16,
     body: [u8; 985],
     signature: [u8; 32],
 }
 
-struct HandshakeMessage {
-    id: [u8; 4],
+pub struct HandshakeMessage {
+    id: u32,
     msg_type: u8,
-    length: [u8; 2],
-    extensions: [u8; 4],
+    length: u16,
+    extensions: u32,
     name: [u8; 981],
     signature: [u8; 32],
 }
 
 impl UDPMessage {
-    pub fn ping(id: i32) -> UDPMessage {
-        UDPMessage { id: id.to_ne_bytes(), msg_type: 0, length: [0; 2], body: [0; 985], signature: [0; 32]}
+    pub fn ping(id: u32) -> UDPMessage {
+        UDPMessage { id: id, msg_type: 0, length: 0, body: [0; 985], signature: [0; 32]}
     }
 
-    pub fn error(id: i32) -> UDPMessage {
+    pub fn error(id: u32) -> UDPMessage {
         
-        UDPMessage { id: id.to_ne_bytes(), msg_type: 129, length: [0; 2], body: [0; 985], signature: [0; 32]}
-    }
-    
-    pub fn hello(id: i32, length: i16, username: String) -> HandshakeMessage {
-        let username_bytes = username.as_bytes();
-    
-        let mut body: [u8; 981] = [0; 981];
-    
-        let length_to_copy = username_bytes.len().min(981);
-        body[..length_to_copy].copy_from_slice(&username_bytes[..length_to_copy]);
-        HandshakeMessage {id: id.to_ne_bytes(), msg_type: 1, length: length.to_ne_bytes(), extensions: [0;4], name: body, signature: [0;32]}
-
-    }
-
-    pub fn helloReply(id: i32, length: i16, username: String) -> HandshakeMessage {
-        let username_bytes = username.as_bytes();
-    
-        let mut body: [u8; 981] = [0; 981];
-    
-        let length_to_copy = username_bytes.len().min(981);
-        body[..length_to_copy].copy_from_slice(&username_bytes[..length_to_copy]);
-        HandshakeMessage {id: id.to_ne_bytes(), msg_type: 130, length: length.to_ne_bytes(), extensions: [0;4], name: body, signature: [0;32]}
-
+        UDPMessage { id: id, msg_type: 129, length: 0, body: [0; 985], signature: [0; 32]}
     }
 }
 
+impl HandshakeMessage {
+    pub fn display(&self) {
+        println!("ID: {:?}", self.id);
+        println!("Message Type: {}", self.msg_type);
+        println!("Length: {:?}", self.length);
+        println!("extensions: {:?}", self.extensions);
+        let good_length = usize::min(self.length as usize, 981);
+        println!("name: {:?}", &self.name[..good_length]);
+        println!("Signature: {:?}", self.signature);
+    }
+    pub fn hello(id: u32, length: u16, username: String) -> HandshakeMessage {
+        let username_bytes = username.as_bytes();
+    
+        let mut name: [u8; 981] = [0; 981];
+    
+        let length_to_copy = username_bytes.len().min(981);
+        name[..length_to_copy].copy_from_slice(&username_bytes[..length_to_copy]);
+        HandshakeMessage {id: id, msg_type: 1, length: length, extensions: 0, name: name, signature: [0;32]}
+
+    }
+
+    pub fn helloReply(id: u32, length: u16, username: String) -> HandshakeMessage {
+        let username_bytes = username.as_bytes();
+    
+        let mut name: [u8; 981] = [0; 981];
+    
+        let length_to_copy = username_bytes.len().min(981);
+        name[..length_to_copy].copy_from_slice(&username_bytes[..length_to_copy]);
+        HandshakeMessage {id: id, msg_type: 130, length: length, extensions: 0, name: name, signature: [0;32]}
+
+    }
+
+    pub fn serialize(&self) -> [u8; 1024] {
+        let mut buffer = [0u8; 1024];
+    let mut offset = 0;
+
+    buffer[offset..offset + 4].copy_from_slice(&self.id.to_be_bytes());
+    offset += 4;
+
+    buffer[offset] = self.msg_type;
+    offset += 1;
+
+    buffer[offset..offset + 2].copy_from_slice(&self.length.to_be_bytes());
+    offset += 2;
+
+    buffer[offset..offset + 4].copy_from_slice(&self.extensions.to_be_bytes());
+    offset += 4;
+
+    buffer[offset..offset + 981].copy_from_slice(&self.name);
+    offset += 981;
+
+    buffer[offset..offset + 32].copy_from_slice(&self.signature);
+    
+    buffer
+    }
+
+    pub fn parse(received_message: [u8; 1024]) -> HandshakeMessage {
+        let id_bytes: [u8; 4] = received_message[0..4].try_into().expect("Taille incorrecte");
+        let length_bytes: [u8; 2] = received_message[5..7].try_into().expect("Taille incorrecte");
+        let extensions_bytes: [u8; 4] = received_message[7..11].try_into().expect("Taille incorrecte");
+        let name_bytes: [u8; 981] = received_message[11..992].try_into().expect("Taille incorrecte");
+        let signature_bytes: [u8; 32] = received_message[992..1024].try_into().expect("Taille incorrecte");
+        HandshakeMessage {
+            id: u32::from_be_bytes(id_bytes),
+            msg_type: received_message[4],
+            length: u16::from_be_bytes(length_bytes),
+            extensions: u32::from_be_bytes(extensions_bytes),
+            name: name_bytes,
+            signature: signature_bytes,
+        }
+    }
+}
+
+fn convert_to_u16(bytes: [u8; 2]) -> u16 {
+    ((bytes[0] as u16) << 8) | (bytes[1] as u16)
+}
+
+
+
+#[cfg(test)]
+mod tests {
+    // Note this useful idiom: importing names from outer (for mod tests) scope.
+    use super::*;
+
+    /*#[tokio::test]
+    async fn creating_cryptographic_signature() {
+        let username = String::from("charlie_kirk");
+        let handshake = HandshakeMessage::hello(0, 12, username);
+        handshake.display();
+    }*/
+    
+    /*#[tokio::test]
+    async fn parse_handshakemessage() {
+        let username = String::from("charlie_kirk");
+        let handshake = HandshakeMessage::hello(0, 12, username);
+        let ser = handshake.serialize();
+        let parsed = HandshakeMessage::parse(ser);
+        handshake.display();
+        parsed.display();
+    }*/
+}
+