release: prepare GP Connect 3.5.0 with Windows support

This commit is contained in:
Kevin Yue committed 2026-11-19 01:40:22 +08:00
1 parent 6ffb1e8709
commit 43c20d0976
172 files changed
+9629 -1171

No files matched your search

+23
View File
@@ -0,0 +1,23 @@
<?xml version="1.0"?>
<?fixture fixture-pi?>
<policy>
<!--fixture-comment-->
<portal-userauthcookie>fixture-user-cookie</portal-userauthcookie>
<portal-prelogonuserauthcookie><![CDATA[fixture-prelogon-cookie]]></portal-prelogonuserauthcookie>
<portal-csc-auth-cookie>fixture-csc-cookie</portal-csc-auth-cookie>
<username>fixture-username</username>
<saml-request>fixture-saml</saml-request>
<property name="password" value="fixture-property-password"/>
<cookie name="fixture-cookie-name"/>
<settings auth_token="fixture-attribute-token"/>
<download href="https://user:[email protected]/client?auth=fixture-query-token"/>
<hip-collection>
<hip-report-interval>3600</hip-report-interval>
<collect-hip-data>yes</collect-hip-data>
<custom-checks>
<mac-os><plist><entry name="com.paloaltonetworks.GlobalProtect.settings"><key><member>HipID</member></key></entry><entry name="com.1password.1password"><key><member>Version</member></key></entry></plist></mac-os>
<windows><registry-key><entry name="HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters"><registry-value><member>Domain</member><member>NV Domain</member></registry-value></entry></registry-key></windows>
</custom-checks>
</hip-collection>
<domain>Corp.Example.test</domain>
</policy>
+13 -6
View File
@@ -93,12 +93,19 @@ fn traditional_encrypted_pem_preserves_password_errors() {
let result = load(&certificate, &key, password);
if password == Some(PASSWORD) {
let identity = result.unwrap_or_else(|error| panic!("{key:?}: {error}"));
let actual = openssl::pkey::PKey::private_key_from_pem(identity.key_data().unwrap()).unwrap();
let expected = openssl::pkey::PKey::private_key_from_pem(&bytes(&format!("{algorithm}-pkcs8.pem"))).unwrap();
assert!(
actual.public_eq(&expected),
"{key:?}: imported key differs from the fixture"
);
let public_key = |pem: &[u8]| {
let key = rustls_pemfile::private_key(&mut std::io::Cursor::new(pem))
.unwrap()
.unwrap();
rustls::crypto::ring::sign::any_supported_type(&key)
.unwrap()
.public_key()
.unwrap()
.into_owned()
};
let actual = public_key(identity.key_data().unwrap());
let expected = public_key(&bytes(&format!("{algorithm}-pkcs8.pem")));
assert!(actual == expected, "{key:?}: imported key differs from the fixture");
assert!(identity.key_password().is_none());
} else {
let error = result.unwrap_err();
+123
View File
@@ -0,0 +1,123 @@
use std::sync::Mutex;
use gpapi::utils::parse_gp_response;
use log::{LevelFilter, Log, Metadata, Record};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
};
struct Capture(Mutex<Vec<String>>);
static LOGS: Capture = Capture(Mutex::new(Vec::new()));
impl Log for Capture {
fn enabled(&self, _: &Metadata<'_>) -> bool {
true
}
fn log(&self, record: &Record<'_>) {
if record.target() == "gpapi::utils::response_log" {
self.0.lock().unwrap().push(record.args().to_string());
}
}
fn flush(&self) {}
}
async fn response(path: &str, status: &str, body: &str) -> reqwest::Response {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let data = format!(
"HTTP/1.1 {status}\r\nContent-Type: application/xml\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut request = [0; 4096];
socket.read(&mut request).await.unwrap();
socket.write_all(data.as_bytes()).await.unwrap();
});
reqwest::Client::builder()
.no_proxy()
.build()
.unwrap()
.get(format!("http://{address}{path}"))
.send()
.await
.unwrap()
}
#[tokio::test]
async fn logs_redacted_xml_at_debug_without_changing_responses_or_exposing_error_bodies() {
rustls::crypto::ring::default_provider().install_default().unwrap();
log::set_logger(&LOGS).unwrap();
log::set_max_level(LevelFilter::Debug);
let portal = include_str!("fixtures/portal-response.xml");
for path in [
"/global-protect/getconfig.esp",
"/global-protect/getconfig_csc.esp",
"/global-protect/prelogin.esp",
"/ssl-vpn/login.esp",
] {
let result = parse_gp_response(response(path, "200 OK", portal).await).await.unwrap();
assert_eq!(result, portal);
}
let logs = LOGS.0.lock().unwrap().join("\n");
assert!(logs.contains("getconfig.esp response XML"));
assert!(logs.contains("getconfig_csc.esp response XML"));
assert!(logs.contains("prelogin.esp response XML"));
assert!(logs.contains("login.esp response XML"));
assert!(logs.contains("custom-checks") && logs.contains("HipID"));
for secret in [
"fixture-user-cookie",
"fixture-prelogon-cookie",
"fixture-csc-cookie",
"fixture-username",
"fixture-saml",
"fixture-attribute-token",
"fixture-property-password",
"fixture-cookie-name",
"fixture-query-token",
"fixture-url-password",
"fixture-comment",
"fixture-pi",
] {
assert!(!logs.contains(secret), "logged secret: {secret}");
}
let error = parse_gp_response(response("/global-protect/getconfig.esp", "403 Forbidden", portal).await)
.await
.unwrap_err();
assert_eq!(error.status, reqwest::StatusCode::FORBIDDEN);
assert!(!format!("{error:?} {error}").contains("fixture-"));
assert!(LOGS.0.lock().unwrap().iter().any(|line| line.contains("HTTP 403")));
let error = parse_gp_response(
response(
"/global-protect/getconfig.esp",
"500 Internal Server Error",
"<html><body>fixture-error-secret</body></html>",
)
.await,
)
.await
.unwrap_err();
assert!(!format!("{error:?} {error}").contains("fixture-error-secret"));
assert!(!LOGS.0.lock().unwrap().join("\n").contains("fixture-error-secret"));
LOGS.0.lock().unwrap().clear();
let body = "<jnlp><application-desc><argument>fixture-login-cookie</argument></application-desc></jnlp>";
parse_gp_response(response("/redirect/fixture-path-token?token=fixture-query-token", "200 OK", body).await)
.await
.unwrap();
let logs = LOGS.0.lock().unwrap().join("\n");
assert!(logs.contains("[response endpoint]"));
assert!(!logs.contains("fixture-"));
LOGS.0.lock().unwrap().clear();
log::set_max_level(LevelFilter::Info);
assert_eq!(
parse_gp_response(response("/global-protect/getconfig.esp", "200 OK", portal).await)
.await
.unwrap(),
portal
);
assert!(LOGS.0.lock().unwrap().is_empty());
}
+87
View File
@@ -0,0 +1,87 @@
#![cfg(windows)]
use gpapi::windows::{PipeClientIdentity, create_user_pipe, current_user_sid};
use std::{io, os::windows::io::AsRawHandle, ptr, time::Duration};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::windows::named_pipe::ClientOptions,
};
use windows_sys::Win32::{
Foundation::{CloseHandle, ERROR_NO_TOKEN},
Security::{GetTokenInformation, TOKEN_QUERY, TOKEN_TYPE, TokenPrimary, TokenType},
Storage::FileSystem::{SECURITY_IDENTIFICATION, SECURITY_IMPERSONATION},
System::Threading::{GetCurrentThread, OpenThreadToken},
};
fn assert_reverted() {
let mut token = ptr::null_mut();
let success = unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) };
if success != 0 {
unsafe {
CloseHandle(token);
}
panic!("The service thread still impersonates its client");
}
assert_eq!(io::Error::last_os_error().raw_os_error(), Some(ERROR_NO_TOKEN as i32));
}
async fn admission(qos: u32) -> io::Result<PipeClientIdentity> {
let path = format!(r"\\.\pipe\GPConnect.IdentityTest.{}", uuid::Uuid::new_v4());
let mut pipe = create_user_pipe(&path, true)?;
let client = tokio::spawn(async move {
let mut pipe = ClientOptions::new().security_qos_flags(qos).open(path).unwrap();
pipe.write_all(b"admit").await.unwrap();
let mut response = [0];
pipe.read_exact(&mut response).await.unwrap();
// Confirm delivery before the server disconnects its Windows pipe.
pipe.write_all(b"ack").await.unwrap();
});
pipe.connect().await?;
let mut request = [0; 5];
pipe.read_exact(&mut request).await?;
assert_eq!(&request, b"admit");
let identity = PipeClientIdentity::from_pipe(&pipe);
assert_reverted();
pipe.write_all(&[1]).await?;
let mut ack = [0; 3];
pipe.read_exact(&mut ack).await?;
assert_eq!(&ack, b"ack");
client.await.unwrap();
identity
}
#[tokio::test]
async fn captures_primary_token_and_reverts_before_returning() {
let identity = tokio::time::timeout(Duration::from_secs(5), admission(SECURITY_IMPERSONATION))
.await
.unwrap()
.unwrap();
assert_eq!(identity.sid(), current_user_sid().unwrap());
let mut kind: TOKEN_TYPE = 0;
let mut length = 0;
assert_ne!(
unsafe {
GetTokenInformation(
identity.primary_token().as_raw_handle(),
TokenType,
(&mut kind as *mut TOKEN_TYPE).cast(),
std::mem::size_of_val(&kind) as u32,
&mut length,
)
},
0
);
assert_eq!(kind, TokenPrimary);
assert_reverted();
}
#[tokio::test]
async fn identification_only_client_cannot_supply_a_worker_token() {
assert!(
tokio::time::timeout(Duration::from_secs(5), admission(SECURITY_IDENTIFICATION))
.await
.unwrap()
.is_err()
);
assert_reverted();
}