From 6ccb834189694001af8191519a62f14c26e5a353 Mon Sep 17 00:00:00 2001 From: Kevin Yue Date: Sun, 4 Oct 2026 14:17:38 +0800 Subject: [PATCH] fix: validate non-tunnel egress per destination --- Cargo.lock | 1 + crates/gpapi/Cargo.toml | 1 + crates/gpapi/src/session/network/bsd.rs | 10 + crates/gpapi/src/session/network/linux.rs | 10 + crates/gpapi/src/session/network/macos.rs | 15 ++ crates/gpapi/src/session/network/mod.rs | 265 ++++++++++++++++------ 6 files changed, 228 insertions(+), 74 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0d7b5d9..8ce936d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1860,6 +1860,7 @@ dependencies = [ "serde_urlencoded", "sha256", "snow", + "socket2", "specta", "tauri", "tempfile", diff --git a/crates/gpapi/Cargo.toml b/crates/gpapi/Cargo.toml index 405fb90..4b7271c 100644 --- a/crates/gpapi/Cargo.toml +++ b/crates/gpapi/Cargo.toml @@ -38,6 +38,7 @@ uuid = { workspace = true, features = ["v4", "v5", "serde"] } chrono.workspace = true humantime.workspace = true netdev.workspace = true +socket2 = { version = "0.6", features = ["all"] } os_info = { version = "3", default-features = false } snow.workspace = true zeroize = { workspace = true, features = ["serde"] } diff --git a/crates/gpapi/src/session/network/bsd.rs b/crates/gpapi/src/session/network/bsd.rs index ad624e4..c1e9ff3 100644 --- a/crates/gpapi/src/session/network/bsd.rs +++ b/crates/gpapi/src/session/network/bsd.rs @@ -1,6 +1,16 @@ pub(super) use super::bsd_routes::routes; use super::*; +pub(super) fn scope_resolver_socket( + _socket: &tokio::net::UdpSocket, + _interface: &Interface, + _endpoint: SocketAddr, +) -> anyhow::Result<()> { + // resolv.conf has no per-interface resolver contexts. IPv6 zones are carried + // in the destination address instead. + anyhow::bail!("Interface-scoped resolver contexts are unsupported on BSD") +} + pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result> { resolv_conf(control) } diff --git a/crates/gpapi/src/session/network/linux.rs b/crates/gpapi/src/session/network/linux.rs index 4b2cbd6..f7883f4 100644 --- a/crates/gpapi/src/session/network/linux.rs +++ b/crates/gpapi/src/session/network/linux.rs @@ -1,5 +1,15 @@ use super::*; +#[cfg(target_os = "linux")] +pub(super) fn scope_resolver_socket( + socket: &tokio::net::UdpSocket, + interface: &Interface, + _endpoint: SocketAddr, +) -> anyhow::Result<()> { + socket2::SockRef::from(socket).bind_device(Some(interface.name.as_bytes()))?; + Ok(()) +} + #[cfg(target_os = "linux")] pub(super) fn routes(control: &dyn CollectionControl) -> anyhow::Result> { let mut routes = Vec::new(); diff --git a/crates/gpapi/src/session/network/macos.rs b/crates/gpapi/src/session/network/macos.rs index 8a6bed7..c5055b9 100644 --- a/crates/gpapi/src/session/network/macos.rs +++ b/crates/gpapi/src/session/network/macos.rs @@ -1,6 +1,21 @@ pub(super) use super::bsd_routes::routes; use super::*; +pub(super) fn scope_resolver_socket( + socket: &tokio::net::UdpSocket, + interface: &Interface, + endpoint: SocketAddr, +) -> anyhow::Result<()> { + let index = std::num::NonZeroU32::new(interface.index).context("Resolver interface index is missing")?; + let socket = socket2::SockRef::from(socket); + if endpoint.is_ipv4() { + socket.bind_device_by_index_v4(Some(index))?; + } else { + socket.bind_device_by_index_v6(Some(index))?; + } + Ok(()) +} + pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result> { parse_resolvers(&command("scutil", &["--dns"], control)?) } diff --git a/crates/gpapi/src/session/network/mod.rs b/crates/gpapi/src/session/network/mod.rs index e704010..37c833b 100644 --- a/crates/gpapi/src/session/network/mod.rs +++ b/crates/gpapi/src/session/network/mod.rs @@ -128,79 +128,41 @@ impl PhysicalNetwork { cancellation: &CancellationToken, ) -> anyhow::Result<()> { self.validate_binding(binding, cancellation).await?; - ensure!( - binding.interface() == self.physical_interface()?.name, - "Gateway uses a different physical uplink" - ); + physical_interface_for_source(&self.interfaces, binding.source(), binding.endpoint())?; self.validate_internal(detection, cancellation).await } - fn physical_interface(&self) -> anyhow::Result<&Interface> { - let defaults = self - .snapshot - .routes - .iter() - .filter(|route| matches!(route.destination.as_str(), "default" | "0.0.0.0/0" | "::/0")) - .map(|route| route.interface.as_str()) - .collect::>(); - ensure!( - defaults.len() == 1, - "Non-tunnel sessions require one unambiguous physical uplink" - ); - let name = defaults.first().context("Physical default route is missing")?; - let interface = self - .interfaces - .iter() - .find(|interface| interface.name == *name) - .context("Physical interface is missing")?; - ensure!( - matches!( - interface.if_type, - netdev::prelude::InterfaceType::Ethernet - | netdev::prelude::InterfaceType::Wireless80211 - | netdev::prelude::InterfaceType::FastEthernetT - | netdev::prelude::InterfaceType::FastEthernetFx - | netdev::prelude::InterfaceType::GigabitEthernet - ), - "Unsupported physical interface type" - ); - Ok(interface) - } - pub async fn validate_internal( &self, detection: Option<&InternalHostDetection>, cancellation: &CancellationToken, ) -> anyhow::Result<()> { self.ensure_current(cancellation).await?; - let interface = self.physical_interface()?; let mut resolver_count = 0; for resolver in &self.snapshot.resolvers { if resolver.servers.is_empty() { continue; } - ensure!( - resolver.interface.as_deref().is_none_or(|name| name == interface.name), - "Split physical resolver attribution is unsupported" - ); for server in &resolver.servers { - let server = if server.contains(':') { - format!("[{server}]:53") - } else { - format!("{server}:53") - }; - let endpoint: SocketAddr = server.parse().context("Scoped resolver attribution is unsupported")?; + let endpoint = resolver_endpoint(server, resolver.interface.as_deref(), &self.interfaces)?; ensure!( !endpoint.ip().is_loopback() && !endpoint.ip().is_unspecified(), "Unattributed local DNS stub is unsupported" ); let socket = tokio::net::UdpSocket::bind(if endpoint.is_ipv4() { "0.0.0.0:0" } else { "[::]:0" }).await?; + if let Some(name) = &resolver.interface { + let interface = self + .interfaces + .iter() + .find(|interface| interface.name == *name) + .context("Configured resolver interface is missing")?; + platform::scope_resolver_socket(&socket, interface, endpoint)?; + } socket.connect(endpoint).await?; - let source = socket.local_addr()?.ip(); + let interface = physical_interface_for_source(&self.interfaces, socket.local_addr()?, endpoint)?; ensure!( - interface.ipv4.iter().any(|ip| IpAddr::V4(ip.addr()) == source) - || interface.ipv6.iter().any(|ip| IpAddr::V6(ip.addr()) == source), - "Resolver does not use the physical uplink" + resolver.interface.as_deref().is_none_or(|name| name == interface.name), + "Resolver route differs from its configured interface" ); resolver_count += 1; } @@ -347,7 +309,7 @@ async fn resolve_binding( }; ensure!( endpoints.contains(&authenticated_endpoint), - "Authenticated peer is not a resolved gateway endpoint; proxied non-tunnel sessions are unsupported" + "Authenticated peer differs from the gateway's current DNS addresses; check for a proxy or changed DNS answer" ); let endpoint = authenticated_endpoint; ensure!( @@ -360,28 +322,7 @@ async fn resolve_binding( let mut source_address = socket.local_addr()?; source_address.set_port(0); let source = source_address.ip(); - let scope = [source_address, endpoint] - .into_iter() - .find_map(|address| match address { - SocketAddr::V6(address) if address.scope_id() != 0 => Some(address.scope_id()), - _ => None, - }); - let mut matches = interfaces.iter().filter(|interface| { - scope.is_none_or(|scope| scope == interface.index) - && (interface.ipv4.iter().any(|ip| IpAddr::V4(ip.addr()) == source) - || interface.ipv6.iter().any(|ip| IpAddr::V6(ip.addr()) == source)) - }); - let interface = matches - .next() - .context("Gateway route has no matching physical interface")?; - ensure!( - matches.next().is_none(), - "Gateway route has ambiguous physical interfaces" - ); - ensure!( - !source.is_unspecified() && !source.is_loopback(), - "Gateway route has no source address" - ); + let interface = physical_interface_for_source(interfaces, source_address, endpoint)?; let ipv4 = match source { IpAddr::V4(ip) => Some(ip), _ => interface @@ -417,6 +358,87 @@ async fn resolve_binding( ) } +// Default-route inventories include scoped, backup, and unrelated address-family +// routes. Attribute each actual destination by its selected source instead. +fn physical_interface_for_source( + interfaces: &[Interface], + source: SocketAddr, + endpoint: SocketAddr, +) -> anyhow::Result<&Interface> { + let mut scope = None; + for address in [source, endpoint] { + if let SocketAddr::V6(address) = address { + if address.scope_id() != 0 { + ensure!( + scope.is_none_or(|scope| scope == address.scope_id()), + "Network source and destination have different interface scopes" + ); + scope = Some(address.scope_id()); + } + } + } + let source = source.ip(); + ensure!( + !source.is_unspecified() && !source.is_loopback(), + "Network route has no physical source address" + ); + let mut matches = interfaces.iter().filter(|interface| { + scope.is_none_or(|scope| scope == interface.index) + && (interface.ipv4.iter().any(|ip| IpAddr::V4(ip.addr()) == source) + || interface.ipv6.iter().any(|ip| IpAddr::V6(ip.addr()) == source)) + }); + let interface = matches + .next() + .context("Network route has no matching physical interface")?; + ensure!( + matches.next().is_none(), + "Network route has ambiguous physical interfaces" + ); + ensure!( + matches!( + interface.if_type, + netdev::prelude::InterfaceType::Ethernet + | netdev::prelude::InterfaceType::Wireless80211 + | netdev::prelude::InterfaceType::FastEthernetT + | netdev::prelude::InterfaceType::FastEthernetFx + | netdev::prelude::InterfaceType::GigabitEthernet + ), + "Network route uses an unsupported physical interface: {}", + interface.name + ); + Ok(interface) +} + +fn resolver_endpoint(server: &str, interface: Option<&str>, interfaces: &[Interface]) -> anyhow::Result { + let (address, zone) = server + .split_once('%') + .map_or((server, None), |(ip, zone)| (ip, Some(zone))); + let ip: IpAddr = address.parse().context("Invalid resolver address")?; + let mut endpoint = SocketAddr::new(ip, 53); + if let SocketAddr::V6(address) = &mut endpoint { + let zone = if zone.is_none() && address.ip().is_unicast_link_local() { + interface + } else { + zone + }; + if let Some(zone) = zone { + let index = interfaces + .iter() + .find(|candidate| candidate.name == zone || candidate.index.to_string() == zone) + .context("Resolver IPv6 zone has no matching interface")? + .index; + address.set_scope_id(index); + } + ensure!( + !address.ip().is_unicast_link_local() || address.scope_id() != 0, + "Link-local resolver has no interface scope" + ); + } else { + ensure!(zone.is_none(), "IPv4 resolver cannot have an interface scope"); + } + Ok(endpoint) +} + async fn inspect(cancellation: CancellationToken) -> anyhow::Result { tokio::task::spawn_blocking(move || { let budget = CollectionBudget::new(INSPECTION_TIMEOUT); @@ -509,6 +531,101 @@ fn parse_resolv_conf(contents: &str) -> anyhow::Result { mod tests { use super::*; + fn ethernet(name: &str, index: u32, address: &str) -> Interface { + let mut interface = Interface::dummy(); + interface.name = name.into(); + interface.index = index; + interface.if_type = netdev::prelude::InterfaceType::Ethernet; + interface.ipv4 = vec![address.parse().unwrap()]; + interface.ipv6 = vec!["fe80::1/64".parse().unwrap()]; + interface + } + + #[test] + fn attributes_each_destination_without_requiring_a_single_uplink() { + let ethernet = ethernet("en0", 7, "192.0.2.10/24"); + let mut wifi = ethernet.clone(); + wifi.name = "en1".into(); + wifi.index = 8; + wifi.if_type = netdev::prelude::InterfaceType::Wireless80211; + wifi.ipv4 = vec!["198.51.100.10/24".parse().unwrap()]; + let mut tunnel = Interface::dummy(); + tunnel.name = "utun0".into(); + tunnel.index = 9; + tunnel.ipv4 = vec!["10.0.0.1/24".parse().unwrap()]; + let interfaces = [ethernet, wifi, tunnel]; + for (source, endpoint, expected) in [ + ("192.0.2.10:0", "203.0.113.1:443", "en0"), + ("198.51.100.10:0", "198.51.100.53:53", "en1"), + ("[fe80::1%8]:0", "[fe80::53%8]:53", "en1"), + ] { + assert_eq!( + physical_interface_for_source(&interfaces, source.parse().unwrap(), endpoint.parse().unwrap()) + .unwrap() + .name, + expected + ); + } + // Virtual interfaces may coexist, but must never supply the selected source. + assert!( + physical_interface_for_source( + &interfaces, + "10.0.0.1:0".parse().unwrap(), + "10.0.0.53:53".parse().unwrap() + ) + .is_err() + ); + // Identical link-local addresses without scope are ambiguous. + assert!( + physical_interface_for_source( + &interfaces, + "[fe80::1]:0".parse().unwrap(), + "[fe80::53]:53".parse().unwrap() + ) + .is_err() + ); + assert!( + physical_interface_for_source( + &interfaces, + "[fe80::1%7]:0".parse().unwrap(), + "[fe80::53%8]:53".parse().unwrap() + ) + .is_err() + ); + } + + #[test] + fn rejects_ambiguous_or_unattributed_sources() { + let interfaces = [ethernet("en0", 7, "192.0.2.10/24"), ethernet("en1", 8, "192.0.2.10/24")]; + for source in ["192.0.2.10:0", "192.0.2.11:0", "127.0.0.1:0", "0.0.0.0:0"] { + assert!( + physical_interface_for_source(&interfaces, source.parse().unwrap(), "192.0.2.53:53".parse().unwrap()).is_err() + ); + } + } + + #[test] + fn resolver_zones_support_native_names_and_numeric_indices() { + let interfaces = [ethernet("en0", 7, "192.0.2.10/24")]; + let expected: SocketAddr = "[fe80::53%7]:53".parse().unwrap(); + assert_eq!(resolver_endpoint("fe80::53%en0", None, &interfaces).unwrap(), expected); + assert_eq!(resolver_endpoint("fe80::53%7", None, &interfaces).unwrap(), expected); + assert_eq!( + resolver_endpoint("fe80::53", Some("en0"), &interfaces).unwrap(), + expected + ); + assert_eq!( + resolver_endpoint("192.0.2.53", Some("en0"), &interfaces).unwrap(), + "192.0.2.53:53".parse().unwrap() + ); + for server in ["fe80::53", "fe80::53%missing", "fe80::53%8", "192.0.2.53%en0"] { + assert!( + resolver_endpoint(server, None, &interfaces).is_err(), + "accepted {server}" + ); + } + } + #[test] fn bracketed_ipv6_gateway_is_a_literal_endpoint() { let origin = super::super::transport::gateway_origin("https://[2001:db8::1]:444").unwrap();