De prototypevervuilingsaanval maakt gebruik van de manier waarop JavaScript-objecten omgaan met hun overeenkomstige prototypes. In JavaScript zijn prototypes een ander object dat de standaardeigenschappen en -methoden voor het geselecteerde object definieert. Een aanvaller maakt misbruik van de prototypevervuiling door kwaadaardige code in deze prototypes te injecteren door de eigenschappen van het object te manipuleren of door een functie te gebruiken die objecten recursief samenvoegt.
In deze gids worden de manieren uitgelegd waarop prototypen van vervuilingsaanvallen kunnen worden voorkomen.
Prototypevervuilingsaanvallen voorkomen?
De hoofdoorzaak van vervuilingsaanvallen op prototypes is dat JavaScript-objecten eigenschappen van hun prototype overnemen. Dit betekent dat als een aanvaller kwaadaardige code in het prototype kan injecteren, deze wordt overgenomen door alle objecten die van dat prototype hebben geërfd. Dit leidt tot het stelen van gegevens, het uitvoeren van willekeurige code of het overnemen van de controle over andere applicaties.
In het onderstaande codefragment wordt het prototype van de vervuilingscode geïnjecteerd:
const y = { A: 1 , B: 2 } ;
const-gegevens = JSON.parse ( '{'__proto__': { 'defect': waar}}' ) ;
const c = Object.toewijzen ( { } , en, gegevens ) ;
console.log ( c.defect ) ;
De beschrijving van het bovenstaande codefragment:
-
- Eerst wordt de lijst met de naam “ En ” wordt gemaakt en slaat de waarden op in het sleutel-waardepaar.
- Met de hulp van ' -daarom- ”, wordt de willekeurige vervuilde code geïmplementeerd in het sleutelwaardeformaat. De sleutel is ingesteld op “ defect ' en de toegewezen waarde van ' WAAR ”.
- Vervolgens wordt deze vervuilde code toegewezen aan de “ En ' lijst door een beroep te doen op de ' toewijzen() ”methode, en de resulterende lijst wordt opgeslagen in een nieuwe lijst met de naam “ C ”.
- Tenslotte wordt de geïnjecteerde vervuilde code in de “ C De lijst wordt opgehaald en de waarde ervan wordt op de console weergegeven. Om ervoor te zorgen dat vervuiling of kwaadaardige gegevens zijn geïnjecteerd.
Na het uitvoeren van het bevattende bestand laat de uitvoer zien dat de kwaadaardige code met succes is geïnjecteerd en dat de waarde ervan is opgehaald:
Hoe kunnen prototype-vervuilingsaanvallen worden voorkomen?
Er zijn verschillende benaderingen waarmee het prototype van een vervuilingsaanval kan worden voorkomen:
Onveilige recursieve samenvoegingen:
Vermijd de onveilige recursieve samensmeltingen, omdat deze kunnen leiden tot prototypes van vervuilingsaanvallen:
waarbij samenvoegen = ( neemt , src ) = > {voor ( var-attributen in src ) {
als ( soort van ( neemt [ attributen ] ) === 'obj' && soort van ( src [ attributen ] ) === 'obj' )
{
samenvoegen ( neemt [ attributen ] , src [ attributen ] ) ;
} anders {
neemt [ attributen ] = src [ attributen ] ;
}
}
opbrengst neemt ;
} ;
In de bovenstaande code:
-
- Ten eerste de aangepaste functie “ samenvoegen() ” is gemaakt die twee arrayparameters accepteert “ neemt ' En ' src ”.
- De verbeterde “ voor 'lus wordt gebruikt om de variabele' te herhalen attributen ” boven de voorziene “ src ' parameter.
- Gebruik binnen de lus een “ als ”-instructie die door beide fouten navigeert en of een element in beide arrays hetzelfde gegevenstype heeft. Vervolgens worden die elementen als parameters doorgegeven aan dezelfde “ samenvoegen() '-functie die een recursief karakter creëert.
- Als de typen niet hetzelfde zijn, wordt de elementwaarde die zich in de “ src ” parameterarray wordt doorgegeven aan de “ neemt ' parameter.
- Eindelijk, de ' neemt ”parametrische array wordt geretourneerd.
Het prototype bevriezen
Een andere preventie voor prototype-vervuilingsaanvallen is het bevriezen van de uitvoeringscyclus ervan. Dit gebeurt via de “ Object.freeze() methode. In het onderstaande fragment wordt de hierboven geïnjecteerde vervuilde prototypecode bevroren:
const y = { A: 1 , B: 2 } ;const-gegevens = JSON.parse ( '{'__proto__': { 'defect': waar}}' ) ;
const c = Object.toewijzen ( { } , en, gegevens ) ;
console.log ( c.defect ) ;
console.log ( Object.bevriezen ( c.defect ) ) ;
console.log ( Object.is bevroren ( c.defect ) ) ;
De uitleg van de bovenstaande code wordt hieronder weergegeven:
-
- In eerste instantie zal de vervuilde code van het dummy-prototype in de dummy-lijst worden geïnjecteerd “ En ”Net zoals uitgelegd in het bovenstaande gedeelte.
- Vervolgens wordt de geïnjecteerde vervuilde sleutel “ defect ' wordt doorgegeven aan de ' bevriezen() methode om het vervuilde deel te bevriezen.
- Ten slotte, om het vervuilingsgedeelte van het bevroren prototype te bevestigen. De ' defect ' sleutel van lijst ' C ' wordt doorgegeven aan de ' is bevroren() methode. Deze methode retourneert “ WAAR ” in geval van bevroren en “ vals ” in geval van ontdooien:
Na het uitvoeren van de bevattende code laat de uitvoer zien dat de injectie, bevriezing en verificatie van bevroren vervuilde code:
Aanvullende tips om een aanval op prototypevervuiling te voorkomen
Hieronder vindt u enkele aanvullende tips waarmee het prototype van een vervuilingsaanval kan worden voorkomen:
-
- De optie van “ –disable-proto ” kan worden gebruikt om de werking van de “ prototype.__proto__ ' eigendom.
- Gebruik geen methoden met behulp van “ prototype ”.
- Door ' Het opschonen van de gebruikersinvoer ', waarbij gebruikersinvoer wordt gevalideerd en gefilterd om kwaadaardige of vervuilde code te verwijderen.
- Gebruik van ' witte lijst ”, wat een lijst is met toegestane eigenschappen en methoden voor een object. Alle pogingen om eigenschappen of methoden in te stellen of te verkrijgen die geen lid zijn van de witte lijst, worden geblokkeerd.
Dat draait allemaal om het voorkomen van prototype-vervuilingsaanvallen in Node.js.
Conclusie
Om aanvallen op prototypevervuiling te voorkomen, zijn benaderingen zoals het vermijden van onveilige recursieve samenvoegingen, het bevriezen van het prototype en het gebruik van een witte lijst om de “ __daarom__ ”-eigenschap die niet is ingesteld, kan worden gebruikt. Samen met het gebruik van “ –disable-proto ' opties, waarbij het gebruik van ' Object.prototype ', En ' het opschonen van de gebruikersinvoer ” voor vervuilde code. Deze gids illustreert de preventie van prototype-vervuilingsaanvallen in Nodejs.