Files
GlobalProtect-openconnect/apps/gpservice/src/vpn_task/preparation.rs
T

256 lines
9.4 KiB
Rust

use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::{
collection::{CollectionBudget, CollectionControl},
gp_params::GpParams,
os_profile::OsProfile,
service::request::ConnectRequest,
session::{
desktop::GatewaySession, desktop::GatewaySessions, desktop::network::PhysicalNetwork, transport::GatewayTransport,
},
};
use tokio_util::sync::CancellationToken;
pub(crate) struct PreparedConnection {
pub(super) request: ConnectRequest,
pub(super) resources: Arc<ConnectionResources>,
pub(super) sessions: GatewaySessions,
}
pub(super) struct ConnectionResources {
pub profile: OsProfile,
pub identity: Option<gpapi::utils::request::ClientIdentity>,
pub identity_files: Option<gpapi::utils::request::ClientIdentityFiles>,
pub network: Option<PhysicalNetwork>,
}
/// Preparation sends no authenticated gateway requests. Rejection leaves the
/// authentication owner responsible for logout; only queued admission transfers
/// the complete ledger and its retained identity resources to the service.
pub(crate) async fn prepare_connection(
request: ConnectRequest,
restricted_desktop: bool,
cancellation: CancellationToken,
) -> anyhow::Result<PreparedConnection> {
let mode = request.args().packet_delivery().clone();
let request = request.with_packet_delivery(mode);
let args = request.args();
if let gpapi::script_tun::PacketDelivery::ScriptTun(consumer) = args.packet_delivery() {
consumer.validate()?;
anyhow::ensure!(
request.plan().members().len() == 1
&& request.plan().members()[0].authentication.mode() == gpapi::session::SessionMode::Tunnel,
"Script-tun requires a tunnel gateway"
);
}
let non_tunnel = request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel);
anyhow::ensure!(
non_tunnel || request.plan().members().len() == 1,
"Only one selected tunnel gateway can execute"
);
for member in request.plan().members() {
if non_tunnel {
let binding = member.binding.as_ref().context("Internal gateway binding is missing")?;
anyhow::ensure!(
!args.disable_ipv6() || (binding.endpoint().is_ipv4() && binding.addresses().ipv6.is_none()),
"IPv6 gateway transport or identity is disabled"
);
}
}
let setup_request = request.clone();
let setup_cancel = cancellation.clone();
let resources = tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if setup_cancel.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"Connection preparation cancelled",
));
}
budget.check()
};
check()?;
let args = setup_request.args();
let identity = super::prepare_identity(args, restricted_desktop || non_tunnel)?;
#[cfg(target_os = "macos")]
let directory = restricted_desktop.then(|| std::path::PathBuf::from("/var/run/com.yuezk.gpgui"));
#[cfg(windows)]
let directory = Some(common::paths::service_private_dir());
#[cfg(all(unix, not(target_os = "macos")))]
let directory: Option<std::path::PathBuf> = None;
let identity_files = identity
.as_ref()
.map(|identity| identity.write_files(directory.as_deref()))
.transpose()?;
let host = args.host_identity().context("Authenticated host identity is missing")?;
let profile = crate::hip_source::profile(
host,
args.os().context("Authenticated client OS is missing")?,
args.client_version(),
args.os_version(),
args.host_id(),
args.local_hostname(),
&check,
)?;
let network = if non_tunnel {
Some(PhysicalNetwork::capture(&check)?)
} else {
None
};
check()?;
Ok::<_, anyhow::Error>(Arc::new(ConnectionResources {
profile,
identity,
identity_files,
network,
}))
})
.await??;
let args = request.args();
let mut builder = GpParams::builder(resources.profile.clone());
builder
.ignore_tls_errors(args.ignore_tls_errors())
.client_identity(resources.identity.clone());
let params = builder.build();
let mut sessions = Vec::new();
for member in request.plan().members() {
let binding = if non_tunnel {
Some(member.binding.as_ref().context("Internal gateway binding is missing")?)
} else {
None
};
if let Some(network) = &resources.network {
network
.validate_internal_binding(
binding.context("Internal gateway binding is missing")?,
request.plan().internal_detection(),
&cancellation,
)
.await?;
}
let transport = GatewayTransport::new(member.gateway.server(), member.authentication.clone(), &params, binding)?;
sessions.push(GatewaySession {
gateway: member.gateway.clone(),
transport,
addresses: binding.map(|binding| binding.addresses()).unwrap_or_default(),
});
}
if let Some(network) = &resources.network {
network.ensure_current(&cancellation).await?;
}
Ok(PreparedConnection {
request,
resources,
sessions: GatewaySessions::new(sessions),
})
}
#[cfg(test)]
impl PreparedConnection {
/// Lifecycle-only fixtures own no issued server sessions. Protocol ownership
/// checks use actual gateway transports rather than this actor-state fixture.
pub(crate) fn lifecycle_fixture(request: ConnectRequest) -> Self {
let profile = gpapi::os_profile::desktop::collect_profile(
OsProfile::builder(gpapi::os_profile::ClientOs::Linux).host_identity(
gpapi::os_profile::desktop::identity_from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
),
),
None,
);
Self {
request,
resources: Arc::new(ConnectionResources {
profile,
identity: None,
identity_files: None,
network: None,
}),
sessions: GatewaySessions::new(vec![]),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::{gateway::Gateway, service::vpn_state::ConnectInfo};
#[tokio::test]
async fn restricted_desktop_and_non_tunnel_identity_reject_path_handoff() {
for (restricted_desktop, non_tunnel) in [(true, false), (false, true), (true, true)] {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_certificate(Some("/identity.pem".into()));
let mut wire = serde_json::to_value(request).unwrap();
if non_tunnel {
wire["plan"]["members"][0]["gateway"]["kind"] = serde_json::json!("internal");
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
}
let request = serde_json::from_value(wire).unwrap();
let error = prepare_connection(request, restricted_desktop, CancellationToken::new())
.await
.err()
.unwrap();
assert_eq!(error.to_string(), "Client identity must be a protected snapshot");
}
}
#[tokio::test]
async fn disabled_ipv6_rejects_ipv6_report_identity_before_setup() {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_disable_ipv6(true);
let mut wire = serde_json::to_value(request).unwrap();
wire["plan"]["members"][0]["gateway"]["kind"] = serde_json::json!("internal");
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
wire["plan"]["members"][0]["binding"]["addresses"]["ipv6"] = serde_json::json!("2001:db8::5");
let request: ConnectRequest = serde_json::from_value(wire).unwrap();
// The fixture has no host identity or usable physical interface. Policy
// rejection must happen before those collectors or transport setup run.
let error = prepare_connection(request, false, CancellationToken::new())
.await
.err()
.unwrap();
assert_eq!(error.to_string(), "IPv6 gateway transport or identity is disabled");
}
#[tokio::test]
async fn ordinary_tunnel_preparation_needs_no_physical_binding_or_resolver() {
let gateway = Gateway::new("fixture".into(), "does-not-resolve.invalid".into());
let profile = gpapi::os_profile::desktop::collect_profile(
OsProfile::builder(gpapi::os_profile::ClientOs::Linux).host_identity(
gpapi::os_profile::desktop::identity_from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
),
),
None,
);
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_os_profile(&profile)
.with_disable_ipv6(true);
let mut wire = serde_json::to_value(request).unwrap();
wire["plan"]["members"][0]["binding"] = serde_json::Value::Null;
let request: ConnectRequest = serde_json::from_value(wire).unwrap();
let prepared = prepare_connection(request, false, CancellationToken::new())
.await
.unwrap();
assert!(prepared.resources.network.is_none());
assert_eq!(prepared.sessions.members().len(), 1);
assert!(prepared.sessions.members()[0].addresses.ipv4.is_none());
assert!(prepared.sessions.members()[0].addresses.ipv6.is_none());
}
}