Prepare explicit Windows protected key file fixture test
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 14:21:16 +01:00
parent 5d6d5b4c01
commit 45b533705d
3 changed files with 169 additions and 0 deletions
@@ -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<u16> = 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<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
let attributes = SECURITY_ATTRIBUTES {
nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() 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::<std::io::Error>().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();
}
}
+8
View File
@@ -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
+35
View File
@@ -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`.