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.
This commit is contained in:
Kevin Yue committed 2026-11-07 11:23:19 +08:00
1 parent e03a758acb
commit c476dfefb0
42 files changed
+2618 -163

No files matched your search

@@ -0,0 +1,150 @@
//! Supported desktop identities and actionable failures for unsupported inputs.
#![cfg(any(
target_os = "macos",
target_os = "linux",
target_os = "freebsd",
target_os = "openbsd"
))]
use gpapi::utils::request::{ClientIdentity, RequestIdentityError};
use openssl::{
asn1::Asn1Time,
bn::BigNum,
hash::MessageDigest,
pkey::PKey,
stack::Stack,
x509::{X509, X509NameBuilder},
};
use std::{fs, path::PathBuf};
use zeroize::Zeroizing;
fn fixture(name: &str) -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/files/client-identity")
.join(name)
}
fn assert_unsupported_key(certificate: &str, key: &str) {
let error = ClientIdentity::load(
fixture(certificate).to_str().unwrap(),
Some(fixture(key).to_str().unwrap()),
None,
)
.unwrap_err();
assert!(
matches!(
error.downcast_ref::<RequestIdentityError>(),
Some(RequestIdentityError::UnsupportedKeyAlgorithm(_))
),
"{error:#}"
);
let message = error.to_string();
assert!(message.contains("unsupported"), "{message}");
assert!(message.contains("VPN administrator"), "{message}");
assert!(
!message.contains("password") && !message.contains("does not match"),
"{message}"
);
}
#[test]
fn compressed_ec_certificate_reports_an_unsupported_encoding() {
assert_unsupported_key("ec-compressed-cert.pem", "ec-pkcs8.pem");
}
#[test]
fn compressed_ec_private_key_reports_an_unsupported_encoding() {
assert_unsupported_key("ec-compressed-cert.pem", "ec-compressed.pem");
}
#[test]
fn explicit_ec_parameters_report_an_unsupported_encoding() {
assert_unsupported_key("ec-explicit-cert.pem", "ec-explicit.pem");
}
#[test]
fn p521_key_reports_the_known_tls_capability_limit() {
assert_unsupported_key("ec-p521-cert.pem", "ec-p521.pem");
}
#[test]
fn rsa_pss_key_reports_the_known_tls_capability_limit() {
assert_unsupported_key("rsa-pss-cert.pem", "rsa-pss.pem");
}
fn legacy_archive(name: &str) {
let path = fixture(name);
let bytes = fs::read(&path).unwrap();
let identity = ClientIdentity::load(path.to_str().unwrap(), None, Some("fixture-password"))
.unwrap_or_else(|error| panic!("{name}: {error:#}"));
assert_eq!(identity.certificate_data(), bytes);
assert!(ClientIdentity::load(path.to_str().unwrap(), None, Some("incorrect")).is_err());
}
fn unsupported_archive(name: &str) {
let path = fixture(name);
let bytes = fs::read(&path).unwrap();
for password in [None, Some("fixture-password"), Some("incorrect"), Some("")] {
for error in [
ClientIdentity::load(path.to_str().unwrap(), None, password).unwrap_err(),
ClientIdentity::from_data(Zeroizing::new(bytes.clone()), None, password).unwrap_err(),
] {
assert!(
matches!(
error.downcast_ref::<RequestIdentityError>(),
Some(RequestIdentityError::UnsupportedEncryption)
),
"{name}: {error:#}"
);
assert!(error.to_string().contains("AES"), "{error}");
}
}
}
#[test]
fn legacy_rc2_128_pkcs12_explains_the_unsupported_encryption() {
unsupported_archive("legacy-RC2-128.p12");
}
#[test]
fn legacy_rc4_128_pkcs12_is_usable() {
legacy_archive("legacy-RC4-128.p12");
}
#[test]
fn legacy_two_key_3des_pkcs12_explains_the_unsupported_encryption() {
unsupported_archive("legacy-2DES.p12");
}
#[test]
fn renewed_pkcs12_with_one_key_is_accepted_without_artificial_ambiguity() {
let key = PKey::private_key_from_pem(&fs::read(fixture("rsa-pkcs8.pem")).unwrap()).unwrap();
let mut name = X509NameBuilder::new().unwrap();
name.append_entry_by_text("CN", "Public renewed identity").unwrap();
let name = name.build();
let mut certs = Vec::new();
for serial in [10, 11] {
let mut builder = X509::builder().unwrap();
builder.set_version(2).unwrap();
builder.set_subject_name(&name).unwrap();
builder.set_issuer_name(&name).unwrap();
builder.set_pubkey(&key).unwrap();
builder
.set_serial_number(&BigNum::from_u32(serial).unwrap().to_asn1_integer().unwrap())
.unwrap();
builder.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
builder.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
builder.sign(&key, MessageDigest::sha256()).unwrap();
certs.push(builder.build());
}
let mut extra = Stack::new().unwrap();
extra.push(certs[0].clone()).unwrap();
let mut builder = openssl::pkcs12::Pkcs12::builder();
builder.name("renewed").pkey(&key).cert(&certs[1]).ca(extra);
let archive = builder.build2("fixture-password").unwrap().to_der().unwrap();
// Independent oracle for this bag order. Native bag-order permutation tests
// establish selection; localKeyId alone does not override native ordering.
let parsed = openssl::pkcs12::Pkcs12::from_der(&archive)
.unwrap()
.parse2("fixture-password")
.unwrap();
assert_eq!(parsed.cert.unwrap().to_der().unwrap(), certs[1].to_der().unwrap());
ClientIdentity::from_data(Zeroizing::new(archive), None, Some("fixture-password")).unwrap();
}
@@ -0,0 +1,419 @@
//! Issue #697: local identity matching must not apply a peer's extension policy.
//! OpenSSL is an independent test oracle/server, never a product import backend.
use std::{
fs,
io::{Read, Write},
net::TcpListener,
thread,
time::Duration,
};
use gpapi::{
gp_params::GpParams,
os_profile::{ClientOs, HostIdentity, HostSnapshot, OsProfile},
utils::request::{ClientIdentity, RequestIdentityError},
};
use openssl::{
asn1::{Asn1Object, Asn1OctetString, Asn1Time},
ec::{EcGroup, EcKey},
hash::MessageDigest,
nid::Nid,
pkey::{Id, PKey, Private},
ssl::{SslAcceptor, SslConnector, SslMethod, SslVerifyMode, SslVersion},
x509::{X509, X509Extension, X509NameBuilder},
};
use zeroize::Zeroizing;
const PASSWORD: &str = "fixture-password";
fn key(family: &str) -> PKey<Private> {
if family == "ec-p384" {
let group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
return PKey::from_ec_key(EcKey::generate(&group).unwrap()).unwrap();
}
if family == "ed25519" {
return PKey::generate_ed25519().unwrap();
}
let bytes: &[u8] = match family {
"rsa" => include_bytes!("files/client-identity/rsa-pkcs8.pem"),
"ec" => include_bytes!("files/client-identity/ec-pkcs8.pem"),
_ => panic!("unknown key family"),
};
PKey::private_key_from_pem(bytes).unwrap()
}
fn certificate(key: &PKey<Private>, extension: Option<(&str, bool, &[u8])>) -> X509 {
let mut name = X509NameBuilder::new().unwrap();
name.append_entry_by_text("CN", "Public regression identity").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::from_unix(1_700_000_000).unwrap())
.unwrap();
cert
.set_not_after(&Asn1Time::from_unix(4_000_000_000).unwrap())
.unwrap();
if let Some((oid, critical, value)) = extension {
let oid = Asn1Object::from_str(oid).unwrap();
let value = Asn1OctetString::new_from_bytes(value).unwrap();
cert
.append_extension(X509Extension::new_from_der(&oid, critical, &value).unwrap())
.unwrap();
}
let digest = if key.id() == Id::ED25519 {
MessageDigest::null()
} else {
MessageDigest::sha256()
};
cert.sign(key, digest).unwrap();
cert.build()
}
fn private_extension() -> Option<(&'static str, bool, &'static [u8])> {
Some(("1.3.6.1.4.1.55555.1", true, &[0x05, 0x00]))
}
fn params(identity: ClientIdentity, ignore_tls_errors: bool) -> GpParams {
let snapshot = HostSnapshot {
runtime_os: ClientOs::Linux,
identity: HostIdentity::application("regression-test".into(), "public-test-id".into()),
os_version: "test".into(),
software_version: "test".into(),
};
GpParams::builder(OsProfile::builder(ClientOs::Linux).build(snapshot))
.client_identity(Some(identity))
.ignore_tls_errors(ignore_tls_errors)
.build()
}
fn assert_usable(identity: ClientIdentity) {
reqwest::Client::try_from(&params(identity.clone(), false)).unwrap();
reqwest::Client::try_from(&params(identity.clone(), true)).unwrap();
let restored = ClientIdentity::from_data(
Zeroizing::new(identity.certificate_data().to_vec()),
identity.key_data().map(|key| Zeroizing::new(key.to_vec())),
identity.key_password(),
)
.unwrap();
assert_eq!(restored.certificate_data(), identity.certificate_data());
let files = restored.write_files(None).unwrap();
ClientIdentity::load(files.certificate(), files.key(), restored.key_password()).unwrap();
}
#[derive(Clone, Copy, Debug)]
enum Container {
SeparatePem,
CombinedPem,
Der,
Pkcs12,
Snapshot,
}
fn load(container: Container, cert: &X509, key: &PKey<Private>) -> anyhow::Result<ClientIdentity> {
let directory = tempfile::tempdir().unwrap();
let source = directory.path().join("client.pem");
let key_path = directory.path().join("client.key");
let key_pem = key.private_key_to_pem_pkcs8().unwrap();
fs::write(&key_path, &key_pem).unwrap();
match container {
Container::SeparatePem => {
fs::write(&source, cert.to_pem().unwrap()).unwrap();
ClientIdentity::load(source.to_str().unwrap(), Some(key_path.to_str().unwrap()), None)
}
Container::CombinedPem => {
let mut combined = cert.to_pem().unwrap();
combined.extend(&key_pem);
fs::write(&source, combined).unwrap();
ClientIdentity::load(source.to_str().unwrap(), None, None)
}
Container::Der => {
fs::write(&source, cert.to_der().unwrap()).unwrap();
fs::write(&key_path, key.private_key_to_pkcs8().unwrap()).unwrap();
ClientIdentity::load(source.to_str().unwrap(), Some(key_path.to_str().unwrap()), None)
}
Container::Pkcs12 => {
let mut archive = openssl::pkcs12::Pkcs12::builder();
archive.name("public regression identity").pkey(key).cert(cert);
let archive = archive.build2(PASSWORD).unwrap().to_der().unwrap();
let source = directory.path().join("client.p12");
fs::write(&source, archive).unwrap();
ClientIdentity::load(source.to_str().unwrap(), None, Some(PASSWORD))
}
Container::Snapshot => ClientIdentity::from_data(
Zeroizing::new(cert.to_pem().unwrap()),
Some(Zeroizing::new(key_pem)),
None,
),
}
}
fn extension_matrix(container: Container) {
let cases: &[(&str, Option<(&str, bool, &[u8])>)] = &[
("no extensions", None),
(
"private noncritical",
Some(("1.3.6.1.4.1.55555.1", false, &[0x05, 0x00])),
),
("private critical", private_extension()),
// Netscape certificate type and Microsoft certificate template name are
// realistic enterprise extensions that WebPKI does not interpret.
(
"Netscape client type",
Some(("2.16.840.1.113730.1.1", true, &[0x03, 0x02, 0x07, 0x80])),
),
(
"Microsoft template",
Some(("1.3.6.1.4.1.311.20.2", true, &[0x1e, 0x02, 0x00, b'A'])),
),
(
"critical key usage",
Some(("2.5.29.15", true, &[0x03, 0x02, 0x07, 0x80])),
),
(
"critical client EKU",
Some((
"2.5.29.37",
true,
&[0x30, 0x0a, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02],
)),
),
];
for family in ["rsa", "ec", "ec-p384", "ed25519"] {
let key = key(family);
for &(name, extension) in cases {
let cert = certificate(&key, extension);
// The previous OpenSSL backend accepts this local certificate/key pair.
let mut oracle = SslConnector::builder(SslMethod::tls()).unwrap();
oracle.set_certificate(&cert).unwrap();
oracle.set_private_key(&key).unwrap();
oracle.check_private_key().unwrap();
let identity =
load(container, &cert, &key).unwrap_or_else(|error| panic!("{container:?}/{family}/{name}: {error:#}"));
if !matches!(container, Container::Pkcs12) {
assert_eq!(identity.certificate_data(), cert.to_pem().unwrap());
}
assert_usable(identity);
}
}
}
#[test]
fn separate_pem_extension_matrix() {
extension_matrix(Container::SeparatePem);
}
#[test]
fn combined_pem_extension_matrix() {
extension_matrix(Container::CombinedPem);
}
#[test]
fn der_extension_matrix() {
extension_matrix(Container::Der);
}
#[test]
fn pkcs12_extension_matrix() {
extension_matrix(Container::Pkcs12);
}
#[test]
fn snapshot_extension_matrix() {
extension_matrix(Container::Snapshot);
}
#[test]
fn critical_extensions_do_not_hide_a_mismatched_private_key() {
for family in ["rsa", "ec"] {
let cert = certificate(&key(family), private_extension());
let wrong_family = if family == "rsa" { "ec" } else { "rsa" };
let same_family_wrong_key = if family == "rsa" {
PKey::from_rsa(openssl::rsa::Rsa::generate(2048).unwrap()).unwrap()
} else {
let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
PKey::from_ec_key(EcKey::generate(&group).unwrap()).unwrap()
};
// PEM and service snapshots can carry mismatched material. OpenSSL's
// PKCS#12 writer itself rejects a mismatch; existing archive fixtures cover it.
for wrong_key in [key(wrong_family), same_family_wrong_key] {
for container in [
Container::SeparatePem,
Container::CombinedPem,
Container::Der,
Container::Snapshot,
] {
let error = load(container, &cert, &wrong_key).unwrap_err();
assert!(
matches!(
error.downcast_ref::<RequestIdentityError>(),
Some(RequestIdentityError::KeyMismatch)
),
"{error:#}"
);
}
}
}
}
#[test]
fn cli_identity_preparation_keeps_critical_extensions_after_source_files_are_removed() {
let key = key("rsa");
let cert = certificate(&key, private_extension());
let directory = tempfile::tempdir().unwrap();
let source = directory.path().join("client.pem");
let key_path = directory.path().join("client.key");
fs::write(&source, cert.to_pem().unwrap()).unwrap();
fs::write(&key_path, key.private_key_to_pem_pkcs8().unwrap()).unwrap();
let identity = load(Container::Snapshot, &cert, &key).unwrap();
let profile = params(identity, false).os_profile().clone();
// Start with the unprepared path used by the reported gateway prelogin.
let mut params = GpParams::builder(profile)
.certificate(Some(source.to_string_lossy().into_owned()))
.sslkey(Some(key_path.to_string_lossy().into_owned()))
.build();
reqwest::Client::try_from(&params).unwrap();
params.prepare_client_identity().unwrap();
drop(directory);
reqwest::Client::try_from(&params).unwrap();
assert_eq!(
params.client_identity().unwrap().certificate_data(),
cert.to_pem().unwrap()
);
}
#[test]
fn critical_extension_in_a_chain_preserves_every_certificate() {
let key = key("rsa");
let cert = certificate(&key, private_extension());
let mut chain = cert.to_pem().unwrap();
chain.extend(include_bytes!("files/client-identity/root.pem"));
let identity = ClientIdentity::from_data(
Zeroizing::new(chain.clone()),
Some(Zeroizing::new(key.private_key_to_pem_pkcs8().unwrap())),
None,
)
.unwrap();
assert_eq!(identity.certificate_data(), chain);
assert_usable(identity);
}
fn server(
cert: &X509,
key: &PKey<Private>,
version: SslVersion,
expected_client: Vec<u8>,
accept_client: bool,
) -> (String, thread::JoinHandle<bool>) {
let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
acceptor.set_certificate(cert).unwrap();
acceptor.set_private_key(key).unwrap();
acceptor.set_min_proto_version(Some(version)).unwrap();
acceptor.set_max_proto_version(Some(version)).unwrap();
// Model a VPN that understands this private extension. TLS still verifies
// CertificateVerify; the server also checks the exact leaf bytes below.
acceptor.set_verify_callback(
SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT,
move |_, _| accept_client,
);
let acceptor = acceptor.build();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let address = format!("https://{}", listener.local_addr().unwrap());
let worker = thread::spawn(move || {
// Bound failures even if client construction or connection fails.
let deadline = std::time::Instant::now() + Duration::from_secs(5);
let stream = loop {
match listener.accept() {
Ok((stream, _)) => break stream,
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
if std::time::Instant::now() >= deadline {
return false;
}
thread::sleep(Duration::from_millis(5));
}
Err(error) => panic!("{error}"),
}
};
stream.set_nonblocking(false).unwrap();
stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
stream.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
let Ok(mut stream) = acceptor.accept(stream) else {
return false;
};
let peer = stream.ssl().peer_certificate().unwrap();
assert_eq!(
peer.to_der().unwrap(),
expected_client,
"the original signed certificate must be sent unchanged"
);
assert!(peer.verify(&peer.public_key().unwrap()).unwrap());
let mut request = [0; 4096];
if stream.read(&mut request).is_err() {
return false;
}
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
.is_ok()
});
(address, worker)
}
#[tokio::test]
async fn critical_extension_identity_completes_tls12_and_tls13_client_authentication() {
let server_key = key("rsa");
let server_cert = certificate(&server_key, None);
for family in ["rsa", "ec", "ec-p384", "ed25519"] {
let key = key(family);
let cert = certificate(&key, private_extension());
for container in [Container::SeparatePem, Container::Pkcs12] {
for version in [SslVersion::TLS1_2, SslVersion::TLS1_3] {
let identity = load(container, &cert, &key).unwrap();
let client = reqwest::Client::try_from(&params(identity, true)).unwrap();
let (address, worker) = server(&server_cert, &server_key, version, cert.to_der().unwrap(), true);
let result = client.get(address).timeout(Duration::from_secs(5)).send().await;
assert!(
worker.join().unwrap(),
"{family}/{container:?}/{version:?}: server did not complete client authentication"
);
assert_eq!(result.unwrap().text().await.unwrap(), "ok");
}
}
}
}
#[tokio::test]
async fn client_extensions_do_not_disable_server_trust_or_peer_rejection() {
let key = key("rsa");
let cert = certificate(&key, private_extension());
let server_cert = certificate(&key, None);
for (ignore_server_errors, accept_client) in [(false, true), (true, false)] {
for version in [SslVersion::TLS1_2, SslVersion::TLS1_3] {
let identity = load(Container::SeparatePem, &cert, &key).unwrap();
let client = reqwest::Client::try_from(&params(identity, ignore_server_errors)).unwrap();
let (address, worker) = server(&server_cert, &key, version, cert.to_der().unwrap(), accept_client);
let result = client.get(address).timeout(Duration::from_secs(5)).send().await;
assert!(
result.is_err(),
"server trust and peer rejection must still be enforced"
);
assert!(!worker.join().unwrap());
let error = result.unwrap_err();
assert!(
!error.is_timeout(),
"expected a TLS rejection, not a timeout: {error:?}"
);
let details = format!("{error:?}");
if ignore_server_errors {
assert!(
details.contains("AlertReceived"),
"expected the server's client-certificate rejection: {details}"
);
} else {
assert!(
details.contains("InvalidCertificate"),
"expected server certificate validation to fail: {details}"
);
}
}
}
}
@@ -0,0 +1,156 @@
//! Recorded 3.2 compatibility gap: TLS 1.2 ECDSA hashes are not curve-bound.
//! OpenSSL is a test-only baseline and peer, never a product TLS backend.
#![cfg(any(
target_os = "macos",
target_os = "linux",
target_os = "freebsd",
target_os = "openbsd"
))]
use std::{
io::{Read, Write},
net::{TcpListener, TcpStream},
thread,
time::{Duration, Instant},
};
use gpapi::{
gp_params::GpParams,
os_profile::{ClientOs, HostIdentity, HostSnapshot, OsProfile},
utils::request::ClientIdentity,
};
use openssl::{
asn1::Asn1Time,
ec::{EcGroup, EcKey},
hash::MessageDigest,
nid::Nid,
pkey::{PKey, Private},
ssl::{SslAcceptor, SslConnector, SslMethod, SslVerifyMode, SslVersion},
x509::{X509, X509NameBuilder},
};
use zeroize::Zeroizing;
fn identity(curve: Nid, name: &str) -> (PKey<Private>, X509) {
let group = EcGroup::from_curve_name(curve).unwrap();
let key = PKey::from_ec_key(EcKey::generate(&group).unwrap()).unwrap();
let mut subject = X509NameBuilder::new().unwrap();
subject.append_entry_by_text("CN", name).unwrap();
let subject = subject.build();
let mut certificate = X509::builder().unwrap();
certificate.set_version(2).unwrap();
certificate.set_subject_name(&subject).unwrap();
certificate.set_issuer_name(&subject).unwrap();
certificate.set_pubkey(&key).unwrap();
certificate
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
.unwrap();
certificate.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
certificate.sign(&key, MessageDigest::sha256()).unwrap();
(key, certificate.build())
}
fn sha256_only_tls12_peer(expected: &X509) -> (String, thread::JoinHandle<Result<(), String>>) {
let (key, certificate) = identity(Nid::X9_62_PRIME256V1, "Public TLS 1.2 peer");
let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
acceptor.set_certificate(&certificate).unwrap();
acceptor.set_private_key(&key).unwrap();
acceptor.set_min_proto_version(Some(SslVersion::TLS1_2)).unwrap();
acceptor.set_max_proto_version(Some(SslVersion::TLS1_2)).unwrap();
// P-256 server authentication works with this list. The P-384 client must
// also sign with SHA-256, which is allowed in TLS 1.2 but not TLS 1.3.
acceptor.set_sigalgs_list("ECDSA+SHA256").unwrap();
let expected = expected.to_der().unwrap();
let pinned = expected.clone();
acceptor.set_verify_callback(
SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT,
move |_, context| {
context.error_depth() == 0
&& context
.current_cert()
.is_some_and(|certificate| certificate.to_der().unwrap() == pinned)
},
);
let acceptor = acceptor.build();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let address = listener.local_addr().unwrap().to_string();
let worker = thread::spawn(move || {
let deadline = Instant::now() + Duration::from_secs(5);
let stream = loop {
match listener.accept() {
Ok((stream, _)) => break stream,
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock && Instant::now() < deadline => {
thread::sleep(Duration::from_millis(5));
}
Err(error) => return Err(format!("Accepting TLS peer: {error}")),
}
};
stream.set_nonblocking(false).unwrap();
stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
stream.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
// SSL_accept checks the client's CertificateVerify proof of possession.
let mut stream = acceptor
.accept(stream)
.map_err(|error| format!("Client authentication: {error}"))?;
assert_eq!(stream.ssl().version2(), Some(SslVersion::TLS1_2));
assert_eq!(stream.ssl().peer_certificate().unwrap().to_der().unwrap(), expected);
let mut request = [0; 4096];
let length = stream.read(&mut request).map_err(|error| error.to_string())?;
assert!(length > 0);
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
.map_err(|error| error.to_string())
});
(address, worker)
}
#[test]
fn openssl_baseline_authenticates_p384_with_tls12_sha256() {
let (key, certificate) = identity(Nid::SECP384R1, "Public P-384 client");
let (address, peer) = sha256_only_tls12_peer(&certificate);
let mut connector = SslConnector::builder(SslMethod::tls()).unwrap();
connector.set_certificate(&certificate).unwrap();
connector.set_private_key(&key).unwrap();
// This fixture isolates client authentication; the peer pins the exact leaf.
connector.set_verify(SslVerifyMode::NONE);
let socket = TcpStream::connect(address).unwrap();
socket.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
socket.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
let mut stream = connector.build().connect("localhost", socket).unwrap();
stream.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n").unwrap();
let mut response = [0; 1024];
assert!(stream.read(&mut response).unwrap() > 0);
peer.join().unwrap().unwrap();
}
#[tokio::test]
#[ignore = "Known regression from 3.2: P-384 signs only SHA-384; Rustls SigningKey has no negotiated version to safely allow TLS 1.2 SHA-256 while preserving TLS 1.3 curve binding"]
async fn p384_authenticates_with_tls12_sha256() {
let (key, certificate) = identity(Nid::SECP384R1, "Public P-384 client");
let identity = ClientIdentity::from_data(
Zeroizing::new(certificate.to_pem().unwrap()),
Some(Zeroizing::new(key.private_key_to_pem_pkcs8().unwrap())),
None,
)
.unwrap();
let snapshot = HostSnapshot {
runtime_os: ClientOs::Linux,
identity: HostIdentity::application("regression-test".into(), "public-test-id".into()),
os_version: "test".into(),
software_version: "test".into(),
};
let params = GpParams::builder(OsProfile::builder(ClientOs::Linux).build(snapshot))
.client_identity(Some(identity))
.ignore_tls_errors(true)
.build();
let client = reqwest::Client::try_from(&params).unwrap();
let (address, peer) = sha256_only_tls12_peer(&certificate);
let response = client
.get(format!("https://{address}"))
.timeout(Duration::from_secs(5))
.send()
.await;
let authentication = peer.join().unwrap();
assert!(authentication.is_ok(), "{authentication:?}; HTTP result: {response:?}");
assert_eq!(response.unwrap().text().await.unwrap(), "ok");
}
+13 -16
View File
@@ -114,11 +114,10 @@ fn malformed_rsa_pkcs1_is_rejected_before_connection() {
None,
)
.unwrap_err();
assert!(
error
.to_string()
.contains("Check that the private key matches the certificate")
);
assert!(matches!(
error.downcast_ref::<RequestIdentityError>(),
Some(RequestIdentityError::InvalidKey)
));
}
fn check_archive(name: &str, password: &str) {
@@ -604,17 +603,15 @@ fn mismatched_certificate_key_is_rejected_before_request_client_creation() {
let certificate = fs::read(fixture("root.pem")).unwrap();
let key = fs::read(fixture("rsa-pkcs8.pem")).unwrap();
let error = load("root.pem", "rsa-pkcs8.pem", None).unwrap_err();
assert!(
error
.to_string()
.contains("Check that the private key matches the certificate")
);
assert!(matches!(
error.downcast_ref::<RequestIdentityError>(),
Some(RequestIdentityError::KeyMismatch)
));
let error = ClientIdentity::from_data(certificate.into(), Some(key.into()), None).unwrap_err();
assert!(
error
.to_string()
.contains("Check that the private key matches the certificate")
);
assert!(matches!(
error.downcast_ref::<RequestIdentityError>(),
Some(RequestIdentityError::KeyMismatch)
));
}
#[test]
@@ -640,7 +637,7 @@ fn pkcs12_rejects_mismatched_and_multiple_identities() {
let error = ClientIdentity::load(fixture(name).to_str().unwrap(), None, None).unwrap_err();
match error.downcast_ref::<RequestIdentityError>() {
Some(RequestIdentityError::AmbiguousPkcs12) => assert!(ambiguous),
Some(RequestIdentityError::InvalidCertificate) => assert!(!ambiguous),
Some(RequestIdentityError::KeyMismatch) => assert!(!ambiguous),
other => panic!("{name}: unexpected archive error: {other:?}"),
}
}
@@ -19,6 +19,7 @@ optional fixture-generation script, not identity import.
| Files | Contents |
| --- | --- |
| `root.pem`, `rsa-cert.pem`, `ec-cert.pem` | Test root and issued RSA-2048 / P-256 client certificates, SHA256 signatures |
| `rsa-critical-extension.pem` | Self-signed certificate for the existing RSA key with a private critical extension; issue #697 desktop validation regression |
| `rsa-pkcs8.pem`, `ec-pkcs8.pem` | Plain PKCS#8 keys; expected normalized output |
| `rsa-pkcs1.pem`, `ec-sec1.pem` | Same keys in traditional containers |
| `{rsa,ec}-traditional-{aes128,aes192,aes256,des3}.pem` | Traditional encrypted PEM with AES-CBC or 3DES-CBC; password `fixture-password` |
@@ -34,13 +35,19 @@ optional fixture-generation script, not identity import.
| `modern.p12`, `unicode-password.p12` | Leaf/key/root, AES256-CBC/PBKDF2-SHA256, SHA256 MAC; RSA and EC respectively |
| `certificate-only.pfx`, `key-only.pfx` | Incomplete PKCS#12 archives: certificate without key, and key without certificate; password `fixture-password` |
| `legacy-rc2.p12` | Issue #437 case: RC2-40 certificate bags, SHA1/3DES key bag, SHA1 MAC |
| `ec-p521.pem`, `ec-p521-cert.pem` | Valid P-521 identity; explicit unsupported-key error until HTTP negotiation parity exists |
| `rsa-pss.pem`, `rsa-pss-cert.pem` | Valid RSA-PSS identity; explicit unsupported-key error until Rustls negotiation parity exists |
| `ec-{compressed,explicit}.pem`, matching `-cert.pem` files | Valid OpenSSL inputs rejected by the tested GnuTLS backend; actionable unsupported-encoding tests |
| `legacy-RC4-128.p12` | SHA1/RC4-128 key encryption and SHA1/3DES certificate encryption; native archive import |
| `legacy-RC2-128.p12`, `legacy-2DES.p12` | Unsupported archive encryption; terminal AES re-export guidance with any password |
`tests/client_identity.rs` covers all supported key families, password failures,
archive integrity, certificate/key matching, retained snapshots, private-file
permissions and cleanup. `tests/identity_encoding.rs` covers PEM/DER, RSA PKCS#1,
EC SEC1, traditional encrypted PEM, first-key selection, malformed encryption
headers and archive extension capitalization. Rustls validates RSA and EC keys
on all supported targets; desktop legacy encrypted-key imports use GnuTLS.
headers and archive extension capitalization. Desktop GnuTLS validates and signs client keys; portable builds keep the Rust
implementation. Legacy encrypted-key imports use the private GnuTLS shim.
Legacy PKCS#12 SHA1/3DES keys use a consistent limit of 127 UTF-16 code units
(256 bytes including the terminator), matching older supported GnuTLS releases.
Longer passwords report a clear error without exposing the password.
@@ -53,6 +60,35 @@ MAC. Decrypted output is compared with independent plaintext fixture keys.
Unit tests in `utils/request.rs` cover missing keys, large local files and request
client construction.
`tests/client_certificate_extensions.rs` covers issue #697 with generated
RSA, P-256, P-384 and Ed25519 identities: no extensions, private critical and
noncritical extensions, critical Netscape client type, Microsoft template,
key usage and client EKU. Each is exercised as separate PEM, combined PEM,
DER, PKCS#12 and a service snapshot, including snapshot/file round trips and
request-client construction. Independent OpenSSL checks establish local key
compatibility. TLS 1.2/1.3 tests verify client authentication with PEM and
PKCS#12 and confirm the original signed certificate is sent unchanged. Negative
cases retain key mismatch errors, server trust checks and server rejection of
a client certificate. The checked-in critical-extension fixture also covers
the shared certificate validation used by both desktop shells.
`tests/certificate_compatibility.rs` checks RC4-128 import, renewed identities and P-521 rejection,
and typed, actionable errors for unsupported algorithms,
EC encodings and archive encryption. The OpenConnect integration suite checks
the real loader/handshake separately from these HTTP/import tests.
Desktop local matching and signing use GnuTLS. The VPN server validates client
certificate extensions and trust; HTTP server trust still uses the platform
verifier with Rustls/ring. RSA-PSS and P-521 key types deliberately fail before connecting
until the HTTP transport can negotiate them correctly on both TLS versions.
This differs from ordinary RSA keys producing RSA-PSS signatures, which remain
supported. OpenSSL remains development-only.
`tests/client_certificate_tls12_hash.rs` records the remaining TLS 1.2 P-384
with SHA-256-only peer request gap: the OpenSSL baseline passes, while the
replacement reproducer is explicitly ignored pending negotiated-version-aware
signing. TLS 1.3 curve restrictions must remain intact.
The unencrypted, MAC-less `no-bag-ids.p12`, `mismatched.p12`, and
`multiple-identities.p12` contain only the same public test keys/certificates.
They exercise PKCS#12 bags without optional attributes, reversed certificate
@@ -0,0 +1,11 @@
-----BEGIN CERTIFICATE-----
MIIBiTCCAS+gAwIBAgIUHDc6Wcp0MUwwtwAhR3fEY3zLSXQwCgYIKoZIzj0EAwIw
KjEoMCYGA1UEAwwfR1AgUHVibGljIGNvbXByZXNzZWQgUmVncmVzc2lvbjAeFw0y
NjExMDcwMjA2MjZaFw0zNjExMDQwMjA2MjZaMCoxKDAmBgNVBAMMH0dQIFB1Ymxp
YyBjb21wcmVzc2VkIFJlZ3Jlc3Npb24wOTATBgcqhkjOPQIBBggqhkjOPQMBBwMi
AANCb8yN/N6VTBYHE1F66qyust8GzXKAd6pfo1cEItbJFaNTMFEwHQYDVR0OBBYE
FIK3uCPt33xbuFkEkBQx2RBu3UIDMB8GA1UdIwQYMBaAFIK3uCPt33xbuFkEkBQx
2RBu3UIDMA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDSAAwRQIhALe0rg77
NMpcc8yKUnGcdWDu8GW1IE55TJf++RkJ+/JAAiBnlmSBnoZaTrPa5LEycfTJMKSN
URn6fRsbCH1z4mQ6XQ==
-----END CERTIFICATE-----
@@ -0,0 +1,4 @@
-----BEGIN EC PRIVATE KEY-----
MFcCAQEEIMIgGXJZB//8Zp7TOavSyB+7LrPKFG4eQZ8Fxx30bTzUoAoGCCqGSM49
AwEHoSQDIgADQm/MjfzelUwWBxNReuqsrrLfBs1ygHeqX6NXBCLWyRU=
-----END EC PRIVATE KEY-----
@@ -0,0 +1,16 @@
-----BEGIN CERTIFICATE-----
MIICmTCCAj+gAwIBAgIUNb1E0mpnr5RBM1FR96iDr4We5r0wCgYIKoZIzj0EAwIw
KDEmMCQGA1UEAwwdR1AgUHVibGljIGV4cGxpY2l0IFJlZ3Jlc3Npb24wHhcNMjYx
MTA3MDIwNjI2WhcNMzYxMTA0MDIwNjI2WjAoMSYwJAYDVQQDDB1HUCBQdWJsaWMg
ZXhwbGljaXQgUmVncmVzc2lvbjCCAUswggEDBgcqhkjOPQIBMIH3AgEBMCwGByqG
SM49AQECIQD/////AAAAAQAAAAAAAAAAAAAAAP///////////////zBbBCD/////
AAAAAQAAAAAAAAAAAAAAAP///////////////AQgWsY12Ko6k+ez671VdpiGvGUd
BrDMU7D2O848PifSYEsDFQDEnTYIhucEk2pmeOETnSa3gZ9+kARBBGsX0fLhLEJH
+Lzm5WOkQPJ3A32BLeszoPShOUXYmMKWT+NC4v4af5uO5+tKfA+eFivOM1drMV7O
y7ZAaDe/UfUCIQD/////AAAAAP//////////vOb6racXnoTzucrC/GMlUQIBAQNC
AARCb8yN/N6VTBYHE1F66qyust8GzXKAd6pfo1cEItbJFapMj+oEjBtrobfNydlo
CucLD5ewywG9O2mG6IMei49bo1MwUTAdBgNVHQ4EFgQUbJK+tR9aD33KGW9Ed7lV
x1BX7qwwHwYDVR0jBBgwFoAUbJK+tR9aD33KGW9Ed7lVx1BX7qwwDwYDVR0TAQH/
BAUwAwEB/zAKBggqhkjOPQQDAgNIADBFAiAHTMFLSyvWxcE198z6beN5B4+0LnsW
96Y06HhX5+uzaAIhANZHyKvAU4wDnTslafc7ch3ETQPBhWppgiTKHqE0+jUI
-----END CERTIFICATE-----
@@ -0,0 +1,10 @@
-----BEGIN EC PRIVATE KEY-----
MIIBaAIBAQQgwiAZclkH//xmntM5q9LIH7sus8oUbh5BnwXHHfRtPNSggfowgfcC
AQEwLAYHKoZIzj0BAQIhAP////8AAAABAAAAAAAAAAAAAAAA////////////////
MFsEIP////8AAAABAAAAAAAAAAAAAAAA///////////////8BCBaxjXYqjqT57Pr
vVV2mIa8ZR0GsMxTsPY7zjw+J9JgSwMVAMSdNgiG5wSTamZ44ROdJreBn36QBEEE
axfR8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5RdiYwpZP40Li/hp/m47n60p8D54W
K84zV2sxXs7LtkBoN79R9QIhAP////8AAAAA//////////+85vqtpxeehPO5ysL8
YyVRAgEBoUQDQgAEQm/MjfzelUwWBxNReuqsrrLfBs1ygHeqX6NXBCLWyRWqTI/q
BIwba6G3zcnZaArnCw+XsMsBvTtphuiDHouPWw==
-----END EC PRIVATE KEY-----
@@ -0,0 +1,14 @@
-----BEGIN CERTIFICATE-----
MIICJDCCAYagAwIBAgIURE3nvaUdT7yk7gTwyhUFyCE1+K8wCgYIKoZIzj0EAwIw
JDEiMCAGA1UEAwwZR1AgUHVibGljIHA1MjEgUmVncmVzc2lvbjAeFw0yNjExMDcw
MjA2MjZaFw0zNjExMDQwMjA2MjZaMCQxIjAgBgNVBAMMGUdQIFB1YmxpYyBwNTIx
IFJlZ3Jlc3Npb24wgZswEAYHKoZIzj0CAQYFK4EEACMDgYYABAAu5HAWZpjZxfu6
jQ+61F5CysJzWgkc4MIB4z8kW9w0x76vUGlWPX+yw0q5EzpeEGjWV82YDRoEfkDR
fAjk8/B/8wDNJ7oH9pepkq3DroH0v3R34C8oQwbsw/Rx9JwOECR3u2jIgzNLtiEf
iEBgucZ5MgDEgNJdB03qCvaqUmYXN7LwoqNTMFEwHQYDVR0OBBYEFOsuLBWpYWC7
PHAVmEE4a4gypkYaMB8GA1UdIwQYMBaAFOsuLBWpYWC7PHAVmEE4a4gypkYaMA8G
A1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDgYsAMIGHAkEPBtWqP2e1ZLiXH3V5
Zp21p4uWCJiJxasdl3iuGgKbJiSUSM9m/90iLhan+j/RTkxW8Yt5KkWDTNFQac17
7oSymAJCAROy25Xz7ScbLRbh2CquVzelxmxQtrWZmr2C6hNOG8vZat4qOigwmz/1
ZRn2bQL5Gh0J21ohAXpzWgpLlXp1O4Bf
-----END CERTIFICATE-----
@@ -0,0 +1,7 @@
-----BEGIN EC PRIVATE KEY-----
MIHcAgEBBEIB61IsG6+MaMabtPWlbajOeOFQHcYyRjgenJqZdHvPt4VW9COQZGai
NkHmp3iifcXWDegv1vY4fFmCmc9zlbbZU7qgBwYFK4EEACOhgYkDgYYABAAu5HAW
ZpjZxfu6jQ+61F5CysJzWgkc4MIB4z8kW9w0x76vUGlWPX+yw0q5EzpeEGjWV82Y
DRoEfkDRfAjk8/B/8wDNJ7oH9pepkq3DroH0v3R34C8oQwbsw/Rx9JwOECR3u2jI
gzNLtiEfiEBgucZ5MgDEgNJdB03qCvaqUmYXN7Lwog==
-----END EC PRIVATE KEY-----
@@ -17,6 +17,19 @@ for algorithm in rsa ec; do
"$openssl_bin" x509 -req -in "$scratch/$algorithm.csr" -CA root.pem -CAkey "$scratch/root.key" \
-set_serial 10 -days 3650 -sha256 -out "$algorithm-cert.pem"
done
# Issue #697: the local identity must allow a server-specific critical extension.
"$openssl_bin" req -new -x509 -key rsa-pkcs8.pem -sha256 -days 3650 \
-subj '/CN=GP Critical Extension Regression' \
-addext '1.3.6.1.4.1.55555.1=critical,DER:05:00' -out rsa-critical-extension.pem
# Compatibility and unsupported-input fixtures use the same public test keys.
"$openssl_bin" ec -in ec-pkcs8.pem -conv_form compressed -out ec-compressed.pem
"$openssl_bin" ec -in ec-pkcs8.pem -param_enc explicit -out ec-explicit.pem
"$openssl_bin" ecparam -name secp521r1 -genkey -noout -out ec-p521.pem
"$openssl_bin" genpkey -algorithm RSA-PSS -pkeyopt rsa_keygen_bits:2048 -out rsa-pss.pem
for variant in ec-compressed ec-explicit ec-p521 rsa-pss; do
"$openssl_bin" req -new -x509 -key "$variant.pem" -sha256 -days 3650 \
-subj "/CN=GP Public $variant Regression" -out "$variant-cert.pem"
done
"$openssl_bin" rsa -in rsa-pkcs8.pem -traditional -out rsa-pkcs1.pem
"$openssl_bin" ec -in ec-pkcs8.pem -out ec-sec1.pem
for cipher in aes128 aes192 aes256 des3; do
@@ -70,6 +83,14 @@ done
"$openssl_bin" pkcs8 -provider default -provider legacy -topk8 -in rsa-pkcs8.pem \
-v2 des-cbc -v2prf hmacWithSHA256 -passout pass:fixture-password -out rsa-pbes2-des.pem
# RC4-128 was usable with the former OpenSSL legacy provider and OpenConnect.
# RC2-128 and two-key 3DES deliberately exercise unsupported-encryption errors.
for scheme in RC4-128 RC2-128 2DES; do
"$openssl_bin" pkcs12 -export -legacy -inkey rsa-pkcs8.pem -in rsa-cert.pem \
-keypbe "PBE-SHA1-$scheme" -certpbe PBE-SHA1-3DES \
-passout pass:fixture-password -out "legacy-$scheme.p12"
done
# Incomplete identity archives exercise validation before native TLS import.
"$openssl_bin" pkcs12 -export -nokeys -in rsa-cert.pem \
-name fixture -passout pass:fixture-password -out certificate-only.pfx
@@ -0,0 +1,20 @@
-----BEGIN CERTIFICATE-----
MIIDSzCCAjOgAwIBAgIUColgV9GBymAbAEDYl4N4hI5i+icwDQYJKoZIhvcNAQEL
BQAwKzEpMCcGA1UEAwwgR1AgQ3JpdGljYWwgRXh0ZW5zaW9uIFJlZ3Jlc3Npb24w
HhcNMjYxMTA3MDA0ODI3WhcNMzYxMTA0MDA0ODI3WjArMSkwJwYDVQQDDCBHUCBD
cml0aWNhbCBFeHRlbnNpb24gUmVncmVzc2lvbjCCASIwDQYJKoZIhvcNAQEBBQAD
ggEPADCCAQoCggEBAN3VB3+IqFOlVY6OF/A9OqVqP0BzoIq5sWvR9mxWBHyvU5KZ
G/Xp7a2OF+OOE4jRzPdLgKq31k8tYgwYy6C31jVgUemDyBOwuudiBEcG0DZ6gGEt
E4uyPnFqJQGgBg9HW8uY/Ie0+6+95F6lpjn0ARqum3Hr/+N/oslACPFM1uJTkVCw
aviLFUYjb3Ox6wUTRVtVLEph2Iw3525VfuI9BKQw4NZ51wESpCjXvEB28+CO2k3U
B9egMdaez+Sl85vbP1bWjcYbz1fEDWz8gGK+YhvoPL6nsLOEIXEeY53xaW3z9Tlb
3CSmEeYdZuwXv1cQGrIihTHpWjWQ2wJ7MJJ/1ocCAwEAAaNnMGUwHQYDVR0OBBYE
FD9xPMh2lH691o/ln18HGnmKxdkwMB8GA1UdIwQYMBaAFD9xPMh2lH691o/ln18H
GnmKxdkwMA8GA1UdEwEB/wQFMAMBAf8wEgYJKwYBBAGDsgMBAQH/BAIFADANBgkq
hkiG9w0BAQsFAAOCAQEANDajhAeLynPhIpjeh0FJf2lwTVap0yA903pGeOziuvdc
R3eTX6DF9lXyNsfdiIR9BL+oL0fhOh8LG85dqCANIKCkKqelcI6FBUjTbZziDXxi
Xxc68XHfNs+f8Z+LLTuBo7k8vPuOxPLxTmERi5+O2dLUINAjZrQML+uzAmK3KlfZ
Ge6qWNE6k35+ZQGQwor+VHwmwJjKLHaPaZHAwhQWJer/dDcadkxLGGJ4DDt95awL
ggpS/04jM5tUxlysCQqrTHxFIiiALFPy7+Md4DRLv+oinIpcRrT2SECVWCW583JI
gWAPCoAvOOT7qMWYuba6OUidaeR7T6sgIQtZ4x9Fnw==
-----END CERTIFICATE-----
@@ -0,0 +1,22 @@
-----BEGIN CERTIFICATE-----
MIIDjTCCAkGgAwIBAgIUZbovjhUmkSfk/CWcoqSraiFxygUwQQYJKoZIhvcNAQEK
MDSgDzANBglghkgBZQMEAgEFAKEcMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEF
AKIDAgEgMCMxITAfBgNVBAMMGEdQIFB1YmxpYyBwc3MgUmVncmVzc2lvbjAeFw0y
NjExMDcwMjA2MjZaFw0zNjExMDQwMjA2MjZaMCMxITAfBgNVBAMMGEdQIFB1Ymxp
YyBwc3MgUmVncmVzc2lvbjCCASAwCwYJKoZIhvcNAQEKA4IBDwAwggEKAoIBAQDr
NsIJvoquN4qj9OIcsw8Pu/jjZMUPFGXQeejNRh1oIA+Lo0aps9IgQm2iIHlrusdO
3DbXriMvrUXEmrp10FC7JCe34oY1SahpY4/EU5acQrcANwszkN+wRxGHNmZ4jYGQ
tRZGyQIDiejvztBAWsCjSp/VfqyfCoECe21/6cKl1qZRJSPgnXlZJrYfvJeyKMoa
/GYyE1oFQRvNN56TRkT4Z4ys5kN3tl7S4GI13LohIzlej3pQeAiU+4+addJ71c29
3UDfZfqu2p+qpcZ9y5k1dhVn/XAuiX4avQ40UYxtYMTo10h6oyU64GBfcJ05ljbb
UaX4XcC0udKPcWmH/Y2/AgMBAAGjUzBRMB0GA1UdDgQWBBSG4neJk61a5OKpTJwv
xTfMYWhzRTAfBgNVHSMEGDAWgBSG4neJk61a5OKpTJwvxTfMYWhzRTAPBgNVHRMB
Af8EBTADAQH/MEEGCSqGSIb3DQEBCjA0oA8wDQYJYIZIAWUDBAIBBQChHDAaBgkq
hkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIAOCAQEArry92CksVDObs8ekbHPQ
tz5BF8s7yI729Dy35oH/zFT/vWOtP9vMYRF83x+g5ZzNMjdBZDm2lzVLlHOjClbp
RKxMthR+Dy8jGu2+5f+GwaOWWvIlTGJB0qssH5pKWvt5PU1f2KGuPAp4aU+1VxwA
DJXbQn5ssQxS/L/9WsQGOzvDMuMkWKxIZ+Z1YsAvBNlhYlS8OMdfDVGl5MobomVl
WU5kwNZlIDoBk3J9EXXa40xbUULCCq3bEEfIu5Mo6VgzyE8Y/EAPjI2q23wH2Map
ReT5yhKyqX6BXfUGaN9jNv/t7j6h+gXEXx5WYXb5OX557csMWRCBiHjAQUoIh3FB
7Q==
-----END CERTIFICATE-----
@@ -0,0 +1,28 @@
-----BEGIN PRIVATE KEY-----
MIIEuwIBADALBgkqhkiG9w0BAQoEggSnMIIEowIBAAKCAQEA6zbCCb6KrjeKo/Ti
HLMPD7v442TFDxRl0HnozUYdaCAPi6NGqbPSIEJtoiB5a7rHTtw2164jL61FxJq6
ddBQuyQnt+KGNUmoaWOPxFOWnEK3ADcLM5DfsEcRhzZmeI2BkLUWRskCA4no787Q
QFrAo0qf1X6snwqBAnttf+nCpdamUSUj4J15WSa2H7yXsijKGvxmMhNaBUEbzTee
k0ZE+GeMrOZDd7Ze0uBiNdy6ISM5Xo96UHgIlPuPmnXSe9XNvd1A32X6rtqfqqXG
fcuZNXYVZ/1wLol+Gr0ONFGMbWDE6NdIeqMlOuBgX3CdOZY221Gl+F3AtLnSj3Fp
h/2NvwIDAQABAoIBACQNGFrU/RLXHs/4HytQmIeMAzRF2Ybw/z/1B3plpj6I4h5q
xVBfvYjwlYwqwmGBgb3eYSYtTGWo1E+I0E5xbNuaHt+qKnGCxiYiZUKCoKF3qkPa
q+6t5FMeOXC0z6o833XLWPbleoJfV2K2G1OEdWUxxri6zytwjoslBDNS+WC1xTj/
3IOj0hQwwTToiLkqrcyG1ymCj9RR+3CJ30/QVSmj9Gg+1/9Cws3/mc3en2hjVhSw
AwCEZUD2c+Uvc+DnfOtJNeJaDrwgmuZNNPUw/SEkTtsUY6SMbY5tgrkHzNhXl5Af
aqSznvhwykxvgw/PIowgZMA1pGynicX2ajYq+KECgYEA+5OfLmT4e1tXqTgiv7Ea
pOmPR2AaAsryZNpSf5CbmmxgVrNvLtmy5PNV7QvRtsIvmoCPHZkyHmLGPIIIMu8L
G2yyFyZWSCVVieanRrxJrRZlssbHRRcu9r9LFNi1S7SgkMKknaiWQIbQFVMx/rZQ
VTiPGu+sicoPefeCuvOtOKECgYEA71l8QLRApjOHShiWPzZFn9aD23txtsbcpHD+
pzW/yB+19gnUQA4VtIfQFvlUMmeRbu2LnIXhTqXEo4Zfkgq7o5ROtyrK/FOQ/qKr
N8C112O9vUS0ccpN31VaN66jWGPa61+a5awtEr78c153Z94Pl4iYmMFhshK79E2G
tEX3Sl8CgYBea6Bh1EmiWr0C6Ou50Gm0nWhGHJ6Gj8775Sjzcb3E7ooV4FCJX/GR
lnaYekgidK1TKo8MR9QUrXPDf/Y9z5P2ngwVPjFB8KkzEZuUo9RvHynaOFrP5oyc
1V0DnPYmTMu6qSMJfR2vaCmu50OrWpe59HlZXbz/FhRK7YdmTVClIQKBgCjFuaDc
E9c8F+PLZGzINfwQcs3ErY5ROezZQsgBI/ZXUIvlCL8QpynlqNEBEBK2CdQ3qvyy
4bqgCmtAzK74HRa0gOQ66fEp2x1FYJ1SuqdCWmQPfB2WNMXCqGer3C+Gcxh9ZMmT
FuqGlkKg6P5MmaNapYQADUBkaJgpTLUQ5htJAoGBAMpA9RbcSNPMe+POUxGb6pk3
mSV4ymmotWtyr0GqNa/FgujjZ68TWwvhrJFD0kQap3flM3/82ThJCk9HsJ9osjPM
mNEHccfgASpPVgpkvLUjtITUb7aO1cdjHK1gFknNQSy/jZyMClfhnwvXiqqgWqme
f9Ih4LSOdrek2teuI5Mo
-----END PRIVATE KEY-----