Add crash-safe passive Windows certificate renewal
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 13:54:59 +01:00
parent 17a33e7823
commit 0b1f582998
9 changed files with 914 additions and 20 deletions
Generated
+1
View File
@@ -2263,6 +2263,7 @@ dependencies = [
"tokio-tungstenite 0.28.0",
"uuid",
"windows-sys 0.61.2",
"x509-parser",
]
[[package]]
+1
View File
@@ -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]
@@ -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<u8>,
pub private_key_pem: Vec<u8>,
}
/// Never supplies private bytes to the SQLite writer.
pub trait KeyFiles {
fn read(&self, version: Uuid) -> Result<Vec<u8>>;
/// 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<u8>,
}
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<u8>) -> Result<Self> {
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<Uuid>)> {
let (schema, agent, enrollment, current, pending): (u32,String,u64,String,Option<String>) = 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(&current)?,
pending.map(|s| Uuid::parse_str(&s)).transpose()?,
))
}
pub fn current(
&self,
db: &Connection,
keys: &impl KeyFiles,
now: i64,
) -> Result<DeviceIdentity> {
let (version, _) = self.selector(db)?;
let cert: Vec<u8> = 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::<std::io::Result<Vec<_>>>()?;
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::<Vec<_>>();
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<bool> {
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<bool> {
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<PendingRequest> {
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<String> {
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<Self> {
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<Vec<u8>> {
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<BTreeMap<Uuid, Vec<u8>>>);
impl KeyFiles for Keys {
fn read(&self, id: Uuid) -> Result<Vec<u8>> {
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<u8> {
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<String>=db.prepare("SELECT coalesce(CAST(certificate AS TEXT),'') || coalesce(csr,'') FROM tls_versions").unwrap().query_map([],|r|r.get(0)).unwrap().collect::<rusqlite::Result<_>>().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<Vec<u8>> = 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();
}
}
+1
View File
@@ -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;
+1 -6
View File
@@ -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<u8>,
pub private_key_pem: Vec<u8>,
}
pub use rmm_agent_windows::certificate_rotation::DeviceIdentity;
}
#[cfg(windows)]
fn main() {
+83 -14
View File
@@ -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<u8>,
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<String> = 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,
+5
View File
@@ -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
+17
View File
@@ -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
+101
View File
@@ -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-<UUID>.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).