fix: finalize code for DEFCON

remove print statements
switch to async based waiting to improve performance a little on Linux
disable checksums on inbound packets on Linux with smoltcp

sparse-beacon/Cargo.toml

@@ -6,7 +6,7 @@ publish = false
 
 [dependencies]
 hyper = { version = "1.6.0", features = ["client", "http1", "http2"] }
-smoltcp = { version = "0.12.0", default-features = false, features = ["async", "log", "medium-ethernet", "proto-ipv4", "proto-ipv4-fragmentation", "socket-raw", "socket-tcp", "std"] }
+smoltcp = { version = "0.12.0", default-features = false, features = ["async", "log", "medium-ethernet", "proto-ipv4", "proto-ipv4-fragmentation", "socket-raw", "socket-tcp", "std", "phy-raw_socket"] }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["fs", "io-std", "io-util", "net", "process", "rt", "sync", "time", "tokio-macros"] }
 async-trait = "0.1.86"

sparse-beacon/src/socket.rs

@@ -17,27 +17,37 @@ impl RawSocket {
     pub fn new<T: adapter::BeaconAdapter>(
         a_interface: &adapter::BeaconInterface,
         promisc: bool,
-        port: u16,
+        local_port: u16,
+        remote_port: u16,
     ) -> Result<Self, error::BeaconError<T::Error>> {
         let name_raw = T::interface_name_from_interface(&a_interface);
         let name = std::str::from_utf8(&name_raw)?;
         let mut lower = Interface::new(name)?;
 
-        let mtu = a_interface.mtu as usize + if cfg!(unix) { 14 } else { 0 };
+        let mtu = a_interface.mtu as usize - if cfg!(unix) { 14 } else { 0 };
 
         lower.set_promisc(promisc)?;
         lower.set_buffer_size(mtu as i32)?;
         lower.set_non_blocking(true)?;
-        lower.set_buffer_size(8192)?;
-        lower.set_timeout(10)?;
+        #[cfg(windows)]
+        {
+            lower.set_buffer_size(2048)?;
+            lower.set_timeout(10)?;
+        }
+
+        #[cfg(unix)]
+        {
+            lower.set_immediate_mode(true)?;
+        }
 
         lower.activate()?;
 
-        if cfg!(target_os = "linux") {
-            lower.set_filter(&format!("arp or (inbound and tcp port {port})"), true, None)?;
-        } else {
-            lower.set_filter(&format!("arp or tcp port {port}"), true, None)?;
-        }
+        lower.set_filter(&format!("arp or tcp port {local_port}"), true, None)?;
+        // if cfg!(target_os = "linux") {
+        //     lower.set_filter(&format!("arp or (inbound and tcp port {port})"), true, None)?;
+        // } else {
+        //     lower.set_filter(&format!("arp or tcp port {port}"), true, None)?;
+        // }
 
         Ok(Self {
             inner: SocketInner { lower },
@@ -66,6 +76,15 @@ impl Device for RawSocket {
 
         caps.max_transmission_unit = self.mtu;
         caps.medium = Medium::Ethernet;
+        #[cfg(unix)]
+        {
+            use smoltcp::phy::{Checksum as Cs, ChecksumCapabilities as CC};
+            caps.checksum = CC::default();
+            caps.checksum.ipv4 = Cs::Tx;
+            caps.checksum.udp = Cs::Tx;
+            caps.checksum.tcp = Cs::Tx;
+            caps.checksum.icmpv4 = Cs::None;
+        }
 
         caps
     }

sparse-beacon/src/tcp.rs

@@ -235,7 +235,7 @@ where
         .unwrap_or(interface.mac_addr);
 
     let local_port = 49152 + rand::random::<u16>() % 16384;
-    let mut device = crate::socket::RawSocket::new::<T>(interface, go_promisc, local_port)?;
+    let mut device = crate::socket::RawSocket::new::<T>(interface, go_promisc, local_port, parameters.destination_port)?;
 
     let mut config = Config::new(EthernetAddress(mac_address).into());
     config.random_seed = rand::random();
@@ -251,8 +251,8 @@ where
         .add_default_ipv4_route(gateway_ip.into())
         .expect("did not expect route table to be full");
 
-    let tcp_rx_buffer = SocketBuffer::new(vec![0; 8192]);
-    let tcp_tx_buffer = SocketBuffer::new(vec![0; 8192]);
+    let tcp_rx_buffer = SocketBuffer::new(vec![0; 32768]);
+    let tcp_tx_buffer = SocketBuffer::new(vec![0; 32768]);
     let tcp_socket = Socket::new(tcp_rx_buffer, tcp_tx_buffer);
 
     let mut sockets = SocketSet::new(vec![]);
@@ -285,7 +285,7 @@ where
         }
         active = socket.is_active() && socket.state() == State::Established;
 
-        ready_wait.wait(iface.poll_delay(timestamp, &sockets).map(Into::into))?;
+        let _ = ready_wait.wait(iface.poll_delay(timestamp, &sockets).map(Into::into)).await;
     }
     if cfg!(debug_assertions) {
         println!("Connected!");
@@ -293,11 +293,11 @@ where
 
     let net = Arc::new(Mutex::new((sockets, device, iface)));
 
-    spawn_blocking({
+    tokio::spawn({
         let net = Arc::clone(&net);
         let tcp_handle = tcp_handle.clone();
 
-        move || {
+        async move {
             let mut close_attempts = -1;
 
             loop {
@@ -331,7 +331,7 @@ where
                     i_guard.poll_delay(timestamp, s_guard)
                 };
 
-                let _ = ready_wait.wait(delay.map(Into::into));
+                let _ = ready_wait.wait(delay.map(Into::into)).await;
             }
         }
     });