Parameter Pollution | JSON Injection

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

HTTP Parameter Pollution (HPP) — Überblick

HTTP Parameter Pollution (HPP) ist eine Technik, bei der Angreifer HTTP-Parameter manipulieren, um das Verhalten einer Webanwendung auf unerwartete Weise zu ändern. Diese Manipulation erfolgt durch Hinzufügen, Ändern oder Duplizieren von HTTP-Parametern. Die Auswirkungen dieser Manipulationen sind für den Benutzer nicht direkt sichtbar, können jedoch die Funktionalität der Anwendung auf Serverseite erheblich verändern und auf der Clientseite beobachtbare Effekte haben.

Beispiel für HTTP Parameter Pollution (HPP)

Eine Banking-Anwendungs-Transaktions-URL:

  • Ursprüngliche URL: https://www.victim.com/send/?from=accountA&to=accountB&amount=10000

Durch Einfügen eines zusätzlichen from-Parameters:

  • Manipulierte URL: https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC

Die Transaktion könnte fälschlicherweise accountC statt accountA belasten, was das Potenzial von HPP zeigt, Transaktionen oder andere Funktionen wie Passwort-Resets, 2FA-Einstellungen oder API-Key-Anfragen zu manipulieren.

Technologie-spezifische Parameterverarbeitung

  • Die Art und Weise, wie Parameter geparst und priorisiert werden, hängt von der zugrundeliegenden Webtechnologie ab und beeinflusst, wie HPP ausgenutzt werden kann.
  • Tools wie Wappalyzer helfen dabei, diese Technologien und ihr Parsing-Verhalten zu identifizieren.

PHP und HPP-Ausnutzung

OTP-Manipulationsfall:

  • Kontext: Ein Login-Mechanismus, der ein One-Time Password (OTP) erfordert, wurde ausgenutzt.
  • Methode: Durch das Abfangen der OTP-Anfrage mit Werkzeugen wie Burp Suite duplizierten Angreifer den email-Parameter in der HTTP-Anfrage.
  • Ergebnis: Das OTP, das für die ursprüngliche E-Mail bestimmt war, wurde stattdessen an die zweite E-Mail-Adresse in der manipulierten Anfrage gesendet. Dieser Fehler ermöglichte unautorisierten Zugriff, indem das vorgesehene Sicherheitsverfahren umgangen wurde.

Dieses Szenario hebt einen kritischen Fehler im Backend der Anwendung hervor, das den ersten email-Parameter zur OTP-Generierung verarbeitete, aber den letzten zur Zustellung verwendete.

API-Key-Manipulationsfall:

  • Szenario: Eine Anwendung erlaubt Nutzern, ihren API-Key über eine Profil-Einstellungsseite zu aktualisieren.
  • Angriffsvektor: Ein Angreifer entdeckt, dass er durch Anhängen eines zusätzlichen api_key-Parameters an die POST-Anfrage das Ergebnis der API-Key-Update-Funktion beeinflussen 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 das letzte Vorkommen verarbeitet, aktualisiert den API-Key auf den vom Angreifer gelieferten Wert.
  • Folge: Der Angreifer erlangt Kontrolle über die API-Funktionalität des Opfers und kann möglicherweise private Daten unbefugt abrufen oder verändern.

Dieses Beispiel unterstreicht die Notwendigkeit sicherer Parameterverarbeitung, insbesondere bei so kritischen Funktionen wie dem Management von API-Keys.

Parameter Parsing: Flask vs. PHP

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, z. B. a=1 in einer Query-String a=1&a=2, und priorisiert das erste Vorkommen gegenüber nachfolgenden Duplikaten.
  • PHP (auf Apache HTTP Server): Priorisiert hingegen den letzten Parameterwert und würde im gegebenen Beispiel a=2 wählen. Dieses Verhalten kann HPP-Exploits erleichtern, indem das vom Angreifer manipulierte Parameter vorrangig behandelt wird.

HPP-Testhinweise (OWASP WSTG)

  • HTTP-Standards definieren nicht, wie mehrere Parameter mit demselben Namen zu interpretieren sind, daher variiert das Verhalten zwischen Stacks und Komponenten.
  • Beim Testen von serverseitigem HPP dupliziere jeden Parameter in Query-Strings oder Bodies und beobachte, ob die Anwendung Werte konkatenieren, erste/letzte verwenden oder Fehler auslöst.
  • Für clientseitiges HPP injiziere ein URL-kodiertes & in einen reflektierten Parameterwert (z. B. %26HPP_TEST) und suche nach dekodierten Vorkommen wie &HPP_TEST oder &HPP_TEST in erzeugten Links oder Form-Aktionen.

Server-Side Parameter Pollution (SSPP) in internen APIs

Einige Anwendungen betten Benutzereingaben in serverseitige Anfragen an interne APIs ein. Wenn diese Eingaben nicht korrekt kodiert sind, kannst du Parameter in der internen Anfrage injizieren oder überschreiben. Teste jegliche Benutzereingaben, einschließlich Query-Parameter, Formularfelder, Header und URL-Pfadparameter.

Gängige Probes:

  • Füge einen neuen Parameter mit %26 (URL-kodiertes &) hinzu.
  • Kürze die downstream Query mit %23 (URL-kodiertes #).
  • Überschreibe einen bestehenden Parameter durch Duplizieren.

Beispiel:

GET /userSearch?name=peter%26name=carlos&back=/home

Führt möglicherweise zu einer serverseitigen Anfrage wie:

GET /users/search?name=peter&name=carlos&publicProfile=true

Parameter pollution by technology

Die Ergebnisse stammen von https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89

PHP 8.3.11 AND Apache 2.4.62

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg

  1. Ignoriere alles nach %00 im Parameternamen.
  2. Behandelt name[] als Array.
  3. _GET bedeutet nicht die GET-Methode.
  4. Bevorzugt den letzten Parameter.

Ruby 3.3.5 and WEBrick 1.8.2

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg

  1. Verwendet die &- und ;-Trennzeichen, um Parameter zu trennen.
  2. Erkennt name[] nicht.
  3. Bevorzugt den ersten Parameter.

Spring MVC 6.0.23 AND Apache Tomcat 10.1.30

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*llG22MF1gPTYZYFVCmCiVw.jpeg

  1. POST RequestMapping == PostMapping & GET RequestMapping == GetMapping.
  2. POST RequestMapping & PostMapping erkennen name[].
  3. Bevorzugt name, wenn sowohl name als auch name[] existieren.
  4. Verkettet Parameter, z. B. first,last.
  5. POST RequestMapping & PostMapping erkennen Query-Parameter mit Content-Type.

NodeJS 20.17.0 AND Express 4.21.0

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg

  1. Erkennt name[].
  2. Verkettet Parameter, z. B. first,last.

GO 1.22.7

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg

  1. Erkennt name[] nicht.
  2. Bevorzugt den ersten Parameter.

Python 3.12.6 AND Werkzeug 3.0.4 AND Flask 3.0.3

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg

  1. Erkennt name[] nicht.
  2. Bevorzugt den ersten Parameter.

Python 3.12.6 AND Django 4.2.15

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg

  1. Erkennt name[] nicht.
  2. Bevorzugt den letzten Parameter.

Python 3.12.6 AND Tornado 6.4.1

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg

  1. Erkennt name[] nicht.
  2. Bevorzugt den letzten Parameter.

JSON Injection

JSON, XML and YAML Hacking

Doppelte Schlüssel

obj = {"test": "user", "test": "admin"}

Das Frontend könnte dem ersten Vorkommen glauben, während das Backend das zweite Vorkommen des Schlüssels verwendet.

Key Collision: Character Truncation and Comments

Bestimmte Zeichen werden vom Frontend nicht korrekt interpretiert, das Backend hingegen interpretiert sie und verwendet diese Schlüssel; das kann nützlich sein, um bestimmte Beschränkungen zu umgehen:

{"test": 1, "test\[raw \x0d byte]": 2}
{"test": 1, "test\ud800": 2}
{"test": 1, "test"": 2}
{"test": 1, "te\st": 2}

Beachte, wie in diesen Fällen das front end denken könnte, dass test == 1, während das backend denken wird, dass test == 2.

Dies kann auch verwendet werden, um Wertebeschränkungen wie folgt zu umgehen:

{"role": "administrator\[raw \x0d byte]"}
{"role":"administrator\ud800"}
{"role": "administrator""}
{"role": "admini\strator"}

Verwendung von Comment Truncation

obj = {"description": "Duplicate with comments", "test": 2, "extra": /*, "test": 1, "extra2": */}

Hier verwenden wir den Serializer jedes Parsers, um dessen jeweilige Ausgabe zu sehen.

Serializer 1 (z. B. GoLang’s GoJay library) wird Folgendes erzeugen:

  • description = "Duplicate with comments"
  • test = 2
  • extra = ""

Serializer 2 (z. B. Java’s JSON-iterator library) wird Folgendes erzeugen:

  • description = "Duplicate with comments"
  • extra = "/*"
  • extra2 = "*/"
  • test = 1

Alternativ kann auch die einfache Verwendung von Kommentaren effektiv sein:

obj = {"description": "Comment support", "test": 1, "extra": "a"/*, "test": 2, "extra2": "b"*/}

Javas GSON-Bibliothek:

{ "description": "Comment support", "test": 1, "extra": "a" }

Rubys simdjson-Bibliothek:

{ "description": "Comment support", "test": 2, "extra": "a", "extra2": "b" }

Inkonsistente Priorität: Deserialization vs. Serialization

obj = {"test": 1, "test": 2}

obj["test"] // 1
obj.toString() // {"test": 2}

Gleitkommazahl und Ganzzahl

Die Zahl

999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

kann in mehrere Darstellungen dekodiert werden, einschließlich:

999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
9.999999999999999e95
1E+96
0
9223372036854775807

Was zu Inkonsistenzen führen kann

Quellen

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks