Merge commit '45b533705dd391afa460bf49fa2181aca7c69053'
This commit is contained in:
@@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user