Feature Request: Support for Mid-Function Hooking Without Parameter Qualification

[AlexAdasCca]

Description

First, thank you for creating such an excellent hooking library. I've spent some time learning how to use DynoHook, which works well in most scenarios. However, I was wondering if there's a way to use it without specifying an ICallingConvention with parameter qualification.

In certain cases where we don't need to specify function parameters (e.g., when hooking mid-execution flow at a specific code location rather than at function entry), DynoHook doesn't appear to support this use case optimally.

Proposed Use Case: Mid-Function Hooking

1. Use Zydis + user-defined signatures(scan code) to identify hook locations (typically before call or jmp instructions)
2. Hook exactly once at the target location without affecting all call points
3. Pass a lambda callback that can:
   • Access pre-interrupt context (registers/stack pointers)
   • Flexibly modify original function behavior

Reference Implementation

This technique (known as mid-function hooking) is implemented in the SafetyHook project, which was designed with this capability in mind. An excellent article detailing this approach can be found here: SafetyHook: Mid-Function Hooking - Aixxe's Blog

SafetyHook repository: https://github.com/cursey/safetyhook

Feature Request

Could mid-function hooking support be added to DynoHook? I'd appreciate your insights on:

• Implementation feasibility
• Potential design approaches
• Roadmap considerations

Once again, thank you for maintaining DynoHook — it's a fantastic project, and I really appreciate your work!

[qubka]

@AlexAdasCca Hey, sorry for the extremely late reply — it’s been quite a while since I last looked at DynoHook.

That’s a really interesting feature idea, and I have to say, mid-function hooking is a pretty cool and powerful concept. SafetyHook’s approach with Zydis and context manipulation is a solid reference for that kind of low-level control.

That said, I’m currently not actively developing new features for DynoHook. I no longer use it in my own projects, mainly because its design relies on mutexes for thread safety, which comes with some performance overhead in high-frequency hook scenarios.

For my current work, I built a new hooking library as part of my Plugify project — it’s based on PolyHook and AsmJit. This implementation generates thread-safe hooks using stack memory and leverages AsmJit’s high-level compiler to emit pre/post callback code dynamically. It’s much faster and fits better into modern runtime environments.

If you’re interested, you can check it out here:
👉 Plugify Plugin PolyHook

Again, thanks a lot for the kind words and for taking the time to write up such a thoughtful suggestion. I really appreciate it!