#![allow(unsafe_code)]
use std::ffi::{OsStr, c_void};
use std::io;
use std::os::windows::io::{AsRawHandle as _, FromRawHandle as _, OwnedHandle, RawHandle};
use shep_core::transport::PipeInstances;
use tokio::net::windows::named_pipe::{NamedPipeServer, ServerOptions};
use windows_sys::Win32::Foundation::{
CloseHandle, 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::JobObjects::{
AssignProcessToJobObject, CreateJobObjectW, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
JobObjectExtendedLimitInformation, SetInformationJobObject, TerminateJobObject,
};
use windows_sys::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};
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);
}
}
}
#[derive(Debug)]
pub(crate) struct Job(HANDLE);
unsafe impl Send for Job {}
unsafe impl Sync for Job {}
impl Job {
pub(crate) fn create() -> io::Result<Self> {
let handle = unsafe { CreateJobObjectW(core::ptr::null(), core::ptr::null()) };
if handle.is_null() {
return Err(io::Error::last_os_error());
}
let job = Self(handle);
let info: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = unsafe { core::mem::zeroed() };
let ok = unsafe {
SetInformationJobObject(
job.0,
JobObjectExtendedLimitInformation,
core::ptr::from_ref(&info).cast(),
u32::try_from(core::mem::size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>())
.expect("the size of a fixed Win32 struct fits in u32"),
)
};
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(job)
}
pub(crate) fn assign(&self, process: RawHandle) -> io::Result<()> {
let ok = unsafe { AssignProcessToJobObject(self.0, process as HANDLE) };
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
pub(crate) fn terminate(&self, exit_code: u32) -> io::Result<()> {
let ok = unsafe { TerminateJobObject(self.0, exit_code) };
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
}
impl Drop for Job {
fn drop(&mut self) {
unsafe {
let _ = CloseHandle(self.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);
}
}
}
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;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_empty_job_is_created_and_terminated_without_error() {
let job = Job::create().expect("a job object must be creatable");
job.terminate(1)
.expect("terminating a job with no members must succeed");
}
#[tokio::test]
async fn a_child_assigned_to_a_job_is_killed_by_terminate() {
let job = Job::create().unwrap();
let mut child = tokio::process::Command::new("cmd")
.args(["/C", "ping", "-n", "600", "127.0.0.1"])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null())
.spawn()
.expect("cmd must be spawnable on Windows");
let handle = child
.raw_handle()
.expect("a just-spawned child has a raw handle");
job.assign(handle).expect("assignment must succeed");
job.terminate(9).unwrap();
let status = tokio::time::timeout(std::time::Duration::from_secs(10), child.wait())
.await
.expect("a terminated job member must not outlive its job")
.unwrap();
assert!(
!status.success(),
"a job-terminated child must not report success"
);
}
}