feat: prepare 3.0.0 release

This commit is contained in:
Kevin Yue committed 2026-10-09 18:21:44 +08:00
1 parent e98fd7894a
commit b7b708e9cd
252 files changed
+26210 -7457

No files matched your search

+335
View File
@@ -0,0 +1,335 @@
use std::{fmt, time::Duration};
use anyhow::ensure;
use serde::{Deserialize, Serialize};
use specta::Type;
use zeroize::Zeroize;
use crate::gateway::Gateway;
/// Network location and session mode are independent: an internal gateway can
/// still require a tunnel.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum SessionMode {
Tunnel,
NonTunnel,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum MaintenanceState {
Authenticated,
Healthy,
Rejected,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct GatewaySessionSummary {
pub gateway: Gateway,
pub mode: SessionMode,
pub client_ip: Option<String>,
pub client_ipv6: Option<String>,
pub maintenance: MaintenanceState,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum SessionEndReason {
InvalidCookie,
NetworkChanged,
AllMembersFailed,
AuthorizationRevoked,
}
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "GatewayAuthenticationFields")]
pub struct GatewayAuthentication {
cookie: String,
connection_type: String,
}
#[derive(Deserialize)]
struct GatewayAuthenticationFields {
cookie: String,
connection_type: String,
}
impl TryFrom<GatewayAuthenticationFields> for GatewayAuthentication {
type Error = anyhow::Error;
fn try_from(fields: GatewayAuthenticationFields) -> Result<Self, Self::Error> {
Self::new(fields.cookie, fields.connection_type)
}
}
impl GatewayAuthentication {
pub fn new(cookie: String, connection_type: String) -> anyhow::Result<Self> {
let authentication = Self {
cookie,
connection_type,
};
ensure!(
!authentication.cookie.is_empty() && authentication.cookie.len() <= 64 * 1024,
"Gateway authentication cookie is missing or too large"
);
let params = url::form_urlencoded::parse(authentication.cookie.as_bytes()).collect::<Vec<_>>();
for key in ["authcookie", "user"] {
let mut values = params.iter().filter(|(name, _)| name == key).map(|(_, value)| value);
ensure!(
values.next().is_some_and(|value| !value.is_empty()) && values.next().is_none(),
"Gateway authentication requires one nonempty {key}"
);
}
ensure!(
!authentication.connection_type.trim().is_empty()
&& authentication.connection_type != "(null)"
&& authentication.connection_type != "-1",
"Gateway connection type is missing"
);
Ok(authentication)
}
pub fn cookie(&self) -> &str {
&self.cookie
}
pub fn connection_type(&self) -> &str {
&self.connection_type
}
pub fn mode(&self) -> SessionMode {
if self.connection_type == "tunnel" {
SessionMode::Tunnel
} else {
SessionMode::NonTunnel
}
}
}
impl fmt::Debug for GatewayAuthentication {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("GatewayAuthentication")
.field("cookie", &"<redacted>")
.field("mode", &self.mode())
.finish()
}
}
impl Drop for GatewayAuthentication {
fn drop(&mut self) {
self.cookie.zeroize();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", try_from = "InternalSessionPolicyFields")]
pub struct InternalSessionPolicy {
hip_interval_secs: u32,
collect_hip_data: bool,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct InternalSessionPolicyFields {
hip_interval_secs: u32,
collect_hip_data: bool,
}
impl TryFrom<InternalSessionPolicyFields> for InternalSessionPolicy {
type Error = anyhow::Error;
fn try_from(fields: InternalSessionPolicyFields) -> Result<Self, Self::Error> {
Self::new(fields.hip_interval_secs, fields.collect_hip_data)
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
pub struct AuthenticatedGateway {
pub gateway: Gateway,
pub authentication: GatewayAuthentication,
pub binding: Option<super::network::GatewayBinding>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum GatewayFailure {
AuthenticationRejected,
Unreachable,
TunnelFailed,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
pub struct GatewayFailureSummary {
pub gateway: Gateway,
pub failure: GatewayFailure,
}
/// Credentials remain in the interactive authentication owner; only issued
/// gateway cookies cross the runtime/service boundary.
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "ConnectionPlanFields")]
pub struct ConnectionPlan {
members: Vec<AuthenticatedGateway>,
failures: Vec<GatewayFailureSummary>,
policy: InternalSessionPolicy,
internal_detection: Option<super::network::InternalHostDetection>,
}
#[derive(Deserialize)]
struct ConnectionPlanFields {
members: Vec<AuthenticatedGateway>,
failures: Vec<GatewayFailureSummary>,
policy: InternalSessionPolicy,
internal_detection: Option<super::network::InternalHostDetection>,
}
impl TryFrom<ConnectionPlanFields> for ConnectionPlan {
type Error = anyhow::Error;
fn try_from(fields: ConnectionPlanFields) -> Result<Self, Self::Error> {
Ok(Self::new(fields.members, fields.failures, fields.policy)?.with_internal_detection(fields.internal_detection))
}
}
impl ConnectionPlan {
pub fn new(
members: Vec<AuthenticatedGateway>,
failures: Vec<GatewayFailureSummary>,
policy: InternalSessionPolicy,
) -> anyhow::Result<Self> {
ensure!(!members.is_empty(), "Connection plan has no authenticated gateways");
ensure!(
members.len() <= 64 && failures.len() <= 64,
"Connection plan exceeds its gateway limit"
);
let mode = members[0].authentication.mode();
ensure!(
members.iter().all(|member| member.authentication.mode() == mode),
"Mixed tunnel and non-tunnel sessions are unsupported"
);
ensure!(
mode != SessionMode::NonTunnel
|| members
.iter()
.all(|member| member.gateway.kind() == crate::gateway::GatewayKind::Internal),
"Non-tunnel sessions require freshly discovered internal gateways"
);
ensure!(
members.len() == 1
|| members
.iter()
.all(|member| member.gateway.kind() == crate::gateway::GatewayKind::Internal),
"Multiple authenticated gateways require an internal connection"
);
let mut hosts = std::collections::HashSet::new();
for member in &members {
if mode == SessionMode::NonTunnel {
let binding = member
.binding
.as_ref()
.ok_or_else(|| anyhow::anyhow!("Non-tunnel session has no physical binding"))?;
binding.validate_server(member.gateway.server())?;
}
let host = crate::utils::normalize_server(member.gateway.server())?;
ensure!(hosts.insert(host), "Connection plan has duplicate gateways");
}
Ok(Self {
members,
failures,
policy,
internal_detection: None,
})
}
pub fn members(&self) -> &[AuthenticatedGateway] {
&self.members
}
pub fn failures(&self) -> &[GatewayFailureSummary] {
&self.failures
}
pub fn policy(&self) -> InternalSessionPolicy {
self.policy
}
pub fn mode(&self) -> SessionMode {
self.members[0].authentication.mode()
}
pub fn with_internal_detection(mut self, detection: Option<super::network::InternalHostDetection>) -> Self {
self.internal_detection = detection;
self
}
pub fn internal_detection(&self) -> Option<&super::network::InternalHostDetection> {
self.internal_detection.as_ref()
}
}
impl Default for InternalSessionPolicy {
fn default() -> Self {
Self {
hip_interval_secs: 3600,
collect_hip_data: true,
}
}
}
impl InternalSessionPolicy {
pub fn new(hip_interval_secs: u32, collect_hip_data: bool) -> anyhow::Result<Self> {
ensure!(hip_interval_secs > 0, "HIP report interval must be positive");
ensure!(
hip_interval_secs.checked_mul(1000).is_some(),
"HIP report interval exceeds the supported range"
);
Ok(Self {
hip_interval_secs,
collect_hip_data,
})
}
pub fn hip_interval(&self) -> Duration {
Duration::from_secs(u64::from(self.hip_interval_secs))
}
pub fn collect_hip_data(&self) -> bool {
self.collect_hip_data
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn deserialization_enforces_authentication_invariants() {
for (cookie, mode) in [
("", "tunnel"),
("not-a-cookie", "tunnel"),
("user=alice", "tunnel"),
("authcookie=token", "tunnel"),
("authcookie=token&user=alice&user=bob", "tunnel"),
("authcookie=token&user=alice", ""),
] {
let serialized = serde_json::json!({"cookie":cookie, "connection_type":mode});
assert!(serde_json::from_value::<GatewayAuthentication>(serialized).is_err());
}
let auth = GatewayAuthentication::new("authcookie=token&user=alice".into(), "non-tunnel".into()).unwrap();
let decoded: GatewayAuthentication = serde_json::from_str(&serde_json::to_string(&auth).unwrap()).unwrap();
assert_eq!(decoded.mode(), SessionMode::NonTunnel);
}
#[test]
fn deserialization_enforces_schedule_invariants() {
for interval in [0, u32::MAX] {
let serialized = serde_json::json!({"hipIntervalSecs":interval,"collectHipData":false});
assert!(serde_json::from_value::<InternalSessionPolicy>(serialized).is_err());
}
let serialized = serde_json::to_string(&InternalSessionPolicy::default()).unwrap();
let decoded: InternalSessionPolicy = serde_json::from_str(&serialized).unwrap();
assert_eq!(decoded.hip_interval(), Duration::from_secs(3600));
}
}
@@ -0,0 +1,103 @@
use std::{
net::{Ipv4Addr, Ipv6Addr},
sync::Arc,
time::Duration,
};
use crate::gateway::Gateway;
use super::transport::GatewayTransport;
const LOGOUT_TIMEOUT: Duration = Duration::from_secs(5);
#[derive(Clone, Copy, Debug, Default, serde::Serialize, serde::Deserialize, specta::Type)]
pub struct ClientAddresses {
pub ipv4: Option<Ipv4Addr>,
pub ipv6: Option<Ipv6Addr>,
}
/// One issued gateway authentication and its original request context. Session
/// mode governs execution, while every mode has the same cleanup owner.
pub struct GatewaySession {
pub gateway: Gateway,
pub transport: GatewayTransport,
pub addresses: ClientAddresses,
}
/// Owns issued gateway sessions independently of tunnel or HIP setup. Workers
/// borrow members; their owner joins them before consuming this ledger in logout.
/// This owner is deliberately not Clone: transfer or drain it exactly once.
#[derive(Default)]
pub struct GatewaySessions {
members: Vec<Arc<GatewaySession>>,
}
impl GatewaySessions {
pub fn new(members: Vec<GatewaySession>) -> Self {
Self {
members: members.into_iter().map(Arc::new).collect(),
}
}
pub fn register(&mut self, session: GatewaySession) {
self.members.push(Arc::new(session));
}
pub(crate) fn update(&mut self, session: GatewaySession) {
if let Some(member) = self
.members
.iter_mut()
.find(|member| member.gateway.server() == session.gateway.server())
{
*member = Arc::new(session);
}
}
pub fn is_empty(&self) -> bool {
self.members.is_empty()
}
/// Consume the local cleanup copies only after another owner has proved it
/// acquired responsibility for these issued sessions.
pub fn relinquish(self) {}
pub fn members(&self) -> &[Arc<GatewaySession>] {
&self.members
}
/// Transfer a selected tunnel login to OpenConnect immediately before its
/// native worker starts. OpenConnect owns the live reconnect cookie and logout.
pub fn relinquish_gateway(&mut self, server: &str) {
if let Some(index) = self.members.iter().position(|member| member.gateway.server() == server) {
self.members.remove(index);
}
}
/// Call only after this member's worker has joined. Removing ownership before
/// awaiting logout prevents routine final cleanup from repeating the request.
pub async fn logout_gateway(&mut self, server: &str) {
if let Some(index) = self.members.iter().position(|member| member.gateway.server() == server) {
logout(self.members.remove(index)).await;
}
}
pub async fn logout(self) {
let mut workers = tokio::task::JoinSet::new();
for session in self.members {
workers.spawn(logout(session));
}
while let Some(result) = workers.join_next().await {
if let Err(error) = result {
log::warn!("Gateway cleanup worker failed: {error}");
}
}
}
}
async fn logout(session: Arc<GatewaySession>) {
match tokio::time::timeout(LOGOUT_TIMEOUT, session.transport.logout()).await {
Ok(Ok(())) => {}
Ok(Err(error)) => log::warn!("Gateway logout failed: {error}"),
Err(_) => log::warn!("Gateway logout timed out"),
}
}
+223
View File
@@ -0,0 +1,223 @@
use std::net::{IpAddr, SocketAddr};
use anyhow::ensure;
use serde::{Deserialize, Serialize};
use specta::Type;
use super::super::ClientAddresses;
/// Physical network context bound to the authenticated non-tunnel endpoint. Wire input is validated;
/// runtime transports use this context without performing another DNS lookup.
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "BindingFields", rename_all = "camelCase")]
pub struct GatewayBinding {
endpoint: SocketAddr,
source: SocketAddr,
interface: String,
interface_index: u32,
addresses: ClientAddresses,
network_fingerprint: Option<String>,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct BindingFields {
endpoint: SocketAddr,
source: SocketAddr,
interface: String,
interface_index: u32,
addresses: ClientAddresses,
network_fingerprint: Option<String>,
}
impl TryFrom<BindingFields> for GatewayBinding {
type Error = anyhow::Error;
fn try_from(fields: BindingFields) -> Result<Self, Self::Error> {
Self::new(
fields.endpoint,
fields.source,
fields.interface,
fields.interface_index,
fields.addresses,
fields.network_fingerprint,
)
}
}
impl GatewayBinding {
pub fn new(
endpoint: SocketAddr,
source: SocketAddr,
interface: String,
interface_index: u32,
addresses: ClientAddresses,
network_fingerprint: impl Into<Option<String>>,
) -> anyhow::Result<Self> {
let network_fingerprint = network_fingerprint.into();
ensure!(
network_fingerprint
.as_ref()
.is_none_or(|value| value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit())),
"Physical network fingerprint is invalid"
);
ensure!(
endpoint.port() != 0 && !endpoint.ip().is_unspecified() && !endpoint.ip().is_multicast(),
"Gateway endpoint is invalid"
);
ensure!(
source.port() == 0 && !source.ip().is_unspecified() && !source.ip().is_multicast(),
"Gateway source is invalid"
);
ensure!(
endpoint.is_ipv4() == source.is_ipv4(),
"Gateway address families differ"
);
ensure!(
!interface.is_empty() && interface.len() < 64 && !interface.contains('\0') && interface_index != 0,
"Gateway interface is invalid"
);
for address in [endpoint, source] {
if let SocketAddr::V6(address) = address {
ensure!(address.flowinfo() == 0, "Gateway IPv6 flow information is invalid");
ensure!(
address.scope_id() == 0 || address.scope_id() == interface_index,
"Gateway IPv6 scope differs from its interface"
);
ensure!(
!address.ip().is_unicast_link_local() || address.scope_id() == interface_index,
"Gateway IPv6 scope is missing"
);
}
}
match source.ip() {
IpAddr::V4(ip) => ensure!(
addresses.ipv4 == Some(ip),
"Gateway IPv4 source differs from its identity"
),
IpAddr::V6(ip) => ensure!(
addresses.ipv6 == Some(ip),
"Gateway IPv6 source differs from its identity"
),
}
Ok(Self {
endpoint,
source,
interface,
interface_index,
addresses,
network_fingerprint,
})
}
pub fn endpoint(&self) -> SocketAddr {
self.endpoint
}
pub fn source(&self) -> SocketAddr {
self.source
}
pub fn interface(&self) -> &str {
&self.interface
}
pub fn interface_index(&self) -> u32 {
self.interface_index
}
pub fn addresses(&self) -> ClientAddresses {
self.addresses
}
pub fn network_fingerprint(&self) -> Option<&str> {
self.network_fingerprint.as_deref()
}
pub fn validate_server(&self, server: &str) -> anyhow::Result<()> {
let origin = super::super::transport::gateway_origin(server)?;
ensure!(
origin.port_or_known_default() == Some(self.endpoint.port()),
"Gateway endpoint port differs"
);
let literal = match origin.host() {
Some(url::Host::Ipv4(ip)) => Some(IpAddr::V4(ip)),
Some(url::Host::Ipv6(ip)) => Some(IpAddr::V6(ip)),
_ => None,
};
if let Some(ip) = literal {
ensure!(self.endpoint.ip() == ip, "Literal gateway endpoint differs");
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ipv4_binding() -> GatewayBinding {
GatewayBinding::new(
"192.0.2.10:443".parse().unwrap(),
"192.0.2.5:0".parse().unwrap(),
"fixture".into(),
7,
ClientAddresses {
ipv4: Some("192.0.2.5".parse().unwrap()),
ipv6: None,
},
"a".repeat(64),
)
.unwrap()
}
#[test]
fn wire_input_rejects_inconsistent_network_identity() {
let original = serde_json::to_value(ipv4_binding()).unwrap();
for (field, value) in [
("source", serde_json::json!("192.0.2.6:0")),
("source", serde_json::json!("192.0.2.5:1234")),
("endpoint", serde_json::json!("[2001:db8::10]:443")),
("interfaceIndex", serde_json::json!(0)),
("networkFingerprint", serde_json::json!("not-a-fingerprint")),
] {
let mut invalid = original.clone();
invalid[field] = value;
assert!(
serde_json::from_value::<GatewayBinding>(invalid).is_err(),
"accepted {field}"
);
}
assert!(serde_json::from_value::<GatewayBinding>(original).is_ok());
}
#[test]
fn link_local_scope_survives_wire_round_trip_and_must_match_interface() {
let addresses = ClientAddresses {
ipv4: None,
ipv6: Some("fe80::5".parse().unwrap()),
};
let binding = GatewayBinding::new(
"[fe80::10%7]:443".parse().unwrap(),
"[fe80::5%7]:0".parse().unwrap(),
"fixture".into(),
7,
addresses,
"a".repeat(64),
)
.unwrap();
let value = serde_json::to_value(&binding).unwrap();
let restored: GatewayBinding = serde_json::from_value(value.clone()).unwrap();
assert_eq!(restored.source(), binding.source());
assert_eq!(restored.endpoint(), binding.endpoint());
for source in ["[fe80::5]:0", "[fe80::5%8]:0"] {
let mut invalid = value.clone();
invalid["source"] = serde_json::json!(source);
assert!(serde_json::from_value::<GatewayBinding>(invalid).is_err());
}
}
#[test]
fn server_origin_must_match_endpoint_port_and_literal_address() {
let binding = ipv4_binding();
assert!(binding.validate_server("gateway.example.com").is_ok());
assert!(binding.validate_server("192.0.2.10").is_ok());
assert!(binding.validate_server("192.0.2.11").is_err());
assert!(binding.validate_server("gateway.example.com:444").is_err());
}
}
+16
View File
@@ -0,0 +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<Vec<ResolverContext>> {
resolv_conf(control)
}
@@ -0,0 +1,60 @@
use super::*;
#[cfg(any(target_os = "freebsd", target_os = "openbsd", target_os = "macos"))]
pub(super) fn routes(control: &dyn CollectionControl) -> anyhow::Result<Vec<RouteContext>> {
let mut routes = Vec::new();
for family in ["inet", "inet6"] {
routes.extend(parse_routes(&command("netstat", &["-rn", "-f", family], control)?)?);
}
Ok(routes)
}
fn parse_routes(contents: &str) -> anyhow::Result<Vec<RouteContext>> {
let mut interface_column = None;
let mut routes = Vec::new();
for line in contents.lines() {
let fields = line.split_whitespace().collect::<Vec<_>>();
if fields.first() == Some(&"Destination") {
interface_column = Some(
fields
.iter()
.position(|field| matches!(*field, "Netif" | "Iface"))
.context("Route table has no interface column")?,
);
continue;
}
let Some(column) = interface_column else {
continue;
};
if fields.len() <= column {
continue;
}
// L/W entries are neighbor-cache or cloned host routes. Their presence,
// gateway MAC and expiry depend on traffic and must not cause rediscovery.
if fields[2].contains('L') || fields[2].contains('W') {
continue;
}
routes.push(RouteContext {
destination: fields[0].into(),
gateway: fields[1].into(),
interface: fields[column].into(),
table: String::new(),
metric: String::new(),
});
}
ensure!(interface_column.is_some(), "Route table header is missing");
Ok(routes)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ignores_route_use_expiry_and_platform_column_positions() {
let darwin = parse_routes("Routing tables\nInternet:\nDestination Gateway Flags Netif Expire\ndefault 192.0.2.1 UGScg en0\n192.0.2.5 aa:bb:cc:dd:ee:ff UHLWI en0 123").unwrap();
let bsd = parse_routes("Destination Gateway Flags Refs Use Mtu Netif Expire\ndefault 192.0.2.1 UGS 4 22 1500 en0\n192.0.2.5 aa:bb:cc:dd:ee:ff UHL 0 33 1500 en0 99").unwrap();
assert_eq!(darwin, bsd);
assert_eq!(darwin.len(), 1);
assert!(parse_routes("unrecognized table").is_err());
}
}
@@ -0,0 +1,94 @@
use std::net::IpAddr;
use anyhow::ensure;
use serde::{Deserialize, Serialize};
use specta::Type;
use tokio_util::sync::CancellationToken;
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "DetectionFields")]
pub struct InternalHostDetection {
targets: Vec<DetectionTarget>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
struct DetectionTarget {
address: IpAddr,
hostname: String,
}
#[derive(Deserialize)]
struct DetectionFields {
targets: Vec<DetectionTarget>,
}
impl TryFrom<DetectionFields> for InternalHostDetection {
type Error = anyhow::Error;
fn try_from(fields: DetectionFields) -> anyhow::Result<Self> {
Self::new(
fields
.targets
.into_iter()
.map(|target| (target.address, target.hostname))
.collect(),
)
}
}
impl InternalHostDetection {
pub fn new(targets: Vec<(IpAddr, String)>) -> anyhow::Result<Self> {
ensure!(
!targets.is_empty() && targets.len() <= 2,
"Invalid internal detection target count"
);
let targets = targets
.into_iter()
.map(|(address, hostname)| {
validate_target(address, &hostname)?;
Ok(DetectionTarget { address, hostname })
})
.collect::<anyhow::Result<Vec<_>>>()?;
Ok(Self { targets })
}
pub async fn detect(&self, cancellation: &CancellationToken) -> anyhow::Result<bool> {
for target in &self.targets {
if super::native::detect(target.address, &target.hostname, cancellation).await? {
return Ok(true);
}
}
Ok(false)
}
}
pub(super) fn validate_target(address: IpAddr, hostname: &str) -> anyhow::Result<()> {
ensure!(
!address.is_unspecified() && !address.is_loopback() && !address.is_multicast(),
"Invalid internal detection address"
);
ensure!(
!hostname.is_empty()
&& hostname.len() <= 253
&& hostname.is_ascii()
&& hostname
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b'_')),
"Invalid internal detection hostname"
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detection_inputs_are_retained_and_validated_on_deserialization() {
let detection = InternalHostDetection::new(vec![("192.0.2.10".parse().unwrap(), "host.example".into())]).unwrap();
let value = serde_json::to_value(&detection).unwrap();
assert!(serde_json::from_value::<InternalHostDetection>(value).is_ok());
assert!(InternalHostDetection::new(vec![]).is_err());
assert!(InternalHostDetection::new(vec![("127.0.0.1".parse().unwrap(), "host.example".into())]).is_err());
}
}
+131
View File
@@ -0,0 +1,131 @@
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<Vec<RouteContext>> {
let mut routes = Vec::new();
for family in ["-4", "-6"] {
routes.extend(parse_routes(&command(
"ip",
&[family, "-j", "route", "show", "table", "all"],
control,
)?)?);
}
Ok(routes)
}
fn parse_routes(contents: &str) -> anyhow::Result<Vec<RouteContext>> {
let value: Vec<serde_json::Value> = serde_json::from_str(contents)?;
let mut routes = Vec::new();
for route in value {
// Kernel cache and neighbor lifetimes are traffic, not network changes.
if route.get("cache").is_some() {
continue;
}
let Some(interface) = route["dev"].as_str() else {
continue;
};
let field = |name| {
route
.get(name)
.map(|value| value.as_str().map(str::to_owned).unwrap_or_else(|| value.to_string()))
.unwrap_or_default()
};
routes.push(RouteContext {
destination: field("dst"),
gateway: field("gateway"),
interface: interface.into(),
table: field("table"),
metric: field("metric"),
});
}
Ok(routes)
}
#[cfg(target_os = "linux")]
pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
let path = std::fs::canonicalize("/etc/resolv.conf")?;
if path.starts_with("/run/systemd/resolve") {
let dns = command("resolvectl", &["dns"], control)?;
let domains = command("resolvectl", &["domain"], control)?;
return parse_resolved(&dns, &domains);
}
resolv_conf(control)
}
fn parse_resolved(dns: &str, domains: &str) -> anyhow::Result<Vec<ResolverContext>> {
let mut resolvers = std::collections::BTreeMap::<Option<String>, ResolverContext>::new();
for (contents, is_dns) in [(dns, true), (domains, false)] {
for line in contents.lines().filter(|line| !line.trim().is_empty()) {
let (label, values) = line.split_once(':').context("Invalid systemd resolver output")?;
let interface = if label == "Global" {
None
} else {
let (_, name) = label.split_once('(').context("Invalid systemd resolver interface")?;
Some(
name
.strip_suffix(')')
.context("Invalid systemd resolver interface")?
.to_owned(),
)
};
let resolver = resolvers.entry(interface.clone()).or_insert_with(|| ResolverContext {
interface,
servers: Vec::new(),
domains: Vec::new(),
});
if is_dns {
for server in values.split_whitespace() {
server
.split('%')
.next()
.unwrap_or_default()
.parse::<IpAddr>()
.context("Invalid systemd resolver address")?;
resolver.servers.push(server.to_owned());
}
} else {
resolver
.domains
.extend(values.split_whitespace().map(|domain| domain.to_ascii_lowercase()));
}
}
}
Ok(resolvers.into_values().collect())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn route_identity_retains_ipv6_and_ignores_cache() {
let routes = parse_routes(r#"[{"dst":"default","gateway":"2001:db8::1","dev":"eth0","metric":600,"table":"main"},{"dst":"2001:db8::5","dev":"eth0","cache":[]}]"#).unwrap();
assert_eq!(routes.len(), 1);
assert_eq!(routes[0].gateway, "2001:db8::1");
assert_eq!(routes[0].metric, "600");
}
#[test]
fn resolved_preserves_interface_domains_and_empty_global_context() {
let resolvers = parse_resolved(
"Global:\nLink 2 (eth0): 192.0.2.53\n\nLink 3 (tun0): 198.51.100.53\n",
"Global:\nLink 2 (eth0): CORP.EXAMPLE\nLink 3 (tun0): ~.\n",
)
.unwrap();
assert_eq!(resolvers.len(), 3);
assert!(
resolvers
.iter()
.any(|resolver| resolver.interface.as_deref() == Some("eth0")
&& resolver.domains.iter().any(|domain| domain == "corp.example"))
);
}
}
+89
View File
@@ -0,0 +1,89 @@
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<Vec<ResolverContext>> {
parse_resolvers(&command("scutil", &["--dns"], control)?)
}
fn parse_resolvers(contents: &str) -> anyhow::Result<Vec<ResolverContext>> {
let mut resolvers = Vec::new();
let mut current: Option<ResolverContext> = None;
for line in contents.lines().map(str::trim) {
if line.starts_with("resolver #") {
if let Some(resolver) = current.take() {
resolvers.push(resolver);
}
current = Some(ResolverContext {
interface: None,
servers: Vec::new(),
domains: Vec::new(),
});
continue;
}
let Some(resolver) = &mut current else {
continue;
};
let Some((field, value)) = line.split_once(':') else {
continue;
};
let field = field.trim();
let value = value.trim();
if field.starts_with("nameserver[") {
value
.split('%')
.next()
.unwrap_or_default()
.parse::<IpAddr>()
.context("Invalid macOS resolver address")?;
resolver.servers.push(value.to_owned());
} else if field == "domain" || field.starts_with("search domain[") {
resolver.domains.push(value.to_ascii_lowercase());
} else if field == "if_index" {
if let Some((_, name)) = value.split_once('(') {
resolver.interface = Some(
name
.strip_suffix(')')
.context("Invalid macOS resolver interface")?
.to_owned(),
);
}
}
}
if let Some(resolver) = current {
resolvers.push(resolver);
}
Ok(resolvers)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolver_identity_is_scoped_and_ignores_reachability_counters() {
let a = parse_resolvers(
"resolver #1\n nameserver[0] : 192.0.2.53\n if_index : 4 (en0)\n search domain[0] : CORP.EXAMPLE\n reach : 2",
)
.unwrap();
let b = parse_resolvers(
"resolver #9\n search domain[0] : corp.example\n if_index : 4 (en0)\n nameserver[0] : 192.0.2.53\n reach : 3",
)
.unwrap();
assert_eq!(a, b);
assert_eq!(a[0].interface.as_deref(), Some("en0"));
}
}
+680
View File
@@ -0,0 +1,680 @@
use std::{
collections::BTreeSet,
io,
net::{IpAddr, SocketAddr},
time::Duration,
};
use anyhow::{Context, ensure};
use netdev::Interface;
use tokio_util::sync::CancellationToken;
use super::ClientAddresses;
use crate::process::collection::{CollectionBudget, CollectionControl, CollectorCommands};
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
mod bsd;
#[cfg(any(target_os = "freebsd", target_os = "openbsd", target_os = "macos", test))]
mod bsd_routes;
#[cfg(any(target_os = "linux", test))]
mod linux;
#[cfg(target_os = "macos")]
mod macos;
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
use bsd as platform;
#[cfg(target_os = "linux")]
use linux as platform;
#[cfg(target_os = "macos")]
use macos as platform;
mod binding;
mod detection;
pub mod native;
pub use binding::GatewayBinding;
pub use detection::InternalHostDetection;
const INSPECTION_TIMEOUT: Duration = Duration::from_secs(5);
const POLL_INTERVAL: Duration = Duration::from_secs(5);
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
struct InterfaceIdentity {
index: u32,
name: String,
mac: Option<String>,
flags: u32,
addresses: BTreeSet<(String, u32)>,
}
impl From<&Interface> for InterfaceIdentity {
fn from(interface: &Interface) -> Self {
let mut addresses = interface
.ipv4
.iter()
.map(|ip| (ip.to_string(), 0))
.collect::<BTreeSet<_>>();
addresses.extend(interface.ipv6.iter().enumerate().map(|(index, ip)| {
(
ip.to_string(),
interface.ipv6_scope_ids.get(index).copied().unwrap_or_default(),
)
}));
Self {
index: interface.index,
name: interface.name.clone(),
mac: interface.mac_addr.map(|mac| mac.to_string()),
flags: interface.flags,
addresses,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
struct RouteContext {
destination: String,
gateway: String,
interface: String,
table: String,
metric: String,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
struct ResolverContext {
interface: Option<String>,
servers: Vec<String>,
domains: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
struct NetworkSnapshot {
interfaces: BTreeSet<InterfaceIdentity>,
routes: BTreeSet<RouteContext>,
resolvers: Vec<ResolverContext>,
}
/// Captured before this attempt installs a tunnel. Interface counters and
/// timestamps do not participate in identity; routes and resolver context do.
#[derive(Clone)]
pub struct PhysicalNetwork {
snapshot: NetworkSnapshot,
interfaces: Vec<Interface>,
}
impl PhysicalNetwork {
pub async fn bind_authenticated_endpoint(
&self,
server: &str,
endpoint: SocketAddr,
disable_ipv6: bool,
cancellation: &CancellationToken,
) -> anyhow::Result<GatewayBinding> {
self.ensure_current(cancellation).await?;
let binding = resolve_binding(
&self.interfaces,
Some(self.fingerprint()?),
server,
disable_ipv6,
cancellation,
endpoint,
)
.await?;
self.ensure_current(cancellation).await?;
Ok(binding)
}
pub async fn validate_internal_binding(
&self,
binding: &GatewayBinding,
detection: Option<&InternalHostDetection>,
cancellation: &CancellationToken,
) -> anyhow::Result<()> {
self.validate_binding(binding, cancellation).await?;
physical_interface_for_source(&self.interfaces, binding.source(), binding.endpoint())?;
self.validate_internal(detection, cancellation).await
}
pub async fn validate_internal(
&self,
detection: Option<&InternalHostDetection>,
cancellation: &CancellationToken,
) -> anyhow::Result<()> {
self.ensure_current(cancellation).await?;
let mut resolver_count = 0;
for resolver in &self.snapshot.resolvers {
if resolver.servers.is_empty() {
continue;
}
for server in &resolver.servers {
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 interface = physical_interface_for_source(&self.interfaces, socket.local_addr()?, endpoint)?;
ensure!(
resolver.interface.as_deref().is_none_or(|name| name == interface.name),
"Resolver route differs from its configured interface"
);
resolver_count += 1;
}
}
ensure!(resolver_count > 0, "Physical resolver context is unavailable");
if let Some(detection) = detection {
ensure!(
detection.detect(cancellation).await?,
"Internal host detection no longer matches"
);
}
self.ensure_current(cancellation).await
}
pub async fn capture_controlled(cancellation: &CancellationToken) -> anyhow::Result<Self> {
let cancellation = cancellation.clone();
tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(INSPECTION_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(io::ErrorKind::Interrupted, "Network capture cancelled"));
}
budget.check()
};
Self::capture(&check)
})
.await?
}
pub async fn validate_binding(
&self,
binding: &GatewayBinding,
cancellation: &CancellationToken,
) -> anyhow::Result<()> {
self.ensure_current(cancellation).await?;
ensure!(
binding.network_fingerprint() == Some(self.fingerprint()?.as_str()),
"Physical network changed since authentication"
);
let interface = self
.interfaces
.iter()
.find(|interface| interface.index == binding.interface_index() && interface.name == binding.interface())
.context("Authenticated gateway interface is no longer present")?;
let addresses = binding.addresses();
ensure!(
addresses
.ipv4
.is_none_or(|ip| interface.ipv4.iter().any(|address| address.addr() == ip)),
"Authenticated IPv4 address changed"
);
ensure!(
addresses
.ipv6
.is_none_or(|ip| interface.ipv6.iter().any(|address| address.addr() == ip)),
"Authenticated IPv6 address changed"
);
Ok(())
}
fn fingerprint(&self) -> anyhow::Result<String> {
Ok(sha256::digest(serde_json::to_vec(&self.snapshot)?))
}
pub fn capture(control: &dyn CollectionControl) -> anyhow::Result<Self> {
control.check()?;
let mut interfaces = netdev::get_interfaces();
for interface in &mut interfaces {
interface.ipv4.sort();
// The address and its zone must move together when native enumeration
// order changes between captures.
let mut ipv6 = interface
.ipv6
.iter()
.copied()
.enumerate()
.map(|(index, address)| {
(
address,
interface.ipv6_scope_ids.get(index).copied().unwrap_or_default(),
)
})
.collect::<Vec<_>>();
ipv6.sort();
interface.ipv6 = ipv6.iter().map(|(address, _)| *address).collect();
interface.ipv6_scope_ids = ipv6.into_iter().map(|(_, scope)| scope).collect();
}
let snapshot = snapshot(&interfaces, control)?;
control.check()?;
Ok(Self { snapshot, interfaces })
}
/// Validate endpoint selection against the captured network. The inspection
/// is joined even when cancellation occurs, so native collectors cannot outlive
/// the connection attempt.
pub async fn ensure_current(&self, cancellation: &CancellationToken) -> anyhow::Result<()> {
let current = inspect(cancellation.clone()).await?;
ensure!(
current == self.snapshot,
"Physical network changed during gateway setup"
);
Ok(())
}
/// The owner must cancel and await this monitor, including its blocking
/// inspection. Dropping a selected future would detach the native collector.
pub async fn wait_for_change(
&self,
detection: Option<InternalHostDetection>,
cancellation: CancellationToken,
) -> anyhow::Result<bool> {
loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => return Ok(false),
_ = tokio::time::sleep(POLL_INTERVAL) => {},
}
let current = self.validate_internal(detection.as_ref(), &cancellation).await;
if cancellation.is_cancelled() {
return Ok(false);
}
if current.is_err() {
return Ok(true);
}
}
}
}
async fn resolve_binding(
interfaces: &[Interface],
fingerprint: Option<String>,
server: &str,
disable_ipv6: bool,
cancellation: &CancellationToken,
authenticated_endpoint: SocketAddr,
) -> anyhow::Result<GatewayBinding> {
let origin = super::transport::gateway_origin(server)?;
let host = origin.host_str().context("Gateway host is missing")?;
let port = origin.port_or_known_default().context("Gateway port is missing")?;
let literal = literal_gateway_address(&origin)?;
let endpoints = if let Some(ip) = literal {
vec![SocketAddr::new(ip, port)]
} else {
native::resolve(host, port, disable_ipv6, cancellation).await?
};
ensure!(
endpoints.contains(&authenticated_endpoint),
"Authenticated peer differs from the gateway's current DNS addresses; check for a proxy or changed DNS answer"
);
let endpoint = authenticated_endpoint;
ensure!(
!(disable_ipv6 && endpoint.is_ipv6()),
"Authenticated gateway uses disabled IPv6"
);
let bind = if endpoint.is_ipv4() { "0.0.0.0:0" } else { "[::]:0" };
let socket = tokio::net::UdpSocket::bind(bind).await?;
socket.connect(endpoint).await?;
let mut source_address = socket.local_addr()?;
source_address.set_port(0);
let source = source_address.ip();
let interface = physical_interface_for_source(interfaces, source_address, endpoint)?;
let ipv4 = match source {
IpAddr::V4(ip) => Some(ip),
_ => interface
.ipv4
.iter()
.map(|ip| ip.addr())
.find(|ip| !ip.is_loopback() && !ip.is_unspecified()),
};
let ipv6 = if disable_ipv6 {
None
} else {
match source {
IpAddr::V6(ip) => Some(ip),
_ => interface
.ipv6
.iter()
.map(|ip| ip.addr())
.find(|ip| !ip.is_loopback() && !ip.is_unspecified() && !ip.is_unicast_link_local()),
}
};
if let std::net::SocketAddr::V6(address) = &mut source_address {
if address.ip().is_unicast_link_local() && address.scope_id() == 0 {
address.set_scope_id(interface.index);
}
}
GatewayBinding::new(
endpoint,
source_address,
interface.name.clone(),
interface.index,
ClientAddresses { ipv4, ipv6 },
fingerprint.clone(),
)
}
// 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<SocketAddr> {
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<NetworkSnapshot> {
tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(INSPECTION_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"Network inspection cancelled",
));
}
budget.check()
};
let result = snapshot(&netdev::get_interfaces(), &check)?;
check()?;
Ok(result)
})
.await?
}
fn literal_gateway_address(origin: &url::Url) -> anyhow::Result<Option<IpAddr>> {
Ok(match origin.host().context("Gateway host is missing")? {
url::Host::Ipv4(ip) => Some(IpAddr::V4(ip)),
url::Host::Ipv6(ip) => Some(IpAddr::V6(ip)),
url::Host::Domain(_) => None,
})
}
fn snapshot(interfaces: &[Interface], control: &dyn CollectionControl) -> anyhow::Result<NetworkSnapshot> {
control.check()?;
Ok(NetworkSnapshot {
interfaces: interfaces.iter().map(InterfaceIdentity::from).collect(),
routes: platform::routes(control)?.into_iter().collect(),
resolvers: platform::resolvers(control)?,
})
}
fn command(name: &str, args: &[&str], control: &dyn CollectionControl) -> anyhow::Result<String> {
let output = CollectorCommands::new(control)
.run(name, args)?
.with_context(|| format!("Required network tool {name} is unavailable"))?;
ensure!(output.status.success(), "Network tool {name} failed");
String::from_utf8(output.stdout).context("Network tool output is not UTF-8")
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
fn resolv_conf(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
control.check()?;
let file = std::fs::File::open("/etc/resolv.conf")?;
use std::io::Read;
let mut contents = String::new();
file.take(64 * 1024 + 1).read_to_string(&mut contents)?;
ensure!(contents.len() <= 64 * 1024, "Resolver configuration is too large");
control.check()?;
Ok(vec![parse_resolv_conf(&contents)?])
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
fn parse_resolv_conf(contents: &str) -> anyhow::Result<ResolverContext> {
let mut resolver = ResolverContext {
interface: None,
servers: Vec::new(),
domains: Vec::new(),
};
for line in contents.lines() {
let line = line.split(['#', ';']).next().unwrap_or_default();
let mut fields = line.split_whitespace();
match fields.next() {
Some("nameserver") => {
if let Some(server) = fields.next() {
// IPv6 zone identifiers are retained for scoped physical resolvers.
server
.split('%')
.next()
.unwrap_or_default()
.parse::<IpAddr>()
.context("Invalid resolver address")?;
resolver.servers.push(server.to_owned());
}
}
Some("search" | "domain") => resolver
.domains
.extend(fields.map(|domain| domain.to_ascii_lowercase())),
_ => {}
}
}
Ok(resolver)
}
#[cfg(test)]
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();
assert_eq!(
literal_gateway_address(&origin).unwrap(),
Some("2001:db8::1".parse().unwrap())
);
}
#[test]
fn resolver_order_comments_and_case_do_not_change_network_identity() {
assert_eq!(
parse_resolv_conf("nameserver 192.0.2.53\nsearch CORP.EXAMPLE\n# comment").unwrap(),
parse_resolv_conf("search corp.example\nnameserver 192.0.2.53 # DHCP\n").unwrap()
);
assert_ne!(
parse_resolv_conf("nameserver 192.0.2.53").unwrap(),
parse_resolv_conf("nameserver 192.0.2.54").unwrap()
);
}
#[test]
fn interface_identity_ignores_counters_and_address_enumeration_order() {
let mut interface = Interface::dummy();
interface.index = 7;
interface.name = "bridge0".into();
interface.ipv4 = vec!["192.0.2.10/24".parse().unwrap(), "192.0.2.11/24".parse().unwrap()];
let original = InterfaceIdentity::from(&interface);
interface.ipv4.reverse();
interface.mtu = Some(1200);
interface.default = !interface.default;
assert_eq!(original, InterfaceIdentity::from(&interface));
interface.index = 8;
assert_ne!(original, InterfaceIdentity::from(&interface));
}
}
#[cfg(test)]
pub(crate) fn test_binding() -> GatewayBinding {
GatewayBinding::new(
"192.0.2.10:443".parse().unwrap(),
"192.0.2.5:0".parse().unwrap(),
"fixture".into(),
1,
ClientAddresses {
ipv4: Some("192.0.2.5".parse().unwrap()),
ipv6: None,
},
"0".repeat(64),
)
.unwrap()
}
+245
View File
@@ -0,0 +1,245 @@
use std::{net::SocketAddr, path::PathBuf};
use anyhow::{Context, ensure};
use dns_lookup::{AddrFamily, AddrInfoHints, SockType, getaddrinfo};
use tokio_util::sync::CancellationToken;
use super::*;
const MAX_ADDRESSES: usize = 64;
#[doc(hidden)]
pub fn detect_in_helper(address: std::net::IpAddr, hostname: &str) -> anyhow::Result<bool> {
super::detection::validate_target(address, hostname)?;
Ok(dns_lookup::lookup_addr(&address).is_ok_and(|name| name.eq_ignore_ascii_case(hostname)))
}
pub(super) async fn detect(
address: std::net::IpAddr,
hostname: &str,
cancellation: &CancellationToken,
) -> anyhow::Result<bool> {
super::detection::validate_target(address, hostname)?;
let args = vec![
"detect-internal-host".into(),
"--address".into(),
address.to_string(),
"--hostname".into(),
hostname.into(),
];
let output = run_helper(common::binary_paths::gpclient(), args, cancellation.clone()).await?;
serde_json::from_slice(&output).context("Invalid internal detection helper response")
}
/// Entry point for gpclient's isolated native resolver helper. This blocking
/// function must run in the child process, never a connection runtime thread.
#[doc(hidden)]
pub fn lookup_in_helper(host: &str, port: u16, disable_ipv6: bool) -> anyhow::Result<Vec<SocketAddr>> {
validate_host(host, port)?;
let hints = AddrInfoHints {
address: if disable_ipv6 { AddrFamily::Inet.into() } else { 0 },
socktype: SockType::Stream.into(),
..AddrInfoHints::default()
};
let service = port.to_string();
let mut addresses = Vec::new();
for result in getaddrinfo(Some(host), Some(&service), Some(hints)).map_err(io::Error::from)? {
let address = result?.sockaddr;
if !addresses.contains(&address) {
ensure!(
addresses.len() < MAX_ADDRESSES,
"Native resolver returned too many gateway addresses"
);
addresses.push(address);
}
}
validate_addresses(&addresses, port, disable_ipv6)?;
Ok(addresses)
}
pub(super) async fn resolve(
host: &str,
port: u16,
disable_ipv6: bool,
cancellation: &CancellationToken,
) -> anyhow::Result<Vec<SocketAddr>> {
validate_host(host, port)?;
let mut args = vec!["resolve-gateway".into(), host.into(), "--port".into(), port.to_string()];
if disable_ipv6 {
args.push("--disable-ipv6".into());
}
run_resolver(
common::binary_paths::gpclient(),
args,
port,
disable_ipv6,
cancellation.clone(),
)
.await
}
async fn run_resolver(
executable: PathBuf,
args: Vec<String>,
port: u16,
disable_ipv6: bool,
cancellation: CancellationToken,
) -> anyhow::Result<Vec<SocketAddr>> {
let output = run_helper(executable, args, cancellation).await?;
let addresses: Vec<SocketAddr> = serde_json::from_slice(&output).context("Invalid resolver helper response")?;
validate_addresses(&addresses, port, disable_ipv6)?;
Ok(addresses)
}
async fn run_helper(
executable: PathBuf,
args: Vec<String>,
cancellation: CancellationToken,
) -> anyhow::Result<Vec<u8>> {
// Await the owned worker even on cancellation. CollectorCommands kills and
// waits for the helper process and any descendants before returning.
tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(INSPECTION_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"Gateway resolution cancelled",
));
}
budget.check()
};
let args = args.iter().map(String::as_str).collect::<Vec<_>>();
let output = CollectorCommands::new(&check)
.run_executable(&executable, &args)?
.context("Native resolver helper is unavailable")?;
check()?;
ensure!(output.status.success(), "Native gateway resolution failed");
Ok(output.stdout)
})
.await?
}
fn validate_host(host: &str, port: u16) -> anyhow::Result<()> {
ensure!(port != 0, "Gateway port is zero");
ensure!(
!host.is_empty() && host.len() <= 253 && !host.contains('\0') && !host.contains(['/', ':']),
"Invalid gateway hostname"
);
Ok(())
}
fn validate_addresses(addresses: &[SocketAddr], port: u16, disable_ipv6: bool) -> anyhow::Result<()> {
ensure!(
!addresses.is_empty() && addresses.len() <= MAX_ADDRESSES,
"Invalid gateway address count"
);
ensure!(
addresses.iter().all(|address| {
address.port() == port && !address.ip().is_unspecified() && (!disable_ipv6 || address.is_ipv4())
}),
"Invalid gateway address from resolver helper"
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn actual_helper_output_is_validated_before_admission() {
let addresses = run_resolver(
"/bin/sh".into(),
vec!["-c".into(), "printf '[\"192.0.2.1:443\"]'".into()],
443,
true,
CancellationToken::new(),
)
.await
.unwrap();
assert_eq!(addresses, vec!["192.0.2.1:443".parse::<SocketAddr>().unwrap()]);
assert!(
run_resolver(
"/bin/sh".into(),
vec!["-c".into(), "printf '[\"192.0.2.1:444\"]'".into()],
443,
true,
CancellationToken::new(),
)
.await
.is_err()
);
}
#[tokio::test]
async fn cancellation_kills_and_joins_the_running_resolver_process() {
let file = tempfile::NamedTempFile::new().unwrap();
let path = file.path().to_owned();
let cancellation = CancellationToken::new();
let worker = tokio::spawn(run_resolver(
"/bin/sh".into(),
vec![
"-c".into(),
"printf '%s' \"$$\" > \"$1\"; sleep 30 & wait".into(),
"resolver-test".into(),
path.to_string_lossy().into_owned(),
],
443,
false,
cancellation.clone(),
));
let pid = tokio::time::timeout(Duration::from_secs(2), async {
loop {
if let Ok(pid) = std::fs::read_to_string(&path).unwrap().parse::<i32>() {
break pid;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
cancellation.cancel();
let error = tokio::time::timeout(Duration::from_secs(1), worker)
.await
.unwrap()
.unwrap()
.unwrap_err();
assert_eq!(
error.downcast::<io::Error>().unwrap().kind(),
io::ErrorKind::Interrupted
);
assert_eq!(
nix::sys::signal::kill(nix::unistd::Pid::from_raw(pid), None),
Err(nix::errno::Errno::ESRCH)
);
}
#[test]
fn native_lookup_preserves_port_and_ipv4_policy() {
let addresses = lookup_in_helper("localhost", 444, true).unwrap();
assert!(
addresses
.iter()
.all(|address| address.is_ipv4() && address.ip().is_loopback() && address.port() == 444)
);
}
#[test]
fn helper_response_validation_retains_ipv6_scope_and_rejects_wrong_port() {
let addresses = vec!["[fe80::1%7]:443".parse().unwrap(), "192.0.2.1:443".parse().unwrap()];
validate_addresses(&addresses, 443, false).unwrap();
assert_eq!(
serde_json::from_str::<Vec<SocketAddr>>(&serde_json::to_string(&addresses).unwrap()).unwrap(),
addresses
);
assert!(validate_addresses(&addresses, 444, false).is_err());
assert!(validate_addresses(&addresses, 443, true).is_err());
}
#[test]
fn rejects_invalid_helper_requests_before_lookup() {
assert!(lookup_in_helper("gateway.example/path", 443, false).is_err());
assert!(lookup_in_helper("gateway.example", 0, false).is_err());
}
}
+316
View File
@@ -0,0 +1,316 @@
use std::{
future::Future,
io,
pin::Pin,
sync::{Arc, Mutex},
time::{Duration, Instant},
};
use tokio::task::JoinSet;
use tokio_util::sync::CancellationToken;
use zeroize::{Zeroize, Zeroizing};
use crate::{gateway::Gateway, process::collection::CollectionControl};
use super::{
GatewaySession, GatewaySessionSummary, GatewaySessions, InternalSessionPolicy, MaintenanceState, SessionEndReason,
SessionMode, transport::GatewayRequestError,
};
const COLLECTION_TIMEOUT: Duration = Duration::from_secs(60);
/// This request is deliberately independent of OpenConnect's callback/FFI types.
#[derive(Clone)]
pub struct SessionHipRequest {
pub gateway: Gateway,
pub cookie: String,
pub client_ip: Option<String>,
pub client_ipv6: Option<String>,
pub md5: String,
pub collect_posture: bool,
}
impl Drop for SessionHipRequest {
fn drop(&mut self) {
self.cookie.zeroize();
}
}
pub struct SessionCollectionControl {
cancellation: CancellationToken,
deadline: Instant,
}
impl CollectionControl for SessionCollectionControl {
fn check(&self) -> io::Result<()> {
if self.cancellation.is_cancelled() {
Err(io::Error::new(io::ErrorKind::Interrupted, "HIP collection cancelled"))
} else if Instant::now() >= self.deadline {
Err(io::Error::new(io::ErrorKind::TimedOut, "HIP collection timed out"))
} else {
Ok(())
}
}
}
pub type SessionReportProducer =
dyn Fn(&SessionHipRequest, &SessionCollectionControl) -> io::Result<String> + Send + Sync;
pub type SessionReportObserver = dyn Fn(&SessionHipRequest, &str) + Send + Sync;
pub type SessionStatusObserver = dyn Fn(GatewaySessionSummary) + Send + Sync;
pub type SessionNetworkValidator =
dyn Fn(CancellationToken) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>> + Send + Sync;
#[derive(Clone)]
pub struct SessionCallbacks {
pub produce_report: Arc<SessionReportProducer>,
pub report_submitted: Arc<SessionReportObserver>,
pub status_changed: Arc<SessionStatusObserver>,
pub validate_network: Arc<SessionNetworkValidator>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionExit {
Disconnected,
Failed(SessionEndReason),
}
/// Owns maintenance workers until they have stopped. The session owner retains
/// its ledger and logs out after joining every worker. Interactive authentication
/// also belongs to that owner. Cancel and await this future, never abort/drop it:
/// blocking collectors must finish before cleanup releases their resources.
pub async fn maintain_non_tunnel_sessions(
sessions: &mut GatewaySessions,
policy: InternalSessionPolicy,
mut callbacks: SessionCallbacks,
cancellation: CancellationToken,
network_change: impl Future<Output = SessionEndReason>,
) -> anyhow::Result<SessionExit> {
anyhow::ensure!(!sessions.is_empty(), "Non-tunnel session set is empty");
anyhow::ensure!(
sessions
.members()
.iter()
.all(|session| session.transport.authentication().mode() == SessionMode::NonTunnel),
"Tunnel member supplied to non-tunnel runtime"
);
let workers_cancel = cancellation.child_token();
let observer = callbacks.status_changed.clone();
let status_gate = Arc::new(Mutex::new(()));
let gate = status_gate.clone();
let cancelled = workers_cancel.clone();
let worker_observer = observer.clone();
callbacks.status_changed = Arc::new(move |summary| {
let _guard = gate.lock().unwrap_or_else(|error| error.into_inner());
if !cancelled.is_cancelled() {
worker_observer(summary);
}
});
let mut workers = JoinSet::new();
for session in sessions.members() {
let session = session.clone();
let callbacks = callbacks.clone();
let cancellation = workers_cancel.clone();
workers.spawn(async move {
let server = session.gateway.server().to_owned();
(server, maintain_member(session, policy, callbacks, cancellation).await)
});
}
tokio::pin!(network_change);
let mut worker_failure = None;
let outcome = loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => break SessionExit::Disconnected,
reason = &mut network_change => break SessionExit::Failed(reason),
result = workers.join_next() => match result {
Some(Ok((_, MemberExit::Terminal(reason)))) => break SessionExit::Failed(reason),
Some(Ok((server, MemberExit::Rejected))) => {
sessions.logout_gateway(&server).await;
if workers.is_empty() { break SessionExit::Failed(SessionEndReason::AllMembersFailed); }
},
Some(Ok((_, MemberExit::Cancelled))) => {},
Some(Err(error)) => { worker_failure = Some(error); break SessionExit::Disconnected; },
None => break SessionExit::Failed(SessionEndReason::AllMembersFailed),
},
}
};
workers_cancel.cancel();
if matches!(outcome, SessionExit::Failed(_)) || worker_failure.is_some() {
// Invalidate advertised health before waiting for collectors or remote
// cleanup. Cancellation prevents workers from publishing Healthy afterwards.
let _guard = status_gate.lock().unwrap_or_else(|error| error.into_inner());
for session in sessions.members() {
observer(GatewaySessionSummary {
gateway: session.gateway.clone(),
mode: SessionMode::NonTunnel,
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
maintenance: MaintenanceState::Rejected,
});
}
}
// Do not abort workers: a blocking collector must observe cancellation and be
// joined before approval/identity resources can be released by the caller.
while let Some(result) = workers.join_next().await {
if let Err(error) = result {
worker_failure.get_or_insert(error);
}
}
if let Some(error) = worker_failure {
return Err(error.into());
}
// Deliberate disconnect wins even when it arrives during coordinated cleanup.
if cancellation.is_cancelled() {
Ok(SessionExit::Disconnected)
} else {
Ok(outcome)
}
}
async fn maintain_member(
session: Arc<GatewaySession>,
policy: InternalSessionPolicy,
callbacks: SessionCallbacks,
cancellation: CancellationToken,
) -> MemberExit {
let request = SessionHipRequest {
gateway: session.gateway.clone(),
cookie: session.transport.authentication().cookie().into(),
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
md5: session.transport.hip_token(),
collect_posture: policy.collect_hip_data(),
};
let status = |maintenance| {
if !cancellation.is_cancelled() {
(callbacks.status_changed)(GatewaySessionSummary {
gateway: session.gateway.clone(),
mode: SessionMode::NonTunnel,
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
maintenance,
});
}
};
status(MaintenanceState::Authenticated);
loop {
if (callbacks.validate_network)(cancellation.clone()).await.is_err() {
return MemberExit::Terminal(SessionEndReason::NetworkChanged);
}
let sent_at = tokio::time::Instant::now();
let check = tokio::select! {
biased;
_ = cancellation.cancelled() => return MemberExit::Cancelled,
result = session.transport.check_hip(session.addresses.ipv4.map(Into::into), session.addresses.ipv6.map(Into::into)) => result,
};
let (result, delay) = match check {
Ok(check) => {
let result = if check.report_needed {
collect_and_submit(&session, &request, &callbacks, &cancellation).await
} else {
Ok(())
};
(result, check.delay)
}
Err(error) => (Err(MemberError::Gateway(error)), Duration::ZERO),
};
let next_check = match result {
Ok(()) => {
if cancellation.is_cancelled() {
return MemberExit::Cancelled;
}
status(MaintenanceState::Healthy);
let Some(next_check) = sent_at
.checked_add(policy.hip_interval())
.and_then(|time| time.checked_add(delay))
else {
status(MaintenanceState::Rejected);
return MemberExit::Rejected;
};
next_check
}
Err(MemberError::Gateway(GatewayRequestError::InvalidCookie)) => {
status(MaintenanceState::Rejected);
return MemberExit::Terminal(SessionEndReason::InvalidCookie);
}
Err(MemberError::Network) => return MemberExit::Terminal(SessionEndReason::NetworkChanged),
Err(MemberError::Authorization) => return MemberExit::Terminal(SessionEndReason::AuthorizationRevoked),
Err(error) => {
if cancellation.is_cancelled() {
return MemberExit::Cancelled;
}
status(MaintenanceState::Rejected);
log::warn!("Gateway maintenance failed: {error}");
return MemberExit::Rejected;
}
};
tokio::select! {
biased;
_ = cancellation.cancelled() => return MemberExit::Cancelled,
_ = tokio::time::sleep_until(next_check) => {},
}
}
}
enum MemberExit {
Cancelled,
Rejected,
Terminal(SessionEndReason),
}
#[derive(Debug, thiserror::Error)]
enum MemberError {
#[error("{0}")]
Gateway(#[from] GatewayRequestError),
// Collector/script errors can contain user-provided text. Do not log payloads.
#[error("HIP report collection failed")]
Collection,
#[error("Physical network validation failed")]
Network,
#[error("HIP report authorization was revoked")]
Authorization,
}
async fn collect_and_submit(
session: &GatewaySession,
request: &SessionHipRequest,
callbacks: &SessionCallbacks,
cancellation: &CancellationToken,
) -> Result<(), MemberError> {
let producer = callbacks.produce_report.clone();
let input = request.clone();
let control = SessionCollectionControl {
cancellation: cancellation.clone(),
deadline: Instant::now() + COLLECTION_TIMEOUT,
};
let report = tokio::task::spawn_blocking(move || {
control.check()?;
let report = Zeroizing::new(producer(&input, &control)?);
control.check()?;
Ok::<_, io::Error>(report)
})
.await
.map_err(|_| MemberError::Collection)?
.map_err(|error| {
if error.kind() == io::ErrorKind::PermissionDenied {
MemberError::Authorization
} else {
MemberError::Collection
}
})?;
(callbacks.validate_network)(cancellation.clone())
.await
.map_err(|_| MemberError::Network)?;
tokio::select! {
biased;
_ = cancellation.cancelled() => return Err(MemberError::Collection),
result = session.transport.submit_hip(&report, session.addresses.ipv4.map(Into::into), session.addresses.ipv6.map(Into::into)) => result?,
}
if !cancellation.is_cancelled() {
(callbacks.report_submitted)(request, &report);
}
Ok(())
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,415 @@
use std::{
future::pending,
sync::{
Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
};
use tokio::sync::Notify;
use super::*;
use crate::session::transport::GatewayTransport;
use crate::session::{
ClientAddresses, GatewaySessions,
transport::tests::{gateway, response},
};
async fn run_owned_sessions(
members: Vec<GatewaySession>,
policy: InternalSessionPolicy,
callbacks: SessionCallbacks,
cancellation: CancellationToken,
network_change: impl Future<Output = SessionEndReason>,
) -> anyhow::Result<SessionExit> {
let mut sessions = GatewaySessions::new(members);
let result =
maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation.clone(), network_change).await;
sessions.logout().await;
if cancellation.is_cancelled() {
Ok(SessionExit::Disconnected)
} else {
result
}
}
fn member(name: &str, transport: GatewayTransport) -> GatewaySession {
GatewaySession {
gateway: Gateway::new(name.into(), format!("{name}.example")),
transport,
addresses: ClientAddresses {
ipv4: Some("192.0.2.7".parse().unwrap()),
ipv6: None,
},
}
}
fn callbacks() -> SessionCallbacks {
SessionCallbacks {
produce_report: Arc::new(|_, _| Ok("<hip-report/>".into())),
report_submitted: Arc::new(|_, _| {}),
status_changed: Arc::new(|_| {}),
validate_network: Arc::new(|_| Box::pin(async { Ok(()) })),
}
}
#[tokio::test]
async fn network_uncertainty_prevents_hip_and_healthy_status() {
let (transport, server) = gateway(vec![response("<response status='success'/>")]).await;
let mut callbacks = callbacks();
callbacks.validate_network = Arc::new(|_| Box::pin(async { anyhow::bail!("Network changed") }));
callbacks.status_changed = Arc::new(|summary| assert_ne!(summary.maintenance, MaintenanceState::Healthy));
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::NetworkChanged));
assert_eq!(server.await.unwrap()[0].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn revoked_report_authorization_terminates_the_attempt() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
callbacks.produce_report = Arc::new(|_, _| Err(io::ErrorKind::PermissionDenied.into()));
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::AuthorizationRevoked));
assert_eq!(server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn invalid_cookie_terminates_only_after_logout() {
let (transport, server) = gateway(vec![
response("<response status='error'><error>Invalid authentication cookie</error></response>"),
response("<response status='success'/>"),
])
.await;
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks(),
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::InvalidCookie));
let requests = server.await.unwrap();
assert_eq!(requests.len(), 2);
assert_eq!(requests[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn rejection_preserves_healthy_members_and_cleanup_owns_all_members() {
let (rejected, rejected_server) = gateway(vec![
response("<response status='error'><error>Denied</error></response>"),
response("<response status='success'/>"),
])
.await;
let (healthy, healthy_server) = gateway(vec![
response("<response><hip-report-needed>no</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let ready = Arc::new(Notify::new());
let states = Arc::new(Mutex::new(Vec::new()));
let mut callbacks = callbacks();
let states_copy = states.clone();
let ready_copy = ready.clone();
callbacks.status_changed = Arc::new(move |summary| {
if summary.maintenance != MaintenanceState::Authenticated {
let mut states = states_copy.lock().unwrap();
states.push((summary.gateway.name().to_owned(), summary.maintenance));
if states.len() == 2 {
ready_copy.notify_one();
}
}
});
let exit = run_owned_sessions(
vec![member("rejected", rejected), member("healthy", healthy)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
async {
ready.notified().await;
SessionEndReason::NetworkChanged
},
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::NetworkChanged));
let states = states.lock().unwrap();
assert!(states.contains(&("rejected".into(), MaintenanceState::Rejected)));
assert!(states.contains(&("healthy".into(), MaintenanceState::Healthy)));
assert_eq!(rejected_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
assert_eq!(healthy_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn observes_reports_only_after_successful_submission() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
response("<response status='success'/>"),
])
.await;
let cancellation = CancellationToken::new();
let submitted = Arc::new(AtomicUsize::new(0));
let observed = submitted.clone();
let stop = cancellation.clone();
let mut callbacks = callbacks();
callbacks.report_submitted = Arc::new(move |request, report| {
assert_eq!(request.client_ip.as_deref(), Some("192.0.2.7"));
assert_eq!(report, "<hip-report/>");
observed.fetch_add(1, Ordering::SeqCst);
stop.cancel();
});
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
cancellation,
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Disconnected);
assert_eq!(submitted.load(Ordering::SeqCst), 1);
assert_eq!(server.await.unwrap().len(), 3);
}
#[tokio::test]
async fn cancelled_collection_is_joined_before_runtime_returns() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let cancellation = CancellationToken::new();
let entered = Arc::new(Notify::new());
let stopped = Arc::new(AtomicBool::new(false));
let mut callbacks = callbacks();
let entered_copy = entered.clone();
let stopped_copy = stopped.clone();
callbacks.produce_report = Arc::new(move |_, control| {
entered_copy.notify_one();
loop {
if let Err(error) = control.check() {
stopped_copy.store(true, Ordering::SeqCst);
return Err(error);
}
std::thread::sleep(Duration::from_millis(10));
}
});
callbacks.report_submitted = Arc::new(|_, _| panic!("Cancelled report must not be observed"));
let stop = cancellation.clone();
let exit = tokio::time::timeout(
Duration::from_secs(2),
run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
cancellation,
async {
entered.notified().await;
stop.cancel();
pending().await
},
),
)
.await
.unwrap()
.unwrap();
assert_eq!(exit, SessionExit::Disconnected);
assert!(stopped.load(Ordering::SeqCst));
assert_eq!(server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn all_rejected_members_are_logged_out_before_terminal_failure() {
let (transport, server) = gateway(vec![
response("<response status='error'><error>Denied</error></response>"),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
callbacks.produce_report = Arc::new(|_, _| panic!("Rejected member cannot collect a report"));
let exit = run_owned_sessions(
vec![member("rejected", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::AllMembersFailed));
assert_eq!(server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn invalid_member_cookie_cancels_and_joins_another_members_collector() {
let arrived = Arc::new(Notify::new());
let release = Arc::new(Notify::new());
let collecting = Arc::new(Notify::new());
let stopped = Arc::new(AtomicBool::new(false));
let (expired, expired_server) = crate::session::transport::tests::gateway_with_first_response_gate(
vec![
response("<response status='error'><error>Invalid authentication cookie</error></response>"),
response("<response status='success'/>"),
],
arrived.clone(),
release.clone(),
)
.await;
let (healthy, healthy_server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
let collecting_copy = collecting.clone();
let stopped_copy = stopped.clone();
callbacks.produce_report = Arc::new(move |request, control| {
assert_eq!(request.gateway.name(), "collecting");
collecting_copy.notify_one();
loop {
if let Err(error) = control.check() {
stopped_copy.store(true, Ordering::SeqCst);
return Err(error);
}
std::thread::sleep(Duration::from_millis(10));
}
});
callbacks.report_submitted = Arc::new(|_, _| panic!("Interrupted collection must not submit"));
let exit = tokio::time::timeout(
Duration::from_secs(2),
run_owned_sessions(
vec![member("expired", expired), member("collecting", healthy)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
async {
arrived.notified().await;
collecting.notified().await;
release.notify_one();
pending().await
},
),
)
.await
.unwrap()
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::InvalidCookie));
assert!(stopped.load(Ordering::SeqCst));
assert_eq!(expired_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
assert_eq!(healthy_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn failed_submission_is_terminal_without_retry_or_observation() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_owned(),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
callbacks.report_submitted = Arc::new(|_, _| panic!("Failed report must not be retained"));
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::AllMembersFailed));
let requests = server.await.unwrap();
assert_eq!(
requests.iter().map(|request| request.0.as_str()).collect::<Vec<_>>(),
[
"/ssl-vpn/hipreportcheck.esp",
"/ssl-vpn/hipreport.esp",
"/ssl-vpn/logout.esp"
]
);
}
#[tokio::test]
async fn schedules_from_send_time_plus_interval_and_server_delay() {
let arrived = Arc::new(Notify::new());
let release = Arc::new(Notify::new());
let (transport, server) = crate::session::transport::tests::gateway_with_first_response_gate(
vec![
response("<response><hip-report-needed>no</hip-report-needed><delay>7</delay></response>"),
response("<response><hip-report-needed>no</hip-report-needed></response>"),
response("<response status='success'/>"),
],
arrived.clone(),
release.clone(),
)
.await;
let cancellation = CancellationToken::new();
let stop = cancellation.clone();
let (sent, mut received) = tokio::sync::mpsc::unbounded_channel();
let mut callbacks = callbacks();
callbacks.status_changed = Arc::new(move |summary| {
if summary.maintenance == MaintenanceState::Healthy {
sent.send(tokio::time::Instant::now()).unwrap();
}
});
let runtime = tokio::spawn(run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::new(10, false).unwrap(),
callbacks,
cancellation,
pending(),
));
arrived.notified().await;
// Simulate three seconds spent waiting for the first response. The interval
// must be anchored before that latency, rather than after completion.
tokio::time::pause();
tokio::time::advance(Duration::from_secs(3)).await;
tokio::time::resume();
release.notify_one();
let first = received.recv().await.unwrap();
tokio::time::pause();
tokio::time::advance(Duration::from_secs(13)).await;
tokio::time::resume();
tokio::time::sleep(Duration::from_millis(20)).await;
assert!(received.try_recv().is_err(), "Server delay must extend the interval");
tokio::time::pause();
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let second = tokio::time::timeout(Duration::from_millis(500), received.recv())
.await
.unwrap()
.unwrap();
let elapsed = second.duration_since(first);
assert!(
elapsed >= Duration::from_millis(13_900) && elapsed < Duration::from_millis(14_500),
"Unexpected anchored interval: {elapsed:?}"
);
stop.cancel();
assert_eq!(runtime.await.unwrap().unwrap(), SessionExit::Disconnected);
assert_eq!(server.await.unwrap().len(), 3);
}
+335
View File
@@ -0,0 +1,335 @@
use std::{net::IpAddr, time::Duration};
use reqwest::{Client, StatusCode, Url, redirect::Policy};
use xmltree::Element;
use crate::{gp_params::GpParams, os_profile::OsProfile, utils::xml::ElementExt};
use super::{GatewayAuthentication, network::GatewayBinding};
const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
pub(crate) const MAX_GATEWAY_RESPONSE_BYTES: usize = 1024 * 1024;
pub const MAX_HIP_REPORT_BYTES: usize = 1024 * 1024;
#[derive(Debug, thiserror::Error)]
pub enum GatewayRequestError {
#[error("Gateway authentication cookie expired")]
InvalidCookie,
#[error("Gateway request failed: {0}")]
Transport(#[from] reqwest::Error),
#[error("Gateway returned HTTP {0}")]
Http(StatusCode),
#[error("Gateway rejected the request")]
Rejected,
#[error("Gateway returned a malformed response")]
MalformedResponse,
#[error("Gateway response exceeds its size limit")]
ResponseTooLarge,
#[error("HIP report is empty, contains NUL, or exceeds its size limit")]
InvalidReport,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HipCheck {
pub report_needed: bool,
pub delay: Duration,
}
/// Authenticated HTTP requests retain the login identity. Non-tunnel maintenance
/// uses a validated physical binding; pre-tunnel cleanup uses ordinary HTTP.
pub struct GatewayTransport {
client: Client,
origin: Url,
authentication: GatewayAuthentication,
profile: OsProfile,
}
impl GatewayTransport {
pub fn new(
server: &str,
authentication: GatewayAuthentication,
params: &GpParams,
binding: Option<&GatewayBinding>,
) -> anyhow::Result<Self> {
let origin = Url::parse(&crate::utils::normalize_server(server)?)?;
let client = match binding {
Some(binding) => bound_client(server, params, binding)?,
None => Client::try_from(params)?,
};
Ok(Self {
client,
origin,
authentication,
profile: params.os_profile().clone(),
})
}
/// The login client already validated and built this transport before issuing
/// authentication. Registering its cleanup context cannot fail afterwards.
pub(crate) fn from_authenticated_login(
client: Client,
origin: Url,
authentication: GatewayAuthentication,
profile: OsProfile,
) -> Self {
Self {
client,
origin,
authentication,
profile,
}
}
pub fn authentication(&self) -> &GatewayAuthentication {
&self.authentication
}
pub fn hip_token(&self) -> String {
hip_token(self.authentication.cookie())
}
pub async fn check_hip(&self, ipv4: Option<IpAddr>, ipv6: Option<IpAddr>) -> Result<HipCheck, GatewayRequestError> {
let mut form = self.hip_form(ipv4, ipv6);
form.push(("md5".into(), self.hip_token()));
parse_hip_check(&self.post("hipreportcheck.esp", &form).await?)
}
pub async fn submit_hip(
&self,
report: &str,
ipv4: Option<IpAddr>,
ipv6: Option<IpAddr>,
) -> Result<(), GatewayRequestError> {
if report.is_empty() || report.len() > MAX_HIP_REPORT_BYTES || report.contains('\0') {
return Err(GatewayRequestError::InvalidReport);
}
let mut form = self.hip_form(ipv4, ipv6);
form.push(("report".into(), report.into()));
self.post("hipreport.esp", &form).await?;
Ok(())
}
pub async fn logout(&self) -> Result<(), GatewayRequestError> {
logout_cookie(&self.client, &self.origin, self.authentication.cookie(), &self.profile).await
}
fn cookie_form(&self) -> Vec<(String, String)> {
url::form_urlencoded::parse(self.authentication.cookie().as_bytes())
.into_owned()
.collect()
}
fn hip_form(&self, ipv4: Option<IpAddr>, ipv6: Option<IpAddr>) -> Vec<(String, String)> {
let mut form = self.cookie_form();
set_form(&mut form, "client-role", "global-protect-full");
set_form(&mut form, "computer", self.profile.computer());
set_form(&mut form, "host-id", self.profile.host_id());
set_form(&mut form, "serialno", self.profile.serialno());
if let Some(ip) = ipv4 {
set_form(&mut form, "client-ip", &ip.to_string());
}
if let Some(ip) = ipv6 {
set_form(&mut form, "client-ipv6", &ip.to_string());
}
form
}
async fn post(&self, endpoint: &str, form: &[(String, String)]) -> Result<Element, GatewayRequestError> {
post(&self.client, &self.origin, endpoint, form).await
}
}
/// Cleanup uses trustworthy issued cookie fields even when execution mode is
/// invalid. It never creates a runnable authentication with a fabricated mode.
pub(crate) async fn logout_cookie(
client: &Client,
origin: &Url,
cookie: &str,
profile: &OsProfile,
) -> Result<(), GatewayRequestError> {
let mut form = url::form_urlencoded::parse(cookie.as_bytes()).into_owned().collect();
set_form(&mut form, "computer", profile.computer());
set_form(&mut form, "clientos", profile.client_os().as_str());
set_form(&mut form, "os-version", profile.os_version());
post(client, origin, "logout.esp", &form).await?;
Ok(())
}
async fn post(
client: &Client,
origin: &Url,
endpoint: &str,
form: &[(String, String)],
) -> Result<Element, GatewayRequestError> {
let mut url = origin.clone();
url.set_path(&format!("/ssl-vpn/{endpoint}"));
let response = client.post(url).form(form).send().await?;
let status = response.status();
let invalid_cookie = status.as_u16() == 512
|| response
.headers()
.get("x-private-pan-globalprotect")
.is_some_and(|value| value == "Invalid authentication cookie");
if invalid_cookie {
return Err(GatewayRequestError::InvalidCookie);
}
if !status.is_success() {
return Err(GatewayRequestError::Http(status));
}
let body = crate::utils::request::read_bounded_response(response, MAX_GATEWAY_RESPONSE_BYTES)
.await
.map_err(|error| match error {
crate::utils::request::ResponseBodyError::Transport(error) => GatewayRequestError::Transport(error),
crate::utils::request::ResponseBodyError::TooLarge => GatewayRequestError::ResponseTooLarge,
})?;
parse_response(&body)
}
pub(crate) fn bound_client(server: &str, params: &GpParams, binding: &GatewayBinding) -> anyhow::Result<Client> {
binding.validate_server(server)?;
let origin = gateway_origin(server)?;
let host = origin
.host_str()
.ok_or_else(|| anyhow::anyhow!("Gateway host is missing"))?;
let builder = params
.client_builder()?
.redirect(Policy::none())
.no_proxy()
.local_address(binding.source().ip())
.resolve(host, binding.endpoint())
.timeout(REQUEST_TIMEOUT);
let builder = bind_interface(builder, binding)?;
Ok(builder.build()?)
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) -> anyhow::Result<reqwest::ClientBuilder> {
Ok(builder.interface(binding.interface()))
}
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) -> anyhow::Result<reqwest::ClientBuilder> {
if let std::net::SocketAddr::V6(source) = binding.source() {
anyhow::ensure!(
source.scope_id() == 0,
"Scoped IPv6 source requires a native socket connector"
);
}
Ok(builder)
}
pub(crate) fn gateway_origin(server: &str) -> anyhow::Result<Url> {
let server = if server.starts_with("https://") {
server.to_owned()
} else {
format!("https://{server}")
};
let origin = Url::parse(&server)?;
anyhow::ensure!(
origin.scheme() == "https"
&& origin.username().is_empty()
&& origin.password().is_none()
&& origin.path() == "/"
&& origin.query().is_none()
&& origin.fragment().is_none(),
"Gateway endpoint must be an HTTPS origin"
);
Ok(origin)
}
fn set_form(form: &mut Vec<(String, String)>, key: &str, value: &str) {
form.retain(|(name, _)| name != key);
form.push((key.into(), value.into()));
}
/// Match gpst.c::build_csd_token without decoding or reordering cookie fields.
pub fn hip_token(cookie: &str) -> String {
let stable = cookie
.split('&')
.filter(|field| {
let key = field.split('=').next().unwrap_or_default();
!matches!(key, "authcookie" | "preferred-ip" | "preferred-ipv6")
})
.collect::<Vec<_>>()
.join("&");
format!("{:x}", md5::compute(stable.as_bytes()))
}
fn parse_response(body: &[u8]) -> Result<Element, GatewayRequestError> {
let text = std::str::from_utf8(body).map_err(|_| GatewayRequestError::MalformedResponse)?;
let lower = text.to_ascii_lowercase();
if lower.contains("<!doctype") || lower.contains("<!entity") {
return Err(GatewayRequestError::MalformedResponse);
}
if let Some(error) = javascript_error(text) {
return Err(error);
}
let root = Element::parse(body).map_err(|_| GatewayRequestError::MalformedResponse)?;
if root.name == "html" {
return Err(
root
.descendant_text("body")
.as_deref()
.and_then(javascript_error)
.unwrap_or(GatewayRequestError::MalformedResponse),
);
}
if root.name == "prelogin-response" && root.child_text("status").as_deref() == Some("Error") {
return Err(message_error(root.child_text("msg").as_deref()));
}
if root.name != "response" {
return Err(GatewayRequestError::MalformedResponse);
}
match root.attr("status") {
Some("error") => Err(message_error(root.child_text("error").as_deref())),
None | Some("success") => Ok(root),
_ => Err(GatewayRequestError::Rejected),
}
}
fn message_error(message: Option<&str>) -> GatewayRequestError {
if message == Some("Invalid authentication cookie") {
GatewayRequestError::InvalidCookie
} else {
GatewayRequestError::Rejected
}
}
fn javascript_error(text: &str) -> Option<GatewayRequestError> {
static ERROR: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
let regex = ERROR.get_or_init(|| {
regex::Regex::new(r#"(?s)^\s*var\s+respStatus\s*=\s*"Error"\s*;\s*var\s+respMsg\s*=\s*("(?:\\.|[^"\\])*")"#)
.expect("valid GlobalProtect error pattern")
});
let captures = regex.captures(text)?;
match serde_json::from_str::<String>(&captures[1]) {
Ok(message) => Some(message_error(Some(&message))),
Err(_) => Some(GatewayRequestError::MalformedResponse),
}
}
fn parse_hip_check(root: &Element) -> Result<HipCheck, GatewayRequestError> {
let report_needed = match root.child_text("hip-report-needed").as_deref() {
Some("yes") => true,
Some("no") => false,
_ => return Err(GatewayRequestError::MalformedResponse),
};
let delay = match root.child_text("delay") {
Some(value) => value
.parse::<u32>()
.map_err(|_| GatewayRequestError::MalformedResponse)?,
None => 0,
};
// Limit this client's supported response delay to one hour. The official
// registry scheduling cap is not evidence of a wire-protocol maximum.
if delay > 3600 {
return Err(GatewayRequestError::MalformedResponse);
}
Ok(HipCheck {
report_needed,
delay: Duration::from_secs(u64::from(delay)),
})
}
#[cfg(test)]
pub(crate) mod tests;
+246
View File
@@ -0,0 +1,246 @@
use super::*;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
task::JoinHandle,
};
pub(crate) async fn gateway(responses: Vec<String>) -> (GatewayTransport, JoinHandle<Vec<(String, String)>>) {
gateway_fixture(responses, None).await
}
pub(crate) async fn login_gateway(responses: Vec<String>) -> (Client, Url, JoinHandle<Vec<(String, String)>>) {
let (transport, server) = gateway(responses).await;
(transport.client, transport.origin, server)
}
pub(crate) async fn gateway_with_first_response_gate(
responses: Vec<String>,
arrived: std::sync::Arc<tokio::sync::Notify>,
release: std::sync::Arc<tokio::sync::Notify>,
) -> (GatewayTransport, JoinHandle<Vec<(String, String)>>) {
gateway_fixture(responses, Some((arrived, release))).await
}
async fn gateway_fixture(
responses: Vec<String>,
gate: Option<(std::sync::Arc<tokio::sync::Notify>, std::sync::Arc<tokio::sync::Notify>)>,
) -> (GatewayTransport, JoinHandle<Vec<(String, String)>>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = Url::parse(&format!("http://{}", listener.local_addr().unwrap())).unwrap();
let server = tokio::spawn(async move {
let mut requests = Vec::new();
for (index, response) in responses.into_iter().enumerate() {
let (mut stream, _) = listener.accept().await.unwrap();
let mut bytes = Vec::new();
let (headers_end, length) = loop {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).await.unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
if let Some(position) = bytes.windows(4).position(|part| part == b"\r\n\r\n") {
let headers = std::str::from_utf8(&bytes[..position]).unwrap();
let length = headers
.lines()
.find_map(|line| {
let (key, value) = line.split_once(':')?;
key
.eq_ignore_ascii_case("content-length")
.then(|| value.trim().parse::<usize>().unwrap())
})
.unwrap();
break (position + 4, length);
}
};
while bytes.len() < headers_end + length {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).await.unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
}
let path = std::str::from_utf8(&bytes[..headers_end])
.unwrap()
.split_whitespace()
.nth(1)
.unwrap()
.to_owned();
let body = String::from_utf8(bytes[headers_end..headers_end + length].to_vec()).unwrap();
requests.push((path, body));
if index == 0
&& let Some((arrived, release)) = &gate
{
arrived.notify_one();
release.notified().await;
}
stream.write_all(response.as_bytes()).await.unwrap();
}
requests
});
let transport = GatewayTransport {
client: Client::builder()
.redirect(Policy::none())
.no_proxy()
.timeout(REQUEST_TIMEOUT)
.build()
.unwrap(),
origin,
authentication: GatewayAuthentication::new(
"authcookie=test-cookie&portal=portal&user=alice&domain=example&computer=test".into(),
"non-tunnel".into(),
)
.unwrap(),
profile: OsProfile::builder(crate::os_profile::ClientOs::Linux)
.computer_name_override("test")
.build(),
};
(transport, server)
}
pub(crate) fn response(body: &str) -> String {
format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
}
#[test]
fn checksum_matches_c_protocol_golden_fixture() {
for volatile in [
"authcookie=test&preferred-ip=192.0.2.1&preferred-ipv6=2001%3Adb8%3A%3A1",
"authcookie=refreshed&preferred-ip=192.0.2.2&preferred-ipv6=2001%3Adb8%3A%3A2",
] {
let cookie =
format!("user=test&{volatile}&persistent-cookie=persistent%2Bcookie&portal=test&domain=test&computer=test");
assert_eq!(hip_token(&cookie), "20f30054f721fd212925866b5778447d");
}
assert_ne!(hip_token("user=alice%20bob"), hip_token("user=alice+bob"));
assert_ne!(hip_token("user=alice&portal=a"), hip_token("portal=a&user=alice"));
}
#[tokio::test]
async fn maintenance_uses_only_hip_and_logout_with_physical_identity() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed><delay>7</delay></response>"),
response("<response status='success'/>"),
response("<response status='success'/>"),
])
.await;
let ipv4 = Some("192.0.2.7".parse().unwrap());
let ipv6 = Some("2001:db8::7".parse().unwrap());
let check = transport.check_hip(ipv4, ipv6).await.unwrap();
assert_eq!(
check,
HipCheck {
report_needed: true,
delay: Duration::from_secs(7)
}
);
transport.submit_hip("<hip-report/>", ipv4, ipv6).await.unwrap();
transport.logout().await.unwrap();
let requests = server.await.unwrap();
assert_eq!(
requests.iter().map(|(path, _)| path.as_str()).collect::<Vec<_>>(),
[
"/ssl-vpn/hipreportcheck.esp",
"/ssl-vpn/hipreport.esp",
"/ssl-vpn/logout.esp"
]
);
let form: std::collections::HashMap<String, String> = serde_urlencoded::from_str(&requests[0].1).unwrap();
assert_eq!(form["authcookie"], "test-cookie");
assert_eq!(form["client-ip"], "192.0.2.7");
assert_eq!(form["client-ipv6"], "2001:db8::7");
assert_eq!(form["md5"], transport.hip_token());
}
#[tokio::test]
async fn rejects_redirects_without_forwarding_authentication() {
let destination = TcpListener::bind("127.0.0.1:0").await.unwrap();
let (transport, server) = gateway(vec![format!(
"HTTP/1.1 307 Temporary Redirect\r\nLocation: http://{}/stolen\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
destination.local_addr().unwrap()
)])
.await;
assert!(
matches!(transport.check_hip(None, None).await, Err(GatewayRequestError::Http(status)) if status.as_u16() == 307)
);
assert!(
tokio::time::timeout(Duration::from_millis(100), destination.accept())
.await
.is_err()
);
assert_eq!(server.await.unwrap().len(), 1);
}
#[tokio::test]
async fn distinguishes_expired_cookie_from_transport_and_protocol_errors() {
let (transport, server) = gateway(vec![
response("<response status='error'><error>Invalid authentication cookie</error></response>"),
"HTTP/1.1 512 Invalid Cookie\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(),
"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(),
response("<response><hip-report-needed>maybe</hip-report-needed></response>"),
response("<response status='error'><error>server-private-payload</error></response>"),
])
.await;
for _ in 0..2 {
assert!(matches!(
transport.check_hip(None, None).await,
Err(GatewayRequestError::InvalidCookie)
));
}
assert!(matches!(
transport.check_hip(None, None).await.unwrap_err(),
GatewayRequestError::Http(StatusCode::SERVICE_UNAVAILABLE)
));
assert!(matches!(
transport.check_hip(None, None).await,
Err(GatewayRequestError::MalformedResponse)
));
let error = transport.check_hip(None, None).await.unwrap_err();
assert!(!format!("{error:?}").contains("server-private-payload"));
server.await.unwrap();
}
#[tokio::test]
async fn bounds_response_size_before_reading_body() {
let (transport, server) = gateway(vec![format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
MAX_GATEWAY_RESPONSE_BYTES + 1
)])
.await;
assert!(matches!(
transport.check_hip(None, None).await,
Err(GatewayRequestError::ResponseTooLarge)
));
server.await.unwrap();
}
#[test]
fn rejects_invalid_delays_and_unsafe_response_xml() {
for delay in ["-1", "3601", "4294967296", "invalid"] {
let root = parse_response(
format!("<response><hip-report-needed>no</hip-report-needed><delay>{delay}</delay></response>").as_bytes(),
)
.unwrap();
assert!(parse_hip_check(&root).is_err());
}
assert!(parse_response(b"<!DOCTYPE response><response/>").is_err());
}
#[test]
fn recognizes_cookie_expiry_in_official_error_formats() {
for body in [
r#"var respStatus = "Error"; var respMsg = "Invalid authentication\u0020cookie"; thisForm.inputStr.value = "";"#,
r#"<html><head/><body>var respStatus = "Error"; var respMsg = "Invalid authentication cookie";</body></html>"#,
"<prelogin-response><status>Error</status><msg>Invalid authentication cookie</msg></prelogin-response>",
] {
assert!(matches!(
parse_response(body.as_bytes()),
Err(GatewayRequestError::InvalidCookie)
));
}
assert!(matches!(
parse_response(b"<response status='error'><error>Denied</error></response>"),
Err(GatewayRequestError::Rejected)
));
}