mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
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.
488 lines
15 KiB
Rust
488 lines
15 KiB
Rust
use std::net::ToSocketAddrs;
|
|
|
|
use super::{RequestParams, credential as credential_params};
|
|
use crate::{credential::Credential, gateway::GatewayLoginContext, gp_params::GpParams};
|
|
|
|
/// Inputs required to build gateway login request parameters.
|
|
pub(crate) struct GatewayLoginInput<'a> {
|
|
pub gp_params: &'a GpParams,
|
|
pub cred: &'a Credential,
|
|
pub gateway_host: &'a str,
|
|
pub context: Option<&'a GatewayLoginContext>,
|
|
pub client_ip: Option<&'a str>,
|
|
pub extend_lifetime: bool,
|
|
}
|
|
|
|
/// Build request parameters for the gateway login endpoint.
|
|
///
|
|
/// Resolves the `server` parameter to an IPv4 address when
|
|
/// `profile.gateway_server_uses_resolved_ipv4()` is true.
|
|
/// Sets `gw` and `gateway-name` to the gateway FQDN.
|
|
pub(crate) fn build(input: &GatewayLoginInput) -> RequestParams {
|
|
let profile = input.gp_params.os_profile();
|
|
let mut body: Vec<(String, String)> = Vec::new();
|
|
|
|
// Credential params (user, passwd, prelogin-cookie, portal-userauthcookie, etc.)
|
|
body.extend(credential_params::build(input.cred, input.gp_params));
|
|
|
|
// Common login params
|
|
body.push(("prot".into(), "https:".into()));
|
|
body.push(("jnlpReady".into(), "jnlpReady".into()));
|
|
body.push(("ok".into(), "Login".into()));
|
|
body.push(("direct".into(), "yes".into()));
|
|
body.push(("ipv6-support".into(), "yes".into()));
|
|
body.push(("clientVer".into(), "4100".into()));
|
|
body.push(("clientos".into(), profile.client_os().as_str().into()));
|
|
body.push(("computer".into(), profile.computer().into()));
|
|
body.push((
|
|
"inputStr".into(),
|
|
input.gp_params.input_str().unwrap_or_default().into(),
|
|
));
|
|
if let Some(otp) = input.gp_params.otp() {
|
|
body.push(("passwd".into(), otp.into()));
|
|
}
|
|
if let Some(os_version) = input.gp_params.os_version() {
|
|
body.push(("os-version".into(), os_version.into()));
|
|
}
|
|
|
|
// Server — resolve to IPv4 when profile requires it
|
|
let server = resolve_server(input);
|
|
body.push(("server".into(), server));
|
|
|
|
// Identity fields
|
|
body.push(("host-id".into(), profile.host_id().into()));
|
|
body.push(("serialno".into(), profile.serialno().into()));
|
|
body.push(("preferred-ip".into(), String::new()));
|
|
body.push(("preferred-ipv6".into(), String::new()));
|
|
|
|
// Client version
|
|
if let Some(client_version) = input.gp_params.client_version() {
|
|
body.push(("clientgpversion".into(), client_version.to_string()));
|
|
}
|
|
|
|
// Context-dependent fields
|
|
if let Some(context) = input.context {
|
|
let gateway_host = context.host().to_string();
|
|
body.push(("host".into(), gateway_host.clone()));
|
|
body.push(("gw".into(), gateway_host.clone()));
|
|
body.push(("gateway-name".into(), gateway_host));
|
|
body.push(("internal".into(), context.kind().as_login_param().to_string()));
|
|
body.push((
|
|
"selection-type".into(),
|
|
context.selection().as_login_param().to_string(),
|
|
));
|
|
body.push(("client-ipv6".into(), String::new()));
|
|
|
|
if let Some(connect_method) = context.connect_method() {
|
|
body.push(("connect-method".into(), connect_method.to_string()));
|
|
}
|
|
|
|
if let Some(client_version) = input.gp_params.client_version() {
|
|
// Ensure clientgpversion is set in the context block (override earlier value if present)
|
|
if let Some(pos) = body.iter().position(|(k, _)| k == "clientgpversion") {
|
|
body[pos].1 = client_version.to_string();
|
|
} else {
|
|
body.push(("clientgpversion".into(), client_version.to_string()));
|
|
}
|
|
}
|
|
|
|
if let Some(client_ip) = input.client_ip {
|
|
body.push(("client-ip".into(), client_ip.to_string()));
|
|
}
|
|
}
|
|
|
|
// Extend lifetime
|
|
if input.extend_lifetime {
|
|
body.push(("extend-lifetime".into(), "true".into()));
|
|
}
|
|
|
|
RequestParams { body, query: vec![] }
|
|
}
|
|
|
|
/// Resolve the gateway server to an IPv4 address if the profile requires it.
|
|
///
|
|
/// Falls back to the original gateway host if resolution fails.
|
|
fn resolve_server(input: &GatewayLoginInput) -> String {
|
|
if !input.gp_params.os_profile().gateway_server_uses_resolved_ipv4() {
|
|
return input.gateway_host.to_string();
|
|
}
|
|
|
|
if let Some(context) = input.context {
|
|
resolve_to_ipv4(context.host()).unwrap_or_else(|| input.gateway_host.to_string())
|
|
} else {
|
|
input.gateway_host.to_string()
|
|
}
|
|
}
|
|
|
|
/// Attempt DNS resolution of a hostname to its first IPv4 address.
|
|
fn resolve_to_ipv4(host: &str) -> Option<String> {
|
|
(host, 443)
|
|
.to_socket_addrs()
|
|
.ok()?
|
|
.find(|addr| addr.ip().is_ipv4())
|
|
.map(|addr| addr.ip().to_string())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{
|
|
credential::{AuthCookieCredential, PasswordCredential},
|
|
gateway::{Gateway, GatewayKind, GatewaySelection},
|
|
os_profile::{ClientOs, HostIdentity, OsProfile},
|
|
};
|
|
|
|
fn test_identity() -> HostIdentity {
|
|
HostIdentity::new(
|
|
"test-computer".to_string(),
|
|
"host-id-123".to_string(),
|
|
"serial-456".to_string(),
|
|
"aa-bb-cc-dd-ee-ff".to_string(),
|
|
)
|
|
}
|
|
|
|
fn test_profile(os: ClientOs) -> OsProfile {
|
|
OsProfile::builder(os).host_identity(test_identity()).build()
|
|
}
|
|
|
|
fn make_gp_params() -> GpParams {
|
|
GpParams::builder(test_profile(ClientOs::Linux)).build()
|
|
}
|
|
|
|
fn make_credential() -> Credential {
|
|
Credential::Password(PasswordCredential::new("alice", "secret"))
|
|
}
|
|
|
|
#[test]
|
|
fn build_without_context_includes_identity_fields() {
|
|
let profile = test_profile(ClientOs::Linux);
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
|
|
assert_eq!(find("host-id"), Some(profile.host_id()));
|
|
assert_eq!(find("serialno"), Some(profile.serialno()));
|
|
assert_eq!(find("preferred-ip"), Some(""));
|
|
assert_eq!(find("preferred-ipv6"), Some(""));
|
|
assert_eq!(find("token"), Some(""));
|
|
assert_eq!(find("server"), Some("vpn.example.com"));
|
|
}
|
|
|
|
#[test]
|
|
fn build_without_context_excludes_context_fields() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let has_key = |key: &str| result.body.iter().any(|(k, _)| k == key);
|
|
|
|
assert!(!has_key("host"));
|
|
assert!(!has_key("gw"));
|
|
assert!(!has_key("gateway-name"));
|
|
assert!(!has_key("internal"));
|
|
assert!(!has_key("selection-type"));
|
|
assert!(!has_key("connect-method"));
|
|
assert!(!has_key("client-ip"));
|
|
assert!(!has_key("client-ipv6"));
|
|
}
|
|
|
|
#[test]
|
|
fn build_with_context_includes_gateway_fqdn() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
let gateway = Gateway {
|
|
name: "US_East".to_string(),
|
|
address: "us1.vpn.example.com".to_string(),
|
|
kind: GatewayKind::External,
|
|
priority: 1,
|
|
priority_rules: vec![],
|
|
};
|
|
let context = GatewayLoginContext::new(&gateway, GatewaySelection::Auto);
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "us1.vpn.example.com",
|
|
context: Some(&context),
|
|
client_ip: Some("192.168.0.10"),
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
|
|
assert_eq!(find("gw"), Some("us1.vpn.example.com"));
|
|
assert_eq!(find("gateway-name"), Some("us1.vpn.example.com"));
|
|
assert_eq!(find("host"), Some("us1.vpn.example.com"));
|
|
assert_eq!(find("internal"), Some("no"));
|
|
assert_eq!(find("selection-type"), Some("auto"));
|
|
assert_eq!(find("client-ip"), Some("192.168.0.10"));
|
|
assert_eq!(find("client-ipv6"), Some(""));
|
|
}
|
|
|
|
#[test]
|
|
fn mac_profile_uses_fqdn_for_gateway_display() {
|
|
let gp_params = GpParams::builder(test_profile(ClientOs::Mac)).build();
|
|
let cred = make_credential();
|
|
let gateway = Gateway {
|
|
name: "US_East".to_string(),
|
|
address: "us1.vpn.example.com".to_string(),
|
|
kind: GatewayKind::External,
|
|
priority: 1,
|
|
priority_rules: vec![],
|
|
};
|
|
let context = GatewayLoginContext::new(&gateway, GatewaySelection::Auto);
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "us1.vpn.example.com",
|
|
context: Some(&context),
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
|
|
assert_eq!(find("gw"), Some("us1.vpn.example.com"));
|
|
assert_eq!(find("gateway-name"), Some("us1.vpn.example.com"));
|
|
}
|
|
|
|
#[test]
|
|
fn linux_prelogin_credential_uses_profile_saml_password() {
|
|
let gp_params = GpParams::builder(test_profile(ClientOs::Linux)).build();
|
|
let cred = Credential::Prelogin(crate::credential::PreloginCredential::new(
|
|
"alice",
|
|
Some("prelogin-cookie"),
|
|
None,
|
|
None,
|
|
));
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let passwd = result.body.iter().find(|(k, _)| k == "passwd").map(|(_, v)| v.as_str());
|
|
assert_eq!(passwd, Some("SAMLPASS"));
|
|
}
|
|
|
|
#[test]
|
|
fn portal_auth_cookie_login_leaves_gateway_prelogin_cookie_empty() {
|
|
let gp_params = GpParams::builder(test_profile(ClientOs::Linux)).build();
|
|
let cred = Credential::AuthCookie(AuthCookieCredential::new("alice", "empty", "empty"));
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
|
|
assert_eq!(find("passwd"), Some("SAMLPASS"));
|
|
assert_eq!(find("prelogin-cookie"), Some(""));
|
|
assert_eq!(find("portal-userauthcookie"), Some("empty"));
|
|
assert_eq!(find("portal-prelogonuserauthcookie"), Some("empty"));
|
|
}
|
|
|
|
#[test]
|
|
fn portal_auth_cookie_login_reuses_portal_password_when_available() {
|
|
let gp_params = GpParams::builder(test_profile(ClientOs::Linux)).build();
|
|
let cred = Credential::AuthCookie(
|
|
AuthCookieCredential::new("alice", "portal-user-cookie", "portal-prelogon-cookie").with_password("secret"),
|
|
);
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
|
|
assert_eq!(find("passwd"), Some("secret"));
|
|
assert_eq!(find("prelogin-cookie"), Some(""));
|
|
assert_eq!(find("portal-userauthcookie"), Some("portal-user-cookie"));
|
|
assert_eq!(find("portal-prelogonuserauthcookie"), Some("portal-prelogon-cookie"));
|
|
}
|
|
|
|
#[test]
|
|
fn extend_lifetime_adds_param() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: true,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
assert_eq!(find("extend-lifetime"), Some("true"));
|
|
}
|
|
|
|
#[test]
|
|
fn no_extend_lifetime_omits_param() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let has_key = |key: &str| result.body.iter().any(|(k, _)| k == key);
|
|
assert!(!has_key("extend-lifetime"));
|
|
}
|
|
|
|
#[test]
|
|
fn context_connect_method_included_when_present() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
let gateway = Gateway::new("GW".to_string(), "vpn.example.com".to_string());
|
|
let context = GatewayLoginContext::new(&gateway, GatewaySelection::Manual).with_connect_method(Some("on-demand"));
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: Some(&context),
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let find = |key: &str| result.body.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str());
|
|
assert_eq!(find("connect-method"), Some("on-demand"));
|
|
assert_eq!(find("selection-type"), Some("manual"));
|
|
}
|
|
|
|
#[test]
|
|
fn all_params_in_body_not_query() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "vpn.example.com",
|
|
context: None,
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
assert!(result.query.is_empty());
|
|
assert!(!result.body.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn server_resolves_to_ipv4_with_context_using_localhost() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
let gateway = Gateway::new("Local".to_string(), "localhost".to_string());
|
|
let context = GatewayLoginContext::new(&gateway, GatewaySelection::Auto);
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "localhost",
|
|
context: Some(&context),
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let server = result
|
|
.body
|
|
.iter()
|
|
.find(|(k, _)| k == "server")
|
|
.map(|(_, v)| v.as_str())
|
|
.expect("server param should exist");
|
|
// localhost resolves to 127.0.0.1 (IPv4)
|
|
assert_eq!(server, "127.0.0.1");
|
|
}
|
|
|
|
#[test]
|
|
fn server_falls_back_to_host_when_resolution_fails() {
|
|
let gp_params = make_gp_params();
|
|
let cred = make_credential();
|
|
let gateway = Gateway::new("GW".to_string(), "nonexistent.invalid.test".to_string());
|
|
let context = GatewayLoginContext::new(&gateway, GatewaySelection::Auto);
|
|
|
|
let input = GatewayLoginInput {
|
|
gp_params: &gp_params,
|
|
cred: &cred,
|
|
gateway_host: "nonexistent.invalid.test",
|
|
context: Some(&context),
|
|
client_ip: None,
|
|
extend_lifetime: false,
|
|
};
|
|
|
|
let result = build(&input);
|
|
|
|
let server = result
|
|
.body
|
|
.iter()
|
|
.find(|(k, _)| k == "server")
|
|
.map(|(_, v)| v.as_str())
|
|
.expect("server param should exist");
|
|
// Falls back to the original gateway host when DNS resolution fails
|
|
assert_eq!(server, "nonexistent.invalid.test");
|
|
}
|
|
}
|