64-Bit-ASLR unter Linux x86-64 brechen

In diesem Artikel bespreche ich die Anwendung der Technik, die von Samuel Groß in seinem Blogbeitrag Remote iPhone Exploitation Part 2: Bringing Light into the Darkness -- a Remote ASLR Bypass beschrieben wurde, um ASLR unter Linux x86_64 zu umgehen.

Um das zu zeigen, werde ich eine Pwnable-Challenge von Buckeye CTF lösen, nämlich guess_god.

Ich werde versuchen, den Inhalt so anfängerfreundlich wie möglich zu halten. Du kannst also gerne jeden Abschnitt überspringen, wenn du dich sicher genug fühlst und nur den Exploit sehen möchtest.

0. Einleitung

Ich habe nicht am CTF teilgenommen, aber ich wurde etwa 2 Stunden vor dem CTF-Ende dank Guray00 auf die Challenge aufmerksam, der im fibonhack-Discord nach Hilfe bei einigen Krypto-Spielereien fragte.

Ich konnte ihm nicht helfen, aber ich habe mir die Pwnable-Challenges angesehen und dachte, es wäre gut, den P0-Blogbeitrag zu verstehen und hoffentlich diese Bounty zu bekommen.

1. ASLR und wie man es umgeht

1.1 Was ist ASLR?

### Memory-Mapping-Muster Wenn du das ein paar Mal machst, kannst du Folgendes ableiten: * Die PIE-Basis des Binaries sollte im Bereich 0x00005500_00000000-0x00005700_00000000 liegen, was 2TB möglicher Adressen bedeutet. * Der Heap befindet sich in der Nähe des Binaries. * Bibliotheken liegen im Bereich 0x00007f00_00000000 - 0x00007fff_ffffffff, also 1TB möglicher Adressen. * Der Stack liegt \(meistens\) im Bereich 0x00007ffc_00000000 - 0x00007fff_ffffffff, also 16gb möglicher Adressen. * Der Bereich 0xffffffffff600000 - 0xffffffffff601000 ist immer gemappt. Wenn du dich fragst, was es ist, kannst du [diesen Artikel](http://terenceli.github.io/%E6%8A%80%E6%9C%AF/2019/02/13/vsyscall-and-vdso) lesen. ## 1.3 So umgeht man ASLR ohne Infoleak Lass uns besprechen, was du tun kannst, um ASLR zu umgehen, wenn kein Informationsleck möglich ist. Dies ist mein Versuch, zusammenzufassen, was ich aus Saelos Blogpost mitgenommen habe. Um ASLR zu umgehen, brauchst du: * Eine Memory-Spraying-Technik, mit der du zusammenhängenden Speicher einer bestimmten Größe in einem bestimmten Adressbereich mappen kannst. Wie er sagt, gibt es zwei Möglichkeiten, das zu tun: 1. Durch das Ausnutzen eines Memory-Leaks (kein Informationsleck!), also eines Fehlers, bei dem ein Speicherblock „vergessen“ und nie freigegeben wird, und durch das mehrmalige Auslösen dieses Fehlers, bis die gewünschte Menge an Speicher ausgelaufen ist. 2. Durch das Finden und Ausnutzen eines „Amplification Gadgets“: ein Codeabschnitt, der einen vorhandenen Datenblock nimmt und ihn potenziell mehrfach kopiert, sodass der Angreifer eine große Menge an Speicher sprayen kann, indem er nur eine relativ kleine Anzahl von Bytes sendet. * Ein `isAddressMapped`-Orakel, das dir für eine Adresse sagt, ob diese Adresse gemappt ist oder nicht. ### PoC zum ASLR-Bypass unter Linux Lass uns versuchen, den PoC von saelo zu reproduzieren, um ASLR unter Linux vollständig zu brechen. <img src="https://assets.kitploit.com/production/public/readmes/48660/93fcc6aff8ffd2e8395f34b35bc2f5d244e74a53b2fac39c3dae35c802227339.png" > saelo's poc Unter Linux ist das nicht so einfach: Es ist möglich, ASLR nur dann vollständig zu brechen, wenn du in der Lage bist, 16gb Speicher zu allozieren.```C #include <stdio.h> #include <stdlib.h> int main() { // 64gb size_t size = 0x1000000000; // 16TB allocations for (int i = 0; i < 256; i++) { void *mem = malloc(size); // this ends up calling mmap if (!mem) { puts("Failed"); return 1; } printf("%p\n", mem); } unsigned int *mem = (void*)0x7f0000000000ULL; *mem = 0x41414141; printf("R/W to %p: %x\n", mem, *mem); return 0; }

mem	16-TB-Grenze überschritten?
0x7fb03b55e010	Nein
0x7fa03b55d010	Nein
0x7f903b55c010	Nein
0x7f803b55b010	Nein
0x7f703b55a010	Nein
0x7f603b559010	Nein
0x7f503b558010	Nein
0x7f403b557010	Nein
0x7f303b556010	Nein
0x7f203b555010	Nein
0x7f103b554010	Nein
0x7f003b553010	Nein
0x7ef03b552010	Ja
0x7ee03b551010	Ja
0x7ed03b550010	Ja
0x7ec03b54f010	Ja

Adresse	Ist Adresse gemappt?
0x7fe3f0000000	Nein
0x7fe3e0000000	Nein
0x7fe3d0000000	Ja
0x7fe3df000000	Nein
0x7fe3de000000	Nein
0x7fe3dd000000	Nein
0x7fe3dc000000	Nein
0x7fe3db000000	Nein
0x7fe3da000000	Nein
0x7fe3d9000000	Nein
0x7fe3d8000000	Nein
0x7fe3d7000000	Nein
0x7fe3d6000000	Ja
0x7fe3d6f00000	Nein
0x7fe3d6e00000	Nein
0x7fe3d6d00000	Nein
0x7fe3d6c00000	Nein
0x7fe3d6b00000	Nein
0x7fe3d6a00000	Ja
0x7fe3d6af0000	Nein
0x7fe3d6ae0000	Nein
0x7fe3d6ad0000	Nein
0x7fe3d6ac0000	Nein
0x7fe3d6ab0000	Nein
0x7fe3d6aa0000	Nein
0x7fe3d6a90000	Nein
0x7fe3d6a80000	Nein
0x7fe3d6a70000	Nein
0x7fe3d6a60000	Nein
0x7fe3d6a50000	Ja
0x7fe3d6a5f000	Nein
0x7fe3d6a5e000	Nein
0x7fe3d6a5d000	Nein
0x7fe3d6a5c000	Nein
0x7fe3d6a5b000	Nein
0x7fe3d6a5a000	Ja

how-to-bypass-aslr-on-linux-x86_64

Beliebteste

1.2 ASLR unter Linux

Hinweis zur glibc-Speicherallokation

Trick zur Grenzüberschreitung

2 Die Challenge

2.1 Erster Zugang

2.2 Lokale Umgebung einrichten und die Anwendung untersuchen

Beobachtungen

3.2 decompress.*

decompress()```C

We are at 0xffffffff, what can we add to reach 0?

Result = 0xffffffff00000001

That's the same as doing this

Untersuche die Memory-Mappings der Challenge

4.2 isAddrMapped-Orakel

Memory-Spray-Ergebnis```

Find upper bound, we can't do a binary search because there are some holes which

screw things up

Überschreibe libkyles memcpy@got und erlange RCE