Add support for 32-bit processes

Author: radiantly

.github/workflows/build.yml

@@ -11,7 +11,13 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Build Project
-        run: cargo build --release
+        run: |
+          cargo build --release
+          cargo build --release -p payload --target i686-pc-windows-msvc
+
+      - name: Copy 32-bit binaries
+        shell: powershell
+        run: Copy-Item -Path .\target\i686-pc-windows-msvc\release\utils.dll -Destination .\target\release\utils32.dll
 
       - name: Generate zip bundle
         run: 7z a -tzip Invisiwind.zip .\hide.ahk .\target\release\*.dll .\target\release\*.exe

injector/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 clap = { version = "4.5.43", features = ["derive"] }
 crossbeam-channel = "0.5.15"
-dll-syringe = { version = "0.17.0", features = ["rpc-raw"] }
+dll-syringe = { version = "0.17.0", features = ["into-x86-from-x64", "rpc-raw"] }
 eframe = { version = "0.32.0", features = ["wgpu"] }
 egui_extras = "0.32.0"
 image = { version = "0.25.6", default-features = false, features = ["ico"]}

injector/src/cli.rs

@@ -90,7 +90,11 @@ pub fn start() {
 
     processes.into_iter().for_each(|(pid, process)| {
         if let Some(hwnds) = windows.remove(&pid) {
-            native::Injector::set_window_props(process, &hwnds, cli.hide_args.hide, None);
+            let result =
+                native::Injector::set_window_props(process, &hwnds, cli.hide_args.hide, None);
+            if let Err(err) = result {
+                print_error(format!("Error: {:?}", err));
+            }
         } else {
             print_error(format!(
                 "Cannot find any top level windows for pid {:?}",

injector/src/gui.rs

@@ -104,12 +104,14 @@ impl Gui {
                     }
                     InjectorWorkerEvent::PerformOp(pid, hwnd, hide_window, hide_from_taskbar) => {
                         println!("performing on op on {:?}", hwnd);
-                        native::Injector::set_window_props_with_pid(
+                        if let Err(error) = native::Injector::set_window_props_with_pid(
                             pid,
                             hwnd,
                             hide_window,
                             hide_from_taskbar,
-                        );
+                        ) {
+                            println!("Failed: {:?}", error);
+                        }
                     }
                 }
             }

injector/src/native.rs

@@ -1,9 +1,10 @@
 use dll_syringe::{
     Syringe,
-    process::OwnedProcess,
+    process::{BorrowedProcessModule, OwnedProcess, Process},
     rpc::{RawRpcFunctionPtr, RemoteRawProcedure},
 };
-use std::env;
+use std::error;
+use std::{env, path::PathBuf};
 use windows::{
     Win32::{
         Foundation::{HWND, LPARAM, TRUE, WPARAM},
@@ -185,62 +186,72 @@ pub fn get_top_level_windows() -> Vec<WindowInfo> {
 pub struct Injector {}
 
 impl Injector {
-    pub fn inject_and_get_remote_proc<F>(
-        syringe: &Syringe,
-        proc_name: &str,
-    ) -> RemoteRawProcedure<F>
-    where
-        F: RawRpcFunctionPtr,
-    {
-        let mut dll_path = env::current_exe().unwrap();
+    fn get_dll_path(process: &OwnedProcess) -> Result<PathBuf, Box<dyn error::Error>> {
+        let mut dll_path = env::current_exe()?;
         dll_path.pop();
-        dll_path.push("utils.dll");
 
-        let injected_payload = syringe.find_or_inject(dll_path).unwrap();
+        if cfg!(debug_assertions) && process.runs_under_wow64()? {
+            dll_path.push("../i686-pc-windows-msvc/debug/utils.dll");
+        } else if process.is_x86()? {
+            dll_path.push("utils32.dll");
+        } else {
+            dll_path.push("utils.dll");
+        }
+
+        Ok(dll_path)
+    }
 
-        return unsafe { syringe.get_raw_procedure::<F>(injected_payload, proc_name) }
-            .unwrap()
-            .unwrap();
+    pub fn get_remote_proc<F: RawRpcFunctionPtr>(
+        syringe: &Syringe,
+        module: BorrowedProcessModule<'_>,
+        proc_name: &str,
+    ) -> Result<RemoteRawProcedure<F>, Box<dyn error::Error>> {
+        match unsafe { syringe.get_raw_procedure::<F>(module, proc_name) }? {
+            Some(remote_proc) => Ok(remote_proc),
+            None => Err(format!("Failed to find procedure {}", proc_name).into()),
+        }
     }
 
     pub fn set_window_props(
         target_process: OwnedProcess,
         hwnds: &[u32],
         hide: bool,
         hide_from_taskbar: Option<bool>,
-    ) {
+    ) -> Result<(), Box<dyn error::Error>> {
+        let dll_path = Self::get_dll_path(&target_process)?;
         let syringe = Syringe::for_process(target_process);
+        let module = syringe.find_or_inject(dll_path)?;
 
-        let remote_proc = Self::inject_and_get_remote_proc::<extern "system" fn(HWND, bool) -> bool>(
+        let remote_proc = Self::get_remote_proc::<extern "system" fn(u32, bool) -> bool>(
             &syringe,
+            module,
             "SetWindowVisibility",
-        );
+        )?;
 
-        let remote_proc2 = Self::inject_and_get_remote_proc::<extern "system" fn(HWND, bool) -> bool>(
+        let remote_proc2 = Self::get_remote_proc::<extern "system" fn(u32, bool) -> bool>(
             &syringe,
+            module,
             "HideFromTaskbar",
-        );
+        )?;
 
         for hwnd in hwnds {
-            remote_proc
-                .call(HWND(hwnd.clone() as *mut _), hide)
-                .unwrap();
+            remote_proc.call(*hwnd, hide).unwrap();
 
             if let Some(hide_from_taskbar) = hide_from_taskbar {
-                remote_proc2
-                    .call(HWND(hwnd.clone() as *mut _), hide_from_taskbar)
-                    .unwrap();
+                remote_proc2.call(*hwnd, hide_from_taskbar).unwrap();
             }
         }
+        Ok(())
     }
 
     pub fn set_window_props_with_pid(
         pid: u32,
         hwnd: u32,
         hide: bool,
         hide_from_taskbar: Option<bool>,
-    ) {
-        let target_process = OwnedProcess::from_pid(pid).unwrap();
-        Self::set_window_props(target_process, &[hwnd], hide, hide_from_taskbar);
+    ) -> Result<(), Box<dyn error::Error>> {
+        let target_process = OwnedProcess::from_pid(pid)?;
+        Self::set_window_props(target_process, &[hwnd], hide, hide_from_taskbar)?;
+        Ok(())
     }
 }