> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/de/useful-resources/exploit-development/linux-buffer-overflow-custom.md). # Linux-Buffer-Overflow - Custom Benutzerdefinierte Linux-Buffer-Overflow-Notizen zum Erstellen von Exploits, Kontrollieren des Ausführungsflusses, Erstellen von Payloads und Dokumentieren der Speicherbeschädigungs-Methodik. ## Erstes Beispiel für benutzerdefinierte Binärdateien (Pdmenu/exim):
Lade die Maschine herunter herausziehen
> Das erste Beispiel konzentriert sich auf die Ausnutzung des legitimen Binärprogramms exim-4.84-7, das eine als CVE-2016-1531 identifizierte Schwachstelle aufweist. Diese Schwachstelle ermöglicht es einem Angreifer, über das Missbrauchen bestimmter Umgebungsvariablen Befehle mit erhöhten Rechten auszuführen. * In diesem Fall, wenn wir auf den Benutzer Paul zugreifen, ein **Pdmenu** wird ihm mit bestimmten Funktionen zugewiesen (Verzeichnisauflistung, Dateibearbeitung, Ping-Ausführung usw.):
* Um dieses Menü zu verlassen, müssen wir **eine Datei bearbeiten**, zum Beispiel (etc/host):
* In diesem Fall, **vi** wird als Texteditor verwendet:
* Wenn wir uns **gtfobins**, wenn wir nach vi filtern, erhalten wir die Befehle, um Pdmenu zu verlassen und **eine Shell auszuführen**:
* Wir filtern **SUID** Dateien und finden eine namens exim:
* Mit der **searchsploit** Mit dem Werkzeug suchen wir nach möglichen Schwachstellen für dieses Binärprogramm:
* Laden wir nun das Skript herunter und stellen es bereit mit **python3** damit es geladen werden kann, nachdem die Maschine kompromittiert wurde:
* Wir führen das Skript aus und tatsächlich wird die Schwachstelle dieses Binärprogramms ausgenutzt, wir erhalten somit **Root-Zugriff**:
## Zweites Beispiel (Pufferüberlauf):
Lade die verwundbare Ubuntu Maschine
Installiere das Werkzeug Peda
> Das zweite Beispiel betrifft einen **Pufferüberlauf** in einem benutzerdefinierten [Binärdatei](https://hack4u.io/wp-content/uploads/2023/04/custom) auf einer 32-Bit-Linux-Maschine mit aktiven Schutzmechanismen und aktiviertem ASLR. In diesem Fall konzentrieren wir uns auf die Ausnutzung von ret2libc in einer Binärdatei mit SUID-Rechten, die root gehört. Durch den Pufferüberlauf zeigen wir, wie privilegierte Befehle eingeschleust und Benutzerrechte erhöht werden können. \***Pufferüberlauf** beinhaltet das Überschreiben bestimmter Systemregister, und da das Binärprogramm vom Benutzer erstellt wurde und zur root-Gruppe gehört, **wird es als privilegierter Benutzer ausgeführt**:
* Das Binärprogramm namens "custom" erwartet eine **Zeichenkette als Eingabe** und wenn es ausgeführt wird, passiert nichts:
* Aber wenn wir eine **sehr lange Zeichenkette**, gibt es einen Fehler zurück (Core dump):
Wir senden eine **kurze Zeichenkette** aus AAAAAAAA und keine **Fehler erscheinen**: * Um das Binärprogramm im Detail zu analysieren, werden wir das **gdb-peda** Werkzeug verwenden.
* Aber wenn wir **viele Zeichen**, erhalten wir den folgenden Fehler:
1. Das Erste, was zu tun ist, ist **die Gesamtzahl der Zeichenketten zu bestimmen** die benötigt werden, um das Register (EIP) zu überschreiben. * Die erste Methode besteht darin, ein **Muster** zu verwenden, das eine Kette erzeugt **räumlich gestaltet** (in diesen Fällen 300 Zeichen), die wir im Binärprogramm:
* In der Antwort von **EIP**, wissen wir, dass die **untere sichtbare Kette** „AA8A“ ist:
* Das **automatische** Modus des Programms ist mit dem `Muster-Offset $eip` Befehl:
* Um dies zu überprüfen, verwenden wir **python3** indem wir 112 A-Zeichen plus anschließend 4 B senden: ```bash r $(python3 -c 'print("A"*112 + "B"*4)') ``` * Tatsächlich bestätigen wir nun das Ende dank **EIP** das die letzten 4 B erkennt:
2. Sobald wir die maximale Anzahl an Zeichenketten kennen, **überprüfen wir ASLR** was bestimmt, ob es **Zufälligkeit in den Speicheradressen** gibt oder nicht: /- Mit dem folgenden Befehl filtern wir die Zeichenketten, die uns speziell interessieren, um das Binärprogramm 10 Mal auszuführen, zu sehen, ob es sich jedes Mal ändert, und zu sehen, ob die **C-Bibliothek** zufällig ist oder nicht: Es ist tatsächlich "zufällig"
3. Das Problem bei diesen **32-Bit** Binärprogrammen ist oft, dass wenn wir zum Beispiel jetzt **1000 Mal** A ausführen und nach einer festen Zeichenkette filtern, sehen wir jedes Mal, **wird es sich mindestens einmal wiederholen**:
4. Das Ziel ist nun zunächst, **EIP** Zeichenketten (**system + exit + bin/\_sh**), die immer fest sind und notwendig, um eine **Bash als root** wie im folgenden Beispiel, aber in Python:
* Wir erstellen einen **Haltepunkt** damit der Programmfluss an der gewünschten Stelle stoppt:
* Wir injizieren die **EIP** von (system/exit/bin/\_sh):
5. Sobald wir sehen, dass es **zufällig**, müssen wir **Brute Force** verwenden, bis der **base/\_libc/\_addr** dem gewünschten Wert entspricht: /- Mit dem folgenden sehen wir die **ausgeführten Bibliotheken** (in diesem Fall **libc.so**):
* Mit **readelf**, unsere Filter für die Bibliothek und suchen nach den zuvor injizierten Variablen, die (**exit and system**) mit den Codes:
* Und um die Zeichenkette **/bin/sh**, gehen wir wie folgt vor und fügen ein **0x00** am Anfang hinzu:
Das folgende Python3-Skript wird **den gesamten Brute-Force-Angriff automatisieren** bis **base/\_libc/\_addr** gleich ist: ```python #!/usr/bin/python3 import subprocess from struct import pack import sys offset = 112 before_eip = b"A" * 112 # Benutzerdefinierter Linux-Pufferüberlauf base_libc_addr = 0xb7595000 system_addr_off = 0xb7d86db0 exit_addr_off = 0xb7d7a9e0 bin_sh_addr_off = 0xb7ea7b2b system_addr = pack("
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://hacking-notes.jord4n.pro/de/useful-resources/exploit-development/linux-buffer-overflow-custom.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.