DOM XSS

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks

Kyk na die subskripsie planne!

Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.

Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.

DOM Kw vulnerabilities

DOM kw vulnerabilities ontstaan wanneer data van aanvaller-beheerde bronne (soos location.search, document.referrer, of document.cookie) onveilig na sinkholes oorgedra word. Sinkholes is funksies of voorwerpe (bv. eval(), document.body.innerHTML) wat skadelike inhoud kan uitvoer of weergee as dit kwaadwillige data ontvang.

Bronne is insette wat deur aanvallers gemanipuleer kan word, insluitend URL’s, koekies, en webboodskappe.
Sinkholes is potensieel gevaarlike eindpunte waar kwaadwillige data tot nadelige gevolge kan lei, soos skripuitvoering.

Die risiko ontstaan wanneer data van ’n bron na ’n sinkhole vloei sonder behoorlike validasie of sanitasie, wat aanvalle soos XSS moontlik maak.

Tip

Jy kan ’n meer opgedateerde lys van bronne en sinkholes vind in https://github.com/wisec/domxsswiki/wiki

Gewone bronne:

document.URL
document.documentURI
document.URLUnencoded
document.baseURI
location
document.cookie
document.referrer
window.name
history.pushState
history.replaceState
localStorage
sessionStorage
IndexedDB(mozIndexedDB, webkitIndexedDB, msIndexedDB)
Database

Algemene Sinks:

Open Redirect	Javascript Injection	DOM-data manipulation	jQuery
`location`	`eval()`	`scriptElement.src`	`add()`
`location.host`	`Function() constructor`	`scriptElement.text`	`after()`
`location.hostname`	`setTimeout()`	`scriptElement.textContent`	`append()`
`location.href`	`setInterval()`	`scriptElement.innerText`	`animate()`
`location.pathname`	`setImmediate()`	`someDOMElement.setAttribute()`	`insertAfter()`
`location.search`	`execCommand()`	`someDOMElement.search`	`insertBefore()`
`location.protocol`	`execScript()`	`someDOMElement.text`	`before()`
`location.assign()`	`msSetImmediate()`	`someDOMElement.textContent`	`html()`
`location.replace()`	`range.createContextualFragment()`	`someDOMElement.innerText`	`prepend()`
`open()`	`crypto.generateCRMFRequest()`	`someDOMElement.outerText`	`replaceAll()`
`domElem.srcdoc`	``Local file-path manipulation	`someDOMElement.value`	`replaceWith()`
`XMLHttpRequest.open()`	`FileReader.readAsArrayBuffer()`	`someDOMElement.name`	`wrap()`
`XMLHttpRequest.send()`	`FileReader.readAsBinaryString()`	`someDOMElement.target`	`wrapInner()`
`jQuery.ajax()`	`FileReader.readAsDataURL()`	`someDOMElement.method`	`wrapAll()`
`$.ajax()`	`FileReader.readAsText()`	`someDOMElement.type`	`has()`
``Ajax request manipulation	`FileReader.readAsFile()`	`someDOMElement.backgroundImage`	`constructor()`
`XMLHttpRequest.setRequestHeader()`	`FileReader.root.getFile()`	`someDOMElement.cssText`	`init()`
`XMLHttpRequest.open()`	`FileReader.root.getFile()`	`someDOMElement.codebase`	`index()`
`XMLHttpRequest.send()`	Link manipulation	`someDOMElement.innerHTML`	`jQuery.parseHTML()`
`jQuery.globalEval()`	`someDOMElement.href`	`someDOMElement.outerHTML`	`$.parseHTML()`
`$.globalEval()`	`someDOMElement.src`	`someDOMElement.insertAdjacentHTML`	Client-side JSON injection
``HTML5-storage manipulation	`someDOMElement.action`	`someDOMElement.onevent`	`JSON.parse()`
`sessionStorage.setItem()`	XPath injection	`document.write()`	`jQuery.parseJSON()`
`localStorage.setItem()`	`document.evaluate()`	`document.writeln()`	`$.parseJSON()`
[`Denial of Service`](dom-xss.md#denial-of-service)	`someDOMElement.evaluate()`	`document.title`	``Cookie manipulation
`requestFileSystem()`	``Document-domain manipulation	`document.implementation.createHTMLDocument()`	`document.cookie`
`RegExp()`	`document.domain`	`history.pushState()`	WebSocket-URL poisoning
Client-Side SQl injection	Web-message manipulation	`history.replaceState()`	`WebSocket`
`executeSql()`	`postMessage()`	``	``

Die innerHTML sink aanvaar nie script elemente op enige moderne blaaiers nie, en svg onload gebeurtenisse sal ook nie afgevuur word nie. Dit beteken jy sal alternatiewe elemente soos img of iframe moet gebruik.

Hierdie tipe XSS is waarskynlik die moeiliker om te vind, aangesien jy binne die JS-kode moet kyk, sien of dit gebruik enige objek waarvan die waarde jy beheer, en in daardie geval, kyk of daar enige manier is om dit te misbruik om arbitrêre JS uit te voer.

Gereedskap om hulle te vind

https://github.com/mozilla/eslint-plugin-no-unsanitized
Blaaier uitbreiding om elke data te kontroleer wat ’n potensiële sink bereik: https://github.com/kevin-mizu/domloggerpp

Voorbeelde

Open Redirect

Van: https://portswigger.net/web-security/dom-based/open-redirection

Open redirect kwesbaarhede in die DOM gebeur wanneer ’n skrip data skryf, wat ’n aanvaller kan beheer, in ’n sink wat in staat is om navigasie oor domeine te begin.

Dit is van kardinale belang om te verstaan dat die uitvoering van arbitrêre kode, soos javascript:alert(1), moontlik is as jy beheer het oor die begin van die URL waar die herleiding plaasvind.

Sinks:

location
location.host
location.hostname
location.href
location.pathname
location.search
location.protocol
location.assign()
location.replace()
open()
domElem.srcdoc
XMLHttpRequest.open()
XMLHttpRequest.send()
jQuery.ajax()
$.ajax()

Koekie manipulasie

From: https://portswigger.net/web-security/dom-based/cookie-manipulation

DOM-gebaseerde koekie-manipulasie kwesbaarhede ontstaan wanneer ’n skrif data, wat deur ’n aanvaller beheer kan word, in die waarde van ’n koekie inkorporeer. Hierdie kwesbaarheid kan lei tot onverwagte gedrag van die webblad as die koekie binne die webwerf gebruik word. Boonop kan dit uitgebuit word om ’n sessie-fiksasie-aanval uit te voer as die koekie betrokke is by die opsporing van gebruikersessies. Die primêre sink wat met hierdie kwesbaarheid geassosieer word, is:

Sinks:

document.cookie

JavaScript-inspuiting

Van: https://portswigger.net/web-security/dom-based/javascript-injection

DOM-gebaseerde JavaScript-inspuitingskw vulnerabilities ontstaan wanneer ’n skrip data uitvoer, wat deur ’n aanvaller beheer kan word, as JavaScript-kode.

Sinks:

eval()
Function() constructor
setTimeout()
setInterval()
setImmediate()
execCommand()
execScript()
msSetImmediate()
range.createContextualFragment()
crypto.generateCRMFRequest()

Dokument-domein manipulasie

Van: https://portswigger.net/web-security/dom-based/document-domain-manipulation

Dokument-domein manipulasie kwesbaarhede ontstaan wanneer ’n skrip die document.domain eienskap stel met behulp van data wat ’n aanvaller kan beheer.

Die document.domain eienskap speel ’n sleutelrol in die afdwinging van die selfde-oorsprong beleid deur blaaiers. Wanneer twee bladsye van verskillende oorspronge hul document.domain op die dieselfde waarde stel, kan hulle sonder beperkings interaksie hê. Alhoewel blaaiers sekere grense op die waardes wat aan document.domain toegeken kan word, afdwing, wat die toekenning van heeltemal onverwante waardes aan die werklike bladsy oorsprong voorkom, bestaan daar uitsonderings. Tipies, laat blaaiers die gebruik van kind of ouer domeine toe.

Sinks:

document.domain

WebSocket-URL vergiftiging

From: https://portswigger.net/web-security/dom-based/websocket-url-poisoning

WebSocket-URL vergiftiging gebeur wanneer ’n skrip beheerde data as die teiken-URL vir ’n WebSocket-verbinding gebruik.

Sinks:

Die WebSocket konstruktors kan lei tot WebSocket-URL vergiftiging kwesbaarhede.

Skakel manipulasie

From: https://portswigger.net/web-security/dom-based/link-manipulation

DOM-gebaseerde skakel-manipulasie kwesbaarhede ontstaan wanneer ’n skrip aanvaller-beheerde data na ’n navigasiedoel binne die huidige bladsy skryf, soos ’n klikbare skakel of die indien-URL van ’n vorm.

Sinks:

someDOMElement.href
someDOMElement.src
someDOMElement.action

Ajax versoek manipulasie

Van: https://portswigger.net/web-security/dom-based/ajax-request-header-manipulation

Ajax versoek manipulasie kwesbaarhede ontstaan wanneer ’n skrif aanvaller-beheerde data in ’n Ajax versoek skryf wat uitgevoer word met ’n XmlHttpRequest objek.

Sinks:

XMLHttpRequest.setRequestHeader()
XMLHttpRequest.open()
XMLHttpRequest.send()
jQuery.globalEval()
$.globalEval()

Plaaslike lêer-pad manipulasie

Van: https://portswigger.net/web-security/dom-based/local-file-path-manipulation

Plaaslike lêer-pad manipulasie kwesbaarhede ontstaan wanneer ’n skrip aanvallers-beheerde data aan ’n lêer-hantering API as die filename parameter deurgee. Hierdie kwesbaarheid kan deur ’n aanvaller uitgebuit word om ’n URL te konstrueer wat, indien deur ’n ander gebruiker besoek, kan lei tot die gebruiker se blaaier wat ’n arbitrêre plaaslike lêer oopmaak of skryf.

Sinks:

FileReader.readAsArrayBuffer()
FileReader.readAsBinaryString()
FileReader.readAsDataURL()
FileReader.readAsText()
FileReader.readAsFile()
FileReader.root.getFile()
FileReader.root.getFile()

Kliëntkant SQl-inspuiting

Van: https://portswigger.net/web-security/dom-based/client-side-sql-injection

Kliëntkant SQL-inspuitingskw vulnerabilities ontstaan wanneer ’n skrip aanvaller-beheerde data op ’n onveilige manier in ’n kliëntkant SQL-navraag inkorporeer.

Sinke:

executeSql()

HTML5-storage manipulasie

From: https://portswigger.net/web-security/dom-based/html5-storage-manipulation

HTML5-storage manipulasie kwesbaarhede ontstaan wanneer ’n skrip aanvaller-beheerde data in die webblaaier se HTML5-stoor (localStorage of sessionStorage) stoor. Terwyl hierdie aksie nie inherent ’n sekuriteitskwesbaarheid is nie, word dit problematies as die aansoek daarna die gestoor data lees en dit onveilig verwerk. Dit kan ’n aanvaller toelaat om die stoormeganisme te benut om ander DOM-gebaseerde aanvalle uit te voer, soos cross-site scripting en JavaScript-inspuiting.

Sinks:

sessionStorage.setItem()
localStorage.setItem()

XPath-inspuiting

Van: https://portswigger.net/web-security/dom-based/client-side-xpath-injection

DOM-gebaseerde XPath-inspuitingskw vulnerabilities ontstaan wanneer ’n skrip aanvaller-beheerde data in ’n XPath-navraag inkorporeer.

Sinks:

document.evaluate()
someDOMElement.evaluate()

Kliënt-kant JSON-inspuiting

Van: https://portswigger.net/web-security/dom-based/client-side-json-injection

DOM-gebaseerde JSON-inspuitingskw vulnerabilities gebeur wanneer ’n skrif aanvaller-beheerde data in ’n string inkorporeer wat as ’n JSON-data struktuur geparseer word en dan deur die toepassing verwerk word.

Sinke:

JSON.parse()
jQuery.parseJSON()
$.parseJSON()

Web-boodskap manipulasie

From: https://portswigger.net/web-security/dom-based/web-message-manipulation

Web-boodskap kwesbaarhede ontstaan wanneer ’n skrip aanvaller-beheerde data as ’n web boodskap na ’n ander dokument binne die blaaier stuur. ’n voorbeeld van kwesbare Web-boodskap manipulasie kan gevind word by PortSwigger se Web Sekuriteit Akademie.

Sinks:

Die postMessage() metode om web boodskappe te stuur kan tot kwesbaarhede lei as die gebeurtenisluisteraar vir die ontvangs van boodskappe die inkomende data op ’n onveilige manier hanteer.

DOM-data manipulasie

From: https://portswigger.net/web-security/dom-based/dom-data-manipulation

DOM-data manipulasie kwesbaarhede ontstaan wanneer ’n skrip aanvaller-beheerde data na ’n veld binne die DOM skryf wat in die sigbare UI of kliënt-kant logika gebruik word. Hierdie kwesbaarheid kan deur ’n aanvaller uitgebuit word om ’n URL te konstrueer wat, indien deur ’n ander gebruiker besoek, die voorkoms of gedrag van die kliënt-kant UI kan verander.

Sinks:

scriptElement.src
scriptElement.text
scriptElement.textContent
scriptElement.innerText
someDOMElement.setAttribute()
someDOMElement.search
someDOMElement.text
someDOMElement.textContent
someDOMElement.innerText
someDOMElement.outerText
someDOMElement.value
someDOMElement.name
someDOMElement.target
someDOMElement.method
someDOMElement.type
someDOMElement.backgroundImage
someDOMElement.cssText
someDOMElement.codebase
document.title
document.implementation.createHTMLDocument()
history.pushState()
history.replaceState()

Denial of Service

From: https://portswigger.net/web-security/dom-based/denial-of-service

DOM-gebaseerde ontkenning van diens kwesbaarhede ontstaan wanneer ’n skrip aanvaller-beheerde data onveilig aan ’n problematiese platform API oorhandig. Dit sluit API’s in wat, wanneer dit aangeroep word, die gebruiker se rekenaar kan laat gebruik maak van oormatige hoeveelhede CPU of skyfspasie. Sulke kwesbaarhede kan beduidende newe-effekte hê, soos dat die blaaier die webwerf se funksionaliteit beperk deur pogings om data in localStorage te stoor, te verwerp of besige skripte te beëindig.

Sinks:

requestFileSystem()
RegExp()

Dom Clobbering

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks

Kyk na die subskripsie planne!

Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.

Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.