Aidez - moi à comprendre cet exploit JavaScript

Vous devriez regarder dans la pulvérisation de tas:

Http://en.wikipedia.org/wiki/Heap_spraying

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. Spray et la mémoire sont juste un peu d'espace alloué sur le tas pour aider la condition exploitable se produire.

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

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

Ceci provient de metasploit, cela signifie qu'il utilise l'un des codes shell de metasploit. C'est open source donc vous pouvez aller le récupérer: http://www.metasploit.com/

Pour plus d'informations sur la vulnérabilité elle-même, je suggère de lire MS08-078 et le SDL.

Voir encodages de caractères en HTML .

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

Forme Commune de XSS aussi.

Vous pouvez voir toutes les astuces d'encodage ici:

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

Exemple Simple de shellcode

Bonjour le monde dans l'assemblage AT&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

Compiler 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 code shell, tapez: 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 4e ligne avec du texte, vous verrez: 400078: eb 1a jmp 0x400094

La partie qui dit eb 1a est l'hexadécimal représentation de l'instruction d'assemblage jmp one où " 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 \x avant chaque valeur hexadécimale.

L'exemple de code shell à venir 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. Maintenant vous avez de travail shellcode qui va écrire à 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 programme, tapez:

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

Exécuter avec ./run Vous savez avoir un exemple fonctionnel de développement de shellcode simple qui a été testé dans linux mint / debian.