mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 06:26:14 -05:00
Add tunnel configuration reporting, an optional CLI dashboard, manual browser authentication, native authentication controls, and broader client identity support. Improve TLS recovery, certificate validation, desktop notifications, and platform integration.
327 lines
9.5 KiB
Rust
327 lines
9.5 KiB
Rust
use anyhow::{anyhow, bail};
|
|
use log::{debug, info, warn};
|
|
use reqwest::{Client, StatusCode};
|
|
use serde::Serialize;
|
|
use specta::Type;
|
|
use xmltree::Element;
|
|
|
|
use crate::{
|
|
error::PortalError,
|
|
gp_params::GpParams,
|
|
os_profile::PreloginBrowserMode,
|
|
params::{gateway_prelogin, portal_prelogin},
|
|
utils::{base64, normalize_server, parse_gp_response, xml::ElementExt},
|
|
};
|
|
|
|
#[derive(Debug, Serialize, Type, Clone)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SamlPrelogin {
|
|
region: String,
|
|
is_gateway: bool,
|
|
saml_request: String,
|
|
support_default_browser: bool,
|
|
}
|
|
|
|
impl SamlPrelogin {
|
|
pub fn region(&self) -> &str {
|
|
&self.region
|
|
}
|
|
|
|
pub fn saml_request(&self) -> &str {
|
|
&self.saml_request
|
|
}
|
|
|
|
pub fn support_default_browser(&self) -> bool {
|
|
self.support_default_browser
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Type, Clone)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct StandardPrelogin {
|
|
region: String,
|
|
is_gateway: bool,
|
|
auth_message: String,
|
|
label_username: String,
|
|
label_password: String,
|
|
}
|
|
|
|
impl StandardPrelogin {
|
|
pub fn region(&self) -> &str {
|
|
&self.region
|
|
}
|
|
|
|
pub fn auth_message(&self) -> &str {
|
|
&self.auth_message
|
|
}
|
|
|
|
pub fn label_username(&self) -> &str {
|
|
&self.label_username
|
|
}
|
|
|
|
pub fn label_password(&self) -> &str {
|
|
&self.label_password
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Type, Clone)]
|
|
#[serde(tag = "type", rename_all = "camelCase")]
|
|
pub enum Prelogin {
|
|
Saml(SamlPrelogin),
|
|
Standard(StandardPrelogin),
|
|
}
|
|
|
|
impl Prelogin {
|
|
pub fn region(&self) -> &str {
|
|
match self {
|
|
Prelogin::Saml(saml) => saml.region(),
|
|
Prelogin::Standard(standard) => standard.region(),
|
|
}
|
|
}
|
|
|
|
pub fn is_gateway(&self) -> bool {
|
|
match self {
|
|
Prelogin::Saml(saml) => saml.is_gateway,
|
|
Prelogin::Standard(standard) => standard.is_gateway,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Default)]
|
|
pub struct PreloginOptions {
|
|
external_browser_requested: bool,
|
|
gateway_external_browser_allowed: bool,
|
|
}
|
|
|
|
impl PreloginOptions {
|
|
pub fn external_browser_requested(mut self, external_browser_requested: bool) -> Self {
|
|
self.external_browser_requested = external_browser_requested;
|
|
self
|
|
}
|
|
|
|
pub fn gateway_external_browser_allowed(mut self, gateway_external_browser_allowed: bool) -> Self {
|
|
self.gateway_external_browser_allowed = gateway_external_browser_allowed;
|
|
self
|
|
}
|
|
|
|
fn browser_mode(self, is_gateway: bool) -> PreloginBrowserMode {
|
|
if self.external_browser_requested && (!is_gateway || self.gateway_external_browser_allowed) {
|
|
PreloginBrowserMode::External
|
|
} else {
|
|
PreloginBrowserMode::Embedded
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn prelogin(portal: &str, gp_params: &GpParams, options: PreloginOptions) -> anyhow::Result<Prelogin> {
|
|
let user_agent = gp_params.user_agent();
|
|
let is_gateway = gp_params.is_gateway();
|
|
let prelogin_type = if is_gateway { "Gateway" } else { "Portal" };
|
|
|
|
let portal = normalize_server(portal)?;
|
|
let path = if is_gateway { "ssl-vpn" } else { "global-protect" };
|
|
let prelogin_url = format!("{portal}/{}/prelogin.esp", path);
|
|
let browser_mode = options.browser_mode(is_gateway);
|
|
let request_params = if is_gateway {
|
|
gateway_prelogin::build(gp_params.os_profile(), browser_mode)
|
|
} else {
|
|
portal_prelogin::build(gp_params.os_profile(), browser_mode)
|
|
};
|
|
let default_browser = request_param(&request_params, "default-browser").unwrap_or("");
|
|
|
|
info!(
|
|
"{} prelogin with user_agent: {}, default_browser: {}",
|
|
prelogin_type, user_agent, default_browser
|
|
);
|
|
|
|
let client = Client::try_from(gp_params)?;
|
|
let server_url = url::Url::parse(&portal)?;
|
|
|
|
let mut request = client.post(&prelogin_url);
|
|
if !request_params.query.is_empty() {
|
|
request = request.query(&request_params.query);
|
|
}
|
|
if !request_params.body.is_empty() {
|
|
request = request.form(&request_params.body);
|
|
}
|
|
|
|
let res = request.send().await.map_err(|e| {
|
|
warn!("Network error: {:?}", e);
|
|
match crate::error::ServerTlsError::from_request(&server_url, &e) {
|
|
Some(error) => anyhow!(error),
|
|
None => anyhow!(PortalError::NetworkError(e)),
|
|
}
|
|
})?;
|
|
|
|
let res_xml = parse_gp_response(res).await.or_else(|err| {
|
|
if let Some(tls) = crate::error::ServerTlsError::from_request(&server_url, &err) {
|
|
return Err(anyhow!(tls));
|
|
}
|
|
if err.status == StatusCode::NOT_FOUND {
|
|
bail!(PortalError::PreloginError("Prelogin endpoint not found".to_string()))
|
|
}
|
|
|
|
if err.is_status_error() {
|
|
warn!("{err}");
|
|
bail!("Prelogin error: {}", err.reason)
|
|
}
|
|
|
|
Err(anyhow!(PortalError::PreloginError(err.reason)))
|
|
})?;
|
|
|
|
debug!("Prelogin response XML: {}", res_xml);
|
|
|
|
let prelogin = parse_res_xml(&res_xml, is_gateway).map_err(|err| {
|
|
warn!("Parse response error, response: {}", res_xml);
|
|
PortalError::PreloginError(err.to_string())
|
|
})?;
|
|
|
|
Ok(prelogin)
|
|
}
|
|
|
|
fn request_param<'a>(params: &'a crate::params::RequestParams, name: &str) -> Option<&'a str> {
|
|
params
|
|
.body
|
|
.iter()
|
|
.chain(params.query.iter())
|
|
.find_map(|(key, value)| (key == name).then_some(value.as_str()))
|
|
}
|
|
|
|
fn parse_res_xml(res_xml: &str, is_gateway: bool) -> anyhow::Result<Prelogin> {
|
|
let root = Element::parse(res_xml.as_bytes())?;
|
|
|
|
let status = root
|
|
.descendant_text("status")
|
|
.ok_or_else(|| anyhow::anyhow!("Prelogin response does not contain status element"))?;
|
|
// Check the status of the prelogin response
|
|
if status.to_uppercase() != "SUCCESS" {
|
|
let msg = root
|
|
.descendant_text("msg")
|
|
.unwrap_or_else(|| String::from("Unknown error"));
|
|
bail!("{}", msg)
|
|
}
|
|
|
|
let region = root.descendant_text("region").unwrap_or_else(|| {
|
|
info!("Prelogin response does not contain region element");
|
|
String::from("Unknown")
|
|
});
|
|
|
|
let saml_method = root.descendant_text("saml-auth-method");
|
|
let saml_request = root.descendant_text("saml-request");
|
|
let saml_default_browser = root.descendant_text("saml-default-browser");
|
|
// Check if the prelogin response is SAML
|
|
if saml_method.is_some() && saml_request.is_some() {
|
|
let saml_request = base64::decode_to_string(&saml_request.unwrap())?;
|
|
let support_default_browser = saml_default_browser.map(|s| s.to_lowercase() == "yes").unwrap_or(false);
|
|
|
|
let saml_prelogin = SamlPrelogin {
|
|
region,
|
|
is_gateway,
|
|
saml_request,
|
|
support_default_browser,
|
|
};
|
|
|
|
return Ok(Prelogin::Saml(saml_prelogin));
|
|
}
|
|
|
|
let label_username = root.descendant_text("username-label").unwrap_or_else(|| {
|
|
info!("Username label has no value, using default");
|
|
String::from("Username")
|
|
});
|
|
let label_password = root.descendant_text("password-label").unwrap_or_else(|| {
|
|
info!("Password label has no value, using default");
|
|
String::from("Password")
|
|
});
|
|
|
|
let auth_message = root
|
|
.descendant_text("authentication-message")
|
|
.unwrap_or_else(|| String::from("Please enter the login credentials"));
|
|
let standard_prelogin = StandardPrelogin {
|
|
region,
|
|
is_gateway,
|
|
auth_message,
|
|
label_username,
|
|
label_password,
|
|
};
|
|
|
|
Ok(Prelogin::Standard(standard_prelogin))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::PreloginOptions;
|
|
use crate::{
|
|
gp_params::GpParams,
|
|
os_profile::{ClientOs, HostIdentity, OsProfile, PreloginBrowserMode},
|
|
params::{gateway_prelogin, portal_prelogin},
|
|
};
|
|
|
|
fn gp_params(client_os: ClientOs) -> GpParams {
|
|
let profile = OsProfile::builder(client_os)
|
|
.host_identity(HostIdentity::new(
|
|
"test-computer".to_string(),
|
|
"host-id".to_string(),
|
|
"serial".to_string(),
|
|
"aa:bb:cc:dd:ee:ff".to_string(),
|
|
))
|
|
.build();
|
|
GpParams::builder(profile).build()
|
|
}
|
|
|
|
#[test]
|
|
fn portal_prelogin_params_include_official_profile_fields() {
|
|
let gp_params = gp_params(ClientOs::Linux);
|
|
let request_params = portal_prelogin::build(gp_params.os_profile(), PreloginBrowserMode::Embedded);
|
|
|
|
let body: std::collections::HashMap<&str, &str> = request_params
|
|
.body
|
|
.iter()
|
|
.map(|(k, v)| (k.as_str(), v.as_str()))
|
|
.collect();
|
|
let query: std::collections::HashMap<&str, &str> = request_params
|
|
.query
|
|
.iter()
|
|
.map(|(k, v)| (k.as_str(), v.as_str()))
|
|
.collect();
|
|
|
|
assert_eq!(body.get("host-id"), Some(&gp_params.os_profile().host_id()));
|
|
assert_eq!(body.get("default-browser"), Some(&"-10"));
|
|
assert_eq!(body.get("cas-support"), Some(&"yes"));
|
|
assert_eq!(body.get("data"), Some(&r#"eyJjYXNfZW1iZWRkZWRfYnJvd3NlciI6InllcyJ9"#));
|
|
// Linux does not place kerberos-support in the query string.
|
|
assert_eq!(query.get("kerberos-support"), None);
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_prelogin_uses_gateway_default_browser() {
|
|
let gp_params = gp_params(ClientOs::Mac);
|
|
let request_params = gateway_prelogin::build(gp_params.os_profile(), PreloginBrowserMode::Embedded);
|
|
|
|
let body: std::collections::HashMap<&str, &str> = request_params
|
|
.body
|
|
.iter()
|
|
.map(|(k, v)| (k.as_str(), v.as_str()))
|
|
.collect();
|
|
|
|
assert_eq!(body.get("default-browser"), Some(&"0"));
|
|
}
|
|
|
|
#[test]
|
|
fn browser_mode_uses_external_for_portal_when_requested() {
|
|
let options = PreloginOptions::default().external_browser_requested(true);
|
|
|
|
assert_eq!(options.browser_mode(false), PreloginBrowserMode::External);
|
|
}
|
|
|
|
#[test]
|
|
fn browser_mode_requires_gateway_external_browser_allowed_for_gateway_external() {
|
|
let options = PreloginOptions::default().external_browser_requested(true);
|
|
|
|
assert_eq!(options.browser_mode(true), PreloginBrowserMode::Embedded);
|
|
|
|
let options = options.gateway_external_browser_allowed(true);
|
|
|
|
assert_eq!(options.browser_mode(true), PreloginBrowserMode::External);
|
|
}
|
|
}
|