diff --git a/Cargo.lock b/Cargo.lock
index e4bec29..0d7b5d9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1865,6 +1865,7 @@ dependencies = [
"tempfile",
"thiserror 2.0.21",
"tokio",
+ "tokio-util",
"url",
"urlencoding",
"uuid",
@@ -1915,6 +1916,7 @@ dependencies = [
"sysinfo",
"tempfile",
"tokio",
+ "tokio-util",
"uzers",
"whoami",
]
@@ -1976,6 +1978,7 @@ dependencies = [
"mac_address",
"nix 0.31.3",
"openconnect",
+ "openssl",
"serde",
"serde_json",
"sha256",
@@ -4654,6 +4657,7 @@ checksum = "4ccbb212565d2dc177bc15ecb7b039d66c4490da892436a4eee5b394d620c9bc"
dependencies = [
"specta-macros",
"thiserror 1.0.69",
+ "uuid",
]
[[package]]
diff --git a/apps/gpclient/Cargo.toml b/apps/gpclient/Cargo.toml
index 86fc448..dd5713b 100644
--- a/apps/gpclient/Cargo.toml
+++ b/apps/gpclient/Cargo.toml
@@ -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
diff --git a/apps/gpclient/src/cli.rs b/apps/gpclient/src/cli.rs
index 429b96f..45188bc 100644
--- a/apps/gpclient/src/cli.rs
+++ b/apps/gpclient/src/cli.rs
@@ -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");
diff --git a/apps/gpclient/src/connect/credential.rs b/apps/gpclient/src/connect/credential.rs
index a1f6d27..147535e 100644
--- a/apps/gpclient/src/connect/credential.rs
+++ b/apps/gpclient/src/connect/credential.rs
@@ -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)
}
diff --git a/apps/gpclient/src/connect/flow_tests.rs b/apps/gpclient/src/connect/flow_tests.rs
new file mode 100644
index 0000000..9eff2ca
--- /dev/null
+++ b/apps/gpclient/src/connect/flow_tests.rs
@@ -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!(
+ "{}",
+ fields
+ .iter()
+ .map(|field| format!("{field}"))
+ .collect::()
+ )
+}
+
+async fn gateway(responses: Vec<(&'static str, String)>) -> (String, tokio::task::JoinHandle>) {
+ 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::().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",
+ "Success".into(),
+ ),
+ ("403 Forbidden", "rejected".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"));
+}
diff --git a/apps/gpclient/src/connect/gateway.rs b/apps/gpclient/src/connect/gateway.rs
index 0e23d95..1c06afe 100644
--- a/apps/gpclient/src/connect/gateway.rs
+++ b/apps/gpclient/src/connect/gateway.rs
@@ -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> {
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::()
+ .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 {
+ 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 {
+ 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::()
+ .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 {
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::>();
+ 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 {
+ pub(super) fn hip_source(&self, profile: OsProfile) -> anyhow::Result {
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]
diff --git a/apps/gpclient/src/connect/internal.rs b/apps/gpclient/src/connect/internal.rs
new file mode 100644
index 0000000..1f06017
--- /dev/null
+++ b/apps/gpclient/src/connect/internal.rs
@@ -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::>>()?;
+ 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- ) -> anyhow::Result {
+ 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
+ );
+ }
+}
diff --git a/apps/gpclient/src/connect/mod.rs b/apps/gpclient/src/connect/mod.rs
index 80f9e8b..f615df1 100644
--- a/apps/gpclient/src/connect/mod.rs
+++ b/apps/gpclient/src/connect/mod.rs
@@ -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,
@@ -32,6 +41,8 @@ pub(crate) struct ConnectHandler<'a> {
password_from_stdin: RefCell