Angrepp på Node.js genom manipulation av prototyper för JavaScript-objekt

Forskare vid Helmholtz-centret för informationssäkerhet (CISPA) och Kungliga tekniska högskolan (Sverige) har analyserat tillämpningen av tekniken för prototypförorening av JavaScript för att skapa attacker mot Node.js-plattformen och populära applikationer baserade på den, vilket leder till kodexekvering.

Prototypsföroreningsmetoden använder en funktion av JavaScript-språket som gör att nya egenskaper kan läggas till i den grundläggande prototypen för vilket objekt som helst. I applikationer kan det finnas kodblock (widgets) vars funktion påverkas av den införda egenskapen, till exempel kan koden innehålla en konstruktion av typen ‘const cmd = options.cmd || "/bin/sh"’, vars logik kommer att förändras om angriparen lyckas införa egenskapen ‘cmd’ i den grundläggande prototypen.

För att en attack ska lyckas krävs det att inkommande data i applikationen kan användas för att skapa en ny egenskap i objektets grundläggande prototyp, samt att det under körningen finns en widget som är beroende av den förändrade egenskapen. Ändringen av prototypen görs genom behandling av Node.js systemegenskaperna ‘__proto__’ och ‘constructor’. Egenskapen ‘__proto__’ returnerar prototypen för objektets klass, medan egenskapen ‘constructor’ returnerar funktionen som används för att skapa objektet.

Om koden i applikationen innehåller tilldelningen ‘obj[a][b] = value’ och värdena sätts från externa data, kan angriparen sätta ‘a’ till värdet ‘__proto__’ och på så sätt få sitt eget egenskap med namnet ‘b’ och värdet ‘value’ i objektets grundläggande prototyp (obj.__proto__.b = value;), där den egenskap som sätts i prototypen kommer att synas i alla objekt. På samma sätt, om koden innehåller uttryck av typen ‘obj[a][b][c] = value’, kan man sätta ‘a’ till värdet ‘constructor’ och ‘b’ till ‘prototype’ för att definiera en ny egenskap med namnet ‘c’ och värdet ‘value’ i alla existerande objekt.

Exempel på ändring av prototypen: const o1 = {}; const o2 = new Object(); o1.__proto__.x = 42; // skapar egenskapen ‘x’ i den grundläggande prototypen console.log(o2.x); // får åtkomst till egenskapen ‘x’ från ett annat objekt // i utsignal får vi 42, eftersom den grundläggande prototypen ändrats genom objektet o1, även använd i objektet o2

Exempel på sårbar kod: function entryPoint(arg1, arg2, arg3){ const obj = {}; const p = obj[arg1]; p[arg2] = arg3; return p; }

Om argumenten för funktionen entryPoint genereras från indata kan en angripare skicka värdet «__proto__» i arg1 och skapa en egenskap med valfritt namn i rotprototypen. Om man skickar värdet «toString» i arg2 och 1 i arg3 kan man definiera egenskapen «toString» (Object.prototype.toString=1) och åstadkomma en krasch av applikationen vid anropet av funktionen toString().

Ett exempel på situationer som kan leda till att kod från angriparen körs är skapandet av egenskaperna «main», «shell», «exports», «contextExtensions» och «env». Till exempel kan en angripare skapa en egenskap «main» i rotprototypen för objektet genom att skriva in sökvägen till sin skript (Object.prototype.main = «. /.. /.. /pwned.js») och denna egenskap kommer att anropas vid körning av koden i konstruktionen require(«my-package»), om det anslutna paketet inte uttryckligen definierar egenskapen «main» i package.json (om egenskapen inte är definierad kommer den att hämtas från rotprototypen). På samma sätt kan egenskaperna «shell», «exports» och «env» infogas: let rootProto = Object.prototype; rootProto[«exports»] = {«.»:«./changelog.js»}; rootProto[«1»] = «/path/to/npm/scripts/»; // utlös anrop require («./target.js»); Object.prototype.main = «/path/to/npm/scripts/changelog.js»; Object.prototype.shell = «node»; Object.prototype.env = {}; Object.prototype.env.NODE_OPTIONS = «—inspect-brk=0.0.0.0:1337»; // utlös anrop require («bytes»);

Forskare har analyserat 10 000 NPM-paket med det högsta antalet beroenden och funnit att 1958 av dem saknar egenskapen main i package.json, 4420 använder relativa sökvägar i require-uttrycket, och 355 använder direkt API för att infoga kommandon.

Som ett fungerande exempel kan en exploatering för en attack på backend för Parse Server nämnas, som omdefinierar egenskapen evalFunctions. För att underlätta identifieringen av sådana sårbarheter har ett verktyg utvecklats som kombinerar metoder för statisk och dynamisk analys. Under tester av Node.js identifierades 11 gadgets som kan användas för att utföra attacker som leder till att angriparkod körs. Förutom Parse Server har två utnyttjade sårbarheter också identifierats i NPM CLI.

Källa: opennet.ru