Windows shell replacement in Rust: taskbar, file manager, NTFS search, task manager, disk cleaner. One installer exe.
Rust
//! Тонкие обёртки над Win32: службы, приоритет/ядра/suspend, запуск от администратора, системный диспетчер задач.
use std::{collections::HashMap, ptr::null_mut};
use winapi::um::{
errhandlingapi::GetLastError,
handleapi::CloseHandle,
processthreadsapi::{GetPriorityClass, OpenProcess, SetPriorityClass},
winbase::{
ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS, GetProcessAffinityMask, HIGH_PRIORITY_CLASS,
IDLE_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS,
},
winnt::{HANDLE, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_SET_INFORMATION, SERVICE_WIN32},
winsvc::*,
};
fn wide(s: &str) -> Vec<u16> {
s.encode_utf16().chain(Some(0)).collect()
}
unsafe fn from_wide(p: *const u16) -> String {
if p.is_null() {
return String::new();
}
let mut n = 0;
unsafe {
while *p.add(n) != 0 {
n += 1;
}
String::from_utf16_lossy(std::slice::from_raw_parts(p, n))
}
}
// ---------- службы ----------
pub struct Svc {
pub name: String,
pub display: String,
pub pid: u32,
pub running: bool,
}
pub fn services() -> Vec<Svc> {
let mut out = vec![];
unsafe {
let scm = OpenSCManagerW(std::ptr::null(), std::ptr::null(), SC_MANAGER_ENUMERATE_SERVICE);
if scm.is_null() {
return out;
}
let (mut need, mut cnt, mut resume) = (0u32, 0u32, 0u32);
let enumerate = |buf: *mut u8, len: u32, need: &mut u32, cnt: &mut u32, resume: &mut u32| {
EnumServicesStatusExW(
scm, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, SERVICE_STATE_ALL, buf, len, need, cnt, resume, std::ptr::null(),
)
};
enumerate(null_mut(), 0, &mut need, &mut cnt, &mut resume); // узнаём нужный размер
let mut buf = vec![0u64; need as usize / 8 + 1024]; // u64 — для выравнивания структур
resume = 0;
if enumerate(buf.as_mut_ptr() as *mut u8, (buf.len() * 8) as u32, &mut need, &mut cnt, &mut resume) != 0 {
let arr = buf.as_ptr() as *const ENUM_SERVICE_STATUS_PROCESSW;
for i in 0..cnt as usize {
let e = &*arr.add(i);
out.push(Svc {
name: from_wide(e.lpServiceName),
display: from_wide(e.lpDisplayName),
pid: e.ServiceStatusProcess.dwProcessId,
running: e.ServiceStatusProcess.dwCurrentState == SERVICE_RUNNING,
});
}
}
CloseServiceHandle(scm);
}
out
}
/// Запуск/остановка службы. Err — код ошибки Win32 (5 = нет прав).
pub fn service_ctl(name: &str, start: bool) -> Result<(), u32> {
unsafe {
let scm = OpenSCManagerW(std::ptr::null(), std::ptr::null(), SC_MANAGER_CONNECT);
if scm.is_null() {
return Err(GetLastError());
}
let n = wide(name);
let svc = OpenServiceW(scm, n.as_ptr(), if start { SERVICE_START } else { SERVICE_STOP });
let res = if svc.is_null() {
Err(GetLastError())
} else {
let ok = if start {
StartServiceW(svc, 0, null_mut())
} else {
let mut st: SERVICE_STATUS = std::mem::zeroed();
ControlService(svc, SERVICE_CONTROL_STOP, &mut st)
};
let r = if ok != 0 { Ok(()) } else { Err(GetLastError()) };
CloseServiceHandle(svc);
r
};
CloseServiceHandle(scm);
res
}
}
// ---------- управление процессом ----------
fn with_proc<T>(pid: u32, access: u32, f: impl FnOnce(HANDLE) -> T) -> Option<T> {
unsafe {
let h = OpenProcess(access, 0, pid);
if h.is_null() {
return None;
}
let r = f(h);
CloseHandle(h);
Some(r)
}
}
pub static PRIORITIES: std::sync::LazyLock<[(&'static str, u32); 5]> = std::sync::LazyLock::new(|| [
(t!("Низкий", "Low"), IDLE_PRIORITY_CLASS),
(t!("Ниже среднего", "Below normal"), BELOW_NORMAL_PRIORITY_CLASS),
(t!("Обычный", "Normal"), NORMAL_PRIORITY_CLASS),
(t!("Выше среднего", "Above normal"), ABOVE_NORMAL_PRIORITY_CLASS),
(t!("Высокий", "High"), HIGH_PRIORITY_CLASS),
]);
pub fn set_priority(pid: u32, class: u32) -> bool {
with_proc(pid, PROCESS_SET_INFORMATION, |h| unsafe { SetPriorityClass(h, class) != 0 }).unwrap_or(false)
}
pub fn priority_name(pid: u32) -> String {
let c = with_proc(pid, PROCESS_QUERY_LIMITED_INFORMATION, |h| unsafe { GetPriorityClass(h) }).unwrap_or(0);
PRIORITIES.iter().find(|p| p.1 == c).map_or("—".into(), |p| p.0.into())
}
/// `half = true` — только первая половина логических ядер, иначе все.
pub fn set_affinity(pid: u32, half: bool) -> bool {
with_proc(pid, PROCESS_SET_INFORMATION | PROCESS_QUERY_LIMITED_INFORMATION, |h| unsafe {
let (mut pm, mut sm) = (0usize, 0usize);
if GetProcessAffinityMask(h, &mut pm, &mut sm) == 0 {
return false;
}
let cores = sm.count_ones();
let mask = if half && cores > 1 { first_n_bits(sm, cores / 2) } else { sm };
SetProcessAffinityMask64(h, mask) != 0
})
.unwrap_or(false)
}
/// Первые n установленных бит маски.
fn first_n_bits(mask: usize, n: u32) -> usize {
let (mut out, mut left) = (0usize, n);
for b in 0..usize::BITS {
if left == 0 {
break;
}
if mask >> b & 1 == 1 {
out |= 1 << b;
left -= 1;
}
}
out
}
#[link(name = "kernel32")]
unsafe extern "system" {
// winapi 0.3 declares the mask as a 32-bit DWORD; the real parameter is a pointer-sized DWORD_PTR
#[link_name = "SetProcessAffinityMask"]
fn SetProcessAffinityMask64(h: HANDLE, mask: usize) -> i32;
}
#[link(name = "shell32")]
unsafe extern "system" {
fn IsUserAnAdmin() -> i32;
}
#[link(name = "ntdll")]
unsafe extern "system" {
fn NtSuspendProcess(h: HANDLE) -> i32;
fn NtResumeProcess(h: HANDLE) -> i32;
}
pub fn suspend(pid: u32, on: bool) -> bool {
with_proc(pid, 0x0800 /*PROCESS_SUSPEND_RESUME*/, |h| unsafe {
(if on { NtSuspendProcess(h) } else { NtResumeProcess(h) }) >= 0
})
.unwrap_or(false)
}
// ---------- администратор ----------
pub fn is_admin() -> bool {
unsafe { IsUserAnAdmin() != 0 }
}
/// Запускает запланированную задачу `rtaskmgr` (её регистрирует установщик, уровень "Highest"): та же программа
/// с правами администратора и без окна UAC. false — задачи нет или она не запустилась.
pub fn run_elevated_task() -> bool {
use std::os::windows::process::CommandExt;
std::process::Command::new("schtasks").args(["/run", "/tn", "rtaskmgr"]).creation_flags(0x0800_0000).status().is_ok_and(|s| s.success())
}
/// Запускает себя заново с запросом UAC и аргументами `args`. true — пользователь согласился.
pub fn relaunch_as_admin(args: &str) -> bool {
let Ok(exe) = std::env::current_exe() else { return false };
let (verb, path, params) = (wide("runas"), wide(&exe.to_string_lossy()), wide(args));
unsafe { winapi::um::shellapi::ShellExecuteW(null_mut(), verb.as_ptr(), path.as_ptr(), params.as_ptr(), std::ptr::null(), 1) as usize > 32 }
}
// ---------- системный диспетчер задач ----------
/// Запуск через IFEO: Windows передаёт первым аргументом путь к taskmgr.exe, дальше — его собственные аргументы
/// (например `/0 /startup` из «Параметров»). Возвращает эти аргументы; None — нас запустили напрямую.
pub fn taskmgr_args(args: &[String]) -> Option<String> {
let first = args.first()?;
first.to_lowercase().trim_matches('"').ends_with("taskmgr.exe").then(|| args[1..].join(" "))
}
/// Создаёт процесс под отладкой и сразу отпускает: такой запуск проходит мимо IFEO "Debugger".
/// Возвращает (дескриптор процесса, код ошибки CreateProcess).
fn spawn_past_ifeo(exe: &str, cmdline: &str) -> Result<HANDLE, u32> {
use winapi::um::{debugapi::DebugActiveProcessStop, processthreadsapi::*, winbase::{DEBUG_ONLY_THIS_PROCESS, DebugSetProcessKillOnExit}};
unsafe {
let mut si: STARTUPINFOW = std::mem::zeroed();
si.cb = std::mem::size_of::<STARTUPINFOW>() as u32;
let mut pi: PROCESS_INFORMATION = std::mem::zeroed();
let mut cmd = wide(cmdline);
let ok = CreateProcessW(wide(exe).as_ptr(), cmd.as_mut_ptr(), null_mut(), null_mut(), 0, DEBUG_ONLY_THIS_PROCESS, null_mut(), null_mut(), &mut si, &mut pi);
if ok == 0 {
return Err(GetLastError());
}
DebugSetProcessKillOnExit(0); // our exit must not take it down
DebugActiveProcessStop(pi.dwProcessId);
CloseHandle(pi.hThread);
Ok(pi.hProcess)
}
}
/// Открывает настоящий диспетчер задач Windows (обходя наш собственный IFEO-перехват, иначе снова запустились бы мы).
/// Без прав администратора Taskmgr.exe не стартует (ERROR_ELEVATION_REQUIRED): тогда просим UAC для себя
/// с `--real-taskmgr` и делаем это уже оттуда; `elevate` = false не даёт этому зациклиться.
pub fn start_real_taskmgr(args: &str, elevate: bool) -> bool {
let root = std::env::var("SystemRoot").unwrap_or_else(|_| r"C:\Windows".into());
let exe = format!(r"{root}\System32\Taskmgr.exe");
match spawn_past_ifeo(&exe, &format!("\"{exe}\" {args}")) {
Ok(h) => {
unsafe { CloseHandle(h) };
true
}
Err(740) if elevate => relaunch_as_admin(&format!("--real-taskmgr {args}")),
Err(_) => false,
}
}
/// Включена ли тёмная тема приложений в Windows.
pub fn system_dark() -> bool {
let (key, val) = (wide(r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize"), wide("AppsUseLightTheme"));
let (mut data, mut size) = (1u32, 4u32);
let rc = unsafe {
winapi::um::winreg::RegGetValueW(
winapi::um::winreg::HKEY_CURRENT_USER,
key.as_ptr(),
val.as_ptr(),
0x10, // RRF_RT_REG_DWORD
null_mut(),
&mut data as *mut u32 as *mut _,
&mut size,
)
};
rc == 0 && data == 0
}
#[link(name = "dwmapi")]
unsafe extern "system" {
fn DwmSetWindowAttribute(h: winapi::shared::windef::HWND, attr: u32, v: *const std::ffi::c_void, size: u32) -> i32;
}
/// Тёмная/светлая рамка и заголовок окна.
pub fn set_dark_titlebar(h: winapi::shared::windef::HWND, dark: bool) {
let v = dark as i32;
unsafe { DwmSetWindowAttribute(h, 20 /*DWMWA_USE_IMMERSIVE_DARK_MODE*/, &v as *const i32 as *const _, 4) };
}
/// Заголовки видимых окон верхнего уровня по PID (без окон-владельцев и без пустых заголовков).
pub fn window_titles() -> HashMap<u32, String> {
use winapi::shared::{minwindef::{BOOL, LPARAM}, windef::HWND};
use winapi::um::winuser::{EnumWindows, GetWindow, GetWindowTextW, GetWindowThreadProcessId, IsWindowVisible, GW_OWNER};
unsafe extern "system" fn cb(h: HWND, l: LPARAM) -> BOOL {
unsafe {
let map = &mut *(l as *mut HashMap<u32, String>);
if IsWindowVisible(h) == 0 || !GetWindow(h, GW_OWNER).is_null() {
return 1;
}
let mut buf = [0u16; 256];
let n = GetWindowTextW(h, buf.as_mut_ptr(), 256);
if n > 0 {
let mut pid = 0u32;
GetWindowThreadProcessId(h, &mut pid);
map.entry(pid).or_insert_with(|| String::from_utf16_lossy(&buf[..n as usize]));
}
}
1
}
let mut map: HashMap<u32, String> = HashMap::new();
unsafe { EnumWindows(Some(cb), &mut map as *mut _ as LPARAM) };
map
}
/// Режим эффективности: низкий приоритет + энергосбережение (EcoQoS). `on = false` возвращает обычный режим.
pub fn set_efficiency(pid: u32, on: bool) -> bool {
#[link(name = "kernel32")]
unsafe extern "system" {
fn SetProcessInformation(h: HANDLE, class: i32, info: *const std::ffi::c_void, size: u32) -> i32;
}
#[repr(C)]
struct Throttle {
version: u32,
control: u32,
state: u32,
}
with_proc(pid, PROCESS_SET_INFORMATION, |h| unsafe {
let t = Throttle { version: 1, control: 1 /*EXECUTION_SPEED*/, state: on as u32 };
let a = SetProcessInformation(h, 4 /*ProcessPowerThrottling*/, &t as *const _ as *const _, std::mem::size_of::<Throttle>() as u32) != 0;
let b = SetPriorityClass(h, if on { IDLE_PRIORITY_CLASS } else { NORMAL_PRIORITY_CLASS }) != 0;
a || b
})
.unwrap_or(false)
}
/// Локальное время: (год, месяц, день, час, минута, секунда).
pub fn local_time() -> (u16, u16, u16, u16, u16, u16) {
unsafe {
let mut t: winapi::um::minwinbase::SYSTEMTIME = std::mem::zeroed();
winapi::um::sysinfoapi::GetLocalTime(&mut t);
(t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn taskmgr_args_from_ifeo() {
let a = |v: &[&str]| taskmgr_args(&v.iter().map(|s| s.to_string()).collect::<Vec<_>>());
assert_eq!(a(&["C:\\WINDOWS\\system32\\taskmgr.exe", "/0", "/startup"]).as_deref(), Some("/0 /startup"));
assert_eq!(a(&["\"C:\\Windows\\System32\\Taskmgr.exe\""]).as_deref(), Some(""));
assert_eq!(a(&["--tray"]), None);
assert_eq!(a(&[]), None);
}
#[test]
fn debug_spawn_is_released_and_runs_to_its_end() {
use winapi::um::{processthreadsapi::GetExitCodeProcess, synchapi::WaitForSingleObject};
let cmd = std::env::var("ComSpec").unwrap();
let h = spawn_past_ifeo(&cmd, &format!("\"{cmd}\" /c exit 7")).expect("spawn");
let mut code = 0u32;
unsafe {
assert_eq!(WaitForSingleObject(h, 10_000), 0, "a process we did not let go would hang here");
GetExitCodeProcess(h, &mut code);
CloseHandle(h);
}
assert_eq!(code, 7);
}
#[test]
fn first_bits() {
assert_eq!(first_n_bits(0b1111_0000, 2), 0b0011_0000);
assert_eq!(first_n_bits(0b1111, 4), 0b1111);
assert_eq!(first_n_bits(usize::MAX, 40), (1usize << 40) - 1); // ядра за пределами 32-го бита
}
}
/// Учётная запись, от имени которой запущен процесс: «Пользователь» или «ДОМЕН\Пользователь» для чужих.
/// Для защищённых системных процессов токен недоступен — возвращает None (вызывающий считает их системными).
pub fn process_user(pid: u32) -> Option<String> {
use winapi::um::{processthreadsapi::OpenProcessToken, securitybaseapi::GetTokenInformation, winbase::LookupAccountSidW, winnt::{TOKEN_QUERY, TOKEN_USER}};
with_proc(pid, PROCESS_QUERY_LIMITED_INFORMATION, |h| unsafe {
let mut tok: HANDLE = null_mut();
if OpenProcessToken(h, TOKEN_QUERY, &mut tok) == 0 {
return None;
}
let mut buf = [0u64; 64]; // u64: TOKEN_USER holds pointers, a byte array is not aligned for it
let mut need = 0u32;
let ok = GetTokenInformation(tok, 1 /*TokenUser*/, buf.as_mut_ptr() as *mut _, size_of_val(&buf) as u32, &mut need) != 0;
CloseHandle(tok);
if !ok {
return None;
}
let sid = (*(buf.as_ptr() as *const TOKEN_USER)).User.Sid;
let (mut nl, mut dl, mut ty) = (256u32, 256u32, 0u32);
let (mut name, mut dom) = ([0u16; 256], [0u16; 256]);
if LookupAccountSidW(null_mut(), sid, name.as_mut_ptr(), &mut nl, dom.as_mut_ptr(), &mut dl, &mut ty) == 0 {
return None;
}
let (n, dm) = (String::from_utf16_lossy(&name[..nl as usize]), String::from_utf16_lossy(&dom[..dl as usize]));
let local = std::env::var("COMPUTERNAME").unwrap_or_default();
Some(if dm.is_empty() || dm.eq_ignore_ascii_case(&local) || dm.eq_ignore_ascii_case("NT AUTHORITY") { n } else { format!("{dm}\\{n}") })
})
.flatten()
}
// ---------- диагностика ----------
/// Сумма по всем ядрам: (время ЦП всего, DPC, прерывания), в 100-нс единицах.
pub type CpuTimes = (i64, i64, i64);
pub fn cpu_times() -> Option<CpuTimes> {
#[link(name = "ntdll")]
unsafe extern "system" {
fn NtQuerySystemInformation(class: u32, info: *mut std::ffi::c_void, len: u32, ret: *mut u32) -> i32;
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct Spi {
idle: i64,
kernel: i64, // включает idle
user: i64,
dpc: i64,
interrupt: i64,
count: u32,
}
let mut buf = vec![Spi::default(); 1024];
let mut ret = 0u32;
let st = unsafe { NtQuerySystemInformation(8 /*SystemProcessorPerformanceInformation*/, buf.as_mut_ptr() as *mut _, (buf.len() * size_of::<Spi>()) as u32, &mut ret) };
if st < 0 {
return None;
}
let n = ret as usize / size_of::<Spi>();
Some(buf[..n].iter().fold((0, 0, 0), |a, c| (a.0 + c.kernel + c.user, a.1 + c.dpc, a.2 + c.interrupt)))
}
/// (DPC %, прерывания %) между двумя замерами.
pub fn dpc_share(a: CpuTimes, b: CpuTimes) -> (f32, f32) {
let total = (b.0 - a.0) as f64;
if total <= 0.0 {
return (0.0, 0.0);
}
(((b.1 - a.1) as f64 / total * 100.0) as f32, ((b.2 - a.2) as f64 / total * 100.0) as f32)
}
/// Видимые окна верхнего уровня, которые Windows считает зависшими (не обрабатывают сообщения 5 с).
pub fn hung_windows() -> Vec<(u32, String)> {
use winapi::shared::{minwindef::{BOOL, LPARAM}, windef::HWND};
use winapi::um::winuser::{EnumWindows, GetWindow, GetWindowTextW, GetWindowThreadProcessId, IsHungAppWindow, IsWindowVisible, GW_OWNER};
unsafe extern "system" fn cb(h: HWND, l: LPARAM) -> BOOL {
unsafe {
let v = &mut *(l as *mut Vec<(u32, String)>);
if IsWindowVisible(h) != 0 && GetWindow(h, GW_OWNER).is_null() && IsHungAppWindow(h) != 0 {
let mut buf = [0u16; 256];
let n = GetWindowTextW(h, buf.as_mut_ptr(), 256).max(0) as usize;
let mut pid = 0u32;
GetWindowThreadProcessId(h, &mut pid);
if n > 0 && !v.iter().any(|x| x.0 == pid) {
v.push((pid, String::from_utf16_lossy(&buf[..n])));
}
}
}
1
}
let mut v: Vec<(u32, String)> = vec![];
unsafe { EnumWindows(Some(cb), &mut v as *mut _ as LPARAM) };
v
}
// ---------- запуск с обычными правами ----------
/// Запускает `cmdline` с токеном процесса-донора из нашего сеанса (sihost.exe: есть всегда и работает без повышения).
/// Иначе программа, закрытая профилем и запущенная обратно отсюда, унаследовала бы права администратора.
pub fn run_unelevated(donors: &[u32], cmdline: &str) -> bool {
use winapi::um::{
processthreadsapi::{OpenProcessToken, PROCESS_INFORMATION, ProcessIdToSessionId, STARTUPINFOW},
securitybaseapi::DuplicateTokenEx,
winnt::{SecurityImpersonation, TOKEN_ASSIGN_PRIMARY, TOKEN_DUPLICATE, TOKEN_QUERY, TokenPrimary, MAXIMUM_ALLOWED},
};
#[link(name = "advapi32")]
unsafe extern "system" {
fn CreateProcessWithTokenW(tok: HANDLE, logon: u32, app: *const u16, cmd: *mut u16, flags: u32, env: *mut std::ffi::c_void, dir: *const u16, si: *mut STARTUPINFOW, pi: *mut PROCESS_INFORMATION) -> i32;
}
let mut mine = 0u32;
unsafe { ProcessIdToSessionId(std::process::id(), &mut mine) };
for &pid in donors {
let mut s = u32::MAX;
if unsafe { ProcessIdToSessionId(pid, &mut s) } == 0 || s != mine {
continue;
}
let ok = with_proc(pid, PROCESS_QUERY_LIMITED_INFORMATION, |h| unsafe {
let mut tok: HANDLE = null_mut();
if OpenProcessToken(h, TOKEN_DUPLICATE | TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY, &mut tok) == 0 {
return false;
}
let mut prim: HANDLE = null_mut();
let dup = DuplicateTokenEx(tok, MAXIMUM_ALLOWED, null_mut(), SecurityImpersonation, TokenPrimary, &mut prim) != 0;
CloseHandle(tok);
if !dup {
return false;
}
let mut si: STARTUPINFOW = std::mem::zeroed();
si.cb = size_of::<STARTUPINFOW>() as u32;
let mut pi: PROCESS_INFORMATION = std::mem::zeroed();
let mut cmd = wide(cmdline);
let r = CreateProcessWithTokenW(prim, 0, std::ptr::null(), cmd.as_mut_ptr(), 0x0400 /*CREATE_UNICODE_ENVIRONMENT*/, null_mut(), std::ptr::null(), &mut si, &mut pi) != 0;
if r {
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
CloseHandle(prim);
r
});
if ok == Some(true) {
return true;
}
}
false
}
#[cfg(test)]
mod diag_tests {
use super::*;
#[test]
fn dpc_share_and_times() {
assert_eq!(dpc_share((0, 0, 0), (1000, 20, 10)), (2.0, 1.0));
assert_eq!(dpc_share((5, 0, 0), (5, 1, 1)), (0.0, 0.0));
let t = cpu_times().expect("NtQuerySystemInformation(8)");
assert!(t.0 > 0 && t.1 >= 0 && t.2 >= 0);
let _ = hung_windows();
}
}
/// Завершает процесс (TerminateProcess).
pub fn kill(pid: u32) -> bool {
use winapi::um::{processthreadsapi::TerminateProcess, winnt::PROCESS_TERMINATE};
with_proc(pid, PROCESS_TERMINATE, |h| unsafe { TerminateProcess(h, 1) != 0 }).unwrap_or(false)
}