Integrate passive Windows certificate renewal and native recovery checks
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
Generated
+1
@@ -2263,6 +2263,7 @@ dependencies = [
|
|||||||
"tokio-tungstenite 0.28.0",
|
"tokio-tungstenite 0.28.0",
|
||||||
"uuid",
|
"uuid",
|
||||||
"windows-sys 0.61.2",
|
"windows-sys 0.61.2",
|
||||||
|
"x509-parser",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|||||||
@@ -34,6 +34,7 @@ rmm-protocol = { path = "../protocol" }
|
|||||||
rmm-time-attestation = { path = "../time-attestation" }
|
rmm-time-attestation = { path = "../time-attestation" }
|
||||||
rusqlite = { version = "0.32.1", features = ["bundled"] }
|
rusqlite = { version = "0.32.1", features = ["bundled"] }
|
||||||
fs2 = "0.4.3"
|
fs2 = "0.4.3"
|
||||||
|
x509-parser = { version = "=0.18.1", features = ["verify"] }
|
||||||
rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", "ring", "pem"] }
|
rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", "ring", "pem"] }
|
||||||
|
|
||||||
[build-dependencies]
|
[build-dependencies]
|
||||||
|
|||||||
@@ -0,0 +1,706 @@
|
|||||||
|
//! 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(¤t)?,
|
||||||
|
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()
|
||||||
|
);
|
||||||
|
// Windows SQLite holds byte-range locks in the live WAL/SHM files.
|
||||||
|
// Release the database before inspecting its remaining raw files.
|
||||||
|
drop(journal);
|
||||||
|
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")
|
||||||
|
);
|
||||||
|
}
|
||||||
|
std::fs::remove_dir_all(directory).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -2,6 +2,7 @@
|
|||||||
//! No executor, startgrant consumer or privileged helper is advertised.
|
//! No executor, startgrant consumer or privileged helper is advertised.
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
pub mod actions;
|
pub mod actions;
|
||||||
|
pub mod certificate_rotation;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
pub mod clock;
|
pub mod clock;
|
||||||
pub mod event_log;
|
pub mod event_log;
|
||||||
|
|||||||
@@ -11,12 +11,7 @@ mod transport;
|
|||||||
mod wire_channel;
|
mod wire_channel;
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
mod certificate_rotation {
|
mod certificate_rotation {
|
||||||
// Shared transport input only. Windows certificate rotation is not yet a
|
pub use rmm_agent_windows::certificate_rotation::DeviceIdentity;
|
||||||
// capability: this first slice refuses expired TLS identities normally.
|
|
||||||
pub struct DeviceIdentity {
|
|
||||||
pub certificate_pem: Vec<u8>,
|
|
||||||
pub private_key_pem: Vec<u8>,
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
#[cfg(windows)]
|
#[cfg(windows)]
|
||||||
fn main() {
|
fn main() {
|
||||||
|
|||||||
@@ -7,6 +7,7 @@ use rmm_agent_core::{
|
|||||||
jobs, ledger,
|
jobs, ledger,
|
||||||
reconcile::{self, SyncClock},
|
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_agent_windows::{CAPABILITIES, job_binding::readonly_binding, journal::Journal, native};
|
||||||
use rmm_domain::jobs::{Action, ExecutionPermitPayload};
|
use rmm_domain::jobs::{Action, ExecutionPermitPayload};
|
||||||
use rmm_protocol::*;
|
use rmm_protocol::*;
|
||||||
@@ -411,6 +412,8 @@ struct Agent {
|
|||||||
identity: EnrollmentResponse,
|
identity: EnrollmentResponse,
|
||||||
ca: Vec<u8>,
|
ca: Vec<u8>,
|
||||||
journal: Journal,
|
journal: Journal,
|
||||||
|
certificates: RotationStore,
|
||||||
|
key_files: ProtectedKeyFiles,
|
||||||
boot: String,
|
boot: String,
|
||||||
instance: String,
|
instance: String,
|
||||||
started: Instant,
|
started: Instant,
|
||||||
@@ -1213,7 +1216,11 @@ impl Agent {
|
|||||||
let msi = job.action.windows_msi().cloned();
|
let msi = job.action.windows_msi().cloned();
|
||||||
let address = self.config.connect_address;
|
let address = self.config.connect_address;
|
||||||
let ca = self.ca.clone();
|
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 request_for_stage = request.clone();
|
||||||
let binding_for_stage = binding.clone();
|
let binding_for_stage = binding.clone();
|
||||||
let worker = tokio::spawn(async move {
|
let worker = tokio::spawn(async move {
|
||||||
@@ -1225,9 +1232,12 @@ impl Agent {
|
|||||||
"MSI_DOWNLOAD_FENCED"
|
"MSI_DOWNLOAD_FENCED"
|
||||||
);
|
);
|
||||||
verified_window(&binding_for_stage, &request_for_stage, &clock)?;
|
verified_window(&binding_for_stage, &request_for_stage, &clock)?;
|
||||||
let cert = protected_read(&state.join("device.pem"), 32768)?;
|
let tls = crate::https_channel::mtls_client(
|
||||||
let key = protected_read(&state.join("device.key"), 16384)?;
|
address,
|
||||||
let tls = crate::https_channel::mtls_client(address, &ca, &cert, &key)?;
|
&ca,
|
||||||
|
&tls_identity.certificate_pem,
|
||||||
|
&tls_identity.private_key_pem,
|
||||||
|
)?;
|
||||||
let response = tls
|
let response = tls
|
||||||
.get(format!(
|
.get(format!(
|
||||||
"https://{}:{}/agent/v1/artifacts/{}?job_id={}&attempt_id={}",
|
"https://{}:{}/agent/v1/artifacts/{}?job_id={}&attempt_id={}",
|
||||||
@@ -1493,6 +1503,15 @@ impl Agent {
|
|||||||
result
|
result
|
||||||
}
|
}
|
||||||
async fn session_inner(&mut self, stop: &AtomicBool) -> 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?;
|
self.boot = native::boot_id().await?;
|
||||||
let advertised = self.capabilities();
|
let advertised = self.capabilities();
|
||||||
let hello = self.envelope(
|
let hello = self.envelope(
|
||||||
@@ -1502,16 +1521,11 @@ impl Agent {
|
|||||||
capabilities: advertised.clone(),
|
capabilities: advertised.clone(),
|
||||||
}),
|
}),
|
||||||
)?;
|
)?;
|
||||||
let identity = crate::certificate_rotation::DeviceIdentity {
|
let identity = self.certificates.current(
|
||||||
certificate_pem: protected_read(
|
self.journal.connection(),
|
||||||
&self.config.state_directory.join("device.pem"),
|
&self.key_files,
|
||||||
32768,
|
Utc::now().timestamp(),
|
||||||
)?,
|
)?;
|
||||||
private_key_pem: protected_read(
|
|
||||||
&self.config.state_directory.join("device.key"),
|
|
||||||
16384,
|
|
||||||
)?,
|
|
||||||
};
|
|
||||||
let mode = crate::wire_channel::Mode::parse(&self.config.transport)?;
|
let mode = crate::wire_channel::Mode::parse(&self.config.transport)?;
|
||||||
let mut channel = crate::wire_channel::connect(
|
let mut channel = crate::wire_channel::connect(
|
||||||
mode,
|
mode,
|
||||||
@@ -1557,6 +1571,7 @@ impl Agent {
|
|||||||
let mut replay = Instant::now() - Duration::from_secs(10);
|
let mut replay = Instant::now() - Duration::from_secs(10);
|
||||||
let mut inventory = Instant::now();
|
let mut inventory = Instant::now();
|
||||||
let mut update_at = 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 = Instant::now() - Duration::from_secs(60);
|
||||||
let mut heartbeat_after = Duration::from_secs(30);
|
let mut heartbeat_after = Duration::from_secs(30);
|
||||||
let mut tick = tokio::time::interval(Duration::from_secs(1));
|
let mut tick = tokio::time::interval(Duration::from_secs(1));
|
||||||
@@ -1642,6 +1657,21 @@ impl Agent {
|
|||||||
if stop.load(Ordering::SeqCst) {
|
if stop.load(Ordering::SeqCst) {
|
||||||
continue;
|
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 {
|
if heartbeat.elapsed() >= heartbeat_after {
|
||||||
let payload = Payload::Heartbeat(Heartbeat {
|
let payload = Payload::Heartbeat(Heartbeat {
|
||||||
instance_id: self.instance.clone(),
|
instance_id: self.instance.clone(),
|
||||||
@@ -1677,6 +1707,38 @@ impl Agent {
|
|||||||
}
|
}
|
||||||
Ok(())
|
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<()> {
|
fn service_run(stop: &'static AtomicBool) -> Result<()> {
|
||||||
let arguments: Vec<String> = std::env::args().skip(1).collect();
|
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)?;
|
import_legacy_inventory(&mut journal)?;
|
||||||
}
|
}
|
||||||
ensure!(!config.enable_jobs || binding.is_some(),"ENABLED_JOBS_REQUIRE_BINDING");
|
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 (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 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};
|
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,
|
identity,
|
||||||
ca,
|
ca,
|
||||||
journal,
|
journal,
|
||||||
|
certificates,
|
||||||
|
key_files,
|
||||||
boot,
|
boot,
|
||||||
instance: Uuid::new_v4().to_string(),
|
instance: Uuid::new_v4().to_string(),
|
||||||
started: Instant::now(), binding, ledger, _ledger_file:ledger_file, clock, sync,
|
started: Instant::now(), binding, ledger, _ledger_file:ledger_file, clock, sync,
|
||||||
|
|||||||
@@ -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;
|
verschiedene Geräte. Auf dem Notebook laufen ausschließlich Entwicklungstools;
|
||||||
der Client verwendet den endgültigen Cloudserver `discovery.ease-technologies.de`.
|
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
|
## Aktueller Dienst dauerhaft auf Auto — 2026-11-13
|
||||||
|
|
||||||
Nach dem bestandenen Fallbacktest wurde die bestehende VM im separaten Fall
|
Nach dem bestandenen Fallbacktest wurde die bestehende VM im separaten Fall
|
||||||
|
|||||||
@@ -1,5 +1,32 @@
|
|||||||
# Tatsächlicher Implementierungsstand
|
# 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.
|
||||||
|
|
||||||
|
Ein erster Windowslauf blieb bei4/5 fehlgeschlagen: Testfixture las die rohen
|
||||||
|
SQLite-Dateien vor Schließen ihres eigenen WAL-/SHM-Locks (Win32-Fehler33).
|
||||||
|
Nach ausschließlich diesem Testfix erneut tatsächlich Linux5/18gefiltert,
|
||||||
|
danach Windows11-AMD64-Entwicklungsbenutzer5/44gefiltert bestanden; jeweils
|
||||||
|
keine Skips/Fehler. Neue Quittungen `1736a19a75d49eca91062e4e7adb28732f254279b64003474efcd6201ffa08ac`
|
||||||
|
und `64e960c2eb0b755b376028d923c6fdebbc11d5f96534103452f865ccf51a4fc0`.
|
||||||
|
Nur portable Logik mit synthetischen KeyFiles, keine echte TLS-Rotation oder
|
||||||
|
LocalService-Keydateiabnahme. Originalfehler und genaue Grenzen bleiben im
|
||||||
|
verlinkten Bericht erhalten.
|
||||||
|
|
||||||
## Windowsfortsetzung: Nichtstart-Kern nativ qualifiziert — 2026-11-14
|
## Windowsfortsetzung: Nichtstart-Kern nativ qualifiziert — 2026-11-14
|
||||||
|
|
||||||
Der zusätzliche enge deny-only Nichtstart-Kern ist implementiert und mit
|
Der zusätzliche enge deny-only Nichtstart-Kern ist implementiert und mit
|
||||||
|
|||||||
@@ -0,0 +1,130 @@
|
|||||||
|
# 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.
|
||||||
|
Die portable Logik ist nativ auf Linux und Windows geprüft. Dies ist keine
|
||||||
|
Rotation der permanenten Windowsidentität und keine native
|
||||||
|
Windows-Renewal-/Datei-I/O-Abnahme.
|
||||||
|
|
||||||
|
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.
|
||||||
|
|
||||||
|
Erster tatsächlicher Windows-Unitlauf: vier Fälle bestanden, der fünfte endete
|
||||||
|
mit Exit101/Win32-Fehler33 beim rohen Dateiscan nach allen SQL-Prüfungen. Die
|
||||||
|
Testfixture hatte ihr Journal noch geöffnet und traf auf SQLite-WAL-/SHM-
|
||||||
|
Bytebereichssperren. Originalbeleg
|
||||||
|
`f981a395f4eceb527ad8a8859cff3c69ba79e52421300968b057404742fa1d8c`
|
||||||
|
bleibt fehlgeschlagen. Die Fixture schließt nun das Journal vor dem rohen
|
||||||
|
Restdateiscan; keine Fehler werden übergangen und kein Produktguard geändert.
|
||||||
|
Dieser Scan behauptet keinen Zugriff auf ein aktiv gesperrtes Windows-WAL.
|
||||||
|
Der erste Viererfolg ist keine vollständige Windowsabnahme.
|
||||||
|
|
||||||
|
Das enge Testdelta ist anschließend tatsächlich zuerst auf Cloud-Linux als
|
||||||
|
UID65534 bestanden: fünf PASS, 18 andere gefiltert, keine Skips oder Fehler;
|
||||||
|
Fall `bc2158ce-d500-4c64-8f17-e12527559f5b`, Quittung-SHA256
|
||||||
|
`1736a19a75d49eca91062e4e7adb28732f254279b64003474efcd6201ffa08ac`.
|
||||||
|
Linux-Binary-SHA256
|
||||||
|
`1f9482ce78b6690e6bfbadecc5df61d5157620fce5302c094364cc8c371d1093`.
|
||||||
|
Danach auf Windows11 AMD64 im Entwicklungsbenutzerprozess: dieselben fünf
|
||||||
|
PASS, 44 andere gefiltert, keine Skips oder Fehler; Fall
|
||||||
|
`01d26081-895f-4dea-8eb0-7c4defed1d27`, Quittung-SHA256
|
||||||
|
`64e960c2eb0b755b376028d923c6fdebbc11d5f96534103452f865ccf51a4fc0`.
|
||||||
|
Windows-Binary-SHA256
|
||||||
|
`951a0ddad1225752d8817c15234f74926f1e216c1ca22e1aee8ba0a5e7f97e60`.
|
||||||
|
Beide Nachprüfungen führte der Orchestrator aus. Der Produktcode blieb beim
|
||||||
|
Fixturefix unverändert. Die Windowsfälle verwenden synthetische
|
||||||
|
In-memory-KeyFiles: kein LocalService-/ProtectedKeyFiles-Nachweis, kein echter
|
||||||
|
Renewal-HTTP-Aufruf und keine permanente Zertifikats-, Dienst- oder
|
||||||
|
Jobänderung. Die oben benannten Runtimegates bleiben offen.
|
||||||
|
|
||||||
|
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).
|
||||||
Reference in New Issue
Block a user