#![allow(unsafe_code)]
use std::ffi::{OsStr, OsString};
use std::io;
use std::mem::size_of;
use std::os::windows::ffi::OsStringExt;
use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle, OwnedHandle, RawHandle};
use std::path::{Path, PathBuf};
use std::ptr;
use std::time::Duration;
use windows_sys::Win32::Foundation::{
DuplicateHandle, DUPLICATE_SAME_ACCESS, ERROR_INSUFFICIENT_BUFFER, FILETIME, STILL_ACTIVE,
};
use windows_sys::Win32::Security::{
EqualSid, GetTokenInformation, TokenCapabilities, TokenElevation, TokenIsAppContainer,
SID_AND_ATTRIBUTES, TOKEN_ELEVATION, TOKEN_GROUPS, TOKEN_QUERY,
};
use windows_sys::Win32::Storage::FileSystem::SYNCHRONIZE;
use windows_sys::Win32::System::Threading::{
GetExitCodeProcess, GetProcessId, GetProcessTimes, OpenProcess, OpenProcessToken,
QueryFullProcessImageNameW, TerminateProcess, PROCESS_NAME_WIN32,
PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_TERMINATE,
};
use windows_sys::Win32::UI::Shell::{ShellExecuteExW, SEE_MASK_NOCLOSEPROCESS, SHELLEXECUTEINFOW};
use windows_sys::Win32::UI::WindowsAndMessaging::SW_HIDE;
use crate::app_container::DerivedCapability;
use crate::handle::{current_process, owned_from_creation, wait, WaitOutcome};
use crate::launch::command_line_tail;
use crate::wide::wide_null;
const MAX_IMAGE_PATH_UNITS: usize = 32_768;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum ProcessAccess {
QueryLimited,
Synchronize,
QueryLimitedAndSynchronize,
Terminate,
AsCreated,
}
impl ProcessAccess {
fn rights(self) -> u32 {
match self {
Self::QueryLimited => PROCESS_QUERY_LIMITED_INFORMATION,
Self::Synchronize => SYNCHRONIZE,
Self::QueryLimitedAndSynchronize => PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE,
Self::Terminate => PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE | PROCESS_TERMINATE,
Self::AsCreated => 0,
}
}
}
#[derive(Debug)]
pub struct Process {
handle: OwnedHandle,
access: ProcessAccess,
}
impl Process {
pub fn open(pid: u32, access: ProcessAccess) -> io::Result<Self> {
if access == ProcessAccess::AsCreated {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"full access is only available on a process this one created",
));
}
let handle = unsafe { OpenProcess(access.rights(), 0, pid) };
Ok(Self {
handle: owned_from_creation(handle)?,
access,
})
}
pub fn from_child(child: &std::process::Child) -> io::Result<Self> {
let mut duplicate = ptr::null_mut();
let duplicated = unsafe {
DuplicateHandle(
current_process(),
child.as_raw_handle(),
current_process(),
&mut duplicate,
0,
0,
DUPLICATE_SAME_ACCESS,
)
};
if duplicated == 0 {
return Err(io::Error::last_os_error());
}
Ok(Self {
handle: owned_from_creation(duplicate)?,
access: ProcessAccess::AsCreated,
})
}
pub fn launch_elevated<I, S>(executable: &Path, arguments: I) -> io::Result<Self>
where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
{
let arguments: Vec<OsString> = arguments
.into_iter()
.map(|argument| argument.as_ref().to_owned())
.collect();
let verb = wide_null("runas")?;
let file = wide_null(executable)?;
let parameters = command_line_tail(&arguments)?;
let mut info = SHELLEXECUTEINFOW {
cbSize: size_of::<SHELLEXECUTEINFOW>() as u32,
fMask: SEE_MASK_NOCLOSEPROCESS,
lpVerb: verb.as_ptr(),
lpFile: file.as_ptr(),
lpParameters: parameters.as_ptr(),
nShow: SW_HIDE,
..Default::default()
};
if unsafe { ShellExecuteExW(&mut info) } == 0 {
return Err(io::Error::last_os_error());
}
if info.hProcess.is_null() {
return Err(io::Error::other(
"the shell started the target without returning a process handle",
));
}
Ok(Self {
handle: owned_from_creation(info.hProcess)?,
access: ProcessAccess::AsCreated,
})
}
pub(crate) fn from_owned(handle: OwnedHandle, access: ProcessAccess) -> Self {
Self { handle, access }
}
pub fn access(&self) -> ProcessAccess {
self.access
}
pub fn pid(&self) -> io::Result<u32> {
let pid = unsafe { GetProcessId(self.raw()) };
if pid == 0 {
return Err(io::Error::last_os_error());
}
Ok(pid)
}
pub fn creation_time(&self) -> io::Result<u64> {
let mut creation = FILETIME::default();
let mut exit = FILETIME::default();
let mut kernel = FILETIME::default();
let mut user = FILETIME::default();
let queried = unsafe {
GetProcessTimes(self.raw(), &mut creation, &mut exit, &mut kernel, &mut user)
};
if queried == 0 {
return Err(io::Error::last_os_error());
}
Ok((u64::from(creation.dwHighDateTime) << 32) | u64::from(creation.dwLowDateTime))
}
pub fn exit_code(&self) -> io::Result<Option<u32>> {
let mut exit_code = 0_u32;
if unsafe { GetExitCodeProcess(self.raw(), &mut exit_code) } == 0 {
return Err(io::Error::last_os_error());
}
if exit_code == STILL_ACTIVE as u32 {
match wait(self, Some(Duration::ZERO)) {
Ok(WaitOutcome::Signaled | WaitOutcome::Abandoned) => {}
Ok(WaitOutcome::TimedOut) | Err(_) => return Ok(None),
}
}
Ok(Some(exit_code))
}
pub fn is_app_container(&self) -> io::Result<bool> {
let mut token = ptr::null_mut();
if unsafe { OpenProcessToken(self.handle.as_raw_handle(), TOKEN_QUERY, &mut token) } == 0 {
return Err(io::Error::last_os_error());
}
let token = owned_from_creation(token)?;
let mut is_app_container = 0_u32;
let mut returned = 0_u32;
if unsafe {
GetTokenInformation(
token.as_raw_handle(),
TokenIsAppContainer,
(&mut is_app_container as *mut u32).cast(),
size_of::<u32>() as u32,
&mut returned,
)
} == 0
{
return Err(io::Error::last_os_error());
}
if returned as usize != size_of::<u32>() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Windows returned a truncated AppContainer token flag",
));
}
Ok(is_app_container != 0)
}
pub fn has_capability(&self, name: &str) -> io::Result<bool> {
if !self.is_app_container()? {
return Ok(false);
}
let required = DerivedCapability::from_name(name)?;
let held = token_capability_sids(self)?;
Ok(required.capability_sids().iter().all(|required_sid| {
!required_sid.is_null()
&& held.iter().any(|held_sid| {
let held_sid = held_sid.as_ptr().cast_mut().cast();
unsafe { EqualSid(*required_sid, held_sid) != 0 }
})
}))
}
pub fn image_path(&self) -> io::Result<PathBuf> {
let mut buffer = vec![0_u16; MAX_IMAGE_PATH_UNITS];
let mut length = buffer.len() as u32;
let queried = unsafe {
QueryFullProcessImageNameW(
self.raw(),
PROCESS_NAME_WIN32,
buffer.as_mut_ptr(),
&mut length,
)
};
if queried == 0 {
return Err(io::Error::last_os_error());
}
if length == 0 || length as usize >= buffer.len() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"process image path length is out of range",
));
}
buffer.truncate(length as usize);
Ok(PathBuf::from(OsString::from_wide(&buffer)))
}
pub fn session_id(&self) -> io::Result<u32> {
crate::session::process_session_id(self.pid()?)
}
pub fn terminate(&self, exit_code: u32) -> io::Result<()> {
if unsafe { TerminateProcess(self.raw(), exit_code) } == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
pub fn wait(&self, timeout: Option<Duration>) -> io::Result<WaitOutcome> {
wait(self, timeout)
}
fn raw(&self) -> RawHandle {
self.handle.as_raw_handle()
}
}
pub(crate) fn token_capability_sids(process: &Process) -> io::Result<Vec<Vec<u32>>> {
let mut raw_token = ptr::null_mut();
if unsafe { OpenProcessToken(process.raw(), TOKEN_QUERY, &mut raw_token) } == 0 {
return Err(io::Error::last_os_error());
}
let token = owned_from_creation(raw_token)?;
let mut needed = 0_u32;
let probed = unsafe {
GetTokenInformation(
token.as_raw_handle(),
TokenCapabilities,
ptr::null_mut(),
0,
&mut needed,
)
};
let probe_error = io::Error::last_os_error();
if probed != 0 || probe_error.raw_os_error() != Some(ERROR_INSUFFICIENT_BUFFER as i32) {
return Err(probe_error);
}
if needed < size_of::<u32>() as u32 {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"TokenCapabilities buffer is shorter than its group count",
));
}
let words = (needed as usize).div_ceil(size_of::<usize>());
let mut storage = vec![0_usize; words];
let capacity = storage.len() * size_of::<usize>();
if unsafe {
GetTokenInformation(
token.as_raw_handle(),
TokenCapabilities,
storage.as_mut_ptr().cast(),
needed,
&mut needed,
)
} == 0
{
return Err(io::Error::last_os_error());
}
if needed as usize > capacity || needed < size_of::<u32>() as u32 {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"TokenCapabilities result exceeds its buffer",
));
}
let count = unsafe { *storage.as_ptr().cast::<u32>() as usize };
if count == 0 {
return Ok(Vec::new());
}
let groups_offset = std::mem::offset_of!(TOKEN_GROUPS, Groups);
let groups_bytes = count
.checked_mul(size_of::<SID_AND_ATTRIBUTES>())
.and_then(|bytes| groups_offset.checked_add(bytes))
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidData,
"TokenCapabilities group count overflows",
)
})?;
if groups_bytes > needed as usize {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"TokenCapabilities group array exceeds its buffer",
));
}
let entries_pointer = unsafe { storage.as_ptr().cast::<u8>().add(groups_offset) };
let entries =
unsafe { std::slice::from_raw_parts(entries_pointer.cast::<SID_AND_ATTRIBUTES>(), count) };
let bytes =
unsafe { std::slice::from_raw_parts(storage.as_ptr().cast::<u8>(), needed as usize) };
entries
.iter()
.map(|entry| copy_sid_from_token_buffer(entry.Sid, bytes))
.collect()
}
fn copy_sid_from_token_buffer(sid: *mut std::ffi::c_void, buffer: &[u8]) -> io::Result<Vec<u32>> {
const SID_FIXED_BYTES: usize = 8;
let offset = (sid as usize)
.checked_sub(buffer.as_ptr() as usize)
.filter(|offset| *offset <= buffer.len().saturating_sub(SID_FIXED_BYTES))
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidData,
"a token capability SID lies outside the returned buffer",
)
})?;
let sub_authorities = usize::from(buffer[offset + 1]);
let length = sub_authorities
.checked_mul(size_of::<u32>())
.and_then(|bytes| SID_FIXED_BYTES.checked_add(bytes))
.filter(|length| {
offset
.checked_add(*length)
.is_some_and(|end| end <= buffer.len())
})
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidData,
"a token capability SID exceeds the returned buffer",
)
})?;
let mut copy = vec![0_u32; length.div_ceil(size_of::<u32>())];
let copy_bytes = unsafe {
std::slice::from_raw_parts_mut(
copy.as_mut_ptr().cast::<u8>(),
copy.len() * size_of::<u32>(),
)
};
copy_bytes[..length].copy_from_slice(&buffer[offset..offset + length]);
Ok(copy)
}
impl AsHandle for Process {
fn as_handle(&self) -> BorrowedHandle<'_> {
self.handle.as_handle()
}
}
impl AsRawHandle for Process {
fn as_raw_handle(&self) -> RawHandle {
self.raw()
}
}
impl From<Process> for OwnedHandle {
fn from(process: Process) -> Self {
process.handle
}
}
pub fn is_elevated() -> io::Result<bool> {
let mut token = ptr::null_mut();
if unsafe { OpenProcessToken(current_process(), TOKEN_QUERY, &mut token) } == 0 {
return Err(io::Error::last_os_error());
}
let token = owned_from_creation(token)?;
token_is_elevated(token.as_raw_handle())
}
pub(crate) fn token_is_elevated(token: RawHandle) -> io::Result<bool> {
let mut elevation = TOKEN_ELEVATION::default();
let mut returned = 0_u32;
let queried = unsafe {
GetTokenInformation(
token,
TokenElevation,
(&mut elevation as *mut TOKEN_ELEVATION).cast(),
size_of::<TOKEN_ELEVATION>() as u32,
&mut returned,
)
};
if queried == 0 {
return Err(io::Error::last_os_error());
}
Ok(elevation.TokenIsElevated != 0)
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use windows_sys::Win32::Foundation::ERROR_INVALID_PARAMETER;
use super::{is_elevated, Process, ProcessAccess};
use crate::handle::WaitOutcome;
#[test]
fn the_current_process_opens_and_reports_its_identity() {
let process = Process::open(std::process::id(), ProcessAccess::QueryLimited).unwrap();
assert_eq!(process.pid().unwrap(), std::process::id());
assert_eq!(process.exit_code().unwrap(), None);
assert!(process.creation_time().unwrap() > 0);
assert_eq!(
process.image_path().unwrap(),
std::env::current_exe().unwrap()
);
}
#[test]
fn full_access_cannot_be_requested_by_pid() {
let error = Process::open(std::process::id(), ProcessAccess::AsCreated).unwrap_err();
assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
}
#[test]
fn a_vanished_pid_reports_invalid_parameter() {
let error = Process::open(u32::MAX - 2, ProcessAccess::QueryLimited).unwrap_err();
assert_eq!(error.raw_os_error(), Some(ERROR_INVALID_PARAMETER as i32));
}
#[test]
fn a_std_child_is_adopted_with_its_creation_rights() {
let mut child = std::process::Command::new("cmd")
.args(["/d", "/c", "exit 5"])
.spawn()
.unwrap();
let process = Process::from_child(&child).unwrap();
assert_eq!(process.access(), ProcessAccess::AsCreated);
assert_eq!(
process.wait(Some(Duration::from_secs(30))).unwrap(),
WaitOutcome::Signaled
);
assert_eq!(process.exit_code().unwrap(), Some(5));
child.wait().unwrap();
}
#[test]
fn elevation_is_readable() {
is_elevated().unwrap();
}
}