//! Passive TLS renewal. SQLite commits only public CSR/certificate/version data; //! private keys stay in immutable, protected files outside the telemetry WAL. //! The caller must retain the existing exclusive agent-state journal lock. use anyhow::{Context, Result, ensure}; use rcgen::{CertificateParams, DnType, KeyPair}; use rusqlite::{Connection, params}; use rustls::{RootCertStore, pki_types::UnixTime, sign::CertifiedKey}; use serde::Deserialize; use std::{io::Cursor, sync::Arc, time::Duration}; use uuid::Uuid; use x509_parser::prelude::*; pub struct DeviceIdentity { pub certificate_pem: Vec, pub private_key_pem: Vec, } /// Never supplies private bytes to the SQLite writer. pub trait KeyFiles { fn read(&self, version: Uuid) -> Result>; /// CreateNew, protected before writing, and durable before returning. fn create(&self, version: Uuid, key: &[u8]) -> Result<()>; } pub struct RotationStore { agent: Uuid, enrollment: u64, ca: Vec, } pub struct PendingRequest { pub identity: DeviceIdentity, pub csr_pem: String, base: Uuid, version: Uuid, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RenewalResponse { agent_id: Uuid, certificate_pem: String, overlap_seconds: u32, } impl RotationStore { pub fn new(agent: Uuid, enrollment: u64, ca: Vec) -> Result { ensure!( !agent.is_nil() && enrollment > 0, "ROTATION_IDENTITY_INVALID" ); Ok(Self { agent, enrollment, ca, }) } /// Called under the journal lock. Legacy files are eligible exactly once, /// before any selector exists. There is no recovery fallback or reenrollment. pub fn initialize( &self, db: &mut Connection, keys: &impl KeyFiles, cert: &[u8], now: i64, ) -> Result<()> { let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; tx.execute_batch("CREATE TABLE IF NOT EXISTS tls_versions(version TEXT PRIMARY KEY,certificate BLOB,csr TEXT); CREATE TABLE IF NOT EXISTS tls_rotation(id INTEGER PRIMARY KEY CHECK(id=1),schema_version INTEGER NOT NULL,agent TEXT NOT NULL,enrollment INTEGER NOT NULL,current_version TEXT NOT NULL REFERENCES tls_versions(version),pending_version TEXT REFERENCES tls_versions(version));")?; let present: bool = tx.query_row("SELECT EXISTS(SELECT 1 FROM tls_rotation)", [], |r| { r.get(0) })?; if !present { let count: u64 = tx.query_row("SELECT count(*) FROM tls_versions", [], |r| r.get(0))?; ensure!(count == 0, "ROTATION_SELECTOR_MISSING"); self.verify(cert, &keys.read(Uuid::nil())?, now)?; tx.execute( "INSERT INTO tls_versions VALUES(?1,?2,NULL)", params![Uuid::nil().to_string(), cert], )?; tx.execute( "INSERT INTO tls_rotation VALUES(1,1,?1,?2,?3,NULL)", params![ self.agent.to_string(), self.enrollment, Uuid::nil().to_string() ], )?; } self.current(&tx, keys, now)?; tx.commit()?; Ok(()) } fn selector(&self, db: &Connection) -> Result<(Uuid, Option)> { let (schema, agent, enrollment, current, pending): (u32,String,u64,String,Option) = db.query_row("SELECT schema_version,agent,enrollment,current_version,pending_version FROM tls_rotation WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?)))?; ensure!( schema == 1 && agent == self.agent.to_string() && enrollment == self.enrollment, "ROTATION_IDENTITY_CHANGED" ); Ok(( Uuid::parse_str(¤t)?, pending.map(|s| Uuid::parse_str(&s)).transpose()?, )) } pub fn current( &self, db: &Connection, keys: &impl KeyFiles, now: i64, ) -> Result { let (version, _) = self.selector(db)?; let cert: Vec = db.query_row( "SELECT certificate FROM tls_versions WHERE version=?1", [version.to_string()], |r| r.get(0), )?; let key = keys.read(version)?; self.verify(&cert, &key, now)?; Ok(DeviceIdentity { certificate_pem: cert, private_key_pem: key, }) } fn verify(&self, pem: &[u8], key: &[u8], now: i64) -> Result<(i64, i64)> { ensure!( pem.len() <= 32768 && key.len() <= 16384, "ROTATION_IDENTITY_LIMIT" ); let chain = rustls_pemfile::certs(&mut Cursor::new(pem)).collect::>>()?; let leaf = chain.first().context("ROTATION_CERTIFICATE_MISSING")?; let (rest, cert) = X509Certificate::from_der(leaf.as_ref()) .map_err(|_| anyhow::anyhow!("ROTATION_CERTIFICATE_PARSE"))?; let names = cert.subject().iter_common_name().collect::>(); ensure!( rest.is_empty() && names.len() == 1 && names[0].as_str()? == self.agent.to_string() && !cert.is_ca(), "ROTATION_AGENT_MISMATCH" ); let mut roots = RootCertStore::empty(); for ca in rustls_pemfile::certs(&mut Cursor::new(&self.ca)) { roots.add(ca?)?; } ensure!(!roots.is_empty(), "ROTATION_CA_MISSING"); let provider = Arc::new(rustls::crypto::ring::default_provider()); let verifier = rustls::server::WebPkiClientVerifier::builder_with_provider( Arc::new(roots), provider.clone(), ) .build()?; verifier.verify_client_cert( leaf, &chain[1..], UnixTime::since_unix_epoch(Duration::from_secs(u64::try_from(now)?)), )?; let key = rustls_pemfile::private_key(&mut Cursor::new(key))?.context("ROTATION_KEY_MISSING")?; // from_der allows unknown key consistency; require an actual match. CertifiedKey::from_der(chain.clone(), key, &provider)?.keys_match()?; let begin = cert.validity().not_before.timestamp(); let end = cert.validity().not_after.timestamp(); ensure!( begin <= now && now < end, "ROTATION_EXPIRED_RECOVERY_REQUIRED" ); Ok((begin, end)) } pub fn due(&self, db: &Connection, keys: &impl KeyFiles, now: i64) -> Result { let identity = self.current(db, keys, now)?; let (begin, end) = self.verify(&identity.certificate_pem, &identity.private_key_pem, now)?; Ok(self.selector(db)?.1.is_some() || now.saturating_sub(begin) >= 20 * 86400 || end.saturating_sub(now) <= 10 * 86400) } pub fn has_pending(&self, db: &Connection) -> Result { Ok(self.selector(db)?.1.is_some()) } /// A crash before the transaction leaves only an unselected key file. A /// response loss reuses the committed CSR/key and still-valid old mTLS leaf. pub fn prepare( &self, db: &mut Connection, keys: &impl KeyFiles, now: i64, ) -> Result { let identity = self.current(db, keys, now)?; let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; let (base, pending) = self.selector(&tx)?; let (version, csr_pem) = if let Some(version) = pending { ensure!( !version.is_nil() && version != base, "ROTATION_PENDING_CONFLICT" ); let csr: String = tx.query_row( "SELECT csr FROM tls_versions WHERE version=?1 AND certificate IS NULL", [version.to_string()], |r| r.get(0), )?; let key = KeyPair::from_pem(std::str::from_utf8(&keys.read(version)?)?)?; let (rest, pem) = x509_parser::pem::parse_x509_pem(csr.as_bytes()) .map_err(|_| anyhow::anyhow!("ROTATION_PENDING_CSR"))?; ensure!( rest.is_empty() && pem.label == "CERTIFICATE REQUEST", "ROTATION_PENDING_CSR" ); let (rest, request) = X509CertificationRequest::from_der(&pem.contents) .map_err(|_| anyhow::anyhow!("ROTATION_PENDING_CSR"))?; ensure!( rest.is_empty() && request .certification_request_info .subject_pki .subject_public_key .data .as_ref() == key.public_key_raw(), "ROTATION_PENDING_KEY_MISMATCH" ); request .verify_signature() .map_err(|_| anyhow::anyhow!("ROTATION_PENDING_SIGNATURE"))?; (version, csr) } else { let key = KeyPair::generate()?; let csr = self.csr(&key)?; let version = Uuid::new_v4(); keys.create(version, key.serialize_pem().as_bytes())?; tx.execute( "INSERT INTO tls_versions VALUES(?1,NULL,?2)", params![version.to_string(), csr], )?; tx.execute( "UPDATE tls_rotation SET pending_version=?1 WHERE id=1", [version.to_string()], )?; (version, csr) }; tx.commit()?; Ok(PendingRequest { identity, csr_pem, base, version, }) } fn csr(&self, key: &KeyPair) -> Result { let mut parameters = CertificateParams::default(); parameters .distinguished_name .push(DnType::CommonName, self.agent.to_string()); Ok(parameters.serialize_request(key)?.pem()?) } /// Commit only the exact pending version, with fresh certificate validation. /// Prior certs and key files are retained; failed installs change no selector. pub fn install( &self, db: &mut Connection, keys: &impl KeyFiles, request: &PendingRequest, bytes: &[u8], now: i64, ) -> Result<()> { ensure!(bytes.len() <= 65536, "ROTATION_RESPONSE_LIMIT"); let response: RenewalResponse = serde_json::from_slice(bytes)?; ensure!( response.agent_id == self.agent && response.overlap_seconds == 300, "ROTATION_RESPONSE_BINDING_INVALID" ); self.verify( response.certificate_pem.as_bytes(), &keys.read(request.version)?, now, )?; let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?; ensure!( self.selector(&tx)? == (request.base, Some(request.version)), "ROTATION_SELECTOR_CHANGED" ); let csr: String = tx.query_row( "SELECT csr FROM tls_versions WHERE version=?1 AND certificate IS NULL", [request.version.to_string()], |r| r.get(0), )?; ensure!(csr == request.csr_pem, "ROTATION_PENDING_CHANGED"); ensure!( tx.execute( "UPDATE tls_versions SET certificate=?1 WHERE version=?2 AND certificate IS NULL", params![ response.certificate_pem.as_bytes(), request.version.to_string() ] )? == 1, "ROTATION_PENDING_MISSING" ); tx.execute( "UPDATE tls_rotation SET current_version=?1,pending_version=NULL WHERE id=1", [request.version.to_string()], )?; tx.commit()?; Ok(()) } } #[cfg(windows)] pub struct ProtectedKeyFiles { root: std::path::PathBuf, // Denying FILE_SHARE_DELETE holds the actual parent against rename/removal. _directory: std::fs::File, } #[cfg(windows)] impl ProtectedKeyFiles { pub fn open(root: &std::path::Path) -> Result { use std::{fs::OpenOptions, os::windows::fs::OpenOptionsExt}; use windows_sys::Win32::Storage::FileSystem::*; ensure!(root.is_absolute(), "ROTATION_ABSOLUTE_STATE_REQUIRED"); let directory = OpenOptions::new() .read(true) .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE) .custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT) .open(root)?; crate::native::private_path(root, true)?; Self::information(&directory, true)?; Ok(Self { root: root.into(), _directory: directory, }) } fn path(&self, version: Uuid) -> std::path::PathBuf { self.root.join(if version.is_nil() { "device.key".into() } else { format!("device-{version}.key") }) } fn information(file: &std::fs::File, directory: bool) -> Result<()> { use std::os::windows::io::AsRawHandle; use windows_sys::Win32::Storage::FileSystem::*; let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() }; ensure!( unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut info) } != 0, "ROTATION_FILE_INFORMATION" ); ensure!( info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0 && (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == directory && (directory || info.nNumberOfLinks == 1), "ROTATION_FILE_TYPE_OR_LINKS" ); Ok(()) } } #[cfg(windows)] impl KeyFiles for ProtectedKeyFiles { fn read(&self, version: Uuid) -> Result> { use std::{fs::OpenOptions, io::Read, os::windows::fs::OpenOptionsExt}; use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_OPEN_REPARSE_POINT; let path = self.path(version); let mut file = OpenOptions::new() .read(true) .share_mode(0) .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) .open(&path)?; Self::information(&file, false)?; crate::native::private_path(&path, false)?; let mut bytes = Vec::new(); Read::by_ref(&mut file) .take(16385) .read_to_end(&mut bytes)?; ensure!(bytes.len() <= 16384, "ROTATION_KEY_LIMIT"); Ok(bytes) } fn create(&self, version: Uuid, key: &[u8]) -> Result<()> { use std::{fs::OpenOptions, io::Write, os::windows::fs::OpenOptionsExt}; use windows_sys::Win32::Storage::FileSystem::{ FILE_FLAG_OPEN_REPARSE_POINT, FILE_FLAG_WRITE_THROUGH, }; ensure!( !version.is_nil() && key.len() <= 16384, "ROTATION_NEW_KEY_REQUIRED" ); let path = self.path(version); let mut file = OpenOptions::new() .write(true) .create_new(true) .share_mode(0) .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH) .open(&path)?; Self::information(&file, false)?; // Inherited ACL must already be private: no secret byte precedes this. crate::native::private_path(&path, false)?; file.write_all(key)?; file.sync_all()?; Ok(()) } } #[cfg(test)] mod tests { use super::*; use rcgen::{BasicConstraints, ExtendedKeyUsagePurpose, IsCa, Issuer, KeyUsagePurpose}; use std::{cell::RefCell, collections::BTreeMap}; #[derive(Default)] struct Keys(RefCell>>); impl KeyFiles for Keys { fn read(&self, id: Uuid) -> Result> { self.0 .borrow() .get(&id) .cloned() .context("MISSING_TEST_KEY") } fn create(&self, id: Uuid, key: &[u8]) -> Result<()> { ensure!(!self.0.borrow().contains_key(&id), "TEST_CREATE_NEW"); self.0.borrow_mut().insert(id, key.to_vec()); Ok(()) } } fn now() -> i64 { chrono::DateTime::parse_from_rfc3339("2026-11-21T00:00:00Z") .unwrap() .timestamp() } fn ca() -> (String, Issuer<'static, KeyPair>) { let mut p = CertificateParams::default(); p.is_ca = IsCa::Ca(BasicConstraints::Unconstrained); p.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign]; let key = KeyPair::generate().unwrap(); let cert = p.self_signed(&key).unwrap().pem(); (cert, Issuer::new(p, key)) } fn certificate(agent: Uuid, key: &[u8], issuer: &Issuer<'_, KeyPair>, client: bool) -> String { let mut p = CertificateParams::default(); p.distinguished_name .push(DnType::CommonName, agent.to_string()); p.not_before = rcgen::date_time_ymd(2026, 11, 1); p.not_after = rcgen::date_time_ymd(2026, 12, 1); p.key_usages = vec![KeyUsagePurpose::DigitalSignature]; p.extended_key_usages = vec![if client { ExtendedKeyUsagePurpose::ClientAuth } else { ExtendedKeyUsagePurpose::ServerAuth }]; p.signed_by( &KeyPair::from_pem(std::str::from_utf8(key).unwrap()).unwrap(), issuer, ) .unwrap() .pem() } fn setup() -> ( Connection, Keys, RotationStore, Issuer<'static, KeyPair>, String, ) { let (ca, issuer) = ca(); let store = RotationStore::new(Uuid::new_v4(), 1, ca.into_bytes()).unwrap(); let keys = Keys::default(); keys.create( Uuid::nil(), KeyPair::generate().unwrap().serialize_pem().as_bytes(), ) .unwrap(); let cert = certificate(store.agent, &keys.read(Uuid::nil()).unwrap(), &issuer, true); let mut db = Connection::open_in_memory().unwrap(); store .initialize(&mut db, &keys, cert.as_bytes(), now()) .unwrap(); (db, keys, store, issuer, cert) } fn reply(agent: Uuid, cert: &str) -> Vec { serde_json::to_vec( &serde_json::json!({"agent_id":agent,"certificate_pem":cert,"overlap_seconds":300}), ) .unwrap() } #[test] fn response_loss_reuses_exact_pending_csr_and_private_key_stays_outside_sqlite() { let (mut db, keys, store, issuer, old) = setup(); assert!(store.due(&db, &keys, now()).unwrap()); let first = store.prepare(&mut db, &keys, now()).unwrap(); let second = store.prepare(&mut db, &keys, now()).unwrap(); assert_eq!(first.version, second.version); assert_eq!(first.csr_pem, second.csr_pem); assert_eq!(keys.0.borrow().len(), 2); assert_eq!( store.current(&db, &keys, now()).unwrap().certificate_pem, old.as_bytes() ); let new = certificate( store.agent, &keys.read(first.version).unwrap(), &issuer, true, ); store .install(&mut db, &keys, &first, &reply(store.agent, &new), now()) .unwrap(); assert_eq!( store.current(&db, &keys, now()).unwrap().certificate_pem, new.as_bytes() ); assert_eq!(store.selector(&db).unwrap(), (first.version, None)); assert!( store .install(&mut db, &keys, &second, &reply(store.agent, &new), now()) .is_err() ); assert_eq!(keys.0.borrow().len(), 2); let values:Vec=db.prepare("SELECT coalesce(CAST(certificate AS TEXT),'') || coalesce(csr,'') FROM tls_versions").unwrap().query_map([],|r|r.get(0)).unwrap().collect::>().unwrap(); assert!(values.iter().all(|v| !v.contains("PRIVATE KEY"))); } #[test] fn bad_reply_preserves_current_pending_and_original_identity() { let (mut db, keys, store, issuer, old) = setup(); let pending = store.prepare(&mut db, &keys, now()).unwrap(); let key = keys.read(pending.version).unwrap(); let (_wrong_ca, wrong_issuer) = ca(); let wrong_key = KeyPair::generate().unwrap().serialize_pem(); for cert in [ certificate(Uuid::new_v4(), &key, &issuer, true), certificate(store.agent, wrong_key.as_bytes(), &issuer, true), certificate(store.agent, &key, &issuer, false), certificate(store.agent, &key, &wrong_issuer, true), ] { assert!( store .install(&mut db, &keys, &pending, &reply(store.agent, &cert), now()) .is_err() ); assert_eq!( store.current(&db, &keys, now()).unwrap().certificate_pem, old.as_bytes() ); assert_eq!( store.selector(&db).unwrap(), (Uuid::nil(), Some(pending.version)) ); } let valid = certificate(store.agent, &key, &issuer, true); assert!( store .install( &mut db, &keys, &pending, &reply(store.agent, &valid), now() + 11 * 86400 ) .is_err() ); assert!( store .install( &mut db, &keys, &pending, &reply(Uuid::new_v4(), &valid), now() ) .is_err() ); } #[test] fn committed_version_never_falls_back_to_legacy_on_restart_or_missing_key() { let (mut db, keys, store, issuer, old) = setup(); let pending = store.prepare(&mut db, &keys, now()).unwrap(); let valid = certificate( store.agent, &keys.read(pending.version).unwrap(), &issuer, true, ); store .install(&mut db, &keys, &pending, &reply(store.agent, &valid), now()) .unwrap(); store .initialize(&mut db, &keys, old.as_bytes(), now()) .unwrap(); assert_eq!(store.selector(&db).unwrap().0, pending.version); keys.0.borrow_mut().remove(&pending.version); assert!( store .initialize(&mut db, &keys, old.as_bytes(), now()) .is_err() ); assert!(store.current(&db, &keys, now()).is_err()); assert_eq!(store.selector(&db).unwrap().0, pending.version); assert!(keys.read(Uuid::nil()).is_ok()); } #[test] fn changed_pending_key_or_identity_cannot_create_a_second_request() { let (mut db, keys, store, _issuer, _old) = setup(); let pending = store.prepare(&mut db, &keys, now()).unwrap(); keys.0.borrow_mut().insert( pending.version, KeyPair::generate().unwrap().serialize_pem().into_bytes(), ); assert!(store.prepare(&mut db, &keys, now()).is_err()); assert_eq!(keys.0.borrow().len(), 2); let other = RotationStore::new(store.agent, 2, store.ca.clone()).unwrap(); assert!(other.current(&db, &keys, now()).is_err()); db.execute("DELETE FROM tls_rotation", []).unwrap(); assert!( store .initialize(&mut db, &keys, b"not a bootstrap", now()) .is_err() ); } #[test] fn journal_reopen_recovers_pending_before_hello_and_install_is_one_transaction() { let (_db, keys, store, issuer, old) = setup(); let directory = std::env::temp_dir().join(format!("rmm-tls-renewal-{}", Uuid::new_v4())); std::fs::create_dir(&directory).unwrap(); let mut journal = crate::journal::Journal::open(&directory).unwrap(); journal.pin_identity(&store.agent.to_string()).unwrap(); assert_eq!(journal.next_sequence().unwrap(), 1); store .initialize(journal.connection_mut(), &keys, old.as_bytes(), now()) .unwrap(); let pending = store .prepare(journal.connection_mut(), &keys, now()) .unwrap(); drop(journal); let mut journal = crate::journal::Journal::open(&directory).unwrap(); journal.pin_identity(&store.agent.to_string()).unwrap(); assert_eq!(journal.next_sequence().unwrap(), 2); assert!(store.has_pending(journal.connection()).unwrap()); let recovered = store .prepare(journal.connection_mut(), &keys, now()) .unwrap(); assert_eq!(pending.version, recovered.version); assert_eq!(pending.csr_pem, recovered.csr_pem); let new = certificate( store.agent, &keys.read(pending.version).unwrap(), &issuer, true, ); let response = reply(store.agent, &new); // Force the second SQL write to fail, after writing the certificate: // neither the cert nor selector may survive this aborted transaction. journal.connection().execute_batch("CREATE TEMP TRIGGER refuse_tls_commit BEFORE UPDATE OF current_version ON tls_rotation BEGIN SELECT RAISE(ABORT,'TEST_COMMIT_DENIED'); END;").unwrap(); assert!( store .install( journal.connection_mut(), &keys, &recovered, &response, now() ) .is_err() ); assert_eq!( store .current(journal.connection(), &keys, now()) .unwrap() .certificate_pem, old.as_bytes() ); let staged: Option> = journal .connection() .query_row( "SELECT certificate FROM tls_versions WHERE version=?1", [pending.version.to_string()], |r| r.get(0), ) .unwrap(); assert!(staged.is_none()); journal .connection() .execute_batch("DROP TRIGGER refuse_tls_commit;") .unwrap(); store .install( journal.connection_mut(), &keys, &recovered, &response, now(), ) .unwrap(); drop(journal); let journal = crate::journal::Journal::open(&directory).unwrap(); assert!(!store.has_pending(journal.connection()).unwrap()); assert_eq!( store .current(journal.connection(), &keys, now()) .unwrap() .certificate_pem, new.as_bytes() ); // 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(); } /// Deliberately selected fixture-only native I/O, never a default elevated /// operation. Uses the production KeyFiles implementation; no service, /// account, impersonation, installed state or network operation is involved. #[cfg(windows)] #[test] #[ignore = "explicit Windows administrator fixture; does not prove LocalService execution"] fn protected_key_files_create_new_reopen_acl_and_hardlink_guards() { use std::{fs, os::windows::ffi::OsStrExt, ptr}; use windows_sys::Win32::{ Foundation::LocalFree, Security::{ Authorization::ConvertStringSecurityDescriptorToSecurityDescriptorW, CheckTokenMembership, CreateWellKnownSid, SECURITY_ATTRIBUTES, WinBuiltinAdministratorsSid, }, Storage::FileSystem::CreateDirectoryW, }; // The current token must already be an administrator. This fixture // never obtains or substitutes a different principal's token. let mut admin = [0usize; 16]; let mut length = std::mem::size_of_val(&admin) as u32; let mut member = 0; assert!( unsafe { CreateWellKnownSid( WinBuiltinAdministratorsSid, ptr::null_mut(), admin.as_mut_ptr().cast(), &mut length, ) } != 0 ); assert!( unsafe { CheckTokenMembership(ptr::null_mut(), admin.as_mut_ptr().cast(), &mut member) } != 0 && member == 1 ); let service_sid = crate::native::service_sid().unwrap(); let create_directory = |path: &std::path::Path, broad: bool| { let sddl = format!( "O:BAG:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;{service_sid}){}", if broad { "(A;OICI;FR;;;BU)" } else { "" } ); let sddl: Vec = sddl.encode_utf16().chain(Some(0)).collect(); let mut descriptor = ptr::null_mut(); assert!( unsafe { ConvertStringSecurityDescriptorToSecurityDescriptorW( sddl.as_ptr(), 1, &mut descriptor, ptr::null_mut(), ) } != 0 ); let wide: Vec = path.as_os_str().encode_wide().chain(Some(0)).collect(); let attributes = SECURITY_ATTRIBUTES { nLength: std::mem::size_of::() as u32, lpSecurityDescriptor: descriptor, bInheritHandle: 0, }; let created = unsafe { CreateDirectoryW(wide.as_ptr(), &attributes) }; unsafe { LocalFree(descriptor.cast()); } assert!(created != 0, "fresh protected fixture directory required"); }; let root = std::env::temp_dir().join(format!("rmm-protected-key-fixture-{}", Uuid::new_v4())); create_directory(&root, false); // On failure retain this isolated case for the operator to inspect; // successful cleanup addresses only this newly created fixed namespace. let files = ProtectedKeyFiles::open(&root).unwrap(); // A broad ACL is tested only on an empty, separate fixture directory; // no private key is ever written there. let broad = root.join("broad-empty"); create_directory(&broad, true); let denied = match ProtectedKeyFiles::open(&broad) { Err(error) => error, Ok(_) => panic!("broad fixture DACL must be refused"), }; assert_eq!(denied.to_string(), "PRIVATE_PATH_BROAD_ACL"); fs::remove_dir(broad).unwrap(); let version = Uuid::new_v4(); let key = KeyPair::generate().unwrap(); let pem = key.serialize_pem(); files.create(version, pem.as_bytes()).unwrap(); let path = root.join(format!("device-{version}.key")); crate::native::private_path(&path, false).unwrap(); let read = files.read(version).unwrap(); // Never put private key bytes into assert_eq's panic formatter. assert!(read == pem.as_bytes(), "private key bytes changed"); let parsed = KeyPair::from_pem(std::str::from_utf8(&read).unwrap()).unwrap(); use sha2::{Digest, Sha256}; assert_eq!( Sha256::digest(parsed.public_key_raw()), Sha256::digest(key.public_key_raw()) ); let duplicate = files .create(version, b"must not replace the key") .unwrap_err(); assert_eq!( duplicate.downcast_ref::().unwrap().kind(), std::io::ErrorKind::AlreadyExists ); assert!(files.read(version).unwrap() == pem.as_bytes()); // The actual held directory handle must prevent rename while in use. assert!(fs::rename(&root, root.with_extension("renamed")).is_err()); drop(files); let files = ProtectedKeyFiles::open(&root).unwrap(); assert!(files.read(version).unwrap() == pem.as_bytes()); let link = root.join("own-fixture-hardlink"); fs::hard_link(&path, &link).unwrap(); let denied = match files.read(version) { Err(error) => error, Ok(_) => panic!("hardlinked private key must be refused"), }; assert_eq!(denied.to_string(), "ROTATION_FILE_TYPE_OR_LINKS"); fs::remove_file(link).unwrap(); assert!(files.read(version).unwrap() == pem.as_bytes()); drop(files); fs::remove_file(path).unwrap(); fs::remove_dir(root).unwrap(); } }