From 0b1f58299856dda2955941ea7408ee5afe2965ea Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 13:54:59 +0100 Subject: [PATCH] Add crash-safe passive Windows certificate renewal --- Cargo.lock | 1 + crates/agent-windows/Cargo.toml | 1 + .../agent-windows/src/certificate_rotation.rs | 704 ++++++++++++++++++ crates/agent-windows/src/lib.rs | 1 + crates/agent-windows/src/main.rs | 7 +- crates/agent-windows/src/runtime.rs | 97 ++- deploy/windows/CLIENT.md | 5 + docs/implementation-status.md | 17 + docs/windows-certificate-renewal.md | 101 +++ 9 files changed, 914 insertions(+), 20 deletions(-) create mode 100644 crates/agent-windows/src/certificate_rotation.rs create mode 100644 docs/windows-certificate-renewal.md diff --git a/Cargo.lock b/Cargo.lock index cb16efc..153f830 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2263,6 +2263,7 @@ dependencies = [ "tokio-tungstenite 0.28.0", "uuid", "windows-sys 0.61.2", + "x509-parser", ] [[package]] diff --git a/crates/agent-windows/Cargo.toml b/crates/agent-windows/Cargo.toml index 3b0804c..e81105f 100644 --- a/crates/agent-windows/Cargo.toml +++ b/crates/agent-windows/Cargo.toml @@ -34,6 +34,7 @@ rmm-protocol = { path = "../protocol" } rmm-time-attestation = { path = "../time-attestation" } rusqlite = { version = "0.32.1", features = ["bundled"] } fs2 = "0.4.3" +x509-parser = { version = "=0.18.1", features = ["verify"] } rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", "ring", "pem"] } [build-dependencies] diff --git a/crates/agent-windows/src/certificate_rotation.rs b/crates/agent-windows/src/certificate_rotation.rs new file mode 100644 index 0000000..45deb15 --- /dev/null +++ b/crates/agent-windows/src/certificate_rotation.rs @@ -0,0 +1,704 @@ +//! Passive TLS renewal. SQLite commits only public CSR/certificate/version data; +//! private keys stay in immutable, protected files outside the telemetry WAL. +//! The caller must retain the existing exclusive agent-state journal lock. +use anyhow::{Context, Result, ensure}; +use rcgen::{CertificateParams, DnType, KeyPair}; +use rusqlite::{Connection, params}; +use rustls::{RootCertStore, pki_types::UnixTime, sign::CertifiedKey}; +use serde::Deserialize; +use std::{io::Cursor, sync::Arc, time::Duration}; +use uuid::Uuid; +use x509_parser::prelude::*; + +pub struct DeviceIdentity { + pub certificate_pem: Vec, + pub private_key_pem: Vec, +} +/// Never supplies private bytes to the SQLite writer. +pub trait KeyFiles { + fn read(&self, version: Uuid) -> Result>; + /// CreateNew, protected before writing, and durable before returning. + fn create(&self, version: Uuid, key: &[u8]) -> Result<()>; +} +pub struct RotationStore { + agent: Uuid, + enrollment: u64, + ca: Vec, +} +pub struct PendingRequest { + pub identity: DeviceIdentity, + pub csr_pem: String, + base: Uuid, + version: Uuid, +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RenewalResponse { + agent_id: Uuid, + certificate_pem: String, + overlap_seconds: u32, +} +impl RotationStore { + pub fn new(agent: Uuid, enrollment: u64, ca: Vec) -> Result { + ensure!( + !agent.is_nil() && enrollment > 0, + "ROTATION_IDENTITY_INVALID" + ); + Ok(Self { + agent, + enrollment, + ca, + }) + } + /// Called under the journal lock. Legacy files are eligible exactly once, + /// before any selector exists. There is no recovery fallback or reenrollment. + pub fn initialize( + &self, + db: &mut Connection, + keys: &impl KeyFiles, + cert: &[u8], + now: i64, + ) -> Result<()> { + let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; + tx.execute_batch("CREATE TABLE IF NOT EXISTS tls_versions(version TEXT PRIMARY KEY,certificate BLOB,csr TEXT); + CREATE TABLE IF NOT EXISTS tls_rotation(id INTEGER PRIMARY KEY CHECK(id=1),schema_version INTEGER NOT NULL,agent TEXT NOT NULL,enrollment INTEGER NOT NULL,current_version TEXT NOT NULL REFERENCES tls_versions(version),pending_version TEXT REFERENCES tls_versions(version));")?; + let present: bool = tx.query_row("SELECT EXISTS(SELECT 1 FROM tls_rotation)", [], |r| { + r.get(0) + })?; + if !present { + let count: u64 = tx.query_row("SELECT count(*) FROM tls_versions", [], |r| r.get(0))?; + ensure!(count == 0, "ROTATION_SELECTOR_MISSING"); + self.verify(cert, &keys.read(Uuid::nil())?, now)?; + tx.execute( + "INSERT INTO tls_versions VALUES(?1,?2,NULL)", + params![Uuid::nil().to_string(), cert], + )?; + tx.execute( + "INSERT INTO tls_rotation VALUES(1,1,?1,?2,?3,NULL)", + params![ + self.agent.to_string(), + self.enrollment, + Uuid::nil().to_string() + ], + )?; + } + self.current(&tx, keys, now)?; + tx.commit()?; + Ok(()) + } + fn selector(&self, db: &Connection) -> Result<(Uuid, Option)> { + let (schema, agent, enrollment, current, pending): (u32,String,u64,String,Option) = db.query_row("SELECT schema_version,agent,enrollment,current_version,pending_version FROM tls_rotation WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?)))?; + ensure!( + schema == 1 && agent == self.agent.to_string() && enrollment == self.enrollment, + "ROTATION_IDENTITY_CHANGED" + ); + Ok(( + Uuid::parse_str(¤t)?, + pending.map(|s| Uuid::parse_str(&s)).transpose()?, + )) + } + pub fn current( + &self, + db: &Connection, + keys: &impl KeyFiles, + now: i64, + ) -> Result { + let (version, _) = self.selector(db)?; + let cert: Vec = db.query_row( + "SELECT certificate FROM tls_versions WHERE version=?1", + [version.to_string()], + |r| r.get(0), + )?; + let key = keys.read(version)?; + self.verify(&cert, &key, now)?; + Ok(DeviceIdentity { + certificate_pem: cert, + private_key_pem: key, + }) + } + fn verify(&self, pem: &[u8], key: &[u8], now: i64) -> Result<(i64, i64)> { + ensure!( + pem.len() <= 32768 && key.len() <= 16384, + "ROTATION_IDENTITY_LIMIT" + ); + let chain = + rustls_pemfile::certs(&mut Cursor::new(pem)).collect::>>()?; + let leaf = chain.first().context("ROTATION_CERTIFICATE_MISSING")?; + let (rest, cert) = X509Certificate::from_der(leaf.as_ref()) + .map_err(|_| anyhow::anyhow!("ROTATION_CERTIFICATE_PARSE"))?; + let names = cert.subject().iter_common_name().collect::>(); + ensure!( + rest.is_empty() + && names.len() == 1 + && names[0].as_str()? == self.agent.to_string() + && !cert.is_ca(), + "ROTATION_AGENT_MISMATCH" + ); + let mut roots = RootCertStore::empty(); + for ca in rustls_pemfile::certs(&mut Cursor::new(&self.ca)) { + roots.add(ca?)?; + } + ensure!(!roots.is_empty(), "ROTATION_CA_MISSING"); + let provider = Arc::new(rustls::crypto::ring::default_provider()); + let verifier = rustls::server::WebPkiClientVerifier::builder_with_provider( + Arc::new(roots), + provider.clone(), + ) + .build()?; + verifier.verify_client_cert( + leaf, + &chain[1..], + UnixTime::since_unix_epoch(Duration::from_secs(u64::try_from(now)?)), + )?; + let key = + rustls_pemfile::private_key(&mut Cursor::new(key))?.context("ROTATION_KEY_MISSING")?; + // from_der allows unknown key consistency; require an actual match. + CertifiedKey::from_der(chain.clone(), key, &provider)?.keys_match()?; + let begin = cert.validity().not_before.timestamp(); + let end = cert.validity().not_after.timestamp(); + ensure!( + begin <= now && now < end, + "ROTATION_EXPIRED_RECOVERY_REQUIRED" + ); + Ok((begin, end)) + } + pub fn due(&self, db: &Connection, keys: &impl KeyFiles, now: i64) -> Result { + let identity = self.current(db, keys, now)?; + let (begin, end) = + self.verify(&identity.certificate_pem, &identity.private_key_pem, now)?; + Ok(self.selector(db)?.1.is_some() + || now.saturating_sub(begin) >= 20 * 86400 + || end.saturating_sub(now) <= 10 * 86400) + } + pub fn has_pending(&self, db: &Connection) -> Result { + Ok(self.selector(db)?.1.is_some()) + } + /// A crash before the transaction leaves only an unselected key file. A + /// response loss reuses the committed CSR/key and still-valid old mTLS leaf. + pub fn prepare( + &self, + db: &mut Connection, + keys: &impl KeyFiles, + now: i64, + ) -> Result { + let identity = self.current(db, keys, now)?; + let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; + let (base, pending) = self.selector(&tx)?; + let (version, csr_pem) = if let Some(version) = pending { + ensure!( + !version.is_nil() && version != base, + "ROTATION_PENDING_CONFLICT" + ); + let csr: String = tx.query_row( + "SELECT csr FROM tls_versions WHERE version=?1 AND certificate IS NULL", + [version.to_string()], + |r| r.get(0), + )?; + let key = KeyPair::from_pem(std::str::from_utf8(&keys.read(version)?)?)?; + let (rest, pem) = x509_parser::pem::parse_x509_pem(csr.as_bytes()) + .map_err(|_| anyhow::anyhow!("ROTATION_PENDING_CSR"))?; + ensure!( + rest.is_empty() && pem.label == "CERTIFICATE REQUEST", + "ROTATION_PENDING_CSR" + ); + let (rest, request) = X509CertificationRequest::from_der(&pem.contents) + .map_err(|_| anyhow::anyhow!("ROTATION_PENDING_CSR"))?; + ensure!( + rest.is_empty() + && request + .certification_request_info + .subject_pki + .subject_public_key + .data + .as_ref() + == key.public_key_raw(), + "ROTATION_PENDING_KEY_MISMATCH" + ); + request + .verify_signature() + .map_err(|_| anyhow::anyhow!("ROTATION_PENDING_SIGNATURE"))?; + (version, csr) + } else { + let key = KeyPair::generate()?; + let csr = self.csr(&key)?; + let version = Uuid::new_v4(); + keys.create(version, key.serialize_pem().as_bytes())?; + tx.execute( + "INSERT INTO tls_versions VALUES(?1,NULL,?2)", + params![version.to_string(), csr], + )?; + tx.execute( + "UPDATE tls_rotation SET pending_version=?1 WHERE id=1", + [version.to_string()], + )?; + (version, csr) + }; + tx.commit()?; + Ok(PendingRequest { + identity, + csr_pem, + base, + version, + }) + } + fn csr(&self, key: &KeyPair) -> Result { + let mut parameters = CertificateParams::default(); + parameters + .distinguished_name + .push(DnType::CommonName, self.agent.to_string()); + Ok(parameters.serialize_request(key)?.pem()?) + } + /// Commit only the exact pending version, with fresh certificate validation. + /// Prior certs and key files are retained; failed installs change no selector. + pub fn install( + &self, + db: &mut Connection, + keys: &impl KeyFiles, + request: &PendingRequest, + bytes: &[u8], + now: i64, + ) -> Result<()> { + ensure!(bytes.len() <= 65536, "ROTATION_RESPONSE_LIMIT"); + let response: RenewalResponse = serde_json::from_slice(bytes)?; + ensure!( + response.agent_id == self.agent && response.overlap_seconds == 300, + "ROTATION_RESPONSE_BINDING_INVALID" + ); + self.verify( + response.certificate_pem.as_bytes(), + &keys.read(request.version)?, + now, + )?; + let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; + ensure!( + self.selector(&tx)? == (request.base, Some(request.version)), + "ROTATION_SELECTOR_CHANGED" + ); + let csr: String = tx.query_row( + "SELECT csr FROM tls_versions WHERE version=?1 AND certificate IS NULL", + [request.version.to_string()], + |r| r.get(0), + )?; + ensure!(csr == request.csr_pem, "ROTATION_PENDING_CHANGED"); + ensure!( + tx.execute( + "UPDATE tls_versions SET certificate=?1 WHERE version=?2 AND certificate IS NULL", + params![ + response.certificate_pem.as_bytes(), + request.version.to_string() + ] + )? == 1, + "ROTATION_PENDING_MISSING" + ); + tx.execute( + "UPDATE tls_rotation SET current_version=?1,pending_version=NULL WHERE id=1", + [request.version.to_string()], + )?; + tx.commit()?; + Ok(()) + } +} + +#[cfg(windows)] +pub struct ProtectedKeyFiles { + root: std::path::PathBuf, + // Denying FILE_SHARE_DELETE holds the actual parent against rename/removal. + _directory: std::fs::File, +} +#[cfg(windows)] +impl ProtectedKeyFiles { + pub fn open(root: &std::path::Path) -> Result { + use std::{fs::OpenOptions, os::windows::fs::OpenOptionsExt}; + use windows_sys::Win32::Storage::FileSystem::*; + ensure!(root.is_absolute(), "ROTATION_ABSOLUTE_STATE_REQUIRED"); + let directory = OpenOptions::new() + .read(true) + .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE) + .custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT) + .open(root)?; + crate::native::private_path(root, true)?; + Self::information(&directory, true)?; + Ok(Self { + root: root.into(), + _directory: directory, + }) + } + fn path(&self, version: Uuid) -> std::path::PathBuf { + self.root.join(if version.is_nil() { + "device.key".into() + } else { + format!("device-{version}.key") + }) + } + fn information(file: &std::fs::File, directory: bool) -> Result<()> { + use std::os::windows::io::AsRawHandle; + use windows_sys::Win32::Storage::FileSystem::*; + let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() }; + ensure!( + unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut info) } != 0, + "ROTATION_FILE_INFORMATION" + ); + ensure!( + info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0 + && (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == directory + && (directory || info.nNumberOfLinks == 1), + "ROTATION_FILE_TYPE_OR_LINKS" + ); + Ok(()) + } +} +#[cfg(windows)] +impl KeyFiles for ProtectedKeyFiles { + fn read(&self, version: Uuid) -> Result> { + use std::{fs::OpenOptions, io::Read, os::windows::fs::OpenOptionsExt}; + use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_OPEN_REPARSE_POINT; + let path = self.path(version); + let mut file = OpenOptions::new() + .read(true) + .share_mode(0) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(&path)?; + Self::information(&file, false)?; + crate::native::private_path(&path, false)?; + let mut bytes = Vec::new(); + Read::by_ref(&mut file) + .take(16385) + .read_to_end(&mut bytes)?; + ensure!(bytes.len() <= 16384, "ROTATION_KEY_LIMIT"); + Ok(bytes) + } + fn create(&self, version: Uuid, key: &[u8]) -> Result<()> { + use std::{fs::OpenOptions, io::Write, os::windows::fs::OpenOptionsExt}; + use windows_sys::Win32::Storage::FileSystem::{ + FILE_FLAG_OPEN_REPARSE_POINT, FILE_FLAG_WRITE_THROUGH, + }; + ensure!( + !version.is_nil() && key.len() <= 16384, + "ROTATION_NEW_KEY_REQUIRED" + ); + let path = self.path(version); + let mut file = OpenOptions::new() + .write(true) + .create_new(true) + .share_mode(0) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH) + .open(&path)?; + Self::information(&file, false)?; + // Inherited ACL must already be private: no secret byte precedes this. + crate::native::private_path(&path, false)?; + file.write_all(key)?; + file.sync_all()?; + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use rcgen::{BasicConstraints, ExtendedKeyUsagePurpose, IsCa, Issuer, KeyUsagePurpose}; + use std::{cell::RefCell, collections::BTreeMap}; + #[derive(Default)] + struct Keys(RefCell>>); + impl KeyFiles for Keys { + fn read(&self, id: Uuid) -> Result> { + self.0 + .borrow() + .get(&id) + .cloned() + .context("MISSING_TEST_KEY") + } + fn create(&self, id: Uuid, key: &[u8]) -> Result<()> { + ensure!(!self.0.borrow().contains_key(&id), "TEST_CREATE_NEW"); + self.0.borrow_mut().insert(id, key.to_vec()); + Ok(()) + } + } + fn now() -> i64 { + chrono::DateTime::parse_from_rfc3339("2026-11-21T00:00:00Z") + .unwrap() + .timestamp() + } + fn ca() -> (String, Issuer<'static, KeyPair>) { + let mut p = CertificateParams::default(); + p.is_ca = IsCa::Ca(BasicConstraints::Unconstrained); + p.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign]; + let key = KeyPair::generate().unwrap(); + let cert = p.self_signed(&key).unwrap().pem(); + (cert, Issuer::new(p, key)) + } + fn certificate(agent: Uuid, key: &[u8], issuer: &Issuer<'_, KeyPair>, client: bool) -> String { + let mut p = CertificateParams::default(); + p.distinguished_name + .push(DnType::CommonName, agent.to_string()); + p.not_before = rcgen::date_time_ymd(2026, 11, 1); + p.not_after = rcgen::date_time_ymd(2026, 12, 1); + p.key_usages = vec![KeyUsagePurpose::DigitalSignature]; + p.extended_key_usages = vec![if client { + ExtendedKeyUsagePurpose::ClientAuth + } else { + ExtendedKeyUsagePurpose::ServerAuth + }]; + p.signed_by( + &KeyPair::from_pem(std::str::from_utf8(key).unwrap()).unwrap(), + issuer, + ) + .unwrap() + .pem() + } + fn setup() -> ( + Connection, + Keys, + RotationStore, + Issuer<'static, KeyPair>, + String, + ) { + let (ca, issuer) = ca(); + let store = RotationStore::new(Uuid::new_v4(), 1, ca.into_bytes()).unwrap(); + let keys = Keys::default(); + keys.create( + Uuid::nil(), + KeyPair::generate().unwrap().serialize_pem().as_bytes(), + ) + .unwrap(); + let cert = certificate(store.agent, &keys.read(Uuid::nil()).unwrap(), &issuer, true); + let mut db = Connection::open_in_memory().unwrap(); + store + .initialize(&mut db, &keys, cert.as_bytes(), now()) + .unwrap(); + (db, keys, store, issuer, cert) + } + fn reply(agent: Uuid, cert: &str) -> Vec { + serde_json::to_vec( + &serde_json::json!({"agent_id":agent,"certificate_pem":cert,"overlap_seconds":300}), + ) + .unwrap() + } + #[test] + fn response_loss_reuses_exact_pending_csr_and_private_key_stays_outside_sqlite() { + let (mut db, keys, store, issuer, old) = setup(); + assert!(store.due(&db, &keys, now()).unwrap()); + let first = store.prepare(&mut db, &keys, now()).unwrap(); + let second = store.prepare(&mut db, &keys, now()).unwrap(); + assert_eq!(first.version, second.version); + assert_eq!(first.csr_pem, second.csr_pem); + assert_eq!(keys.0.borrow().len(), 2); + assert_eq!( + store.current(&db, &keys, now()).unwrap().certificate_pem, + old.as_bytes() + ); + let new = certificate( + store.agent, + &keys.read(first.version).unwrap(), + &issuer, + true, + ); + store + .install(&mut db, &keys, &first, &reply(store.agent, &new), now()) + .unwrap(); + assert_eq!( + store.current(&db, &keys, now()).unwrap().certificate_pem, + new.as_bytes() + ); + assert_eq!(store.selector(&db).unwrap(), (first.version, None)); + assert!( + store + .install(&mut db, &keys, &second, &reply(store.agent, &new), now()) + .is_err() + ); + assert_eq!(keys.0.borrow().len(), 2); + let values:Vec=db.prepare("SELECT coalesce(CAST(certificate AS TEXT),'') || coalesce(csr,'') FROM tls_versions").unwrap().query_map([],|r|r.get(0)).unwrap().collect::>().unwrap(); + assert!(values.iter().all(|v| !v.contains("PRIVATE KEY"))); + } + #[test] + fn bad_reply_preserves_current_pending_and_original_identity() { + let (mut db, keys, store, issuer, old) = setup(); + let pending = store.prepare(&mut db, &keys, now()).unwrap(); + let key = keys.read(pending.version).unwrap(); + let (_wrong_ca, wrong_issuer) = ca(); + let wrong_key = KeyPair::generate().unwrap().serialize_pem(); + for cert in [ + certificate(Uuid::new_v4(), &key, &issuer, true), + certificate(store.agent, wrong_key.as_bytes(), &issuer, true), + certificate(store.agent, &key, &issuer, false), + certificate(store.agent, &key, &wrong_issuer, true), + ] { + assert!( + store + .install(&mut db, &keys, &pending, &reply(store.agent, &cert), now()) + .is_err() + ); + assert_eq!( + store.current(&db, &keys, now()).unwrap().certificate_pem, + old.as_bytes() + ); + assert_eq!( + store.selector(&db).unwrap(), + (Uuid::nil(), Some(pending.version)) + ); + } + let valid = certificate(store.agent, &key, &issuer, true); + assert!( + store + .install( + &mut db, + &keys, + &pending, + &reply(store.agent, &valid), + now() + 11 * 86400 + ) + .is_err() + ); + assert!( + store + .install( + &mut db, + &keys, + &pending, + &reply(Uuid::new_v4(), &valid), + now() + ) + .is_err() + ); + } + #[test] + fn committed_version_never_falls_back_to_legacy_on_restart_or_missing_key() { + let (mut db, keys, store, issuer, old) = setup(); + let pending = store.prepare(&mut db, &keys, now()).unwrap(); + let valid = certificate( + store.agent, + &keys.read(pending.version).unwrap(), + &issuer, + true, + ); + store + .install(&mut db, &keys, &pending, &reply(store.agent, &valid), now()) + .unwrap(); + store + .initialize(&mut db, &keys, old.as_bytes(), now()) + .unwrap(); + assert_eq!(store.selector(&db).unwrap().0, pending.version); + keys.0.borrow_mut().remove(&pending.version); + assert!( + store + .initialize(&mut db, &keys, old.as_bytes(), now()) + .is_err() + ); + assert!(store.current(&db, &keys, now()).is_err()); + assert_eq!(store.selector(&db).unwrap().0, pending.version); + assert!(keys.read(Uuid::nil()).is_ok()); + } + #[test] + fn changed_pending_key_or_identity_cannot_create_a_second_request() { + let (mut db, keys, store, _issuer, _old) = setup(); + let pending = store.prepare(&mut db, &keys, now()).unwrap(); + keys.0.borrow_mut().insert( + pending.version, + KeyPair::generate().unwrap().serialize_pem().into_bytes(), + ); + assert!(store.prepare(&mut db, &keys, now()).is_err()); + assert_eq!(keys.0.borrow().len(), 2); + let other = RotationStore::new(store.agent, 2, store.ca.clone()).unwrap(); + assert!(other.current(&db, &keys, now()).is_err()); + db.execute("DELETE FROM tls_rotation", []).unwrap(); + assert!( + store + .initialize(&mut db, &keys, b"not a bootstrap", now()) + .is_err() + ); + } + #[test] + fn journal_reopen_recovers_pending_before_hello_and_install_is_one_transaction() { + let (_db, keys, store, issuer, old) = setup(); + let directory = std::env::temp_dir().join(format!("rmm-tls-renewal-{}", Uuid::new_v4())); + std::fs::create_dir(&directory).unwrap(); + let mut journal = crate::journal::Journal::open(&directory).unwrap(); + journal.pin_identity(&store.agent.to_string()).unwrap(); + assert_eq!(journal.next_sequence().unwrap(), 1); + store + .initialize(journal.connection_mut(), &keys, old.as_bytes(), now()) + .unwrap(); + let pending = store + .prepare(journal.connection_mut(), &keys, now()) + .unwrap(); + drop(journal); + let mut journal = crate::journal::Journal::open(&directory).unwrap(); + journal.pin_identity(&store.agent.to_string()).unwrap(); + assert_eq!(journal.next_sequence().unwrap(), 2); + assert!(store.has_pending(journal.connection()).unwrap()); + let recovered = store + .prepare(journal.connection_mut(), &keys, now()) + .unwrap(); + assert_eq!(pending.version, recovered.version); + assert_eq!(pending.csr_pem, recovered.csr_pem); + let new = certificate( + store.agent, + &keys.read(pending.version).unwrap(), + &issuer, + true, + ); + let response = reply(store.agent, &new); + // Force the second SQL write to fail, after writing the certificate: + // neither the cert nor selector may survive this aborted transaction. + journal.connection().execute_batch("CREATE TEMP TRIGGER refuse_tls_commit BEFORE UPDATE OF current_version ON tls_rotation BEGIN SELECT RAISE(ABORT,'TEST_COMMIT_DENIED'); END;").unwrap(); + assert!( + store + .install( + journal.connection_mut(), + &keys, + &recovered, + &response, + now() + ) + .is_err() + ); + assert_eq!( + store + .current(journal.connection(), &keys, now()) + .unwrap() + .certificate_pem, + old.as_bytes() + ); + let staged: Option> = journal + .connection() + .query_row( + "SELECT certificate FROM tls_versions WHERE version=?1", + [pending.version.to_string()], + |r| r.get(0), + ) + .unwrap(); + assert!(staged.is_none()); + journal + .connection() + .execute_batch("DROP TRIGGER refuse_tls_commit;") + .unwrap(); + store + .install( + journal.connection_mut(), + &keys, + &recovered, + &response, + now(), + ) + .unwrap(); + drop(journal); + let journal = crate::journal::Journal::open(&directory).unwrap(); + assert!(!store.has_pending(journal.connection()).unwrap()); + assert_eq!( + store + .current(journal.connection(), &keys, now()) + .unwrap() + .certificate_pem, + new.as_bytes() + ); + for entry in std::fs::read_dir(&directory).unwrap() { + let bytes = std::fs::read(entry.unwrap().path()).unwrap(); + assert!( + !bytes + .windows(b"PRIVATE KEY".len()) + .any(|s| s == b"PRIVATE KEY") + ); + } + drop(journal); + std::fs::remove_dir_all(directory).unwrap(); + } +} diff --git a/crates/agent-windows/src/lib.rs b/crates/agent-windows/src/lib.rs index ff51846..3dd66db 100644 --- a/crates/agent-windows/src/lib.rs +++ b/crates/agent-windows/src/lib.rs @@ -2,6 +2,7 @@ //! No executor, startgrant consumer or privileged helper is advertised. #[cfg(windows)] pub mod actions; +pub mod certificate_rotation; #[cfg(windows)] pub mod clock; pub mod event_log; diff --git a/crates/agent-windows/src/main.rs b/crates/agent-windows/src/main.rs index c0f0521..f974603 100644 --- a/crates/agent-windows/src/main.rs +++ b/crates/agent-windows/src/main.rs @@ -11,12 +11,7 @@ mod transport; mod wire_channel; #[cfg(windows)] mod certificate_rotation { - // Shared transport input only. Windows certificate rotation is not yet a - // capability: this first slice refuses expired TLS identities normally. - pub struct DeviceIdentity { - pub certificate_pem: Vec, - pub private_key_pem: Vec, - } + pub use rmm_agent_windows::certificate_rotation::DeviceIdentity; } #[cfg(windows)] fn main() { diff --git a/crates/agent-windows/src/runtime.rs b/crates/agent-windows/src/runtime.rs index a6b4a2d..1e61844 100644 --- a/crates/agent-windows/src/runtime.rs +++ b/crates/agent-windows/src/runtime.rs @@ -7,6 +7,7 @@ use rmm_agent_core::{ jobs, ledger, reconcile::{self, SyncClock}, }; +use rmm_agent_windows::certificate_rotation::{ProtectedKeyFiles, RotationStore}; use rmm_agent_windows::{CAPABILITIES, job_binding::readonly_binding, journal::Journal, native}; use rmm_domain::jobs::{Action, ExecutionPermitPayload}; use rmm_protocol::*; @@ -411,6 +412,8 @@ struct Agent { identity: EnrollmentResponse, ca: Vec, journal: Journal, + certificates: RotationStore, + key_files: ProtectedKeyFiles, boot: String, instance: String, started: Instant, @@ -1213,7 +1216,11 @@ impl Agent { let msi = job.action.windows_msi().cloned(); let address = self.config.connect_address; let ca = self.ca.clone(); - let state = self.config.state_directory.clone(); + let tls_identity = self.certificates.current( + self.journal.connection(), + &self.key_files, + Utc::now().timestamp(), + )?; let request_for_stage = request.clone(); let binding_for_stage = binding.clone(); let worker = tokio::spawn(async move { @@ -1225,9 +1232,12 @@ impl Agent { "MSI_DOWNLOAD_FENCED" ); verified_window(&binding_for_stage, &request_for_stage, &clock)?; - let cert = protected_read(&state.join("device.pem"), 32768)?; - let key = protected_read(&state.join("device.key"), 16384)?; - let tls = crate::https_channel::mtls_client(address, &ca, &cert, &key)?; + let tls = crate::https_channel::mtls_client( + address, + &ca, + &tls_identity.certificate_pem, + &tls_identity.private_key_pem, + )?; let response = tls .get(format!( "https://{}:{}/agent/v1/artifacts/{}?job_id={}&attempt_id={}", @@ -1493,6 +1503,15 @@ impl Agent { result } async fn session_inner(&mut self, stop: &AtomicBool) -> Result<()> { + // Server commit may have fenced Hello even if its HTTP response was + // lost. Recover the durable original CSR before requiring any channel. + if self.certificates.has_pending(self.journal.connection())? { + ensure!( + !self.config.enable_jobs, + "ROTATION_PENDING_REQUIRES_PASSIVE_RECOVERY" + ); + self.renew_certificate().await?; + } self.boot = native::boot_id().await?; let advertised = self.capabilities(); let hello = self.envelope( @@ -1502,16 +1521,11 @@ impl Agent { capabilities: advertised.clone(), }), )?; - let identity = crate::certificate_rotation::DeviceIdentity { - certificate_pem: protected_read( - &self.config.state_directory.join("device.pem"), - 32768, - )?, - private_key_pem: protected_read( - &self.config.state_directory.join("device.key"), - 16384, - )?, - }; + let identity = self.certificates.current( + self.journal.connection(), + &self.key_files, + Utc::now().timestamp(), + )?; let mode = crate::wire_channel::Mode::parse(&self.config.transport)?; let mut channel = crate::wire_channel::connect( mode, @@ -1557,6 +1571,7 @@ impl Agent { let mut replay = Instant::now() - Duration::from_secs(10); let mut inventory = Instant::now(); let mut update_at = Instant::now(); + let mut rotation_at = Instant::now(); let mut heartbeat = Instant::now() - Duration::from_secs(60); let mut heartbeat_after = Duration::from_secs(30); let mut tick = tokio::time::interval(Duration::from_secs(1)); @@ -1642,6 +1657,21 @@ impl Agent { if stop.load(Ordering::SeqCst) { continue; } + // This slice renews only passive clients. Job admission and helper + // lifecycle are not extended by certificate maintenance. + if !self.config.enable_jobs && rotation_at.elapsed() >= Duration::from_secs(30) { + rotation_at = Instant::now(); + let now = Utc::now().timestamp(); + if self + .certificates + .due(self.journal.connection(), &self.key_files, now)? + { + self.renew_certificate().await?; + // The server fences the previous connection generation. + // A new Hello/Sync uses the newly selected pair. + return Ok(()); + } + } if heartbeat.elapsed() >= heartbeat_after { let payload = Payload::Heartbeat(Heartbeat { instance_id: self.instance.clone(), @@ -1677,6 +1707,38 @@ impl Agent { } Ok(()) } + async fn renew_certificate(&mut self) -> Result<()> { + ensure!(!self.config.enable_jobs, "PASSIVE_RENEWAL_ONLY"); + self.close_gate(); + let request = self.certificates.prepare( + self.journal.connection_mut(), + &self.key_files, + Utc::now().timestamp(), + )?; + let client = crate::https_channel::mtls_client( + self.config.connect_address, + &self.ca, + &request.identity.certificate_pem, + &request.identity.private_key_pem, + )?; + let response = client + .post(format!( + "https://{}:{}/agent/v1/certificates/renew", + crate::https_channel::server_name()?, + self.config.connect_address.port() + )) + .json(&serde_json::json!({"csr_pem":request.csr_pem})) + .send() + .await?; + let bytes = crate::https_channel::bounded_body(response, 65536, "application/json").await?; + self.certificates.install( + self.journal.connection_mut(), + &self.key_files, + &request, + &bytes, + Utc::now().timestamp(), + ) + } } fn service_run(stop: &'static AtomicBool) -> Result<()> { let arguments: Vec = std::env::args().skip(1).collect(); @@ -1719,6 +1781,11 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> { import_legacy_inventory(&mut journal)?; } ensure!(!config.enable_jobs || binding.is_some(),"ENABLED_JOBS_REQUIRE_BINDING"); + let certificates=RotationStore::new(Uuid::parse_str(&identity.agent_id)?,binding.as_ref().map_or(1,|b|b.enrollment_generation),ca.clone())?; + let key_files=ProtectedKeyFiles::open(&config.state_directory)?; + certificates.initialize(journal.connection_mut(),&key_files,&protected_read(&config.state_directory.join("device.pem"),32768)?,Utc::now().timestamp())?; + // SQLite and sidecars inherit the same service-SID-only state ACL. + for child in fs::read_dir(&config.state_directory)? { let child=child?;native::private_path(&child.path(),child.file_type()?.is_dir())?; } let (ledger,ledger_file)=match &binding {Some(binding)=>{let (db,file)=open_ledger(&config.state_directory,binding)?;(Some(db),Some(file))},None=>(None,None)}; let clock=JobClock::new(config.enable_jobs); let sync=if config.enable_jobs {binding.clone().map(|binding|reconcile::ClientSync::new(binding).with_helper_identity(reconcile::HelperIdentity::System))} else {None}; @@ -1728,6 +1795,8 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> { identity, ca, journal, + certificates, + key_files, boot, instance: Uuid::new_v4().to_string(), started: Instant::now(), binding, ledger, _ledger_file:ledger_file, clock, sync, diff --git a/deploy/windows/CLIENT.md b/deploy/windows/CLIENT.md index bfd6c8d..1c536d5 100644 --- a/deploy/windows/CLIENT.md +++ b/deploy/windows/CLIENT.md @@ -4,6 +4,11 @@ Stand 2026-11-13, Spezifikation 1.15. Windows-11-Gast und Notebook-Host sind verschiedene Geräte. Auf dem Notebook laufen ausschließlich Entwicklungstools; der Client verwendet den endgültigen Cloudserver `discovery.ease-technologies.de`. +Neuer Quellenstand 2026-11-15: [passive Zertifikatserneuerung](../../docs/windows-certificate-renewal.md) +mit geschützter Keydatei und atomarer Versionswahl ist implementiert; native +Windows-Renewal-/Abbruch-/DACLabnahme und Freigabe der permanenten Identität +bleiben offen. Frühere Transportabnahmen darunter bleiben historische Belege. + ## Aktueller Dienst dauerhaft auf Auto — 2026-11-13 Nach dem bestandenen Fallbacktest wurde die bestehende VM im separaten Fall diff --git a/docs/implementation-status.md b/docs/implementation-status.md index 6b15490..c908c5d 100644 --- a/docs/implementation-status.md +++ b/docs/implementation-status.md @@ -1,5 +1,22 @@ # Tatsächlicher Implementierungsstand +## Passiver Windows-Zertifikatspfad — Quellenstand 2026-11-15 + +Eigener RotationStore mit geschützten CreateNew-Keydateien und atomarer +öffentlicher CSR-/Zertifikats-/Versionswahl im bestehenden SQLite-Journal. +Pending wird vor dem Transport-Hello wiederaufgenommen; kein Schlüssel im +Telemetrie-WAL, kein automatisches Reenrollment oder Legacyfallback nach Wechsel. +Automatische Erneuerung ausschließlich bei `enable_jobs=false`; keine neue +Job-/Helperfähigkeit. [Vertrag und Abnahmegrenzen](windows-certificate-renewal.md). + +Lokal Linux23/23Libtests ohne Filter, GNU-Windows-Alltargetscheck mit +`system-helper`, Clippy beider Targets mit `-D warnings` und Workspacefmt +bestanden. Anschließend dieselben fünf portablen Rotationsfälle tatsächlich auf +Cloud-Linux als UID65534 bestanden (5PASS/18andere gefiltert); Ergebnisquittung +`7e6cab5915ec00a9b1392c1f15ddb13fe9ac6dd3b8e007b82e1dc914cb0507e1`. +Kein installierter Dienst oder Gerätezertifikat verändert; echte +Windows-Renewal-/LocalService-Dateiabnahme bleibt offen. + ## Windowsfortsetzung: Nichtstart-Kern nativ qualifiziert — 2026-11-14 Der zusätzliche enge deny-only Nichtstart-Kern ist implementiert und mit diff --git a/docs/windows-certificate-renewal.md b/docs/windows-certificate-renewal.md new file mode 100644 index 0000000..9a15a71 --- /dev/null +++ b/docs/windows-certificate-renewal.md @@ -0,0 +1,101 @@ +# Windows: Geräte-TLS bei passiver Telemetrie erneuern + +Quellenstand 2026-11-15, Spezifikation 1.23. Der Windowsdienst verwendet jetzt +einen eigenen `RotationStore` und den vorhandenen gemeinsamen mTLS-Transport. +Dies ist Quellen-/lokaler Prüfstand, keine Rotation der permanenten +Windowsidentität und keine native Windowsabnahme. + +Der tatsächliche Serverendpoint `POST /agent/v1/certificates/renew` verlangt +eine noch gültige, registrierte mTLS-Identität. Er prüft die signierte P-256-CSR, +stellt ein neues Gerätezertifikat für dieselbe Agent-ID aus, erhöht die +Verbindungsgeneration und akzeptiert den vorherigen Fingerprint 300 Sekunden. +Die exakten CSR-Bytes sind der serverseitige Wiederholungsschlüssel; eine +Wiederholung innerhalb des zulässigen alten Identitätsfensters liefert dasselbe +bereits gespeicherte Zertifikat. Weder Reenrollment noch Widerruf sind enthalten. + +Der Client prüft alle 30 Sekunden, ob das Zertifikat mindestens 20 Tage alt ist +oder höchstens zehn Tage Restgültigkeit hat. Automatische Erneuerung läuft in +diesem Schnitt ausschließlich bei `enable_jobs=false`. Ein dauerhaftes Pending +wird nach Prozessneustart und vor einem neuen Transport-Hello wiederaufgenommen, +ohne zuvor einen erfolgreichen WSS-/HTTPS-Kanal vorauszusetzen. Während eines +Pending ist die Umschaltung auf Jobbetrieb verweigert. Nach erfolgreichem Commit +baut der Client eine neue Verbindung auf; Heartbeats und unbestätigte +Inventarbytes behalten den bestehenden Journalvertrag. + +Die bisherigen Dateien `identity.json`, `device.pem` und `device.key` werden +nicht ersetzt. Nur vor der ersten Versionswahl wird das bestehende Paar als +Initialversion aufgenommen. Jeder neue private Schlüssel entsteht mit +`CreateNew` als `device-.key` im bestehenden geschützten State. Das +exklusive Dateihandle verweigert gleichzeitiges Ersetzen; Reparsepoints und +Hardlinks werden abgewiesen. Die bestehende SYSTEM-/Administratoren-/Service- +SID-DACL wird vor dem ersten Schlüsselbyte geprüft, anschließend werden die +Dateibytes mit Write-through und `sync_all` geflusht. Das gehaltene +Verzeichnishandle verweigert Löschen/Umbenennen seines Parents. Keine neue +ACL-Freigabe oder allgemeine LocalService-Schreibfreigabe wird hinzugefügt. + +Im vorhandenen exklusiv gesperrten Telemetriejournal stehen ausschließlich +öffentliche CSR-/Zertifikatsbytes und UUID-/Identitätsselektoren; private +Schlüssel gelangen weder in SQLite noch WAL. Die neue Schlüsseldatei ist vor +Pending-Commit vollständig geschrieben. Vor der Netzwerkanfrage committen +Versions-ID und exakte CSR gemeinsam. Die Antwort wird gegen die konfigurierte +CA-Kette, ClientAuth-Verwendung, Gültigkeit, genau einen passenden Geräte-CN, +Nicht-CA-Leaf und tatsächlich passende private Schlüsselbytes geprüft. +Zertifikat und aktiver Selektor wechseln in einer einzigen SQLite-Transaktion +unter dem vorhandenen WAL-/`synchronous=FULL`-Vertrag. + +Ein Schreib-, Antwort-, Validierungs- oder Commitfehler lässt den bisherigen +Selektor erhalten. Unselektierte Schlüsseldateien nach Abbruch werden nicht +adoptiert oder automatisch gelöscht. Nach Auswahl einer neuen Version gibt es +keinen automatischen Rückfall auf die Initialversion, auch nicht bei fehlender +Datei oder Ablauf. Alle vorhandenen mTLS-Verbraucher des Windowsagenten +(WSS/HTTPS, Zeitabruf und gegebenenfalls MSI-Download) verwenden dieselbe +Version. Kein Helper-Signierpin, Zeitpin, Geräte-/Enrollmentgeneration oder +Jobrecht wird rotiert oder freigeschaltet. + +Antwortverlust länger als die serverseitigen 300 Sekunden, abgelaufene oder +widerrufene Zertifikate und beschädigter State benötigen eine ausdrücklich +abgestimmte Wiederherstellung. Der Client erfindet kein neues Identitätsfenster. +Die Crashsicherheit beruht auf der vorhandenen SQLite-/Dateisystem- und +Datenträger-Durabilität: keine Behauptung unabhängiger Stromausfalltests oder +Schutz gegen Administratoren, die Schlüssel und State verändern können. + +Lokale Prüfungen und noch offene native Gates werden im Implementierungsstand +getrennt festgehalten. Native LocalService-DACL-/Flush-/Reparse-/Hardlinktests, +Windows-Renewal mit tatsächlichem Server, Antwortverlust, Prozessabbruch, +Transportwechsel und Negativabnahmen bleiben vor einer Runtimefreigabe offen. +Die permanente Identität darf hierfür nicht ohne weitere Abstimmung rotiert +oder widerrufen werden. Keine RMM-Jobs oder Operatorenserie sind Bestandteil. + +Tatsächlich lokal ausgeführt: `cargo test --offline --locked -p +rmm-agent-windows --lib` (23/23, keine Filter); `cargo check --offline --locked +-p rmm-agent-windows --target x86_64-pc-windows-gnu --all-targets --features +system-helper`; Clippy für beide Targets mit `-D warnings`, +`cargo fmt --all --check` und tatsächlicher GNU-Link beider Windowsbinaries mit +`system-helper` bestanden. Das Windows-Lib-Testbinary wurde mit `--no-run` +gebaut (SHA256 `60e053e6e9cc7fb43de73fe05d50f7934a890e2f5de3c330175af4eba5ed50c5`), +hier nicht ausgeführt. Der erste Crosscheck in der unvollständigen +Builderimage scheiterte an fehlendem WIDL; der vorhandene vollständige +WIDL-/clang-Builder bestand danach, ohne Buildguardänderung. + +Der Orchestrator führte anschließend dasselbe Linux-Testbinary tatsächlich +auf Cloud-Linux als UID65534 aus: genau fünf `certificate_rotation::tests::*` +bestanden, 18 andere Tests bewusst gefiltert, keine Skips oder Fehler. +Binary-SHA256 `33d6e1f0c145e90247e123fba00bad6a972bad6aa8d1f84ffcfa801a97787890`; +eigene geschützte Quittung +`devstate/cert-renewal-linux/d61686f2-7829-4756-869e-a407667d1f97/result.json`, +SHA256 `7e6cab5915ec00a9b1392c1f15ddb13fe9ac6dd3b8e007b82e1dc914cb0507e1`. +Das ist ein nativer Linuxnachweis der portablen Logik mit synthetischen +In-memory-KeyFiles, kein Windows-DACL-/Dateiflush- oder echtes Renewal. +Keine permanente Identität oder Dienstkonfiguration wurde hierfür geändert. + +Die fünf Fälle prüfen exakte CSR-Wiederverwendung nach Antwortverlust; +falsche Agent-ID, CA, Schlüssel, Verwendung und Ablauf bei erhaltener alter +Version; fehlenden neuen Key ohne Legacyfallback; manipuliertes Pending und +Enrollmentbindung; sowie echten SQLite-/WAL-Reopen mit fortbestehender Sequenz +und einen absichtlich verweigerten Selektorcommit, bei dem auch das zuvor im +selben SQL-Commit geschriebene Zertifikat zurückgerollt wird. + +Die Dateiflags folgen [CreateFileW](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew) +und [FlushFileBuffers](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-flushfilebuffers); +der öffentliche Selektor übernimmt den vorhandenen +[SQLite-WAL/FULL-Vertrag](https://www.sqlite.org/pragma.html#pragma_synchronous).