mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 06:26:14 -05:00
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
This commit is contained in:
1 parent
e03a758acb
commit
408536807c
55 files changed
+3288
-203
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,238 @@
|
||||
//! A PKCS#12 CA rollover must send the intermediate that signed the client.
|
||||
use gpapi::{
|
||||
gp_params::GpParams,
|
||||
os_profile::{ClientOs, HostIdentity, HostSnapshot, OsProfile},
|
||||
utils::request::ClientIdentity,
|
||||
};
|
||||
use openssl::{
|
||||
asn1::Asn1Time,
|
||||
bn::BigNum,
|
||||
ec::{EcGroup, EcKey},
|
||||
hash::MessageDigest,
|
||||
nid::Nid,
|
||||
pkey::{PKey, Private},
|
||||
ssl::{SslAcceptor, SslMethod, SslVerifyMode},
|
||||
stack::Stack,
|
||||
x509::{
|
||||
X509, X509NameBuilder,
|
||||
extension::{AuthorityKeyIdentifier, BasicConstraints, KeyUsage, SubjectKeyIdentifier},
|
||||
},
|
||||
};
|
||||
use std::{
|
||||
io::{Read, Write},
|
||||
net::TcpListener,
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
fn key() -> PKey<Private> {
|
||||
PKey::from_ec_key(EcKey::generate(&EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap()).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
fn certificate(
|
||||
name: &str,
|
||||
key: &PKey<Private>,
|
||||
issuer: Option<(&X509, &PKey<Private>)>,
|
||||
serial: u32,
|
||||
ca: bool,
|
||||
key_identifiers: bool,
|
||||
) -> X509 {
|
||||
let mut subject = X509NameBuilder::new().unwrap();
|
||||
subject.append_entry_by_text("CN", name).unwrap();
|
||||
let subject = subject.build();
|
||||
let mut cert = X509::builder().unwrap();
|
||||
cert.set_version(2).unwrap();
|
||||
cert
|
||||
.set_serial_number(&BigNum::from_u32(serial).unwrap().to_asn1_integer().unwrap())
|
||||
.unwrap();
|
||||
cert.set_subject_name(&subject).unwrap();
|
||||
cert
|
||||
.set_issuer_name(issuer.map(|(cert, _)| cert.subject_name()).unwrap_or(&subject))
|
||||
.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();
|
||||
let mut constraints = BasicConstraints::new();
|
||||
if ca {
|
||||
constraints.ca();
|
||||
}
|
||||
cert.append_extension(constraints.critical().build().unwrap()).unwrap();
|
||||
let mut usage = KeyUsage::new();
|
||||
if ca {
|
||||
usage.key_cert_sign();
|
||||
} else {
|
||||
usage.digital_signature();
|
||||
}
|
||||
cert.append_extension(usage.critical().build().unwrap()).unwrap();
|
||||
if key_identifiers {
|
||||
let identifier = SubjectKeyIdentifier::new()
|
||||
.build(&cert.x509v3_context(None, None))
|
||||
.unwrap();
|
||||
cert.append_extension(identifier).unwrap();
|
||||
if let Some((parent, _)) = issuer {
|
||||
let identifier = AuthorityKeyIdentifier::new()
|
||||
.keyid(true)
|
||||
.build(&cert.x509v3_context(Some(parent), None))
|
||||
.unwrap();
|
||||
cert.append_extension(identifier).unwrap();
|
||||
}
|
||||
}
|
||||
cert
|
||||
.sign(issuer.map(|(_, key)| key).unwrap_or(key), MessageDigest::sha256())
|
||||
.unwrap();
|
||||
cert.build()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pkcs12_ca_rollover_authenticates_in_both_bag_orders() {
|
||||
for self_issued in [false, true] {
|
||||
let root_key = key();
|
||||
// Ordinary rollover also works without AKI/SKI. The self-issued chain
|
||||
// needs key identifiers so the independent server distinguishes its root.
|
||||
let root = certificate("Root", &root_key, None, 1, true, self_issued);
|
||||
let issuer_name = if self_issued { "Root" } else { "Issuing CA" };
|
||||
let old_key = key();
|
||||
let old = certificate(issuer_name, &old_key, Some((&root, &root_key)), 2, true, self_issued);
|
||||
let current_key = key();
|
||||
let current = certificate(
|
||||
issuer_name,
|
||||
¤t_key,
|
||||
Some((&root, &root_key)),
|
||||
3,
|
||||
true,
|
||||
self_issued,
|
||||
);
|
||||
let client_key = key();
|
||||
let leaf = certificate(
|
||||
"Client",
|
||||
&client_key,
|
||||
Some((¤t, ¤t_key)),
|
||||
4,
|
||||
false,
|
||||
self_issued,
|
||||
);
|
||||
for old_first in [true, false] {
|
||||
let mut ca = Stack::new().unwrap();
|
||||
let intermediates = if old_first { [&old, ¤t] } else { [¤t, &old] };
|
||||
for cert in intermediates {
|
||||
ca.push(cert.clone()).unwrap();
|
||||
}
|
||||
ca.push(root.clone()).unwrap();
|
||||
authenticate(&root, ¤t, &leaf, &client_key, ca).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn authenticate(root: &X509, current: &X509, leaf: &X509, client_key: &PKey<Private>, ca: Stack<X509>) {
|
||||
let archive = openssl::pkcs12::Pkcs12::builder()
|
||||
.pkey(client_key)
|
||||
.cert(leaf)
|
||||
.ca(ca)
|
||||
.build2("test")
|
||||
.unwrap()
|
||||
.to_der()
|
||||
.unwrap();
|
||||
let identity = ClientIdentity::from_data(Zeroizing::new(archive.clone()), None, Some("test")).unwrap();
|
||||
assert_eq!(
|
||||
identity.certificate_data(),
|
||||
archive,
|
||||
"OpenConnect must retain the original archive"
|
||||
);
|
||||
let profile = OsProfile::builder(ClientOs::Linux).build(HostSnapshot {
|
||||
runtime_os: ClientOs::Linux,
|
||||
identity: HostIdentity::application("test".into(), "test".into()),
|
||||
os_version: "test".into(),
|
||||
software_version: "test".into(),
|
||||
});
|
||||
let params = GpParams::builder(profile)
|
||||
.client_identity(Some(identity))
|
||||
.ignore_tls_errors(true)
|
||||
.build();
|
||||
let client = reqwest::Client::try_from(¶ms).unwrap();
|
||||
let server_key = key();
|
||||
let mut server = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
|
||||
server
|
||||
.set_certificate(&certificate("Server", &server_key, None, 5, false, false))
|
||||
.unwrap();
|
||||
server.set_private_key(&server_key).unwrap();
|
||||
server.cert_store_mut().add_cert(root.clone()).unwrap();
|
||||
server.set_verify(SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
|
||||
let server = server.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 expected_leaf = leaf.to_der().unwrap();
|
||||
let expected_issuer = current.to_der().unwrap();
|
||||
let worker = thread::spawn(move || {
|
||||
let deadline = std::time::Instant::now() + Duration::from_secs(5);
|
||||
let socket = loop {
|
||||
match listener.accept() {
|
||||
Ok((socket, _)) => break socket,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock && std::time::Instant::now() < deadline => {
|
||||
thread::sleep(Duration::from_millis(5))
|
||||
}
|
||||
Err(error) => return Err(error.to_string()),
|
||||
}
|
||||
};
|
||||
socket.set_nonblocking(false).unwrap();
|
||||
socket.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
||||
socket.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
||||
let mut socket = server.accept(socket).map_err(|error| error.to_string())?;
|
||||
assert_eq!(
|
||||
socket.ssl().peer_certificate().unwrap().to_der().unwrap(),
|
||||
expected_leaf
|
||||
);
|
||||
assert!(
|
||||
socket
|
||||
.ssl()
|
||||
.peer_cert_chain()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|cert| cert.to_der().unwrap() == expected_issuer)
|
||||
);
|
||||
let mut request = [0; 4096];
|
||||
socket.read(&mut request).map_err(|error| error.to_string())?;
|
||||
socket
|
||||
.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())
|
||||
});
|
||||
let response = client.get(address).timeout(Duration::from_secs(5)).send().await;
|
||||
let server_result = worker.join().unwrap();
|
||||
assert!(server_result.is_ok(), "{server_result:?}; {response:?}");
|
||||
assert_eq!(response.unwrap().text().await.unwrap(), "ok");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pkcs12_pss_certificate_signature_parameters_authenticate() {
|
||||
let root = X509::from_pem(include_bytes!("files/client-identity/pss-chain-root.pem")).unwrap();
|
||||
let issuer = X509::from_pem(include_bytes!("files/client-identity/pss-chain-issuer.pem")).unwrap();
|
||||
let client_key = PKey::private_key_from_pem(include_bytes!("files/client-identity/rsa-pkcs8.pem")).unwrap();
|
||||
let wrong_key = PKey::from_rsa(openssl::rsa::Rsa::generate(2048).unwrap()).unwrap();
|
||||
let wrong_issuer = certificate("PSS Issuing CA", &wrong_key, None, 6, true, false);
|
||||
for certificate in [
|
||||
include_bytes!("files/client-identity/pss-chain-salt-20.pem").as_slice(),
|
||||
include_bytes!("files/client-identity/pss-chain-salt-32.pem").as_slice(),
|
||||
include_bytes!("files/client-identity/pss-chain-salt-48.pem").as_slice(),
|
||||
] {
|
||||
let leaf = X509::from_pem(certificate).unwrap();
|
||||
assert!(leaf.verify(&issuer.public_key().unwrap()).unwrap());
|
||||
for wrong_first in [true, false] {
|
||||
let mut ca = Stack::new().unwrap();
|
||||
let candidates = if wrong_first {
|
||||
[&wrong_issuer, &issuer]
|
||||
} else {
|
||||
[&issuer, &wrong_issuer]
|
||||
};
|
||||
for candidate in candidates {
|
||||
ca.push(candidate.clone()).unwrap();
|
||||
}
|
||||
ca.push(root.clone()).unwrap();
|
||||
authenticate(&root, &issuer, &leaf, &client_key, ca).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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(¶ms(identity.clone(), false)).unwrap();
|
||||
reqwest::Client::try_from(¶ms(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(¶ms).unwrap();
|
||||
params.prepare_client_identity().unwrap();
|
||||
drop(directory);
|
||||
reqwest::Client::try_from(¶ms).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(¶ms(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(¶ms(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(¶ms).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");
|
||||
}
|
||||
@@ -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,20 @@ 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 |
|
||||
| `pss-chain-{root,issuer}.pem`, `pss-chain-salt-{20,32,48}.pem` | RSA client certificates signed with RSA-PSS/SHA256 and different salt lengths; client key is `rsa-pkcs8.pem`. Regenerate with `generate-pss-chain.sh` |
|
||||
| `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 +61,41 @@ 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_chain.rs` checks mutual TLS with PKCS#12 CA rollover,
|
||||
including self-issued intermediates and both certificate bag orders. It also
|
||||
checks RSA-PSS certificate signatures with 20-, 32-, and 48-byte salts against
|
||||
a same-name, wrong-key issuer. The server must receive the original leaf and
|
||||
correct intermediate; OpenConnect must retain the original archive.
|
||||
|
||||
`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-----
|
||||
@@ -0,0 +1,24 @@
|
||||
#!/usr/bin/env bash
|
||||
# Public test certificates only; uses the existing public RSA client key.
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")"
|
||||
openssl_bin=${OPENSSL_BIN:-openssl}
|
||||
scratch=$(mktemp -d)
|
||||
trap 'rm -rf "$scratch"' EXIT
|
||||
"$openssl_bin" req -x509 -newkey rsa:2048 -noenc -sha256 -days 3650 \
|
||||
-subj '/CN=PSS Chain Root' -addext 'basicConstraints=critical,CA:TRUE' \
|
||||
-keyout "$scratch/root.key" -out pss-chain-root.pem
|
||||
"$openssl_bin" req -new -newkey rsa:2048 -noenc -subj '/CN=PSS Issuing CA' \
|
||||
-keyout "$scratch/issuer.key" -out "$scratch/issuer.csr"
|
||||
printf 'basicConstraints=critical,CA:TRUE\nkeyUsage=critical,keyCertSign\n' > "$scratch/ca.ext"
|
||||
"$openssl_bin" x509 -req -in "$scratch/issuer.csr" -CA pss-chain-root.pem \
|
||||
-CAkey "$scratch/root.key" -set_serial 2 -days 3650 -sha256 \
|
||||
-extfile "$scratch/ca.ext" -out pss-chain-issuer.pem
|
||||
"$openssl_bin" req -new -key rsa-pkcs8.pem -subj '/CN=PSS Signed Client' -out "$scratch/client.csr"
|
||||
printf 'basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature\nextendedKeyUsage=clientAuth\n' > "$scratch/client.ext"
|
||||
for salt_length in 20 32 48; do
|
||||
"$openssl_bin" x509 -req -in "$scratch/client.csr" -CA pss-chain-issuer.pem \
|
||||
-CAkey "$scratch/issuer.key" -set_serial "$salt_length" -days 3650 -sha256 \
|
||||
-sigopt rsa_padding_mode:pss -sigopt "rsa_pss_saltlen:$salt_length" \
|
||||
-extfile "$scratch/client.ext" -out "pss-chain-salt-$salt_length.pem"
|
||||
done
|
||||
@@ -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
|
||||
@@ -78,3 +99,4 @@ done
|
||||
|
||||
# Plain PKCS#12 bags let the import tests omit optional IDs and reorder bags.
|
||||
python3 "$(dirname "$0")/generate-plain-pfx.py"
|
||||
bash "$(dirname "$0")/generate-pss-chain.sh"
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,19 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDEDCCAfigAwIBAgIBAjANBgkqhkiG9w0BAQsFADAZMRcwFQYDVQQDDA5QU1Mg
|
||||
Q2hhaW4gUm9vdDAeFw0yNjExMDcwNTIxNTJaFw0zNjExMDQwNTIxNTJaMBkxFzAV
|
||||
BgNVBAMMDlBTUyBJc3N1aW5nIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
|
||||
CgKCAQEAkjFaot6TCYfvnmfxSGfpqd2X+633FdjuaJLFf+G/EAccA7SVwtyGAJuT
|
||||
/+RE3q0JO9I502mPRIWxkKOH0KU1dQK92iIup2lhc4WOtaGFvk+KGu3UrIQhgK8N
|
||||
h0bEkiPcO160M3MEBo3mZGC933n/q+ean1nHcxrh3vp6t4fAUmH8B46+ww2QgUR0
|
||||
nJorVh/gAmrzRmgRfRy3FKHRh9sZLrguJqlNOe8g3x/brmFV2dd4vl1iX84+Xxs3
|
||||
9WfyrYGH0Sy3HAUv7ur5z8j9eiPTdy3UvGpDoz815WKCJNkdTvbMlDJVu0+NokLa
|
||||
7q3z0CidYwVGqHlzKl6yXPp4J/ZbVwIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/
|
||||
MA4GA1UdDwEB/wQEAwICBDAdBgNVHQ4EFgQUjMoHVKzTYMWxwGZvjWzCuv2roqYw
|
||||
HwYDVR0jBBgwFoAUK0dvk5jU2/lvSQ4u3d0VdEQ1bTwwDQYJKoZIhvcNAQELBQAD
|
||||
ggEBABr/bCjbrX3JrF8S30glfEPOwXuYsJRCWuHn4+p89x0nwEU7+DpChepRwG6n
|
||||
rhsFRUz2ADrpJyw+4DaEHquGpEGirRx9QLEV9rDXAAyHK7/k1yy25pfj/CttzjXn
|
||||
M6WEZPR5jRcNNBH+B7Lb55uvGQHiuZg7abuNz+lE8iUwXOsfsbXqAU7RoWpvb59f
|
||||
jrDh925YPvKRIMGPqZjA9l5KzPxmBxyWZlSyTwRlZPVcAJXPRusfuCVko6kXcEJ1
|
||||
U86g8VjR03EknNSxYifXjbAlFGh2NBeJ1BeS12yTe9zlyZ1hijwC0jTlzF9fzI/K
|
||||
YgwNW6V0W51+Rn2L8EyHtl0IbyU=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,19 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDEzCCAfugAwIBAgIUbtOYPmJw0zjzONdDDXnD4PWLy+8wDQYJKoZIhvcNAQEL
|
||||
BQAwGTEXMBUGA1UEAwwOUFNTIENoYWluIFJvb3QwHhcNMjYxMTA3MDUyMTUxWhcN
|
||||
MzYxMTA0MDUyMTUxWjAZMRcwFQYDVQQDDA5QU1MgQ2hhaW4gUm9vdDCCASIwDQYJ
|
||||
KoZIhvcNAQEBBQADggEPADCCAQoCggEBANnZ/+l/MSDO3IlW57rCGg8WOSOQ1Kmy
|
||||
2QoMUGCSNNrYsfmriY0BkcyX4LHyvH2FqZUE4h6IfVnY1qEaKRQYw6Rljy9unGkW
|
||||
Z7a5c6N88KbZ3GgFUkn/BpFbf1FAd7AVfXwOrbUtpw43nxLmN6nXr3iYTme0aOuH
|
||||
rNTnxBUq7WEMKyZNwtuKJoYBllqNr6Pth+KVtFNvXyQfqOetTi1upwObsZYVewnU
|
||||
Hv5+XM9ZQ9S2pC8816B9DGm+ys0+f+mn+W9f6C+ffHhjV+aUMfgBFOIB9sl1oZNO
|
||||
td+WX5yT96/b7OTwOwP/Q6eKvK+QMDEbi2K2ULMqknlUfOfeLvKPCUECAwEAAaNT
|
||||
MFEwHQYDVR0OBBYEFCtHb5OY1Nv5b0kOLt3dFXRENW08MB8GA1UdIwQYMBaAFCtH
|
||||
b5OY1Nv5b0kOLt3dFXRENW08MA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
|
||||
BQADggEBALrN2Eu94nDxpbSp1AfYPVr5/9yUOMfA/NjUB3OZ4q5fyPoAiTmOFZ7C
|
||||
hIdnXfMZq6tKKUf1qO86HreiyHF4+JIewBPkR43uTRxRuuV37R9igbXDmYtvmUK0
|
||||
+8zgj4Y6IhXO7wqr6llIgK3LF9dkg7K1NhqvgWaGXB10YrjU5Ae1rVToN+9Yre8a
|
||||
4PsbaWGQR+kchcYd1WlJJO4afBf7ecGDujwBc0k/bHX8eFmhQ94ZIh/KyONsEI3C
|
||||
mmgEDeFCdWPCG+736IkrYA8SAAFqVMMQCvHDMpROUzbHFOQQIKKOUy0ErLKpwEYo
|
||||
4Xn5o6uX/eWZaLv5iOcNACugZ2JwW1g=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,21 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDgzCCAjygAwIBAgIBFDA8BgkqhkiG9w0BAQowL6APMA0GCWCGSAFlAwQCAQUA
|
||||
oRwwGgYJKoZIhvcNAQEIMA0GCWCGSAFlAwQCAQUAMBkxFzAVBgNVBAMMDlBTUyBJ
|
||||
c3N1aW5nIENBMB4XDTI2MTEwNzA1MjE1MloXDTM2MTEwNDA1MjE1MlowHDEaMBgG
|
||||
A1UEAwwRUFNTIFNpZ25lZCBDbGllbnQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
|
||||
ggEKAoIBAQDd1Qd/iKhTpVWOjhfwPTqlaj9Ac6CKubFr0fZsVgR8r1OSmRv16e2t
|
||||
jhfjjhOI0cz3S4Cqt9ZPLWIMGMugt9Y1YFHpg8gTsLrnYgRHBtA2eoBhLROLsj5x
|
||||
aiUBoAYPR1vLmPyHtPuvveRepaY59AEarptx6//jf6LJQAjxTNbiU5FQsGr4ixVG
|
||||
I29zsesFE0VbVSxKYdiMN+duVX7iPQSkMODWedcBEqQo17xAdvPgjtpN1AfXoDHW
|
||||
ns/kpfOb2z9W1o3GG89XxA1s/IBivmIb6Dy+p7CzhCFxHmOd8Wlt8/U5W9wkphHm
|
||||
HWbsF79XEBqyIoUx6Vo1kNsCezCSf9aHAgMBAAGjdTBzMAwGA1UdEwEB/wQCMAAw
|
||||
DgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMCMB0GA1UdDgQWBBQ/
|
||||
cTzIdpR+vdaP5Z9fBxp5isXZMDAfBgNVHSMEGDAWgBSMygdUrNNgxbHAZm+NbMK6
|
||||
/auipjA8BgkqhkiG9w0BAQowL6APMA0GCWCGSAFlAwQCAQUAoRwwGgYJKoZIhvcN
|
||||
AQEIMA0GCWCGSAFlAwQCAQUAA4IBAQAUOI4kd5ZvRevSo5kt6xoJBYmRw2jVwcqG
|
||||
rVoq21h1L3cqhqYSb9oCyGcrkWcUfXY5uPAemF9wyScbLgwyGudX6ngVdHWwRVvN
|
||||
dBZLRLDsviRAjN60NP06vrV/JzcQfFOL2L0tjGfYCfXdYD+0WZG8R1qtb2fHPh89
|
||||
II7O3dof2eR/GOot/JX6te7vYc3faWyNTC8SclB9tJrwAz8++tf0cuStHoLWd9jV
|
||||
Gq3mhKn1ZzdJsbwTQjledIXLG6eRE6XyLHzcB6VctAt6bhVLxH8Ck/oEfGwYY2wK
|
||||
tkwyNCnl35CCBRdbKxXfUJavoq8jwETZmSVnRUfWn2HUB6FDmtGm
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,22 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDjTCCAkGgAwIBAgIBIDBBBgkqhkiG9w0BAQowNKAPMA0GCWCGSAFlAwQCAQUA
|
||||
oRwwGgYJKoZIhvcNAQEIMA0GCWCGSAFlAwQCAQUAogMCASAwGTEXMBUGA1UEAwwO
|
||||
UFNTIElzc3VpbmcgQ0EwHhcNMjYxMTA3MDUyMTUyWhcNMzYxMTA0MDUyMTUyWjAc
|
||||
MRowGAYDVQQDDBFQU1MgU2lnbmVkIENsaWVudDCCASIwDQYJKoZIhvcNAQEBBQAD
|
||||
ggEPADCCAQoCggEBAN3VB3+IqFOlVY6OF/A9OqVqP0BzoIq5sWvR9mxWBHyvU5KZ
|
||||
G/Xp7a2OF+OOE4jRzPdLgKq31k8tYgwYy6C31jVgUemDyBOwuudiBEcG0DZ6gGEt
|
||||
E4uyPnFqJQGgBg9HW8uY/Ie0+6+95F6lpjn0ARqum3Hr/+N/oslACPFM1uJTkVCw
|
||||
aviLFUYjb3Ox6wUTRVtVLEph2Iw3525VfuI9BKQw4NZ51wESpCjXvEB28+CO2k3U
|
||||
B9egMdaez+Sl85vbP1bWjcYbz1fEDWz8gGK+YhvoPL6nsLOEIXEeY53xaW3z9Tlb
|
||||
3CSmEeYdZuwXv1cQGrIihTHpWjWQ2wJ7MJJ/1ocCAwEAAaN1MHMwDAYDVR0TAQH/
|
||||
BAIwADAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwIwHQYDVR0O
|
||||
BBYEFD9xPMh2lH691o/ln18HGnmKxdkwMB8GA1UdIwQYMBaAFIzKB1Ss02DFscBm
|
||||
b41swrr9q6KmMEEGCSqGSIb3DQEBCjA0oA8wDQYJYIZIAWUDBAIBBQChHDAaBgkq
|
||||
hkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIAOCAQEAHduUqnc8vvfsg8PrIRxD
|
||||
qOWW0wx6BdRSd23cx1V7OaT7JMU6gvWSiiFx+aOl+REPQNNxi9yTAUDL0vPewwa9
|
||||
UZSNUy0tYVXuhZ4QfoPMZNRV2d1JekoHXgWLk39JgD363TL504MEhDoeXtIAbj/d
|
||||
Ta+7aHGH6xMhwldUWMqiUkBpC4TUOsshZm92197/SRl9joTWB5G3RSREirG8LEn4
|
||||
HiTgd2AbiPXzAzA5MdIOeGWMKSF+Ey3R6Z2HzOzIrqAd3pFVPI6oHMSN6WzfHLVW
|
||||
GT8LM+eQyUXTQn7B67REH+/GsolCHBUEMjyABUtZoNIxa3KOXE7GN7SQDV93UPhT
|
||||
CQ==
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,22 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDjTCCAkGgAwIBAgIBMDBBBgkqhkiG9w0BAQowNKAPMA0GCWCGSAFlAwQCAQUA
|
||||
oRwwGgYJKoZIhvcNAQEIMA0GCWCGSAFlAwQCAQUAogMCATAwGTEXMBUGA1UEAwwO
|
||||
UFNTIElzc3VpbmcgQ0EwHhcNMjYxMTA3MDUyMTUyWhcNMzYxMTA0MDUyMTUyWjAc
|
||||
MRowGAYDVQQDDBFQU1MgU2lnbmVkIENsaWVudDCCASIwDQYJKoZIhvcNAQEBBQAD
|
||||
ggEPADCCAQoCggEBAN3VB3+IqFOlVY6OF/A9OqVqP0BzoIq5sWvR9mxWBHyvU5KZ
|
||||
G/Xp7a2OF+OOE4jRzPdLgKq31k8tYgwYy6C31jVgUemDyBOwuudiBEcG0DZ6gGEt
|
||||
E4uyPnFqJQGgBg9HW8uY/Ie0+6+95F6lpjn0ARqum3Hr/+N/oslACPFM1uJTkVCw
|
||||
aviLFUYjb3Ox6wUTRVtVLEph2Iw3525VfuI9BKQw4NZ51wESpCjXvEB28+CO2k3U
|
||||
B9egMdaez+Sl85vbP1bWjcYbz1fEDWz8gGK+YhvoPL6nsLOEIXEeY53xaW3z9Tlb
|
||||
3CSmEeYdZuwXv1cQGrIihTHpWjWQ2wJ7MJJ/1ocCAwEAAaN1MHMwDAYDVR0TAQH/
|
||||
BAIwADAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYIKwYBBQUHAwIwHQYDVR0O
|
||||
BBYEFD9xPMh2lH691o/ln18HGnmKxdkwMB8GA1UdIwQYMBaAFIzKB1Ss02DFscBm
|
||||
b41swrr9q6KmMEEGCSqGSIb3DQEBCjA0oA8wDQYJYIZIAWUDBAIBBQChHDAaBgkq
|
||||
hkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBMAOCAQEAfRbXy5n1jSsOiKKGppzq
|
||||
iRhrCJf51Le9aaf5cot/l1Q8GTFdYi8Ieu4CghsmGvfJIuRyig/aFfqXxpcFldDq
|
||||
Nm4uIKRyDwygLyDau+OUaNmz1UZ2Y6FzOfyb6ujy2pEhOXr1EnQnL82MvlvbN4DT
|
||||
9Dx4FgXAydtM6P6QfALvAEVy8/wjAYVCK5Xv/vKR5fFc2Rgl3DZkopcPF2pNQFN4
|
||||
E0P7GWxE+elRG952lacqHyhL4sIMoHF6AvDFUVwWoqttIfjX1272vt2yN1ej9F94
|
||||
BWyVm+sYf0fg767lsW2yFQS/1LbldjkHmxQn3qkrPhPni1zWhC5MJ6DxFLXGxkIr
|
||||
kw==
|
||||
-----END CERTIFICATE-----
|
||||
@@ -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-----
|
||||
Reference in new issue
Block a user