signature verification

client-network/src/message_handling.rs

@@ -1,5 +1,7 @@
 use crate::{
-    cryptographic_signature::{CryptographicSignature, sign_message},
+    cryptographic_signature::{
+        CryptographicSignature, get_peer_key, sign_message, verify_signature,
+    },
     messages_channels::MultipleSenders,
     messages_structure::HandshakeMessage,
     registration,
@@ -58,34 +60,49 @@ pub fn handle_recevied_message(
     match eventtype {
         Some(EventType::ServerHelloReply) => {
             /*registration::register_ip_addresses(
-                crypto_pair,
-                socket_addr.to_string(),
-                senders,
-                &messages_list, // Pass the mutable reference inside the lock
-                546,
-            );*/
+                 crypto_pair,
+                 socket_addr.to_string(),
+                 senders,
+                 &messages_list, // Pass the mutable reference inside the lock
+            546,
+             );*/
         }
         Some(_) => print!("Not implemented"),
         None => {
             let message_type = recevied_message[4];
             if message_type == 1 {
-                let username_size = crypto_pair.username.len();
-                let hello_handshake = HandshakeMessage::helloReply(
-                    id as u32,
-                    username_size as u16 + 4,
-                    crypto_pair.username.clone(),
-                );
-                //HandshakeMessage::display(&hello_handshake);
-                let hello_handshake_serialized = hello_handshake.serialize();
-                let message_signed = sign_message(crypto_pair, &hello_handshake_serialized);
-                senders.send_via(0, message_signed, socket_addr.to_string());
-                let mut list = messages_list.lock().expect("Failed to lock messages_list");
-                match list.get(&id) {
-                    Some(_) => {
-                        list.remove(&id);
-                    }
-                    None => {
-                        list.insert(id, EventType::ServerHelloReply);
+                println!("verify the signature");
+                let parsed_received_message = HandshakeMessage::parse(recevied_message.to_vec());
+                let received_name = String::from_utf8(parsed_received_message.name).expect("error");
+                let peer_pubkey = tokio::runtime::Runtime::new()
+                    .unwrap()
+                    .block_on(get_peer_key(&received_name))
+                    .expect("failed to retrieve public key");
+
+                if !verify_signature(peer_pubkey, recevied_message) {
+                    println!(
+                        "incorrect signature from given peer: {}, ignoring message {}",
+                        &received_name, id
+                    );
+                } else {
+                    let username_size = crypto_pair.username.len();
+                    let hello_handshake = HandshakeMessage::helloReply(
+                        id as u32,
+                        username_size as u16 + 4,
+                        crypto_pair.username.clone(),
+                    );
+                    //HandshakeMessage::display(&hello_handshake);
+                    let hello_handshake_serialized = hello_handshake.serialize();
+                    let message_signed = sign_message(crypto_pair, &hello_handshake_serialized);
+                    senders.send_via(0, message_signed, socket_addr.to_string());
+                    let mut list = messages_list.lock().expect("Failed to lock messages_list");
+                    match list.get(&id) {
+                        Some(_) => {
+                            list.remove(&id);
+                        }
+                        None => {
+                            list.insert(id, EventType::ServerHelloReply);
+                        }
                     }
                 }
             }