[crimesciberneticos com]_Apostila_EngReversa_Malware

Prévia do material em texto

Engenharia Reversa e 
Análise de Malware 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Ronaldo Pinheiro de Lima 
crimesciberneticos.com@gmail.com 
www.crimesciberneticos.com 
mailto:crimesciberneticos.com@gmail.com
http://www.crimesciberneticos.com/
 
 
 
Conteúdo 
1. Introdução .............................................................................................................................................................. 6 
1.1. Tipos de códigos maliciosos .................................................................................................................................... 6 
1.2. Engenharia reversa de malware ............................................................................................................................. 8 
1.3. Análise estática e dinâmica (comportamental) ....................................................................................................... 9 
1.4. Ferramentas ............................................................................................................................................................ 9 
1.5. Antireversing e anti-antivirus ................................................................................................................................ 19 
1.5.1. Polimorfismo ................................................................................................................................................. 19 
1.5.2. Metamorfismo .............................................................................................................................................. 20 
1.5.3. Packers........................................................................................................................................................... 20 
1.5.4. Cryptors ......................................................................................................................................................... 21 
1.5.5. Binders, Joiners ou Wrappers ........................................................................................................................ 21 
1.5.6. Strings Ofuscadas .......................................................................................................................................... 21 
2. Estruturas Internas dos Softwares .........................................................................................................................23 
2.1. Níveis de abstração ............................................................................................................................................... 23 
2.2. Engenharia Reversa ............................................................................................................................................... 25 
2.3. A Arquitetura x86 .................................................................................................................................................. 26 
2.4. Memória Principal (RAM) ...................................................................................................................................... 27 
2.5. Instruções .............................................................................................................................................................. 28 
2.6. Opcodes e Endianness (Ordenação) ...................................................................................................................... 28 
2.7. Operandos ............................................................................................................................................................. 29 
2.8. Registradores ........................................................................................................................................................ 29 
2.9. A pilha (Stack) ....................................................................................................................................................... 32 
2.10. Chamadas de Funções (FunctionCalls) ................................................................................................................ 32 
2.11. Layout da Pilha (stack layout) ............................................................................................................................. 33 
2.12. Exemplo de código em C e Assembly ................................................................................................................... 36 
2.13. Mais informações: linguagem assembly e arquitetura Intel x86 ........................................................................ 37 
2.14. Lab-02-01 Entendo na prática o funcionamento da pilha com o OllyDbg ........................................................... 39 
3. Laboratório para Análise de Malwares ...................................................................................................................44 
3.1. Máquina virtual ..................................................................................................................................................... 44 
3.2. Preparação do ambiente ....................................................................................................................................... 45 
3.3. Lab-03-01 Uso de máquina virtual e simulação de rede com FakeNet ................................................................. 48 
4. Trabalhando com Executáveis ................................................................................................................................53 
4.1. Identificação do arquivo ........................................................................................................................................ 53 
4.2. Unpacking Automático .......................................................................................................................................... 53 
4.3. Strings ................................................................................................................................................................... 54 
4.4. Strings criptografadas ........................................................................................................................................... 54 
4.5. Debugging ............................................................................................................................................................. 55 
4.6. Lab 04-01 Análise de executável malicioso com strings criptografadas ............................................................... 55 
 
 
 
4.7. Lab 04-02 Análise de executável malicioso com uso dedescompilador................................................................. 69 
5. Análise Dinâmica ...................................................................................................................................................78 
5.1. Monitorando processos com Process Explorer ...................................................................................................... 78 
5.2. Monitorando com Process Monitor....................................................................................................................... 79 
5.3. Monitoramento de Tráfego de Rede ..................................................................................................................... 80 
5.4. Monitoramento do registro e arquivos com Regshot ............................................................................................ 81 
5.5. O uso das ferramentas de análise dinâmica na prática ........................................................................................ 81 
5.6. Lab 05-01 Análise dinâmica com Process Explorer e Process Monitor .................................................................. 82 
5.7. Lab 05-02 Análise de executável malicioso com uso de técnicas diversas ............................................................ 88 
6. WindowsInternals .................................................................................................................................................89 
6.1. Níveis de privilégio do processador – Protection Rings ......................................................................................... 89 
6.2. Transição entre os níveis de privilégio ................................................................................................................... 89 
6.3. Kernel Mode .......................................................................................................................................................... 90 
6.4. User Mode ............................................................................................................................................................. 91 
6.5. Windows APIs ........................................................................................................................................................ 92 
6.5.1. Win32 API ...................................................................................................................................................... 93 
6.5.2. Native API ...................................................................................................................................................... 93 
6.6. Lab 06-01 Entendendo as APIs do Windows na prática ........................................................................................ 95 
6.7. Formato Portable Executable (PE) ......................................................................................................................... 95 
6.7.1. Conceitos Básicos .......................................................................................................................................... 96 
6.7.2. MS-DOS Header ............................................................................................................................................. 97 
6.7.3. PE Header ...................................................................................................................................................... 99 
6.7.4. Section Table ............................................................................................................................................... 102 
6.7.5. PE Sections .................................................................................................................................................. 103 
6.8. O Loader – Como um arquivo PE é carregado na memória ................................................................................ 105 
7. Trabalhando com DLLs ......................................................................................................................................... 107 
7.1. Estrutura Básica de uma DLL ............................................................................................................................... 107 
7.2. Enumerando Exports da DLL ............................................................................................................................... 108 
7.3. Executando DLLs.................................................................................................................................................. 110 
7.4. Restrições de Processo Host ................................................................................................................................ 111 
7.5. Debugging DLL .................................................................................................................................................... 113 
7.6. Component Object Model (COM) ........................................................................................................................ 113 
7.7. Lab 07-01 Análise de DLL maliciosa .................................................................................................................... 116 
7.8. Lab 07-02 Injeção e debugging de DLL com o Immunity Debugger .................................................................... 116 
8. Memory Forensics ............................................................................................................................................... 121 
8.1. Aquisição da memória......................................................................................................................................... 121 
8.2. Análise de Memória ............................................................................................................................................ 123 
8.3. Lab 08-01 Aquisição e análise de dump de memória .......................................................................................... 124 
9. Trabalhando com Rootkits ................................................................................................................................... 125 
9.1. O surgimento dos Rootkits .................................................................................................................................. 125 
 
 
 
9.2. Tipos de rootkits .................................................................................................................................................. 126 
9.3. User-mode Rootkits ............................................................................................................................................. 126 
9.3.1. API Hooking ................................................................................................................................................. 127 
9.3.2. Técnicas de Hooking .................................................................................................................................... 128 
9.4. Ferramentas de detecção de Rootkits ................................................................................................................. 129 
9.5. Lab 09-01 Demonstração de INT 3 Hooks com PyDbg ........................................................................................ 130 
9.6. Kernel-mode Rootkits .......................................................................................................................................... 131 
9.6.1. O Kernel do Windows (NTOSKRNL.EXE) ...................................................................................................... 132 
9.6.2. Device Drivers .............................................................................................................................................. 133 
9.6.3. Windows Hardware Abstraction Layer (HAL) .............................................................................................. 134 
9.6.4. Kernel Drivers no Windows ......................................................................................................................... 135 
9.6.5. Os Rootkits em Kernel-Mode ...................................................................................................................... 136 
9.6.6. Análise de Kernel-Mode Rootkit ................................................................................................................. 138 
9.7. Lab 09-02 Análise de kernel-mode rootkit com o WinDbg .................................................................................. 141 
9.7.1. Configurando Kernel-Mode Debugging com WinDbg e VirtualBox ............................................................. 142 
9.8. Referências de comandos e uso do WinDbg ....................................................................................................... 146 
10. Técnicas contra Engenharia Reversa ................................................................................................................... 147 
10.1. Packers .............................................................................................................................................................. 147 
10.1.1. Anatomiados Packers ............................................................................................................................... 147 
10.1.2. O código de Unpacking .............................................................................................................................. 148 
10.1.3. Identificando Programas com Packers ...................................................................................................... 150 
10.1.4. Métodos de Unpacking ............................................................................................................................. 150 
10.1.5. Unpacking Manual .................................................................................................................................... 152 
10.1.6. Analisando sem realizar o Unpacking total ............................................................................................... 157 
10.1.7. Lab 10-01 Unpacking manual de UPX alterado ......................................................................................... 158 
10.2. Anti-Debugging ................................................................................................................................................. 158 
10.2.1. Detecção de debugger através da Windows API ....................................................................................... 158 
10.2.2. Checagem manual de estruturas ............................................................................................................... 160 
10.2.3. Identificando o comportamento do Debugger.......................................................................................... 163 
10.2.4. Interferindo na funcionalidade do Debugger ............................................................................................ 164 
10.2.5. Vulnerabilidades do Debugger .................................................................................................................. 165 
10.3. Visão geral de Anti-Disassembly ....................................................................................................................... 165 
10.4. Visão geral de Anti-VM ..................................................................................................................................... 167 
10.5. Lab 10-02Análise de malware que emprega técnicas anti-debugging ............................................................. 168 
11. Trabalhando com Documentos Maliciosos ......................................................................................................... 169 
11.1. Etapas genéricas da análise de documentos maliciosos ................................................................................... 169 
11.2. Análise de documento Microsoft Office ............................................................................................................ 170 
11.2.1. OfficeMalScanner ...................................................................................................................................... 170 
11.2.2. Ferramentas e recursos para análise de documentos Office .................................................................... 171 
11.3. Lab 11-01 Análise de documento Office malicioso ............................................................................................ 171 
11.4. Análise de PDF ................................................................................................................................................... 171 
11.5. Lab 11-02 Análise de PDF malicioso .................................................................................................................. 173 
12. Trabalhando com Web Malware ........................................................................................................................ 174 
12.1. JavaScript .......................................................................................................................................................... 174 
12.2. PHP .................................................................................................................................................................... 176 
12.3. Applet Java ........................................................................................................................................................ 177 
 
 
 
12.4. Flash e Action Script .......................................................................................................................................... 178 
12.5. Lab 12-01 Análise de web malware diversos .................................................................................................... 179 
Apêndice A: Sandbox e Multi-AV Scanners .............................................................................................................. 180 
Apêndice B: Coleta de Malware ............................................................................................................................... 182 
Referências Bibliográficas ........................................................................................................................................ 184 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
É terminantemente proibida a reprodução total ou parcial desta obra, por qualquer meio ou 
processo, sem a expressa autorização do autor. 
 
 
Revisão 1.7 – novembro/2016 
Engenharia Reversa e Análise de Malware | 6 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
1. Introdução 
 
Código malicioso ou malware (do inglês “malicious software”) foi um termo criado para 
definir genericamente qualquer software que tenha intenção de realizar alguma atividade no 
computador sem o consentimento ou conhecimento do proprietário, dessa forma beneficiando outra 
pessoa. Geralmente essa atividade maliciosa gerará algum dano ou prejuízo a vítima e envolverá 
captura de teclas digitadas no teclado, cliques do mouse, comunicação de rede, alterações de 
configurações no navegador e sistema operacional, etc. 
1.1. Tipos de códigos maliciosos 
 
Conforme foram surgindo foram identificadas determinadas características e funcionalidades 
comuns em certos grupos de malwares e assim criaram-se categorias para distingui-los. Devido ao 
dinamismo e à velocidade com que surgem novas pragas digitais muitas vezes é difícil saber se um 
malware se encaixa em uma categoria, em várias ou em nenhuma conhecida. Porém é consenso a 
existência de determinados tipos comuns que veremos a seguir. 
 
Vírus: é o tipo mais antigo de malware e tem se tornado menos popular nos dias atuais, 
porém às vezes o termo ainda é utilizado de forma genérica para descrever todos os tipos de 
malwares. Eles fazem cópias de si mesmos infectando outros arquivos legítimos do computador, ou 
seja, se tornam parte de outros programas (geralmente executáveis). Uma característica importante é 
que os vírus geralmente dependem da ação do usuário para se tornarem ativos e infectarem outros 
computadores, diferente da maioria dos malwares atuais que utilizam Internet ou a rede local para 
se replicarem. 
 
 Worm: fundamentalmente é similar ao vírus, porém possui uma diferença significativa, 
worms se auto replicam automaticamente pela rede sem necessitar da ação do usuário, conseguem 
fazer isso explorando vulnerabilidades do sistema operacional e outros softwares. Devido a essa 
característica eles podem se propagarem de forma incontrolável em pouquíssimo período de tempo. 
 
 Trojanhorse: em português cavalo de Troia, foi na mitologia grega uma grande estátua, 
utilizada como instrumento de guerra pelos gregos para obter acesso à cidade de Troia. A estátua do 
cavalo foi recheada com soldados que, durante a noite, abriram os portões da cidade possibilitando 
Engenharia Reversa e Análise de Malware | 7 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.coma entrada dos gregos e a dominação de Troia. Daí surgiram os termos "Presente de Grego" e 
"Cavalo de Troia". No mundo dos malwares, um trojan é um programa normalmente recebido como 
um "presente" (por exemplo, vídeos, fotos, jogos, etc.), que além de executar funções para as quais 
foi aparentemente projetado, também executa outras funções normalmente maliciosas e sem o 
conhecimento do usuário. 
 
 Trojan-Downloader: é um tipo de Trojan que existe somente para fazer download de outros 
códigos maliciosos. Downloaders, ou Loaders como são conhecidos no meio hacker, geralmente são 
instalados pelos atacantes quando eles obtêm acesso ao sistema pela primeira vez. O downloader irá 
baixar e instalar outros malwares automaticamente. 
 
 Trojan-Banker: esse tipo de Trojan é muito comum no Brasil, 95% dos malwares 
produzidos no país são desse tipo [1], são especializados em furtar dados referentes ao Internet 
Banking. Tentam se passar por aplicativos ou sites dos bancos brasileiros para conseguirem capturar 
senhas e demais credenciais de acesso a contas bancárias. 
 
[1] http://oglobo.globo.com/tecnologia/bbr-ajuda-mas-malware-ainda-pode-infectar-aparelhos-3678255 
 
Backdoor: código malicioso que se instala no computador para permitir o acesso remoto do 
atacante. Permite ao atacante se conectar e executar comandos no computador infectado sem que o 
usuário tenha conhecimento. 
 
Bot/Botnet: similar a backdoor, permite ao atacante se conectar remotamente ao computador 
infectado, porém seu uso é diferente. Assim que um computador é infectado por um bot, ele se 
conecta automaticamente a um servidor de comando-e-controle (command-and-control, C&C ou 
C2) e ficar aguardando instruções. Esse servidor C&C é comandado pelo atacante que através que 
instruções ordena que toda a rede de computadores infectados com os bots (a botnet) realizem 
determinadas atividades maliciosas como, por exemplo, capturarem teclas digitadas, acessarem 
determinado web site para sobrecarregá-lo e derrubá-lo (ataque DDoS), instalar malwares 
adicionais, etc. 
 
Rootkit: malware designado para ocultar sua presença e de outros códigos maliciosos no 
sistema operacional. Utiliza-se de técnicas avançadas para dificultar a detecção por parte do 
usuário, geralmente faz isso alterando funções internas do sistema operacional fazendo com que 
passe despercebido pelas ferramentas anti-malware. 
Engenharia Reversa e Análise de Malware | 8 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
 
O uso de códigos maliciosos está diretamente relacionado às fraudes cometidas pela 
Internet, para essas fraudes ou golpes também foram criados alguns termos que valem a pena 
conhecer: 
 
PhishingScam: é um golpe que se utiliza de engenharia social com o envio de mensagem 
não solicitado (spam) para se passar por uma instituição conhecida, como um banco, empresa ou 
site popular, e que procura induzir o usuário a acessar páginas falsas ou instalar códigos maliciosos 
projetados para furtar dados pessoais e financeiros. As palavras inglesas phishing (de "fishing", 
pescaria) e scam (golpe) vêm de uma analogia criada pelos fraudadores, onde "iscas" (e-mails) são 
usadas para "pescar" senhas e dados financeiros de usuários na Internet. No meio hacker, os 
indivíduos especializados em desenvolver códigos maliciosos ou sites fraudulentos para furtar 
informações bancárias é conhecido como "banker" e o especializado somente em cartões de crédito 
é o "carder". 
 
 SpearPhishing: no phishing comum são enviados e-mails para tentar “pescar” senhas e 
outros dados bancários das pessoas em geral, já no spearphishing (“pescaria com arpão”) são 
enviados e-mails direcionados a alvos específicos, a mensagem é cuidadosamente montada para que 
se passe por verdadeira dentro de uma empresa ou órgão. 
1.2. Engenharia reversa de malware 
 
Engenharia reversa é o processo de extrair conhecimento de algo feito pelo homem. 
Geralmente é utilizada para obter informação de algo que foi perdido ou esteja faltando, muitas 
vezes o dono dessa informação não tem a intenção de compartilhá-la ou a informação foi destruída. 
Em muitas indústrias a engenharia reversa é utilizada para descobrir segredos de projetos dos 
concorrentes para desenvolverem produtos similares ou superiores, o produto é dissecado pedaço 
por pedaço até descobrirem o que cada parte faz. 
Software é uma das tecnologias mais complexas feita pelos homens da atualidade, e a 
engenharia reversa de software consiste em abrir um programa e olhá-lo internamente. Portanto a 
engenharia reversa de malware é o processo de abrir um software malicioso, dissecá-lo e entender o 
que cada parte do programa faz sem ter acesso ao seu código-fonte original, já que o criador 
possivelmente não irá querer compartilhá-lo conosco. 
Engenharia reversa de malware requer uma combinação de habilidades e conhecimentos, 
como por exemplo: desenvolvimento de softwares, sistemas operacionais, arquitetura de 
Engenharia Reversa e Análise de Malware | 9 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
computadores, programação baixo nível, formato de arquivos, etc. Porém o mais importante pré-
requisito é a curiosidade e a vontade de aprender. 
1.3. Análise estática e dinâmica (comportamental) 
 
Existem duas abordagens distintas, contudo complementares, que podemos utilizar para 
analisar um malware. A primeira delas é chamada de análise estática, com ela analisamos um 
artefato, na verdade um arquivo, sem executá-lo ou executando apenas pequenos trechos de seu 
código com ajuda de debuggers. Nesse tipo de análise utilizamos diversas ferramentas para 
conseguir extrair o máximo de informações possíveis do malware, geralmente essa abordagem 
exige do analista um conhecimento maior dos formatos de arquivos envolvidos, do funcionamento 
interno do sistema operacional e da linguagem assembly, porém dessa forma conseguimos extrair 
informações mais detalhadas e avançadas do malware. 
Já na análise dinâmica, também chamada de comportamental, executamos o arquivo e 
monitoramos seu comportamento, interação e efeitos no sistema operacional hospedeiro, deixamos 
o malware agir e observamos. Para isso contamos com a ajuda de diversas ferramentas que 
capturam tráfego de rede, execução de processos, modificações no registro, sistema de arquivos, 
etc., e no final da execução, ou após um determinado período de tempo definido por nós, são 
exibidos os relatórios com os resultados. 
Vale dizer que a análise dinâmica é fácil ser automatizada, os sites que analisam malwares 
fazem isso, já a análise estática é muito difícil, a maior parte do trabalho é feito manualmente por 
um analista. As empresas desse ramo, universidades ou mesmo as forças policiais (FBI) geralmente 
possuem gigantescas base de dados com milhões de amostras que são analisadas automaticamente 
pelo método dinâmico e os arquivos que fogem do padrão são separados e analisados manualmente 
por uma pessoa através do método estático. 
Um método não é melhor que o outro, eles são complementares. Às vezes é muito útil 
utilizar a abordagem dinâmica para provar ou tirar uma dúvida do que foi encontrado com a análise 
estática. Também podemos utilizar a análise estática para conseguir mais detalhes do que foi 
apresentado com a abordagem dinâmica. Por isso é importante conhecer os dois métodos. 
1.4. Ferramentas 
 
São poucas as ferramentas criadas especialmente para a engenharia reversa e análise de 
malware, mas mesmo assim existem inúmeras criadas com outros propósitos que são muito úteis na 
hora de lidar com um arquivo malicioso. Elas são categorizadas de acordo com suas 
Engenharia Reversa e Análise de Malware | 10 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
funcionalidades, muitas são bem completas e se encaixam em mais de uma categoria, vejamos 
abaixo as características de cada uma e no decorrer do curso as conheceremos com maisdetalhes. 
Lembrando que todos os softwares utilizados são gratuitos e estão disponíveis na internet para 
qualquer um fazer download. 
 
Identificadores de Arquivos 
 
Quando pretendemos analisar um arquivo suspeito não temos nenhuma informação prévia 
sobre ele, não sabemos o formato do arquivo, para qual sistema operacional foi compilado ou se ele 
possui alguma proteção. Não podemos confiar no nome do arquivo e nem em sua extensão, pois 
isso é usado como engenharia social para enganar os menos atentos. Existem ferramentas, 
classificadas genericamente como identificadores de arquivos, que podemos utilizar para obter um 
perfil inicial do arquivo. 
Elas recebem o arquivo suspeito como entrada e exibem informações detalhadas como: 
formato do arquivo, compilador, linguagem de programação, proteções, cabeçalhos, sessões do 
arquivo, etc. Algumas ainda dão dicas de como remover as proteções e permitem a instalação de 
plug-ins. 
 
Segue uma lista das mais utilizadas: 
 
- PEiD 
Ferramenta gratuita para detecção de packers e compiladores. Inclui mais de 600 assinaturas para 
detectar packers, cryptors e compiladores em arquivos do formato PE (executável do Windows). 
Suporta a instalação de plug-ins como o KryptoANALyzer (KANAL). O KANAL pode ser 
utilizado para encontrar algoritmos de criptografia conhecidos em arquivos PE. Embora o projeto 
do PEiD tenha sido descontinuado ainda é possível fazer o download da ferramenta. 
Download: http://www.peid.info/. 
 
- Exeinfo PE 
Assim como o PEiD é uma ferramenta gratuita que também identifica packers e compiladores de 
arquivos PE. Projeto atualizado que apresenta bons resultados e possui 617 assinaturas de detecção. 
Uma vantagem é que ele quando identifica um packer dá dica de como encontrar o unpacker. 
Permite ainda a integração com o PEiD através de plug-in. 
Site para download: http://www.exeinfo.xwp.pl/. 
 
http://www.peid.info/
http://www.exeinfo.xwp.pl/
Engenharia Reversa e Análise de Malware | 11 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
- RDG Packer Detector 
Como o próprio nome diz identifica packers, cryptors, compiladores e algoritmos de criptografia. É 
uma ferramenta menos conhecida, porém bastante poderosa. Compatível com Windows 7 e 
arquivos PE de 32 e 64 bits. 
Download: http://www.rdgsoft.8k.com/. 
 
- file 
Comando nativo de distribuições Linux para identificação de arquivos. Ideal para saber o tipo de 
um arquivo desconhecido, às vezes consegue identificar a presença de packers. Possui versão 
gratuita para Windows. 
Download (Windows): http://gnuwin32.sourceforge.net/packages/file.htm. 
 
Monitoramento do Sistema 
 
Esse tipo de ferramenta está relacionado com a análise dinâmica do malware, envolve 
tarefas como “sniffar” a rede, monitorar o sistema operacional (SO), explorar e expor o que o 
malware está fazendo. A maioria dessas ferramentas exibe informações coletadas pelo SO sobre o 
malware e seu ambiente, devido à quase totalidade de comunicação do malware com o mundo 
exterior ser feita através do SO, ele pode ser manipulado para extrair essa informação. Ferramentas 
de monitoramento do sistema podem monitorar atividade de rede, acesso a arquivos, acesso ao 
registro, criação de processos, além de objetos do SO como mutex, eventos e outros. 
 
Segue uma lista das mais utilizadas: 
 
- Autoruns 
Autoruns é um utilitário com uma longa lista de locais de inicialização automática de programas no 
Windows. Malwares frequentemente se instalam em uma variedade de locais, incluindo o registro, 
menu iniciar, e outros. Autoruns procura por vários locais possíveis e apresenta um relatório em 
uma interface gráfica. Use o Autoruns na análise dinâmica para ver onde o malware se instalou. A 
ferramenta faz parte da SysinternalsSuite. 
Download: http://www.sysinternals.com/. 
 
- Capture BAT 
É uma ferramenta de análise dinâmica para monitorar o malware enquanto ele ainda está rodando. 
Capture BAT irá monitorar o sistema de arquivos, registro e atividades do processo. Você pode usar 
http://www.rdgsoft.8k.com/
http://gnuwin32.sourceforge.net/packages/file.htm
http://www.sysinternals.com/
Engenharia Reversa e Análise de Malware | 12 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
listas de exclusão (incluindo muitas já predefinidas) para remover os resultados não desejados e 
focar somente no malware que está analisando. Apesar de o Capture BAT não ter uma interface 
gráfica muito sofisticada como o Process Monitor, é uma ferramenta open source, então você pode 
modificá-la. 
Download: http://www.honeynet.org/project/CaptureBAT. 
 
- Process Explorer 
É um poderoso gerenciador de tarefas do Windows que é utilizado para prover informações sobre os 
processos que estão executando no sistema. Process Explorer pode mostrar as DLLs de processos 
individuais, handles, eventos, strings e muito mais. Faz parte da SysinternalsSuite. 
Download: http://www.sysinternals.com/. 
 
- Process Hacker 
É um poderoso gerenciador de tarefas similar ao Process Explorer, porém com muitas 
funcionalidades adicionais. Ele pode buscar por strings e expressões regulares na memória, injetar 
ou descarregar DLL, carregar um driver, criar ou iniciar um serviço e muito mais. 
Download: http://processhacker.sourceforge.net/. 
 
- Process Monitor 
Process Monitor (procmon) é uma ferramenta de análise dinâmica útil para visualizar em tempo real 
atividades no sistema de arquivos, registro e processos. Você pode utilizar filtros para remover 
informações não desejadas do relatório. Faz parte da SysinternalsSuite. 
Download: http://www.sysinternals.com/. 
 
- Regshot 
Ferramenta de análise dinâmica que permite tirar e comparar dois snapshots (estado ou “foto”) do 
registro do sistema. Para usá-la, você simplesmente tira um snapshot do registro, executa o 
malware, aguarda ele fazer as modificações no sistema, tira o segundo snapshot, e então compara os 
dois. O regshot também pode ser utilizado para tirar e comparar dois snapshots de qualquer pasta do 
sistema de arquivos que você especificar. 
Download: http://sourceforge.net/projects/regshot/. 
 
- TCPView 
Ferramenta para mostrar graficamente listagens detalhadas de todas as conexões TCP e UDP 
relacionadas com processos. Essa ferramenta é útil para análise de um malware porque permite 
http://www.honeynet.org/project/CaptureBAT
http://www.sysinternals.com/
http://processhacker.sourceforge.net/
http://www.sysinternals.com/
http://sourceforge.net/projects/regshot/
Engenharia Reversa e Análise de Malware | 13 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
visualizar qual processo é proprietário de determinada conexão. TCPView pode ajudar você a 
rastrear o nome de um processo quando sua máquina de análise se conecta a uma porta TCP e você 
não tem ideia de qual é o responsável. Faz parte da SysinternalsSuite. 
Download: http://www.sysinternals.com/. 
 
- Wireshark 
Wireshark é uma ferramenta open source de análise de pacotes de rede. Pode ser utilizada para 
capturar o tráfego de rede gerado pelo malware e para analisar muitos protocolos diferentes. É a 
ferramenta mais popular disponível livremente para capturar pacotes de rede, possui uma interface 
completa e fácil de usar. 
Download: http://www.wireshark.org/. 
 
Disassemblers 
 
Disassemblers são programas que recebem um arquivo binário executável como entrada e 
geram como saída arquivos textuais que contém o código da linguagem assembly para o programa 
inteiro ou parte dele. Esse processo é relativamente simples considerando que a linguagem 
assembly é simplesmente o mapeamento textual da linguagem de máquina. Disassembly é um 
processo baseado em processador, ou seja, cada arquitetura de CPU tem uma linguagem assembly 
específica, mas alguns disassemblers suportam múltiplas arquiteturas diferentes. Um bom 
disassembler é uma ferramenta essencial no kit do engenheiro reverso de malware,através dele 
temos acesso ao código-fonte do malware (ainda que em linguagem de baixo nível) o que auxilia o 
seu entendimento e manipulação. 
 
- IDA ProFree 
É o disassembler mais poderoso e utilizado em análise de malwares, possui inúmeras 
funcionalidades como geração de gráficos, fluxogramas, referências cruzadas e muito mais. 
Disponível em uma versão paga com mais funcionalidades e outra free que atende bem a análise de 
malwares para plataformas comuns. 
Download: http://www.hex-rays.com/products/ida/support/download_freeware.shtml. 
 
Debuggers 
 
Caso você já tenha feito algo em desenvolvimento de software já deve ter ouvido falar sobre 
os debuggers. Um debugger é um software que permite que o desenvolvedor observe seu programa 
http://www.sysinternals.com/
http://www.wireshark.org/
http://www.hex-rays.com/products/ida/support/download_freeware.shtml
Engenharia Reversa e Análise de Malware | 14 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
enquanto ele está sendo executado. As duas maiores características de um debugger são a habilidade 
de estabelecer breakpoints e a habilidade de navegar através do código. 
Breakpoints permitem ao usuário selecionar uma função ou linha de código em qualquer 
lugar no programa e instruir o debugger a parar a execução do programa assim que essa linha é 
atingida. Quando ele atinge o breakpoint, o debugger para (break) e exibe o estado atual do 
programa. Nesse ponto é possível liberar o programa para continuar a execução ou começar a 
navegar através de seu código. Esse processo de “navegação” através do programa consiste em 
executar uma linha de código de cada vez e congelar, permitindo ao usuário observar e até alterar 
seu estado. Isso permite observar o fluxo exato do programa de uma forma mais lenta e apropriada 
para a compreensão humana, já que o computador executada tudo isso bilhões de vezes mais rápido. 
Instalando breakpoints e navegando por programas, os desenvolvedores podem assistir ao 
programa de perto quando ele executa uma seção problemática do código e tentar determinar a 
origem do problema. Como os desenvolvedores têm acesso ao código-fonte de seus programas, 
debuggers comuns exibem o código-fonte na linguagem de programação de alto-nível que eles 
estão utilizando, permitindo a manipulação desse código. 
Para os engenheiros reversos de malware, o debugger é quase tão importante quanto para o 
desenvolvedor de software, mas por pequenas razões diferentes. Os debuggers são utilizados no 
modo disassembly, por essa razão esse tipo de debugger é conhecido como assembler-
leveldebugger. No modo disassembly um debugger utiliza um disassembler embutido para 
“disassemblar” o código de máquina em tempo de execução. É possível executar linha a linha o 
código assembly e “assistir” como a CPU executa cada instrução do malware. Essa capacidade de 
saber o que está sendo executado é muito valiosa para a análise do malware, inclusive para entender 
trechos mais complexos de seu código ou ainda para tentar remover determinadas proteções do 
código. Ao decorrer do curso utilizaremos bastante debuggers. 
 
Segue uma lista dos mais utilizados: 
 
- OllyDbg 
OllyDbg é um dos mais utilizados debuggers para análise de malware. É um user-mode x86 
debugger com uma interface gráfica. Inúmeros plug-ins estão disponíveis para o OllyDbg, como por 
exemplo, o OllyDump muito utilizado para unpacking de malwares. 
Download: http://www.ollydbg.de/. 
 
- ImmunityDebugger 
O ImmDbg é um user-modedebugger disponível gratuitamente. É derivado do código-fonte do 
http://www.ollydbg.de/
Engenharia Reversa e Análise de Malware | 15 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
OllyDbg 1.1, possui pequenas modificações da GUI do OllyDbg e um interpretador Python 
completamente funcional com uma API que permite escrever e rodar scripts nessa linguagem. 
Download: http://www.immunityinc.com/products-immdbg.shtml. 
 
- WinDbg 
WinDbg é o debugger completo mais popular, distribuído gratuitamente pela Microsoft. Você pode 
utilizá-lo para debugar malware em user-mode, kernel-mode, x86 e x64. O WinDbg não tem a 
interface gráfica robusta como o OllyDbg, ao invés disso possui uma interface de linha de 
comandos. Muitos analistas de malware optam por usar o OllyDbg para user-mode debugging e o 
WinDbg para kernel debugging. WinDbg pode ser baixado independente ou como parte do 
Windows SDK. 
Download: http://msdn.microsoft.com/. 
 
Descompiladores 
 
Descompilar é o próximo passo após o disassembler. Um descompilador recebe um arquivo 
executável binário como entrada e tenta produzir código de linguagem de programação de alto-nível 
a partir dele. A ideia é tentar reverter o processo de compilação para obter o código-fonte original 
ou algo similar a isso. Na maioria das plataformas conseguir isso não é realmente possível, existem 
elementos na maioria das linguagens de programação de alto-nível que são perdidas no processo de 
compilação e fica impossível a recuperação. Porém, ainda assim descompiladores são ferramentas 
poderosas que em determinadas situações e ambientes podem reconstruir o código de alto-nível de 
forma bastante aceitável. Por exemplo, às vezes é possível recuperar janelas e imagens de 
determinados malwares, o que torna muito mais fácil a sua compreensão. 
 
Segue uma lista dos mais utilizados: 
 
- DeDe 
Popular descompilador para executáveis compilados em Delphi. Possui interface gráfica onde é 
possível visualizar o nome original do projeto Delphi, a versão utilizada, forms encontrados, 
funções e mais. Ainda permite salvar o projeto em formato nativo do Delphi o que permite posterior 
abertura na IDE. Apesar de nem sempre apresentar resultados satisfatórios é muito útil para 
recuperar GUIs de malwares. 
Download: 
http://www.softpedia.com/get/Programming/Debuggers-Decompilers-Dissasemblers/DeDe.shtml. 
http://www.immunityinc.com/products-immdbg.shtml
http://msdn.microsoft.com/
http://www.softpedia.com/get/Programming/Debuggers-Decompilers-Dissasemblers/DeDe.shtml
Engenharia Reversa e Análise de Malware | 16 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
 
- VB Decompiler Pro 
Descompilador para executáveis compilados com a linguagem de programação Visual Basic. 
Recupera funções, forms, nome do projeto e permite salvar o projeto para posterior utilização com o 
Visual Basic. 
Download: http://www.vb-decompiler.org/products/pt.htm. 
 
- Hex-RaysDecompiler 
Apesar de ser uma ferramenta paga (e cara, 2.239,00 USD) vale à pena citar a título de 
conhecimento. O Hex-RaysDecompiler é um poderoso plug-in para o IDA Pro que tenta converter 
código assembly em código amigável para humanos, uma espécie de pseudocódigo em C. Por 
exemplo, com o uso do plug-in 100 linhas de código assembly podem se transformar em apenas 8 
linhas de código C.O plug-in é muito útil para decifrar complexos algoritmos de criptografia. É a 
melhor ferramenta no mercado para descompilação, mas não é livre de falhas. 
Para mais informações: http://www.hex-rays.com/. 
 
Memory Forensics 
 
Memory forensics ou forense de memória refere-se a encontrar e extrair artefatos forenses 
da memória física de um computador (RAM). A RAM contém informação crítica sobre o estado do 
sistema em execução enquanto ele ainda está ativo. Capturando uma cópia inteira da memória e 
analisando e um computador separado, é possível reconstruir o estado original do sistema, incluindo 
quais aplicações estavam rodando, quais arquivos essas aplicações estavam acessando, quais 
conexões de rede estavam ativas, e muito mais. Em análise de malware esse acesso à memória 
auxilia na retirada de proteções, detecção de rootkits, e na engenharia reversa como um todo. 
Existem basicamente dois tipos de ferramentas relacionadas com forense de memória, o primeiro 
tipo são as ferramentas que realizam a captura da RAM do computador, elas fazem uma cópia 
idênticade tudo o que está na memória, ou de apenas de um determinado processo, e salva em um 
arquivo para posterior análise, esse processo é conhecido como dump de memória. O segundo tipo 
de ferramenta é responsável pela análise da memória capturada, a partir do arquivo de dump ela 
consegue reconstruir todas as informações que estavam originalmente na RAM do sistema e nos 
exibir de forma amigável, permitindo variadas opções de buscas e listagens. 
 
Segue uma lista das mais utilizadas: 
 
http://www.vb-decompiler.org/products/pt.htm
http://www.hex-rays.com/
Engenharia Reversa e Análise de Malware | 17 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
- LordPE 
É uma ferramenta gratuita para realizar o dump de um executável na memória, com ele é possível 
selecionar um processo que esteja em execução e copiá-lo inteiro ou parcialmente. Ele permite 
editar o arquivo PE e pode ser utilizado para corrigir um programa que foi copiado da memória com 
outra ferramenta. Ferramenta bastante utilizada para unpacking de malware. 
Download: http://www.woodmann.com/collaborative/tools/index.php/LordPE. 
 
- MoonSols Windows Memory Toolkit 
É um kit de ferramentas completo para aquisição e conversão de dumps de memória no Windows. 
Pode lidar com vários tipos de dumps de memória como, por exemplo, VMWarememory snapshot, 
Microsoft crash dump e até arquivos de hibernação do Windows. No kit há inúmeras ferramentas 
como, por exemplo, a win32dd e a DumpIt que com apenas um clique realiza o dump da memória 
física do Windows e salva no diretório atual, ideal para ser utilizada em drives USB para rápida 
resposta a incidentes. O kit possui uma versão Professional paga e uma gratuita para a comunidade. 
Download: http://www.moonsols.com/windows-memory-toolkit/. 
 
- Memoryze 
Ferramenta gratuita criada pela empresa MANDIANT para forense de memória. Memoryze pode 
adquirir e/ou analisar toda a memória física ou apenas a referente a um processo, em um sistema em 
execução ou em um dump de memória salvo. Também pode detectar rootkits e os hooks que eles 
instalam. Para visualizar a saída gerada pela ferramenta Memoryze é necessário fazer download 
também da ferramenta AuditViewer, o que torna o processo de análise rápido e mais intuitivo. 
Download: http://www.mandiant.com/products/free_software/memoryze/. 
 
- Volatility Framework 
É uma coleção de ferramentas open source escritas em Python para live análise de dumps de 
memória. Esse conjunto de ferramentas é útil para análise de malware, pois pode ser utilizada para 
extrair DLLs injetadas em processos, detectar rootkits, encontrar processos ocultos, e muito mais. O 
Volatility possui muitos usuários e colaboradores, então novos recursos estão constantemente sendo 
desenvolvidos. 
Download: http://code.google.com/p/volatility/. 
 
Além dessas categorias existem ferramentas diversas que auxiliam em alguma tarefa 
específica da análise do malware. Podemos citar algumas úteis para o arsenal do analista de 
malware. 
http://www.woodmann.com/collaborative/tools/index.php/LordPE
http://www.moonsols.com/windows-memory-toolkit/
http://www.mandiant.com/products/free_software/memoryze/
http://code.google.com/p/volatility/
Engenharia Reversa e Análise de Malware | 18 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
 
Diversas 
 
- CFF Explorer 
Uma ferramenta designada para permitir a edição de arquivos PE de forma fácil. Útil para editar a 
seção resources, adicionar imports, ou escanear por assinaturas. 
Download: http://www.ntcore.com/. 
 
- Dependency Walker 
Ferramenta de análise estática para explorar DLLs e funções importadas por malwares. Constrói um 
diagrama em formato de árvore hierárquica com todas as DLLs que serão carregadas na memória 
quando o malware executar. 
Download: http://www.dependencywalker.com/. 
 
- Editores Hexadecimais 
Editores hex permitem editar e visualizar arquivos contendo dados binários. Existem muitos 
editores disponíveis alguns gratuitos e outros não, é necessário comparar as características de cada 
para descobrir o mais apropriado. Como sugestão de ferramenta gratuita para Windows pode-se 
baixar o HxDHex Editor, que possui uma boa interface gráfica e bom desempenho. 
Download: http://mh-nexus.de/en/hxd/. 
 
- ImportREConstructor 
ImpREC é uma ferramenta útil quando se está realizando o unpacking manual de um malware. A 
Import Address Table (IAT) é frequentemente danificada quando é feito o unpacking manual através 
de um dump de memória e você pode utilizar o ImpREC para recuperar a tabela. 
Download: http://tuts4you.com/download.php?view.415. 
 
- PEview 
PEview é uma ferramenta gratuita para visualizar as estruturas do arquivo PE. Você pode ver o 
cabeçalho PE, seções individuais e as tabelas de import/export. 
Download: http://www.magma.ca/~wjr/. 
 
- Resource Hacker 
É um utilitário gratuito para análise estática, com ele é possível visualizar, renomear, modificar, 
adicionar, excluir e extrair informações da seção resources de binários do tipo PE. Devido aos 
http://www.ntcore.com/
http://www.dependencywalker.com/
http://mh-nexus.de/en/hxd/
http://tuts4you.com/download.php?view.415
http://www.magma.ca/~wjr/
Engenharia Reversa e Análise de Malware | 19 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
malwares frequentemente extraírem uma DLL, ou um driver da seção resources em tempo de 
execução, essa ferramenta é muito útil para extrair essas seções sem a necessidade de executar o 
código malicioso. 
Download: http://www.angusj.com/resourcehacker/. 
 
- Strings 
Ferramenta de análise estática para examinar strings em ASCII e Unicode em arquivos binários. 
Utilizar Strings é frequentemente um jeito fácil de obter uma visão alto-nível das capacidades do 
malware, mas esse está com algum packer ou ofuscação Strings não tem muita utilidade. O 
comando Strings já vem nativo em todas as distribuições Linux e no Windows e possível fazer o 
download da ferramenta, ela faz parte da SysinternalsSuite. 
Download: http://www.sysinternals.com/. 
1.5. Antireversing e anti-antivirus 
 
Atualmente quase todos os malwares possuem alguma espécie de “armadura” para se 
protegerem. Primeiramente para evitarem ser detectados pelas ferramentas de segurança como 
antivírus e sistemas de detecção de intrusão. Também querem ficar longe dos olhares curiosos dos 
analistas de vírus, pesquisadores de segurança e outros profissionais interessados em realizar a 
engenharia reversa do código. Além disso, essas técnicas de ofuscação também são utilizadas para 
prevenir que outros “hackers” examinem o código, determinando onde o atacante está controlando 
os computadores infectados ou armazenando os dados furtados das vítimas, e tomem para si essa 
botnet para aumentar seus lucros ilícitos com phishings e distribuição de malwares. Ainda como 
forma de proteção, dentro do código de um malware pode haver uma lista de outros malwares que 
são desinstalados assim que o computador é infectado, mantendo pra si o controle total do 
computador da vítima. 
São utilizadas variadas técnicas para proteger e esconder o conteúdo original do arquivo, já é 
bem comum utilizarem mais de uma camada de proteção em um código para terem certeza que ele 
se permanecerá indetectável. Os mecanismos de antireversing mais conhecidos são: packers, 
cryptors (criptografia) e binders, joiners ou wrappers. Também são utilizadas técnicas como 
polimorfismo e metamorfismo para se manterem distantes dos programas antivírus. Vejamos a 
seguir o que cada técnica significa e posteriormente em outras aulas explorá-las com mais detalhes. 
1.5.1. Polimorfismo 
 
A maneira mais fácil para o antivírus identificar programas maliciosos é através de 
http://www.angusj.com/resourcehacker/
http://www.sysinternals.com/
Engenharia Reversa e Análise de Malware | 20 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
assinaturas. Ele mantém um banco dedados frequentemente atualizado com assinaturas de vírus, 
que visa conter uma identificação única para cada malware conhecido. Esta identificação é baseada 
em uma sequência única que foi encontrada em uma amostra específica do programa malicioso. 
O polimorfismo é uma técnica que frustra a identificação baseada em assinatura porque ela 
codifica ou criptografa o código do programa de uma forma que mantém a sua funcionalidade 
original. A abordagem mais simples para o polimorfismo é baseada na criptografia do malware 
usando uma chave aleatória e descriptografando em tempo de execução. Dependendo do momento 
que um antivírus examina o malware por sua assinatura, isso pode impedir a identificação precisa 
do programa malicioso porque cada cópia é completamente diferente (devido à criptografia que 
utiliza a chave aleatória). Porém essa técnica não é livre de falhas já que o antivírus pode escanear o 
malware na memória conseguindo atingir seu código original ou ainda utilizar como assinatura o 
próprio algoritmo de descriptografia do malware que sempre será o mesmo. 
1.5.2. Metamorfismo 
 
Devido ao polimorfismo ser limitado a modificações superficiais no código de 
descriptografia do malware ainda há muitos meios para o antivírus identificar código polimórfico, 
isso pode ser feito analisando o código e extraindo certas informações de alto-nível dele. 
Nessa situação que o metamorfismo é utilizado, ao invés de criptografar o corpo do 
programa e realizar pequenas modificações no mecanismo de descriptografia, é possível alterar todo 
o programa cada vez que o malware é replicado. A vantagem do metamorfismo (do ponto de vista 
do autor) é que cada versão do artefato malicioso é radicalmente diferente das outras. Isso faz com 
que seja muito difícil para os desenvolvedores dos antivírus utilizar qualquer tipo de detecção por 
assinatura. 
Metamorfismo requer um poderoso mecanismo de análise de código que precisa estar embutido 
dentro do programa malicioso. Esse mecanismo escaneia o código do programa e gera uma 
diferente versão dele em tempo de execução cada vez que o programa é duplicado. A parte 
inteligente aqui é o tipo de modificações feitas pelo programa. Um mecanismo metamórfico pode 
executar uma enorme variedade de alterações no programa malicioso, não precisa nem dizer que as 
alterações são realizadas no programa todo inclusive no próprio mecanismo. Em resumo, 
combinando diversas técnicas, um mecanismo metamórfico pode criar malware realmente flexíveis 
que pode ser muito difícil de localizar e identificar. 
1.5.3. Packers 
 
Os termos packer (empacotador), compressor (compressor) e packing (embalagem) são utilizados 
Engenharia Reversa e Análise de Malware | 21 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
nos meios hackers como sinônimo para se referirem geralmente a programas de ofuscação de 
arquivos. Packers são programas que permitem ao usuário comprimir, e muitas vezes criptografar, o 
conteúdo de um arquivo executável sem perder suas funcionalidades. Ele comprime o executável 
original e por consequência ofusca seu conteúdo, cria um novo conteúdo de código executável, 
insere no código uma rotina de descompressão, que geralmente fica no final do arquivo, e modifica 
o entry point do executável para apontar para essa rotina de descompressão. Quando o programa é 
executado a rotina de descompressão entra em ação e o programa é “unpacked” na memória, 
iniciando assim a execução do código original. 
1.5.4. Cryptors 
 
Programas de criptografia de arquivos executáveis (encryptors), também conhecido nos meios 
hackers como cryptors, crypters e protectors, têm os mesmos propósitos dos packers para os 
atacantes, são utilizados para ocultar o conteúdo de um arquivo executável. Também tendem a se 
manterem indetectáveis pelos antivírus e IDS e resistirem a esforços de engenharia reversa. 
Diferente dos packers, os cryptors fazem isso utilizando um algoritmo de criptografia no 
executável, fazendo com que o conteúdo arquivo alvo fique embaralhado e indecifrável. Cryptors 
também inserem no código uma rotina de descriptografia que é responsável por trazer de volta o 
conteúdo original do arquivo na memória toda vez que ele é executado. Além do algoritmo de 
criptografia outra diferença dos packers é que eles geralmente não possuem algoritmos de 
compressão de dados, não têm como objetivo diminuir o tamanho do arquivo. 
 
1.5.5. Binders, Joiners ou Wrappers 
 
Binder (também conhecido como joiner ou wrapper) em ambiente Windows recebe como 
entrada um arquivo executável (geralmente malicioso) e outro arquivo qualquer (geralmente 
benigno), e junta os dois formando um só arquivo executável. O autor pode determinar qual arquivo 
será executado e se essa execução será oculta ou não, além de determinar em qual pasta será 
copiado, quais ações a serem tomadas com os dois arquivos, etc. Por exemplo o atacante pode 
combinar o arquivo malicioso com um arquivo JPG, quando a vítima o executar será aberta a 
imagem JPG e o arquivo malicioso pode ser executado de forma oculta para não levantar suspeita. 
Esse pode ser um mecanismo efetivo para distribuição de malwares. 
1.5.6. Strings Ofuscadas 
 
Veremos nos capítulos posteriores que quando um programa é compilado seu código-fonte é 
Engenharia Reversa e Análise de Malware | 22 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
transformado em uma linguagem que o computador entenda, geralmente chamamos isso de 
linguagem de máquina. Mesmo com essa transformação alguns elementos originais do código-fonte 
do programa permanecem iguais, isso se a aplica para as cadeias de caracteres, mais conhecidas 
como strings. Strings podem conter URLs, endereços de e-mails, conexões com servidores de banco 
de dados, nomes de usuários e senhas, etc. Sabendo que essas informações podem permanecer 
visíveis nos executáveis mesmo após o processo de compilação, os autores de malwares passaram a 
adotar medidas para ofuscar o conteúdo dessas strings. Geralmente isso é feito através de 
algoritmos de criptografia, antes de compilar o programa o atacante seleciona as strings originais do 
código-fonte, as insere em programas cryptors de strings, pega o resultado (a string criptografada) e 
substitui a original do código por essa nova. Feito isso, antes de usar cada string criptografada do 
código ele faz uma chamada para uma função de descriptografia, que em tempo de execução irá 
reverter o processo retornando a string original. Essa técnica será tratada em detalhes nos próximos 
capítulos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Engenharia Reversa e Análise de Malware | 23 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
2. Estruturas Internas dos Softwares 
 
Softwares podem ser considerados umas das mais complexas criações do homem moderno. 
O seu desenvolvimento envolve inúmeras ferramentas como linguagens de programação, 
compiladores, linkers, debuggers, sistemas operacionais, etc. No surgimento dos computadores os 
programadores de software deveriam conhecer todos os mecanismos internos do ambiente onde 
seus programas seriam executados, caso contrário não obteriam sucesso. Isso inclui gerenciamento 
de memória, funcionamento da CPU, linguagem de máquina e muitos outros tópicos. Com o passar 
dos anos, até chegar aos dias atuais, foram criadas diversas camadas de abstrações no 
desenvolvimento de software. Isso possibilita que o desenvolvedor não mais precise conhecer todos 
os mecanismos internos do computador para conseguir produzir um software. De forma 
simplificada ele precisa apenas entender algumas instruções (linguagens de programa de alto-nível) 
que informam ao computador o que fazer. 
Malware nada mais é do que um software com intenções maliciosas, desse modo do ponto 
de vista da engenharia reversa de malware esse avanço que tivemos no desenvolvimento de 
software não é muito bom já que ele deixouos programadores com menos conhecimentos dos 
aspectos internos dos softwares. 
Ao analisar um malware a única coisa que temos é o arquivo malicioso e mais nada, não 
temos o código-fonte com a linguagem de alto-nível que foi utilizada para criá-lo. E as informações 
que conseguimos extrair desse arquivo geralmente estão em baixo-nível, por isso quanto maior for o 
conhecimento dessas estruturas internas dos softwares mais resultados satisfatórios conseguiremos 
extrair das ferramentas. Vamos então iniciar nossa jornada ao mundo dos softwares! 
2.1. Níveis de abstração 
 
Em arquitetura de computadores, tradicionalmente um computador pode ser representado 
através de inúmeros níveis de abstração (camadas) para assim criar um meio de esconder detalhes 
de implementação. Por exemplo, você pode executar o sistema operacional Windows em diferentes 
tipos de hardware porque a camada de hardware abaixo é abstraída do SO. 
Autores de malware criam programas em linguagens de alto-nível e usam um compilador 
para gerar código de máquina que será executado pela CPU. Reciprocamente, analistas de malware 
e engenheiros reversos operam no nível das linguagens de baixo-nível; nós utilizamos um 
disassembler para gerar código assembly e assim podemos ler e analisar para tentar descobrir como 
Engenharia Reversa e Análise de Malware | 24 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
um programa malicioso funciona. 
A Figura abaixo mostra um modelo simplificado de três níveis de código envolvidos em 
análise de malware. 
 
Apesar de haver apenas três níveis de abstração na figura, geralmente computadores são 
descritos com os seis diferentes níveis de abstração que se seguem. Listaremos esses níveis 
começando pelo mais baixo. Os níveis mais altos são colocados no topo e quanto mais baixo você 
vai, menor o nível de portabilidade dos sistemas. 
 
Hardware: O nível do hardware, o único nível físico, consiste em circuitos elétricos que 
implementam complexas combinações de operadores lógicos como o XOR, AND, OR e NOT, 
conhecido como lógica digital. Por causa da sua natureza física, o hardware não pode ser facilmente 
manipulado por software. 
 
Microcódigo: O nível microcódigo também é conhecido como firmware. Microcódigo opera 
somente no exato circuito para o qual foi projetado. Ele contém micro instruções que traduzem o 
código de máquina de alto-nível para prover um meio de interface com o hardware. Quando 
realizamos análise de malware geralmente não nos preocupamos com o microcódigo porque ele é 
bem específico para o hardware para o qual foi escrito. 
 
Código de máquina: O nível do código de máquina consiste em opcodes, dígitos hexadecimais que 
dizem ao processador o que você quer que ele faça. Código de máquina tipicamente é 
implementado com muitas instruções de microcódigo, assim a camada abaixo de hardware 
consegue executar o código. Ele é criado quando um software escrito em linguagem de alto-nível é 
compilado. 
 
Engenharia Reversa e Análise de Malware | 25 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
Linguagens de baixo-nível: Uma linguagem de baixo-nível é a versão amigável aos humanos do 
conjunto de instruções da arquitetura do computador. A linguagem mais comum de baixo-nível é a 
linguagem assembly. Analistas de malware operam no nível das linguagens de baixo-nível porque o 
código de máquina é muito difícil para humanos compreenderem. Utilizamos um disassembler para 
gerar texto em linguagem de baixo-nível, que consiste em simples mnemônicos como o MOV e 
JMP. Existem diferentes dialetos da linguagem assembly, durante o curso iremos focar na sintaxe 
Intel x86. Assembly é a linguagem de mais alto nível que conseguimos recuperar de forma 
consistente e confiável do código de máquina quando o código-fonte original de alto-nível não está 
disponível. 
 
Linguagens de alto-nível: A maioria dos programadores opera no nível das linguagens de alto-
nível. Elas fornecem forte abstração do nível de máquina e facilitam o uso de lógica de 
programação e mecanismos de controle de fluxo. Linguagens de alto-nível incluem C, C++, Visual 
Basic, Pascal e outras. Essas linguagens são tipicamente convertidas em código de máquina por um 
compilador através de um processo chamado compilação. 
 
Linguagens interpretadas: Linguagens interpretadas estão no nível mais alto. Muitos 
programadores utilizam linguagens interpretadas como C#, Perl, Python, .NET e Java. O código 
nesse nível não é compilado em código de máquina; ao invés disso, é traduzido em bytecode. 
Bytecode é uma representação intermediária que é específica da linguagem de programação. Eles 
executam em um interpretador, que é um programa que traduz bytecode em código de máquina em 
tempo de execução. Um interpretador fornece um nível automático de abstração quando comparado 
com código compilado tradicional, porque ele manipula erros e gerenciamento de memória por si 
próprio, independentemente do sistema operacional. 
2.2. Engenharia Reversa 
 
Quando um malware está armazenado no disco, ele geralmente está no formato binário no 
nível de código de máquina. Como foi discutido, código de máquina é uma forma de código que o 
computador pode executar rapidamente e eficientemente. Quando nós fazemos o disassembly do 
malware (como mostrado na figura acima), o arquivo binário é usado como entrada para gerar 
código da linguagem assembly como saída, com a ajuda de um disassembler (IDA Pro). 
Linguagem assembly é na verdade uma classe de linguagens. Cada dialeto do assembly é 
normalmente utilizado para programar uma única família de processadores, como por exemplo x86, 
x64, SPARC, PowerPC, MIPS e ARM. A x86 é de longe a arquitetura mais popular para PCs. 
Engenharia Reversa e Análise de Malware | 26 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
A maioria dos computadores pessoais de 32-bit são x86, também conhecidos como Intel IA-
32, e todas as versões mais modernos do Microsoft Windows de 32-bit são projetados para rodar na 
arquitetura x86. Adicionalmente, a maioria das arquiteturas AMD64 e Intel 64 que rodam Windows 
também suportam binários para a arquitetura x86 32-bit. Por essa razão, a maioria dos malwares são 
compilados para a x86, que será o foco desse curso. Agora iremos nos focar nos aspectos mais 
importantes da arquitetura x86 para a análise de malwares. 
2.3. A Arquitetura x86 
 
As características internas da maioria das arquiteturas dos computadores atuais seguem a 
arquitetura de Von Neumann, ilustrada na figura abaixo. Ela tem três componentes de hardware: 
 - A central processing unit (CPU) executa código. 
 - A main memory (memória principal) do sistema (RAM) armazena todos os dados e código. 
 - Um sistema de entrada/saída (input/output, I/O) faz a interface com os dispositivos como 
discos rígidos, teclados e monitores. 
 
 
 
Como é possível ver na figura, a CPU possui vários componentes: 
- A control unit coordena a execução de instruções vindas da RAM, através de um 
registrador (o instruction pointer, EIP) que armazena o endereço da instrução a ser executada. Ela 
também envia resultados da ALU para a RAM. 
- Registradores são unidades de armazenamento básicas da CPU e são frequentemente 
utilizados para poupar tempo, assim a CPU não precisa acessar a RAM. 
- A ALU, arithmetic logic unit (unidade lógica e aritmética), executa uma instrução trazida 
da RAM e coloca os resultados nos registradores ou na própria RAM. 
O processo de trazer e executar instrução após instrução é repetido enquanto o programa 
Engenharia Reversa e Análise de Malware | 27 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
está rodando. 
2.4. Memória Principal (RAM) 
 
A memória principal para um programa em execução pode ser dividida em quatro seções 
principais, como mostrado na figura abaixo. 
 
 
Dados: Esse termo pode ser utilizado para referenciar uma seção específicada memória chamado 
de data section, que contém dados que são carregados na memória assim que o programa é 
executado. Esses valores às vezes são chamados de dados estáticos porque eles não mudam 
enquanto o programa está rodando, ou também podem ser chamados de dados globais porque estão 
disponíveis para qualquer parte do programa. 
 
Código: Código inclui as instruções que são trazidas pela CPU para executar as tarefas do 
programa. O código controla o que o programa faz e como as tarefas do programa serão 
coordenadas. 
 
Heap: A heap é utilizada para memória dinâmica durante a execução do programa, para criar 
(alocar) novos dados e eliminar (free) dados que o programa não mais precisa. A heap é também 
conhecida como memória dinâmica pois seu conteúdo pode mudar frequentemente enquanto o 
programa está rodando. 
 
Stack: A stack (pilha) é utilizada para variáveis locais e parâmetros de funções, e ajuda no controle 
do fluxo do programa. Falaremos com mais detalhes da stack logo mais. 
 
Engenharia Reversa e Análise de Malware | 28 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
Embora a figura mostre as quatro seções principais em uma ordem específica, essas seções 
podem ser alocadas em qualquer parte da memória. Por exemplo, não há garantia que a stack estará 
abaixo ao código ou vice-versa. 
2.5. Instruções 
 
Instruções são os blocos que constroem os programas. Em assembly x86, uma instrução é 
composta de um mnemônico e zero ou mais operandos. Como mostrado abaixo, o mnemônico é 
uma palavra que identifica a instrução a ser executada, como por exemplo MOV, que movem dados. 
Operandos são normalmente utilizados para identificar informações usadas pela instrução, como por 
exemplo um registrador ou valor. 
 
Formato de uma instrução 
Mnemônico Operando de destino Operando de origem 
MOV ECX 0x42 
 
2.6. Opcodes e Endianness (Ordenação) 
 
Cada instrução corresponde a opcodes (operation codes) que diz à CPU qual operação o 
programa quer realizar. Disassemblers traduzem opcodes em instruções legíveis por humanos. Por 
exemplo, na tabela abaixo você pode ver que o opcodes para a instrução “MOV ECX, 0x42” são 
“B9 42 00 00 00”. O valor 0xB9 corresponde ao “MOV ECX,” e “0x42000000” corresponde ao 
valor 0x42. 
 
Instruções e Opcodes 
Instrução MOV ECX, 0x42 
Opcodes B9 42 00 00 00 
 
0x42000000 é tratado como o valor 0x42 porque a arquitetura x86 usa o formato little-
endian. A endianness (ordem dos bytes) dos dados descreve se o mais significativo (big-endian) ou 
o menos significativo (little-endian) byte é ordenado primeiro, no endereço mais baixo da memória. 
Mudança de endianness é algo que o malware deve fazer durante a comunicação com a rede, isso 
devido aos dados de rede utilizarem o big-endian e programas x86 utilizarem little-endian. Dessa 
forma, o endereço IP 127.0.0.1 será representado como 0x7F000001 em big-endian (na rede) e 
Engenharia Reversa e Análise de Malware | 29 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
0x0100007F em little-endian (localmente na memória). Como um analista de malware você deve 
ser conhecedor desses formatos para ter certeza que não irá acidentalmente inverter a ordem dos 
bytes de importantes indicadores como um endereço IP. 
2.7. Operandos 
 
Operandos são utilizados para identificar os dados usados por uma instrução. Três tipos de 
operandos podem ser usados: 
 - Imediatos: operandos que possuem valor fixo, como por exemplo 0x42. 
 - Registradores: operandos que se referem aos registradores da CPU, como por exemplo 
ECX. 
 - Endereços de memória: operando que fazem referência a endereços da memória que 
contenham um valor de interesse, tipicamente denotados por um valor, registro ou equação entre 
colchetes, como exemplos [0xFFFFFFAA], [ECX] e [ECX+0x08]. 
2.8. Registradores 
 
Um registrador é o menor local de armazenamento de dados disponível para a CPU, cujo 
conteúdo pode ser acessado mais rapidamente que qualquer outro tipo de armazenamento. 
Processadores x86 têm uma coleção de registradores disponíveis, a tabela abaixo mostra os 
registradores mais comuns que se encaixam nessas quatro categorias: 
 - Registradores de uso geral são utilizados pela CPU durante a execução do programa. 
 - Registradores segmentados são utilizados para mapear seções da memória. 
 - Flags de status são utilizadas para a tomada de decisões. 
 - Instruction Pointers são utilizados para manter a sequência da próxima instrução a ser 
executada. 
 
Você pode utilizar a tabela abaixo como referência para consulta durante essa aula, as 
próximas seções discutem cada uma dessas categorias. 
 
Os Registradores x86 
Registradores de uso geral Registradores 
segmentados 
Flags de status Instruction pointers 
EAX (AX, AH, AL) CS EFLAGS EIP 
Engenharia Reversa e Análise de Malware | 30 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
EBX (BX, BH, BL) SS 
ECX (CX, CH, CL) DS 
EDX (DX, DH, DL) ES 
EBP (BP) FS 
ESP (SP) GS 
ESI (SI) 
EDI (DI) 
 
Todos os registradores de uso geral possuem 32 bits de tamanho e podem ser referenciados 
como 32 bits ou 16 bits no código assembly. Por exemplo, EDX é utilizado para referenciar o 
registrador de 32 bits inteiro, e DX é utilizado para referenciar os 16 bits menores do registrador 
EDX. 
Quatro registradores (EAX, EBX, ECX e EDX) também podem ser referenciados como 8 
bits usando os 8 bits mais baixos ou o segundo conjunto de 8 bits mais baixo. Exemplo, AL é 
utilizado para referenciar os 8 bits mais baixos do registrador EAX, e o AH é utilizado para 
referenciar o segundo conjunto de 8 bits mais baixos. 
A tabela acima lista as possíveis referências para cada registrador geral. O EAX 
desmembrado é ilustrado na figura abaixo. No exemplo, o EAX de 32 bits (4 bytes) contém o valor 
0xA9DC81F5 e o código pode referenciá-lo de três formas adicionais: AX (2 bytes) que é 0x81F5, 
AL (1 byte) que é 0xF5 e AH (1 byte) que é 0x81. 
 
 
Registradores de uso geral 
 
Esses registradores geralmente armazenam dados ou endereços de memória e são raramente 
Engenharia Reversa e Análise de Malware | 31 
Ronaldo Pinheiro de Lima | www.crimesciberneticos.com 
 
utilizados alternadamente. Todavia, apesar de serem chamados de registradores globais, eles nem 
sempre são empregados dessa forma. 
Algumas instruções x86 usam registradores específicos por padrão. Por exemplo, as 
instruções de multiplicação e divisão sempre utilizam o EAX e EDX. Adicionalmente, instruções 
específicas em determinados compiladores podem sempre utilizar os mesmos registradores em todo 
o programa. Isso é chamado de convenção. O conhecimento das convenções utilizadas pelos 
compiladores permite ao analista de malware examinar o código mais rapidamente. Um exemplo de 
convenção é o EAX que normalmente armazena o valor de retorno de uma função. Dessa forma se 
você ver o EAX logo após um CALL você provavelmente saberá que os dados manipulados através 
do EAX dizem respeito ao retorno da função. 
 
Flags 
 
O registrador EFLAGS é um registrador de status. Na arquitetura x86, ele possui 32 bits de 
tamanho e cada bit é uma flag. Durante a execução, cada flag é ligada (1) ou desligada (0) para 
controlar as operações da CPU ou indicar resultados dessas operações. As flags abaixo são as mais 
importantes para a análise de malware: 
 - ZF: A Zero Flag é ligada (1) quando o resultado de uma operação é igual à zero; para 
outros resultados ela é desligada (0). 
 - CF: A Carry Flag é ligada (1) quando o resultado de uma operação é muito grande ou 
muito pequeno para um operando, para outros resultados ela é desligada (0). 
 - SF: A Sign Flag é ligada (1) quando o resultado de uma operação é negativo ou desligada 
(0) quando o resultado é positivo. Essa flag também é ligada quando o bit mais significativo é 
ligado após uma operação aritmética. 
 - TF: A Trap Flag é usada para debugging. O processador