From 45b533705dd391afa460bf49fa2181aca7c69053 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 14:21:16 +0100 Subject: [PATCH] Prepare explicit Windows protected key file fixture test --- .../agent-windows/src/certificate_rotation.rs | 126 ++++++++++++++++++ docs/implementation-status.md | 8 ++ docs/windows-certificate-renewal.md | 35 +++++ 3 files changed, 169 insertions(+) diff --git a/crates/agent-windows/src/certificate_rotation.rs b/crates/agent-windows/src/certificate_rotation.rs index c8d618f..0005b25 100644 --- a/crates/agent-windows/src/certificate_rotation.rs +++ b/crates/agent-windows/src/certificate_rotation.rs @@ -703,4 +703,130 @@ mod tests { } 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(); + } } diff --git a/docs/implementation-status.md b/docs/implementation-status.md index 80a9abb..fc33d08 100644 --- a/docs/implementation-status.md +++ b/docs/implementation-status.md @@ -27,6 +27,14 @@ Nur portable Logik mit synthetischen KeyFiles, keine echte TLS-Rotation oder LocalService-Keydateiabnahme. Originalfehler und genaue Grenzen bleiben im verlinkten Bericht erhalten. +Zusätzlich vorbereitet, noch nicht nativ ausgeführt: eine ausdrücklich +auszuwählende Windows-Keydatei-Unit im bestehenden Lib-Testbinary. Sie prüft +geschütztes CreateNew/Flush/Reopen, öffentlichen Keyhash, Nichtüberschreiben, +breite DACL an leerer Fixture, gehaltenes Verzeichnis und Hardlinkablehnung. +Keine Dienste/Accounts/Tokenübernahme oder permanente Dateien betroffen. +Produktcode unverändert; ein Administratorlauf ersetzt keinen LocalService- +Nachweis. Default-`ignored` ist hier ein ausdrücklich offenes natives Gate. + ## Windowsfortsetzung: Nichtstart-Kern nativ qualifiziert — 2026-11-14 Der zusätzliche enge deny-only Nichtstart-Kern ist implementiert und mit diff --git a/docs/windows-certificate-renewal.md b/docs/windows-certificate-renewal.md index fbf4ae0..6d29836 100644 --- a/docs/windows-certificate-renewal.md +++ b/docs/windows-certificate-renewal.md @@ -128,3 +128,38 @@ Die Dateiflags folgen [CreateFileW](https://learn.microsoft.com/en-us/windows/wi 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). + +Eine weitere enge native Datei-I/O-Unit ist **vorbereitet, nicht ausgeführt**: +`certificate_rotation::tests::protected_key_files_create_new_reopen_acl_and_hardlink_guards`. +Sie steckt im vorhandenen Lib-Testbinary; kein zusätzliches Diagnostikbinary, +keine Tokenübernahme, Impersonation, Dienste oder Accounts. Wegen ihrer +expliziten Administrator-/Dateisystemwirkung ist sie im Defaultlauf als +`ignored` markiert und muss separat mit `--ignored --exact` ausgewählt werden. +Dies ist ein offenes natives Gate und wird nicht als bestandener Test gezählt. + +Die Unit verlangt bereits vorhandene Administratorrechte und die vorhandene +Agent-Service-SID, erstellt ausschließlich einen eigenen zufälligen Unterordner +im temporären Verzeichnis mit expliziter SYSTEM-/Administratoren-/Agent-SID-DACL +und nutzt darin den unveränderten `ProtectedKeyFiles`-Produktpfad. Sie prüft +CreateNew/Flush, die wirkliche geerbte DACL, bytegleiche Wiederöffnung samt +öffentlichem P-256-Keyhash, verweigertes Überschreiben, verweigertes Umbenennen +des gehaltenen Verzeichnisses und Hardlinkablehnung. Eine zu breite DACL wird +nur an einer separaten **leeren** eigenen Verzeichnisfixture geprüft. +Private Schlüsselbytes stehen weder in stdout noch in Assert-Debugausgaben. +Bei Erfolg entfernt sie ausschließlich ihre eigenen Fixturedateien und das +leere eigene Verzeichnis; ein Fehler lässt den isolierten Fall erhalten. + +Das belegt nach einem zukünftigen tatsächlichen Lauf nur Datei-I/O des bereits +vorhandenen Administratorprincipals und die geprüfte Service-SID-DACL. Die +produktive Ownerprüfung bleibt vollständig bestehen; ein unzulässiger +Dateieigentümer wird weiterhin verweigert. Tatsächliche LocalService-Erzeugung, +Wiederöffnung und erneutes Öffnen nach Prozessabbruch sind damit weiterhin +nicht nachgewiesen. Es wurde kein konkreter Produkt-I/O-Fehler nachgewiesen, +also kein Produktguard dafür verändert. Der Controller-/Dienstupgradeumfang +und die permanente Identität bleiben unberührt. + +Für diesen vorbereiteten Testschnitt tatsächlich lokal: Linux23/23 ohne +Filter, Windows-GNU-Lib `--no-run`, Windows-Alltargets-Clippy mit +`system-helper`/`-D warnings` und Workspacefmt bestanden. Noch kein neuer +Zielaufruf. Das vorbereitete Windows-Testbinary hat SHA256 +`cd385c3b8696303220d8e601768d70ac96a6e4187a14cbac9d511162a57eee5a`.