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
@@ -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,