Utilizando Um Debugger - OllyDbg

Usuário Lembrar?

Senha

FórumGdH Home do Hardware.com.br

Utilizando um debugger - OllyDbgProgramação, scripts, web e banco de dados

1. Utilizando um debugger - OllyDbg

23-09-2007 por Fergo

Utilizando um debugger - OllyDbg

Boa noite pessoal!Ultimamente tenho visto uma certa quantidade de posts relativos a programação em linguagemassembly e ao uso de debuggers (seja para depuração ou para fazer adaptações). Resolvi criaruma pequena série de tutoriais (comecei hoje) cobrindo alguns conceitos interessantes sobre autilização de debuggers e um pouco de engenharia reversa. A medida que eu vou escrevendoeu vou postando aqui, em forma de post mesmo.

Por enquanto escrevi apenas uma introdução e o esclarecimento de alguns conceitos. Estoupensando ainda no aplicativo que vou programar para usar como exemplo de análise, masprovavelmente eu faça apenas aquele programa clássico de "adivinhe o número" (escolha umnúmero de 1 a 10...). Pretendo utilizar o OllyDbg nos tutoriais, pois é o meu debugger prediletoe o que estou mais familiarizado (gratuito e pequeno).

Sumário:

Introdução e conceitos1.Um pouco de assembly2.Interface do Olly Debugger3.Formas de aproximação4.Re-assembly5.Plugins6.

Mais capítulos em breve!

INTRODUÇÃO

Seguindo a minha linha de tutoriais voltados a programação, vou tratar sobre um assunto queme interessa muito e talvez seja interessante para os programadores em geral: disassembler edebuggers.

Primeiramente seria interessante esclarecer um pouco sobre o que é um debugger e o que éum disassembler, pois apesar de andarem quase sempre juntos, possuem finalidades diferentes.

Disassembler é algo que consegue transformar linguagem de máquina para a linguagemassembly, transcrevendo as instruções enviadas ao processador para os seus mnemônicos emassembly (asm). Não deve ser confundido com um descompilador, que procura converter ocódigo nativo em uma linguagem de mais alto nível como C, C++ ou Basic.

Debuggers são programas capazes de analisar, depurar e testar aplicações. Atualmente amaioria das IDEs de programação contam com um debugger embutido (Visual Studio, porexemplo). A principal utilidade deles é para a identificação e tratamento de erro, sendo que épossível rodar o código linha por linha (ou instrução por instrução) e analisar a mudança dasvariáveis e do comportamento do código. Os debuggers de binários já compilados - como os

Utilizando um debugger - OllyDbg http://www.hardware.com.br/comunidade/utilizando-debugger/785195/

1 de 18 29/4/2014 09:25

executáveis do Windows (EXE) - seguem o mesmo conceito dos depuradores normais, masdevido ao fato de o código já ter sido compilado, ele precisa ter um disassembler embutido nodebugger para decodificar as instruções.

Atualmente existem dezenas de debuggers e disassemblers por aí, dentre os quais os maisfamosos são: W32DASM, IDA, WinDbg, SoftICE e Ollydbg. Neste tutorial será utilizado oOllyDbg, pois é um dos melhores e mais poderosos debuggers (incluindo um disassembler)disponíveis no mercado. É também pequeno e gratuito

Site oficial do OllyDbg, com o link para download: http://www.ollydbg.de

QUAL A UTILIDADE UM DEBUGGER?

Muita gente se pergunta do porquê de usar um debugger, sendo que na maioria dos casos vocêtem a acesso ao código fonte original (caso você tenha programado o aplicativo). Vou citarabaixo algumas das maiores utilidades de um debugger:

Tratamento de erro. Certamente uma das principais. Às vezes durante a programação deum aplicativo um pequeno erro passou despercebido, ocasionando mal funcionamento ougerando uma operação ilegal. Em muitos casos é mais fácil você analisar o binário jácompilado dentro de um debugger do que tentar encontrar o erro no código original.Dentro desse mesmo item podemos citar a correção de bugs de aplicações jádescontinuadas (desde que com a autorização da empresa dona dos direitos).

Engenharia reversa. O processo de engenharia reversa de software não poderia ser feitode forma eficiente sem a utilização de um debugger/disassembler. Muitas pessoas tendema confundir cracking com engenharia reversa, sendo que são conceitos diferentes. Aengenharia reversa por si só é uma atividade completamente legal, pois muito do quevemos hoje só foi possível devido à engenharia reversa. A criação de drivers para Linuxde periféricos que antes só funcionavam com o Windows (WinModems) é um bomexemplo de como a engenharia reversa traz coisas boas para nós.

Aprendizado. O uso de debuggers e engenharia reversa é uma das melhores formas de seaprender a linguagem assembly. Você programa algo em uma linguagem de médio ou altonível e posteriormente analisa o resultado do binário compilado dentro de um debugger.Com esse conhecimento é possível dominar melhor a linguagem e criar algoritmos maisotimizados e eficientes.

CONCEITOS NECESSÁRIOS

Para entender o funcionamento de um debugger é preciso saber um pouco sobre algunsconceitos ligados a informática, como o funcionamento da memória, processador, pilhas eendereços. O conhecimento básico de assembly também é necessário, já que essa é alinguagem que teremos de analisar. Caso não tenha experiência em assembly, fique tranqüilo,pois nos capítulos seguintes darei uma visão geral sobre ela, o suficiente para entender o nossomini-aplicativo de estudo. Abaixo segue uma breve lista de conceitos:

Processador/CPU: É o cérebro de todo computador. É ele que decodifica as instruções eexecuta os códigos operacionais. É composto basicamente por uma unidade lógico-aritmética (ALU), unidade de ponto flutuante (FPU), registradores, cachê, barramento egerador de clock.

Memória RAM: Local de armazenamento temporário de dados (são apagados ao desligaro computador). Todo aplicativo se utiliza da memória para armazenar seus dados e estessão buscados e gerenciados pelo processador.

Endereçamento de memória: É uma faixa de valores que apontam para umadeterminada posição de memória. Toda vez que você escreve ou lê algum dado damemória é necessário indicar o endereço de onde está aquele valor, para que oprocessador possa buscá-lo.

Pilha (Stack): É uma estrutura de dados. Sua principal característica é a forma de


2 de 18 29/4/2014 09:25

funcionamento, onde você apenas coloca ou retira os valores, sem indicar um endereço(LIFO – Last in, First Out – Último a entrar, primeiro a sair). Ela funciona de formasemelhante a uma pilha de livros em que você vai os empilhando. Quando precisarremover um deles, é necessário tirar todos os livros de cima.

Registradores: Pequenas partes de memória presentes dentro dos processadores (nãoconfundir com memória RAM). Extremamente rápidas, sendo que a CPU as utiliza comoforma temporária de armazenamento de dados e realização de operações. A quantidadede dados que podem ser armazenados vai depender do tipo de processador. Osprocessadores de 32 bits conseguem armazenar números de até 32 bits em cadaregistrador, sem precisar de rotinas de conversão.

Parte 2 em breve. Provavelmente com imagens já.

Abraços,Fergo


Continuação...

UM POUCO DE ASSEMBLY

Para fazer o debug de binários compilados é necessário ter um conhecimento (ao menos básico)da linguagem assembly, já que é para ela que a linguagem de máquina é traduzida.

Assembly (ou asm, com é abreviada) é uma linguagem de baixo nível que basicamenteinterpreta os códigos operacionais (opcodes, veja abaixo) e os transcreve para seusmnemônicos. É literalmente uma tradução da linguagem de máquina. O uso da linguagemassembly pode ser bem variado, podendo fazer de tudo um pouco, mas é amplamente utilizadana programação básica de Kernels e em algoritmos que precisam ser altamente otimizados,onde asm é a linguagem ideal, já que é puramente linguagem de máquina traduzida.

Não pretendo agora explicar todo o funcionamento, estrutura e comandos da linguagem. Voudar apenas um apanhado geral sobre alguns termos e uma breve descrição sobre os comandosmais básicos e corriqueiros que se encontra. Precisamos primeiramente definir o que sãomnemônicos e o que são os opcodes.

Opcodes (traduzido em operational code, ou código de operação) é a instrução que é enviada einterpretada pelo processador. Cada opcode, ao ser interpretado pelo processador, vai realizaruma operação. Mnemônicos são as palavras ou combinação de letras utilizadas pararepresentar um opcode, tornando a linguagem de máquina mais legível. Veja abaixo umexemplo de um mnemônico do comando MOV:

Código:

MOV EAX,1

Esse comando em assembly apenas move o valor 1 para o registrador EAX (veremos isso logoadiante na explicação dos comandos). Na hora de transformar isso em linguagem de máquina(por um asssembler), esse comando é traduzido para um conjunto de números que possa serinterpretado pelo processador:

Código:

B801000000

A teoria por trás de tradução de mnemônicos em opcode (e vice-versa) é um tanto complexa,principalmente para a plataforma Intel na arquitetura IA32. É um processo que deve serrealizado bit a bit e fugiria um pouco do contexto deste tutorial.


3 de 18 29/4/2014 09:25

A principal dificuldade na linguagem assembly é certamente a sua estrutura, que foge dopadrão de linguagens de mais alto nível como C ou Pascal. Nada de Ifs com múltiplascomparações, Switches, For ou While. Tudo é feito com comparações simples e saltos, perdendoa sua linearidade (semelhante aos GoTo do BASIC).Felizmente hoje temos debuggers muito inteligentes que conseguem estruturar e identificarrotinas e repetições, facilitando muito o trabalho de interpretação. Mesmo com essas melhorias,ainda acho importante ter um papel e uma caneta ao lado, onde você pode fazer anotações e irestruturando/convertendo o código na medida em que você os interpreta.

Para o assembly, a localização dos valores e variáveis é sempre baseada nos endereços que elasocupam na memória. O nome que você define para uma variável durante a programação ésubstituído pelo endereço de memória que ela ocupa. Cada instrução também possui umendereço, que é utilizado para controlar o fluxo e a estrutura do código. Sempre que você fazum salto, é necessário indicar o endereço que o código deve ser direcionado, semelhante aoque ocorria nas numerações de linhas dos BASICs mais antigos. Veja um exemplo abaixo decomo ficaria um código em C e o seu resultado compilado para assembly, utilizando apenasregistradores comuns:

Código:

void main() {

int a = 4;

int b = 6;

int c;

if((a == 4) && (b == 6)) {

c = 5;

}

}

O código acima quando compilado pode se transformar em algo semelhante a isso (boa parte docódigo acima é inútil, estou utilizando somente para exemplificar):

Código:

00000000 MOV EAX,4h ;move o valor 4 para EAX

00000005 MOV EBX,6h ;move o valor 6 para EBX

0000000A CMP EAX,4h ;compara EAX com 4, se for verdadeiro: ZF = 1

0000000D JNE 00000019h ;se ZF != 1, pule para endereço 00000019h

0000000F CMP EBX,6h ;compara EBX com 6, se for verdadeiro: ZF = 1

00000012 JNE 00000019h ;se ZF != 1, pule para endereço 00000019h

00000014 MOV ECX,5h ;move o valor 5 para ECX

00000019 RETN ;finaliza execução e retorna

Pra entender o código acima é necessário entender sobre aquilo que compõe a linguagemassembly. Ela é basicamente composta por registradores, endereços e instruções(mnemônicos).

Os registradores foram explicados no capítulo anterior, mas vamos agora saber quem são eles.Os processadores da arquitetura Intel de 32 bits possuem basicamente nove registradores de32 bits comuns: EAX, EBX, ECX, EDX, ESP, EBP, ESI, EDI e EIP. Teoricamente cada um dessesregistradores possui uma determinada “função padrão”, mas devido a sua escassez, muitasvezes eles são utilizados como registradores para qualquer propósito. Você pode criar umcódigo usando livremente os oito primeiros registradores que não haverá muitos problemas(desde que saiba o que está fazendo/modificando). O último registrador, EIP, é quase sempremantido intacto, pois ele é o responsável por contar as instruções e informar o endereço dapróxima instrução. Alterar o seu valor pode desviar completamente o fluxo do aplicativo eprovavelmente vai gerar uma falha de segmentação ou uma operação ilegal.


4 de 18 29/4/2014 09:25

Esses registradores apresentados são todos de 32 bits. No entanto também é possível utilizarapenas 8 ou 16 bits, como mostra a tabela abaixo utilizando o EAX como exemplo (a teoria valepara os outros registradores também):

Para o caso da porção de 8 bits, o registrador terminado em L são os 8 bits menos significantesde AX e o terminado em H são os 8 bits mais significantes de AX. Para a porção de 16 bits, sãoutilizados os 16 bits menos significantes da porção de 32 bits.

Além dos registradores, também existem as Flags, que são bits utilizados como resultado deoperações (verdadeiro ou falso, por exemplo). Elas são usadas principalmente para análisecondicional em instruções como CMP e TEST. Dentre as diversas flags, as mais corriqueiras são:ZF (Zero Flag), CF (Carry Flag) e SF (Signal Flag). A ZF é setada sempre que uma operaçãoresulta em zero (uma comparação entre dois números através do comando CMP subtrai seusoperandos sem alterar valores e seta a ZF caso o resultado da subtração seja zero, indicandovalores iguais). A flag CF é setada quando o resultado de uma operação estoura o valor máximocomportado pelo registrador/local sem considerar o sinal (overflow). Por último, tempos a SF,que é ativada sempre que o bit mais significativo de um operando for 1, indicando um valornegativo (pesquise sobre complemento de dois).

Os endereços na linguagem assembly são a base para o fluxo do aplicativo e para oarmazenamento de dados. As variáveis que você usa durante a programação são substituídaspor endereços que apontam para uma área da memória paginada com acesso a leitura e aescrita. Os destinos dos saltos (Jumps) também dependem dos endereços das instruções, pois éatravés deles que você informa o destino do salto.O código abaixo demonstra apenas uma linha de assembly onde é possível ver o endereço dainstrução (00401000) e o endereço para um byte de memória (00403000) para o qual onúmero nove está sendo movido:

Código:

00401000 MOV BYTE PTR DS:[00403000], 09h

Por último temos as instruções, que nada mais são do que os opcodes traduzidos em ummnemônico, como demonstrado e exemplificado alguns parágrafos acima.Abaixo eu vou por uma pequena lista mostrando algumas das instruções mais utilizadas, poisseria inviável colocar todas elas (são aproximadamente 130 instruções bases para a arquiteturaIntel).

MOV destino, origemMove o valor do campo origem para o destino. Essa instrução possui diversas variações,por isso ela pode aparecer de diversas formas diferentes (pode-se trabalhar comconstantes, memória, pilha, etc). Alguns exemplos:

MOV EAX, 10h

MOV AX, WORD PTR DS:[00403000]

MOV BYTE PTR DS:[00403002], 1Ch

CMP arg1, arg2Realiza uma comparação entre os dois operandos. A comparação é feita simplesmentesubtraindo os dois operandos e caso o resultado for zero (valores iguais), ele seta a ZFpara 1. Vale lembrar que essa operação não altera os valores dos operandos, apenas asflags.

CMP EAX, 04h


5 de 18 29/4/2014 09:25

JMP endereçoFaz um salto incondicional e obrigatório para o endereço indicado.

JMP 00401008h

JZ endereço / JE endereçoFaz um salto condicional. Caso o valor da zero flag seja 1, ele realiza o salto.Normalmente utilizado junto com um CMP para realizar um desvio caso a comparaçãoseja verdadeira.

JE 0040101Ah

JNZ endereço / JNE endereçoSemelhante ao item acima, mas realiza o salto somente quando a zero flag não foi setada(ZF = 0).

JNZ 0040102Ch

ADD destino, arg1Adiciona o valor de arg1 ao destino. Também possui diversas variações, pelas mesmasrazões do comando MOV. Se o resultado estourar o limite do destino, a CF é setada.

ADD EBX, 04h

ADD EBX, DWORD PTR DS:[00403032]

SUB destino, arg1Realiza uma subtração dos operandos. As variações e características são as mesmas docomando ADD.

SUB ECX, 2Ah

PUSH valorColoca o valor no topo da pilha (Stack). O comando PUSH é amplamente utilizado naschamadas de funções (CALL), pois é através da pilha que a função busca seusargumentos.

PUSH 08h

POP destinoRemove o valor do topo da pilha e o armazena no destino.

POP EAX

CALL localFaz chamada a uma função. É possível passar o local de diversas formas para o comandoCALL, desde uma constante, registrador ou até mesmo uma função externa dentro deuma DLL. O comando CALL usa a pilha para indicar o endereço para o qual a função deveretornar depois de finalizada a sua execução.

CALL User32!GetDlgItemTextA

CALL 0040115Fh

Essas são as instruções mais comuns dentro de um binário compilado. Claro que existe mais deuma centena delas, mas eu procurei colocar aqui apenas aquelas que serão utilizadas noaplicativo de aprendizado. Para uma lista completa com uma explicação mais profunda dosopcodes, recomendo ver a lista apresentada neste endereço:http://www.numaboa.com.br/informatic...ncias/opcodes/

O próximo capítulo cobrirá a parte da apresentação da interface do OllyDbg para depoispodermos realmente colocar a mão na massa e analisar um binário.

Comentários/críticas/sugestões são bem vindas, claro (não me importo que as partes não


6 de 18 29/4/2014 09:25

fiquem em sequência).

Abraços!Fergo

23-09-2007 por philix

Ô cara!! Para que vc faz um tutorial tão bom?! Vou ter que parar meu serviço para ler agora!23-09-2007 por Etinin

Nota 10 como praticamente todos seus tutos anteriores, Fergo!25-09-2007 por Fergo

Valeu pelo suporte pessoal! Aí vai mais um pedaço

INTERFACE DO OLLY DEBUGGER

Após uma boa parte teórica, chegou a hora de por em prática aquilo que acabamos de estudar.Neste capítulo vou apresentar um pouco da interface do OllyDbg, que apesar de intuitiva,merece esclarecimentos.

Para o nosso estudo, eu criei um simples aplicativo que iremos depurar mais a frente. Ele énecessário neste já neste capítulo (não para depuração, mas para a apresentação dos itens doOlly). Você pode baixar o arquivo executável juntamente com o seu código fonte (programadoem assembly na sintaxe MASM32 utilizando o WinAsm Studio como IDE) no link abaixo:http://www.fergonez.net/files/adivinhe.rar

O OllyDbg pode ser baixado gratuitamente através do site http://www.ollydbg.de. É bempequeno e não necessita instalação, basta extrair o conteúdo para uma pasta qualquer.

Após extraído, abra o Olly, vá em “File->Open” e abra o nosso arquivo de estudo(adivinhe.exe). Rapidamente o Olly vai interpretar o arquivo e mostrar o disassembly na janelaprincipal. Vamos deixar essa parte mais frente, já que o objetivo deste capítulo é apenasmostrar a interface, sem depurar o aplicativo por enquanto. A tela deve ser semelhante a essa:


7 de 18 29/4/2014 09:25

A interface do aplicativo é composta por poucos botões. O segredo do Olly é o botão direito domouse. A maioria das funções existentes no aplicativo pode ser acessada através do botãodireito do mouse, sendo que os itens exibido no menu de popup variam de acordo com o localonde foi dado o clique (dependendo da coluna e da região).

Eu numerei as principais regiões da tela de 1 a 4.

Região 1

Esta é a tela principal do programa, onde é apresentado o disassembly do aplicativo. Ela édividida em quatro colunas:

Coluna 1 – Address. Ela nos mostra o endereço virtual das instruções (para saber maissobre esse endereçamento, veja meu artigo sobre o funcionamento dos executáveis).Você pode reparar que os endereços não são em intervalos iguais para cada instrução.Isso ocorre devido ao fato de que o tamanho das instruções ser variável, como podemosobservar na segunda coluna.

Coluna 2 – Hex Dump. Aqui temos o código da instrução no seu formato hexadecimal (acada 2 caracteres, temos 1 byte). São esses valores que ficam armazenados dentro doarquivo executável e que são passados para o processador. Como mencionado noparágrafo anterior, as instruções variam de tamanho, sendo que o endereço da próximainstrução é dado pelo endereço da instrução atual mais a soma dos bytes da instrução.Veja o exemplo do nosso aplicativo de exemplo. Ele começa no endereço 00401000(padrão do Windows) e a sua primeira instrução é composta por 2 bytes (6A 00). Oendereço da próxima instrução (na linha de baixo) vai ser o endereço atual somado como tamanho da instrução (00401000+2) = 00401002.

Coluna 3 – Disassembly. Essa coluna nada mais é do que a interpretação e a tradução


8 de 18 29/4/2014 09:25

para assembly das instruções presentes na segunda coluna. A análise do aplicativo é feitaquase que inteiramente nela.

Coluna 4 – Comments. Essa coluna não influencia no aplicativo, ela é utilizada apenaspara comentários e informações. O Olly a utiliza para identificar as chamadas de funçãojuntamente com os seus argumentos (você pode ver que ele identifica as chamadas daAPI do Windows em vermelho e lhe mostra os argumentos, facilitando e muito ainterpretação).

Região 2

Essa área mostra todos os registradores e flags que nós vimos anteriormente (juntamente comdiversos outros valores). A cada instrução essa tela é atualizada, mostrando o estado atual decada um dos itens. Caso algum desses itens tenha sido modificado de uma instrução para outra,o Olly as colore com outra cor (nesse caso é o vermelho). As flags são mostradas logo abaixodos registradores, abreviadas com a letra C (Carry Flag), Z (Zero Flag) e S (Signal Flag)

Região 3

Essa região nos mostra a memória física (RAM) destinada ao aplicativo. É possível observar ovalor de cada byte de memória dentro do espaço reservado ao aplicativo. É composta por trêscolunas:

Coluna 1 – Address. Mostra os endereços virtuais de memória.

Coluna 2 – Hex Dump. Este espaço contém o valor de cada byte da memória. Por padrãoo Olly coloca 8 bytes por linha e por essa razão a coluna de endereços cresce de 8 em 8bytes.

Coluna 3 – ASCII. Essa coluna pode ser utilizada para exibir de formas diferentes osvalores contidos na memória. Por padrão o Olly opta por exibir a representação ASCIIdesses valores. O modo de representação pode ser alterado utilizando o botão direito domouse.

Região 4

Mostra o estado atual da pilha (stack). Como visto anteriormente, a pilha é amplamenteutilizada durante as chamadas de função. O VisualBasic é uma linguagem que faz um uso muitogrande da pilha, principalmente pela quantidade de funções que são utilizadas pelo aplicativo.Também é dividida em 3 colunas :

Coluna 1 – Address. Cumpre o mesmo papel das outras colunas de endereço. Nota-seque o endereço cresce de quatro em quatro bytes, pois cada posição da pilha é ocupadapor um tipo DWORD (4 bytes)

Coluna 2 – Value. Valor armazenado naquele endereço da pilha

Coluna 3 – Comment. Utilizado para comentários e mostrar informações relevantessobre aquele endereço. O Olly identifica diversos itens da pilha (como endereços deretorno) e adiciona essas informações na coluna de comentários.

Além das regiões nós temos a barra de ferramentas:

Abaixo uma descrição de cada botão, da esquerda para a direita.

Open - Abre o executável para depuraçãoRestart – Recarrega o aplicativo atualClose – Fecha a aplicação carregada


9 de 18 29/4/2014 09:25

Play – Inicia a execução e depuração do aplicativo. Caso nenhum breakpoint tenha sidoposicionado (veremos adiante), o programa será executado normalmente.Pause – Pausa o aplicativo em andamento

Step Into – Caso um breakpoint tenha sido colocado em uma chamada de função, essebotão lhe permite fazer a depuração do conteúdo dessa função.Step Over – O contrário do item anterior. Ele simplesmente não “entra” dentro dachamada (mas ainda assim a executa), continuando a depuração na próxima instrução.Trace Into – Utilizado apenas quando está se faz backtracing. Ele registra as ações eendereços em um log, registrando também o conteúdo das funções chamadas.Trace Over – Semelhante ao item acima, mas não faz o registro do conteúdo daschamadas.

Execute Till Return – Executa as instruções até encontrar o primeiro comando deretorno (RETN).

Go to Address – Permite ao usuário especificar um endereço do código para visualizar.

Após os comandos básicos de depuração, temos os botões das janelas:

L – Show Log Window: exibe um log, no qual o Olly registra algumas ações comocarregamento de plugins, etc.E – Show Modules Window: exibe todos os módulos e funções externas utilizados peloprograma (DLLs). Com o menu direito é possível acessar uma gama de opções dentrodessa janela (o mesmo vale para todas as outras janelas que forem mencionadas). Essajanela de módulos é muito importante para configurar breakpoints nas APIs do Windows,facilitando a aproximação em determinada região do código.M – Show Memory Window: mostra o estado da memória que está sendo utilizado peloaplicativo, incluindo as seções do executável e tabelas de importação/exportação. Paraum detalhamento byte a byte da memória, deve se utilizar a região de memória físicamostrada na janela principal do aplicativo.T – Show Threads: exibe o estado de cada thread contida no aplicativo. Em aplicaçõesmulti-threading é possível, através dessa janela, ter um controle sobre cada uma dasthreads.W – Show Windows: mostra a estrutura e configuração das janelas carregadas peloaplicativo (definida pelo WinProc). Os dados só são mostrados com o programa emexecução e precisa ser atualizada manualmente pelo usuário (através do botão direito domouse).H – Show Handles: exibe uma informação detalhada sobre os handles (referência a umobjeto) que estão sendo utilizados pelo aplicativo. Quando o aplicativo abre um arquivo, éretornado um handle, que é utilizado para fazer a leitura e escrita, por exemplo.C – Show CPU: janela padrão do aplicativo, que é aberta automaticamente na hora decarregar o alvo. O seu conteúdo já foi explicado nos itens anteriores (onde as regiõesforam numeradas de 1 a 4)./ - Show Patches: as modificações feitas no executável ficam registradas nessa janela,facilitando a modificação ou o retorno à instrução original.K – Show Call Stack: mostra uma pilha de todas as chamadas de função até então feitaspelo aplicativo.B – Show Breakpoints Window: exibe todos os breakpoints setados no programa alvo.R – Show references: exibe todas as referências encontradas durante uma busca (sejaela uma constante, instrução, string). Veremos mais sobre elas adiante.... – Run Trace: nessa janela é mostrado o resultado da operação de tracing(mencionada quando falamos de Trace Into/Over). Tracing é um processo um poucocomplicado, por isso a sua explicação detalhada será apresentada mais a frente (épossível encontrar uma boa explicação na própria ajuda do Olly).S – Show Source: quando o aplicativo alvo é compilado com as informações de debug,normalmente o código assembly resultante também é armazenado. Nesse caso essajanela exibe esse código e mostra em tempo real o local no código fonte original que estásendo executado no momento. Muito útil para comparar o código assembly escrito e ocompilado.

Por último temos os botões de configuração e ajuda.


10 de 18 29/4/2014 09:25

Debugging Options – Exibe a janela de configuração do Olly. A princípio não énecessário alterar nada para fazer a depuração, a não ser que você tenha noção de ondeestá mexendo.Appearence – Permite configurar o esquema de cores. Recomendo alterar essasconfigurações para algo que lhe agrade, fazendo um “syntax highlighting” do código,facilitando a leitura.Help – Mostra a janela de ajuda do Olly. A ajuda está em Inglês.

Estas foram as opções contidas na barra de ferramentas. O Olly também conta com um menutradicional, que contém basicamente as mesmas funções da barra de ferramentas. Um dos itensdo menu que vale a pena mencionar é o de plugins. O Olly suporta a criação de plugins, sendoalguns deles muito úteis. Por padrão ele vêm apenas com dois plugins, um de bookmarks eoutro de comandos, que adiciona uma caixa de texto no rodapé do programa onde você podeentrar com ações e comandos de forma semelhante ao SoftICE.

No rodapé do Olly fica uma pequena barra de status, que além de mostrar o estado atual doalvo (finalizado, pausado ou em execução), serve como um informativo.

No próximo capítulo pretendo colocar alguns conceitos importantes de depuração.

Abraços,Fergo

26-09-2007 por luishoc

Fergo parabéns por criar um tutorial tão exepcional como esse.Tópico bem explicativo.Falou![]'sluishoc

26-09-2007 por rhfpt

voce tem algum site para que possamos baixar esse tutorial?26-09-2007 por philix

Citação:

voce tem algum site para que possamos baixar esse tutorial?

O site dele que está na assinatura dele.26-09-2007 por Fergo

Valeu pelas respostas pessoal, fico grato.Por enquanto estou colocando o tutorial apenas aqui no GdH, talvez quando eu terminar eulanço um PDF dele. Mas como o philix mencionou, você encontra meus outros tutoriais no meusite (www.fergonez.net).

Abraços!Fergo

27-09-2007 por rhfpt

ops... nao havia percebido..

vlw. Muito bom esse tutorial. Parabéns27-09-2007 por Fergo

Valeu rhfpt.Amanhã tenho prova na faculdade então não sei se consigo escrever uma continuação do guiahoje, mas tentarei.

Abraços,Fergo

27-09-2007 por intruso

Muito bom o tópico, parabéns. :-)28-09-2007 por Fergo

Valeu galera!


11 de 18 29/4/2014 09:25

Quarta parte saindo do forninho. Desta vez fala de como encontrar aquilo que você quer nomeio de tanta instrução.

FORMAS DE APROXIMAÇÃO

Uma das maiores dificuldades em debugging de baixo nível (em assembly) é identificar o localonde se encontra aquele trecho de código de deseja analisar. Existem diversas manhas paraconvergir ao local correto, sendo que vou citar duas das mais utilizadas.

A primeira delas consiste em buscar em buscar por strings. Na maioria dos casos todo o textopresente em um aplicativo fica armazenado em uma string table (tabela de strings), cada umacom seu número identificador. Normalmente quem decide o que vai para a tabela de strings ouo que é referenciado diretamente no código é o compilador, por isso esse método nem sempre étotalmente funcional, mas costuma ter bons resultados.

Certo, mas que strings devemos procurar? Nós queremos é encontrar o local onde é feita acomparação do número digitado com o número correto. Se o número não for aquele que vocêdigitou, ele vai exibir uma mensagem, que contém um título e um texto. Isso é bastanteinteressante, pois a provável lógica do programa é verificar pelo número digitado e caso eleseja incorreto, nos mostrar a MessageBox. Se nós encontrarmos o local onde o texto é utilizadopela MsgBox, sabemos que estamos pertos e um pouco adiante de onde foi feita a verificação.

Há uma maneira bem direta de descobrir o local onde está a chamada para a MsgBox, mas voufocar mais no sistema de busca por string. Vamos lá. Entre com um valor qualquer (maior que0 e menor que 21) e mande verificar. Provavelmente você recebeu uma mensagem semelhantea essa:

Repare que ela é composta por um título e um texto. Que tal verificar se é possível buscaresses textos dentro do OllyDbg. Para tal, na janela principal, sobre o disassembly do código,clique com o botão direito e vá em “Search For -> All referenced text strings”. Isso farácom que o Olly mostre uma janela contendo todas as strings que são referenciadas por algumcomando dentro do código. Note que no conteúdo da janela apareceram três itens:

Podemos observar que temos três referências ao texto mensagem, ocorrendo em diferentesendereços. “Curiosamente” a string “Mensagem.” é o título da mensagem de texto querecebemos ao entrar com um valor errado. Isso significa que encontramos 3 possíveis locaisonde a caixa de texto é exibida. Uma maneira fácil de descobrir qual das três é a verdadeira(mais pra frente veremos que na realidade nenhuma delas é “falsa”, são apenas mensagens detexto diferentes) é setando um breakpoint sempre a mensagem de texto for referenciada. Paratal, clique com o botão direito em qualquer uma das linhas e selecione “Set Breakpoint onevery command”. Sempre que a mensagem for utilizada, o Olly vai pausar a execução e lhemostrar onde a execução foi congelada.

Com o breakpoint configurado, apenas digite novamente o número no aplicativo de teste (semfechar ou reiniciar o Olly). Assim que você clicar no botão, ao invés de exibir a mensagem denúmero incorreto, o Olly vai pausar a execução e lhe mostrar o local onde a referência de textofoi utilizada. Você deve ter parado aqui (linha marcada em cinza):


12 de 18 29/4/2014 09:25

Foi bem como queríamos. Paramos bem no local onde o endereço da mensagem é colocado napilha para ser utilizada pela função MessageBoxA:

Por curiosidade, note que temos 3 chamadas para a função MessageBox. Pelo texto de cadauma é possível identificar que a primeira é referente ao texto de quando você acerta o número,a segunda (que nós estamos) é de quando você erra e a última é para quando você entra comum valor fora do intervalo especificado. Isso explica também o fato de termos três referências astring “Mensagem.”, pois ela é utilizada pelas três chamadas.

Como mencionado anteriormente, esse método nos faz convergir para um local além de ondefoi feita a comparação (pois a mensagem de texto é exibida somente depois que o valor éverificado). Para encontrar a comparação a partir do local atual podem-se utilizar diversosmétodos. Alguns preferem simplesmente ir analisado o código acima da MsgBox “na mão” oufazer um backtrace, que consiste em analisar o código asm inversamente. Como esse aplicativoé bem pequeno, fica fácil achar o local na marra, mas vou dar uma visão sobre o backtracing. OOlly felizmente possui várias funções que ajudam na interpretação do código, sendo que vamosutilizar as referências de salto para essa situação. Para chegar até a mensagem de texto, muitoprovavelmente foi feito um salto, já que a provável lógica seria:

Adquire os dados digitados pelo usuário1.Compara com o valor real2.É igual?3.Caso não seja igual, pule para ...4.Caso seja igual continue/pule para outro local5.

Sabendo onde foi realizado o salto nos deixa mais próximo ainda do local da comparação. Comoo pulo foi realizado para mostrar a mensagem de texto, destino mais provável para o salto équando os dados da mensagem de texto começam a ser empilhados. Selecione a linha logoacima da atual, onde tem o comando PUSH 0 (primeiro valor colocado na pilha). Note que oOlly identifica esse local como sendo o alvo de um salto (veja na parte de baixo da região dodisassembly):


13 de 18 29/4/2014 09:25

Basicamente ele está te dizendo que para chegar ao local atual, foi feito um salto no endereço00401061. Podemos ir até esse local e verificar se esse salto realmente existe. Clique com obotão direito sobre essa linha (no endereço 00401079) e vá em “GoTo -> JNZ from00401061”. Isso nos levará diretamente para o local do salto:

Fomos levados até o endereço 00401061 onde realmente existe um salto (JNZ SHORTadivinhe.00401079) e provavelmente estamos bem próximo do local da comparação.Realmente estamos. Analise as linhas que antecedem o salto. Temos uma chamada a funçãoGetDlgItemInt (busca um inteiro contido dentro de um item da janela, que nesse caso é umacaixa de texto) e o armazena em EAX (isso é padrão, todo retorno de função é em EAX). Emsequida temos:

Compare EAX com 11.Se for menor, pule para 0040108F2.Compare EAX com 14 (os números são em hex, logo 14h = 20 decimal)3.Se for maior, pule para 0040108F4.Compare EAX com 45.Se forem diferentes (JNZ/JNE), pule para 004010796.

Creio que você já tenha sacado o que está ocorrendo. Ele está primeiramente verificando se onúmero digitado está dentro do intervalo (20 >= X >= 1). Se eles estão no intervalo, nenhumsalto foi realizado, logo ele continua a execução. Logo após o valor digitado é comparado com onúmero 4, e se eles forem diferentes, o programa pula para aquela mensagem de texto queestávamos anteriormente. Que tal experimentar colocar o número 4 na caixa de texto doprograminha de estudo e ver o resultado? Bingo, encontramos o local da comparação e porconseqüência, o número com o qual ele compara o valor digitado.

Esse código asm seria gerado basicamente por uma estrutura semelhante a esta, em umpseudocódigo:

Código:

Declara variável inteira X;

X = Número contido na caixa de texto;

Se X < 1 ou X > 20 Então

Exibe mensagem de texto “Número Inválido”

Fim Se

Se X = 4 Então

Exibe mensagem de texto “Parabéns”

Caso Contrário

Exibe mensagem de texto “Você Errou”

Fim Se

Essa é uma das maneiras para localizar trechos de código em um debugger. É usado por muitagente, sendo que esse exemplo que apresentei é um “clássico”. Outra forma, muito mais direta,mas que exige um conhecimento da API do Windows é buscar pelas chamadas das funções dasAPIs do Windows.

Supondo que o usuário tenha certa experiência em programação (seja em asm ou em C), eleprovavelmente conhece algumas funções do Windows, já que elas são necessárias paraqualquer aplicativo visual. Como a lógica desse programa se baseia em buscar e comparar umdado digitado em uma caixa de texto, um usuário que já conheça um pouco da API sabe que énecessário usar uma função do Windows para realizar esse processo. As duas funções maisfamosas que pegam dados de controles são: GetDlgItemText e GetDlgItemInt.

O Olly possui uma janela que mostra todas as funções utilizadas pelo programa, então podemos


14 de 18 29/4/2014 09:25

verificar se existe uma dessas duas funções no aplicativo alvo. Para isso, clique no botão E (ouuse o atalho ALT+E) para abrir a janela de módulos. Vai ter uma breve lista, contendo naprimeira linha o próprio programa e nas outras as DLLs dependentes. Clique sobre a linha quecontém o nosso aplicativo (adivinhe) e vá em “View Names”. Isso exibirá uma lista com todasas funções utilizadas pelo aplicativo.

Eis a lista de funções utilizadas:

Note que a função GetDlgItemInt foi utilizada, como buscávamos. Para descobrir o local ondeela é usada pode-se utilizar o mesmo método de antes, clicando com o botão direito eselecionando “Set breakpoint on every referecence”. Daí basta continuar a execução doprograma, digitar um número e clicar no botão. Quando o alvo for chamar a função, o Ollycongela e exibe o local onde será feita a chamada, que é logo acima de onde é feita averificação, como vimos anteriormente.

Eu particularmente prefiro este método sobre o das referências, por algumas razões:

Ele normalmente nos leva para uma região bem mais próxima da verificação e antesdela. Utilizando as referências, você pode ser levado para um local muito além,necessitando de muito backtracing.Algumas referências de texto não aparecem na lista da string table, o que torna essemétodo mais prático.Não depende de mensagem de texto ou MessageBox, que nem sempre estão presentesem todos os aplicativos.

Em breve a continuação!Abraços,Fergo

03-10-2007 por emtudo

cara nao posso deixar de te agradecer por este tutorial, eu queria ate viajar para aprender isso,mas nunca sobrou "$"

esta de parabens!05-10-2007 por junior Fire

Primeiramente quero dar parabéns pelo tutorial.


15 de 18 29/4/2014 09:25

Estou acompanhando ele dês do inicio e quero sabe se você ira com ele até o fim.

T+


Valeu pessoal!Pretendo ir postando sim (até não sei se vai ter um final, posso ir sempre postando dicas sobreo Olly e tudo mais). Tive 2 semanas corridas de prova na faculdade e não sobrou tempo paramuita coisa.

Fergo05-10-2007 por emtudo

Citação:

Postado Originalmente por FergoValeu pessoal!Pretendo ir postando sim (até não sei se vai ter um final, posso ir sempre postando dicassobre o Olly e tudo mais). Tive 2 semanas corridas de prova na faculdade e não sobroutempo para muita coisa.

Fergo

Se for falta de agradecer e dizer que o tutorial esta muito bom, vai ter um fim sim, pq vamossempre agradecer por este excelente trabalho

Mais uma vez o trabalho esta excelente, estamos aguardando com paciencia vc ter um tempopara postar mais, mas nao tenha presa, aguardandos assim vc pode postar com paciencia e otrabalho vai ficar excelente como ja esta ficando...


Valeu pelo apoio pessoal.Finalmente arranjei um tempo livre e dei continuidade do estudo

RE-ASSEMBLY

O Olly além de ser um ótimo debugger, é um ótimo assembler. Com ele também é possíveleditar o código em tempo real e observar as mudanças de comportamento. Todas as mudançasque você realiza no código ficam salvas já janela de “Show Patches” (/). Vamos agora vercomo podemos modificar o código e re-salvar o nosso executável (muito útil para correção debugs).

Reabra o nosso arquivo no Olly, caso ele esteja fechado. Nos capítulos anteriores discutimos umpouco sobre o funcionamento do nosso aplicativo de teste, então vamos agora fazer umapequena modificação no mesmo para que ele sempre exiba a mensagem de “Você acertou”.

Nós tínhamos uma seqüência de comparações seguidas pelos seus respectivos saltos. Aprimeira verificava se o número era menor que 1, a segunda se ele era maior que 20 e aterceira se ele era em si o número escondido (4). Existem diversas formas de fazer com que onúmero seja sempre o correto. Vou listar algumas:

Alterar o código forçando que o valor 4 seja movido para EAX antes da comparação.Anular o último salto (após o CMP EAX, 4), fazendo com que o fluxo do aplicativo sigadireto para a mensagem correta.Desviando e forçando um salto para a mensagem correta logo na primeira comparaçãorealizada.

Existem outras formas ainda, mas vamos ficar com essas três, pois são as mais óbvias. Eu vouutilizar o último método neste tutorial para exemplificar o processo.


16 de 18 29/4/2014 09:25

O que basicamente nós vamos fazer é forçar um salto logo após a função GetDlgItemIntdiretamente para a região que chama a nossa mensagem de texto “Você acertou...”, comomostra a imagem abaixo:

Para modificar o disassembly, basta clicar sobre a linha que deseja alterar e apertar a tecla“Espaço”. Isso fará com que uma janela se abra com um local onde você possa indicar ainstrução que deseja colocar no local.

O nosso objetivo aqui é substituir o CMP EAX, 1 por um salto não-condicional até o local ondeos argumentos da nossa mensagem de texto começam a ser selecionados (no PUSH 0,localizado no endereço 00401063).

Clique sobre a linha que contém o CMP EAX, 1 (no endereço 00401054) e pressione “Espaço”.A seguinte janela se abrirá:

Na caixa de texto é onde você entra com a instrução em assembly que deseja substituir. Caso ainstrução que nós inserirmos seja menor (em bytes) que a instrução anterior, o Olly substituiesses bytes restantes pela instrução NOP, que não realiza nenhuma operação, evitando assimque fiquem resquícios e “lixos” do comando anterior (caso a caixa de seleção “Fill with NOP’s”esteja selecionada, claro).

Altere o CMP EAX, 1 por JMP 00401063, como mostra a figura:

Em seguida, basta clicar em Assemble para confirmar a modificação. Você deve ter notado queo Olly coloriu com vermelho aquilo que foi modificado. Note também que ele inseriu umcomando NOP após o salto, indicando que o nosso opcode do salto era 1 byte menor que ocomando anterior.

Você pode rodar o nosso aplicativo dentro do Olly e observar a modificação. Agora, com


17 de 18 29/4/2014 09:25

qualquer valor que você entre (mesmo aqueles fora do intervalo), o programa vai exibir amensagem que desejávamos.

Como mencionado anteriormente, todas as modificações ficam armazenadas na janela depatches, que pode ser acessada clicando no botão “\” ou através o atalho CTRL+P. Para alternarentre a instrução modificada e a original, basta selecionar a modificação desejada na janela depatches e apertar “Espaço” (ou através do botão direito -> “Restore original code”).

Para salvar o novo executável é bem simples. Na janela de dissassembly, clique com o botãodireito e vá para “Copy to Executable -> All modifications”. Uma pequena janela se abriráperguntando se você deseja copiar o código modificado. Selecione “Copy All”. Uma novajanela, contendo todo o código modificado, será exibida. Clique com o botão direito sobre ela eselecione “Save File”. Basta escolher o local e você terá um novo executável, contendo amodificação realizada.

Espero dar continuidade em breve.

Abraços e bom final de semana,Fergo

20-10-2007 por emtudo

Citação:

Postado Originalmente por FergoValeu pelo apoio pessoal.Finalmente arranjei um tempo livre e dei continuidade do estudo

RE-ASSEMBLY

Valeu, esta cada vez melhor, nao posso deixar de sempre agradecer22-10-2007 por Fergo

Valeu emtudo!

Já foi liberada a versão 2.0 pré-alpha do Ollydbg, pode ser conferida no link:http://www.ollydbg.de/

Ainda não é boa para ser utilizada em debugging, pois quase todas as funcionalidades aindaestão desativadas, mas já da para perceber uma certa melhoria na análise do código.

Fergo

Guia do Hardware Melhores Tópicos


18 de 18 29/4/2014 09:25

Documents

Utilizando Um Debugger - OllyDbg