feat: support internal non-tunnel gateway sessions

This commit is contained in:
Kevin Yue committed 2026-10-04 00:32:10 +08:00
1 parent eec18375cd
commit d518177bd1
58 files changed
+7897 -949

No files matched your search

+48 -3
View File
@@ -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");
+2 -1
View File
@@ -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)
}
+173
View File
@@ -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"));
}
+256 -160
View File
@@ -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, &params, 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]
+226
View File
@@ -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
);
}
}
+94 -25
View File
@@ -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)