https://github.com/devlooped/injector
Allows injecting .NET code into another Windows process
https://github.com/devlooped/injector
Last synced: about 1 year ago
JSON representation
Allows injecting .NET code into another Windows process
- Host: GitHub
- URL: https://github.com/devlooped/injector
- Owner: devlooped
- License: mit
- Created: 2022-04-18T15:51:39.000Z (about 4 years ago)
- Default Branch: main
- Last Pushed: 2024-05-26T01:07:20.000Z (about 2 years ago)
- Last Synced: 2024-05-28T11:57:55.573Z (about 2 years ago)
- Language: C++
- Size: 150 KB
- Stars: 12
- Watchers: 2
- Forks: 1
- Open Issues: 3
-
Metadata Files:
- Readme: readme.md
- Changelog: changelog.md
- License: license.txt
Awesome Lists containing this project
README
 .NET Injector
============
[](https://www.nuget.org/packages/Devlooped.Injector)
[](https://www.nuget.org/packages/Devlooped.Injector)
[](https://github.com//devlooped/Injector/blob/main/license.txt)
[](https://github.com/devlooped/Injector/actions)
Allows injecting .NET code into any Windows process.
Heavily based on [Cory Plott](http://www.cplotts.com)'s [Snoop](https://github.com/cplotts/snoopwpf).
The only requirement is that the injected code must be a public static method on a public static
class, such as:
```csharp
namespace Sample;
public static class Startup
{
public static void Start(string arg1, int arg2, bool debug)
{
if (debug)
Debugger.Launch();
// do stuff with arg1, arg2, etc.
// note args are typed :)
}
}
```
> NOTE: parameter type conversion is supported and happens via the `TypeConverter` associated with the
parameter type.
## Usage
There are two main usages for this package:
* From AnyCPU code: your code is bitness-agnostic and can be injected into
the target process whether it's x86 or x64.
* From x86/x64 code: you are injecting into a target process that has the same
bitness as the calling code.
### AnyCPU code
This is likely the more common scenario. You have .NET code that is AnyCPU and can
therefore be injected regardless of the target process bitness. When referencing this
package, you will get two (content) folders containing a helper `Injector.exe` for each architecture:
These files are automatically copied to the output directory under `Injector\[x86|x64]\Injector.exe`
(and are also included when doing `dotnet publish`). This allows you to run the relevant executable
that matches the target process bitness.
`Injector.exe` usage:
```
> Injector.exe -?
Usage: Injector.exe
Arguments:
IntPtr of the main window handle of the process to inject, i.e. Process.MainWindowHandle.
The full path to the .NET assembly to load in the remote process.
Full type name of the public static class to invoke in the remote process.
Name of the static method in that class to invoke in the remote process. Must be a
static method, which can also receive arguments, such as 'Start:true:42'.
```
To detect the target process bitness, you can use the following bit of interop:
```csharp
static class NativeMethods
{
[DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool IsWow64Process([In] IntPtr process, [Out] out bool wow64Process);
}
```
And the following code would lookup the target process (in this case, we just get the first instance
of `devenv.exe`, the Visual Studio main process, as an example), and invoke the right executable:
```csharp
var targetProcess = System.Diagnostics.Process.GetProcessesByName("devenv.exe")[0];
NativeMethods.IsWow64Process(targetProcess.Handle, out var isWow);
var platform = isWow ? "x86" : "x64";
Process.Start(Path.Combine("Injector", platform, "Injector.exe"),
// IntPtr of the main window handle of the process to inject
targetProcess.MainWindowHandle + " " +
// The full path to the .NET assembly to load in the remote process
Assembly.GetExecutingAssembly().Location + " " +
// Full type name of the public static class to invoke in the remote process
typeof(Startup).FullName + " " +
// Name of the static method in that class to invoke in the remote process,
// and any parameters.
$"{nameof(Startup.Start)}:hello:42:true");
```
> NOTE: we can pass typed arguments to the `Startup.Start` method (shown as an example
> at the beginning) and type conversion will be applied automatically.
### Platform-specific code
When building platform-specific code, the project would typically have (for a console app, for example):
```xml
Exe
net6.0
x64;x86
```
You would then build for either platform via: `dotnet build --arch x64` or `dotnet build --arch x86`.
In this case, the bitness of the calling code (that intends to inject itself into a remote process)
must match the target process bitness too. Since the bitness of both is the same, you can use the
automatically referenced assembly from your code, rather than invoking the helper `Injector.exe`
as shown in the first case.
The code will otherwise look similar to the previous case:
```csharp
var targetProcess = System.Diagnostics.Process.GetProcessesByName("devenv.exe")[0];
// NOTE: target process bitness must match our own assembly architecture for
// this to succeed.
Devlooped.Injector.Launch(
// IntPtr of the main window handle of the process to inject
targetProcess.MainWindowHandle,
// The full path to the .NET assembly to load in the remote process
Assembly.GetExecutingAssembly().Location,
// Full type name of the public static class to invoke in the remote process
typeof(Startup).FullName,
// Name of the static method in that class to invoke in the remote process,
// and any parameters.
$"{nameof(Startup.Start)}:hello:42:true");
```
> NOTE: the `Devlooped.Injector` type will NOT be available on AnyCPU projects
See [Program.cs](src/Sample/Program.cs) for a complete example.
# Sponsors
[](https://github.com/clarius)
[](https://github.com/KirillOsenkov)
[](https://github.com/MFB-Technologies-Inc)
[](https://github.com/decriptor)
[](https://github.com/torutek-gh)
[](https://github.com/drivenet)
[](https://github.com/AshleyMedway)
[](https://github.com/Keflon)
[](https://github.com/tbolon)
[](https://github.com/kfrancis)
[](https://github.com/twenzel)
[](https://github.com/Giorgi)
[](https://github.com/unoplatform)
[](https://github.com/dansiegel)
[](https://github.com/rbnswartz)
[](https://github.com/jfoshee)
[](https://github.com/Mrxx99)
[](https://github.com/eajhnsn1)
[](https://github.com/IxTechnologies)
[](https://github.com/davidjenni)
[](https://github.com/Jonathan-Hickey)
[](https://github.com/okyrylchuk)
[](https://github.com/akunzai)
[](https://github.com/jakobt)
[](https://github.com/seanalexander)
[](https://github.com/tinohager)
[](https://github.com/ploeh)
[](https://github.com/KenBonny)
[](https://github.com/SimonCropp)
[](https://github.com/agileworks-eu)
[](https://github.com/sorahex)
[](https://github.com/arsdragonfly)
[](https://github.com/vezel-dev)
[](https://github.com/ChilliCream)
[](https://github.com/4OTC)
[](https://github.com/sponsors/devlooped)
[Learn more about GitHub Sponsors](https://github.com/sponsors)