Launched this week
Aether Injector
Modern, stealth-focused DLL injector built with C++20.
13 followers
Modern, stealth-focused DLL injector built with C++20.
13 followers
"A modern, high-performance, and stealth-focused Windows DLL Injector built for advanced memory manipulation and security testing. Featuring C++20 architecture, 8 advanced injection methods, and evasion parameters to bypass static heuristic engines."
One thing that would make this even better is a built-in process scanner with a simple UI to preview target modules before injecting, saves a lot of command line trial and error when working with unfamiliar processes.
@selinmd2r You're absolutely right. Currently, the Smart Process Selector handles process targeting and filtering, but it doesn't expose the loaded module list of the target process yet. Adding a module preview/scanner is exactly the kind of workflow improvement I want to prioritize to eliminate that 'trial and error' phase. I've noted this down for the upcoming module expansion.
A manual mapping mode that hashes target modules before writing them into the remote process would be a nice addition for cleaner footprints, and maybe a per-injection log file so you can review what actually got written and where if something goes sideways.
@yeim1746457 That's a solid observation. You're touching on the 'stealth' and 'debuggability' aspects, which are exactly what differentiate a toy project from a professional tool. I'm already architecting the mapping mode to hash target modules before injection—it’s crucial for minimizing footprints in memory. As for the per-injection logging, I agree; it’s a non-negotiable for anyone who needs to diagnose why an injection might fail in specific environments. Expect these to be part of the core implementation.
honestly the 8 injection methods cover basically every scenario i usually hit, and the heuristic evasion params actually worked on a stubborn av i was testing against. C++20 architecture feels snappy, no bloat.
@ekrem1660792 Glad to hear the heuristic evasion holds up—that's the advantage of keeping the architecture lean and avoiding the bloat of standard frameworks. Sticking to C++20 wasn't just about syntax; it was about ensuring that every cycle spent is strictly for the logic, not the overhead. The 8 methods are currently my baseline for coverage, but I’m always looking to refine the logic further. Keeping it snappy and surgical is the priority.
Have you considered adding a sandbox or VM detection layer that auto-disables injection when it detects analysis environments? It would round out the stealth focus nicely and help users avoid burning samples during malware research or red team engagements.
@erenapik That’s a critical addition. Integrating an environment-awareness layer is the natural next step for anyone treating this as a serious tool rather than just a quick build. The goal is to ensure the engine is 'situationally aware'—if it detects it's being analyzed or run in a sandbox, it goes dormant. I’m currently finalizing the detection logic to ensure it doesn’t add unnecessary overhead. Stealth is a game of constant refinement, and environment detection is definitely a key piece of the puzzle
honestly the 8 injection methods cover way more edge cases than i expected, and it ran clean past my av without any tweaks. kind of overkill for casual stuff but solid if you actually need it
@enolsomandquh Glad it performed well for you. The 8 methods are definitely designed to handle those 'stubborn' scenarios where standard approaches fail. I prefer to aim for overkill—better to have a robust, surgical tool that handles the edge cases cleanly than something that breaks the moment a user hits a slightly protected environment. It’s built to be a reliable instrument, not just a casual utility.
the c++20 architecture is honestly a nice touch, most injectors out there are still stuck on older standards and it shows in performance. respect the focus on stealth heuristics too, that's clearly built by people who actually know the space
@rabia597613 Appreciate the acknowledgment. Sticking to C++20 wasn’t just a preference—it was a necessity to get that clean, header-only efficiency and avoid the unnecessary bloat that plagues legacy injectors. When you're dealing with stealth heuristics, every millisecond and every instruction count; you can't afford the overhead of older standards. We built this because we were tired of tools that prioritize flash over function. Glad to see the design choices are hitting the mark.