mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
274 lines
9.7 KiB
Rust
274 lines
9.7 KiB
Rust
//! Container compatibility through the public identity loader, using public fixtures.
|
|
use std::{
|
|
fs,
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
use gpapi::utils::request::{ClientIdentity, RequestIdentityError};
|
|
|
|
const PASSWORD: &str = "fixture-password";
|
|
|
|
fn fixture(name: &str) -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.join("tests/files/client-identity")
|
|
.join(name)
|
|
}
|
|
|
|
fn bytes(name: &str) -> Vec<u8> {
|
|
fs::read(fixture(name)).unwrap()
|
|
}
|
|
|
|
fn load(certificate: &Path, key: &Path, password: Option<&str>) -> anyhow::Result<ClientIdentity> {
|
|
ClientIdentity::load(certificate.to_str().unwrap(), Some(key.to_str().unwrap()), password)
|
|
}
|
|
|
|
#[test]
|
|
fn der_certificates_and_rsa_keys_normalize_to_the_existing_pem_identity() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let certificate = directory.path().join("client.cer");
|
|
let key = directory.path().join("client.key");
|
|
fs::write(&certificate, pem::parse(bytes("rsa-cert.pem")).unwrap().contents()).unwrap();
|
|
let missing = ClientIdentity::load(certificate.to_str().unwrap(), None, None).unwrap_err();
|
|
assert!(matches!(
|
|
missing.downcast_ref::<RequestIdentityError>(),
|
|
Some(RequestIdentityError::NoKey)
|
|
));
|
|
for name in ["rsa-pkcs8.pem", "rsa-pkcs1.pem", "rsa-pbes2-sha256.pem"] {
|
|
fs::write(&key, pem::parse(bytes(name)).unwrap().contents()).unwrap();
|
|
let identity = load(&certificate, &key, Some(PASSWORD)).unwrap_or_else(|error| panic!("{name}: {error}"));
|
|
assert_eq!(identity.certificate_data(), bytes("rsa-cert.pem"));
|
|
assert_eq!(identity.key_data().unwrap(), bytes("rsa-pkcs8.pem"));
|
|
assert!(identity.key_password().is_none());
|
|
let snapshot = ClientIdentity::from_data(
|
|
zeroize::Zeroizing::new(identity.certificate_data().to_vec()),
|
|
Some(zeroize::Zeroizing::new(identity.key_data().unwrap().to_vec())),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(snapshot.key_data(), identity.key_data());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn encrypted_der_preserves_password_errors() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let key = directory.path().join("key.der");
|
|
fs::write(&key, pem::parse(bytes("rsa-pbes2-sha256.pem")).unwrap().contents()).unwrap();
|
|
for (password, missing) in [(None, true), (Some("incorrect"), false)] {
|
|
let error = load(&fixture("rsa-cert.pem"), &key, password).unwrap_err();
|
|
match error.downcast_ref::<RequestIdentityError>() {
|
|
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(missing),
|
|
Some(RequestIdentityError::DecryptError("PEM")) => assert!(!missing),
|
|
other => panic!("unexpected DER password error: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ec_sec1_pem_and_der_are_portable() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let key = directory.path().join("ec.der");
|
|
fs::write(&key, pem::parse(bytes("ec-sec1.pem")).unwrap().contents()).unwrap();
|
|
for source in [fixture("ec-sec1.pem"), key] {
|
|
for password in [None, Some(PASSWORD)] {
|
|
let identity = load(&fixture("ec-cert.pem"), &source, password).unwrap();
|
|
assert_eq!(identity.key_data().unwrap(), bytes("ec-sec1.pem"));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(any(
|
|
target_os = "macos",
|
|
target_os = "linux",
|
|
target_os = "freebsd",
|
|
target_os = "openbsd"
|
|
))]
|
|
fn traditional_encrypted_pem_preserves_password_errors() {
|
|
for algorithm in ["rsa", "ec"] {
|
|
for cipher in ["aes128", "aes192", "aes256", "des3"] {
|
|
let certificate = fixture(&format!("{algorithm}-cert.pem"));
|
|
let key = fixture(&format!("{algorithm}-traditional-{cipher}.pem"));
|
|
for password in [None, Some("incorrect"), Some(PASSWORD)] {
|
|
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"
|
|
);
|
|
assert!(identity.key_password().is_none());
|
|
} else {
|
|
let error = result.unwrap_err();
|
|
match error.downcast_ref::<RequestIdentityError>() {
|
|
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(password.is_none()),
|
|
Some(RequestIdentityError::DecryptError("PEM")) => assert!(password.is_some()),
|
|
other => panic!("{key:?}: unexpected password error {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(any(
|
|
target_os = "macos",
|
|
target_os = "linux",
|
|
target_os = "freebsd",
|
|
target_os = "openbsd"
|
|
))]
|
|
fn traditional_passphrase_with_nul_returns_a_redacted_terminal_error() {
|
|
let error = load(
|
|
&fixture("rsa-cert.pem"),
|
|
&fixture("rsa-traditional-aes256.pem"),
|
|
Some("secret-password\0do-not-log"),
|
|
)
|
|
.unwrap_err();
|
|
assert!(!matches!(
|
|
error.downcast_ref::<RequestIdentityError>(),
|
|
Some(RequestIdentityError::NoPassphrase(_) | RequestIdentityError::DecryptError(_))
|
|
));
|
|
for diagnostic in [error.to_string(), format!("{error:?}")] {
|
|
assert!(!diagnostic.contains("secret-password"));
|
|
assert!(!diagnostic.contains("do-not-log"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(any(
|
|
target_os = "macos",
|
|
target_os = "linux",
|
|
target_os = "freebsd",
|
|
target_os = "openbsd"
|
|
))]
|
|
fn first_traditional_encrypted_key_controls_combined_pem_loading() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let source = directory.path().join("combined.pem");
|
|
let mut chain = bytes("rsa-cert.pem");
|
|
chain.extend(bytes("root.pem"));
|
|
let mut combined = chain.clone();
|
|
combined.extend(bytes("rsa-traditional-aes256.pem"));
|
|
combined.extend(bytes("rsa-pkcs8.pem"));
|
|
fs::write(&source, &combined).unwrap();
|
|
let error = ClientIdentity::load(source.to_str().unwrap(), None, None).unwrap_err();
|
|
assert!(matches!(
|
|
error.downcast_ref::<RequestIdentityError>(),
|
|
Some(RequestIdentityError::NoPassphrase("PEM"))
|
|
));
|
|
let identity = ClientIdentity::load(source.to_str().unwrap(), None, Some(PASSWORD)).unwrap();
|
|
assert_eq!(identity.certificate_data(), chain);
|
|
assert_eq!(identity.key_data().unwrap(), bytes("rsa-pkcs8.pem"));
|
|
assert_eq!(fs::read(source).unwrap(), combined);
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_traditional_headers_are_terminal_and_do_not_expose_material() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let key = directory.path().join("invalid.pem");
|
|
for (headers, unsupported) in [
|
|
(vec![("Proc-Type", "4,ENCRYPTED")], false),
|
|
(
|
|
vec![("DEK-Info", "AES-256-CBC,00000000000000000000000000000000")],
|
|
false,
|
|
),
|
|
(
|
|
vec![
|
|
("Proc-Type", "4,ENCRYPTED"),
|
|
("DEK-Info", "AES-256-CBC,invalid-secret-iv"),
|
|
],
|
|
false,
|
|
),
|
|
(
|
|
vec![("Proc-Type", "4,ENCRYPTED"), ("DEK-Info", "AES-256-CBC,00")],
|
|
false,
|
|
),
|
|
(
|
|
vec![
|
|
("Proc-Type", "4,ENCRYPTED"),
|
|
("Proc-Type", "4,ENCRYPTED"),
|
|
("DEK-Info", "AES-256-CBC,00000000000000000000000000000000"),
|
|
],
|
|
false,
|
|
),
|
|
(
|
|
vec![
|
|
("Proc-Type", "4,ENCRYPTED"),
|
|
("DEK-Info", "UNKNOWN-CIPHER,00000000000000000000000000000000"),
|
|
],
|
|
true,
|
|
),
|
|
] {
|
|
let mut block = pem::Pem::new("RSA PRIVATE KEY", b"secret-invalid-key-material");
|
|
for (name, value) in headers {
|
|
block.headers_mut().add(name, value).unwrap();
|
|
}
|
|
fs::write(&key, pem::encode(&block)).unwrap();
|
|
for password in [None, Some("secret-passphrase")] {
|
|
let error = load(&fixture("rsa-cert.pem"), &key, password).unwrap_err();
|
|
match error.downcast_ref::<RequestIdentityError>() {
|
|
Some(RequestIdentityError::UnsupportedEncryption) => assert!(unsupported),
|
|
Some(RequestIdentityError::InvalidKey) => assert!(!unsupported),
|
|
other => panic!("unexpected traditional header error: {other:?}"),
|
|
}
|
|
let diagnostic = format!("{error:?}");
|
|
for secret in ["secret-invalid-key-material", "secret-passphrase", "invalid-secret-iv"] {
|
|
assert!(!diagnostic.contains(secret));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn der_with_trailing_data_is_rejected_for_certificates_and_keys() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let source = directory.path().join("trailing.der");
|
|
for name in [
|
|
"rsa-cert.pem",
|
|
"rsa-pkcs1.pem",
|
|
"rsa-pkcs8.pem",
|
|
"rsa-pbes2-sha256.pem",
|
|
"ec-sec1.pem",
|
|
] {
|
|
let mut der = pem::parse(bytes(name)).unwrap().into_contents();
|
|
der.push(0);
|
|
fs::write(&source, der).unwrap();
|
|
let result = if name == "rsa-cert.pem" {
|
|
load(&source, &fixture("rsa-pkcs8.pem"), Some(PASSWORD))
|
|
} else {
|
|
load(&fixture("rsa-cert.pem"), &source, Some(PASSWORD))
|
|
};
|
|
let error = result.unwrap_err();
|
|
assert!(
|
|
matches!(
|
|
error.downcast_ref::<RequestIdentityError>(),
|
|
Some(RequestIdentityError::InvalidKey | RequestIdentityError::InvalidCertificate)
|
|
),
|
|
"{name}: {error}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pkcs12_extensions_are_ascii_case_insensitive() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let archive = bytes("modern.p12");
|
|
for extension in ["P12", "p12", "PFX", "pFx"] {
|
|
let path = directory.path().join(format!("identity.{extension}"));
|
|
fs::write(&path, &archive).unwrap();
|
|
let identity = ClientIdentity::load(path.to_str().unwrap(), None, Some(PASSWORD)).unwrap();
|
|
assert_eq!(identity.certificate_data(), archive);
|
|
assert!(identity.key_data().is_none());
|
|
for password in [None, Some("incorrect")] {
|
|
let error = ClientIdentity::load(path.to_str().unwrap(), None, password).unwrap_err();
|
|
match error.downcast_ref::<RequestIdentityError>() {
|
|
Some(RequestIdentityError::NoPassphrase("PKCS#12")) => assert!(password.is_none()),
|
|
Some(RequestIdentityError::InvalidPkcs12(_)) => assert!(password.is_some()),
|
|
other => panic!("unexpected archive error: {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
}
|