#![allow(unsafe_code)]
use std::ffi::{OsStr, c_void};
use std::io;
use std::os::windows::io::{AsRawHandle as _, FromRawHandle as _, OwnedHandle};
use shep_core::transport::PipeInstances;
use tokio::net::windows::named_pipe::{NamedPipeServer, ServerOptions};
use windows_sys::Win32::Foundation::{
HANDLE, HANDLE_FLAG_INHERIT, LocalFree, SetHandleInformation,
};
use windows_sys::Win32::Security::Authorization::{
ConvertSidToStringSidW, ConvertStringSecurityDescriptorToSecurityDescriptorW, SDDL_REVISION_1,
};
use windows_sys::Win32::Security::{
GetTokenInformation, PSID, SECURITY_ATTRIBUTES, TOKEN_QUERY, TOKEN_USER, TokenUser,
};
use windows_sys::Win32::System::Console::{
GetStdHandle, STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
};
use windows_sys::Win32::System::Threading::{
GetCurrentProcess, OpenProcess, OpenProcessToken, PROCESS_TERMINATE, TerminateProcess,
};
pub fn seal_std_handles() {
for id in [STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE] {
let handle = unsafe { GetStdHandle(id) };
if handle.is_null() || handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
continue;
}
unsafe {
let _ = SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
}
}
}
pub(crate) struct UserOnly {
descriptor: *mut c_void,
}
unsafe impl Send for UserOnly {}
unsafe impl Sync for UserOnly {}
impl core::fmt::Debug for UserOnly {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("UserOnly").finish_non_exhaustive()
}
}
impl UserOnly {
pub(crate) fn current_user() -> io::Result<Self> {
let sid = current_user_sid()?;
let mut sddl: Vec<u16> = "D:P(A;;GA;;;".encode_utf16().collect();
sddl.extend_from_slice(&sid);
sddl.extend(")\0".encode_utf16());
let mut descriptor: *mut c_void = core::ptr::null_mut();
let ok = unsafe {
ConvertStringSecurityDescriptorToSecurityDescriptorW(
sddl.as_ptr(),
SDDL_REVISION_1,
&raw mut descriptor,
core::ptr::null_mut(),
)
};
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(Self { descriptor })
}
}
impl PipeInstances for UserOnly {
fn create(&self, options: &ServerOptions, addr: &OsStr) -> io::Result<NamedPipeServer> {
let mut attributes = SECURITY_ATTRIBUTES {
nLength: u32::try_from(core::mem::size_of::<SECURITY_ATTRIBUTES>())
.expect("the size of a fixed Win32 struct fits in u32"),
lpSecurityDescriptor: self.descriptor,
bInheritHandle: 0,
};
unsafe { options.create_with_security_attributes_raw(addr, (&raw mut attributes).cast()) }
}
}
impl Drop for UserOnly {
fn drop(&mut self) {
unsafe {
let _ = LocalFree(self.descriptor);
}
}
}
pub(crate) fn terminate_process(pid: u32, exit_code: u32) -> io::Result<()> {
let handle = unsafe { OpenProcess(PROCESS_TERMINATE, 0, pid) };
if handle.is_null() {
return Err(io::Error::last_os_error());
}
let handle = unsafe { OwnedHandle::from_raw_handle(handle) };
if unsafe { TerminateProcess(handle.as_raw_handle(), exit_code) } == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
fn current_user_sid() -> io::Result<Vec<u16>> {
let mut token: HANDLE = core::ptr::null_mut();
let opened = unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &raw mut token) };
if opened == 0 {
return Err(io::Error::last_os_error());
}
let token = unsafe { OwnedHandle::from_raw_handle(token) };
let mut needed = 0_u32;
unsafe {
GetTokenInformation(
token.as_raw_handle(),
TokenUser,
core::ptr::null_mut(),
0,
&raw mut needed,
);
}
if needed == 0 {
return Err(io::Error::last_os_error());
}
let mut buffer = vec![0_u64; usize::try_from(needed).unwrap_or(0).div_ceil(8)];
let filled = unsafe {
GetTokenInformation(
token.as_raw_handle(),
TokenUser,
buffer.as_mut_ptr().cast(),
needed,
&raw mut needed,
)
};
if filled == 0 {
return Err(io::Error::last_os_error());
}
let sid = unsafe { (*buffer.as_ptr().cast::<TOKEN_USER>()).User.Sid };
unsafe { sid_to_wide(sid) }
}
unsafe fn sid_to_wide(sid: PSID) -> io::Result<Vec<u16>> {
let mut text: *mut u16 = core::ptr::null_mut();
let converted = unsafe { ConvertSidToStringSidW(sid, &raw mut text) };
if converted == 0 {
return Err(io::Error::last_os_error());
}
let mut len = 0;
while unsafe { *text.add(len) } != 0 {
len += 1;
}
let wide = unsafe { core::slice::from_raw_parts(text, len) }.to_vec();
unsafe {
let _ = LocalFree(text.cast());
}
Ok(wide)
}
#[cfg(test)]
mod pipe_security_tests;