mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 06:26:14 -05:00
refactor: align GP profile and packaging flow
Main changes: - Refactor connect/auth flows around a single OS profile and host identity model, including gateway fallback and cookie-on-stdin handling. - Align request parameters, HIP host-id propagation, SAML webview user-agent behavior, and portal default-browser handling with observed official client behavior. - Add opt-in cookie cache support and Microsoft Defender HIP reporting while keeping host-id validation explicit. - Add BSD build, packaging, release artifact, and provenance support with FreeBSD/OpenBSD path and dependency cleanup. - Update NixOS install documentation and dependency compatibility fixes.
This commit is contained in:
92 files changed
+9847
-2868
No files matched your search
@@ -0,0 +1,381 @@
|
||||
use clap::Args;
|
||||
use gpapi::{
|
||||
clap::args::Os,
|
||||
cookie_store,
|
||||
gp_params::CscMode,
|
||||
os_profile::{ClientOs, OsProfile},
|
||||
};
|
||||
use log::warn;
|
||||
use std::path::PathBuf;
|
||||
|
||||
#[derive(Args)]
|
||||
pub(crate) struct ConnectArgs {
|
||||
#[arg(help = "The portal server to connect to")]
|
||||
pub(super) server: String,
|
||||
|
||||
#[arg(short, long, help = "The gateway to connect to, it will prompt if not specified")]
|
||||
pub(super) gateway: Option<String>,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
conflicts_with = "gateway",
|
||||
help = "Automatically try gateways in priority order until gateway auth/config succeeds, without prompting"
|
||||
)]
|
||||
pub(super) auto_gateway: bool,
|
||||
|
||||
#[arg(short, long, help = "The username to use, it will prompt if not specified")]
|
||||
pub(super) user: Option<String>,
|
||||
|
||||
#[arg(long, help = "Read the password from standard input")]
|
||||
pub(super) passwd_on_stdin: bool,
|
||||
|
||||
#[arg(long, help = "Read the gpauth authentication result from standard input")]
|
||||
pub(super) cookie_on_stdin: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Read and write the portal cookie cache, optionally specify the cache file path",
|
||||
default_missing_value = "",
|
||||
num_args=0..=1
|
||||
)]
|
||||
pub(super) cookie_cache: Option<String>,
|
||||
|
||||
#[arg(long, short, help = "The VPNC script to use", required_if_eq("script_tun", "true"))]
|
||||
pub(super) script: Option<String>,
|
||||
|
||||
#[arg(long, short, help = "The IFNAME for tunnel interface")]
|
||||
pub(super) interface: Option<String>,
|
||||
|
||||
#[arg(long, short = 'S', help = "Pass traffic to '--script' program, not tun")]
|
||||
pub(super) script_tun: bool,
|
||||
|
||||
#[arg(long, help = "Connect the server as a gateway, instead of a portal")]
|
||||
pub(super) as_gateway: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Use HIP (Host Integrity Protection) extension, optionally specify the HIP script path",
|
||||
default_missing_value = "",
|
||||
num_args=0..=1
|
||||
)]
|
||||
pub(super) hip: Option<String>,
|
||||
|
||||
#[arg(long, help = "The user used to run the HIP script")]
|
||||
pub(super) hip_user: Option<String>,
|
||||
|
||||
#[arg(
|
||||
short,
|
||||
long,
|
||||
help = "Use SSL client certificate file in pkcs#8 (.pem) or pkcs#12 (.p12, .pfx) format"
|
||||
)]
|
||||
pub(super) certificate: Option<String>,
|
||||
|
||||
#[arg(short = 'k', long, help = "Use SSL private key file in pkcs#8 (.pem) format")]
|
||||
pub(super) sslkey: Option<String>,
|
||||
|
||||
#[arg(short = 'p', long, help = "The key passphrase of the private key")]
|
||||
pub(super) key_password: Option<String>,
|
||||
|
||||
#[arg(long, hide = true)]
|
||||
pub(super) csd_user: Option<String>,
|
||||
|
||||
#[arg(long, hide = true)]
|
||||
pub(super) csd_wrapper: Option<String>,
|
||||
|
||||
#[arg(long, default_value = "300", help = "Reconnection retry timeout in seconds")]
|
||||
pub(super) reconnect_timeout: u32,
|
||||
|
||||
#[arg(short, long, help = "Request MTU from server (legacy servers only)")]
|
||||
pub(super) mtu: Option<u32>,
|
||||
|
||||
#[arg(long, help = "Do not ask for IPv6 connectivity")]
|
||||
pub(super) disable_ipv6: bool,
|
||||
|
||||
#[arg(long = "user-agent", hide = true)]
|
||||
pub(super) deprecated_user_agent: Option<String>,
|
||||
|
||||
#[arg(long = "os-version", hide = true)]
|
||||
pub(super) deprecated_os_version: Option<String>,
|
||||
|
||||
#[arg(long, help = "Override the client version reported to the server, e.g., '6.2.4-49'")]
|
||||
pub(super) client_version: Option<String>,
|
||||
|
||||
#[arg(long, value_enum, default_value_t = Os::default())]
|
||||
pub(super) os: Os,
|
||||
|
||||
#[arg(long, value_enum, default_value_t = CscMode::Auto, help = "CSC support mode: auto, yes, or no")]
|
||||
pub(super) csc: CscMode,
|
||||
|
||||
#[arg(long, help = "Disable DTLS and ESP")]
|
||||
pub(super) no_dtls: bool,
|
||||
|
||||
#[arg(
|
||||
long = "local-hostname",
|
||||
help = "Same as the '--local-hostname' option in the openconnect command"
|
||||
)]
|
||||
pub(super) local_hostname: Option<String>,
|
||||
|
||||
#[arg(
|
||||
long = "force-dpd",
|
||||
help = "Same as the '--force-dpd' option in the openconnect command"
|
||||
)]
|
||||
pub(super) dpd_interval: Option<u32>,
|
||||
|
||||
#[arg(
|
||||
long = "no-xmlpost",
|
||||
help = "Same as the '--no-xmlpost' option in the openconnect command"
|
||||
)]
|
||||
pub(super) no_xmlpost: bool,
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
#[arg(long, help = "The HiDPI mode, useful for high-resolution screens")]
|
||||
pub(super) hidpi: bool,
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
#[arg(long, help = "Do not reuse the remembered authentication cookie")]
|
||||
pub(super) clean: bool,
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
#[arg(long, help = "Deprecated: Use the `--browser` option instead")]
|
||||
pub(super) default_browser: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Use the specified browser to authenticate, e.g., `default`, `firefox`, `chrome`, `chromium`, `remote`.\nOr the path to the browser executable.\nUse 'remote' for headless servers.",
|
||||
default_missing_value = "default",
|
||||
num_args=0..=1
|
||||
)]
|
||||
pub(super) browser: Option<String>,
|
||||
}
|
||||
|
||||
pub(super) fn build_os_profile(args: &ConnectArgs) -> OsProfile {
|
||||
build_os_profile_with_host_id(args, None)
|
||||
}
|
||||
|
||||
pub(super) fn build_os_profile_with_host_id(args: &ConnectArgs, host_id: Option<&str>) -> OsProfile {
|
||||
let mut builder = OsProfile::builder(ClientOs::from(args.os));
|
||||
if let Some(client_version) = args.client_version.as_deref() {
|
||||
builder = builder.client_version(client_version.to_string());
|
||||
}
|
||||
if let Some(local_hostname) = args.local_hostname.as_deref() {
|
||||
builder = builder.computer_name_override(local_hostname.to_string());
|
||||
}
|
||||
if let Some(host_id) = host_id {
|
||||
builder = builder.host_id_override(host_id);
|
||||
}
|
||||
builder.build()
|
||||
}
|
||||
|
||||
pub(super) fn cookie_cache_path(args: &ConnectArgs) -> Option<PathBuf> {
|
||||
args.cookie_cache.as_deref().map(|path| {
|
||||
let custom = (!path.is_empty()).then_some(path);
|
||||
cookie_store::cookie_path(custom)
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn warn_deprecated_connect_args(args: &ConnectArgs) {
|
||||
if args.csd_user.is_some() {
|
||||
warn!("Deprecated option --csd-user will be removed; use --hip-user instead");
|
||||
}
|
||||
|
||||
if args.csd_wrapper.is_some() {
|
||||
warn!("Deprecated option --csd-wrapper will be removed; use --hip instead");
|
||||
}
|
||||
|
||||
if args.deprecated_user_agent.is_some() {
|
||||
warn!("Deprecated option --user-agent is ignored; user agent is derived from --os");
|
||||
}
|
||||
|
||||
if args.deprecated_os_version.is_some() {
|
||||
warn!("Deprecated option --os-version is ignored; OS version is derived from --os");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[derive(clap::Parser)]
|
||||
struct ConnectArgsTestCli {
|
||||
#[command(flatten)]
|
||||
args: ConnectArgs,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_csc_mode_values() {
|
||||
use clap::ValueEnum;
|
||||
|
||||
assert_eq!(CscMode::from_str("auto", false), Ok(CscMode::Auto));
|
||||
assert_eq!(CscMode::from_str("yes", false), Ok(CscMode::Yes));
|
||||
assert_eq!(CscMode::from_str("no", false), Ok(CscMode::No));
|
||||
assert!(CscMode::from_str("maybe", false).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_gateway_flag_parses() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--auto-gateway"])
|
||||
.expect("--auto-gateway alone should parse");
|
||||
|
||||
assert!(cli.args.auto_gateway);
|
||||
assert!(cli.args.gateway.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_gateway_help_describes_auth_config_retry() {
|
||||
use clap::CommandFactory;
|
||||
|
||||
let help = ConnectArgsTestCli::command().render_long_help().to_string();
|
||||
|
||||
assert!(help.contains("--auto-gateway"));
|
||||
assert!(help.contains("Automatically try gateways in priority order until gateway auth/config succeeds"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gateway_flag_alone_parses() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--gateway", "gw1"])
|
||||
.expect("--gateway alone should parse");
|
||||
|
||||
assert!(!cli.args.auto_gateway);
|
||||
assert_eq!(cli.args.gateway.as_deref(), Some("gw1"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn os_defaults_to_runtime_os() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com"]).expect("connect args should parse");
|
||||
|
||||
assert_eq!(cli.args.os, Os::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deprecated_profile_override_flags_still_parse() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from([
|
||||
"test",
|
||||
"portal.example.com",
|
||||
"--user-agent",
|
||||
"legacy-agent",
|
||||
"--os-version",
|
||||
"legacy-os",
|
||||
"--client-version",
|
||||
"legacy-client",
|
||||
])
|
||||
.expect("deprecated profile override flags should remain parse-compatible");
|
||||
|
||||
assert_eq!(cli.args.deprecated_user_agent.as_deref(), Some("legacy-agent"));
|
||||
assert_eq!(cli.args.deprecated_os_version.as_deref(), Some("legacy-os"));
|
||||
assert_eq!(cli.args.client_version.as_deref(), Some("legacy-client"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deprecated_profile_override_flags_do_not_affect_os_profile() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from([
|
||||
"test",
|
||||
"portal.example.com",
|
||||
"--os",
|
||||
"Linux",
|
||||
"--user-agent",
|
||||
"legacy-agent",
|
||||
"--os-version",
|
||||
"legacy-os",
|
||||
"--client-version",
|
||||
"legacy-client",
|
||||
])
|
||||
.expect("deprecated profile override flags should remain parse-compatible");
|
||||
|
||||
let profile = build_os_profile(&cli.args);
|
||||
|
||||
assert_ne!(profile.user_agent(), "legacy-agent");
|
||||
assert_ne!(profile.os_version(), "legacy-os");
|
||||
assert_eq!(profile.client_version(), "legacy-client");
|
||||
assert!(profile.user_agent().contains("legacy-client"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdin_host_id_sets_profile_runtime_identity_seed() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--os", "Linux"])
|
||||
.expect("connect args should parse");
|
||||
|
||||
let profile = build_os_profile_with_host_id(&cli.args, Some("auth-host-id"));
|
||||
|
||||
assert_eq!(profile.host_identity().host_id(), "auth-host-id");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cookie_cache_is_disabled_by_default() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com"]).expect("connect args should parse");
|
||||
|
||||
assert!(cli.args.cookie_cache.is_none());
|
||||
assert!(cookie_cache_path(&cli.args).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cookie_cache_accepts_default_path_without_value() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--cookie-cache"])
|
||||
.expect("--cookie-cache without value should parse");
|
||||
|
||||
assert_eq!(cli.args.cookie_cache.as_deref(), Some(""));
|
||||
assert!(cookie_cache_path(&cli.args).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cookie_cache_accepts_custom_path() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli =
|
||||
ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--cookie-cache", "/tmp/gp-cookie.json"])
|
||||
.expect("--cookie-cache with value should parse");
|
||||
|
||||
assert_eq!(
|
||||
cookie_cache_path(&cli.args).as_deref(),
|
||||
Some(std::path::Path::new("/tmp/gp-cookie.json"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deprecated_hip_alias_flags_still_parse() {
|
||||
use clap::Parser;
|
||||
|
||||
let cli = ConnectArgsTestCli::try_parse_from([
|
||||
"test",
|
||||
"portal.example.com",
|
||||
"--csd-user",
|
||||
"legacy-user",
|
||||
"--csd-wrapper",
|
||||
"/tmp/legacy-hip.sh",
|
||||
])
|
||||
.expect("deprecated HIP alias flags should remain parse-compatible");
|
||||
|
||||
assert_eq!(cli.args.csd_user.as_deref(), Some("legacy-user"));
|
||||
assert_eq!(cli.args.csd_wrapper.as_deref(), Some("/tmp/legacy-hip.sh"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_gateway_and_gateway_are_mutually_exclusive() {
|
||||
use clap::Parser;
|
||||
use clap::error::ErrorKind;
|
||||
|
||||
let result =
|
||||
ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--gateway", "gw1", "--auto-gateway"]);
|
||||
|
||||
let err = match result {
|
||||
Ok(_) => panic!("--gateway and --auto-gateway must conflict"),
|
||||
Err(err) => err,
|
||||
};
|
||||
assert_eq!(err.kind(), ErrorKind::ArgumentConflict);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
use anyhow::{Context, bail};
|
||||
use gpapi::{
|
||||
auth::SamlAuthResult,
|
||||
clap::ToVerboseArg,
|
||||
credential::{Credential, PasswordCredential},
|
||||
portal::{Prelogin, StandardPrelogin},
|
||||
process::auth_launcher::SamlAuthLauncher,
|
||||
};
|
||||
use inquire::{Password, PasswordDisplayMode, Text};
|
||||
use log::info;
|
||||
|
||||
use super::ConnectHandler;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct CleanAuthState {
|
||||
requested: bool,
|
||||
}
|
||||
|
||||
impl CleanAuthState {
|
||||
pub(super) fn new(requested: bool) -> Self {
|
||||
Self { requested }
|
||||
}
|
||||
|
||||
fn consume_for_webview(&mut self, webview_auth: bool) -> bool {
|
||||
if !webview_auth || !self.requested {
|
||||
return false;
|
||||
}
|
||||
|
||||
self.requested = false;
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
impl ConnectHandler<'_> {
|
||||
pub(super) fn prepare_cookie_from_stdin(&self) -> anyhow::Result<()> {
|
||||
if !self.args.cookie_on_stdin || self.cookie_from_stdin.borrow().is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let auth_result = self.read_auth_result_from_stdin()?;
|
||||
log_stdin_host_id(auth_result.host_id());
|
||||
self.apply_stdin_host_id(auth_result.host_id());
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) async fn obtain_credential(&self, prelogin: &Prelogin, server: &str) -> anyhow::Result<Credential> {
|
||||
if should_read_stdin_credential(self.args.cookie_on_stdin, self.args.as_gateway, prelogin.is_gateway()) {
|
||||
return self.read_cookie_from_stdin();
|
||||
}
|
||||
|
||||
let is_gateway = prelogin.is_gateway();
|
||||
|
||||
match prelogin {
|
||||
Prelogin::Saml(prelogin) => {
|
||||
let browser = if prelogin.support_default_browser() {
|
||||
self.args.browser.as_deref()
|
||||
} else if !cfg!(feature = "webview-auth") {
|
||||
bail!(
|
||||
"The server does not support authentication via the default browser and the gpclient is not built with the `webview-auth` feature"
|
||||
);
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let verbose = self.shared_args.verbose.to_verbose_arg();
|
||||
let os_profile = self.os_profile.borrow().clone();
|
||||
let auth_launcher = SamlAuthLauncher::new(server)
|
||||
.gateway(is_gateway)
|
||||
.saml_request(prelogin.saml_request())
|
||||
.os_profile(&os_profile)
|
||||
.fix_openssl(self.shared_args.fix_openssl)
|
||||
.ignore_tls_errors(self.shared_args.ignore_tls_errors)
|
||||
.browser(browser)
|
||||
.verbose(verbose);
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
let use_default_browser = prelogin.support_default_browser() && self.args.default_browser;
|
||||
#[cfg(feature = "webview-auth")]
|
||||
let browser_kind = if browser.is_some() || use_default_browser {
|
||||
"external"
|
||||
} else {
|
||||
"embedded"
|
||||
};
|
||||
#[cfg(not(feature = "webview-auth"))]
|
||||
let browser_kind = "external";
|
||||
|
||||
let clean_auth = self
|
||||
.clean_auth_state
|
||||
.borrow_mut()
|
||||
.consume_for_webview(browser_kind == "embedded");
|
||||
|
||||
info!(
|
||||
"SAML auth launch: gateway={}, clean={}, browser={}",
|
||||
is_gateway, clean_auth, browser_kind
|
||||
);
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
let auth_launcher = auth_launcher
|
||||
.hidpi(self.args.hidpi)
|
||||
.clean(clean_auth)
|
||||
.default_browser(use_default_browser);
|
||||
|
||||
let cred = auth_launcher.launch().await?;
|
||||
Ok(cred)
|
||||
}
|
||||
|
||||
Prelogin::Standard(prelogin) => {
|
||||
let prefix = if is_gateway { "Gateway" } else { "Portal" };
|
||||
println!("{} ({}: {})", prelogin.auth_message(), prefix, server);
|
||||
|
||||
let user = self.args.user.as_ref().map_or_else(
|
||||
|| Text::new(&format!("{}:", prelogin.label_username())).prompt(),
|
||||
|user| Ok(user.to_owned()),
|
||||
)?;
|
||||
|
||||
let password = self.obtain_password(prelogin)?;
|
||||
let password_cred = PasswordCredential::new(&user, &password);
|
||||
|
||||
Ok(password_cred.into())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn read_cookie_from_stdin(&self) -> anyhow::Result<Credential> {
|
||||
if let Some(cookie) = self.cookie_from_stdin.borrow().as_ref() {
|
||||
info!("Reusing the cookie read from standard input");
|
||||
return Credential::try_from(serde_json::from_str::<SamlAuthResult>(cookie)?);
|
||||
}
|
||||
|
||||
let auth_result = self.read_auth_result_from_stdin()?;
|
||||
log_stdin_host_id(auth_result.host_id());
|
||||
self.apply_stdin_host_id(auth_result.host_id());
|
||||
Credential::try_from(auth_result)
|
||||
}
|
||||
|
||||
fn read_auth_result_from_stdin(&self) -> anyhow::Result<SamlAuthResult> {
|
||||
info!("Reading cookie from standard input");
|
||||
|
||||
let mut cookie = String::new();
|
||||
std::io::stdin().read_line(&mut cookie)?;
|
||||
|
||||
self.cookie_from_stdin.replace(Some(cookie.trim_end().to_owned()));
|
||||
|
||||
let auth_result = serde_json::from_str::<SamlAuthResult>(cookie.trim_end()).context("Failed to parse auth data")?;
|
||||
Ok(auth_result)
|
||||
}
|
||||
|
||||
fn obtain_password(&self, prelogin: &StandardPrelogin) -> anyhow::Result<String> {
|
||||
let password = if self.args.passwd_on_stdin {
|
||||
if let Some(password) = self.password_from_stdin.borrow().as_ref() {
|
||||
info!("Reusing the password read from standard input");
|
||||
return Ok(password.clone());
|
||||
}
|
||||
|
||||
info!("Reading password from standard input");
|
||||
let mut input = String::new();
|
||||
std::io::stdin().read_line(&mut input)?;
|
||||
let password = input.trim_end().to_owned();
|
||||
self.password_from_stdin.replace(Some(password.clone()));
|
||||
|
||||
password
|
||||
} else {
|
||||
Password::new(&format!("{}:", prelogin.label_password()))
|
||||
.without_confirmation()
|
||||
.with_display_mode(PasswordDisplayMode::Masked)
|
||||
.prompt()?
|
||||
};
|
||||
|
||||
Ok(password)
|
||||
}
|
||||
}
|
||||
|
||||
fn should_read_stdin_credential(cookie_on_stdin: bool, as_gateway: bool, prelogin_is_gateway: bool) -> bool {
|
||||
cookie_on_stdin && (!prelogin_is_gateway || as_gateway)
|
||||
}
|
||||
|
||||
fn log_stdin_host_id(host_id: Option<&str>) {
|
||||
match host_id {
|
||||
Some(host_id) => info!("stdin auth result host-id: {}", host_id),
|
||||
None => info!("stdin auth result host-id: <none>"),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn clean_auth_state_is_consumed_once_for_webview() {
|
||||
let mut state = CleanAuthState::new(true);
|
||||
|
||||
assert!(state.consume_for_webview(true));
|
||||
assert!(!state.consume_for_webview(true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clean_auth_state_is_not_consumed_by_external_browser() {
|
||||
let mut state = CleanAuthState::new(true);
|
||||
|
||||
assert!(!state.consume_for_webview(false));
|
||||
assert!(state.consume_for_webview(true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clean_auth_state_remains_false_when_not_requested() {
|
||||
let mut state = CleanAuthState::new(false);
|
||||
|
||||
assert!(!state.consume_for_webview(true));
|
||||
assert!(!state.consume_for_webview(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdin_credential_is_allowed_for_portal_auth() {
|
||||
assert!(should_read_stdin_credential(true, false, false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdin_credential_is_allowed_for_direct_gateway_auth() {
|
||||
assert!(should_read_stdin_credential(true, true, true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdin_credential_is_not_reused_for_gateway_fallback_auth() {
|
||||
assert!(!should_read_stdin_credential(true, false, true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdin_credential_is_not_used_when_flag_is_disabled() {
|
||||
assert!(!should_read_stdin_credential(false, false, false));
|
||||
assert!(!should_read_stdin_credential(false, true, true));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,502 @@
|
||||
use std::{
|
||||
fs,
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
},
|
||||
};
|
||||
|
||||
use gpapi::{
|
||||
cookie_store,
|
||||
credential::{AuthCookieCredential, Credential},
|
||||
gateway::{GatewayLogin, GatewayLoginContext, SessionExtensionAuth, gateway_login, gateway_login_with_context},
|
||||
gp_params::GpParams,
|
||||
os_profile::OsProfile,
|
||||
portal::prelogin,
|
||||
process::users::{get_non_root_user, get_user_by_name},
|
||||
utils::shutdown_signal,
|
||||
};
|
||||
use inquire::Text;
|
||||
use log::{info, warn};
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
use tokio::{runtime::Handle, task::JoinHandle};
|
||||
|
||||
use crate::{
|
||||
GP_CLIENT_LOCK_FILE,
|
||||
session::{SessionContextInput, build_session_context, session_info_from_vpn, spawn_session_runtime_with_info},
|
||||
};
|
||||
|
||||
use super::{ConnectHandler, args::cookie_cache_path};
|
||||
|
||||
struct GatewayLoginSession {
|
||||
cookie: String,
|
||||
extension_auth: SessionExtensionAuth,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum GatewayConnectFailureStage {
|
||||
BeforeTunnel,
|
||||
AfterTunnel,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(super) struct GatewayConnectError {
|
||||
stage: GatewayConnectFailureStage,
|
||||
error: anyhow::Error,
|
||||
}
|
||||
|
||||
impl GatewayConnectError {
|
||||
fn before_tunnel(error: anyhow::Error) -> Self {
|
||||
Self {
|
||||
stage: GatewayConnectFailureStage::BeforeTunnel,
|
||||
error,
|
||||
}
|
||||
}
|
||||
|
||||
fn after_tunnel(error: anyhow::Error) -> Self {
|
||||
Self {
|
||||
stage: GatewayConnectFailureStage::AfterTunnel,
|
||||
error,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_before_tunnel(&self) -> bool {
|
||||
self.stage == GatewayConnectFailureStage::BeforeTunnel
|
||||
}
|
||||
|
||||
pub(super) fn as_error(&self) -> &anyhow::Error {
|
||||
&self.error
|
||||
}
|
||||
|
||||
pub(super) fn into_error(self) -> anyhow::Error {
|
||||
self.error
|
||||
}
|
||||
}
|
||||
|
||||
impl ConnectHandler<'_> {
|
||||
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 {
|
||||
Ok(session) => session,
|
||||
Err(err) => {
|
||||
warn!(
|
||||
"Cached portal cookie rejected by gateway {}: {}. Clearing cache and falling back to portal auth.",
|
||||
stored.last_gateway, err
|
||||
);
|
||||
cookie_store::clear(&path);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
match self
|
||||
.connect_gateway(
|
||||
server,
|
||||
&stored.last_gateway,
|
||||
&login_session.cookie,
|
||||
false,
|
||||
login_session.extension_auth,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(()) => Some(()),
|
||||
Err(err) => {
|
||||
warn!("Gateway connect failed after cached-cookie login: {}", err.as_error());
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn connect_gateway_with_prelogin(
|
||||
&self,
|
||||
portal: &str,
|
||||
gateway: &str,
|
||||
allow_extend_session: bool,
|
||||
gateway_context: Option<GatewayLoginContext>,
|
||||
) -> anyhow::Result<()> {
|
||||
info!("Performing the gateway authentication...");
|
||||
|
||||
let mut gp_params = self.build_gp_params();
|
||||
gp_params.set_is_gateway(true);
|
||||
|
||||
let prelogin = prelogin(gateway, &gp_params, self.prelogin_options(false)).await?;
|
||||
let cred = self.obtain_credential(&prelogin, gateway).await?;
|
||||
|
||||
let login_session = self
|
||||
.login_gateway(gateway, &cred, &gp_params, gateway_context.as_ref())
|
||||
.await?;
|
||||
|
||||
self
|
||||
.connect_gateway(
|
||||
portal,
|
||||
gateway,
|
||||
&login_session.cookie,
|
||||
allow_extend_session,
|
||||
login_session.extension_auth,
|
||||
)
|
||||
.await
|
||||
.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: &str,
|
||||
portal_cred: &AuthCookieCredential,
|
||||
allow_extend_session: bool,
|
||||
portal_default_browser_enabled: bool,
|
||||
gateway_context: GatewayLoginContext,
|
||||
) -> Result<(), GatewayConnectError> {
|
||||
info!("Connecting to gateway with portal-cookie first, gateway prelogin fallback...");
|
||||
|
||||
let mut gp_params = self.build_gp_params();
|
||||
gp_params.set_is_gateway(true);
|
||||
|
||||
let gateway_prelogin = prelogin(
|
||||
gateway,
|
||||
&gp_params,
|
||||
self.prelogin_options(portal_default_browser_enabled),
|
||||
)
|
||||
.await
|
||||
.map_err(GatewayConnectError::before_tunnel)?;
|
||||
|
||||
if portal_cred.can_authenticate_gateway() {
|
||||
let portal_cred_for_login: Credential = portal_cred.into();
|
||||
match self
|
||||
.login_gateway(gateway, &portal_cred_for_login, &gp_params, Some(&gateway_context))
|
||||
.await
|
||||
{
|
||||
Ok(login_session) => {
|
||||
info!("Gateway login with portal auth cookies succeeded");
|
||||
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;
|
||||
}
|
||||
Err(err) => {
|
||||
info!("Gateway login with portal auth cookies failed: {}", err);
|
||||
info!("Falling back to gateway prelogin authentication...");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
info!("Portal config did not provide gateway auth cookies; using gateway prelogin flow");
|
||||
}
|
||||
|
||||
let gateway_cred = match self.obtain_credential(&gateway_prelogin, gateway).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,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
fn save_cookie_cache(&self, portal: &str, gateway: &str, auth_cookie: &AuthCookieCredential) {
|
||||
let Some(path) = cookie_cache_path(self.args) else {
|
||||
return;
|
||||
};
|
||||
|
||||
if !auth_cookie.can_authenticate_gateway() {
|
||||
return;
|
||||
}
|
||||
|
||||
let stored = cookie_store::StoredCookie::new(
|
||||
portal.to_string(),
|
||||
auth_cookie.username().to_string(),
|
||||
self.os_profile.borrow().host_identity().host_id().to_string(),
|
||||
gateway.to_string(),
|
||||
auth_cookie.clone(),
|
||||
);
|
||||
|
||||
match cookie_store::save(&path, &stored) {
|
||||
Ok(()) => info!("Saved portal cookie cache to {}", path.display()),
|
||||
Err(err) => warn!("Failed to save portal cookie cache to {}: {}", path.display(), err),
|
||||
}
|
||||
}
|
||||
|
||||
fn print_direct_gateway_recommendation(&self, gateway: &str) {
|
||||
if !self.args.cookie_on_stdin {
|
||||
return;
|
||||
}
|
||||
|
||||
eprintln!("\nNOTE: Gateway authentication failed after portal login.");
|
||||
eprintln!("NOTE: If this server also accepts direct gateway login, try:");
|
||||
eprintln!("NOTE: {}", direct_gateway_command(gateway));
|
||||
}
|
||||
|
||||
async fn login_gateway(
|
||||
&self,
|
||||
gateway: &str,
|
||||
cred: &Credential,
|
||||
gp_params: &GpParams,
|
||||
gateway_context: Option<&GatewayLoginContext>,
|
||||
) -> anyhow::Result<GatewayLoginSession> {
|
||||
let mut gp_params = gp_params.clone();
|
||||
|
||||
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?,
|
||||
};
|
||||
|
||||
match login {
|
||||
GatewayLogin::Cookie(cookie) => {
|
||||
return Ok(GatewayLoginSession {
|
||||
cookie,
|
||||
extension_auth: SessionExtensionAuth::new(cred.clone(), gp_params),
|
||||
});
|
||||
}
|
||||
GatewayLogin::Mfa(message, input_str) => {
|
||||
let otp = Text::new(&message).prompt()?;
|
||||
gp_params.set_input_str(&input_str);
|
||||
gp_params.set_otp(&otp);
|
||||
|
||||
info!("Retrying gateway login with MFA...");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn connect_gateway(
|
||||
&self,
|
||||
portal: &str,
|
||||
gateway: &str,
|
||||
cookie: &str,
|
||||
allow_extend_session: bool,
|
||||
extension_auth: SessionExtensionAuth,
|
||||
) -> Result<(), GatewayConnectError> {
|
||||
let mtu = self.args.mtu.unwrap_or(0);
|
||||
let (hip, csd_wrapper) = self.determine_hip_script();
|
||||
let hip_user = self.determine_hip_user();
|
||||
let csd_uid = get_uid(&hip_user).map_err(GatewayConnectError::before_tunnel)?;
|
||||
let os_profile = self.os_profile.borrow().clone();
|
||||
|
||||
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(),
|
||||
disable_ipv6: self.args.disable_ipv6,
|
||||
extension_auth: Some(extension_auth),
|
||||
});
|
||||
let vpn_builder = Vpn::builder(gateway, cookie)
|
||||
.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())
|
||||
.hip(hip)
|
||||
.csd_uid(csd_uid)
|
||||
.csd_wrapper(csd_wrapper)
|
||||
.reconnect_timeout(self.args.reconnect_timeout)
|
||||
.mtu(mtu)
|
||||
.disable_ipv6(self.args.disable_ipv6)
|
||||
.no_dtls(self.args.no_dtls)
|
||||
.local_hostname(self.args.local_hostname.clone())
|
||||
.dpd_interval(self.args.dpd_interval.unwrap_or(0))
|
||||
.no_xmlpost(self.args.no_xmlpost);
|
||||
let vpn = apply_os_profile(vpn_builder, &os_profile)
|
||||
.build()
|
||||
.map_err(|err| GatewayConnectError::before_tunnel(err.into()))?;
|
||||
|
||||
let vpn = Arc::new(vpn);
|
||||
let vpn_clone = vpn.clone();
|
||||
let runtime_handle = Handle::current();
|
||||
let session_ctx = Arc::new(Mutex::new(Some(session_ctx)));
|
||||
let session_task: Arc<Mutex<Option<JoinHandle<()>>>> = Arc::new(Mutex::new(None));
|
||||
let session_task_on_connect = Arc::clone(&session_task);
|
||||
let session_ctx_on_connect = Arc::clone(&session_ctx);
|
||||
let tunnel_established = Arc::new(AtomicBool::new(false));
|
||||
let tunnel_established_on_connect = Arc::clone(&tunnel_established);
|
||||
|
||||
tokio::spawn(async move {
|
||||
shutdown_signal().await;
|
||||
info!("Received the interrupt signal, disconnecting...");
|
||||
vpn_clone.disconnect();
|
||||
});
|
||||
|
||||
let connect_result = vpn.connect(move |vpn_session_info| {
|
||||
tunnel_established_on_connect.store(true, Ordering::SeqCst);
|
||||
write_pid_file();
|
||||
|
||||
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);
|
||||
session_task_on_connect.lock().unwrap().replace(task);
|
||||
});
|
||||
let tunnel_established = tunnel_established.load(Ordering::SeqCst);
|
||||
|
||||
if let Some(task) = session_task.lock().unwrap().take() {
|
||||
task.abort();
|
||||
}
|
||||
|
||||
if fs::metadata(GP_CLIENT_LOCK_FILE).is_ok() {
|
||||
info!("Removing PID file");
|
||||
fs::remove_file(GP_CLIENT_LOCK_FILE).map_err(|err| GatewayConnectError::after_tunnel(err.into()))?;
|
||||
}
|
||||
|
||||
classify_openconnect_result(connect_result, tunnel_established)
|
||||
}
|
||||
|
||||
fn determine_hip_script(&self) -> (bool, Option<String>) {
|
||||
if let Some(hip) = &self.args.hip {
|
||||
return if hip.is_empty() {
|
||||
(true, None)
|
||||
} else {
|
||||
(true, Some(hip.clone()))
|
||||
};
|
||||
}
|
||||
|
||||
(self.args.csd_wrapper.is_some(), self.args.csd_wrapper.clone())
|
||||
}
|
||||
|
||||
fn determine_hip_user(&self) -> Option<String> {
|
||||
if let Some(hip_user) = &self.args.hip_user {
|
||||
return Some(hip_user.clone());
|
||||
}
|
||||
|
||||
self.args.csd_user.clone()
|
||||
}
|
||||
}
|
||||
|
||||
fn classify_openconnect_result(exit_code: i32, tunnel_established: bool) -> Result<(), GatewayConnectError> {
|
||||
if exit_code == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let error = anyhow::anyhow!("OpenConnect exited with status {}", exit_code);
|
||||
if tunnel_established {
|
||||
Err(GatewayConnectError::after_tunnel(error))
|
||||
} else {
|
||||
Err(GatewayConnectError::before_tunnel(error))
|
||||
}
|
||||
}
|
||||
|
||||
fn direct_gateway_command(gateway: &str) -> String {
|
||||
format!("gpauth --gateway {gateway} | sudo gpclient connect {gateway} --as-gateway --cookie-on-stdin")
|
||||
}
|
||||
|
||||
fn write_pid_file() {
|
||||
let pid = std::process::id();
|
||||
|
||||
if let Err(err) = fs::write(GP_CLIENT_LOCK_FILE, pid.to_string()) {
|
||||
warn!("Failed to write PID file: {}", err);
|
||||
} else {
|
||||
info!("Wrote PID {} to {}", pid, GP_CLIENT_LOCK_FILE);
|
||||
}
|
||||
}
|
||||
|
||||
fn get_uid(user: &Option<String>) -> anyhow::Result<u32> {
|
||||
if let Some(user) = user {
|
||||
get_user_by_name(user).map(|user| user.uid())
|
||||
} else {
|
||||
get_non_root_user().map_or_else(|_| Ok(0), |user| Ok(user.uid()))
|
||||
}
|
||||
}
|
||||
|
||||
fn apply_os_profile(builder: VpnBuilder, profile: &OsProfile) -> VpnBuilder {
|
||||
builder
|
||||
.os(Some(profile.client_os().to_openconnect_os().to_string()))
|
||||
.os_version(Some(profile.os_version().to_string()))
|
||||
.client_version(Some(profile.client_version().to_string()))
|
||||
.host_id(Some(profile.host_identity().host_id().to_string()))
|
||||
.user_agent(Some(profile.user_agent().to_string()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn openconnect_success_is_not_a_gateway_failure() {
|
||||
assert!(classify_openconnect_result(0, false).is_ok());
|
||||
assert!(classify_openconnect_result(0, true).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openconnect_failure_before_callback_is_retryable_gateway_failure() {
|
||||
let err = classify_openconnect_result(1, false).expect_err("nonzero exit should fail");
|
||||
|
||||
assert!(err.is_before_tunnel());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openconnect_failure_after_callback_is_terminal_gateway_failure() {
|
||||
let err = classify_openconnect_result(1, true).expect_err("nonzero exit should fail");
|
||||
|
||||
assert!(!err.is_before_tunnel());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direct_gateway_recommendation_uses_gateway_server() {
|
||||
assert_eq!(
|
||||
direct_gateway_command("gateway.example.test"),
|
||||
"gpauth --gateway gateway.example.test | sudo gpclient connect gateway.example.test --as-gateway --cookie-on-stdin"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,281 @@
|
||||
mod args;
|
||||
mod credential;
|
||||
mod gateway;
|
||||
|
||||
use std::cell::RefCell;
|
||||
|
||||
use anyhow::bail;
|
||||
use gpapi::{
|
||||
error::PortalError,
|
||||
gateway::{GatewayLoginContext, GatewaySelection},
|
||||
gp_params::GpParams,
|
||||
os_profile::OsProfile,
|
||||
portal::{PreloginOptions, prelogin, retrieve_config},
|
||||
utils::request::RequestIdentityError,
|
||||
};
|
||||
use inquire::{Password, PasswordDisplayMode, Select};
|
||||
use log::{info, warn};
|
||||
|
||||
use crate::cli::SharedArgs;
|
||||
|
||||
pub(crate) use args::ConnectArgs;
|
||||
use args::{build_os_profile, build_os_profile_with_host_id, warn_deprecated_connect_args};
|
||||
use credential::CleanAuthState;
|
||||
use gateway::GatewayConnectError;
|
||||
|
||||
pub(crate) struct ConnectHandler<'a> {
|
||||
args: &'a ConnectArgs,
|
||||
shared_args: &'a SharedArgs<'a>,
|
||||
os_profile: RefCell<OsProfile>,
|
||||
latest_key_password: RefCell<Option<String>>,
|
||||
password_from_stdin: RefCell<Option<String>>,
|
||||
cookie_from_stdin: RefCell<Option<String>>,
|
||||
clean_auth_state: RefCell<CleanAuthState>,
|
||||
}
|
||||
|
||||
impl<'a> ConnectHandler<'a> {
|
||||
pub(crate) fn new(args: &'a ConnectArgs, shared_args: &'a SharedArgs) -> Self {
|
||||
warn_deprecated_connect_args(args);
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
let clean_auth = args.clean;
|
||||
#[cfg(not(feature = "webview-auth"))]
|
||||
let clean_auth = false;
|
||||
|
||||
Self {
|
||||
args,
|
||||
shared_args,
|
||||
os_profile: RefCell::new(build_os_profile(args)),
|
||||
latest_key_password: Default::default(),
|
||||
password_from_stdin: Default::default(),
|
||||
cookie_from_stdin: Default::default(),
|
||||
clean_auth_state: RefCell::new(CleanAuthState::new(clean_auth)),
|
||||
}
|
||||
}
|
||||
|
||||
fn build_gp_params(&self) -> GpParams {
|
||||
let mut builder = GpParams::builder(self.os_profile.borrow().clone());
|
||||
builder
|
||||
.csc_mode(self.args.csc)
|
||||
.ignore_tls_errors(self.shared_args.ignore_tls_errors)
|
||||
.certificate(self.args.certificate.clone())
|
||||
.sslkey(self.args.sslkey.clone())
|
||||
.key_password(self.latest_key_password.borrow().clone());
|
||||
|
||||
builder.build()
|
||||
}
|
||||
|
||||
pub(super) fn prelogin_options(&self, portal_default_browser_enabled: bool) -> PreloginOptions {
|
||||
PreloginOptions::default()
|
||||
.external_browser_requested(self.external_browser_requested())
|
||||
.portal_default_browser_enabled(portal_default_browser_enabled)
|
||||
}
|
||||
|
||||
fn external_browser_requested(&self) -> bool {
|
||||
#[cfg(feature = "webview-auth")]
|
||||
{
|
||||
self.args.default_browser || self.args.browser.is_some()
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "webview-auth"))]
|
||||
{
|
||||
self.args.browser.is_some()
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn handle(&self) -> anyhow::Result<()> {
|
||||
#[cfg(feature = "webview-auth")]
|
||||
if self.args.default_browser && self.args.browser.is_some() {
|
||||
bail!("Cannot use `--default-browser` and `--browser` options at the same time");
|
||||
}
|
||||
|
||||
self.latest_key_password.replace(self.args.key_password.clone());
|
||||
|
||||
loop {
|
||||
let Err(err) = self.handle_impl().await else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
let Some(root_cause) = err.root_cause().downcast_ref::<RequestIdentityError>() else {
|
||||
return Err(err);
|
||||
};
|
||||
|
||||
match root_cause {
|
||||
RequestIdentityError::NoKey => {
|
||||
eprintln!("ERROR: No private key found in the certificate file");
|
||||
eprintln!("ERROR: Please provide the private key file using the `-k` option");
|
||||
return Ok(());
|
||||
}
|
||||
RequestIdentityError::NoPassphrase(cert_type) | RequestIdentityError::DecryptError(cert_type) => {
|
||||
let message = format!("Enter the {} passphrase:", cert_type);
|
||||
let password = Password::new(&message)
|
||||
.without_confirmation()
|
||||
.with_display_mode(PasswordDisplayMode::Masked)
|
||||
.prompt()?;
|
||||
|
||||
self.latest_key_password.replace(Some(password));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn handle_impl(&self) -> anyhow::Result<()> {
|
||||
let server = self.args.server.as_str();
|
||||
let as_gateway = self.args.as_gateway;
|
||||
|
||||
self.prepare_cookie_from_stdin()?;
|
||||
|
||||
if as_gateway {
|
||||
info!("Treating the server as a gateway");
|
||||
return self.connect_gateway_with_prelogin(server, server, false, None).await;
|
||||
}
|
||||
|
||||
if !self.args.cookie_on_stdin {
|
||||
if let Some(()) = self.try_cached_cookie(server).await {
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
let Err(err) = self.connect_portal_with_prelogin(server).await else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
warn!("Failed to connect portal with prelogin: {}", err);
|
||||
if err.root_cause().downcast_ref::<PortalError>().is_some() {
|
||||
info!("Trying the gateway authentication workflow...");
|
||||
self.connect_gateway_with_prelogin(server, server, false, None).await?;
|
||||
|
||||
eprintln!("\nNOTE: the server may be a gateway, not a portal.");
|
||||
eprintln!("NOTE: try to use the `--as-gateway` option if you were authenticated twice.");
|
||||
|
||||
Ok(())
|
||||
} else {
|
||||
Err(err)
|
||||
}
|
||||
}
|
||||
|
||||
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 cred = self.obtain_credential(&prelogin, portal).await?;
|
||||
let mut portal_config = retrieve_config(portal, &cred, &gp_params).await?;
|
||||
|
||||
portal_config.sort_gateways(prelogin.region());
|
||||
|
||||
let auth_cookie = match cred.password() {
|
||||
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_default_browser_enabled = portal_config.default_browser().unwrap_or(false);
|
||||
|
||||
if self.args.auto_gateway {
|
||||
let gateways = portal_config.gateways();
|
||||
if gateways.is_empty() {
|
||||
bail!("No gateways available in portal config for auto-gateway selection");
|
||||
}
|
||||
|
||||
info!(
|
||||
"Auto-gateway mode: trying {} gateway(s) in priority order",
|
||||
gateways.len()
|
||||
);
|
||||
|
||||
let mut last_err: Option<anyhow::Error> = None;
|
||||
for gateway in &gateways {
|
||||
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(),
|
||||
&auth_cookie,
|
||||
allow_extend_session,
|
||||
portal_default_browser_enabled,
|
||||
gateway_context,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(()) => return Ok(()),
|
||||
Err(err) => {
|
||||
if !err.is_before_tunnel() {
|
||||
return Err(err.into_error());
|
||||
}
|
||||
warn!(
|
||||
"Auto-gateway: gateway {} failed before tunnel setup: {}",
|
||||
gateway,
|
||||
err.as_error()
|
||||
);
|
||||
last_err = Some(err.into_error());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let detail = last_err
|
||||
.map(|e| e.to_string())
|
||||
.unwrap_or_else(|| "unknown error".to_string());
|
||||
bail!(
|
||||
"Auto-gateway: all {} gateway(s) failed to connect; last error: {}",
|
||||
gateways.len(),
|
||||
detail
|
||||
);
|
||||
}
|
||||
|
||||
let gateway_selection = if self.args.gateway.is_some() {
|
||||
GatewaySelection::Manual
|
||||
} else {
|
||||
GatewaySelection::Auto
|
||||
};
|
||||
let selected_gateway = match &self.args.gateway {
|
||||
Some(gateway) => portal_config
|
||||
.find_gateway(gateway)
|
||||
.ok_or_else(|| anyhow::anyhow!("Cannot find gateway specified: {}", gateway))?,
|
||||
None => {
|
||||
let gateways = portal_config.gateways();
|
||||
|
||||
if gateways.len() > 1 {
|
||||
let gateway = Select::new("Which gateway do you want to connect to?", gateways)
|
||||
.with_vim_mode(true)
|
||||
.prompt()?;
|
||||
info!("Connecting to the selected gateway: {}", gateway);
|
||||
gateway
|
||||
} else {
|
||||
info!("Connecting to the only available gateway: {}", gateways[0]);
|
||||
gateways[0]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
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,
|
||||
&auth_cookie,
|
||||
allow_extend_session,
|
||||
portal_default_browser_enabled,
|
||||
gateway_context,
|
||||
)
|
||||
.await
|
||||
.map_err(GatewayConnectError::into_error)
|
||||
}
|
||||
|
||||
fn apply_stdin_host_id(&self, host_id: Option<&str>) {
|
||||
let Some(host_id) = host_id else {
|
||||
return;
|
||||
};
|
||||
self
|
||||
.os_profile
|
||||
.replace(build_os_profile_with_host_id(self.args, Some(host_id)));
|
||||
info!(
|
||||
"connect profile host-id: {}",
|
||||
self.os_profile.borrow().host_identity().host_id()
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user