hacktricks/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ebp2ret-ebp-chaining.md

EBP2Ret - EBP-Verkettung

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

Andere Möglichkeiten, HackTricks zu unterstützen:

• Wenn Sie Ihr Unternehmen in HackTricks beworben sehen möchten oder HackTricks im PDF-Format herunterladen möchten, überprüfen Sie die ABONNEMENTPLÄNE!
• Holen Sie sich das offizielle PEASS & HackTricks-Merch
• Entdecken Sie The PEASS Family, unsere Sammlung exklusiver NFTs
• Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.
• Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud GitHub-Repositories einreichen.

Grundlegende Informationen

Diese Technik nutzt die Möglichkeit, den Base Pointer (EBP) zu manipulieren, um die Ausführung mehrerer Funktionen durch sorgfältige Verwendung des EBP-Registers und der Befehlssequenz leave; ret zu verketten.

Zur Erinnerung bedeutet leave im Grunde genommen:

movl               %ebp, %esp
popl               %ebp
ret

Und da der EBP im Stack vor dem EIP liegt, ist es möglich, ihn zu kontrollieren, indem man den Stack kontrolliert.

EBP2Ret

Diese Technik ist besonders nützlich, wenn Sie den EBP-Register ändern können, aber keinen direkten Weg haben, das EIP-Register zu ändern. Sie nutzt das Verhalten von Funktionen aus, wenn sie ihre Ausführung beenden.

Wenn es Ihnen während der Ausführung von fvuln gelingt, einen gefälschten EBP im Stack einzuspeisen, der auf einen Speicherbereich zeigt, in dem die Adresse Ihres Shellcodes liegt (plus 4 Bytes für die pop-Operation), können Sie indirekt das EIP kontrollieren. Wenn fvuln zurückkehrt, wird der ESP auf diese manipulierte Position gesetzt, und die nachfolgende pop-Operation verringert den ESP um 4, sodass er effektiv auf Ihren Shellcode zeigt. Wenn die ret-Anweisung ausgeführt wird, wird die Kontrolle an Ihren Shellcode übertragen.

Exploit-Konstruktion

Zuerst müssen Sie Ihren Shellcode irgendwo in einem ausführbaren Speicher einspeisen und die Adresse abrufen, oder die Adresse zu einem gültigen ONE_GADGET erhalten, oder den ESP auf einen Ort zeigen lassen, an dem die Adresse von system() gefolgt von 4 Junk-Bytes und der Adresse von "/bin/sh" steht.

Dann erstellen Sie ein Padding und kompromittieren den EBP mit der Adresse des Shellcodes/one_gadget - 4. Es muss -4 sein wegen des pop. Dann wird der ESP auf unsere gewünschte Adresse zeigen und das ret wird ausgeführt.

Off-By-One Exploit

Es gibt eine spezifische Variante dieser Technik, die als "Off-By-One Exploit" bekannt ist. Sie wird verwendet, wenn Sie nur das am wenigsten signifikante Byte des EBP ändern können. In einem solchen Fall muss der Speicherort, der die Adresse des Shellcodes speichert, die ersten drei Bytes mit dem EBP teilen, was eine ähnliche Manipulation unter stärker eingeschränkten Bedingungen ermöglicht.

EBP Chaining

Daher ist es möglich, indem man eine kontrollierte Adresse in den EBP-Eintrag des Stacks und eine Adresse zu leave; ret in EIP platziert, den ESP zur kontrollierten EBP-Adresse im Stack zu verschieben.

Nun wird der ESP kontrolliert und zeigt auf eine gewünschte Adresse, und die nächste auszuführende Anweisung ist ein RET. Um dies auszunutzen, ist es möglich, an dieser kontrollierten ESP-Stelle Folgendes zu platzieren:

• &(nächster gefälschter EBP) -> Lädt den neuen EBP aufgrund von pop ebp aus der leave-Anweisung
• system() -> Aufgerufen von ret
• &(leave;ret) -> Wird nach dem Ende von system aufgerufen, es verschiebt den ESP zum gefälschten EBP und startet erneut
• &("/bin/sh")-> Parameter für system

Auf diese Weise ist es im Grunde genommen möglich, mehrere gefälschte EBPs zu verketten, um den Programmfluss zu kontrollieren.

Ehrlich gesagt, das ist wie ein ret2lib, aber komplexer ohne offensichtlichen Nutzen, könnte aber in einigen Randfällen interessant sein.