hacktricks/pentesting-web/xss-cross-site-scripting/dom-xss.md

24 KiB

DOM XSS

Erlernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!

DOM-Schwachstellen

DOM-Schwachstellen treten auf, wenn Daten von angreiferkontrollierten Quellen (wie location.search, document.referrer oder document.cookie) unsicher an Sinks übertragen werden. Sinks sind Funktionen oder Objekte (z. B. eval(), document.body.innerHTML), die schädlichen Inhalt ausführen oder rendern können, wenn ihnen bösartige Daten übergeben werden.

  • Quellen sind Eingaben, die von Angreifern manipuliert werden können, einschließlich URLs, Cookies und Webnachrichten.
  • Sinks sind potenziell gefährliche Endpunkte, an denen bösartige Daten zu nachteiligen Auswirkungen führen können, wie z. B. die Ausführung von Skripten.

Das Risiko entsteht, wenn Daten von einer Quelle zu einem Sink fließen, ohne ordnungsgemäße Validierung oder Säuberung, was Angriffe wie XSS ermöglicht.

{% hint style="info" %} Eine aktuellere Liste von Quellen und Sinks finden Sie unter https://github.com/wisec/domxsswiki/wiki {% endhint %}

Häufige Quellen:

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

Gemeinsame Schwachstellen:

Offene Weiterleitung Javascript-Injektion DOM-Datenmanipulation jQuery
location eval() scriptElement.src add()
location.host Function() Konstruktor 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 ``Lokale Dateipfadmanipulation 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-Anforderungsmanipulation FileReader.readAsFile() someDOMElement.backgroundImage constructor()
XMLHttpRequest.setRequestHeader() FileReader.root.getFile() someDOMElement.cssText init()
XMLHttpRequest.open() FileReader.root.getFile() someDOMElement.codebase index()
XMLHttpRequest.send() Linkmanipulation someDOMElement.innerHTML jQuery.parseHTML()
jQuery.globalEval() someDOMElement.href someDOMElement.outerHTML $.parseHTML()
$.globalEval() someDOMElement.src someDOMElement.insertAdjacentHTML Client-seitige JSON-Injektion
``HTML5-Speicher-Manipulation someDOMElement.action someDOMElement.onevent JSON.parse()
sessionStorage.setItem() XPath-Injektion 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() ``Dokument-Domänenmanipulation document.implementation.createHTMLDocument() document.cookie
RegExp() document.domain history.pushState() WebSocket-URL-Vergiftung
Client-seitige SQL-Injektion Web-Nachrichtenmanipulation history.replaceState() WebSocket
executeSql() postMessage() `` ``

Die innerHTML-Schwachstelle akzeptiert keine script-Elemente in modernen Browsern, und auch svg onload-Ereignisse werden nicht ausgelöst. Dies bedeutet, dass alternative Elemente wie img oder iframe verwendet werden müssen.

Diese Art von XSS ist wahrscheinlich am schwierigsten zu finden, da Sie den JS-Code überprüfen müssen, um zu sehen, ob er ein Objekt verwendet, dessen Wert Sie kontrollieren, und in diesem Fall prüfen müssen, ob es eine Möglichkeit gibt, es zu missbrauchen, um beliebigen JS-Code auszuführen.

Tools zum Auffinden

Beispiele

Offene Weiterleitung

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

Offene Weiterleitungs-Schwachstellen im DOM treten auf, wenn ein Skript Daten schreibt, die ein Angreifer kontrollieren kann, in eine Schwachstelle, die in der Lage ist, Navigationen zwischen Domänen zu initiieren.

Es ist entscheidend zu verstehen, dass die Ausführung beliebigen Codes, wie z.B. javascript:alert(1), möglich ist, wenn Sie die Kontrolle über den Anfang der URL haben, an dem die Weiterleitung erfolgt.

Schwachstellen:

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()

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

DOM-basierte Cookie-Manipulations-Schwachstellen treten auf, wenn ein Skript Daten, die von einem Angreifer kontrolliert werden können, in den Wert eines Cookies einbezieht. Diese Schwachstelle kann zu unerwartetem Verhalten der Webseite führen, wenn das Cookie innerhalb der Seite verwendet wird. Darüber hinaus kann sie ausgenutzt werden, um einen Session-Fixierungsangriff durchzuführen, wenn das Cookie zur Verfolgung von Benutzersitzungen verwendet wird. Der Haupt-Sink, der mit dieser Schwachstelle verbunden ist, lautet:

Sinks:

document.cookie

JavaScript-Injektion

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

DOM-basierte JavaScript-Injektionsanfälligkeiten entstehen, wenn ein Skript Daten ausführt, die von einem Angreifer kontrolliert werden können, als JavaScript-Code.

Sinks:

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

Dokument-Domänenmanipulation

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

Dokument-Domänenmanipulationsanfälligkeiten treten auf, wenn ein Skript die document.domain-Eigenschaft unter Verwendung von Daten setzt, die ein Angreifer kontrollieren kann.

Die document.domain-Eigenschaft spielt eine Schlüsselrolle bei der Durchsetzung der Same-Origin-Richtlinie durch Browser. Wenn zwei Seiten aus verschiedenen Ursprüngen ihre document.domain auf den gleichen Wert setzen, können sie ohne Einschränkungen interagieren. Obwohl Browser bestimmte Grenzen für die Werte festlegen, die document.domain zugewiesen werden können, um die Zuweisung von vollständig nicht verwandten Werten zum tatsächlichen Seitenursprung zu verhindern, gibt es Ausnahmen. Typischerweise erlauben Browser die Verwendung von Unter- oder Elterndomänen.

Sinks:

document.domain

WebSocket-URL-Vergiftung

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

WebSocket-URL-Vergiftung tritt auf, wenn ein Skript steuerbare Daten als Ziel-URL für eine WebSocket-Verbindung verwendet.

Sinks:

Der WebSocket-Konstruktor kann zu Schwachstellen bei der WebSocket-URL-Vergiftung führen.

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

DOM-basierte Link-Manipulationsanfälligkeiten treten auf, wenn ein Skript vom Angreifer steuerbare Daten in ein Navigationsziel innerhalb der aktuellen Seite schreibt, wie z. B. einen anklickbaren Link oder die Übermittlungs-URL eines Formulars.

Sinks:

someDOMElement.href
someDOMElement.src
someDOMElement.action

Ajax-Anforderungsmanipulation

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

Ajax-Anforderungsmanipulationsanfälligkeiten treten auf, wenn ein Skript von einem Angreifer steuerbare Daten in eine Ajax-Anforderung schreibt, die unter Verwendung eines XmlHttpRequest-Objekts ausgegeben wird.

Sinks:

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

Lokale Dateipfadmanipulation

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

Lokale Dateipfadmanipulationsanfälligkeiten treten auf, wenn ein Skript vom Angreifer steuerbare Daten an eine Dateiverwaltungs-API als Parameter filename übergibt. Diese Schwachstelle kann von einem Angreifer ausgenutzt werden, um eine URL zu konstruieren, die, wenn sie von einem anderen Benutzer besucht wird, dazu führen könnte, dass der Browser des Benutzers eine beliebige lokale Datei öffnet oder schreibt.

Senken:

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

Client-Seitige SQL-Injektion

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

Client-seitige SQL-Injektionslücken treten auf, wenn ein Skript angreifersteuerbare Daten auf unsichere Weise in eine clientseitige SQL-Abfrage einbezieht.

Sinks:

executeSql()

HTML5-Speichermanipulation

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

HTML5-Speichermanipulationsanfälligkeiten treten auf, wenn ein Skript von einem Angreifer steuerbare Daten im HTML5-Speicher des Webbrowsers (localStorage oder sessionStorage) speichert. Während diese Aktion an sich keine Sicherheitsanfälligkeit darstellt, wird es problematisch, wenn die Anwendung anschließend die gespeicherten Daten liest und unsicher verarbeitet. Dies könnte einem Angreifer ermöglichen, den Speichermechanismus zu nutzen, um andere DOM-basierte Angriffe durchzuführen, wie z. B. Cross-Site-Scripting und JavaScript-Injektion.

Senken:

sessionStorage.setItem()
localStorage.setItem()

XPath-Injektion

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

DOM-basierte XPath-Injektionsanfälligkeiten treten auf, wenn ein Skript von einem Angreifer steuerbare Daten in eine XPath-Abfrage einbezieht.

Sinks:

document.evaluate()
someDOMElement.evaluate()

Client-seitige JSON-Injektion

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

DOM-basierte JSON-Injektionsanfälligkeiten treten auf, wenn ein Skript angreifersteuerbare Daten in einen String einbettet, der als JSON-Datenstruktur geparst und dann von der Anwendung verarbeitet wird.

Sinks:

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

Web-Nachrichtenmanipulation

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

Web-Nachrichten-Schwachstellen entstehen, wenn ein Skript angreifersteuerbare Daten als Web-Nachricht an ein anderes Dokument im Browser sendet. Ein Beispiel für anfällige Web-Nachrichtenmanipulation finden Sie im Web Security Academy von PortSwigger.

Sinks:

Die Methode postMessage() zum Senden von Web-Nachrichten kann zu Schwachstellen führen, wenn der Ereignislistener zum Empfangen von Nachrichten die eingehenden Daten auf unsichere Weise verarbeitet.

DOM-Datenmanipulation

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

DOM-Datenmanipulationsschwachstellen entstehen, wenn ein Skript angreifersteuerbare Daten in ein Feld innerhalb des DOM schreibt, das in der sichtbaren Benutzeroberfläche oder der clientseitigen Logik verwendet wird. Diese Schwachstelle kann von einem Angreifer ausgenutzt werden, um eine URL zu erstellen, die, wenn sie von einem anderen Benutzer besucht wird, das Aussehen oder Verhalten der clientseitigen Benutzeroberfläche ändern kann.

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

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

DOM-basierte Denial-of-Service-Schwachstellen treten auf, wenn ein Skript angreifersteuerbare Daten unsicher an eine problematische Plattform-API übergibt. Dies umfasst APIs, die, wenn sie aufgerufen werden, dazu führen können, dass der Computer des Benutzers übermäßige Mengen an CPU oder Festplattenspeicher verbraucht. Solche Schwachstellen können erhebliche Nebenwirkungen haben, wie z.B. dass der Browser die Funktionalität der Website einschränkt, indem er Versuche ablehnt, Daten im localStorage zu speichern oder beschäftigte Skripte beendet.

Sinks:

requestFileSystem()
RegExp()

Dom Clobbering

{% content-ref url="dom-clobbering.md" %} dom-clobbering.md {% endcontent-ref %}

Erlernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!