mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
feat: support internal non-tunnel gateway sessions
This commit is contained in:
58 files changed
+7897
-949
No files matched your search
@@ -18,6 +18,7 @@ env_logger.workspace = true
|
||||
inquire = "0.9"
|
||||
log.workspace = true
|
||||
tokio = { workspace = true, features = ["rt-multi-thread"] }
|
||||
tokio-util.workspace = true
|
||||
sysinfo.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
|
||||
@@ -50,6 +50,21 @@ enum CliCommand {
|
||||
LaunchGui(LaunchGuiArgs),
|
||||
#[command(about = "Generate HIP report")]
|
||||
Hip(HipArgs),
|
||||
#[command(hide = true)]
|
||||
DetectInternalHost {
|
||||
#[arg(long)]
|
||||
address: std::net::IpAddr,
|
||||
#[arg(long)]
|
||||
hostname: String,
|
||||
},
|
||||
#[command(hide = true)]
|
||||
ResolveGateway {
|
||||
host: String,
|
||||
#[arg(long, default_value_t = 443)]
|
||||
port: u16,
|
||||
#[arg(long)]
|
||||
disable_ipv6: bool,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Parser)]
|
||||
@@ -118,10 +133,9 @@ impl Args for Cli {
|
||||
impl Cli {
|
||||
fn can_run_alongside_client(&self) -> bool {
|
||||
match &self.command {
|
||||
CliCommand::Disconnect(_) => true,
|
||||
CliCommand::Hip(_) => true,
|
||||
CliCommand::Connect(_) => false,
|
||||
CliCommand::LaunchGui(args) => args.is_auth_callback(),
|
||||
_ => false,
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -179,6 +193,20 @@ impl Cli {
|
||||
CliCommand::Disconnect(args) => DisconnectHandler::new(args, shared_args.lock_file).handle().await,
|
||||
CliCommand::LaunchGui(args) => LaunchGuiHandler::new(args).handle().await,
|
||||
CliCommand::Hip(args) => HipHandler::new(args).handle().await,
|
||||
CliCommand::DetectInternalHost { address, hostname } => {
|
||||
let internal = gpapi::session::network::native::detect_in_helper(*address, hostname)?;
|
||||
println!("{}", serde_json::to_string(&internal)?);
|
||||
Ok(())
|
||||
}
|
||||
CliCommand::ResolveGateway {
|
||||
host,
|
||||
port,
|
||||
disable_ipv6,
|
||||
} => {
|
||||
let addresses = gpapi::session::network::native::lookup_in_helper(host, *port, *disable_ipv6)?;
|
||||
println!("{}", serde_json::to_string(&addresses)?);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -220,6 +248,23 @@ mod tests {
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn resolver_helper_runs_alongside_client_and_is_hidden_from_help() {
|
||||
let cli = Cli::try_parse_from([
|
||||
"gpclient",
|
||||
"resolve-gateway",
|
||||
"localhost",
|
||||
"--port",
|
||||
"444",
|
||||
"--disable-ipv6",
|
||||
])
|
||||
.unwrap();
|
||||
assert!(cli.can_run_alongside_client());
|
||||
use clap::CommandFactory;
|
||||
let help = Cli::command().render_help().to_string();
|
||||
assert!(!help.contains("resolve-gateway"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lock_file_defaults_to_standard_path() {
|
||||
let cli = Cli::try_parse_from(["gpclient", "connect", "portal.example.com"]).expect("cli should parse");
|
||||
|
||||
@@ -116,7 +116,8 @@ impl ConnectHandler<'_> {
|
||||
.clean(clean_auth)
|
||||
.default_browser(use_default_browser);
|
||||
|
||||
let cred = auth_launcher.launch().await?;
|
||||
let cred = auth_launcher.cancellation(&self.cancellation).launch().await?;
|
||||
self.check_cancelled()?;
|
||||
Ok(cred)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
use std::time::Duration;
|
||||
|
||||
use clap::Parser;
|
||||
use gpapi::{
|
||||
cookie_store::{self, StoredCookie},
|
||||
credential::AuthCookieCredential,
|
||||
gateway::{Gateway, GatewayLoginContext, GatewaySelection},
|
||||
log_format::LogFormat,
|
||||
session::SessionMode,
|
||||
};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
|
||||
use super::{ConnectArgs, ConnectHandler};
|
||||
use crate::cli::SharedArgs;
|
||||
|
||||
#[derive(Parser)]
|
||||
struct TestArgs {
|
||||
#[command(flatten)]
|
||||
connect: ConnectArgs,
|
||||
}
|
||||
|
||||
fn login_response() -> String {
|
||||
let mut fields = [""; 20];
|
||||
fields[1] = "issued-cookie";
|
||||
fields[3] = "gateway";
|
||||
fields[4] = "alice";
|
||||
fields[5] = "fixture-auth";
|
||||
fields[6] = "vsys1";
|
||||
fields[12] = "tunnel";
|
||||
format!(
|
||||
"<jnlp><application-desc>{}</application-desc></jnlp>",
|
||||
fields
|
||||
.iter()
|
||||
.map(|field| format!("<argument>{field}</argument>"))
|
||||
.collect::<String>()
|
||||
)
|
||||
}
|
||||
|
||||
async fn gateway(responses: Vec<(&'static str, String)>) -> (String, tokio::task::JoinHandle<Vec<String>>) {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let origin = format!("http://{}", listener.local_addr().unwrap());
|
||||
let worker = tokio::spawn(async move {
|
||||
tokio::time::timeout(Duration::from_secs(5), async move {
|
||||
let mut requests = Vec::new();
|
||||
for (status, body) in responses {
|
||||
let (mut stream, _) = listener.accept().await.unwrap();
|
||||
let mut request = Vec::new();
|
||||
loop {
|
||||
let mut buf = [0; 4096];
|
||||
let count = stream.read(&mut buf).await.unwrap();
|
||||
assert_ne!(count, 0, "Request ended before its body");
|
||||
request.extend_from_slice(&buf[..count]);
|
||||
if let Some(end) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") {
|
||||
let headers = String::from_utf8_lossy(&request[..end]).to_ascii_lowercase();
|
||||
let length = headers
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix("content-length:"))
|
||||
.map(|value| value.trim().parse::<usize>().unwrap())
|
||||
.unwrap_or(0);
|
||||
if request.len() >= end + 4 + length {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
requests.push(String::from_utf8(request).unwrap());
|
||||
stream
|
||||
.write_all(
|
||||
format!(
|
||||
"HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
body.len()
|
||||
)
|
||||
.as_bytes(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
requests
|
||||
})
|
||||
.await
|
||||
.expect("Gateway fixture timed out")
|
||||
});
|
||||
(origin, worker)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cached_tunnel_authentication_does_not_require_portal_discovery() {
|
||||
let (gateway, worker) = gateway(vec![("200 OK", login_response())]).await;
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let cache = directory.path().join("cookie.json");
|
||||
let args = TestArgs::parse_from([
|
||||
"test",
|
||||
"http://unavailable-portal.invalid",
|
||||
"--cookie-only",
|
||||
"--cookie-cache",
|
||||
cache.to_str().unwrap(),
|
||||
])
|
||||
.connect;
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
verbose: &verbose,
|
||||
log_format: LogFormat::Text,
|
||||
};
|
||||
let handler = ConnectHandler::new(&args, &shared);
|
||||
cookie_store::save(
|
||||
&cache,
|
||||
&StoredCookie::new(
|
||||
args.server.clone(),
|
||||
"alice".into(),
|
||||
handler.os_profile.borrow().host_identity().host_id().into(),
|
||||
gateway,
|
||||
AuthCookieCredential::new("alice", "portal-cookie", ""),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
handler.handle_impl().await.unwrap();
|
||||
let requests = worker.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].starts_with("POST /ssl-vpn/login.esp "));
|
||||
assert!(requests[0].contains("portal-cookie"));
|
||||
assert_eq!(
|
||||
handler.sessions.borrow().members()[0].transport.authentication().mode(),
|
||||
SessionMode::Tunnel
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_rejection() {
|
||||
let (origin, worker) = gateway(vec![
|
||||
(
|
||||
"200 OK",
|
||||
"<prelogin-response><status>Success</status></prelogin-response>".into(),
|
||||
),
|
||||
("403 Forbidden", "<response><error>rejected</error></response>".into()),
|
||||
("200 OK", login_response()),
|
||||
])
|
||||
.await;
|
||||
let args = TestArgs::parse_from(["test", &origin, "--user", "alice", "--passwd-on-stdin"]).connect;
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
verbose: &verbose,
|
||||
log_format: LogFormat::Text,
|
||||
};
|
||||
let handler = ConnectHandler::new(&args, &shared);
|
||||
handler.password_from_stdin.replace(Some("gateway-password".into()));
|
||||
let mut value = serde_json::to_value(Gateway::new("internal".into(), origin.clone())).unwrap();
|
||||
value["kind"] = serde_json::json!("internal");
|
||||
let gateway: Gateway = serde_json::from_value(value).unwrap();
|
||||
let session = handler
|
||||
.authenticate_gateway(
|
||||
&origin,
|
||||
&origin,
|
||||
&AuthCookieCredential::new("alice", "rejected-cookie", ""),
|
||||
false,
|
||||
GatewayLoginContext::new(&gateway, GatewaySelection::Auto),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(session.authentication.mode(), SessionMode::Tunnel);
|
||||
assert!(session.extension_auth.binding().is_none());
|
||||
let requests = worker.await.unwrap();
|
||||
assert_eq!(requests.len(), 3);
|
||||
assert!(requests[1].contains("rejected-cookie"));
|
||||
assert!(requests[2].contains("gateway-password"));
|
||||
}
|
||||
@@ -11,12 +11,12 @@ use gpapi::{
|
||||
clap::report,
|
||||
cookie_store,
|
||||
credential::{AuthCookieCredential, Credential},
|
||||
gateway::{GatewayLogin, GatewayLoginContext, SessionExtensionAuth, gateway_login, gateway_login_with_context},
|
||||
gateway::{Gateway, GatewayLogin, GatewayLoginClient, GatewayLoginContext, GatewaySelection, SessionExtensionAuth},
|
||||
gp_params::GpParams,
|
||||
os_profile::OsProfile,
|
||||
portal::prelogin,
|
||||
portal::{PortalConfig, prelogin},
|
||||
process::users::get_user_by_name,
|
||||
utils::shutdown_signal,
|
||||
session::{GatewayAuthentication, SessionMode},
|
||||
};
|
||||
use inquire::Text;
|
||||
use log::{Level, info, warn};
|
||||
@@ -31,15 +31,15 @@ use super::{ConnectHandler, args::cookie_cache_path};
|
||||
|
||||
const OPENCONNECT_INTERRUPTED_EXIT_CODE: i32 = -4;
|
||||
|
||||
struct GatewayLoginSession {
|
||||
cookie: String,
|
||||
extension_auth: SessionExtensionAuth,
|
||||
pub(super) struct GatewayLoginSession {
|
||||
pub(super) authentication: GatewayAuthentication,
|
||||
pub(super) extension_auth: SessionExtensionAuth,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum GatewayConnectFailureStage {
|
||||
BeforeTunnel,
|
||||
AfterTunnel,
|
||||
BeforeEstablishment,
|
||||
AfterEstablishment,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -49,22 +49,22 @@ pub(super) struct GatewayConnectError {
|
||||
}
|
||||
|
||||
impl GatewayConnectError {
|
||||
fn before_tunnel(error: anyhow::Error) -> Self {
|
||||
fn before_establishment(error: anyhow::Error) -> Self {
|
||||
Self {
|
||||
stage: GatewayConnectFailureStage::BeforeTunnel,
|
||||
stage: GatewayConnectFailureStage::BeforeEstablishment,
|
||||
error,
|
||||
}
|
||||
}
|
||||
|
||||
fn after_tunnel(error: anyhow::Error) -> Self {
|
||||
fn after_establishment(error: anyhow::Error) -> Self {
|
||||
Self {
|
||||
stage: GatewayConnectFailureStage::AfterTunnel,
|
||||
stage: GatewayConnectFailureStage::AfterEstablishment,
|
||||
error,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_before_tunnel(&self) -> bool {
|
||||
self.stage == GatewayConnectFailureStage::BeforeTunnel
|
||||
pub(super) fn is_before_establishment(&self) -> bool {
|
||||
self.stage == GatewayConnectFailureStage::BeforeEstablishment
|
||||
}
|
||||
|
||||
pub(super) fn as_error(&self) -> &anyhow::Error {
|
||||
@@ -77,59 +77,81 @@ impl GatewayConnectError {
|
||||
}
|
||||
|
||||
impl ConnectHandler<'_> {
|
||||
pub(super) async fn try_cached_cookie(&self, server: &str) -> Option<()> {
|
||||
pub(super) async fn try_cached_cookie(&self, server: &str) -> Option<anyhow::Result<()>> {
|
||||
let path = cookie_cache_path(self.args)?;
|
||||
let host_id = self.os_profile.borrow().host_identity().host_id().to_string();
|
||||
let stored = cookie_store::load(&path, server, &host_id)?;
|
||||
|
||||
if !stored.auth_cookie.can_authenticate_gateway() {
|
||||
warn!(
|
||||
"Cached portal cookie for {} is not usable for gateway authentication. Clearing cache.",
|
||||
stored.server
|
||||
);
|
||||
cookie_store::clear(&path);
|
||||
return None;
|
||||
}
|
||||
|
||||
info!(
|
||||
"Using cached portal cookie for {} (saved_at={}, gateway={})",
|
||||
stored.server, stored.saved_at, stored.last_gateway
|
||||
);
|
||||
|
||||
let cred: Credential = (&stored.auth_cookie).into();
|
||||
let mut gp_params = self.build_gp_params();
|
||||
gp_params.set_is_gateway(true);
|
||||
|
||||
let login_session = match self.login_gateway(&stored.last_gateway, &cred, &gp_params, None).await {
|
||||
let credential = (&stored.auth_cookie).into();
|
||||
let mut params = self.build_gp_params();
|
||||
params.set_is_gateway(true);
|
||||
let session = match self
|
||||
.login_gateway(&stored.last_gateway, &credential, ¶ms, None)
|
||||
.await
|
||||
{
|
||||
Ok(session) => session,
|
||||
Err(err) => {
|
||||
warn!(
|
||||
"Cached portal cookie rejected by gateway {}: {}. Clearing cache and falling back to portal auth.",
|
||||
stored.last_gateway, err
|
||||
);
|
||||
Err(error) => {
|
||||
if self.cancellation.is_cancelled()
|
||||
|| error
|
||||
.downcast_ref::<gpapi::gateway::GatewayLoginProtocolError>()
|
||||
.is_some()
|
||||
{
|
||||
return Some(Err(error));
|
||||
}
|
||||
cookie_store::clear(&path);
|
||||
warn!("Cached gateway authentication failed: {error}");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
match self
|
||||
if session.authentication.mode() == SessionMode::NonTunnel && !self.args.cookie_only {
|
||||
self.logout_gateway(&stored.last_gateway).await;
|
||||
info!("Cached non-tunnel login requires fresh portal discovery");
|
||||
return None;
|
||||
}
|
||||
let result = self
|
||||
.connect_gateway(
|
||||
server,
|
||||
&stored.last_gateway,
|
||||
&login_session.cookie,
|
||||
&session.authentication,
|
||||
false,
|
||||
login_session.extension_auth,
|
||||
session.extension_auth,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(()) => Some(()),
|
||||
Err(err) => {
|
||||
warn!("Gateway connect failed after cached-cookie login: {}", err.as_error());
|
||||
.await;
|
||||
match result {
|
||||
Ok(()) => Some(Ok(())),
|
||||
Err(error) if self.cancellation.is_cancelled() => Some(Err(error.into_error())),
|
||||
Err(error) => {
|
||||
self.logout_gateway(&stored.last_gateway).await;
|
||||
warn!("Cached gateway connection failed: {}", error.as_error());
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn cached_portal_credential(&self, server: &str) -> Option<Credential> {
|
||||
if self.args.cookie_on_stdin {
|
||||
return None;
|
||||
}
|
||||
let path = cookie_cache_path(self.args)?;
|
||||
let host_id = self.os_profile.borrow().host_identity().host_id().to_string();
|
||||
let stored = cookie_store::load(&path, server, &host_id)?;
|
||||
if !stored.auth_cookie.can_authenticate_gateway() {
|
||||
cookie_store::clear(&path);
|
||||
return None;
|
||||
}
|
||||
info!("Using cached credential for fresh portal discovery");
|
||||
Some((&stored.auth_cookie).into())
|
||||
}
|
||||
|
||||
pub(super) fn clear_cookie_cache(&self) {
|
||||
if let Some(path) = cookie_cache_path(self.args) {
|
||||
cookie_store::clear(&path);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn connect_gateway_with_prelogin(
|
||||
&self,
|
||||
portal: &str,
|
||||
@@ -143,7 +165,11 @@ impl ConnectHandler<'_> {
|
||||
gp_params.set_is_gateway(true);
|
||||
|
||||
let gateway_browser_auth_allowed = true;
|
||||
let prelogin = prelogin(gateway, &gp_params, self.direct_gateway_prelogin_options()).await?;
|
||||
let prelogin = tokio::select! {
|
||||
biased;
|
||||
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
|
||||
result = prelogin(gateway, &gp_params, self.direct_gateway_prelogin_options()) => result?,
|
||||
};
|
||||
let cred = self
|
||||
.obtain_credential(&prelogin, gateway, gateway_browser_auth_allowed)
|
||||
.await?;
|
||||
@@ -156,7 +182,7 @@ impl ConnectHandler<'_> {
|
||||
.connect_gateway(
|
||||
portal,
|
||||
gateway,
|
||||
&login_session.cookie,
|
||||
&login_session.authentication,
|
||||
allow_extend_session,
|
||||
login_session.extension_auth,
|
||||
)
|
||||
@@ -164,94 +190,101 @@ impl ConnectHandler<'_> {
|
||||
.map_err(GatewayConnectError::into_error)
|
||||
}
|
||||
|
||||
/// Connect to a gateway using the official client's auth flow:
|
||||
///
|
||||
/// 1. Call gateway prelogin and retain the response (SAML data is held as a fallback).
|
||||
/// 2. If the portal provided auth cookies, attempt gateway login using them.
|
||||
/// 3. If that login succeeds, proceed directly to the VPN connection.
|
||||
/// 4. If no portal auth cookies exist or portal-cookie login fails, use the retained gateway prelogin response to authenticate
|
||||
/// against the gateway (SAML or username/password) and obtain a gateway-issued
|
||||
/// credential.
|
||||
/// 5. Retry gateway login with the gateway credential (now carrying the gateway's
|
||||
/// `prelogin-cookie`) and connect on success.
|
||||
pub(super) async fn connect_gateway_with_fallback(
|
||||
&self,
|
||||
portal: &str,
|
||||
gateway: &Gateway,
|
||||
portal_cred: &AuthCookieCredential,
|
||||
config: &PortalConfig,
|
||||
selection: GatewaySelection,
|
||||
remaining: &[&Gateway],
|
||||
) -> Result<(), GatewayConnectError> {
|
||||
let session = self
|
||||
.authenticate_gateway(
|
||||
portal,
|
||||
gateway.server(),
|
||||
portal_cred,
|
||||
config.default_browser().unwrap_or(false),
|
||||
GatewayLoginContext::new(gateway, selection).with_connect_method(config.connect_method()),
|
||||
)
|
||||
.await
|
||||
.map_err(GatewayConnectError::before_establishment)?;
|
||||
if !self.args.cookie_only && session.authentication.mode() == SessionMode::NonTunnel {
|
||||
if gateway.kind() != gpapi::gateway::GatewayKind::Internal {
|
||||
return Err(GatewayConnectError::after_establishment(anyhow::anyhow!(
|
||||
"Non-tunnel authentication requires freshly discovered internal gateways"
|
||||
)));
|
||||
}
|
||||
return self
|
||||
.connect_internal_gateways(portal, config, portal_cred, gateway, session, remaining)
|
||||
.await
|
||||
.map_err(GatewayConnectError::after_establishment);
|
||||
}
|
||||
self
|
||||
.connect_gateway(
|
||||
portal,
|
||||
gateway.server(),
|
||||
&session.authentication,
|
||||
config.allow_extend_session().unwrap_or(false),
|
||||
session.extension_auth,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
pub(super) async fn authenticate_gateway(
|
||||
&self,
|
||||
portal: &str,
|
||||
gateway: &str,
|
||||
portal_cred: &AuthCookieCredential,
|
||||
allow_extend_session: bool,
|
||||
portal_config_default_browser: bool,
|
||||
gateway_context: GatewayLoginContext,
|
||||
) -> Result<(), GatewayConnectError> {
|
||||
info!("Connecting to gateway with portal-cookie first, gateway prelogin fallback...");
|
||||
|
||||
) -> anyhow::Result<GatewayLoginSession> {
|
||||
self.check_cancelled()?;
|
||||
let mut gp_params = self.build_gp_params();
|
||||
gp_params.set_is_gateway(true);
|
||||
let gateway_browser_auth_allowed = self.gateway_browser_auth_allowed(portal_config_default_browser);
|
||||
|
||||
let gateway_prelogin = prelogin(gateway, &gp_params, self.prelogin_options(gateway_browser_auth_allowed))
|
||||
.await
|
||||
.map_err(GatewayConnectError::before_tunnel)?;
|
||||
let browser_allowed = self.gateway_browser_auth_allowed(portal_config_default_browser);
|
||||
let gateway_prelogin = tokio::select! {
|
||||
biased;
|
||||
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
|
||||
result = prelogin(gateway, &gp_params, self.prelogin_options(browser_allowed)) => result?,
|
||||
};
|
||||
self.check_cancelled()?;
|
||||
|
||||
if portal_cred.can_authenticate_gateway() {
|
||||
let portal_cred_for_login: Credential = portal_cred.into();
|
||||
let credential: Credential = portal_cred.into();
|
||||
match self
|
||||
.login_gateway(gateway, &portal_cred_for_login, &gp_params, Some(&gateway_context))
|
||||
.login_gateway(gateway, &credential, &gp_params, Some(&gateway_context))
|
||||
.await
|
||||
{
|
||||
Ok(login_session) => {
|
||||
info!("Gateway login with portal auth cookies succeeded");
|
||||
Ok(session) => {
|
||||
self.save_cookie_cache(portal, gateway, portal_cred);
|
||||
return self
|
||||
.connect_gateway(
|
||||
portal,
|
||||
gateway,
|
||||
&login_session.cookie,
|
||||
allow_extend_session,
|
||||
login_session.extension_auth,
|
||||
)
|
||||
.await;
|
||||
return Ok(session);
|
||||
}
|
||||
Err(err) => {
|
||||
info!("Gateway login with portal auth cookies failed: {}", err);
|
||||
info!("Falling back to gateway prelogin authentication...");
|
||||
Err(error) => {
|
||||
self.check_cancelled()?;
|
||||
if error
|
||||
.downcast_ref::<gpapi::gateway::GatewayLoginProtocolError>()
|
||||
.is_some()
|
||||
{
|
||||
return Err(error);
|
||||
}
|
||||
info!("Portal cookie login failed; using gateway prelogin authentication: {error}");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
info!("Portal config did not provide gateway auth cookies; using gateway prelogin flow");
|
||||
}
|
||||
|
||||
let gateway_cred = match self
|
||||
.obtain_credential(&gateway_prelogin, gateway, gateway_browser_auth_allowed)
|
||||
.await
|
||||
{
|
||||
Ok(cred) => cred,
|
||||
Err(err) => {
|
||||
self.print_direct_gateway_recommendation(gateway);
|
||||
return Err(GatewayConnectError::before_tunnel(err));
|
||||
}
|
||||
};
|
||||
|
||||
let login_session = match self
|
||||
.login_gateway(gateway, &gateway_cred, &gp_params, Some(&gateway_context))
|
||||
.await
|
||||
{
|
||||
Ok(login_session) => login_session,
|
||||
Err(err) => {
|
||||
self.print_direct_gateway_recommendation(gateway);
|
||||
return Err(GatewayConnectError::before_tunnel(err));
|
||||
}
|
||||
};
|
||||
|
||||
self
|
||||
.connect_gateway(
|
||||
portal,
|
||||
gateway,
|
||||
&login_session.cookie,
|
||||
allow_extend_session,
|
||||
login_session.extension_auth,
|
||||
)
|
||||
let credential = self
|
||||
.obtain_credential(&gateway_prelogin, gateway, browser_allowed)
|
||||
.await
|
||||
.inspect_err(|_| self.print_direct_gateway_recommendation(gateway))?;
|
||||
self.check_cancelled()?;
|
||||
let result = self
|
||||
.login_gateway(gateway, &credential, &gp_params, Some(&gateway_context))
|
||||
.await;
|
||||
if result.is_err() {
|
||||
self.print_direct_gateway_recommendation(gateway);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn save_cookie_cache(&self, portal: &str, gateway: &str, auth_cookie: &AuthCookieCredential) {
|
||||
@@ -308,24 +341,39 @@ impl ConnectHandler<'_> {
|
||||
gateway_context: Option<&GatewayLoginContext>,
|
||||
) -> anyhow::Result<GatewayLoginSession> {
|
||||
let mut gp_params = gp_params.clone();
|
||||
gp_params.prepare_client_identity()?;
|
||||
let cancellation = self.cancellation.clone();
|
||||
let internal = gateway_context.is_some_and(|context| context.kind() == gpapi::gateway::GatewayKind::Internal);
|
||||
let mut client = GatewayLoginClient::new(gateway, gp_params)?;
|
||||
|
||||
loop {
|
||||
let login = match gateway_context {
|
||||
Some(context) => gateway_login_with_context(gateway, cred, &gp_params, context).await?,
|
||||
None => gateway_login(gateway, cred, &gp_params).await?,
|
||||
};
|
||||
self.check_cancelled()?;
|
||||
let login = client.login(cred, gateway_context, &cancellation).await?;
|
||||
|
||||
match login {
|
||||
GatewayLogin::Cookie(cookie) => {
|
||||
GatewayLogin::Authenticated(authentication) => {
|
||||
let descriptor = Gateway::new(gateway.to_string(), gateway.to_string());
|
||||
client.register_session(
|
||||
descriptor.clone(),
|
||||
authentication.clone(),
|
||||
&mut self.sessions.borrow_mut(),
|
||||
);
|
||||
self.check_cancelled()?;
|
||||
if internal && authentication.mode() == SessionMode::NonTunnel && !self.args.cookie_only {
|
||||
client
|
||||
.bind_non_tunnel(self.args.disable_ipv6, None, &cancellation)
|
||||
.await
|
||||
.map_err(|error| error.context(gpapi::gateway::GatewayLoginProtocolError))?;
|
||||
client.update_registered_session(&descriptor, &authentication, &mut self.sessions.borrow_mut());
|
||||
}
|
||||
return Ok(GatewayLoginSession {
|
||||
cookie,
|
||||
extension_auth: SessionExtensionAuth::new(cred.clone(), gp_params),
|
||||
authentication,
|
||||
extension_auth: SessionExtensionAuth::new(cred.clone(), client),
|
||||
});
|
||||
}
|
||||
GatewayLogin::Mfa(message, input_str) => {
|
||||
let otp = Text::new(&message).prompt()?;
|
||||
gp_params.set_input_str(&input_str);
|
||||
gp_params.set_otp(&otp);
|
||||
client.respond_mfa(&input_str, &otp);
|
||||
|
||||
info!("Retrying gateway login with MFA...");
|
||||
}
|
||||
@@ -333,14 +381,15 @@ impl ConnectHandler<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
async fn connect_gateway(
|
||||
pub(super) async fn connect_gateway(
|
||||
&self,
|
||||
portal: &str,
|
||||
gateway: &str,
|
||||
cookie: &str,
|
||||
authentication: &GatewayAuthentication,
|
||||
allow_extend_session: bool,
|
||||
extension_auth: SessionExtensionAuth,
|
||||
) -> Result<(), GatewayConnectError> {
|
||||
let cookie = authentication.cookie();
|
||||
// --cookie-only: print the gateway cookie and exit without opening a tunnel.
|
||||
// No tun device is allocated, no root is required, and no logout is issued
|
||||
// against the gateway — the cookie remains valid for subsequent use.
|
||||
@@ -351,20 +400,39 @@ impl ConnectHandler<'_> {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if authentication.mode() != SessionMode::Tunnel {
|
||||
return Err(GatewayConnectError::after_establishment(anyhow::anyhow!(
|
||||
"Non-tunnel authentication requires fresh internal portal discovery"
|
||||
)));
|
||||
}
|
||||
self
|
||||
.check_cancelled()
|
||||
.map_err(GatewayConnectError::after_establishment)?;
|
||||
let identity_files = extension_auth
|
||||
.client_identity()
|
||||
.map(|identity| identity.write_files(None))
|
||||
.transpose()
|
||||
.map_err(GatewayConnectError::before_establishment)?;
|
||||
let certificate = identity_files.as_ref().map(|files| files.certificate().to_owned());
|
||||
let sslkey = identity_files.as_ref().and_then(|files| files.key().map(str::to_owned));
|
||||
let key_password = extension_auth
|
||||
.client_identity()
|
||||
.and_then(|identity| identity.key_password())
|
||||
.map(str::to_owned);
|
||||
let mtu = self.args.mtu.unwrap_or(0);
|
||||
let os_profile = self.os_profile.borrow().clone();
|
||||
let hip_source = self
|
||||
.hip_source(os_profile.clone())
|
||||
.map_err(GatewayConnectError::before_tunnel)?;
|
||||
.map_err(GatewayConnectError::before_establishment)?;
|
||||
|
||||
let session_ctx = build_session_context(SessionContextInput {
|
||||
portal: portal.to_string(),
|
||||
gateway: gateway.to_string(),
|
||||
cookie: cookie.to_string(),
|
||||
os_profile: os_profile.clone(),
|
||||
certificate: self.args.certificate.clone(),
|
||||
sslkey: self.args.sslkey.clone(),
|
||||
key_password: self.latest_key_password.borrow().clone(),
|
||||
certificate: certificate.clone(),
|
||||
sslkey: sslkey.clone(),
|
||||
key_password: key_password.clone(),
|
||||
disable_ipv6: self.args.disable_ipv6,
|
||||
extension_auth: Some(extension_auth),
|
||||
});
|
||||
@@ -372,9 +440,9 @@ impl ConnectHandler<'_> {
|
||||
.script(self.args.script.clone())
|
||||
.interface(self.args.interface.clone())
|
||||
.script_tun(self.args.script_tun)
|
||||
.certificate(self.args.certificate.clone())
|
||||
.sslkey(self.args.sslkey.clone())
|
||||
.key_password(self.latest_key_password.borrow().clone())
|
||||
.certificate(certificate)
|
||||
.sslkey(sslkey)
|
||||
.key_password(key_password)
|
||||
.hip_source(hip_source)
|
||||
.reconnect_timeout(self.args.reconnect_timeout)
|
||||
.mtu(mtu)
|
||||
@@ -385,7 +453,7 @@ impl ConnectHandler<'_> {
|
||||
.no_xmlpost(self.args.no_xmlpost);
|
||||
let vpn = apply_os_profile(vpn_builder, &os_profile)
|
||||
.build()
|
||||
.map_err(|err| GatewayConnectError::before_tunnel(err.into()))?;
|
||||
.map_err(|err| GatewayConnectError::before_establishment(err.into()))?;
|
||||
|
||||
let vpn = Arc::new(vpn);
|
||||
let vpn_clone = vpn.clone();
|
||||
@@ -398,46 +466,72 @@ impl ConnectHandler<'_> {
|
||||
let tunnel_established_on_connect = Arc::clone(&tunnel_established);
|
||||
let disconnect_requested = Arc::new(AtomicBool::new(false));
|
||||
let disconnect_requested_on_signal = Arc::clone(&disconnect_requested);
|
||||
let cancellation = self.cancellation.clone();
|
||||
|
||||
tokio::spawn(async move {
|
||||
shutdown_signal().await;
|
||||
let disconnect_task = tokio::spawn(async move {
|
||||
cancellation.cancelled().await;
|
||||
info!("Received the interrupt signal, disconnecting...");
|
||||
disconnect_requested_on_signal.store(true, Ordering::SeqCst);
|
||||
vpn_clone.disconnect();
|
||||
});
|
||||
|
||||
let lock_file = self.shared_args.lock_file.to_path_buf();
|
||||
let lock_file_on_connect = lock_file.clone();
|
||||
let lock_file_on_connect = self.shared_args.lock_file.to_path_buf();
|
||||
let pid_written = self.pid_written.clone();
|
||||
let log_format = self.shared_args.log_format;
|
||||
let connect_result = vpn.connect(move |vpn_session_info| {
|
||||
tunnel_established_on_connect.store(true, Ordering::SeqCst);
|
||||
write_pid_file(&lock_file_on_connect);
|
||||
let session_cancellation = self.cancellation.clone();
|
||||
let (established_tx, established_rx) = tokio::sync::oneshot::channel();
|
||||
self.sessions.borrow_mut().relinquish_gateway(gateway);
|
||||
let worker = tokio::task::spawn_blocking(move || {
|
||||
vpn.connect(move |vpn_session_info| {
|
||||
if session_cancellation.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
tunnel_established_on_connect.store(true, Ordering::SeqCst);
|
||||
pid_written.store(write_pid_file(&lock_file_on_connect), Ordering::SeqCst);
|
||||
let _ = established_tx.send(());
|
||||
|
||||
let Some(session_ctx) = session_ctx_on_connect.lock().unwrap().take() else {
|
||||
return;
|
||||
};
|
||||
let session_info = session_info_from_vpn(vpn_session_info, allow_extend_session);
|
||||
info!("VPN session info: {}", session_info.log_summary());
|
||||
let Some(session_ctx) = session_ctx_on_connect.lock().unwrap().take() else {
|
||||
return;
|
||||
};
|
||||
let session_info = session_info_from_vpn(vpn_session_info, allow_extend_session);
|
||||
info!("VPN session info: {}", session_info.log_summary());
|
||||
|
||||
let task = spawn_session_runtime_with_info(&runtime_handle, session_ctx, session_info, log_format);
|
||||
session_task_on_connect.lock().unwrap().replace(task);
|
||||
let task = spawn_session_runtime_with_info(&runtime_handle, session_ctx, session_info, log_format);
|
||||
session_task_on_connect.lock().unwrap().replace(task);
|
||||
})
|
||||
});
|
||||
tokio::pin!(worker);
|
||||
let connect_result = tokio::select! {
|
||||
result = &mut worker => result,
|
||||
established = established_rx => {
|
||||
if established.is_ok() {
|
||||
let unused = self.sessions.borrow().members().iter()
|
||||
.filter(|session| session.gateway.server() != gateway)
|
||||
.map(|session| session.gateway.server().to_owned())
|
||||
.collect::<Vec<_>>();
|
||||
for server in unused {
|
||||
self.logout_gateway(&server).await;
|
||||
}
|
||||
}
|
||||
(&mut worker).await
|
||||
}
|
||||
};
|
||||
let tunnel_established = tunnel_established.load(Ordering::SeqCst);
|
||||
disconnect_task.abort();
|
||||
let _ = disconnect_task.await;
|
||||
|
||||
if let Some(task) = session_task.lock().unwrap().take() {
|
||||
let session_task = { session_task.lock().unwrap().take() };
|
||||
if let Some(task) = session_task {
|
||||
task.abort();
|
||||
}
|
||||
|
||||
if fs::metadata(&lock_file).is_ok() {
|
||||
info!("Removing PID file");
|
||||
fs::remove_file(&lock_file).map_err(|err| GatewayConnectError::after_tunnel(err.into()))?;
|
||||
let _ = task.await;
|
||||
}
|
||||
|
||||
let disconnect_requested = disconnect_requested.load(Ordering::SeqCst);
|
||||
let connect_result = connect_result.map_err(|error| GatewayConnectError::after_establishment(error.into()))?;
|
||||
classify_openconnect_result(connect_result, tunnel_established, disconnect_requested)
|
||||
}
|
||||
|
||||
fn hip_source(&self, profile: OsProfile) -> anyhow::Result<HipSource> {
|
||||
pub(super) fn hip_source(&self, profile: OsProfile) -> anyhow::Result<HipSource> {
|
||||
let user = self.determine_hip_user();
|
||||
let script = self.args.hip.as_ref().or(self.args.csd_wrapper.as_ref());
|
||||
match script {
|
||||
@@ -489,9 +583,9 @@ fn classify_openconnect_result(
|
||||
|
||||
let error = anyhow::anyhow!("OpenConnect exited with status {}", exit_code);
|
||||
if tunnel_established {
|
||||
Err(GatewayConnectError::after_tunnel(error))
|
||||
Err(GatewayConnectError::after_establishment(error))
|
||||
} else {
|
||||
Err(GatewayConnectError::before_tunnel(error))
|
||||
Err(GatewayConnectError::before_establishment(error))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -499,13 +593,15 @@ fn direct_gateway_command(gateway: &str) -> String {
|
||||
format!("gpauth --gateway {gateway} | sudo gpclient connect {gateway} --as-gateway --cookie-on-stdin")
|
||||
}
|
||||
|
||||
fn write_pid_file(lock_file: &Path) {
|
||||
pub(super) fn write_pid_file(lock_file: &Path) -> bool {
|
||||
let pid = std::process::id();
|
||||
|
||||
if let Err(err) = fs::write(lock_file, pid.to_string()) {
|
||||
warn!("Failed to write PID file: {}", err);
|
||||
false
|
||||
} else {
|
||||
info!("Wrote PID {} to {}", pid, lock_file.display());
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
@@ -556,14 +652,14 @@ mod tests {
|
||||
fn openconnect_failure_before_callback_is_retryable_gateway_failure() {
|
||||
let err = classify_openconnect_result(1, false, false).expect_err("nonzero exit should fail");
|
||||
|
||||
assert!(err.is_before_tunnel());
|
||||
assert!(err.is_before_establishment());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openconnect_failure_after_callback_is_terminal_gateway_failure() {
|
||||
let err = classify_openconnect_result(1, true, false).expect_err("nonzero exit should fail");
|
||||
|
||||
assert!(!err.is_before_tunnel());
|
||||
assert!(!err.is_before_establishment());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -576,7 +672,7 @@ mod tests {
|
||||
let err = classify_openconnect_result(OPENCONNECT_INTERRUPTED_EXIT_CODE, true, false)
|
||||
.expect_err("unexpected interrupt should fail");
|
||||
|
||||
assert!(!err.is_before_tunnel());
|
||||
assert!(!err.is_before_establishment());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -0,0 +1,226 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use anyhow::{Context, bail, ensure};
|
||||
use gpapi::{
|
||||
credential::AuthCookieCredential,
|
||||
gateway::{Gateway, GatewayLoginContext, GatewaySelection},
|
||||
portal::PortalConfig,
|
||||
process::collection::CollectionControl,
|
||||
session::{
|
||||
MaintenanceState, SessionEndReason, SessionMode,
|
||||
network::PhysicalNetwork,
|
||||
non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
|
||||
},
|
||||
};
|
||||
use log::{info, warn};
|
||||
|
||||
use super::ConnectHandler;
|
||||
|
||||
impl ConnectHandler<'_> {
|
||||
pub(super) async fn connect_internal_gateways(
|
||||
&self,
|
||||
portal: &str,
|
||||
config: &PortalConfig,
|
||||
credential: &AuthCookieCredential,
|
||||
first_gateway: &Gateway,
|
||||
first_session: super::gateway::GatewayLoginSession,
|
||||
remaining: &[&Gateway],
|
||||
) -> anyhow::Result<()> {
|
||||
ensure!(remaining.len() < 64, "Too many internal non-tunnel candidates");
|
||||
let mut hosts = std::collections::HashSet::new();
|
||||
for gateway in std::iter::once(first_gateway).chain(remaining.iter().copied()) {
|
||||
ensure!(
|
||||
gateway.kind() == gpapi::gateway::GatewayKind::Internal,
|
||||
"Non-tunnel candidates must be internal"
|
||||
);
|
||||
ensure!(
|
||||
hosts.insert(gpapi::utils::normalize_server(gateway.server())?),
|
||||
"Duplicate internal gateway"
|
||||
);
|
||||
}
|
||||
let mut authenticated = vec![(first_gateway, first_session)];
|
||||
for gateway in remaining.iter().copied() {
|
||||
self.check_cancelled()?;
|
||||
let context =
|
||||
GatewayLoginContext::new(gateway, GatewaySelection::Auto).with_connect_method(config.connect_method());
|
||||
match self
|
||||
.authenticate_gateway(
|
||||
portal,
|
||||
gateway.server(),
|
||||
credential,
|
||||
config.default_browser().unwrap_or(false),
|
||||
context,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(session) => authenticated.push((gateway, session)),
|
||||
Err(error) => {
|
||||
self.logout_gateway(gateway.server()).await;
|
||||
self.check_cancelled()?;
|
||||
warn!("Internal gateway {gateway} authentication failed: {error}");
|
||||
}
|
||||
}
|
||||
}
|
||||
self.check_cancelled()?;
|
||||
let modes = authenticated.iter().map(|(_, session)| session.authentication.mode());
|
||||
ensure!(
|
||||
internal_session_mode(modes)? == SessionMode::NonTunnel,
|
||||
"Expected non-tunnel authentication"
|
||||
);
|
||||
self.run_internal_session(config, &authenticated).await
|
||||
}
|
||||
|
||||
async fn run_internal_session(
|
||||
&self,
|
||||
config: &PortalConfig,
|
||||
authenticated: &[(&gpapi::gateway::Gateway, super::gateway::GatewayLoginSession)],
|
||||
) -> anyhow::Result<()> {
|
||||
let cancellation = self.cancellation.clone();
|
||||
let network = Arc::new(PhysicalNetwork::capture_controlled(&cancellation).await?);
|
||||
let detection = config.internal_detection().cloned();
|
||||
let bindings = authenticated
|
||||
.iter()
|
||||
.map(|(_, session)| {
|
||||
session
|
||||
.extension_auth
|
||||
.binding()
|
||||
.cloned()
|
||||
.context("Non-tunnel binding is missing")
|
||||
})
|
||||
.collect::<anyhow::Result<Vec<_>>>()?;
|
||||
for binding in &bindings {
|
||||
network
|
||||
.validate_internal_binding(binding, detection.as_ref(), &cancellation)
|
||||
.await?;
|
||||
}
|
||||
let policy = config
|
||||
.internal_session_policy()
|
||||
.context("Invalid internal session policy")?;
|
||||
let profile = self.os_profile.borrow().clone();
|
||||
let source = if policy.collect_hip_data() {
|
||||
self.hip_source(profile.clone())?
|
||||
} else {
|
||||
openconnect::HipSource::Disabled
|
||||
};
|
||||
let source = Arc::new(source);
|
||||
let validate_network = network.clone();
|
||||
let validate_detection = detection.clone();
|
||||
let callbacks = SessionCallbacks {
|
||||
produce_report: Arc::new(move |request, control| {
|
||||
control.check()?;
|
||||
if matches!(source.as_ref(), openconnect::HipSource::Disabled) {
|
||||
return gphip::generate_identity_report(&gphip::ReportInput {
|
||||
profile: profile.clone(),
|
||||
context: gphip::ReportContext::Connected {
|
||||
cookie: request.cookie.clone(),
|
||||
client_ip: request.client_ip.clone(),
|
||||
client_ipv6: request.client_ipv6.clone(),
|
||||
md5: request.md5.clone(),
|
||||
},
|
||||
})
|
||||
.map_err(std::io::Error::other);
|
||||
}
|
||||
source.collect(
|
||||
&openconnect::HipRequest {
|
||||
cookie: request.cookie.clone(),
|
||||
client_ip: request.client_ip.clone(),
|
||||
client_ipv6: request.client_ipv6.clone(),
|
||||
md5: request.md5.clone(),
|
||||
client_version: profile.client_version().into(),
|
||||
client_os: profile.client_os().as_str().into(),
|
||||
os_version: profile.os_version().into(),
|
||||
host_id: Some(profile.host_id().into()),
|
||||
local_hostname: Some(profile.computer().into()),
|
||||
},
|
||||
&|| control.check(),
|
||||
)
|
||||
}),
|
||||
report_submitted: Arc::new(|_, _| {}),
|
||||
status_changed: Arc::new(|member| match member.maintenance {
|
||||
MaintenanceState::Healthy => info!(
|
||||
"Internal network — authenticated: {} (IPv4: {:?}, IPv6: {:?})",
|
||||
member.gateway, member.client_ip, member.client_ipv6
|
||||
),
|
||||
state => info!("Internal gateway {}: {state:?}", member.gateway),
|
||||
}),
|
||||
validate_network: Arc::new(move |cancellation| {
|
||||
let network = validate_network.clone();
|
||||
let detection = validate_detection.clone();
|
||||
let bindings = bindings.clone();
|
||||
Box::pin(async move {
|
||||
for binding in &bindings {
|
||||
network
|
||||
.validate_internal_binding(binding, detection.as_ref(), &cancellation)
|
||||
.await?;
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
}),
|
||||
};
|
||||
let monitor_cancel = cancellation.child_token();
|
||||
let monitor_token = monitor_cancel.clone();
|
||||
let (network_changed, network_signal) = tokio::sync::oneshot::channel();
|
||||
let monitor = tokio::spawn(async move {
|
||||
match network.wait_for_change(detection, monitor_token).await {
|
||||
Ok(false) => {}
|
||||
Ok(true) | Err(_) => {
|
||||
let _ = network_changed.send(SessionEndReason::NetworkChanged);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// The PID spans maintenance and cleanup, including initialization before the
|
||||
// first successful HIP exchange. The outer handler owns final session logout.
|
||||
self.pid_written.store(
|
||||
super::gateway::write_pid_file(self.shared_args.lock_file),
|
||||
std::sync::atomic::Ordering::SeqCst,
|
||||
);
|
||||
let mut sessions = self.sessions.take();
|
||||
let result = maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation, async move {
|
||||
network_signal.await.unwrap_or(SessionEndReason::NetworkChanged)
|
||||
})
|
||||
.await;
|
||||
self.sessions.replace(sessions);
|
||||
monitor_cancel.cancel();
|
||||
monitor.await.context("Internal network monitor failed")?;
|
||||
match result? {
|
||||
SessionExit::Disconnected => Ok(()),
|
||||
SessionExit::Failed(reason) => bail!("Internal session ended: {reason:?}. Connect again to authenticate."),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn logout_gateway(&self, gateway: &str) {
|
||||
let mut sessions = self.sessions.take();
|
||||
sessions.logout_gateway(gateway).await;
|
||||
self.sessions.replace(sessions);
|
||||
}
|
||||
}
|
||||
|
||||
fn internal_session_mode(modes: impl Iterator<Item = SessionMode>) -> anyhow::Result<SessionMode> {
|
||||
let mut modes = modes;
|
||||
let mode = modes.next().context("No internal gateway authenticated successfully")?;
|
||||
ensure!(
|
||||
modes.all(|candidate| candidate == mode),
|
||||
"Mixed tunnel and non-tunnel internal gateways are unsupported; select a gateway explicitly"
|
||||
);
|
||||
Ok(mode)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn internal_modes_reject_mixed_and_empty_sets() {
|
||||
assert!(internal_session_mode([].into_iter()).is_err());
|
||||
assert!(internal_session_mode([SessionMode::Tunnel, SessionMode::NonTunnel].into_iter()).is_err());
|
||||
assert_eq!(
|
||||
internal_session_mode([SessionMode::NonTunnel, SessionMode::NonTunnel].into_iter()).unwrap(),
|
||||
SessionMode::NonTunnel
|
||||
);
|
||||
assert_eq!(
|
||||
internal_session_mode([SessionMode::Tunnel].into_iter()).unwrap(),
|
||||
SessionMode::Tunnel
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,17 +1,25 @@
|
||||
mod args;
|
||||
mod credential;
|
||||
#[cfg(test)]
|
||||
mod flow_tests;
|
||||
mod gateway;
|
||||
mod internal;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
};
|
||||
|
||||
use anyhow::bail;
|
||||
use gpapi::{
|
||||
clap::report,
|
||||
error::PortalError,
|
||||
gateway::{GatewayLoginContext, GatewaySelection},
|
||||
gateway::GatewaySelection,
|
||||
gp_params::GpParams,
|
||||
os_profile::OsProfile,
|
||||
portal::{PreloginOptions, prelogin, retrieve_config},
|
||||
session::GatewaySessions,
|
||||
utils::request::RequestIdentityError,
|
||||
};
|
||||
use inquire::{Password, PasswordDisplayMode, Select};
|
||||
@@ -25,6 +33,7 @@ use credential::CleanAuthState;
|
||||
use gateway::GatewayConnectError;
|
||||
|
||||
pub(crate) struct ConnectHandler<'a> {
|
||||
cancellation: tokio_util::sync::CancellationToken,
|
||||
args: &'a ConnectArgs,
|
||||
shared_args: &'a SharedArgs<'a>,
|
||||
os_profile: RefCell<OsProfile>,
|
||||
@@ -32,6 +41,8 @@ pub(crate) struct ConnectHandler<'a> {
|
||||
password_from_stdin: RefCell<Option<String>>,
|
||||
cookie_from_stdin: RefCell<Option<String>>,
|
||||
clean_auth_state: RefCell<CleanAuthState>,
|
||||
sessions: RefCell<GatewaySessions>,
|
||||
pid_written: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl<'a> ConnectHandler<'a> {
|
||||
@@ -44,6 +55,7 @@ impl<'a> ConnectHandler<'a> {
|
||||
let clean_auth = false;
|
||||
|
||||
Self {
|
||||
cancellation: tokio_util::sync::CancellationToken::new(),
|
||||
args,
|
||||
shared_args,
|
||||
os_profile: RefCell::new(build_os_profile(args)),
|
||||
@@ -51,6 +63,8 @@ impl<'a> ConnectHandler<'a> {
|
||||
password_from_stdin: Default::default(),
|
||||
cookie_from_stdin: Default::default(),
|
||||
clean_auth_state: RefCell::new(CleanAuthState::new(clean_auth)),
|
||||
sessions: RefCell::default(),
|
||||
pid_written: Arc::default(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -93,6 +107,37 @@ impl<'a> ConnectHandler<'a> {
|
||||
}
|
||||
|
||||
pub(crate) async fn handle(&self) -> anyhow::Result<()> {
|
||||
let cancellation = self.cancellation.clone();
|
||||
let signal = tokio::spawn(async move {
|
||||
gpapi::utils::shutdown_signal().await;
|
||||
cancellation.cancel();
|
||||
});
|
||||
let result = self.handle_attempt().await;
|
||||
let sessions = self.sessions.take();
|
||||
if self.args.cookie_only && result.is_ok() {
|
||||
sessions.relinquish();
|
||||
} else {
|
||||
sessions.logout().await;
|
||||
}
|
||||
if self.pid_written.load(Ordering::SeqCst) {
|
||||
if let Err(error) = std::fs::remove_file(self.shared_args.lock_file) {
|
||||
warn!("Failed to remove PID file: {error}");
|
||||
}
|
||||
}
|
||||
signal.abort();
|
||||
let _ = signal.await;
|
||||
result
|
||||
}
|
||||
|
||||
fn check_cancelled(&self) -> anyhow::Result<()> {
|
||||
if self.cancellation.is_cancelled() {
|
||||
Err(gpapi::auth::AuthenticationCancelled.into())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle_attempt(&self) -> anyhow::Result<()> {
|
||||
if self.args.browser_listen.is_some()
|
||||
&& !matches!(self.args.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("remote"))
|
||||
{
|
||||
@@ -107,6 +152,7 @@ impl<'a> ConnectHandler<'a> {
|
||||
self.latest_key_password.replace(self.args.key_password.clone());
|
||||
|
||||
loop {
|
||||
self.check_cancelled()?;
|
||||
let Err(err) = self.handle_impl().await else {
|
||||
return Ok(());
|
||||
};
|
||||
@@ -144,6 +190,7 @@ impl<'a> ConnectHandler<'a> {
|
||||
}
|
||||
|
||||
pub(crate) async fn handle_impl(&self) -> anyhow::Result<()> {
|
||||
self.check_cancelled()?;
|
||||
let server = self.args.server.as_str();
|
||||
let as_gateway = self.args.as_gateway;
|
||||
|
||||
@@ -155,10 +202,11 @@ impl<'a> ConnectHandler<'a> {
|
||||
}
|
||||
|
||||
if !self.args.cookie_on_stdin {
|
||||
if let Some(()) = self.try_cached_cookie(server).await {
|
||||
return Ok(());
|
||||
if let Some(result) = self.try_cached_cookie(server).await {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
self.check_cancelled()?;
|
||||
|
||||
let Err(err) = self.connect_portal_with_prelogin(server).await else {
|
||||
return Ok(());
|
||||
@@ -190,10 +238,35 @@ impl<'a> ConnectHandler<'a> {
|
||||
async fn connect_portal_with_prelogin(&self, portal: &str) -> anyhow::Result<()> {
|
||||
let gp_params = self.build_gp_params();
|
||||
|
||||
let prelogin = prelogin(portal, &gp_params, self.prelogin_options(false)).await?;
|
||||
let prelogin = tokio::select! {
|
||||
biased;
|
||||
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
|
||||
result = prelogin(portal, &gp_params, self.prelogin_options(false)) => result?,
|
||||
};
|
||||
|
||||
let cred = self.obtain_credential(&prelogin, portal, false).await?;
|
||||
let mut portal_config = retrieve_config(portal, &cred, &gp_params).await?;
|
||||
let cached = self.cached_portal_credential(portal);
|
||||
let cached_config = match cached {
|
||||
Some(cred) => match retrieve_config(portal, &cred, &gp_params, &self.cancellation).await {
|
||||
Ok(config) => Some((cred, config)),
|
||||
Err(error) => {
|
||||
self.check_cancelled()?;
|
||||
warn!("Cached portal authentication failed: {error}");
|
||||
self.clear_cookie_cache();
|
||||
None
|
||||
}
|
||||
},
|
||||
None => None,
|
||||
};
|
||||
let (cred, mut portal_config) = match cached_config {
|
||||
Some(result) => result,
|
||||
None => {
|
||||
let cred = self.obtain_credential(&prelogin, portal, false).await?;
|
||||
self.check_cancelled()?;
|
||||
let config = retrieve_config(portal, &cred, &gp_params, &self.cancellation).await?;
|
||||
(cred, config)
|
||||
}
|
||||
};
|
||||
self.check_cancelled()?;
|
||||
|
||||
portal_config.sort_gateways(prelogin.region());
|
||||
|
||||
@@ -201,7 +274,6 @@ impl<'a> ConnectHandler<'a> {
|
||||
Some(password) => portal_config.auth_cookie().clone().with_password(password),
|
||||
None => portal_config.auth_cookie().clone(),
|
||||
};
|
||||
let allow_extend_session = portal_config.allow_extend_session().unwrap_or(false);
|
||||
let portal_config_default_browser = portal_config.default_browser().unwrap_or(false);
|
||||
info!("Portal config default-browser: {}", portal_config_default_browser);
|
||||
|
||||
@@ -217,29 +289,27 @@ impl<'a> ConnectHandler<'a> {
|
||||
);
|
||||
|
||||
let mut last_err: Option<anyhow::Error> = None;
|
||||
for gateway in &gateways {
|
||||
for (index, gateway) in gateways.iter().enumerate() {
|
||||
info!("Auto-gateway: attempting gateway {}", gateway);
|
||||
let gateway_context =
|
||||
GatewayLoginContext::new(gateway, GatewaySelection::Auto).with_connect_method(portal_config.connect_method());
|
||||
|
||||
match self
|
||||
.connect_gateway_with_fallback(
|
||||
portal,
|
||||
gateway.server(),
|
||||
gateway,
|
||||
&auth_cookie,
|
||||
allow_extend_session,
|
||||
portal_config_default_browser,
|
||||
gateway_context,
|
||||
&portal_config,
|
||||
GatewaySelection::Auto,
|
||||
&gateways[index + 1..],
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(()) => return Ok(()),
|
||||
Err(err) => {
|
||||
if !err.is_before_tunnel() {
|
||||
self.logout_gateway(gateway.server()).await;
|
||||
if !err.is_before_establishment() {
|
||||
return Err(err.into_error());
|
||||
}
|
||||
warn!(
|
||||
"Auto-gateway: gateway {} failed before tunnel setup: {}",
|
||||
"Auto-gateway: gateway {} failed before session establishment: {}",
|
||||
gateway,
|
||||
err.as_error()
|
||||
);
|
||||
@@ -270,6 +340,9 @@ impl<'a> ConnectHandler<'a> {
|
||||
None => {
|
||||
let gateways = portal_config.gateways();
|
||||
|
||||
if gateways.is_empty() {
|
||||
bail!("No gateways available in portal configuration");
|
||||
}
|
||||
if gateways.len() > 1 {
|
||||
let gateway = Select::new("Which gateway do you want to connect to?", gateways)
|
||||
.with_vim_mode(true)
|
||||
@@ -283,18 +356,14 @@ impl<'a> ConnectHandler<'a> {
|
||||
}
|
||||
};
|
||||
|
||||
let gateway = selected_gateway.server();
|
||||
let gateway_context =
|
||||
GatewayLoginContext::new(selected_gateway, gateway_selection).with_connect_method(portal_config.connect_method());
|
||||
|
||||
self
|
||||
.connect_gateway_with_fallback(
|
||||
portal,
|
||||
gateway,
|
||||
selected_gateway,
|
||||
&auth_cookie,
|
||||
allow_extend_session,
|
||||
portal_config_default_browser,
|
||||
gateway_context,
|
||||
&portal_config,
|
||||
gateway_selection,
|
||||
&[],
|
||||
)
|
||||
.await
|
||||
.map_err(GatewayConnectError::into_error)
|
||||
|
||||
@@ -35,4 +35,5 @@ mac_address = "1"
|
||||
nix = { version = "0.31", features = ["fs", "socket", "user"] }
|
||||
|
||||
[dev-dependencies]
|
||||
openssl.workspace = true
|
||||
tokio-tungstenite = "0.29"
|
||||
@@ -301,7 +301,7 @@ async fn wait_for_brokered_idle(
|
||||
_ = interval.tick() => {},
|
||||
}
|
||||
|
||||
let idle = matches!(*vpn_state_rx.borrow(), VpnState::Disconnected) && registry.is_empty();
|
||||
let idle = matches!(*vpn_state_rx.borrow(), VpnState::Disconnected | VpnState::Failed(_)) && registry.is_empty();
|
||||
if !idle {
|
||||
idle_since = None;
|
||||
continue;
|
||||
|
||||
@@ -198,7 +198,7 @@ fn generate(
|
||||
let openconnect::HipSource::Script(script) = execution.source else {
|
||||
bail!("HIP preview executable is unavailable");
|
||||
};
|
||||
let xml = script.preview(&input, &check)?;
|
||||
let xml = script.collect(&input, &check)?;
|
||||
gphip::validate_edited_report(&xml).context("Custom HIP script did not emit a valid HIP report")?;
|
||||
xml
|
||||
}
|
||||
|
||||
@@ -24,16 +24,12 @@ pub(crate) struct HipApproval {
|
||||
}
|
||||
|
||||
impl HipApproval {
|
||||
pub(crate) fn approval_id(&self) -> Option<&str> {
|
||||
self.identity.as_ref().map(|(id, _)| id.as_str())
|
||||
}
|
||||
|
||||
pub(crate) fn approval_is_valid(&self) -> bool {
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
if let Some((id, uid)) = &self.identity {
|
||||
return gpservice::hip_approval::resolve(id, *uid).is_ok();
|
||||
}
|
||||
true
|
||||
self.identity.is_none()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -24,6 +24,54 @@ const MAX_GUI_ARCHIVE_SIZE: u64 = 256 * 1024 * 1024;
|
||||
const MAX_GUI_ARCHIVE_CONTENT_SIZE: u64 = 512 * 1024 * 1024;
|
||||
const MAX_GUI_BINARY_SIZE: u64 = 256 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct SessionAuthority {
|
||||
pub registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
pub session_id: uuid::Uuid,
|
||||
pub generation: u64,
|
||||
}
|
||||
|
||||
pub(crate) enum PendingDispatch {
|
||||
Connect {
|
||||
preparation: ConnectionPreparation,
|
||||
request: Box<gpapi::service::request::ConnectRequest>,
|
||||
desktop_uid: Option<u32>,
|
||||
edited_report: Option<Arc<str>>,
|
||||
},
|
||||
Drain(Option<crate::vpn_task::AttemptDrain>),
|
||||
Other(WsRequest),
|
||||
}
|
||||
|
||||
pub(crate) struct ConnectionPreparation {
|
||||
authority: SessionAuthority,
|
||||
non_tunnel: bool,
|
||||
reservation: Option<crate::vpn_task::ConnectReservation>,
|
||||
}
|
||||
|
||||
impl ConnectionPreparation {
|
||||
fn cancellation(&self) -> tokio_util::sync::CancellationToken {
|
||||
self
|
||||
.reservation
|
||||
.as_ref()
|
||||
.expect("preparation retains reservation")
|
||||
.cancellation()
|
||||
}
|
||||
|
||||
fn commit(
|
||||
mut self,
|
||||
connection: crate::vpn_task::PreparedConnection,
|
||||
desktop_uid: Option<u32>,
|
||||
edited_report: Option<Arc<str>>,
|
||||
) -> ServiceResult {
|
||||
let reservation = self.reservation.take().expect("preparation retains reservation");
|
||||
self.authority.registry.commit_connection(
|
||||
self.authority.session_id,
|
||||
self.authority.generation,
|
||||
self.non_tunnel,
|
||||
|| reservation.commit(connection, desktop_uid, edited_report, Some(self.authority.session_id)),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct RequestDispatcher {
|
||||
lifecycle: crate::vpn_task::LifecycleHandle,
|
||||
gui_restart_requested: Arc<AtomicBool>,
|
||||
@@ -56,38 +104,123 @@ impl RequestDispatcher {
|
||||
request: WsRequest,
|
||||
desktop_uid: Option<u32>,
|
||||
edited_report: Option<Arc<str>>,
|
||||
session_id: Option<uuid::Uuid>,
|
||||
) -> Result<WsRequest, ServiceResult> {
|
||||
authority: Option<SessionAuthority>,
|
||||
) -> Result<PendingDispatch, ServiceResult> {
|
||||
match request {
|
||||
WsRequest::Connect(request) => {
|
||||
if let Err(message) = self.validate_connect_paths(&request) {
|
||||
return Err(ServiceResult::rejected(ServiceErrorCode::InvalidRequest, message));
|
||||
}
|
||||
if let Err(err) = self
|
||||
.redaction
|
||||
.add_values(&[request.gateway().server(), request.args().cookie()])
|
||||
{
|
||||
let redaction_values = request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.flat_map(|member| [member.gateway.server(), member.authentication.cookie()])
|
||||
.collect::<Vec<_>>();
|
||||
if let Err(err) = self.redaction.add_values(&redaction_values) {
|
||||
warn!("Failed to update log redaction: {err}");
|
||||
return Err(ServiceResult::rejected(
|
||||
ServiceErrorCode::Internal,
|
||||
"Request could not be accepted",
|
||||
));
|
||||
}
|
||||
Err(
|
||||
self
|
||||
.lifecycle
|
||||
.submit_connect(*request, desktop_uid, edited_report, session_id),
|
||||
)
|
||||
let authority = authority
|
||||
.ok_or_else(|| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection session is missing"))?;
|
||||
let non_tunnel = request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel);
|
||||
let reservation =
|
||||
authority
|
||||
.registry
|
||||
.reserve_connection(authority.session_id, authority.generation, non_tunnel, || {
|
||||
self.lifecycle.reserve_connect()
|
||||
})?;
|
||||
let preparation = ConnectionPreparation {
|
||||
authority,
|
||||
non_tunnel,
|
||||
reservation: Some(reservation),
|
||||
};
|
||||
let edited_report = if let gpapi::hip::HipSource::Edited { report_id } = request.args().hip_source() {
|
||||
let report_id = uuid::Uuid::parse_str(report_id)
|
||||
.map_err(|_| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report ID"))?;
|
||||
Some(
|
||||
preparation
|
||||
.authority
|
||||
.registry
|
||||
.edited_hip_report(preparation.authority.session_id, report_id)
|
||||
.map_err(|_| {
|
||||
ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"HIP report is unavailable for this session",
|
||||
)
|
||||
})?,
|
||||
)
|
||||
} else {
|
||||
edited_report
|
||||
};
|
||||
Ok(PendingDispatch::Connect {
|
||||
preparation,
|
||||
request,
|
||||
desktop_uid,
|
||||
edited_report,
|
||||
})
|
||||
}
|
||||
WsRequest::StopNonTunnelAttachment { connection_id } => {
|
||||
let authority = authority
|
||||
.ok_or_else(|| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection session is missing"))?;
|
||||
let drain =
|
||||
authority
|
||||
.registry
|
||||
.stop_non_tunnel_attachment(authority.session_id, authority.generation, connection_id)?;
|
||||
Ok(PendingDispatch::Drain(drain))
|
||||
}
|
||||
WsRequest::Disconnect(_) => Err(self.lifecycle.request_disconnect()),
|
||||
request => Ok(request),
|
||||
request => Ok(PendingDispatch::Other(request)),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub async fn dispatch(&self, request: WsRequest) -> ServiceResult {
|
||||
let request = match self.dispatch_lifecycle(request, None, None, None) {
|
||||
Ok(request) => request,
|
||||
Err(result) => return result,
|
||||
match self.dispatch_lifecycle(request, None, None, None) {
|
||||
Ok(request) => self.dispatch_pending(request).await,
|
||||
Err(result) => result,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn dispatch_pending(&self, request: PendingDispatch) -> ServiceResult {
|
||||
let request = match request {
|
||||
PendingDispatch::Connect {
|
||||
preparation,
|
||||
request,
|
||||
desktop_uid,
|
||||
edited_report,
|
||||
} => {
|
||||
let prepared = crate::vpn_task::prepare_connection(
|
||||
*request,
|
||||
self.brokered_scripts_dir.is_some(),
|
||||
preparation.cancellation(),
|
||||
)
|
||||
.await;
|
||||
return match prepared {
|
||||
Ok(connection) => preparation.commit(connection, desktop_uid, edited_report),
|
||||
Err(error) => {
|
||||
warn!("Connection preparation failed: {error:#}");
|
||||
ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"Connection resources could not be prepared",
|
||||
)
|
||||
}
|
||||
};
|
||||
}
|
||||
PendingDispatch::Drain(drain) => {
|
||||
if let Some(drain) = drain {
|
||||
drain.wait().await;
|
||||
}
|
||||
return ServiceResult::Accepted;
|
||||
}
|
||||
PendingDispatch::Other(request) => request,
|
||||
};
|
||||
|
||||
match request {
|
||||
@@ -132,6 +265,7 @@ impl RequestDispatcher {
|
||||
ServiceResult::Accepted
|
||||
}
|
||||
WsRequest::Connect(_)
|
||||
| WsRequest::StopNonTunnelAttachment { .. }
|
||||
| WsRequest::Disconnect(_)
|
||||
| WsRequest::StoreEditedHipReportChunk(_)
|
||||
| WsRequest::PreviewHipReport(_)
|
||||
@@ -296,14 +430,12 @@ fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<N
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::vpn_task::test_connect_request as test_request;
|
||||
use std::{io::Cursor, os::unix::fs::PermissionsExt};
|
||||
|
||||
use gpapi::{
|
||||
gateway::Gateway,
|
||||
service::{
|
||||
request::ConnectRequest,
|
||||
transport::{ServiceErrorCode, ServiceResult},
|
||||
},
|
||||
service::transport::{ServiceErrorCode, ServiceResult},
|
||||
};
|
||||
use tar::{Builder, EntryType, Header};
|
||||
use xz2::write::XzEncoder;
|
||||
@@ -426,7 +558,7 @@ mod tests {
|
||||
|
||||
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
|
||||
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
|
||||
let request = ConnectRequest::new(info, "cookie".into())
|
||||
let request = test_request(info)
|
||||
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
|
||||
.with_certificate(Some("/Users/example/client.pem".to_string()));
|
||||
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
|
||||
@@ -446,18 +578,17 @@ mod tests {
|
||||
);
|
||||
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
|
||||
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
|
||||
let bundled = ConnectRequest::new(info.clone(), "cookie".into())
|
||||
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()));
|
||||
let bundled =
|
||||
test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()));
|
||||
assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(()));
|
||||
|
||||
let old_layout = ConnectRequest::new(info.clone(), "cookie".into())
|
||||
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()));
|
||||
let old_layout = test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()));
|
||||
assert_eq!(
|
||||
dispatcher.validate_connect_paths(&old_layout),
|
||||
Err("macOS VPN script must be the bundled script")
|
||||
);
|
||||
|
||||
let custom = ConnectRequest::new(info, "cookie".into())
|
||||
let custom = test_request(info)
|
||||
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
|
||||
.with_hip_source(gpapi::hip::HipSource::UserScript {
|
||||
path: "/tmp/hip.sh".into(),
|
||||
|
||||
@@ -4,7 +4,7 @@ use std::{
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use gpapi::service::transport::SessionCredential;
|
||||
use gpapi::service::transport::{ServiceErrorCode, ServiceResult, SessionCredential};
|
||||
use thiserror::Error;
|
||||
use uuid::Uuid;
|
||||
use zeroize::Zeroizing;
|
||||
@@ -62,6 +62,8 @@ enum SessionStatus {
|
||||
}
|
||||
|
||||
struct SessionRecord {
|
||||
non_tunnel: Option<AttachmentAttempt>,
|
||||
closed_attachment: Option<Uuid>,
|
||||
secret: Zeroizing<[u8; 32]>,
|
||||
product_version: String,
|
||||
desktop_uid: Option<u32>,
|
||||
@@ -72,12 +74,120 @@ struct SessionRecord {
|
||||
status: SessionStatus,
|
||||
}
|
||||
|
||||
/// Only live preparation/execution is retained, never acceptance history.
|
||||
struct AttachmentAttempt {
|
||||
generation: u64,
|
||||
connection_id: Uuid,
|
||||
drain: crate::vpn_task::AttemptDrain,
|
||||
}
|
||||
|
||||
pub struct SessionRegistry {
|
||||
service_instance_id: Uuid,
|
||||
sessions: Mutex<HashMap<Uuid, SessionRecord>>,
|
||||
}
|
||||
|
||||
fn unavailable_connection() -> ServiceResult {
|
||||
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection attachment is unavailable")
|
||||
}
|
||||
|
||||
fn current_connection(record: &SessionRecord, expected: u64) -> Result<Uuid, ServiceResult> {
|
||||
match &record.status {
|
||||
SessionStatus::Active {
|
||||
generation,
|
||||
connection: Some(connection),
|
||||
..
|
||||
} if *generation == expected && !connection.is_closed() => Ok(connection.connection_id()),
|
||||
_ => Err(unavailable_connection()),
|
||||
}
|
||||
}
|
||||
|
||||
impl SessionRegistry {
|
||||
pub(crate) fn reserve_connection(
|
||||
&self,
|
||||
session_id: Uuid,
|
||||
generation: u64,
|
||||
non_tunnel: bool,
|
||||
reserve: impl FnOnce() -> Result<crate::vpn_task::ConnectReservation, ServiceResult>,
|
||||
) -> Result<crate::vpn_task::ConnectReservation, ServiceResult> {
|
||||
let mut sessions = self.sessions.lock().map_err(|_| unavailable_connection())?;
|
||||
let record = sessions.get_mut(&session_id).ok_or_else(unavailable_connection)?;
|
||||
let connection_id = current_connection(record, generation)?;
|
||||
if non_tunnel && record.closed_attachment == Some(connection_id) {
|
||||
return Err(ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"Non-tunnel attachment is closing",
|
||||
));
|
||||
}
|
||||
if record
|
||||
.non_tunnel
|
||||
.as_ref()
|
||||
.is_some_and(|attempt| attempt.drain.is_complete())
|
||||
{
|
||||
record.non_tunnel = None;
|
||||
}
|
||||
let reservation = reserve()?;
|
||||
if non_tunnel {
|
||||
record.non_tunnel = Some(AttachmentAttempt {
|
||||
generation,
|
||||
connection_id,
|
||||
drain: reservation.drain(),
|
||||
});
|
||||
}
|
||||
Ok(reservation)
|
||||
}
|
||||
|
||||
pub(crate) fn commit_connection(
|
||||
&self,
|
||||
session_id: Uuid,
|
||||
generation: u64,
|
||||
non_tunnel: bool,
|
||||
commit: impl FnOnce() -> ServiceResult,
|
||||
) -> ServiceResult {
|
||||
let Ok(sessions) = self.sessions.lock() else {
|
||||
return unavailable_connection();
|
||||
};
|
||||
let Some(record) = sessions.get(&session_id) else {
|
||||
return unavailable_connection();
|
||||
};
|
||||
if non_tunnel {
|
||||
let connection_id = match current_connection(record, generation) {
|
||||
Ok(id) => id,
|
||||
Err(result) => return result,
|
||||
};
|
||||
if record.closed_attachment == Some(connection_id) {
|
||||
return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Non-tunnel attachment is closing");
|
||||
}
|
||||
} else if !matches!(record.status, SessionStatus::Active { .. }) {
|
||||
return unavailable_connection();
|
||||
}
|
||||
// Non-tunnel attachment invalidation takes this same lock. An authorized
|
||||
// tunnel reservation survives attachment loss as before; revoked sessions
|
||||
// cannot commit either mode. Queue insertion transfers cleanup ownership.
|
||||
commit()
|
||||
}
|
||||
|
||||
pub(crate) fn stop_non_tunnel_attachment(
|
||||
&self,
|
||||
session_id: Uuid,
|
||||
generation: u64,
|
||||
connection_id: Uuid,
|
||||
) -> Result<Option<crate::vpn_task::AttemptDrain>, ServiceResult> {
|
||||
let mut sessions = self.sessions.lock().map_err(|_| unavailable_connection())?;
|
||||
let record = sessions.get_mut(&session_id).ok_or_else(unavailable_connection)?;
|
||||
let current_id = current_connection(record, generation)?;
|
||||
if current_id == connection_id {
|
||||
record.closed_attachment = Some(connection_id);
|
||||
}
|
||||
if let Some(attempt) = &record.non_tunnel {
|
||||
if attempt.connection_id == connection_id {
|
||||
attempt.drain.cancel();
|
||||
return Ok(Some(attempt.drain.clone()));
|
||||
}
|
||||
}
|
||||
// No retained live work belongs to that attachment. Never stop a successor.
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
pub fn new(service_instance_id: Uuid) -> Self {
|
||||
Self {
|
||||
service_instance_id,
|
||||
@@ -120,6 +230,8 @@ impl SessionRegistry {
|
||||
sessions.insert(
|
||||
credential.session_id(),
|
||||
SessionRecord {
|
||||
non_tunnel: None,
|
||||
closed_attachment: None,
|
||||
secret: Zeroizing::new(*credential.secret()),
|
||||
product_version: credential.product_version().to_owned(),
|
||||
desktop_uid,
|
||||
@@ -258,6 +370,10 @@ impl SessionRegistry {
|
||||
connection: current,
|
||||
reconnect_token,
|
||||
} if *generation == permit.observed_generation && *reconnect_token == Some(permit.token) => {
|
||||
if let Some(attempt) = &record.non_tunnel {
|
||||
attempt.drain.cancel();
|
||||
}
|
||||
record.closed_attachment = None;
|
||||
*generation = generation.checked_add(1).ok_or(SessionError::Unavailable)?;
|
||||
*reconnect_token = None;
|
||||
Ok(current.replace(connection))
|
||||
@@ -418,6 +534,13 @@ impl SessionRegistry {
|
||||
let Ok(mut sessions) = self.sessions.lock() else {
|
||||
return;
|
||||
};
|
||||
if let Some(record) = sessions.get_mut(&session_id) {
|
||||
if let Some(attempt) = &record.non_tunnel {
|
||||
if attempt.generation == generation {
|
||||
attempt.drain.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(SessionRecord {
|
||||
status: SessionStatus::Active {
|
||||
generation: current,
|
||||
@@ -438,9 +561,14 @@ impl SessionRegistry {
|
||||
.lock()
|
||||
.ok()
|
||||
.and_then(|mut sessions| sessions.remove(&session_id))
|
||||
.and_then(|record| match record.status {
|
||||
SessionStatus::Active { connection, .. } => connection,
|
||||
SessionStatus::Pending { .. } => None,
|
||||
.and_then(|record| {
|
||||
if let Some(attempt) = &record.non_tunnel {
|
||||
attempt.drain.cancel();
|
||||
}
|
||||
match record.status {
|
||||
SessionStatus::Active { connection, .. } => connection,
|
||||
SessionStatus::Pending { .. } => None,
|
||||
}
|
||||
});
|
||||
if let Some(connection) = connection {
|
||||
connection.close(gpapi::service::transport::CloseReason::Unauthorized);
|
||||
@@ -468,6 +596,140 @@ mod tests {
|
||||
ConnectionControl::new(Uuid::new_v4(), tx).0
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn attachment_replacement_cancels_preparation_and_retains_drain_until_release() {
|
||||
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
|
||||
let credential = registry.issue("fixture", None).unwrap();
|
||||
let session = credential.session_id();
|
||||
let first = registry
|
||||
.begin_handshake(credential.service_instance_id(), session, "fixture")
|
||||
.unwrap();
|
||||
let (tx, _rx) = mpsc::channel(4);
|
||||
let first_control = ConnectionControl::new(Uuid::new_v4(), tx).0;
|
||||
let old_id = first_control.connection_id();
|
||||
registry.commit_attach(&first, first_control).unwrap();
|
||||
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
|
||||
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
|
||||
let reservation = registry
|
||||
.reserve_connection(session, 1, true, || lifecycle.reserve_connect())
|
||||
.unwrap();
|
||||
let drain = reservation.drain();
|
||||
let cancel = reservation.cancellation();
|
||||
|
||||
let next = registry
|
||||
.begin_handshake(credential.service_instance_id(), session, "fixture")
|
||||
.unwrap();
|
||||
let (tx, _next_rx) = mpsc::channel(4);
|
||||
registry
|
||||
.commit_attach(&next, ConnectionControl::new(Uuid::new_v4(), tx).0)
|
||||
.unwrap();
|
||||
assert!(cancel.is_cancelled());
|
||||
assert!(!drain.is_complete());
|
||||
assert!(
|
||||
registry
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
|
||||
.is_err()
|
||||
);
|
||||
assert!(matches!(
|
||||
registry.commit_connection(session, 1, true, || panic!("stale start committed")),
|
||||
ServiceResult::Rejected(_)
|
||||
));
|
||||
drop(reservation);
|
||||
drain.wait().await;
|
||||
|
||||
let next_reservation = registry
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
|
||||
.unwrap();
|
||||
assert!(
|
||||
registry
|
||||
.stop_non_tunnel_attachment(session, 2, old_id)
|
||||
.unwrap()
|
||||
.is_none()
|
||||
);
|
||||
assert!(!next_reservation.cancellation().is_cancelled());
|
||||
registry.disconnect_if_current(session, 1);
|
||||
assert!(!next_reservation.cancellation().is_cancelled());
|
||||
registry.disconnect_if_current(session, 2);
|
||||
assert!(next_reservation.cancellation().is_cancelled());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn scoped_stop_closes_attachment_to_delayed_starts_without_receipt_history() {
|
||||
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
|
||||
let credential = registry.issue("fixture", None).unwrap();
|
||||
let session = credential.session_id();
|
||||
let permit = registry
|
||||
.begin_handshake(credential.service_instance_id(), session, "fixture")
|
||||
.unwrap();
|
||||
let (tx, _rx) = mpsc::channel(4);
|
||||
let connection = ConnectionControl::new(Uuid::new_v4(), tx).0;
|
||||
let id = connection.connection_id();
|
||||
registry.commit_attach(&permit, connection).unwrap();
|
||||
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
|
||||
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
|
||||
let reservation = registry
|
||||
.reserve_connection(session, 1, true, || lifecycle.reserve_connect())
|
||||
.unwrap();
|
||||
let drain = registry.stop_non_tunnel_attachment(session, 1, id).unwrap().unwrap();
|
||||
assert!(reservation.cancellation().is_cancelled());
|
||||
assert!(matches!(
|
||||
registry.commit_connection(session, 1, true, || panic!("closing start committed")),
|
||||
ServiceResult::Rejected(_)
|
||||
));
|
||||
assert!(!drain.is_complete());
|
||||
drop(reservation);
|
||||
drain.wait().await;
|
||||
assert!(
|
||||
registry
|
||||
.reserve_connection(session, 1, true, || panic!("closed attachment reserved"))
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
registry
|
||||
.reserve_connection(session, 1, false, || lifecycle.reserve_connect())
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn tunnel_reservation_survives_attachment_loss_but_non_tunnel_revocation_cancels() {
|
||||
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
|
||||
let credential = registry.issue("fixture", None).unwrap();
|
||||
let session = credential.session_id();
|
||||
let permit = registry
|
||||
.begin_handshake(credential.service_instance_id(), session, "fixture")
|
||||
.unwrap();
|
||||
let (tx, _rx) = mpsc::channel(4);
|
||||
registry
|
||||
.commit_attach(&permit, ConnectionControl::new(Uuid::new_v4(), tx).0)
|
||||
.unwrap();
|
||||
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
|
||||
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
|
||||
let tunnel = registry
|
||||
.reserve_connection(session, 1, false, || lifecycle.reserve_connect())
|
||||
.unwrap();
|
||||
registry.disconnect_if_current(session, 1);
|
||||
assert!(!tunnel.cancellation().is_cancelled());
|
||||
assert_eq!(
|
||||
registry.commit_connection(session, 1, false, || ServiceResult::Accepted),
|
||||
ServiceResult::Accepted
|
||||
);
|
||||
drop(tunnel);
|
||||
let permit = registry
|
||||
.begin_handshake(credential.service_instance_id(), session, "fixture")
|
||||
.unwrap();
|
||||
let (tx, _next_rx) = mpsc::channel(4);
|
||||
registry
|
||||
.commit_attach(&permit, ConnectionControl::new(Uuid::new_v4(), tx).0)
|
||||
.unwrap();
|
||||
let session_work = registry
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
|
||||
.unwrap();
|
||||
registry.revoke(session);
|
||||
assert!(session_work.cancellation().is_cancelled());
|
||||
assert!(!session_work.drain().is_complete());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn credential_retains_verified_desktop_user_across_reconnect() {
|
||||
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
|
||||
|
||||
+774
-329
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,192 @@
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
use anyhow::Context;
|
||||
use gpapi::process::collection::CollectionControl;
|
||||
use gpapi::session::{
|
||||
GatewaySessionSummary, MaintenanceState, SessionEndReason,
|
||||
non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
|
||||
};
|
||||
use log::warn;
|
||||
use tokio::sync::{mpsc, watch};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use super::{
|
||||
LifecycleEvent,
|
||||
runtime::{AttemptInput, stop_for_revoked_approval},
|
||||
};
|
||||
|
||||
/// Borrow the accepted ledger. The outer attempt owner retains identity/source
|
||||
/// resources and joins this runtime before draining the remaining members.
|
||||
pub(super) async fn run(
|
||||
input: &mut AttemptInput,
|
||||
source: Arc<openconnect::HipSource>,
|
||||
approval: &crate::hip_source::HipApproval,
|
||||
cancellation: CancellationToken,
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
) -> anyhow::Result<SessionExit> {
|
||||
let request = &input.connection.request;
|
||||
let args = request.args();
|
||||
let resources = &input.connection.resources;
|
||||
let sessions = &mut input.connection.sessions;
|
||||
let network = resources
|
||||
.network
|
||||
.as_ref()
|
||||
.context("Physical network context is missing")?;
|
||||
let posture_enabled =
|
||||
request.plan().policy().collect_hip_data() && !matches!(args.hip_source(), gpapi::hip::HipSource::Disabled);
|
||||
let profile = resources.profile.clone();
|
||||
let initial = sessions
|
||||
.members()
|
||||
.iter()
|
||||
.map(|session| GatewaySessionSummary {
|
||||
gateway: session.gateway.clone(),
|
||||
mode: gpapi::session::SessionMode::NonTunnel,
|
||||
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
|
||||
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
|
||||
maintenance: MaintenanceState::Authenticated,
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let (status, mut changed) = watch::channel(initial);
|
||||
let registry = input.registry.clone();
|
||||
let session_id = input.session_id;
|
||||
let validation_network = network.clone();
|
||||
let validation_detection = request.plan().internal_detection().cloned();
|
||||
let callbacks = SessionCallbacks {
|
||||
validate_network: Arc::new(move |cancel| {
|
||||
let network = validation_network.clone();
|
||||
let detection = validation_detection.clone();
|
||||
Box::pin(async move { network.validate_internal(detection.as_ref(), &cancel).await })
|
||||
}),
|
||||
produce_report: Arc::new(move |request, control| {
|
||||
control.check()?;
|
||||
let context = gphip::ReportContext::Connected {
|
||||
cookie: request.cookie.clone(),
|
||||
client_ip: request.client_ip.clone(),
|
||||
client_ipv6: request.client_ipv6.clone(),
|
||||
md5: request.md5.clone(),
|
||||
};
|
||||
if !posture_enabled {
|
||||
return gphip::generate_identity_report(&gphip::ReportInput {
|
||||
profile: profile.clone(),
|
||||
context,
|
||||
})
|
||||
.map_err(std::io::Error::other);
|
||||
}
|
||||
source.collect(
|
||||
&openconnect::HipRequest {
|
||||
cookie: request.cookie.clone(),
|
||||
client_ip: request.client_ip.clone(),
|
||||
client_ipv6: request.client_ipv6.clone(),
|
||||
md5: request.md5.clone(),
|
||||
client_version: profile.client_version().into(),
|
||||
client_os: profile.client_os().as_str().into(),
|
||||
os_version: profile.os_version().into(),
|
||||
host_id: Some(profile.host_id().into()),
|
||||
local_hostname: Some(profile.computer().into()),
|
||||
},
|
||||
&|| control.check(),
|
||||
)
|
||||
}),
|
||||
report_submitted: Arc::new(move |_, xml| {
|
||||
if let Some(session_id) = session_id {
|
||||
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
|
||||
warn!("Could not retain submitted HIP report: {error}");
|
||||
}
|
||||
}
|
||||
}),
|
||||
status_changed: Arc::new(move |summary| {
|
||||
status.send_modify(|members| {
|
||||
if let Some(member) = members
|
||||
.iter_mut()
|
||||
.find(|member| member.gateway.server() == summary.gateway.server())
|
||||
{
|
||||
*member = summary;
|
||||
}
|
||||
});
|
||||
}),
|
||||
};
|
||||
let monitor_cancel = cancellation.child_token();
|
||||
let monitor_token = monitor_cancel.clone();
|
||||
let network = network.clone();
|
||||
let detection = request.plan().internal_detection().cloned();
|
||||
let (network_changed, network_signal) = tokio::sync::oneshot::channel();
|
||||
let monitor = tokio::spawn(async move {
|
||||
match network.wait_for_change(detection, monitor_token).await {
|
||||
Ok(false) => {}
|
||||
Ok(true) => {
|
||||
let _ = network_changed.send(SessionEndReason::NetworkChanged);
|
||||
}
|
||||
Err(error) => {
|
||||
warn!("Physical network inspection failed: {error}");
|
||||
let _ = network_changed.send(SessionEndReason::NetworkChanged);
|
||||
}
|
||||
}
|
||||
});
|
||||
let mut approval_revoked = false;
|
||||
let result = {
|
||||
let lifecycle_cancel = cancellation.clone();
|
||||
let maintenance = maintain_non_tunnel_sessions(
|
||||
sessions,
|
||||
request.plan().policy(),
|
||||
callbacks,
|
||||
lifecycle_cancel,
|
||||
async move { network_signal.await.unwrap_or(SessionEndReason::NetworkChanged) },
|
||||
);
|
||||
tokio::pin!(maintenance);
|
||||
let mut approval_poll = tokio::time::interval(Duration::from_secs(1));
|
||||
let mut publish = true;
|
||||
let result = loop {
|
||||
if publish && !cancellation.is_cancelled() {
|
||||
let members = changed.borrow_and_update().clone();
|
||||
let _ = events
|
||||
.send(LifecycleEvent::MembersChanged {
|
||||
attempt: input.attempt,
|
||||
members,
|
||||
failures: request.plan().failures().to_vec(),
|
||||
})
|
||||
.await;
|
||||
publish = false;
|
||||
}
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut maintenance => break result,
|
||||
_ = approval_poll.tick() => if !approval.approval_is_valid() {
|
||||
approval_revoked = true;
|
||||
stop_for_revoked_approval(&input.lifecycle, &cancellation);
|
||||
},
|
||||
result = changed.changed() => { if result.is_ok() { publish = true; } },
|
||||
}
|
||||
};
|
||||
// Maintenance can invalidate every member and finish in the same poll.
|
||||
// Forward that last snapshot before monitor/remote cleanup, even when the
|
||||
// completed maintenance branch won over the watch notification.
|
||||
if !cancellation.is_cancelled() {
|
||||
let members = changed.borrow_and_update().clone();
|
||||
let _ = events
|
||||
.send(LifecycleEvent::MembersChanged {
|
||||
attempt: input.attempt,
|
||||
members,
|
||||
failures: request.plan().failures().to_vec(),
|
||||
})
|
||||
.await;
|
||||
}
|
||||
result
|
||||
};
|
||||
monitor_cancel.cancel();
|
||||
monitor.await.context("Network monitor worker failed")?;
|
||||
if approval_revoked {
|
||||
let _ = events
|
||||
.send(LifecycleEvent::Failed {
|
||||
attempt: input.attempt,
|
||||
reason: "HIP script approval was revoked".into(),
|
||||
})
|
||||
.await;
|
||||
}
|
||||
// resources and approval remain owned until maintenance/logout and monitor
|
||||
// inspection are drained. Deliberate disconnect wins throughout cleanup.
|
||||
if cancellation.is_cancelled() {
|
||||
Ok(SessionExit::Disconnected)
|
||||
} else {
|
||||
result
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
use std::{
|
||||
io::{Read, Write},
|
||||
sync::Arc,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use gpapi::{
|
||||
gateway::Gateway,
|
||||
gp_params::GpParams,
|
||||
service::{
|
||||
transport::ServiceResult,
|
||||
vpn_state::{ConnectInfo, VpnState},
|
||||
},
|
||||
session::{ClientAddresses, GatewayAuthentication, GatewaySession, GatewaySessions, transport::GatewayTransport},
|
||||
};
|
||||
use openssl::{
|
||||
asn1::Asn1Time,
|
||||
hash::MessageDigest,
|
||||
pkey::PKey,
|
||||
rsa::Rsa,
|
||||
ssl::{SslAcceptor, SslMethod},
|
||||
x509::{X509, X509NameBuilder},
|
||||
};
|
||||
use tokio::sync::{oneshot, watch};
|
||||
|
||||
use super::{LifecycleEvent, PreparedConnection, VpnTask, test_connect_request};
|
||||
|
||||
fn tls_acceptor() -> SslAcceptor {
|
||||
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
|
||||
let mut name = X509NameBuilder::new().unwrap();
|
||||
name.append_entry_by_text("CN", "localhost").unwrap();
|
||||
let name = name.build();
|
||||
let mut cert = X509::builder().unwrap();
|
||||
cert.set_version(2).unwrap();
|
||||
cert.set_subject_name(&name).unwrap();
|
||||
cert.set_issuer_name(&name).unwrap();
|
||||
cert.set_pubkey(&key).unwrap();
|
||||
cert.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
|
||||
cert.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
|
||||
cert.sign(&key, MessageDigest::sha256()).unwrap();
|
||||
let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
|
||||
acceptor.set_private_key(&key).unwrap();
|
||||
acceptor.set_certificate(&cert.build()).unwrap();
|
||||
acceptor.check_private_key().unwrap();
|
||||
acceptor.build()
|
||||
}
|
||||
|
||||
/// Exercise the real HTTPS logout transport without any production network,
|
||||
/// host collectors, or user identity files. The response gate proves admission
|
||||
/// stays owned until the server request finishes.
|
||||
#[tokio::test]
|
||||
async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let endpoint = listener.local_addr().unwrap();
|
||||
let server_name = format!("https://{endpoint}");
|
||||
let mut gateway = serde_json::to_value(Gateway::new("fixture".into(), server_name.clone())).unwrap();
|
||||
gateway["kind"] = serde_json::json!("internal");
|
||||
let gateway: Gateway = serde_json::from_value(gateway).unwrap();
|
||||
let registry = Arc::new(crate::session_registry::SessionRegistry::new(uuid::Uuid::new_v4()));
|
||||
let credential = registry.issue("fixture", None).unwrap();
|
||||
let session_id = credential.session_id();
|
||||
let permit = registry
|
||||
.begin_handshake(credential.service_instance_id(), session_id, "fixture")
|
||||
.unwrap();
|
||||
let (tx, _rx) = tokio::sync::mpsc::channel(4);
|
||||
let control = crate::ws_connection::ConnectionControl::new(uuid::Uuid::new_v4(), tx).0;
|
||||
let connection_id = control.connection_id();
|
||||
registry.commit_attach(&permit, control).unwrap();
|
||||
let fixture = test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![]));
|
||||
let mut member = fixture.plan().members()[0].clone();
|
||||
member.authentication =
|
||||
GatewayAuthentication::new("authcookie=fixture&user=fixture".into(), "internal".into()).unwrap();
|
||||
let plan = gpapi::session::ConnectionPlan::new(vec![member], vec![], fixture.plan().policy()).unwrap();
|
||||
let request = gpapi::service::request::ConnectRequest::new(fixture.info().clone(), plan);
|
||||
let mut prepared = PreparedConnection::lifecycle_fixture(request);
|
||||
let mut params = GpParams::builder(prepared.resources.profile.clone());
|
||||
params.ignore_tls_errors(true);
|
||||
prepared.sessions = GatewaySessions::new(vec![GatewaySession {
|
||||
gateway,
|
||||
transport: GatewayTransport::new(
|
||||
&server_name,
|
||||
prepared.request.plan().members()[0].authentication.clone(),
|
||||
¶ms.build(),
|
||||
prepared.request.plan().members()[0].binding.as_ref(),
|
||||
)
|
||||
.unwrap(),
|
||||
addresses: ClientAddresses::default(),
|
||||
}]);
|
||||
let acceptor = tls_acceptor();
|
||||
let (arrived, arrival) = oneshot::channel();
|
||||
let (release, response_gate) = oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (socket, _) = tokio::time::timeout(Duration::from_secs(3), listener.accept())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let socket = socket.into_std().unwrap();
|
||||
socket.set_nonblocking(false).unwrap();
|
||||
socket.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
|
||||
socket.set_write_timeout(Some(Duration::from_secs(3))).unwrap();
|
||||
let request = tokio::task::spawn_blocking(move || {
|
||||
let mut stream = acceptor.accept(socket).unwrap();
|
||||
let mut bytes = Vec::new();
|
||||
let (headers_end, body_len) = loop {
|
||||
let mut chunk = [0; 1024];
|
||||
let count = stream.read(&mut chunk).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 + body_len {
|
||||
let mut chunk = [0; 1024];
|
||||
let count = stream.read(&mut chunk).unwrap();
|
||||
assert_ne!(count, 0);
|
||||
bytes.extend_from_slice(&chunk[..count]);
|
||||
}
|
||||
arrived.send(()).unwrap();
|
||||
response_gate.blocking_recv().unwrap();
|
||||
let body = "<response status=\"success\"/>";
|
||||
write!(
|
||||
stream,
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
body.len()
|
||||
)
|
||||
.unwrap();
|
||||
stream.flush().unwrap();
|
||||
String::from_utf8(bytes).unwrap()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
// A single accepted authentication must produce a single logout.
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(100), listener.accept())
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
request
|
||||
});
|
||||
let (state, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let (mut task, lifecycle) = VpnTask::new(state, false, registry.clone());
|
||||
let reservation = registry
|
||||
.reserve_connection(session_id, 1, true, || lifecycle.reserve_connect())
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
registry.commit_connection(session_id, 1, true, || reservation.commit(
|
||||
prepared,
|
||||
None,
|
||||
None,
|
||||
Some(session_id)
|
||||
)),
|
||||
ServiceResult::Accepted
|
||||
);
|
||||
let drain = registry
|
||||
.stop_non_tunnel_attachment(session_id, 1, connection_id)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let drain_waiter = tokio::spawn(async move {
|
||||
drain.wait().await;
|
||||
});
|
||||
let start = task.events.recv().await.unwrap();
|
||||
assert!(matches!(&start, LifecycleEvent::Start { .. }));
|
||||
task.handle_event(start).await;
|
||||
tokio::time::timeout(Duration::from_secs(3), arrival)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert!(lifecycle.has_attempt(0));
|
||||
assert!(!drain_waiter.is_finished());
|
||||
assert!(lifecycle.reserve_connect().is_err());
|
||||
assert!(!task.active.as_ref().unwrap().task.is_finished());
|
||||
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
|
||||
release.send(()).unwrap();
|
||||
while task.active.is_some() {
|
||||
let event = tokio::time::timeout(Duration::from_secs(3), task.events.recv())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
task.handle_event(event).await;
|
||||
}
|
||||
assert!(!lifecycle.has_attempt(0));
|
||||
drain_waiter.await.unwrap();
|
||||
assert!(lifecycle.reserve_connect().is_ok());
|
||||
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
|
||||
let request = server.await.unwrap();
|
||||
assert!(request.starts_with("POST /ssl-vpn/logout.esp "));
|
||||
let form = request.split_once("\r\n\r\n").unwrap().1;
|
||||
let fields = url_form(form);
|
||||
assert_eq!(fields.get("user").map(String::as_str), Some("fixture"));
|
||||
assert_eq!(fields.get("computer").map(String::as_str), Some("fixture"));
|
||||
assert_eq!(fields.get("clientos").map(String::as_str), Some("Linux"));
|
||||
}
|
||||
|
||||
fn url_form(form: &str) -> std::collections::HashMap<String, String> {
|
||||
form
|
||||
.split('&')
|
||||
.map(|field| {
|
||||
let (key, value) = field.split_once('=').unwrap();
|
||||
(key.to_owned(), value.to_owned())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
use anyhow::Context;
|
||||
use gpapi::{
|
||||
gp_params::GpParams,
|
||||
os_profile::OsProfile,
|
||||
process::collection::{CollectionBudget, CollectionControl},
|
||||
service::request::ConnectRequest,
|
||||
session::{GatewaySession, GatewaySessions, 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,
|
||||
brokered_macos: bool,
|
||||
cancellation: CancellationToken,
|
||||
) -> anyhow::Result<PreparedConnection> {
|
||||
let args = request.args();
|
||||
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, brokered_macos || non_tunnel)?;
|
||||
let directory = brokered_macos.then(|| std::path::Path::new("/var/run/com.yuezk.gpgui"));
|
||||
let identity_files = identity
|
||||
.as_ref()
|
||||
.map(|identity| identity.write_files(directory))
|
||||
.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(), ¶ms, 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 = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
|
||||
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
|
||||
"fixture".into(),
|
||||
"fixture-host".into(),
|
||||
"fixture-serial".into(),
|
||||
"02:00:00:00:00:01".into(),
|
||||
))
|
||||
.build();
|
||||
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 brokered_macos_and_non_tunnel_identity_reject_path_handoff() {
|
||||
for (brokered_macos, 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, brokered_macos, 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 = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
|
||||
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
|
||||
"fixture".into(),
|
||||
"fixture-host".into(),
|
||||
"fixture-serial".into(),
|
||||
"02:00:00:00:00:01".into(),
|
||||
))
|
||||
.build();
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,302 @@
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::{
|
||||
process::collection::{CollectionBudget, CollectionControl},
|
||||
service::request::ConnectRequest,
|
||||
session::SessionMode,
|
||||
};
|
||||
use log::warn;
|
||||
use openconnect::Vpn;
|
||||
use tokio::{sync::mpsc, task::JoinHandle};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::{LifecycleEvent, LifecycleHandle, PreparedConnection, preparation::ConnectionResources};
|
||||
|
||||
pub(super) struct AttemptInput {
|
||||
pub attempt: u64,
|
||||
pub connection: PreparedConnection,
|
||||
pub desktop_uid: Option<u32>,
|
||||
pub edited_report: Option<Arc<str>>,
|
||||
pub session_id: Option<Uuid>,
|
||||
pub brokered_macos: bool,
|
||||
pub registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
pub lifecycle: LifecycleHandle,
|
||||
}
|
||||
|
||||
struct TunnelInput {
|
||||
request: ConnectRequest,
|
||||
resources: Arc<ConnectionResources>,
|
||||
source: Arc<openconnect::HipSource>,
|
||||
session_id: Option<Uuid>,
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
}
|
||||
|
||||
struct PreparedTunnel {
|
||||
vpn: Arc<Vpn>,
|
||||
}
|
||||
|
||||
/// The accepted attempt owns cleanup through fallible setup. Non-tunnel workers
|
||||
/// borrow that ledger; a native tunnel takes its cleanup ownership when started.
|
||||
/// Cancellation joins execution before draining any remaining issued sessions.
|
||||
pub(super) fn spawn(
|
||||
mut input: AttemptInput,
|
||||
cancellation: CancellationToken,
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
) -> JoinHandle<()> {
|
||||
tokio::spawn(async move {
|
||||
let attempt = input.attempt;
|
||||
let non_tunnel = input
|
||||
.connection
|
||||
.request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == SessionMode::NonTunnel);
|
||||
let mut failure = None;
|
||||
let mut approval = None;
|
||||
if !cancellation.is_cancelled() {
|
||||
let request = input.connection.request.clone();
|
||||
let resources = input.connection.resources.clone();
|
||||
let desktop_uid = input.desktop_uid;
|
||||
let brokered = input.brokered_macos;
|
||||
let edited = input.edited_report.clone();
|
||||
let setup_cancel = cancellation.clone();
|
||||
let execution = tokio::task::spawn_blocking(move || {
|
||||
prepare_execution(request, resources, desktop_uid, brokered, edited, &setup_cancel)
|
||||
})
|
||||
.await;
|
||||
match execution {
|
||||
Ok(Ok(execution)) => {
|
||||
let (source, guard) = execution.into_parts();
|
||||
approval = Some(guard);
|
||||
let source = Arc::new(source);
|
||||
let guard = approval.as_ref().expect("execution approval is retained");
|
||||
if input
|
||||
.connection
|
||||
.request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == SessionMode::NonTunnel)
|
||||
{
|
||||
match super::non_tunnel::run(&mut input, source, guard, cancellation.clone(), events.clone()).await {
|
||||
Ok(gpapi::session::non_tunnel::SessionExit::Disconnected) => {}
|
||||
Ok(gpapi::session::non_tunnel::SessionExit::Failed(reason)) => {
|
||||
let message = match reason {
|
||||
gpapi::session::SessionEndReason::InvalidCookie => {
|
||||
"Internal gateway authentication expired; connect again"
|
||||
}
|
||||
gpapi::session::SessionEndReason::NetworkChanged => {
|
||||
"Physical network changed or could not be verified; connect again"
|
||||
}
|
||||
gpapi::session::SessionEndReason::AllMembersFailed => {
|
||||
"All internal gateway sessions failed; connect again"
|
||||
}
|
||||
gpapi::session::SessionEndReason::AuthorizationRevoked => "HIP execution authorization was revoked",
|
||||
};
|
||||
failure = Some(message.into());
|
||||
}
|
||||
Err(error) => {
|
||||
warn!("Non-tunnel maintenance failed: {error:#}");
|
||||
failure = Some("Internal session maintenance failed".into());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let tunnel_input = TunnelInput {
|
||||
request: input.connection.request.clone(),
|
||||
resources: input.connection.resources.clone(),
|
||||
source,
|
||||
session_id: input.session_id,
|
||||
registry: input.registry.clone(),
|
||||
};
|
||||
let setup_cancel = cancellation.clone();
|
||||
let prepared = tokio::task::spawn_blocking(move || prepare_tunnel(tunnel_input, &setup_cancel)).await;
|
||||
match prepared {
|
||||
Ok(Ok(prepared)) => {
|
||||
run_tunnel(
|
||||
attempt,
|
||||
&prepared,
|
||||
guard,
|
||||
&input.lifecycle,
|
||||
&mut input.connection.sessions,
|
||||
cancellation.clone(),
|
||||
events.clone(),
|
||||
)
|
||||
.await
|
||||
}
|
||||
Ok(Err(error)) => warn!("Failed to prepare tunnel: {error:#}"),
|
||||
Err(error) => warn!("Tunnel setup worker failed: {error}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Err(error)) => {
|
||||
warn!("Failed to prepare HIP execution: {error:#}");
|
||||
failure = Some("HIP execution could not be prepared".into());
|
||||
}
|
||||
Err(error) => {
|
||||
warn!("HIP setup worker failed: {error}");
|
||||
failure = Some("HIP setup worker failed".into());
|
||||
}
|
||||
}
|
||||
}
|
||||
input.connection.sessions.logout().await;
|
||||
// Identity and approval remain alive through worker drain and logout. Ended
|
||||
// only releases admission after the actor also joins this task.
|
||||
drop(approval);
|
||||
if non_tunnel && !cancellation.is_cancelled() {
|
||||
if let Some(reason) = failure {
|
||||
let _ = events.send(LifecycleEvent::Failed { attempt, reason }).await;
|
||||
}
|
||||
}
|
||||
let _ = events.send(LifecycleEvent::Ended { attempt }).await;
|
||||
})
|
||||
}
|
||||
|
||||
fn prepare_execution(
|
||||
request: ConnectRequest,
|
||||
resources: Arc<ConnectionResources>,
|
||||
desktop_uid: Option<u32>,
|
||||
brokered: bool,
|
||||
edited: Option<Arc<str>>,
|
||||
cancellation: &CancellationToken,
|
||||
) -> anyhow::Result<crate::hip_source::HipExecution> {
|
||||
let budget = CollectionBudget::new(Duration::from_secs(60));
|
||||
let check = || {
|
||||
if cancellation.is_cancelled() {
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::Interrupted,
|
||||
"HIP setup cancelled",
|
||||
));
|
||||
}
|
||||
budget.check()
|
||||
};
|
||||
check()?;
|
||||
let args = request.args();
|
||||
let pure_non_tunnel = request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == SessionMode::NonTunnel);
|
||||
let disabled = pure_non_tunnel && !request.plan().policy().collect_hip_data();
|
||||
let source = if disabled {
|
||||
&gpapi::hip::HipSource::Disabled
|
||||
} else {
|
||||
args.hip_source()
|
||||
};
|
||||
let execution = crate::hip_source::resolve(source, desktop_uid, brokered, edited, Some(resources.profile.clone()))?;
|
||||
check()?;
|
||||
Ok(execution)
|
||||
}
|
||||
|
||||
fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyhow::Result<PreparedTunnel> {
|
||||
let args = input.request.args();
|
||||
let budget = CollectionBudget::new(Duration::from_secs(60));
|
||||
let check = || {
|
||||
if cancellation.is_cancelled() {
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::Interrupted,
|
||||
"Tunnel setup cancelled",
|
||||
));
|
||||
}
|
||||
budget.check()
|
||||
};
|
||||
check()?;
|
||||
ensure!(
|
||||
input.request.plan().members().len() == 1
|
||||
&& input.request.plan().members()[0].authentication.mode() == SessionMode::Tunnel,
|
||||
"Tunnel execution requires one selected tunnel gateway"
|
||||
);
|
||||
let member = &input.request.plan().members()[0];
|
||||
let identity_files = &input.resources.identity_files;
|
||||
let vpn = Arc::new(
|
||||
crate::vpn_script::builder(member.gateway.server(), member.authentication.cookie(), args)?
|
||||
.user_agent(args.user_agent())
|
||||
.os(args.openconnect_os())
|
||||
.os_version(args.os_version())
|
||||
.client_version(args.client_version())
|
||||
.host_id(args.host_id())
|
||||
.certificate(identity_files.as_ref().map(|files| files.certificate().to_owned()))
|
||||
.sslkey(identity_files.as_ref().and_then(|files| files.key()).map(str::to_owned))
|
||||
.key_password(
|
||||
input
|
||||
.resources
|
||||
.identity
|
||||
.as_ref()
|
||||
.and_then(|identity| identity.key_password())
|
||||
.map(str::to_owned),
|
||||
)
|
||||
.hip_source(input.source)
|
||||
.reconnect_timeout(args.reconnect_timeout())
|
||||
.mtu(args.mtu())
|
||||
.disable_ipv6(args.disable_ipv6())
|
||||
.no_dtls(args.no_dtls())
|
||||
.local_hostname(args.local_hostname())
|
||||
.dpd_interval(args.force_dpd())
|
||||
.no_xmlpost(args.no_xmlpost())
|
||||
.build()
|
||||
.context("Failed to create tunnel worker")?,
|
||||
);
|
||||
check()?;
|
||||
if let Some(session_id) = input.session_id {
|
||||
let registry = input.registry;
|
||||
vpn.set_hip_report_callback(move |xml| {
|
||||
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
|
||||
warn!("Could not retain submitted HIP report: {error}");
|
||||
}
|
||||
});
|
||||
}
|
||||
Ok(PreparedTunnel { vpn })
|
||||
}
|
||||
|
||||
async fn run_tunnel(
|
||||
attempt: u64,
|
||||
prepared: &PreparedTunnel,
|
||||
approval: &crate::hip_source::HipApproval,
|
||||
lifecycle: &LifecycleHandle,
|
||||
sessions: &mut gpapi::session::GatewaySessions,
|
||||
cancellation: CancellationToken,
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
) {
|
||||
if cancellation.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
let vpn = prepared.vpn.clone();
|
||||
// The native tunnel keeps its reconnect endpoint and cookie current and owns
|
||||
// normal logout. The ledger remains responsible only before native execution.
|
||||
// Service admission permits exactly one tunnel member.
|
||||
std::mem::take(sessions).relinquish();
|
||||
let worker = tokio::task::spawn_blocking(move || {
|
||||
vpn.connect(move |session| {
|
||||
let _ = events.blocking_send(LifecycleEvent::Established { attempt, session });
|
||||
})
|
||||
});
|
||||
tokio::pin!(worker);
|
||||
let mut approval_poll = tokio::time::interval(Duration::from_secs(1));
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = cancellation.cancelled() => { prepared.vpn.disconnect(); break (&mut worker).await; },
|
||||
result = &mut worker => break result,
|
||||
_ = approval_poll.tick() => if !approval.approval_is_valid() {
|
||||
stop_for_revoked_approval(lifecycle, &cancellation);
|
||||
prepared.vpn.disconnect();
|
||||
break (&mut worker).await;
|
||||
},
|
||||
}
|
||||
};
|
||||
match result {
|
||||
Ok(0 | -4) => {}
|
||||
Ok(code) => warn!("Tunnel worker exited with status {code}"),
|
||||
Err(error) => warn!("Tunnel worker failed: {error}"),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn stop_for_revoked_approval(lifecycle: &LifecycleHandle, cancellation: &CancellationToken) {
|
||||
let result = lifecycle.request_disconnect();
|
||||
if !matches!(result, gpapi::service::transport::ServiceResult::Accepted) {
|
||||
warn!("Could not enqueue approval revocation stop: {result:?}");
|
||||
}
|
||||
cancellation.cancel();
|
||||
}
|
||||
@@ -58,11 +58,11 @@ impl ConnectionControl {
|
||||
}
|
||||
|
||||
pub fn is_closed(&self) -> bool {
|
||||
self.tx.is_closed()
|
||||
self.tx.is_closed() || self.close_tx.borrow().is_some()
|
||||
}
|
||||
|
||||
pub fn close(&self, reason: CloseReason) {
|
||||
let _ = self.close_tx.send(Some(reason));
|
||||
self.close_tx.send_replace(Some(reason));
|
||||
}
|
||||
|
||||
pub async fn send_reply(&self, id: Uuid, result: ServiceResult) {
|
||||
@@ -185,11 +185,11 @@ impl WsConnection {
|
||||
}
|
||||
|
||||
ctx
|
||||
.hip_previews
|
||||
.cancel_connection(permit.session_id, control.connection_id())
|
||||
.remove_connection(control.connection_id(), permit.session_id, generation)
|
||||
.await;
|
||||
ctx
|
||||
.remove_connection(control.connection_id(), permit.session_id, generation)
|
||||
.hip_previews
|
||||
.cancel_connection(permit.session_id, control.connection_id())
|
||||
.await;
|
||||
info!("GUI connection {} closed", control.connection_id());
|
||||
}
|
||||
@@ -487,44 +487,17 @@ async fn handle_client_message(
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let edited_report = if let WsRequest::Connect(connect) = &request {
|
||||
if let HipSource::Edited { report_id } = connect.args().hip_source() {
|
||||
let report_id = match Uuid::parse_str(report_id) {
|
||||
Ok(id) => id,
|
||||
Err(_) => {
|
||||
control
|
||||
.send(ConnectionCommand::Reply {
|
||||
id,
|
||||
result: ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report ID"),
|
||||
})
|
||||
.map_err(|_| ())?;
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
match ctx.registry().edited_hip_report(session_id, report_id) {
|
||||
Ok(report) => Some(report),
|
||||
Err(_) => {
|
||||
control
|
||||
.send(ConnectionCommand::Reply {
|
||||
id,
|
||||
result: ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"HIP report is unavailable for this session",
|
||||
),
|
||||
})
|
||||
.map_err(|_| ())?;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let dispatcher = ctx.dispatcher();
|
||||
let request = match dispatcher.dispatch_lifecycle(request, desktop_uid, edited_report, Some(session_id)) {
|
||||
let request = match dispatcher.dispatch_lifecycle(
|
||||
request,
|
||||
desktop_uid,
|
||||
None,
|
||||
Some(crate::request_dispatcher::SessionAuthority {
|
||||
registry: Arc::clone(ctx.registry()),
|
||||
session_id,
|
||||
generation,
|
||||
}),
|
||||
) {
|
||||
Ok(request) => request,
|
||||
Err(result) => {
|
||||
if control.send(ConnectionCommand::Reply { id, result }).is_err() {
|
||||
@@ -536,7 +509,7 @@ async fn handle_client_message(
|
||||
};
|
||||
let control = control.clone();
|
||||
tokio::spawn(async move {
|
||||
let result = dispatcher.dispatch(request).await;
|
||||
let result = dispatcher.dispatch_pending(request).await;
|
||||
control.send_reply(id, result).await;
|
||||
});
|
||||
Ok(())
|
||||
|
||||
@@ -151,8 +151,8 @@ impl WsServerContext {
|
||||
}
|
||||
|
||||
pub async fn remove_connection(&self, connection_id: Uuid, session_id: Uuid, generation: u64) {
|
||||
self.state.lock().await.connections.remove(&connection_id);
|
||||
self.registry.disconnect_if_current(session_id, generation);
|
||||
self.state.lock().await.connections.remove(&connection_id);
|
||||
}
|
||||
|
||||
pub async fn send_event(&self, event: WsEvent) {
|
||||
|
||||
Reference in new issue
Block a user