#![allow(unsafe_code)]
use std::ffi::OsString;
use std::io;
use std::mem::{offset_of, size_of};
use std::os::windows::ffi::OsStringExt;
use std::path::Path;
use std::ptr;
use windows_sys::Win32::Foundation::{LocalFree, GENERIC_EXECUTE, GENERIC_READ, GENERIC_WRITE};
use windows_sys::Win32::Globalization::lstrlenW;
use windows_sys::Win32::Security::Authorization::{
ConvertSidToStringSidW, GetNamedSecurityInfoW, SetEntriesInAclW, SetNamedSecurityInfoW,
EXPLICIT_ACCESS_W, SET_ACCESS, SE_FILE_OBJECT, TRUSTEE_IS_GROUP, TRUSTEE_IS_SID, TRUSTEE_W,
};
use windows_sys::Win32::Security::Isolation::{
CreateAppContainerProfile, DeleteAppContainerProfile, DeriveAppContainerSidFromAppContainerName,
};
use windows_sys::Win32::Security::{
AclSizeInformation, CreateWellKnownSid, DeriveCapabilitySidsFromName, EqualSid, FreeSid,
GetAce, GetAclInformation, GetLengthSid, IsValidSid, MapGenericMask, WinBuiltinAnyPackageSid,
ACCESS_ALLOWED_ACE, ACL, ACL_SIZE_INFORMATION, CONTAINER_INHERIT_ACE,
DACL_SECURITY_INFORMATION, GENERIC_MAPPING, INHERIT_ONLY_ACE, OBJECT_INHERIT_ACE, PSID,
SECURITY_CAPABILITIES, SID_AND_ATTRIBUTES,
};
use windows_sys::Win32::Storage::FileSystem::{
DELETE, FILE_ALL_ACCESS, FILE_GENERIC_EXECUTE, FILE_GENERIC_READ, FILE_GENERIC_WRITE,
};
use windows_sys::Win32::System::SystemServices::{
ACCESS_ALLOWED_ACE_TYPE, ACCESS_DENIED_ACE_TYPE, SE_GROUP_ENABLED,
};
use crate::wide::wide_null;
const PROFILE_ALREADY_EXISTS: u32 = 0x8007_00b7;
pub struct AppContainerProfile {
sid: AppContainerSid,
_capabilities: Vec<DerivedCapability>,
capability_attributes: Vec<SID_AND_ATTRIBUTES>,
name: Vec<u16>,
created: bool,
}
unsafe impl Send for AppContainerProfile {}
unsafe impl Sync for AppContainerProfile {}
impl AppContainerProfile {
pub fn create_or_open(name: &str, display_name: &str, description: &str) -> io::Result<Self> {
Self::create_or_open_with_capabilities(name, display_name, description, &[])
}
pub fn create_or_open_with_capabilities(
name: &str,
display_name: &str,
description: &str,
capabilities: &[&str],
) -> io::Result<Self> {
let name_w = wide_null(name)?;
if name_w.len() > 65 || name.is_empty() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"AppContainer profile names must be 1 to 64 UTF-16 code units",
));
}
let display_w = wide_null(display_name)?;
let description_w = wide_null(description)?;
let mut derivations = Vec::with_capacity(capabilities.len());
for capability in capabilities {
derivations.push(DerivedCapability::from_name(capability)?);
}
let mut capability_attributes = Vec::new();
for derivation in &derivations {
capability_attributes.extend(derivation.capability_sids.iter().map(|sid| {
SID_AND_ATTRIBUTES {
Sid: *sid,
Attributes: SE_GROUP_ENABLED as u32,
}
}));
}
let mut sid = ptr::null_mut();
let result = unsafe {
CreateAppContainerProfile(
name_w.as_ptr(),
display_w.as_ptr(),
description_w.as_ptr(),
if capability_attributes.is_empty() {
ptr::null()
} else {
capability_attributes.as_ptr()
},
capability_attributes.len() as u32,
&mut sid,
)
};
let created = if result as u32 == PROFILE_ALREADY_EXISTS {
let derived =
unsafe { DeriveAppContainerSidFromAppContainerName(name_w.as_ptr(), &mut sid) };
if derived < 0 {
return Err(hresult_error(derived));
}
false
} else if result < 0 {
return Err(hresult_error(result));
} else {
true
};
if sid.is_null() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Windows returned a null AppContainer SID",
));
}
Ok(Self {
sid: AppContainerSid(sid),
_capabilities: derivations,
capability_attributes,
name: name_w,
created,
})
}
pub fn was_created(&self) -> bool {
self.created
}
pub fn delete(self) -> io::Result<()> {
let result = unsafe { DeleteAppContainerProfile(self.name.as_ptr()) };
if result < 0 {
return Err(hresult_error(result));
}
Ok(())
}
pub fn sid_string(&self) -> io::Result<String> {
let mut string = ptr::null_mut();
if unsafe { ConvertSidToStringSidW(self.sid.0, &mut string) } == 0 || string.is_null() {
return Err(io::Error::last_os_error());
}
let length = unsafe { lstrlenW(string) };
if length < 0 {
unsafe { LocalFree(string.cast()) };
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Windows returned an invalid SID string",
));
}
let value =
unsafe { OsString::from_wide(std::slice::from_raw_parts(string, length as usize)) };
unsafe { LocalFree(string.cast()) };
value
.into_string()
.map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "SID string was not Unicode"))
}
pub fn grant_path(&self, path: impl AsRef<Path>, access: AppContainerAccess) -> io::Result<()> {
grant_sid_access(path.as_ref(), self.sid.0, access)
}
pub fn ensure_path_access(
&self,
path: impl AsRef<Path>,
access: AppContainerAccess,
) -> io::Result<bool> {
let path = path.as_ref();
let dacl = path_dacl(path)?;
let Some(dacl) = dacl.dacl else {
return Ok(false);
};
let mut package_sid = [0_u32; 17];
let mut package_sid_bytes = std::mem::size_of_val(&package_sid) as u32;
if unsafe {
CreateWellKnownSid(
WinBuiltinAnyPackageSid,
ptr::null_mut(),
package_sid.as_mut_ptr().cast(),
&mut package_sid_bytes,
)
} == 0
{
return Err(io::Error::last_os_error());
}
let package_sid = package_sid.as_mut_ptr().cast();
let granted = container_rights(dacl, &[self.sid.0, package_sid])?;
let required = map_file_generic_mask(access_mask(access));
if granted & required == required {
return Ok(false);
}
grant_sid_access(path, self.sid.0, access)?;
Ok(true)
}
#[cfg(test)]
pub(crate) fn effective_path_rights(&self, path: &Path) -> io::Result<u32> {
let dacl = path_dacl(path)?;
match dacl.dacl {
Some(dacl) => container_rights(dacl, &[self.sid.0]),
None => Ok(FILE_ALL_ACCESS),
}
}
pub(crate) fn security_capabilities(&self) -> SECURITY_CAPABILITIES {
SECURITY_CAPABILITIES {
AppContainerSid: self.sid.0,
Capabilities: if self.capability_attributes.is_empty() {
ptr::null_mut()
} else {
self.capability_attributes.as_ptr().cast_mut()
},
CapabilityCount: self.capability_attributes.len() as u32,
Reserved: 0,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum AppContainerAccess {
Read,
ReadWrite,
ReadExecute,
ReadWriteExecute,
}
const fn access_mask(access: AppContainerAccess) -> u32 {
match access {
AppContainerAccess::Read => GENERIC_READ,
AppContainerAccess::ReadWrite => GENERIC_READ | GENERIC_WRITE | DELETE,
AppContainerAccess::ReadExecute => GENERIC_READ | GENERIC_EXECUTE,
AppContainerAccess::ReadWriteExecute => {
GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE
}
}
}
struct PathDacl {
dacl: Option<*mut ACL>,
_descriptor: LocalBlock,
}
fn path_dacl(path: &Path) -> io::Result<PathDacl> {
let path = wide_null(path.as_os_str())?;
let mut dacl: *mut ACL = ptr::null_mut();
let mut descriptor = ptr::null_mut();
let status = unsafe {
GetNamedSecurityInfoW(
path.as_ptr(),
SE_FILE_OBJECT,
DACL_SECURITY_INFORMATION,
ptr::null_mut(),
ptr::null_mut(),
&mut dacl,
ptr::null_mut(),
&mut descriptor,
)
};
if status != 0 {
return Err(io::Error::from_raw_os_error(status as i32));
}
Ok(PathDacl {
dacl: if dacl.is_null() { None } else { Some(dacl) },
_descriptor: LocalBlock(descriptor.cast()),
})
}
fn container_rights(dacl: *const ACL, sids: &[PSID]) -> io::Result<u32> {
let mut size = ACL_SIZE_INFORMATION::default();
if unsafe {
GetAclInformation(
dacl,
(&mut size as *mut ACL_SIZE_INFORMATION).cast(),
size_of::<ACL_SIZE_INFORMATION>() as u32,
AclSizeInformation,
)
} == 0
{
return Err(io::Error::last_os_error());
}
let sid_offset = offset_of!(ACCESS_ALLOWED_ACE, SidStart);
const SID_FIXED_BYTES: usize = 8;
let mut granted = 0_u32;
let mut denied = 0_u32;
for index in 0..size.AceCount {
let mut raw_ace = ptr::null_mut();
if unsafe { GetAce(dacl, index, &mut raw_ace) } == 0 {
return Err(io::Error::last_os_error());
}
if raw_ace.is_null() {
return Err(invalid_acl("Windows returned a null ACE"));
}
let ace = raw_ace.cast::<ACCESS_ALLOWED_ACE>();
let header = unsafe { (*ace).Header };
if u32::from(header.AceFlags) & INHERIT_ONLY_ACE != 0 {
continue;
}
let kind = u32::from(header.AceType);
if kind != ACCESS_ALLOWED_ACE_TYPE && kind != ACCESS_DENIED_ACE_TYPE {
continue;
}
let ace_size = usize::from(header.AceSize);
if ace_size < sid_offset + SID_FIXED_BYTES {
return Err(invalid_acl("an access ACE is too short for its SID"));
}
let sid = unsafe { raw_ace.cast::<u8>().add(sid_offset).cast() };
if unsafe { IsValidSid(sid) } == 0 {
return Err(invalid_acl("an access ACE contains an invalid SID"));
}
let sid_length = unsafe { GetLengthSid(sid) } as usize;
if sid_length > ace_size - sid_offset {
return Err(invalid_acl("an access ACE SID exceeds the ACE"));
}
let matches = sids.iter().any(|expected| {
if expected.is_null() {
return false;
}
unsafe { EqualSid(*expected, sid) != 0 }
});
if !matches {
continue;
}
let mask = map_file_generic_mask(unsafe { (*ace).Mask });
if kind == ACCESS_ALLOWED_ACE_TYPE {
granted |= mask & !denied;
} else {
denied |= mask & !granted;
}
}
Ok(granted)
}
fn invalid_acl(message: &str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, message)
}
fn map_file_generic_mask(mut mask: u32) -> u32 {
const FILE_MAPPING: GENERIC_MAPPING = GENERIC_MAPPING {
GenericRead: FILE_GENERIC_READ,
GenericWrite: FILE_GENERIC_WRITE,
GenericExecute: FILE_GENERIC_EXECUTE,
GenericAll: FILE_ALL_ACCESS,
};
unsafe { MapGenericMask(&mut mask, &FILE_MAPPING) };
mask
}
fn grant_sid_access(path: &Path, sid: PSID, access: AppContainerAccess) -> io::Result<()> {
let path = wide_null(path.as_os_str())?;
let mut old_dacl: *mut ACL = ptr::null_mut();
let mut descriptor = ptr::null_mut();
let status = unsafe {
GetNamedSecurityInfoW(
path.as_ptr(),
SE_FILE_OBJECT,
DACL_SECURITY_INFORMATION,
ptr::null_mut(),
ptr::null_mut(),
&mut old_dacl,
ptr::null_mut(),
&mut descriptor,
)
};
if status != 0 {
return Err(io::Error::from_raw_os_error(status as i32));
}
let _descriptor = LocalBlock(descriptor.cast());
let entry = EXPLICIT_ACCESS_W {
grfAccessPermissions: access_mask(access),
grfAccessMode: SET_ACCESS,
grfInheritance: OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
Trustee: TRUSTEE_W {
pMultipleTrustee: ptr::null_mut(),
MultipleTrusteeOperation: 0,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_GROUP,
ptstrName: sid.cast(),
},
};
let mut new_dacl: *mut ACL = ptr::null_mut();
let status = unsafe { SetEntriesInAclW(1, &entry, old_dacl, &mut new_dacl) };
if status != 0 {
return Err(io::Error::from_raw_os_error(status as i32));
}
let _new_dacl = LocalBlock(new_dacl.cast());
let status = unsafe {
SetNamedSecurityInfoW(
path.as_ptr().cast_mut(),
SE_FILE_OBJECT,
DACL_SECURITY_INFORMATION,
ptr::null_mut(),
ptr::null_mut(),
new_dacl,
ptr::null_mut(),
)
};
if status != 0 {
return Err(io::Error::from_raw_os_error(status as i32));
}
Ok(())
}
fn hresult_error(hr: i32) -> io::Error {
if ((hr as u32 >> 16) & 0x1fff) == 7 {
io::Error::from_raw_os_error((hr as u32 & 0xffff) as i32)
} else {
io::Error::other(format!("HRESULT 0x{:08X}", hr as u32))
}
}
struct LocalBlock(*mut std::ffi::c_void);
impl Drop for LocalBlock {
fn drop(&mut self) {
unsafe { LocalFree(self.0) };
}
}
impl std::fmt::Debug for AppContainerProfile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AppContainerProfile")
.field("sid", &self.sid)
.field("capability_count", &self.capability_attributes.len())
.field("created", &self.created)
.finish()
}
}
struct AppContainerSid(PSID);
impl std::fmt::Debug for AppContainerSid {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_tuple("AppContainerSid").field(&self.0).finish()
}
}
impl Drop for AppContainerSid {
fn drop(&mut self) {
unsafe { FreeSid(self.0) };
}
}
pub(crate) struct DerivedCapability {
capability_sids: Vec<PSID>,
capability_array: *mut PSID,
group_sids: Vec<PSID>,
group_array: *mut PSID,
}
impl DerivedCapability {
pub(crate) fn from_name(name: &str) -> io::Result<Self> {
let name = wide_null(name)?;
if name.len() <= 1 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"capability names must not be empty",
));
}
let mut group_array = ptr::null_mut();
let mut group_count = 0_u32;
let mut capability_array = ptr::null_mut();
let mut capability_count = 0_u32;
if unsafe {
DeriveCapabilitySidsFromName(
name.as_ptr(),
&mut group_array,
&mut group_count,
&mut capability_array,
&mut capability_count,
)
} == 0
{
let error = io::Error::last_os_error();
if !group_array.is_null() {
unsafe { LocalFree(group_array.cast()) };
}
if !capability_array.is_null() {
unsafe { LocalFree(capability_array.cast()) };
}
return Err(error);
}
let capability_sids = if capability_count == 0 || capability_array.is_null() {
Vec::new()
} else {
unsafe { std::slice::from_raw_parts(capability_array, capability_count as usize) }
.to_vec()
};
let group_sids = if group_count == 0 || group_array.is_null() {
Vec::new()
} else {
unsafe { std::slice::from_raw_parts(group_array, group_count as usize) }.to_vec()
};
let derived = Self {
capability_sids,
capability_array,
group_sids,
group_array,
};
if capability_count == 0 || capability_array.is_null() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Windows resolved no capability SIDs",
));
}
Ok(derived)
}
pub(crate) fn capability_sids(&self) -> &[PSID] {
&self.capability_sids
}
}
impl Drop for DerivedCapability {
fn drop(&mut self) {
for sid in self.capability_sids.iter().chain(&self.group_sids) {
if !sid.is_null() {
unsafe { LocalFree((*sid).cast()) };
}
}
if !self.capability_array.is_null() {
unsafe { LocalFree(self.capability_array.cast()) };
}
if !self.group_array.is_null() {
unsafe { LocalFree(self.group_array.cast()) };
}
}
}
const _: () = {
const fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<AppContainerProfile>();
assert_send_sync::<crate::Launch<'static>>();
};
#[cfg(test)]
mod tests {
use super::hresult_error;
#[test]
fn win32_hresult_preserves_the_win32_error_code() {
let error = hresult_error(0x8007_0005_u32 as i32);
assert_eq!(error.raw_os_error(), Some(5));
assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
}
#[test]
fn non_win32_hresult_keeps_its_hexadecimal_identity() {
let error = hresult_error(0x8000_ffff_u32 as i32);
assert_eq!(error.raw_os_error(), None);
assert!(error.to_string().contains("HRESULT 0x8000FFFF"));
}
}