Files
rust-discovery/crates/agent-windows/examples/windows_certificate_acceptance.rs
T
kevin_janssen b3fe35b86b
Rust development slice / linux (push) Failing after 8s
Show available RAM and measured CPU usage for devices
2026-11-18 18:37:18 +01:00

475 lines
18 KiB
Rust

//! Explicit passive-certificate qualification on a separate fixture identity.
//! Run only as a child of the existing LocalService agent, after WebUI approval.
//! No original agent state, certificate, service configuration or key is read.
#[cfg(windows)]
mod native {
use anyhow::{Context, Result, ensure};
use chrono::Utc;
use prost::Message;
use rcgen::{CertificateParams, DnType, KeyPair};
use rmm_agent_windows::{
certificate_rotation::{DeviceIdentity, ProtectedKeyFiles, RotationStore},
journal::Journal,
native,
};
use rmm_protocol::{
ClientHello, EnrollmentRequest, EnrollmentResponse, Envelope, Heartbeat, MessageBatch,
Payload,
};
use serde_json::{Value, json};
use sha2::{Digest, Sha256};
use std::{fs, io::Write, net::SocketAddr, path::Path, time::Duration};
use uuid::Uuid;
const SERVER: &str = "discovery.ease-technologies.de";
const PERMANENT_AGENT: &str = "63ea15b2-0643-403d-b5b4-cba1288dbea3";
fn hash(bytes: &[u8]) -> String {
format!("{:x}", Sha256::digest(bytes))
}
fn read(path: &Path, maximum: usize) -> Result<Vec<u8>> {
native::private_path(path, false)?;
ensure!(
fs::metadata(path)?.len() <= maximum as u64,
"FIXTURE_FILE_LIMIT"
);
Ok(fs::read(path)?)
}
fn create(path: &Path, bytes: &[u8]) -> Result<()> {
let mut file = fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(path)?;
// The fixture directory must provide its inherited service DACL before
// any private bytes are written, exactly like ProtectedKeyFiles.
native::private_path(path, false)?;
file.write_all(bytes)?;
file.sync_all()?;
Ok(())
}
fn client(ca: &[u8], identity: Option<&DeviceIdentity>) -> Result<reqwest::Client> {
let address: SocketAddr = "88.99.80.202:443".parse()?;
let mut builder = reqwest::Client::builder()
.https_only(true)
.tls_built_in_root_certs(false)
.add_root_certificate(reqwest::Certificate::from_pem(ca)?)
.resolve(SERVER, address)
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.timeout(Duration::from_secs(10));
if let Some(identity) = identity {
let mut pair = identity.certificate_pem.clone();
pair.extend_from_slice(&identity.private_key_pem);
builder = builder.identity(reqwest::Identity::from_pem(&pair)?);
}
Ok(builder.build()?)
}
async fn body(mut response: reqwest::Response, content_type: &str) -> Result<Vec<u8>> {
ensure!(response.status().as_u16() == 200, "FIXTURE_HTTP_STATUS");
ensure!(
response
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|v| v.to_str().ok())
== Some(content_type),
"FIXTURE_CONTENT_TYPE"
);
let mut result = Vec::new();
while let Some(chunk) = response.chunk().await? {
ensure!(
result.len().saturating_add(chunk.len()) <= 65536,
"FIXTURE_RESPONSE_LIMIT"
);
result.extend_from_slice(&chunk);
}
Ok(result)
}
fn certificate_hash(pem: &[u8]) -> Result<String> {
let mut cursor = std::io::Cursor::new(pem);
let mut certificates = rustls_pemfile::certs(&mut cursor);
Ok(hash(
certificates
.next()
.context("FIXTURE_CERTIFICATE")??
.as_ref(),
))
}
fn envelope(
journal: &mut Journal,
agent: &str,
boot: &str,
generation: u64,
payload: Payload,
) -> Result<Envelope> {
Ok(Envelope {
protocol_major: 1,
protocol_minor: 0,
message_id: Uuid::new_v4().to_string(),
agent_id: agent.into(),
enrollment_generation: 1,
connection_generation: generation,
boot_id: boot.into(),
sequence: journal.next_sequence()?,
observed_at: Utc::now().timestamp_millis(),
payload: Some(payload),
})
}
async fn send(client: &reqwest::Client, envelope: &Envelope) -> Result<Envelope> {
let bytes = body(
client
.post(format!("https://{SERVER}/agent/v1/messages"))
.header(reqwest::header::CONTENT_TYPE, "application/x-protobuf")
.body(
MessageBatch {
protocol_major: 1,
messages: vec![envelope.clone()],
}
.encode_to_vec(),
)
.send()
.await?,
"application/x-protobuf",
)
.await?;
let replies = MessageBatch::decode(bytes.as_slice())?;
ensure!(
replies.protocol_major == 1 && replies.messages.len() == 1,
"FIXTURE_EXACT_REPLY"
);
let reply = replies
.messages
.into_iter()
.next()
.context("FIXTURE_REPLY")?;
ensure!(
reply.protocol_major == 1
&& reply.protocol_minor == 0
&& reply.agent_id == envelope.agent_id
&& reply.enrollment_generation == 1
&& reply.boot_id == envelope.boot_id
&& reply.sequence == envelope.sequence,
"FIXTURE_REPLY_BINDING"
);
Ok(reply)
}
async fn connect(
client: &reqwest::Client,
journal: &mut Journal,
agent: &str,
boot: &str,
) -> Result<u64> {
let hello = envelope(
journal,
agent,
boot,
0,
Payload::ClientHello(ClientHello {
agent_version: "certificate-acceptance/1".into(),
capabilities: vec!["heartbeat/1".into()],
}),
)?;
let reply = send(client, &hello).await?;
let Some(Payload::ServerHello(server)) = reply.payload else {
anyhow::bail!("FIXTURE_HELLO_REQUIRED")
};
ensure!(
server.connection_generation > 0
&& reply.connection_generation == server.connection_generation,
"FIXTURE_GENERATION"
);
let heartbeat = envelope(
journal,
agent,
boot,
server.connection_generation,
Payload::Heartbeat(Heartbeat {
instance_id: Uuid::new_v4().to_string(),
uptime_seconds: 1,
system_usage: None,
}),
)?;
let acknowledgement = send(client, &heartbeat).await?;
ensure!(
matches!(acknowledgement.payload, Some(Payload::Ack(ref a)) if a.message_id == heartbeat.message_id),
"FIXTURE_HEARTBEAT_ACK"
);
ensure!(
acknowledgement.connection_generation == server.connection_generation,
"FIXTURE_ACK_GENERATION"
);
Ok(server.connection_generation)
}
async fn renew(root: &Path, phase: &mut &'static str) -> Result<Value> {
*phase = "enrollment";
create(
&root.join("started.json"),
b"{\"schema_version\":1,\"no_restart\":true}",
)?;
let ca = read(&root.join("ca.pem"), 32768)?;
let key = KeyPair::generate()?;
create(&root.join("device.key"), key.serialize_pem().as_bytes())?;
let mut parameters = CertificateParams::default();
parameters
.distinguished_name
.push(DnType::CommonName, "certificate-acceptance");
let csr = parameters.serialize_request(&key)?.pem()?;
let token = String::from_utf8(read(&root.join("enrollment-token"), 128)?)?
.trim()
.to_owned();
ensure!(
token.len() == 64 && token.bytes().all(|b| b.is_ascii_hexdigit()),
"FIXTURE_ENROLLMENT_TOKEN"
);
let enrolled: EnrollmentResponse = serde_json::from_slice(
&body(
client(&ca, None)?
.post(format!("https://{SERVER}/agent/v1/enroll"))
.json(&EnrollmentRequest {
token,
csr_pem: csr,
})
.send()
.await?,
"application/json",
)
.await?,
)?;
let agent = Uuid::parse_str(&enrolled.agent_id)?;
ensure!(
!agent.is_nil()
&& enrolled.agent_id != PERMANENT_AGENT
&& !Uuid::parse_str(&enrolled.asset_id)?.is_nil(),
"SEPARATE_FIXTURE_IDENTITY"
);
create(
&root.join("device.pem"),
enrolled.certificate_pem.as_bytes(),
)?;
create(&root.join("identity.json"), &serde_json::to_vec(&enrolled)?)?;
fs::remove_file(root.join("enrollment-token"))?;
let original_key_hash = hash(&read(&root.join("device.key"), 16384)?);
let original_certificate_hash = certificate_hash(enrolled.certificate_pem.as_bytes())?;
let store = RotationStore::new(agent, 1, ca.clone())?;
let mut journal = Journal::open(root)?;
journal.pin_identity(&enrolled.agent_id)?;
let keys = ProtectedKeyFiles::open(root)?;
store.initialize(
journal.connection_mut(),
&keys,
enrolled.certificate_pem.as_bytes(),
Utc::now().timestamp(),
)?;
ensure!(
!store.due(journal.connection(), &keys, Utc::now().timestamp())?,
"FRESH_CERTIFICATE_NOT_DUE"
);
let original = store.current(journal.connection(), &keys, Utc::now().timestamp())?;
let old_client = client(&ca, Some(&original))?;
let boot = native::boot_id().await?;
let original_generation =
connect(&old_client, &mut journal, &enrolled.agent_id, &boot).await?;
*phase = "renewal_response_discard";
let pending = store.prepare(journal.connection_mut(), &keys, Utc::now().timestamp())?;
let csr_hash = hash(pending.csr_pem.as_bytes());
let first = body(
old_client
.post(format!("https://{SERVER}/agent/v1/certificates/renew"))
.json(&json!({"csr_pem":pending.csr_pem}))
.send()
.await?,
"application/json",
)
.await?;
let first_hash = hash(&first);
// Deliberately do not install the first real server response. Close the
// actual SQLite/key handles; a reopened journal must reuse the CSR.
drop(pending);
drop(first);
drop(keys);
drop(journal);
*phase = "renewal_reopen";
let mut journal = Journal::open(root)?;
let keys = ProtectedKeyFiles::open(root)?;
let pending = store.prepare(journal.connection_mut(), &keys, Utc::now().timestamp())?;
ensure!(
hash(pending.csr_pem.as_bytes()) == csr_hash,
"EXACT_PENDING_CSR_AFTER_REOPEN"
);
let second = body(
client(&ca, Some(&pending.identity))?
.post(format!("https://{SERVER}/agent/v1/certificates/renew"))
.json(&json!({"csr_pem":pending.csr_pem}))
.send()
.await?,
"application/json",
)
.await?;
ensure!(
hash(&second) == first_hash,
"EXACT_IDEMPOTENT_SERVER_RESPONSE"
);
store.install(
journal.connection_mut(),
&keys,
&pending,
&second,
Utc::now().timestamp(),
)?;
ensure!(
!store.has_pending(journal.connection())?,
"RENEWAL_COMMIT_PENDING"
);
drop(pending);
drop(keys);
drop(journal);
*phase = "new_certificate_connection";
let mut journal = Journal::open(root)?;
let keys = ProtectedKeyFiles::open(root)?;
let current = store.current(journal.connection(), &keys, Utc::now().timestamp())?;
let renewed_hash = certificate_hash(&current.certificate_pem)?;
ensure!(
renewed_hash != original_certificate_hash,
"NEW_CERTIFICATE_REQUIRED"
);
let renewed_generation = connect(
&client(&ca, Some(&current))?,
&mut journal,
&enrolled.agent_id,
&boot,
)
.await?;
ensure!(
renewed_generation > original_generation,
"RENEWAL_RECONNECTED_GENERATION"
);
ensure!(
hash(&read(&root.join("device.key"), 16384)?) == original_key_hash
&& certificate_hash(&read(&root.join("device.pem"), 32768)?)?
== original_certificate_hash,
"ORIGINAL_FIXTURE_FILES_PRESERVED"
);
Ok(
json!({"schema_version":1,"verified":true,"identity_scope":"separate_fixture","agent_id":agent,
"asset_id":enrolled.asset_id,"boot_id":boot,"execution_sid":"S-1-5-19","service_sid":native::service_sid()?,
"original_certificate_sha256":original_certificate_hash,"renewed_certificate_sha256":renewed_hash,
"csr_sha256":csr_hash,"response_sha256":first_hash,"same_csr_after_reopen":true,
"same_server_response":true,"new_certificate_mtls_hello_and_heartbeat":true,
"original_generation":original_generation,"renewed_generation":renewed_generation,
"original_fixture_files_preserved":true,"permanent_identity_read":false,
"scheduler_age_trigger_tested":false,"jobs_created":false,"completed_at":Utc::now()}),
)
}
async fn revoked_read(root: &Path, phase: &mut &'static str) -> Result<Value> {
*phase = "revoked_identity_denial";
let before: Value =
serde_json::from_slice(&read(&root.join("renewal-result.json"), 16384)?)?;
ensure!(before["verified"] == true, "PRIOR_RENEWAL_REQUIRED");
let enrolled: EnrollmentResponse =
serde_json::from_slice(&read(&root.join("identity.json"), 32768)?)?;
ensure!(
enrolled.agent_id != PERMANENT_AGENT && before["agent_id"] == enrolled.agent_id,
"SAME_SEPARATE_FIXTURE"
);
let ca = read(&root.join("ca.pem"), 32768)?;
let store = RotationStore::new(Uuid::parse_str(&enrolled.agent_id)?, 1, ca.clone())?;
let mut journal = Journal::open(root)?;
let keys = ProtectedKeyFiles::open(root)?;
let identity = store.current(journal.connection(), &keys, Utc::now().timestamp())?;
ensure!(
before["renewed_certificate_sha256"] == certificate_hash(&identity.certificate_pem)?,
"SAME_RENEWED_CERTIFICATE"
);
let hello = envelope(
&mut journal,
&enrolled.agent_id,
&native::boot_id().await?,
0,
Payload::ClientHello(ClientHello {
agent_version: "certificate-acceptance/1".into(),
capabilities: vec!["heartbeat/1".into()],
}),
)?;
let response = client(&ca, Some(&identity))?
.post(format!("https://{SERVER}/agent/v1/messages"))
.header(reqwest::header::CONTENT_TYPE, "application/x-protobuf")
.body(
MessageBatch {
protocol_major: 1,
messages: vec![hello],
}
.encode_to_vec(),
)
.send()
.await?;
// A TLS or network failure is not accepted as proof of revocation.
ensure!(
response.status().as_u16() == 401,
"EXACT_AUTHENTICATED_REVOCATION_DENIAL"
);
Ok(
json!({"schema_version":1,"verified":true,"agent_id":enrolled.agent_id,
"execution_sid":"S-1-5-19","http_status":401,"permanent_identity_read":false,
"jobs_created":false,"completed_at":Utc::now()}),
)
}
pub fn main() -> Result<()> {
native::require_local_service()?;
let arguments: Vec<_> = std::env::args().skip(1).collect();
ensure!(arguments.len() == 2, "FIXTURE_ARGUMENTS");
let id = Uuid::parse_str(&arguments[1])?;
ensure!(
!id.is_nil() && id.to_string() == arguments[1],
"FIXTURE_CASE_UUID"
);
let root = std::path::PathBuf::from(r"C:\ProgramData\RustDiscovery\certificate-acceptance")
.join(id.to_string());
native::private_path(&root, true)?;
let report = match arguments[0].as_str() {
"renew" => root.join("renewal-result.json"),
"revoked-read" => root.join("revocation-result.json"),
_ => anyhow::bail!("FIXTURE_MODE"),
};
ensure!(!report.try_exists()?, "FIXTURE_REPORT_ALREADY_PRESENT");
let mut phase = "initialization";
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()?;
let result = runtime.block_on(async {
if arguments[0] == "renew" {
renew(&root, &mut phase).await
} else {
revoked_read(&root, &mut phase).await
}
});
match result {
Ok(value) => {
create(&report, &serde_json::to_vec(&value)?)?;
println!("{}", serde_json::to_string(&value)?);
Ok(())
}
Err(_) => {
// No network/library error text, credential or private key goes
// into the approved job's output or its public receipt.
let failure = json!({"schema_version":1,"verified":false,"phase":phase,
"error_code":"CERTIFICATE_ACCEPTANCE_FAILED","restart_allowed":false});
create(&report, &serde_json::to_vec(&failure)?)?;
println!("{}", serde_json::to_string(&failure)?);
anyhow::bail!("CERTIFICATE_ACCEPTANCE_FAILED")
}
}
}
}
#[cfg(windows)]
fn main() {
if native::main().is_err() {
eprintln!("CERTIFICATE_ACCEPTANCE_FAILED");
std::process::exit(1);
}
}
#[cfg(not(windows))]
fn main() {
eprintln!("Native Windows LocalService fixture only");
std::process::exit(1);
}