//! 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 { fs::read(fixture(name)).unwrap() } fn load(certificate: &Path, key: &Path, password: Option<&str>) -> anyhow::Result { 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::(), 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::() { 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::() { 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::(), 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::(), 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::() { 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::(), 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::() { Some(RequestIdentityError::NoPassphrase("PKCS#12")) => assert!(password.is_none()), Some(RequestIdentityError::InvalidPkcs12(_)) => assert!(password.is_some()), other => panic!("unexpected archive error: {other:?}"), } } } }