From 803a98aa0bcaf8977df0b8836efeea47fff160a0 Mon Sep 17 00:00:00 2001 From: DJMrTV Date: Tue, 25 Mar 2025 22:53:43 +0100 Subject: [PATCH] feat: fix prudp stuff(almost there) --- src/main.rs | 39 +++++++++++++++++-------- src/prudp/router.rs | 2 ++ src/prudp/sockaddr.rs | 2 +- src/prudp/socket.rs | 62 ++++++++++++++++++++++++++++++++++------ src/rmc/protocols/mod.rs | 10 +++---- 5 files changed, 88 insertions(+), 27 deletions(-) diff --git a/src/main.rs b/src/main.rs index b743c62..f9190a6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -16,7 +16,7 @@ use crate::prudp::router::Router; use crate::prudp::sockaddr::PRUDPSockAddr; use crate::prudp::socket::Unsecure; use chrono::{Local, SecondsFormat}; -use log::info; +use log::{error, info}; use once_cell::sync::Lazy; use simplelog::{ ColorChoice, CombinedLogger, Config, LevelFilter, TermLogger, TerminalMode, WriteLogger, @@ -68,7 +68,7 @@ static SECURE_SERVER_PORT: Lazy = Lazy::new(|| { env::var("SECURE_SERVER_PORT") .ok() .and_then(|s| s.parse().ok()) - .unwrap_or(10002) + .unwrap_or(10001) }); static OWN_IP_PRIVATE: Lazy = Lazy::new(|| { @@ -258,11 +258,6 @@ async fn start_secure_server() -> SecureServer{ } }*/ -define_rmc_proto!( - proto AuthClientProtocol{ - Auth - } -); impl Auth for AuthClient{ async fn login(&self, name: String) -> Result<(), ErrorCode> { @@ -287,7 +282,16 @@ impl Auth for AuthClient{ } #[rmc_struct(AuthClientProtocol)] -struct AuthClient {} +struct AuthClient { + +} + +define_rmc_proto!( + proto AuthClientProtocol{ + Auth + } +); + async fn start_servers() { @@ -298,18 +302,29 @@ async fn start_servers() { let auth_sockaddr = PRUDPSockAddr::new(auth_ip, auth_port); - let (router_secure, _) = Router::new(SocketAddrV4::new(*OWN_IP_PRIVATE, *SECURE_SERVER_PORT)) + let (router_secure, _) = Router::new(SocketAddrV4::new(*OWN_IP_PRIVATE, *AUTH_SERVER_PORT)) .await .expect("unable to start router"); let mut socket_secure = router_secure - .add_socket(VirtualPort::new(1, 10), Unsecure("CD&ML")) + .add_socket(VirtualPort::new(1, 10), Unsecure("6f599f81")) .await .expect("unable to add socket"); - let conn = socket_secure.connect(auth_sockaddr).await.unwrap(); + // let conn = socket_secure.connect(auth_sockaddr).await.unwrap(); - let obj = new_rmc_gateway_connection(conn, OnlyRemote::::new); + + loop { + let Some(conn) = socket_secure.accept().await else { + error!("server crashed"); + return; + }; + + info!("new connected user!"); + + let _ = new_rmc_gateway_connection(conn, |_| AuthClient {}); //OnlyRemote::::new + + } diff --git a/src/prudp/router.rs b/src/prudp/router.rs index 5fd4198..16424c6 100644 --- a/src/prudp/router.rs +++ b/src/prudp/router.rs @@ -51,6 +51,8 @@ impl Router { let connection = packet.source_sockaddr(addr); + println!("data from {:?}", connection); + let endpoints = self.endpoints.read().await; let Some(endpoint) = endpoints[packet.header.destination_port.get_port_number() as usize].as_ref() else { diff --git a/src/prudp/sockaddr.rs b/src/prudp/sockaddr.rs index 75254bf..fe6a9d8 100644 --- a/src/prudp/sockaddr.rs +++ b/src/prudp/sockaddr.rs @@ -26,7 +26,7 @@ impl PRUDPSockAddr{ let mut hmac = Md5Hmac::new_from_slice(&[0; 16]).expect("fuck"); let mut data = self.regular_socket_addr.ip().octets().to_vec(); - data.extend_from_slice(&self.regular_socket_addr.port().to_be_bytes()); + //data.extend_from_slice(&self.regular_socket_addr.port().to_be_bytes()); hmac.write_all(&data).expect("figuring this out was complete ass"); let result: [u8; 16] = hmac.finalize().into_bytes()[0..16].try_into().expect("fuck"); diff --git a/src/prudp/socket.rs b/src/prudp/socket.rs index a0429c8..6b5c6a2 100644 --- a/src/prudp/socket.rs +++ b/src/prudp/socket.rs @@ -1,6 +1,6 @@ use crate::prudp::packet::flags::{ACK, HAS_SIZE, MULTI_ACK, NEED_ACK, RELIABLE}; use crate::prudp::packet::types::{CONNECT, DATA, DISCONNECT, PING, SYN}; -use crate::prudp::packet::PacketOption::{ConnectionSignature, FragmentId, MaximumSubstreamId, SupportedFunctions}; +use crate::prudp::packet::PacketOption::{ConnectionSignature, FragmentId, InitialSequenceId, MaximumSubstreamId, SupportedFunctions}; use crate::prudp::packet::{PRUDPHeader, PRUDPPacket, PacketOption, TypesFlags, VirtualPort}; use crate::prudp::router::{Error, Router}; use crate::prudp::sockaddr::PRUDPSockAddr; @@ -670,7 +670,7 @@ impl InternalSocket { .write_to(&mut vec) .expect("somehow failed to convert backet to bytes"); - println!("{}", hex::encode(&vec)); + println!("sent out: {}", hex::encode(&vec)); self.socket .send_to(&vec, dest.regular_socket_addr) @@ -681,7 +681,11 @@ impl InternalSocket { async fn handle_syn(&self, address: PRUDPSockAddr, packet: PRUDPPacket) { info!("got syn"); - let mut response = packet.base_acknowledgement_packet(); + let mut response = packet.base_response_packet(); + + response.header.types_and_flags.set_types(SYN); + response.header.types_and_flags.set_flag(ACK); + response.header.types_and_flags.set_flag(HAS_SIZE); let signature = address.calculate_connection_signature(); @@ -700,10 +704,12 @@ impl InternalSocket { } } - response.header.types_and_flags.set_flag(HAS_SIZE | ACK); + response.set_sizes(); self.crypto_handler.sign_pre_handshake(&mut response); + //println!("got syn: {:?}", response); + self.send_packet_unbuffered(address, response) .await; } @@ -822,16 +828,45 @@ impl InternalSocket { remote_signature, *own_signature, &packet.payload, - *max_substream, + 1 + *max_substream, ); - let mut response = packet.base_acknowledgement_packet(); - response.header.types_and_flags.set_flag(HAS_SIZE | ACK); + let mut response = packet.base_response_packet(); + response.header.types_and_flags.set_types(CONNECT); + response.header.types_and_flags.set_flag(ACK); + response.header.types_and_flags.set_flag(HAS_SIZE); + response.header.session_id = session_id; + response.header.sequence_id = 1; + response.payload = return_data; + + //let remote_signature = address.calculate_connection_signature(); + + response + .options + .push(ConnectionSignature(Default::default())); + + for option in &packet.options { + match option { + MaximumSubstreamId(max_substream) => response + .options + .push(MaximumSubstreamId(*max_substream)), + SupportedFunctions(funcs) => { + response.options.push(SupportedFunctions(*funcs)) + } + _ => { /* ? */ } + } + } + + + response.set_sizes(); + crypto.sign_connect(&mut response); + //println!("connect out: {:?}", response); + self.create_connection(crypto, address, session_id).await; self.send_packet_unbuffered(address, response).await; @@ -926,6 +961,15 @@ impl AnyInternalSocket for InternalSocket { info!("got ack"); if packet.header.types_and_flags.get_types() == SYN || packet.header.types_and_flags.get_types() == CONNECT{ + + if packet.header.types_and_flags.get_types() == SYN{ + println!("Syn: {:?}", packet); + } + + if packet.header.types_and_flags.get_types() == CONNECT{ + println!("Connect: {:?}", packet); + } + let sender = self.connection_establishment_data_sender.lock().await; info!("redirecting ack to active connection establishment code"); @@ -976,7 +1020,7 @@ impl AnyInternalSocket for InternalSocket { }, options: vec![ SupportedFunctions(0x104), - MaximumSubstreamId(1), + MaximumSubstreamId(0), ConnectionSignature(remote_signature) ], ..Default::default() @@ -1011,7 +1055,7 @@ impl AnyInternalSocket for InternalSocket { }, options: vec![ SupportedFunctions(0x04), - MaximumSubstreamId(1), + MaximumSubstreamId(0), ConnectionSignature(remote_signature) ], ..Default::default() diff --git a/src/rmc/protocols/mod.rs b/src/rmc/protocols/mod.rs index 6234149..38430df 100644 --- a/src/rmc/protocols/mod.rs +++ b/src/rmc/protocols/mod.rs @@ -132,14 +132,14 @@ impl RemoteObject for () { pub trait RmcCallable { //type Remote: RemoteObject; - async fn rmc_call( + fn rmc_call( &self, responder: &SendingConnection, protocol_id: u16, method_id: u32, call_id: u32, rest: Vec, - ); + ) -> impl std::future::Future + Send; } #[macro_export] @@ -215,8 +215,8 @@ impl OnlyRemote{ } impl RmcCallable for OnlyRemote{ - async fn rmc_call(&self, responder: &SendingConnection, protocol_id: u16, method_id: u32, call_id: u32, rest: Vec) { - + fn rmc_call(&self, responder: &SendingConnection, protocol_id: u16, method_id: u32, call_id: u32, rest: Vec) -> impl std::future::Future + Send { + async{} } } @@ -229,7 +229,7 @@ async fn handle_incoming( let sending_conn = connection.duplicate_sender(); while let Some(v) = connection.recv().await{ - let Some(proto_id) = v.get(5) else { + let Some(proto_id) = v.get(4) else { error!("received too small rmc message."); error!("ending rmc gateway."); return