mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
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:
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(¶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,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
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -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