Preserve native TLS refusal evidence and qualify typed Windows error classification
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -0,0 +1,268 @@
|
||||
//! Explicit development TLS fixture only. No enrollment, service or job path.
|
||||
//! The fixture private key is generated and retained on this Windows guest.
|
||||
#[cfg(windows)]
|
||||
#[path = "../../agent/src/https_channel.rs"]
|
||||
pub mod https_channel;
|
||||
|
||||
#[cfg(any(windows, test))]
|
||||
mod tls_errors {
|
||||
use std::error::Error;
|
||||
pub(super) fn classify(error: &(dyn Error + 'static)) -> &'static str {
|
||||
let mut next = Some(error);
|
||||
for _ in 0..16 {
|
||||
let Some(current) = next else { break };
|
||||
if let Some(tls) = current.downcast_ref::<rustls::Error>() {
|
||||
return match tls {
|
||||
rustls::Error::AlertReceived(rustls::AlertDescription::CertificateExpired) => {
|
||||
"TLS_PEER_CERTIFICATE_EXPIRED"
|
||||
}
|
||||
rustls::Error::InvalidCertificate(rustls::CertificateError::UnknownIssuer) => {
|
||||
"TLS_UNKNOWN_ISSUER"
|
||||
}
|
||||
rustls::Error::InvalidCertificate(
|
||||
rustls::CertificateError::NotValidForName
|
||||
| rustls::CertificateError::NotValidForNameContext { .. },
|
||||
) => "TLS_SERVER_NAME_MISMATCH",
|
||||
rustls::Error::InvalidCertificate(_) => "TLS_OTHER_INVALID_CERTIFICATE",
|
||||
rustls::Error::AlertReceived(_) => "TLS_OTHER_PEER_ALERT",
|
||||
_ => "TLS_OTHER_ERROR",
|
||||
};
|
||||
}
|
||||
// io::Error::source skips its boxed payload itself. Inspect get_ref
|
||||
// first to preserve the concrete rustls::Error inside nested TLS I/O.
|
||||
next = current
|
||||
.downcast_ref::<std::io::Error>()
|
||||
.and_then(std::io::Error::get_ref)
|
||||
.map(|inner| inner as &(dyn Error + 'static))
|
||||
.or_else(|| current.source());
|
||||
}
|
||||
"UNCLASSIFIED_TRANSPORT_ERROR"
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn nested_io_preserves_typed_tls_and_rejects_untyped_failures() {
|
||||
use std::io::{Error as IoError, ErrorKind};
|
||||
let cases = [
|
||||
(
|
||||
rustls::Error::InvalidCertificate(rustls::CertificateError::UnknownIssuer),
|
||||
"TLS_UNKNOWN_ISSUER",
|
||||
),
|
||||
(
|
||||
rustls::Error::InvalidCertificate(rustls::CertificateError::NotValidForName),
|
||||
"TLS_SERVER_NAME_MISMATCH",
|
||||
),
|
||||
(
|
||||
rustls::Error::AlertReceived(rustls::AlertDescription::CertificateExpired),
|
||||
"TLS_PEER_CERTIFICATE_EXPIRED",
|
||||
),
|
||||
];
|
||||
for (error, expected) in cases {
|
||||
// Tokio-rustls wraps InvalidData; hyper-rustls wraps it again as Other.
|
||||
let nested = IoError::other(IoError::new(ErrorKind::InvalidData, error));
|
||||
assert_eq!(classify(&nested), expected);
|
||||
}
|
||||
for error in [
|
||||
IoError::from(ErrorKind::TimedOut),
|
||||
IoError::from(ErrorKind::ConnectionReset),
|
||||
IoError::other("certificate has expired: UnknownIssuer"),
|
||||
] {
|
||||
assert_eq!(classify(&error), "UNCLASSIFIED_TRANSPORT_ERROR");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod probe {
|
||||
use anyhow::{Result, ensure};
|
||||
use rcgen::{BasicConstraints, CertificateParams, DnType, IsCa, KeyPair};
|
||||
use serde_json::{Value, json};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{fs, io::Write, path::Path};
|
||||
use uuid::Uuid;
|
||||
|
||||
const ROOT: &str = r"C:\ProgramData\RustDiscoveryBootstrap\tls-negative";
|
||||
const SERVER: &str = "discovery.ease-technologies.de";
|
||||
|
||||
fn private_read(root: &Path, name: &str, maximum: usize) -> Result<Vec<u8>> {
|
||||
let path = root.join(name);
|
||||
rmm_agent_windows::native::private_path(&path, false)?;
|
||||
ensure!(
|
||||
fs::metadata(&path)?.len() <= maximum as u64,
|
||||
"FIXTURE_FILE_LIMIT"
|
||||
);
|
||||
Ok(fs::read(path)?)
|
||||
}
|
||||
fn create(root: &Path, name: &str, bytes: &[u8]) -> Result<()> {
|
||||
let mut file = fs::OpenOptions::new()
|
||||
.create_new(true)
|
||||
.write(true)
|
||||
.open(root.join(name))?;
|
||||
file.write_all(bytes)?;
|
||||
file.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
fn prepare(root: &Path, id: Uuid) -> Result<Value> {
|
||||
ensure!(
|
||||
fs::read_dir(root)?.next().is_none(),
|
||||
"FRESH_FIXTURE_DIRECTORY_REQUIRED"
|
||||
);
|
||||
let key = KeyPair::generate()?;
|
||||
let mut params = CertificateParams::default();
|
||||
params
|
||||
.distinguished_name
|
||||
.push(DnType::CommonName, id.to_string());
|
||||
let csr = params.serialize_request(&key)?.pem()?;
|
||||
ensure!(csr.len() < 8192, "FIXTURE_CSR_LIMIT");
|
||||
// Never emit or transfer the private key. Parent directory has already
|
||||
// been restricted to SYSTEM/Administrators by the bootstrap wrapper.
|
||||
create(root, "fixture.key", key.serialize_pem().as_bytes())?;
|
||||
create(root, "fixture.csr", csr.as_bytes())?;
|
||||
let mut wrong = CertificateParams::default();
|
||||
wrong.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
|
||||
wrong
|
||||
.distinguished_name
|
||||
.push(DnType::CommonName, "RMM unrelated fixture CA");
|
||||
let wrong_key = KeyPair::generate()?;
|
||||
create(
|
||||
root,
|
||||
"wrong-ca.pem",
|
||||
wrong.self_signed(&wrong_key)?.pem().as_bytes(),
|
||||
)?;
|
||||
create(
|
||||
root,
|
||||
"case.json",
|
||||
&serde_json::to_vec(&json!({"schema_version":1,"case_id":id}))?,
|
||||
)?;
|
||||
Ok(
|
||||
json!({"prepared":true,"case_id":id,"csr_pem":csr,"csr_sha256":format!("{:x}",Sha256::digest(csr.as_bytes())),
|
||||
"private_key_exported":false,"enrollment_created":false,"jobs_created":false}),
|
||||
)
|
||||
}
|
||||
async fn request(root: &Path, id: Uuid, kind: &str) -> Result<Value> {
|
||||
let marker: Value = serde_json::from_slice(&private_read(root, "case.json", 1024)?)?;
|
||||
ensure!(
|
||||
marker == json!({"schema_version":1,"case_id":id}),
|
||||
"FIXTURE_ID_BINDING"
|
||||
);
|
||||
let ca = private_read(
|
||||
root,
|
||||
if kind == "wrong-ca" {
|
||||
"wrong-ca.pem"
|
||||
} else {
|
||||
"issuer-ca.pem"
|
||||
},
|
||||
32768,
|
||||
)?;
|
||||
let certificate = private_read(
|
||||
root,
|
||||
if kind == "expired" {
|
||||
"expired.pem"
|
||||
} else {
|
||||
"valid.pem"
|
||||
},
|
||||
32768,
|
||||
)?;
|
||||
let key = private_read(root, "fixture.key", 16384)?;
|
||||
let address = "88.99.80.202:443".parse()?;
|
||||
// Exactly the production transport builder: configured CA only,
|
||||
// verified DNS/SNI, mTLS, no proxy trust, redirects or invalid-cert mode.
|
||||
let client = crate::https_channel::mtls_client(address, &ca, &certificate, &key)?;
|
||||
let name = crate::https_channel::server_name()?;
|
||||
let result = client
|
||||
.post(format!("https://{name}:443/agent/v1/messages"))
|
||||
.header(reqwest::header::CONTENT_TYPE, "application/x-protobuf")
|
||||
.body(Vec::new())
|
||||
.send()
|
||||
.await;
|
||||
let (status, code) = match result {
|
||||
Ok(response) => (Some(response.status().as_u16()), "HTTP_RESPONSE"),
|
||||
Err(error) if error.is_timeout() => (None, "TRANSPORT_TIMEOUT"),
|
||||
Err(error) => (None, super::tls_errors::classify(&error)),
|
||||
};
|
||||
let expected = match kind {
|
||||
"valid" => status == Some(401),
|
||||
"expired" => status.is_none() && code == "TLS_PEER_CERTIFICATE_EXPIRED",
|
||||
"wrong-ca" => status.is_none() && code == "TLS_UNKNOWN_ISSUER",
|
||||
"wrong-name" => status.is_none() && code == "TLS_SERVER_NAME_MISMATCH",
|
||||
_ => false,
|
||||
};
|
||||
Ok(
|
||||
json!({"case_id":id,"kind":kind,"verified":expected,"http_status":status,"code":code,
|
||||
"native_windows":true,"execution_context":"bootstrap_administrator_tls_probe",
|
||||
"shared_https_client":true,"certificate_verification_disabled":false,"clock_adjusted":false,
|
||||
"private_key_exported":false,"enrollment_created":false,"jobs_created":false}),
|
||||
)
|
||||
}
|
||||
pub fn run() -> Result<Value> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
ensure!(
|
||||
(args.len() == 2 && args[0] == "prepare") || (args.len() == 3 && args[0] == "probe"),
|
||||
"FIXED_PROBE_ARGUMENTS"
|
||||
);
|
||||
let id = Uuid::parse_str(&args[1])?;
|
||||
ensure!(
|
||||
!id.is_nil() && id.to_string() == args[1],
|
||||
"CANONICAL_FIXTURE_UUID"
|
||||
);
|
||||
let root = Path::new(ROOT).join(id.to_string());
|
||||
rmm_agent_windows::native::private_path(Path::new(ROOT), true)?;
|
||||
rmm_agent_windows::native::private_path(&root, true)?;
|
||||
if args[0] == "prepare" {
|
||||
return prepare(&root, id);
|
||||
}
|
||||
let kind = args[2].as_str();
|
||||
ensure!(
|
||||
matches!(kind, "valid" | "expired" | "wrong-ca" | "wrong-name"),
|
||||
"FIXED_PROBE_KIND"
|
||||
);
|
||||
// SAFETY: one freshly launched process per kind, before constructing
|
||||
// Tokio or any worker threads. No environment mutation during a runtime.
|
||||
unsafe {
|
||||
std::env::set_var(
|
||||
"RMM_SERVER_NAME",
|
||||
if kind == "wrong-name" {
|
||||
"wrong-name.invalid"
|
||||
} else {
|
||||
SERVER
|
||||
},
|
||||
);
|
||||
}
|
||||
let runtime = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()?;
|
||||
runtime.block_on(request(&root, id, kind))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn main() {
|
||||
match probe::run() {
|
||||
Ok(value) => {
|
||||
let accepted = value
|
||||
.get("prepared")
|
||||
.and_then(serde_json::Value::as_bool)
|
||||
.unwrap_or(false)
|
||||
|| value
|
||||
.get("verified")
|
||||
.and_then(serde_json::Value::as_bool)
|
||||
.unwrap_or(false);
|
||||
println!("{value}");
|
||||
if !accepted {
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::json!({"verified":false,"code":"WINDOWS_TLS_FIXTURE_INCOMPLETE"})
|
||||
);
|
||||
std::process::exit(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
fn main() {
|
||||
eprintln!("Windows TLS fixture probe requires native Windows");
|
||||
std::process::exit(1);
|
||||
}
|
||||
Reference in New Issue
Block a user