mod args; mod credential; #[cfg(all(test, unix))] mod flow_tests; mod gateway; mod internal; #[cfg(unix)] #[path = "internal_output/unix.rs"] mod internal_output; #[cfg(windows)] #[path = "internal_output/windows.rs"] mod internal_output; #[cfg(unix)] mod tunnel_output; mod vpn_script; use std::cell::RefCell; #[cfg(unix)] use std::sync::{ Arc, atomic::{AtomicBool, Ordering}, }; use anyhow::bail; use gpapi::{ clap::report, error::PortalError, gateway::GatewaySelection, gp_params::GpParams, os_profile::OsProfile, portal::{PreloginOptions, discovery::discover, prelogin}, session::desktop::GatewaySessions, utils::request::RequestIdentityError, }; use inquire::{Password, PasswordDisplayMode, Select}; use log::{Level, 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> { cancellation: tokio_util::sync::CancellationToken, args: &'a ConnectArgs, shared_args: &'a SharedArgs<'a>, os_profile: RefCell, latest_key_password: RefCell>, password_from_stdin: RefCell>, cookie_from_stdin: RefCell>, clean_auth_state: RefCell, #[cfg(test)] auth_attempt_fixture: RefCell, auth_recovery: RefCell, sessions: RefCell, #[cfg(unix)] pid_written: Arc, #[cfg(unix)] background: Option, } 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 { cancellation: tokio_util::sync::CancellationToken::new(), 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)), #[cfg(test)] auth_attempt_fixture: Default::default(), auth_recovery: RefCell::default(), sessions: RefCell::default(), #[cfg(unix)] pid_written: Arc::default(), #[cfg(unix)] background: None, } } #[cfg(unix)] pub(crate) fn with_background(mut self, background: Option) -> Self { self.background = background; self } 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, gateway_browser_auth_allowed: bool) -> PreloginOptions { PreloginOptions::default() .external_browser_requested(self.external_browser_requested()) .gateway_external_browser_allowed(gateway_browser_auth_allowed) } pub(super) fn direct_gateway_prelogin_options(&self) -> PreloginOptions { self.prelogin_options(true) } pub(super) fn gateway_browser_auth_allowed(&self, portal_config_default_browser: bool) -> bool { gateway_browser_auth_allowed(portal_config_default_browser, self.external_browser_requested()) } 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<()> { let cancellation = self.cancellation.clone(); let signal = tokio::spawn(async move { gpapi::utils::shutdown_signal().await; cancellation.cancel(); }); self.auth_recovery.replace(Default::default()); 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; } #[cfg(unix)] 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("manual") || browser.eq_ignore_ascii_case("remote")) { bail!("The '--browser-listen' option requires '--browser manual'"); } #[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 { self.check_cancelled()?; let result = self.handle_impl().await; let Err(err) = self.auth_recovery.borrow().finish(result) else { return Ok(()); }; if err .downcast_ref::() .is_some() { return Err(err); } let Some(identity_error) = err.downcast_ref::() else { return Err(err); }; match identity_error { RequestIdentityError::UnsupportedEncryption | RequestIdentityError::UnsupportedKeyFormat | RequestIdentityError::UnsupportedKeyAlgorithm(_) | RequestIdentityError::KeyMismatch | RequestIdentityError::InvalidKey | RequestIdentityError::InvalidCertificate | RequestIdentityError::IncompletePkcs12 | RequestIdentityError::AmbiguousPkcs12 | RequestIdentityError::InvalidPkcs12(_) => return Err(err), RequestIdentityError::NoKey => { let format = self.shared_args.log_format; report( format, Level::Error, "ERROR: No private key found in the certificate file", ); report( format, Level::Error, "ERROR: Please provide the private key file using the `-k` option", ); return Ok(()); } RequestIdentityError::NoPassphrase(cert_type) | RequestIdentityError::DecryptError(cert_type) => { let message = if *cert_type == "PKCS#12" { "Enter the certificate file password:" } else { "Enter the private key password:" }; 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<()> { self.check_cancelled()?; 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(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(()); }; let err = self.auth_recovery.borrow().terminal(err); if err .downcast_ref::() .is_some() { return Err(err); } warn!("Failed to connect portal with prelogin: {}", err); if err.root_cause().downcast_ref::().is_some() { info!("Trying the gateway authentication workflow..."); self.connect_gateway_with_prelogin(server, server, false, None).await?; let format = self.shared_args.log_format; report( format, Level::Warn, "\nNOTE: the server may be a gateway, not a portal.", ); report( format, Level::Warn, "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 mut prelogin = tokio::select! { biased; _ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()), result = prelogin(portal, &gp_params, self.prelogin_options(false)) => result?, }; let cached = self.cached_portal_credential(portal); let cached_config = match cached { Some(cred) => match discover(portal, &cred, &gp_params, &self.cancellation).await { Ok(config) => Some((cred, config)), Err(error) => { self.check_cancelled()?; // A failed request does not establish that the cookie was rejected. if gateway::is_network_error(&error) { warn!("Cached portal authentication request failed: {error}"); return Err(error); } 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 (replacement, cred) = self .obtain_credential_with_recovery(prelogin.clone(), portal, false) .await?; prelogin = replacement; self.check_cancelled()?; let config = discover(portal, &cred, &gp_params, &self.cancellation).await?; (cred, config) } }; self.check_cancelled()?; 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 portal_config_default_browser = portal_config.default_browser().unwrap_or(false); info!("Portal config default-browser: {}", portal_config_default_browser); 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 = None; for (index, gateway) in gateways.iter().enumerate() { info!("Auto-gateway: attempting gateway {}", gateway); match self .connect_gateway_with_fallback( portal, gateway, &auth_cookie, &portal_config, GatewaySelection::Auto, &gateways[index + 1..], ) .await { Ok(()) => return Ok(()), Err(err) => { self.logout_gateway(gateway.server()).await; if self.auth_recovery.borrow().dmabuf_disabled() || !err.is_before_establishment() { return Err(self.auth_recovery.borrow().terminal(err.into_error())); } warn!( "Auto-gateway: gateway {} failed before session establishment: {}", 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.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) .prompt()?; info!("Connecting to the selected gateway: {}", gateway); gateway } else { info!("Connecting to the only available gateway: {}", gateways[0]); gateways[0] } } }; self .connect_gateway_with_fallback( portal, selected_gateway, &auth_cookie, &portal_config, gateway_selection, &[], ) .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() ); } } fn gateway_browser_auth_allowed(portal_config_default_browser: bool, external_browser_requested: bool) -> bool { portal_config_default_browser || external_browser_requested } #[cfg(test)] mod tests { use super::gateway_browser_auth_allowed; #[test] fn gateway_browser_auth_is_allowed_by_portal_config() { assert!(gateway_browser_auth_allowed(true, false)); } #[test] fn gateway_browser_auth_is_allowed_by_explicit_browser_request() { assert!(gateway_browser_auth_allowed(false, true)); } #[test] fn gateway_browser_auth_is_disabled_without_portal_config_or_user_request() { assert!(!gateway_browser_auth_allowed(false, false)); } }