From dc1767abe4cd909dca6639d3412d139fbce63d19 Mon Sep 17 00:00:00 2001 From: wikano Date: Wed, 7 Jan 2026 23:34:44 +0100 Subject: [PATCH 1/5] messages rewrite --- client-network/src/datum_parsing.rs | 1 + client-network/src/lib.rs | 1 + client-network/src/message_handling.rs | 211 ++++++++++++++++++++--- client-network/src/messages_structure.rs | 58 +++++++ todo.md | 43 +++-- 5 files changed, 276 insertions(+), 38 deletions(-) create mode 100644 client-network/src/datum_parsing.rs diff --git a/client-network/src/datum_parsing.rs b/client-network/src/datum_parsing.rs new file mode 100644 index 0000000..0ed934a --- /dev/null +++ b/client-network/src/datum_parsing.rs @@ -0,0 +1 @@ +fn parse_received_datum(recevied_datum: Vec) {} diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index e5ef93e..86ce7cf 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -1,5 +1,6 @@ mod cryptographic_signature; mod data; +mod datum_parsing; mod message_handling; mod messages_channels; mod messages_structure; diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index dd651f9..79427cc 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -16,29 +16,24 @@ pub enum EventType { PeerHello, } -/*pub fn handle_recevied_message( - messages_list: &mut HashMap, - recevied_message: &Vec, - crypto_pair: &CryptographicSignature, - socket_addr: &SocketAddr, - senders: &MultipleSenders, -) { - let message_id: [u8; 4] = recevied_message[0..4].try_into().expect("size error"); - let id = i32::from_be_bytes(message_id); - let eventtype = messages_list.get(&id); - match eventtype { - Some(EventType::ServerHelloReply) => { - registration::register_ip_addresses( - &crypto_pair, - socket_addr.ip().to_string(), - &senders, - messages_list, - ); - } - Some(_) => print!("Not implemented"), - None => print!("Message not found"), - } -}*/ +const ID: usize = 4; +const TYPE: usize = 5; +const LENGTH: usize = 7; +const EXTENSIONS: usize = 32; +const SIGNATURE: usize = 64; + +const PING: u8 = 0; +const OK: u8 = 128; +const ERROR: u8 = 129; +const HELLO: u8 = 1; +const HELLOREPLY: u8 = 130; +const ROOTREQUEST: u8 = 2; +const ROOTREPLY: u8 = 131; +const DATUMREQUEST: u8 = 3; +const NODATUM: u8 = 133; +const DATUM: u8 = 132; +const NATTRAVERSALREQUEST: u8 = 4; +const NATTRAVERSALREQUEST2: u8 = 5; pub fn handle_recevied_message( messages_list: &Arc>>, @@ -120,3 +115,173 @@ pub fn handle_recevied_message( } } } + +pub fn ping(received_message: Vec, socket_addr: String) {} + +pub fn ok(received_message: Vec, socket_addr: String) {} + +pub fn error(received_message: Vec, socket_addr: String) {} + +pub fn hello(received_message: Vec, socket_addr: String) {} + +pub fn hello_reply(received_message: Vec, socket_addr: String) {} + +pub fn root_request(received_message: Vec, socket_addr: String) {} + +pub fn root_reply(received_message: Vec, socket_addr: String) {} + +pub fn datum_request(received_message: Vec, socket_addr: String) {} + +pub fn no_datum(received_message: Vec, socket_addr: String) {} + +pub fn datum(received_message: Vec, socket_addr: String) {} + +pub fn parse_message( + received_message: Vec, + received_name: String, + id: i32, + username: String, +) -> Option> { + let id_bytes: [u8; 4] = received_message[0..ID] + .try_into() + .expect("Taille incorrecte"); + + let msgtype = received_message[ID]; + + let length_bytes: [u8; 2] = received_message[TYPE..LENGTH] + .try_into() + .expect("Taille incorrecte"); + + let msg_length = u16::from_be_bytes(length_bytes) as usize; + + // verify signature + match msgtype { + HELLO | HELLOREPLY | ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => { + let peer_pubkey = tokio::runtime::Runtime::new() + .unwrap() + .block_on(get_peer_key(&received_name)) + .expect("failed to retrieve public key"); + + let signature: [u8; SIGNATURE] = received_message + [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE] + .try_into() + .expect("Taille incorrecte"); + if !verify_signature(peer_pubkey, &received_message) { + println!( + "incorrect signature from given peer: {}, ignoring message of type {} with id {}", + &received_name, received_message[ID], id + ); + return None; + } + } + _ => {} + } + match msgtype { + // PING + // + // envoie un OK + // + // OK + // + // si NATTRAVERSALREQUEST alors + // + // ERROR + // + // affiche un msg d'erreur + // + // HELLO + // + // envoie une hello reply + // + HELLO => { + let username_size = username.len(); + let hello_handshake = + HandshakeMessage::helloReply(id as u32, username_size as u16 + 4, username.clone()); + //HandshakeMessage::display(&hello_handshake); + let hello_handshake_serialized = hello_handshake.serialize(); + return Some(hello_handshake_serialized); + } + // HELLOREPLY + // + // envoie un root request + // + // ROOTREQUEST + // + // envoie un root reply + // + // ROOTREPLY + // + // envoie un datum request + // + // DATUMREQUEST + // + // envoie le datum + // + // NODATUM + // + // affiche un msg d'erreur + // + // DATUM + // + // parcourt le directory recu ou le big directory et renvoie une DATUMREQUEST pour chaque + // directory ou big directory lu + // + // NATTRAVERSALREQUEST + // + // repond OK et envoie un NATTRAVERSALREQUEST2 au pair B + // + // NATTRAVERSALREQUEST2 + // + // envoie OK à S puis envoie un ping à S + + // PING + // + // envoie un OK + // + // OK + // + // si NATTRAVERSALREQUEST alors + // + // ERROR + // + // affiche un msg d'erreur + // + // HELLO + // + // envoie une hello reply + // + // HELLOREPLY + // + // envoie un root request + // + // ROOTREQUEST + // + // envoie un root reply + // + // ROOTREPLY + // + // envoie un datum request + // + // DATUMREQUEST + // + // envoie le datum + // + // NODATUM + // + // affiche un msg d'erreur + // + // DATUM + // + // parcourt le directory recu ou le big directory et renvoie une DATUMREQUEST pour chaque + // directory ou big directory lu + // + // NATTRAVERSALREQUEST + // + // repond OK et envoie un NATTRAVERSALREQUEST2 au pair B + // + // NATTRAVERSALREQUEST2 + // + // envoie OK à S puis envoie un ping à S + _ => return None, + } +} diff --git a/client-network/src/messages_structure.rs b/client-network/src/messages_structure.rs index 94c7a16..2609ea3 100644 --- a/client-network/src/messages_structure.rs +++ b/client-network/src/messages_structure.rs @@ -1,3 +1,45 @@ +use crate::server_communication::generate_id; + +const ID: usize = 4; +const TYPE: usize = 5; +const LENGTH: usize = 7; +const EXTENSIONS: usize = 32; +const SIGNATURE: usize = 64; + +const PING: u8 = 0; +const OK: u8 = 128; +const ERROR: u8 = 129; +const HELLO: u8 = 1; +const HELLOREPLY: u8 = 130; +const ROOTREQUEST: u8 = 2; +const ROOTREPLY: u8 = 131; +const DATUMREQUEST: u8 = 3; +const NODATUM: u8 = 133; +const DATUM: u8 = 132; +const NATTRAVERSALREQUEST: u8 = 4; +const NATTRAVERSALREQUEST2: u8 = 5; + +pub fn constructMessage(msgtype: u8, payload: Vec, id: &[u8]) { + match msgtype { + HELLO => { + let message: Vec = vec![0u8; LENGTH + EXTENSIONS + payload.len() + SIGNATURE]; + + message.extend_from_slice(id); + message.extend_from_slice(0); + + let name_vec = username.trim_end_matches(char::from(0)).as_bytes().to_vec(); + HandshakeMessage { + id: id, + msg_type: 1, + length: length, + extensions: 0, + name: name_vec, + signature: vec![0; 64], + } + } + } +} + pub struct UDPMessage { id: u32, msg_type: u8, @@ -15,6 +57,22 @@ pub struct HandshakeMessage { pub signature: Vec, } +pub struct DatumRootRequest { + pub id: u32, + msg_type: u8, + length: u16, + hash: Vec, +} + +pub struct DatumReply { + pub id: u32, + msg_type: u8, + length: u16, + hash: Vec, + value: Vec, + signature: Vec, +} + impl UDPMessage { pub fn ping(id: u32) -> UDPMessage { UDPMessage { diff --git a/todo.md b/todo.md index d978db1..3931686 100644 --- a/todo.md +++ b/todo.md @@ -1,16 +1,9 @@ # Todo : -## peer discovery -- get rsquest to the uri /peers/ -## registration with the server -- generation of the cryptographic key OK -- put request to the uri (check if the peer is already connected) OK -- udp handshakes OK -- get request to the uri /peers/key to get the public key of a peer OK -- get request to the uri /peers/key/addresses OK + +## peer discovery ## handshake -- handshake structure OK - 5min timeout after handshake - matain connection every 4 min @@ -22,14 +15,34 @@ - setting in gui to act as a relay - chunk, directory, big, bigdirectory structures -fonctionnalités : +## fonctionnalités application : -s'enregistrer avec le serveur OK -rechercher un pair -generer une clé publique OK rechercher les fichiers d'un pair telechargement des fichiers choisir un dossier à partager -se deconnecter du réseau +choisir le nombre de canaux + +handshake server DOING +se deconnecter du réseau DOING + + +## autre : + +socket ipv6 + + +# FAIT : + +- choisir un pseudo OK +- get rsquest to the uri /peers/ OK +- generation of the cryptographic key OK +- put request to the uri (check if the peer is already connected) OK +- get request to the uri /peers/key to get the public key of a peer OK +- get request to the uri /peers/key/addresses OK +- udp handshakes OK +- handshake structure OK +- s'enregistrer avec le serveur OK +- generer une clé publique OK +- verifier signature OK +- 2 channels -> un pour envoyer et un pour recevoir OK -2 channels -> un pour envoyer et un pour recevoir OK -- 2.39.5 From cd2f87cb817279e482c5d7ffd53330718a237ae3 Mon Sep 17 00:00:00 2001 From: TIBERGHIEN corentin Date: Thu, 8 Jan 2026 19:12:07 +0100 Subject: [PATCH 2/5] wip --- README.md | Bin 54 -> 540 bytes client-gui/src/gui_app.rs | 11 +++++-- client-network/src/message_handling.rs | 5 +-- client-network/src/messages_structure.rs | 39 +++++++++++++---------- 4 files changed, 34 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index 840f9cf0d71540d9aed6e2648c548d885fa077e5..c85e147781f611e785cdd254d714c4ab11c08cd4 100644 GIT binary patch literal 540 zcmaix-Acni5QWdR;5)3nkQAg46qNq>7~X_Z(k9kG+Jv2)he|B<%-0} { - let str = format!("📡 {}", self.active_server); + let str = format!("📡"); ui.label(str); } } @@ -344,7 +344,14 @@ impl eframe::App for P2PClientApp { for peer in &self.known_peers { let is_active = self.active_peer.as_ref().map_or(false, |id| id == peer); // if peer.id == self.active_peer_id - let selectable = ui.selectable_label(is_active, format!("{}", peer)); + + let selectable; + if &self.active_server == peer { + selectable = + ui.selectable_label(is_active, format!("{} 📡 🌀", peer)) + } else { + selectable = ui.selectable_label(is_active, format!("{}", peer)); + } if selectable.clicked() { // switch to displaying this peer's tree self.active_peer = Some(peer.clone()); diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index 79427cc..8c3d430 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -4,7 +4,7 @@ use crate::{ CryptographicSignature, get_peer_key, sign_message, verify_signature, }, messages_channels::MultipleSenders, - messages_structure::HandshakeMessage, + messages_structure::{HandshakeMessage, constructMessage}, registration, }; use std::sync::{Arc, Mutex}; @@ -141,6 +141,7 @@ pub fn parse_message( received_name: String, id: i32, username: String, + crypto_pair: &CryptographicSignature ) -> Option> { let id_bytes: [u8; 4] = received_message[0..ID] .try_into() @@ -161,7 +162,6 @@ pub fn parse_message( .unwrap() .block_on(get_peer_key(&received_name)) .expect("failed to retrieve public key"); - let signature: [u8; SIGNATURE] = received_message [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE] .try_into() @@ -195,6 +195,7 @@ pub fn parse_message( // HELLO => { let username_size = username.len(); + let helloreply = constructMessage(msgtype, payload, &id, crypto_pair) let hello_handshake = HandshakeMessage::helloReply(id as u32, username_size as u16 + 4, username.clone()); //HandshakeMessage::display(&hello_handshake); diff --git a/client-network/src/messages_structure.rs b/client-network/src/messages_structure.rs index 2609ea3..f62a2da 100644 --- a/client-network/src/messages_structure.rs +++ b/client-network/src/messages_structure.rs @@ -1,4 +1,7 @@ -use crate::server_communication::generate_id; +use crate::{ + cryptographic_signature::{CryptographicSignature, sign_message}, + server_communication::generate_id, +}; const ID: usize = 4; const TYPE: usize = 5; @@ -19,25 +22,27 @@ const DATUM: u8 = 132; const NATTRAVERSALREQUEST: u8 = 4; const NATTRAVERSALREQUEST2: u8 = 5; -pub fn constructMessage(msgtype: u8, payload: Vec, id: &[u8]) { +pub fn constructMessage( + msgtype: u8, + payload: Vec, + id: i32, + crypto_pair: &CryptographicSignature, +) -> Option> { + let mut message = Vec::new(); + + message.extend_from_slice(&id); + message.push(msgtype); + match msgtype { - HELLO => { - let message: Vec = vec![0u8; LENGTH + EXTENSIONS + payload.len() + SIGNATURE]; - - message.extend_from_slice(id); - message.extend_from_slice(0); - - let name_vec = username.trim_end_matches(char::from(0)).as_bytes().to_vec(); - HandshakeMessage { - id: id, - msg_type: 1, - length: length, - extensions: 0, - name: name_vec, - signature: vec![0; 64], - } + HELLO | HELLOREPLY => { + message.extend_from_slice(&payload); + let signature = sign_message(crypto_pair, &message); + message.extend_from_slice(&signature); + return Some(message); } + _ => {} } + None } pub struct UDPMessage { -- 2.39.5 From 9fc33804d03618cd5134682308d5c2c7f8b24d14 Mon Sep 17 00:00:00 2001 From: wikano Date: Fri, 9 Jan 2026 01:03:40 +0100 Subject: [PATCH 3/5] manage handshake wiip --- client-network/src/cryptographic_signature.rs | 8 +- client-network/src/lib.rs | 1 + client-network/src/message_handling.rs | 63 +++-- client-network/src/messages_structure.rs | 215 ++---------------- client-network/src/peers_refresh.rs | 68 ++++++ client-network/src/registration.rs | 2 +- 6 files changed, 145 insertions(+), 212 deletions(-) create mode 100644 client-network/src/peers_refresh.rs diff --git a/client-network/src/cryptographic_signature.rs b/client-network/src/cryptographic_signature.rs index 8a857ed..e278ca1 100644 --- a/client-network/src/cryptographic_signature.rs +++ b/client-network/src/cryptographic_signature.rs @@ -1,6 +1,5 @@ use std::io::Read; -use crate::messages_structure::HandshakeMessage; use bytes::Bytes; use p256::EncodedPoint; use p256::ecdsa::{ @@ -148,10 +147,7 @@ mod tests { println!("pubkey : {}", formatted_pubkey); } - /// - /// signs a message - /// - #[test] + /*#[test] fn signing_message() { let username = String::from("gamixtreize"); let crypto_pair = CryptographicSignature::new(username.clone()); @@ -160,5 +156,5 @@ mod tests { let signed_message = sign_message(&crypto_pair, &ser); println!("unsigned_message: {:?}", ser); println!("signed_message: {:?}", signed_message); - } + }*/ } diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index 86ce7cf..ccdd77a 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -4,6 +4,7 @@ mod datum_parsing; mod message_handling; mod messages_channels; mod messages_structure; +mod peers_refresh; mod registration; mod server_communication; diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index 8c3d430..50e11ca 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -4,7 +4,7 @@ use crate::{ CryptographicSignature, get_peer_key, sign_message, verify_signature, }, messages_channels::MultipleSenders, - messages_structure::{HandshakeMessage, constructMessage}, + messages_structure::construct_message, registration, }; use std::sync::{Arc, Mutex}; @@ -19,7 +19,7 @@ pub enum EventType { const ID: usize = 4; const TYPE: usize = 5; const LENGTH: usize = 7; -const EXTENSIONS: usize = 32; +const EXTENSIONS: usize = 4; const SIGNATURE: usize = 64; const PING: u8 = 0; @@ -50,8 +50,11 @@ pub fn handle_recevied_message( let message_id: [u8; 4] = recevied_message[0..4].try_into().expect("size error"); let id = i32::from_be_bytes(message_id); + parse_message(recevied_message, received_name, id, crypto_pair, cmd_tx) + //TODO + // Lock the mutex to access the HashMap - let list = messages_list.lock().unwrap(); + /*let list = messages_list.lock().unwrap(); let eventtype = list.get(&id); // Clone the enum so we can release the lock if needed match eventtype { @@ -113,7 +116,7 @@ pub fn handle_recevied_message( } print!("Message not found for ID: {}", id) } - } + }*/ } pub fn ping(received_message: Vec, socket_addr: String) {} @@ -140,9 +143,11 @@ pub fn parse_message( received_message: Vec, received_name: String, id: i32, - username: String, - crypto_pair: &CryptographicSignature + crypto_pair: &CryptographicSignature, + cmd_tx: crossbeam_channel::Sender, ) -> Option> { + let cmd_tx_clone = cmd_tx.clone(); + let id_bytes: [u8; 4] = received_message[0..ID] .try_into() .expect("Taille incorrecte"); @@ -176,35 +181,62 @@ pub fn parse_message( } _ => {} } + + // Message handling + let mut constructed_message: Option> = None; match msgtype { // PING // // envoie un OK + PING => { + constructed_message = construct_message(OK, Vec::new(), id, crypto_pair); + } // // OK // + // rien ? // si NATTRAVERSALREQUEST alors // // ERROR // // affiche un msg d'erreur - // + ERROR => { + if let Ok(err_received) = + String::from_utf8(received_message[LENGTH..(msg_length + LENGTH)].to_vec()) + { + let err_msg = format!( + "Error received from peer {} : {}", + String::from(received_name), + err_received + ); + let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg)); + } else { + let err_msg = format!( + "Error received from peer {} : N/A", + String::from(received_name), + ); + let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg)); + } + } // HELLO // // envoie une hello reply // HELLO => { - let username_size = username.len(); - let helloreply = constructMessage(msgtype, payload, &id, crypto_pair) - let hello_handshake = - HandshakeMessage::helloReply(id as u32, username_size as u16 + 4, username.clone()); - //HandshakeMessage::display(&hello_handshake); - let hello_handshake_serialized = hello_handshake.serialize(); - return Some(hello_handshake_serialized); + let mut payload = Vec::new(); + + payload.extend_from_slice(&0u32.to_be_bytes()); + payload.extend_from_slice(&crypto_pair.username.clone().as_bytes()); + + let helloreply = construct_message(HELLOREPLY, payload, id, crypto_pair); + + return helloreply; } // HELLOREPLY // - // envoie un root request + // + // ajoute a la liste des peers handshake + HELLOREPLY => {} // // ROOTREQUEST // @@ -285,4 +317,5 @@ pub fn parse_message( // envoie OK à S puis envoie un ping à S _ => return None, } + constructed_message } diff --git a/client-network/src/messages_structure.rs b/client-network/src/messages_structure.rs index f62a2da..b0cac34 100644 --- a/client-network/src/messages_structure.rs +++ b/client-network/src/messages_structure.rs @@ -6,7 +6,7 @@ use crate::{ const ID: usize = 4; const TYPE: usize = 5; const LENGTH: usize = 7; -const EXTENSIONS: usize = 32; +const EXTENSIONS: usize = 4; const SIGNATURE: usize = 64; const PING: u8 = 0; @@ -22,7 +22,7 @@ const DATUM: u8 = 132; const NATTRAVERSALREQUEST: u8 = 4; const NATTRAVERSALREQUEST2: u8 = 5; -pub fn constructMessage( +pub fn construct_message( msgtype: u8, payload: Vec, id: i32, @@ -30,204 +30,39 @@ pub fn constructMessage( ) -> Option> { let mut message = Vec::new(); - message.extend_from_slice(&id); + // ID + // type + message.extend_from_slice(&id.to_be_bytes()); + message.push(msgtype); match msgtype { HELLO | HELLOREPLY => { + // length + message.extend_from_slice(&(EXTENSIONS + payload.len()).to_be_bytes()); message.extend_from_slice(&payload); let signature = sign_message(crypto_pair, &message); message.extend_from_slice(&signature); return Some(message); } + PING | OK => { + message.extend_from_slice(&0u16.to_be_bytes()); + return Some(message); + } + ERROR | ROOTREQUEST | DATUMREQUEST => { + message.extend_from_slice(&payload.len().to_be_bytes()); + message.extend_from_slice(&payload); + return Some(message); + } + ROOTREPLY | NODATUM | DATUM | NATTRAVERSALREQUEST => { + message.extend_from_slice(&payload.len().to_be_bytes()); + message.extend_from_slice(&payload); + let signature = sign_message(crypto_pair, &message); + message.extend_from_slice(&signature); + return Some(message); + } + _ => {} } None } - -pub struct UDPMessage { - id: u32, - msg_type: u8, - length: u16, - body: Vec, - signature: Vec, -} - -pub struct HandshakeMessage { - pub id: u32, - msg_type: u8, - length: u16, - extensions: u32, - pub name: Vec, - pub signature: Vec, -} - -pub struct DatumRootRequest { - pub id: u32, - msg_type: u8, - length: u16, - hash: Vec, -} - -pub struct DatumReply { - pub id: u32, - msg_type: u8, - length: u16, - hash: Vec, - value: Vec, - signature: Vec, -} - -impl UDPMessage { - pub fn ping(id: u32) -> UDPMessage { - UDPMessage { - id: id, - msg_type: 0, - length: 0, - body: vec![0; 985], - signature: vec![0; 32], - } - } - - pub fn error(id: u32) -> UDPMessage { - UDPMessage { - id: id, - msg_type: 129, - length: 0, - body: vec![0; 985], - signature: vec![0; 32], - } - } - - pub fn parse(received_message: Vec) -> UDPMessage { - 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 msg_length = u16::from_be_bytes(length_bytes); - let name_bytes = &received_message[7..msg_length as usize + 8]; - let signature_bytes = - &received_message[msg_length as usize + 8..msg_length as usize + 9 + 32]; - UDPMessage { - id: u32::from_be_bytes(id_bytes), - msg_type: received_message[4], - length: u16::from_be_bytes(length_bytes), - body: name_bytes.to_vec(), - signature: signature_bytes.to_vec(), - } - } - - pub fn display(&self) { - println!("ID: {:?}", self.id); - println!("Message Type: {}", self.msg_type); - println!("Length: {:?}", self.length); - let good_length = usize::min(self.length as usize, 985); - println!("name: {:?}", &self.body[..good_length]); - println!("Signature: {:?}", self.signature); - } -} - -impl HandshakeMessage { - pub fn display(&self) { - println!("ID: {:?}", self.id); - println!("Message Type: {}", self.msg_type); - println!("Length: {:?}", self.length); - println!("extensions: {:?}", self.extensions); - println!("name: {:?}", &self.name[..(self.length - 4) as usize]); - println!("Signature: {:?}", self.signature); - } - pub fn hello(id: u32, length: u16, username: String) -> HandshakeMessage { - let name_vec = username.trim_end_matches(char::from(0)).as_bytes().to_vec(); - HandshakeMessage { - id: id, - msg_type: 1, - length: length, - extensions: 0, - name: name_vec, - signature: vec![0; 64], - } - } - - pub fn helloReply(id: u32, length: u16, username: String) -> HandshakeMessage { - let name_vec = username.trim_end_matches(char::from(0)).as_bytes().to_vec(); - HandshakeMessage { - id: id, - msg_type: 130, - length: length, - extensions: 0, - name: name_vec, - signature: vec![0; 64], - } - } - - pub fn serialize(&self) -> Vec { - let mut out = Vec::with_capacity(4 + 1 + 2 + 4 + self.name.len() + self.signature.len()); - - // id: u32 little-endian - out.extend_from_slice(&self.id.to_be_bytes()); - - // msg_type: u8 - out.push(self.msg_type); - - out.extend_from_slice(&self.length.to_be_bytes()); - - out.extend_from_slice(&self.extensions.to_be_bytes()); - - out.extend_from_slice(&self.name); - - out.extend_from_slice(&self.signature); - - out - } - - pub fn parse(received_message: Vec) -> 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 msg_length = u16::from_be_bytes(length_bytes); - let extensions_bytes: [u8; 4] = received_message[7..11] - .try_into() - .expect("Taille incorrecte"); - let name_bytes = &received_message[11..(11 + msg_length - 4) as usize]; - let signature_bytes = - &received_message[(11 + msg_length - 4) as usize..(11 + msg_length - 4 + 64) as usize]; - 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.to_vec(), - signature: signature_bytes.to_vec(), - } - } -} - -#[cfg(test)] -mod tests { - // Note this useful idiom: importing names from outer (for mod tests) scope. - use super::*; - - /// creates an handshake message - #[tokio::test] - async fn creating_handshake_msg() { - let username = String::from("charlie_kirk"); - let handshake = HandshakeMessage::hello(0, 12, username); - handshake.display(); - } - - /// parses an handshake message - #[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(); - } -} diff --git a/client-network/src/peers_refresh.rs b/client-network/src/peers_refresh.rs new file mode 100644 index 0000000..32ddac9 --- /dev/null +++ b/client-network/src/peers_refresh.rs @@ -0,0 +1,68 @@ +// this class consists of a thread that will re send pings every time the first element +// of the stack is at the correct unix time + +use std::{ + collections::{HashMap, VecDeque}, + net::SocketAddr, + thread, + time::{self, SystemTime}, +}; + +pub struct PeerInfo { + username: String, + ip: SocketAddr, +} + +pub struct HandshakeHistory { + time_k_hash_v: HashMap, + hash_k_peerinfo_v: HashMap, + times_to_check: VecDeque, +} + +impl HandshakeHistory { + pub fn new() -> HandshakeHistory { + HandshakeHistory { + time_k_hash_v: HashMap::new(), + hash_k_peerinfo_v: HashMap::new(), + times_to_check: VecDeque::new(), + } + } + + pub fn update_handshake(&self) { + thread::spawn(move || { + // adds 10 seconds in the queue every 10 seconds + self.times_to_check.insert(index, value); + }); + } + + pub fn add_new_handshake(&mut self, hash: u64, username: String, ip: SocketAddr) { + let current_time: u64 = SystemTime::now() + .duration_since(time::UNIX_EPOCH) + .expect("system time before UNIX EPOCH") + .as_secs(); + println!("time:{}", current_time); + self.time_k_hash_v.insert(current_time, hash); + self.hash_k_peerinfo_v + .insert(hash, PeerInfo { username, ip }); + } +} + +#[cfg(test)] +mod tests { + use std::net::{IpAddr, Ipv4Addr}; + + use super::*; + + /// + /// creates a cryptographic signature + /// + #[test] + fn creating_cryptographic_signature() { + let mut hh = HandshakeHistory::new(); + hh.add_new_handshake( + 20, + "putain".to_string(), + SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 1), + ); + } +} diff --git a/client-network/src/registration.rs b/client-network/src/registration.rs index 52f3198..bbbc57b 100644 --- a/client-network/src/registration.rs +++ b/client-network/src/registration.rs @@ -4,7 +4,6 @@ use getrandom::Error; use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message}; use crate::message_handling::EventType; use crate::messages_channels::{Message, MultipleSenders}; -use crate::messages_structure::{HandshakeMessage, UDPMessage}; use std::collections::HashMap; use std::net::SocketAddr; use std::net::UdpSocket; @@ -98,6 +97,7 @@ pub fn register_ip_addresses( socket.recv_from(&mut buf).expect("receive failed"); let hello_handshake_received = UDPMessage::parse(buf.to_vec()); hello_handshake_received.display();*/ + //TODO } #[cfg(test)] -- 2.39.5 From 489669b93dd43cedb03d94c4f62236aae0f6b1b0 Mon Sep 17 00:00:00 2001 From: TIBERGHIEN corentin Date: Fri, 9 Jan 2026 20:09:39 +0100 Subject: [PATCH 4/5] wip messages creation & handling --- client-network/src/cryptographic_signature.rs | 7 +- client-network/src/lib.rs | 1 + client-network/src/message_handling.rs | 107 ++++++++++-------- client-network/src/messages_channels.rs | 8 +- client-network/src/messages_structure.rs | 4 +- client-network/src/peers_refresh.rs | 39 +++++-- client-network/src/registration.rs | 25 ++-- 7 files changed, 114 insertions(+), 77 deletions(-) diff --git a/client-network/src/cryptographic_signature.rs b/client-network/src/cryptographic_signature.rs index e278ca1..542daba 100644 --- a/client-network/src/cryptographic_signature.rs +++ b/client-network/src/cryptographic_signature.rs @@ -108,11 +108,10 @@ pub fn sign_message(crypto_pair: &CryptographicSignature, message: &Vec) -> let digest = Sha256::digest(&message[..7 + msg_length as usize]); let signature = crypto_pair.priv_key.sign_prehash_recoverable(&digest); - let message_length = 12 + msg_length as usize + 32; + let message_length = 7 + msg_length as usize + 64; let mut signed_message = Vec::with_capacity(message_length); println!("{}", message_length); - signed_message.extend_from_slice(&message[..8 + msg_length as usize]); - signed_message.pop(); + signed_message.extend_from_slice(&message[..7 + msg_length as usize]); println!("signed_tmp:{:?}", signed_message); match signature { Ok(signature) => { @@ -123,7 +122,7 @@ pub fn sign_message(crypto_pair: &CryptographicSignature, message: &Vec) -> let s_bytes = s.to_bytes(); signed_message.extend_from_slice(&r_bytes[..32]); signed_message.extend_from_slice(&s_bytes[..32]); - println!("signed:{:?}", signed_message); + println!("signed:{:?}, len: {}", signed_message, signed_message.len()); signed_message } Err(e) => { diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index ccdd77a..7fe4742 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -187,6 +187,7 @@ pub fn start_p2p_executor( start_receving_thread( sd, *first, // copie le SocketAddr (implémente Copy pour SocketAddr) + event_tx.clone(), // ); register_ip_addresses( sd.cryptopair_ref(), diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index 50e11ca..637c69d 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -7,8 +7,11 @@ use crate::{ messages_structure::construct_message, registration, }; -use std::sync::{Arc, Mutex}; use std::{collections::HashMap, net::SocketAddr}; +use std::{ + net::IpAddr, + sync::{Arc, Mutex}, +}; pub enum EventType { ServerHelloReply, @@ -42,6 +45,8 @@ pub fn handle_recevied_message( socket_addr: &SocketAddr, senders: &MultipleSenders, server_name: &String, + cmd_tx: crossbeam_channel::Sender, + ip: SocketAddr, ) { if recevied_message.len() < 4 { return; @@ -50,8 +55,31 @@ pub fn handle_recevied_message( let message_id: [u8; 4] = recevied_message[0..4].try_into().expect("size error"); let id = i32::from_be_bytes(message_id); - parse_message(recevied_message, received_name, id, crypto_pair, cmd_tx) - //TODO + let mut is_resp_to_server_handshake = false; + + if recevied_message[4] == HELLO { + let length_bytes: [u8; 2] = recevied_message[TYPE..LENGTH] + .try_into() + .expect("Taille incorrecte"); + let msg_length = u16::from_be_bytes(length_bytes) as usize; + let ilength = u16::from_be_bytes(length_bytes); + let received_name = + &recevied_message[LENGTH + EXTENSIONS..LENGTH + EXTENSIONS + ilength as usize]; + let name = String::from_utf8(received_name.to_vec()).expect("wrong name"); + if name.clone() == server_name.clone() { + is_resp_to_server_handshake = true; + } + } + + let resp = parse_message(recevied_message.to_vec(), id, crypto_pair, cmd_tx, ip); + + match resp { + None => {} + Some(resp_msg) => { + println!("msg_sent:{:?}", resp_msg); + senders.send_via(0, resp_msg, ip.to_string(), is_resp_to_server_handshake); + } + } // Lock the mutex to access the HashMap /*let list = messages_list.lock().unwrap(); @@ -119,32 +147,12 @@ pub fn handle_recevied_message( }*/ } -pub fn ping(received_message: Vec, socket_addr: String) {} - -pub fn ok(received_message: Vec, socket_addr: String) {} - -pub fn error(received_message: Vec, socket_addr: String) {} - -pub fn hello(received_message: Vec, socket_addr: String) {} - -pub fn hello_reply(received_message: Vec, socket_addr: String) {} - -pub fn root_request(received_message: Vec, socket_addr: String) {} - -pub fn root_reply(received_message: Vec, socket_addr: String) {} - -pub fn datum_request(received_message: Vec, socket_addr: String) {} - -pub fn no_datum(received_message: Vec, socket_addr: String) {} - -pub fn datum(received_message: Vec, socket_addr: String) {} - pub fn parse_message( received_message: Vec, - received_name: String, id: i32, crypto_pair: &CryptographicSignature, cmd_tx: crossbeam_channel::Sender, + ip: SocketAddr, ) -> Option> { let cmd_tx_clone = cmd_tx.clone(); @@ -163,20 +171,32 @@ pub fn parse_message( // verify signature match msgtype { HELLO | HELLOREPLY | ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => { - let peer_pubkey = tokio::runtime::Runtime::new() - .unwrap() - .block_on(get_peer_key(&received_name)) - .expect("failed to retrieve public key"); - let signature: [u8; SIGNATURE] = received_message - [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE] - .try_into() - .expect("Taille incorrecte"); - if !verify_signature(peer_pubkey, &received_message) { - println!( - "incorrect signature from given peer: {}, ignoring message of type {} with id {}", - &received_name, received_message[ID], id - ); - return None; + let ilength = u16::from_be_bytes(length_bytes); + let received_name = + &received_message[LENGTH + EXTENSIONS..LENGTH + EXTENSIONS + ilength as usize]; + let received_username = String::from_utf8(received_name.to_vec()); + match received_username { + Ok(username) => { + let peer_pubkey = tokio::runtime::Runtime::new() + .unwrap() + .block_on(get_peer_key(&username)) + .expect("failed to retrieve public key"); + let signature: [u8; SIGNATURE] = received_message + [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE] + .try_into() + .expect("Taille incorrecte"); + if !verify_signature(peer_pubkey, &received_message) { + println!( + "incorrect signature from given peer: {}, ignoring message of type {} with id {}", + &username, received_message[ID], id + ); + return None; + } + } + Err(e) => { + println!("incorrect name: {}", e); + return None; + } } } _ => {} @@ -204,17 +224,10 @@ pub fn parse_message( if let Ok(err_received) = String::from_utf8(received_message[LENGTH..(msg_length + LENGTH)].to_vec()) { - let err_msg = format!( - "Error received from peer {} : {}", - String::from(received_name), - err_received - ); + let err_msg = format!("Error received from peer {} : {}", ip, err_received); let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg)); } else { - let err_msg = format!( - "Error received from peer {} : N/A", - String::from(received_name), - ); + let err_msg = format!("Error received from peer {} : N/A", ip,); let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg)); } } diff --git a/client-network/src/messages_channels.rs b/client-network/src/messages_channels.rs index 13bb67b..a76d8a9 100644 --- a/client-network/src/messages_channels.rs +++ b/client-network/src/messages_channels.rs @@ -253,7 +253,11 @@ impl MultipleSenders { }); }*/ -pub fn start_receving_thread(shared_data: &P2PSharedData, socket_addr: SocketAddr) { +pub fn start_receving_thread( + shared_data: &P2PSharedData, + socket_addr: SocketAddr, + cmd_tx: crossbeam_channel::Sender, +) { let sock_clone = shared_data.socket(); let cryptopair_clone = shared_data.cryptopair(); let senders_clone = shared_data.senders(); @@ -274,6 +278,8 @@ pub fn start_receving_thread(shared_data: &P2PSharedData, socket_addr: SocketAdd &socket_addr, &senders_clone, &servername_clone, + cmd_tx.clone(), + src, ); } Err(e) => eprintln!("Erreur de réception: {}", e), diff --git a/client-network/src/messages_structure.rs b/client-network/src/messages_structure.rs index b0cac34..ef4d290 100644 --- a/client-network/src/messages_structure.rs +++ b/client-network/src/messages_structure.rs @@ -39,7 +39,9 @@ pub fn construct_message( match msgtype { HELLO | HELLOREPLY => { // length - message.extend_from_slice(&(EXTENSIONS + payload.len()).to_be_bytes()); + let a = payload.len() as u16; + println!("payload size:{}", a); + message.extend_from_slice(&a.to_be_bytes()); message.extend_from_slice(&payload); let signature = sign_message(crypto_pair, &message); message.extend_from_slice(&signature); diff --git a/client-network/src/peers_refresh.rs b/client-network/src/peers_refresh.rs index 32ddac9..e1cd85c 100644 --- a/client-network/src/peers_refresh.rs +++ b/client-network/src/peers_refresh.rs @@ -3,9 +3,12 @@ use std::{ collections::{HashMap, VecDeque}, - net::SocketAddr, + net::{AddrParseError, SocketAddr}, + ops::Add, + process::Command, + sync::{Arc, Mutex}, thread, - time::{self, SystemTime}, + time::{self, Duration, SystemTime}, }; pub struct PeerInfo { @@ -14,24 +17,36 @@ pub struct PeerInfo { } pub struct HandshakeHistory { - time_k_hash_v: HashMap, - hash_k_peerinfo_v: HashMap, - times_to_check: VecDeque, + time_k_ip_v: HashMap, + ip_k_peerinfo_v: HashMap, } impl HandshakeHistory { pub fn new() -> HandshakeHistory { HandshakeHistory { - time_k_hash_v: HashMap::new(), - hash_k_peerinfo_v: HashMap::new(), - times_to_check: VecDeque::new(), + time_k_ip_v: HashMap::new(), + ip_k_peerinfo_v: HashMap::new(), } } - pub fn update_handshake(&self) { + pub fn update_handshake(&mut self) { thread::spawn(move || { + let mut times_to_check = VecDeque::new(); + let current_time: u64 = SystemTime::now() + .duration_since(time::UNIX_EPOCH) + .expect("system time before UNIX EPOCH") + .add(Duration::from_secs(10)) + .as_secs(); // adds 10 seconds in the queue every 10 seconds - self.times_to_check.insert(index, value); + loop { + let mut child = Command::new("sleep").arg("9").spawn().unwrap(); + let _result = child.wait().unwrap(); + for n in 0..9 { + // push 9 successive seconds + times_to_check.push_back(current_time + n); + // gestion d'erreur si verrou mort + } + } }); } @@ -41,9 +56,9 @@ impl HandshakeHistory { .expect("system time before UNIX EPOCH") .as_secs(); println!("time:{}", current_time); - self.time_k_hash_v.insert(current_time, hash); + /*self.time_k_hash_v.insert(current_time, hash); self.hash_k_peerinfo_v - .insert(hash, PeerInfo { username, ip }); + .insert(hash, PeerInfo { username, ip });*/ } } diff --git a/client-network/src/registration.rs b/client-network/src/registration.rs index bbbc57b..5ddcdf5 100644 --- a/client-network/src/registration.rs +++ b/client-network/src/registration.rs @@ -4,6 +4,7 @@ use getrandom::Error; use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message}; use crate::message_handling::EventType; use crate::messages_channels::{Message, MultipleSenders}; +use crate::messages_structure::construct_message; use std::collections::HashMap; use std::net::SocketAddr; use std::net::UdpSocket; @@ -72,17 +73,17 @@ pub fn register_ip_addresses( messages_list: &Mutex>, id: i32, ) { - let username_size = crypto_pair.username.len(); - let hello_handshake = HandshakeMessage::hello( - 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, server_uri, false); - let mut list = messages_list.lock().expect("Failed to lock messages_list"); + let mut payload = Vec::new(); + payload.extend_from_slice(&0u32.to_be_bytes()); + payload.extend_from_slice(&crypto_pair.username.clone().as_bytes()); + let hello_handshake = construct_message(1, payload, id, crypto_pair); + match hello_handshake { + Some(handshake_message) => { + senders.send_via(0, handshake_message, server_uri, false); + } + None => {} + } + /*let mut list = messages_list.lock().expect("Failed to lock messages_list"); match list.get(&id) { Some(_) => { list.remove(&id); @@ -91,7 +92,7 @@ pub fn register_ip_addresses( list.insert(id, EventType::ServerHelloReply); } } - println!("message sent: {}", &id); + println!("message sent: {}", &id);*/ // 3. Perform the insertion /*let mut buf = [0u8; 1024]; socket.recv_from(&mut buf).expect("receive failed"); -- 2.39.5 From 92f38c9c127d742e94741d47b7575a48698089ee Mon Sep 17 00:00:00 2001 From: TIBERGHIEN corentin Date: Sat, 10 Jan 2026 20:34:51 +0100 Subject: [PATCH 5/5] fix name length issue --- client-network/src/message_handling.rs | 7 +++---- client-network/src/messages_structure.rs | 3 +-- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index 637c69d..9b427f5 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -63,8 +63,7 @@ pub fn handle_recevied_message( .expect("Taille incorrecte"); let msg_length = u16::from_be_bytes(length_bytes) as usize; let ilength = u16::from_be_bytes(length_bytes); - let received_name = - &recevied_message[LENGTH + EXTENSIONS..LENGTH + EXTENSIONS + ilength as usize]; + let received_name = &recevied_message[LENGTH + EXTENSIONS..LENGTH + ilength as usize]; let name = String::from_utf8(received_name.to_vec()).expect("wrong name"); if name.clone() == server_name.clone() { is_resp_to_server_handshake = true; @@ -172,8 +171,8 @@ pub fn parse_message( match msgtype { HELLO | HELLOREPLY | ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => { let ilength = u16::from_be_bytes(length_bytes); - let received_name = - &received_message[LENGTH + EXTENSIONS..LENGTH + EXTENSIONS + ilength as usize]; + println!("name received length: {}", ilength); + let received_name = &received_message[LENGTH + EXTENSIONS..LENGTH + ilength as usize]; let received_username = String::from_utf8(received_name.to_vec()); match received_username { Ok(username) => { diff --git a/client-network/src/messages_structure.rs b/client-network/src/messages_structure.rs index ef4d290..2376e83 100644 --- a/client-network/src/messages_structure.rs +++ b/client-network/src/messages_structure.rs @@ -44,8 +44,7 @@ pub fn construct_message( message.extend_from_slice(&a.to_be_bytes()); message.extend_from_slice(&payload); let signature = sign_message(crypto_pair, &message); - message.extend_from_slice(&signature); - return Some(message); + return Some(signature); } PING | OK => { message.extend_from_slice(&0u16.to_be_bytes()); -- 2.39.5