Files
GlobalProtect-openconnect/crates/gpapi/src/error/server_tls.rs
T
Kevin Yue 408536807c chore: promote GP Connect 3.3.1 sources and Nix packages (#699)
* fix: restore client certificate compatibility after OpenSSL removal

Use GnuTLS for desktop client key matching and signing without applying server certificate policy to local identities. Restore RC4 PKCS12 import and renewed certificate selection, and provide actionable unsupported identity errors.

Add HTTP and OpenConnect mutual TLS regressions. Record the unresolved TLS 1.2 ECDSA hash limitation and reject P-521 and RSA-PSS keys explicitly.

* fix: select PKCS12 issuers by certificate signature

Handle CA rollover and self-issued intermediates by checking issuer signatures. Preserve RSA-PSS signature parameters during GnuTLS verification and keep the original archive for OpenConnect.

Add mutual-TLS regression coverage for certificate bag order and RSA-PSS salt lengths. Verified 53 targeted tests plus gpapi, desktop-core, and iOS compile checks.

* fix: add gateway login diagnostics and scope platform dependencies

* chore: prepare GP Connect 3.3.1 release
2026-11-09 00:51:46 +08:00

541 lines
19 KiB
Rust

use std::{error::Error, fmt};
use serde::{Deserialize, Serialize};
use super::PortalError;
/// A VPN HTTP TLS failure. The server identifies the configured VPN origin,
/// not necessarily the peer that failed after an HTTP redirect.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServerTlsError {
pub server: String,
pub kind: ServerTlsErrorKind,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum ServerTlsErrorKind {
Certificate,
ClientCertificateRequired,
Other,
}
impl ServerTlsError {
pub(crate) fn from_request(
server: &url::Url,
error: &(dyn Error + 'static),
has_client_identity: bool,
) -> Option<anyhow::Error> {
let kind = classify_with_identity(error, has_client_identity)?;
let error = anyhow::Error::new(Self {
server: server.origin().ascii_serialization(),
kind,
});
if has_client_identity && kind == ServerTlsErrorKind::ClientCertificateRequired {
Some(error.context(
"The VPN server could not use the configured client certificate. Check it with your VPN administrator",
))
} else {
Some(error)
}
}
}
impl fmt::Display for ServerTlsError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let message = match self.kind {
ServerTlsErrorKind::Certificate => "The server's certificate could not be verified",
ServerTlsErrorKind::ClientCertificateRequired => "The server requires a client certificate",
ServerTlsErrorKind::Other => "A secure connection to the server could not be established",
};
write!(f, "{message}: {}", self.server)
}
}
impl Error for ServerTlsError {}
impl ServerTlsErrorKind {
/// One classification interface for CLI hints and desktop error mapping.
pub fn from_error(error: &anyhow::Error) -> Option<Self> {
error.chain().find_map(|source| {
source
.downcast_ref::<ServerTlsError>()
.map(|error| error.kind)
.or_else(|| {
source
.downcast_ref::<PortalError>()
.and_then(PortalError::tls_error_kind)
})
})
}
}
pub(super) fn classify(error: &(dyn Error + 'static)) -> Option<ServerTlsErrorKind> {
classify_with_identity(error, false)
}
fn classify_with_identity(error: &(dyn Error + 'static), has_client_identity: bool) -> Option<ServerTlsErrorKind> {
let mut source = Some(error);
while let Some(error) = source {
if let Some(tls) = error.downcast_ref::<ServerTlsError>() {
return Some(tls.kind);
}
if let Some(tls) = error.downcast_ref::<rustls::Error>() {
return Some(match tls {
rustls::Error::InvalidCertificate(_) => ServerTlsErrorKind::Certificate,
rustls::Error::AlertReceived(rustls::AlertDescription::CertificateRequired) => {
ServerTlsErrorKind::ClientCertificateRequired
}
rustls::Error::AlertReceived(
rustls::AlertDescription::BadCertificate
| rustls::AlertDescription::UnsupportedCertificate
| rustls::AlertDescription::CertificateRevoked
| rustls::AlertDescription::CertificateExpired
| rustls::AlertDescription::CertificateUnknown
| rustls::AlertDescription::UnknownCA,
) if has_client_identity => ServerTlsErrorKind::ClientCertificateRequired,
_ => ServerTlsErrorKind::Other,
});
}
source = error
.downcast_ref::<std::io::Error>()
.and_then(|error| error.get_ref().map(|inner| inner as &(dyn Error + 'static)))
.or_else(|| error.source());
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use openssl::{
asn1::Asn1Time,
hash::MessageDigest,
pkey::PKey,
rsa::Rsa,
ssl::{SslAcceptor, SslMethod, SslVerifyMode},
x509::{X509, X509NameBuilder},
};
use std::{
io::{Read, Write},
net::TcpListener,
thread,
time::Duration,
};
#[test]
fn typed_tls_causes_distinguish_local_trust_from_peer_alerts() {
for reason in [
rustls::CertificateError::Expired,
rustls::CertificateError::UnknownIssuer,
] {
let error = std::io::Error::other(std::io::Error::other(rustls::Error::InvalidCertificate(reason)));
assert_eq!(classify(&error), Some(ServerTlsErrorKind::Certificate));
}
for alert in [
rustls::AlertDescription::UnknownCA,
rustls::AlertDescription::BadCertificate,
] {
assert_eq!(
classify(&rustls::Error::AlertReceived(alert)),
Some(ServerTlsErrorKind::Other)
);
}
let required = rustls::Error::AlertReceived(rustls::AlertDescription::CertificateRequired);
assert_eq!(classify(&required), Some(ServerTlsErrorKind::ClientCertificateRequired));
assert_eq!(classify(&std::io::Error::other("certificate verify failed")), None);
}
#[test]
fn configured_identity_peer_errors_have_actionable_copy_without_becoming_server_trust_failures() {
let server = url::Url::parse("https://vpn.example.com/private/login").unwrap();
for alert in [
rustls::AlertDescription::CertificateRequired,
rustls::AlertDescription::BadCertificate,
rustls::AlertDescription::UnknownCA,
] {
let error = rustls::Error::AlertReceived(alert);
let configured = ServerTlsError::from_request(&server, &error, true).unwrap();
assert_eq!(
ServerTlsErrorKind::from_error(&configured),
Some(ServerTlsErrorKind::ClientCertificateRequired)
);
let message = configured.to_string();
assert!(
message.contains("configured client certificate") && message.contains("VPN administrator"),
"{message}"
);
assert!(
!message.contains("password") && !message.contains("passphrase"),
"{message}"
);
assert!(!message.contains("/private/login"));
}
let trust_error = rustls::Error::InvalidCertificate(rustls::CertificateError::UnknownIssuer);
let classified = ServerTlsError::from_request(&server, &trust_error, true).unwrap();
assert_eq!(
ServerTlsErrorKind::from_error(&classified),
Some(ServerTlsErrorKind::Certificate)
);
}
fn server(tls: bool) -> (String, thread::JoinHandle<()>) {
server_with_client_auth(tls, SslVerifyMode::NONE)
}
fn server_with_client_auth(tls: bool, verify: SslVerifyMode) -> (String, thread::JoinHandle<()>) {
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
let mut name = X509NameBuilder::new().unwrap();
name.append_entry_by_text("CN", "localhost").unwrap();
let name = name.build();
let mut cert = X509::builder().unwrap();
cert.set_version(2).unwrap();
cert.set_subject_name(&name).unwrap();
cert.set_issuer_name(&name).unwrap();
cert.set_pubkey(&key).unwrap();
cert.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
cert.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
cert.sign(&key, MessageDigest::sha256()).unwrap();
let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
acceptor.set_private_key(&key).unwrap();
acceptor.set_certificate(&cert.build()).unwrap();
acceptor.set_verify(verify);
acceptor
.set_ca_file(concat!(
env!("CARGO_MANIFEST_DIR"),
"/tests/files/client-identity/root.pem"
))
.unwrap();
let acceptor = acceptor.build();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = format!("https://{}", listener.local_addr().unwrap());
let worker = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
stream.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
let body = "<prelogin-response><status>Success</status><saml-auth-method>REDIRECT</saml-auth-method><saml-request>aHR0cHM6Ly9pZHAuZXhhbXBsZS5jb20v</saml-request></prelogin-response>";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let mut request = [0; 8192];
if tls {
if let Ok(mut stream) = acceptor.accept(stream) {
let _ = stream.read(&mut request);
let _ = stream.write_all(response.as_bytes());
}
} else {
let _ = stream.read(&mut request);
let _ = stream.write_all(response.as_bytes());
}
});
(address, worker)
}
#[tokio::test]
async fn prelogin_returns_typed_certificate_failure_with_only_the_server_origin() {
use crate::{
gp_params::GpParams,
os_profile::{ClientOs, OsProfile},
portal::{PreloginOptions, prelogin},
};
let (address, worker) = server(true);
let profile = OsProfile::builder(ClientOs::Linux).build(crate::os_profile::test_snapshot());
let params = GpParams::builder(profile).build();
let error = prelogin(&address, &params, PreloginOptions::default())
.await
.unwrap_err();
worker.join().unwrap();
let tls = error
.downcast_ref::<ServerTlsError>()
.unwrap_or_else(|| panic!("unclassified: {error:?}"));
assert_eq!(tls.kind, ServerTlsErrorKind::Certificate);
assert_eq!(tls.server, address);
}
#[tokio::test]
async fn certificate_bypass_allows_prelogin() {
use crate::{
gp_params::GpParams,
os_profile::{ClientOs, OsProfile},
portal::{PreloginOptions, prelogin},
};
let (address, worker) = server(true);
let params = GpParams::builder(OsProfile::builder(ClientOs::Linux).build(crate::os_profile::test_snapshot()))
.ignore_tls_errors(true)
.build();
let result = prelogin(&address, &params, PreloginOptions::default()).await;
worker.join().unwrap();
assert!(matches!(result.unwrap(), crate::portal::Prelogin::Saml(_)));
}
#[tokio::test]
async fn incompatible_tls_is_not_a_certificate_error_even_with_bypass() {
let (address, worker) = server(false);
let error = crate::utils::request::client_builder()
.no_proxy()
.danger_accept_invalid_certs(true)
.build()
.unwrap()
.get(&address)
.send()
.await
.unwrap_err();
worker.join().unwrap();
let tls = ServerTlsError::from_request(&url::Url::parse(&address).unwrap(), &error, false).unwrap();
assert_eq!(ServerTlsErrorKind::from_error(&tls), Some(ServerTlsErrorKind::Other));
}
#[tokio::test]
async fn connection_refused_is_not_tls() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = format!("https://{}", listener.local_addr().unwrap());
drop(listener);
let error = crate::utils::request::client_builder()
.no_proxy()
.build()
.unwrap()
.get(address)
.send()
.await
.unwrap_err();
assert_eq!(classify(&error), None);
}
#[cfg(feature = "desktop")]
#[test]
fn rendering_recovery_retains_client_certificate_requirement() {
use crate::process::rendering_recovery::{RecoveryState, RenderingCrash};
use std::os::unix::process::ExitStatusExt;
let mut recovery = RecoveryState::default();
assert!(
recovery.recover(
&RenderingCrash {
status: std::process::ExitStatus::from_raw(71 << 8)
}
.into()
)
);
let error = recovery.terminal(
ServerTlsError {
server: "https://vpn.example.com".into(),
kind: ServerTlsErrorKind::ClientCertificateRequired,
}
.into(),
);
assert_eq!(
ServerTlsErrorKind::from_error(&error),
Some(ServerTlsErrorKind::ClientCertificateRequired)
);
}
#[tokio::test]
async fn required_client_certificate_is_not_bypassed_by_ignoring_server_trust() {
use crate::{
gp_params::GpParams,
os_profile::{ClientOs, OsProfile},
portal::{PreloginOptions, prelogin},
};
let params = GpParams::builder(OsProfile::builder(ClientOs::Linux).build(crate::os_profile::test_snapshot()))
.ignore_tls_errors(true)
.build();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
let cancellation = tokio_util::sync::CancellationToken::new();
for operation in ["prelogin", "config", "gateway"] {
let (address, worker) = server_with_client_auth(true, SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
let error = match operation {
"prelogin" => prelogin(&address, &params, PreloginOptions::default())
.await
.err()
.unwrap(),
"config" => crate::portal::retrieve_config(&address, &credential, &params, &cancellation)
.await
.err()
.unwrap(),
_ => crate::gateway::GatewayLoginClient::new(&address, params.clone())
.unwrap()
.login(&credential, None, &cancellation)
.await
.err()
.unwrap(),
};
worker.join().unwrap();
let kind =
ServerTlsErrorKind::from_error(&error).unwrap_or_else(|| panic!("{operation}: unclassified: {error:?}"));
assert_eq!(
kind,
ServerTlsErrorKind::ClientCertificateRequired,
"{operation}: {error:?}"
);
}
}
#[tokio::test]
async fn prelogin_explains_peer_rejection_of_an_already_configured_identity() {
use crate::{
gp_params::GpParams,
os_profile::{ClientOs, OsProfile},
portal::{PreloginOptions, prelogin},
utils::request::ClientIdentity,
};
let fixtures = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/files/client-identity");
let identity = ClientIdentity::load(
fixtures.join("rsa-critical-extension.pem").to_str().unwrap(),
Some(fixtures.join("rsa-pkcs8.pem").to_str().unwrap()),
None,
)
.unwrap();
let params = GpParams::builder(OsProfile::builder(ClientOs::Linux).build(crate::os_profile::test_snapshot()))
.client_identity(Some(identity))
.ignore_tls_errors(true)
.build();
let (address, worker) = server_with_client_auth(true, SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
let error = prelogin(&address, &params, PreloginOptions::default())
.await
.unwrap_err();
worker.join().unwrap();
assert_eq!(
ServerTlsErrorKind::from_error(&error),
Some(ServerTlsErrorKind::ClientCertificateRequired)
);
assert!(error.to_string().contains("configured client certificate"), "{error:#}");
assert!(!error.to_string().contains("passphrase"));
}
#[tokio::test]
async fn prelogin_accepts_a_valid_identity_and_an_optional_certificate_request() {
use crate::{
gp_params::GpParams,
os_profile::{ClientOs, OsProfile},
portal::{PreloginOptions, prelogin},
};
for required in [false, true] {
let verify = if required {
SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT
} else {
SslVerifyMode::PEER
};
let (address, worker) = server_with_client_auth(true, verify);
let mut builder =
GpParams::builder(OsProfile::builder(ClientOs::Linux).build(crate::os_profile::test_snapshot()));
builder.ignore_tls_errors(true);
if required {
builder
.certificate(Some(
concat!(env!("CARGO_MANIFEST_DIR"), "/tests/files/client-identity/rsa-cert.pem").to_owned(),
))
.sslkey(Some(
concat!(env!("CARGO_MANIFEST_DIR"), "/tests/files/client-identity/rsa-pkcs8.pem").to_owned(),
));
}
let result = prelogin(&address, &builder.build(), PreloginOptions::default()).await;
worker.join().unwrap();
assert!(matches!(result.unwrap(), crate::portal::Prelogin::Saml(_)));
}
}
#[tokio::test]
async fn imported_identity_formats_complete_mutual_tls_prelogin() {
use crate::{
gp_params::GpParams,
os_profile::{ClientOs, OsProfile},
portal::{PreloginOptions, prelogin},
};
let fixture = |name: &str| format!("{}/tests/files/client-identity/{name}", env!("CARGO_MANIFEST_DIR"));
for (certificate, key, password) in [
(
"rsa-cert.pem",
Some("rsa-traditional-aes256.pem"),
Some("fixture-password"),
),
("ec-cert.pem", Some("ec-traditional-des3.pem"), Some("fixture-password")),
("rsa-cert.pem", Some("rsa-pbes1-3des.pem"), Some("fixture-password")),
("rsa-cert.pem", Some("rsa-pbes2-scrypt.pem"), Some("fixture-password")),
("ec-cert.pem", Some("ec-sec1.pem"), None),
("modern.p12", None, Some("fixture-password")),
("legacy-rc2.p12", None, Some("fixture-password")),
("empty-password.p12", None, None),
("no-bag-ids.p12", None, None),
] {
let (address, worker) = server_with_client_auth(true, SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
let mut builder =
GpParams::builder(OsProfile::builder(ClientOs::Linux).build(crate::os_profile::test_snapshot()));
builder
.ignore_tls_errors(true)
.certificate(Some(fixture(certificate)))
.sslkey(key.map(fixture))
.key_password(password.map(str::to_owned));
let mut params = builder.build();
params
.prepare_client_identity()
.unwrap_or_else(|error| panic!("{certificate}/{key:?}: {error:?}"));
let result = prelogin(&address, &params, PreloginOptions::default()).await;
worker.join().unwrap();
assert!(matches!(
result.unwrap_or_else(|error| panic!("{certificate}/{key:?}: {error:?}")),
crate::portal::Prelogin::Saml(_)
));
}
}
/// Point at the GnuTLS fixture configured without RFC 5746, with a trusted test root.
#[tokio::test]
#[ignore = "requires GP_TLS_TEST_SERVER and GP_TLS_TEST_CA for the external GnuTLS fixture"]
async fn tls12_peer_without_renegotiation_extension_uses_default_policy() {
let server = std::env::var("GP_TLS_TEST_SERVER").unwrap();
let root = std::fs::read(std::env::var("GP_TLS_TEST_CA").unwrap()).unwrap();
let client = crate::utils::request::client_builder()
.no_proxy()
.add_root_certificate(reqwest::Certificate::from_pem(&root).unwrap())
.build()
.unwrap();
assert!(client.get(&server).send().await.unwrap().status().is_success());
let error = crate::utils::request::client_builder()
.no_proxy()
.build()
.unwrap()
.get(&server)
.send()
.await
.unwrap_err();
assert_eq!(
ServerTlsErrorKind::from_error(
&ServerTlsError::from_request(&url::Url::parse(&server).unwrap(), &error, false).unwrap()
),
Some(ServerTlsErrorKind::Certificate)
);
}
#[tokio::test]
async fn failed_response_reads_preserve_the_transport_cause() {
for status in [200, 403] {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = format!("http://{}", listener.local_addr().unwrap());
let worker = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
let mut request = [0; 8192];
stream.read(&mut request).unwrap();
write!(
stream,
"HTTP/1.1 {status} Test\r\nContent-Length: 100\r\nConnection: close\r\n\r\ntruncated"
)
.unwrap();
});
let response = crate::utils::request::client_builder()
.no_proxy()
.build()
.unwrap()
.get(address)
.send()
.await
.unwrap();
let error = crate::utils::parse_gp_response(response).await.unwrap_err();
assert_eq!(error.status.as_u16(), status);
assert!(error.source().unwrap().is::<reqwest::Error>());
worker.join().unwrap();
}
}
}