detours-redirecting-csharp-methods-at-runtime

[giscus[bot]]

detours-redirecting-csharp-methods-at-runtime

Detours are a way to replace the implementation of a C# method. Basically, you take a method (typically from some assembly you don’t have the source for) and overwrite it with a jmp to your own implementation.

https://tryfinally.dev/detours-redirecting-csharp-methods-at-runtime

[BazookaMusic]

Ideas for wrapping the function:

1. Use a disposable object to set/unset the function address within a scope. Might need a lock for this to be thread-safe.
2. Replace a function with another function that checks a register or some data structure to see if a function pointer is set. If set, jump to that (the override function), else jump to the original location. Threads that want to call the override functions should update the register or data structure with the jump location before calling the function.

[apkd]

Nice, thanks! I'll have to play around with this.

[RonSijm]

It's a very interesting approach, but I'm wondering, instead of doing all of this - wouldn't it be simpler to just create a small program that runs something like reflexil (or another weaver), and then make every method public virtual? (I used to do it like that manually using JustDecompile if I wanted to patch something specific)

After that you can replace the objects with a Castle DynamicProxy of the object - (especially if the project is already using dependency injection) and then add an IInterceptor to the methods that you want to "Detour". You can skip the invocation completely, or you can use the IInterceptor as a decorator to add behavior or re-write the return objects

[apkd]

Hey, a couple of use cases off the top of my head:

• Patching/extending the Unity Editor via UPM packages. You don't have access to editor assemblies at the package level, and with detours you can easily deploy an editor mod to the rest of your team (or even just make it easily installable via the package manager).
• Publishing game mods. In case of Rimworld, Steam Workshop won't allow you to modify the core game assemblies, but mods can ship additional assemblies that are loaded at startup. Multiple mods can be using detours simultaneously and they'll be compatible with each other as long as they don't try to mess with the same logic. (And even when they do, they can be made compatible if the mod developers work with each other, or if detours are applied by some base modding library to expose the functionality in an extendable manner.)

I do think assembly weaving might be a better solution where the use cases overlap, though. Unity does have a first-party Cecil package that can be used to do similar stuff, eg. patch assemblies from installed packages, but I'm about... 85% certain... that you still don't get to mess with UnityEngine.dll/UnityEditor.dll. Bringing in the entire assembly post-processing pipeline also somewhat affects in-editor compilation times (and by extension, code iteration time), and detours are blazing fast in comparison.

[apkd]

I just noticed that my post has made it to Reddit (thanks!), and somebody mentioned a list of .NET detouring libraries that they maintain. Anyway, I'll just leave this here: https://github.com/jzabroski/Home/tree/master/TechRadar#function-detouring--function-hooking

[wewrere41]

Hi. I wondered what is difference between your solution and this solution. Can you explain?
https://stackoverflow.com/a/65051169/11040772