Saudações

Esse mini-guia com a intenção de ser um auxílio em sua jornada caso

tenha interesse em engenharia reversa, ou quem sabe venha a ter.

O que é necessário para iniciar a engenharia reversa?

• Ter força de vontade e determinação para aprender, além de tempo

é claro.
• Conhecimentos em Software e Hardware;
• Conhecimentos em programação (Assembly e C em especial);
• Sistemas Operacionais e Arquitetura de Computadores

Hoje em dia muitos de nós acabam ficando sobrecarregados e super

eufóricos devido o excesso de conteúdo disponível, aquele sentimento
diário de estar perdendo algo e deixar um zilhão de abas abertas com
artigos que merecem ser lidos...Eu sei eu passo por isso também.
Por isso eu acho interessante ter um guia para manter a ordem e tive
essa ideia de contribuir para com que está chegando na área, e também
estou escrevendo sobre outros temas, no futuro um guia mais completo
para:

Sistemas Operacionais

Engenharia Reversa

Análise de Malware

Deixo em aberto para quem quiser contribuir para a iniciativa

escrevendo sobre algo que tenha interesse, complementar ou criticar.

Zolf#1763

Atenção! Nas páginas a seguir, haverá conceitos básicos mas que não
podem ser subestimados.
Introdução à Engenharia reversa
O que é engenharia reversa?

Engenharia reversa, como o próprio nome já diz é a engenharia ao

contrário, ou seja, seguindo os passos contrários aos usados para se
construir. Usada para entender as características de um produto como
por exemplo uma placa de vídeo ou software.

Lembrando que é ilegal quando se faz isso com hardware ou software comercial

Engenharia reversa é o processo de descoberta dos princípios

tecnológicos de um dispositivo, objeto ou sistema através da análise de
sua estrutura, função e operação.

Um bom exemplo de engenharia reversa está em uma das minhas séries

favoritas e que recomendo para todos Haltch and Catch Fire
A série se passa nos anos 80, no início dos computadores e como tudo era
hardware proprietário acabava dificultando o processo de evolução. Os
dois da foto aí estão fazendo engenharia reversa de um computador da
IBM. Vou deixar um link do YouTube da cena
https://www.youtube.com/watch?v=jSZwtrnKxf4
 Os conceitos aprendidos aqui vão servir perfeitamente caso queira
aprofundar em hardware, no entanto vale avisar que esse guia não se
destina para o hardware hacking, mas talvez numa próxima.

Áreas de aplicação da engenharia reversa de software

Análise de Malware

Os criadores de programas maliciosos geralmente não compartilham seu

código-fonte com empresas de segurança da informação. Portanto,
analistas e até pesquisadores independentes, podem usar a engenharia
reversa para entender como essas ameaças digitais funcionam e, em
seguida, construir suas defesas

Análise de Vulnerabilidade

Alguns bugs encontrados em software podem ser exploráveis por outros

programas. Por exemplo, uma falha no componente SMB do Windows
permitiu que a NSA desenvolvesse um programa que dava acesso a
qualquer computador com o componente exposto na Internet. Para
encontrar tal vulnerabilidade, especialistas precisam conhecer sobre
engenharia reversa, dentre outras áreas.

Correção de bugs

Às vezes um software tem um problema e por algum motivo você ou sua

empresa não possui mais o código-fonte para repará-lo ou o contrato
com o fornecedor que desenvolveu a aplicação foi encerrado. Com
engenharia reversa, pode ser possível corrigir tal problema.
Mudança e adição de recursos

Mesmo sem ter o código-fonte, é possível também alterar a maneira

como um programa se comporta. Por exemplo, um programa que salva
suas configurações num diretório específico pode ser instruído a salvá-
las num compartilhamento de rede. Adicionar um recurso é, em geral,
trabalhoso, mas possível.

\(Anti-\)pirataria

Software proprietário costuma vir protegido contra pirataria. Você já

deve ter visto programas que pedem número de série, chave de registro,
etc. Com engenharia reversa, os chamados _crackers_ são capazes de
quebrar essas proteções. Por outro lado, saber como isso é feito é útil
para programadores protegerem melhor seus programas. ;-\)

Reimplementação de software e protocolos

Um bom exemplo de uso da engenharia reversa é o caso da equipe que

desenvolve o LibreOffice(Software o qual eu estou escrevendo isso nesse
instante) mesmo sem ter acesso ao código fonte, eles precisam entender
como o Microsoft Office funciona, a fim de que os documentos criados
nos dois produtos sejam compatíveis. Outros bons exemplos incluem:

O Wine, capaz de rodar programas feitos para Windows no GNU/Linux;

O Samba que permite que o GNU/Linux apareça e interaja em redes
Windows;
O Pidgin que conecta numa série de protocolos de mensagem
instantânea;
Até um sistema operacional inteiro chamado ReactOS, que lhe permite
executar seus aplicativos e drivers favoritos do Windows em um
ambiente de código aberto e gratuito.

Todos estes são exemplos de implementações em software livre, que

tiveram de ser criadas a partir da engenharia reversa feita em programas
e/ou protocolos de rede proprietários.
 Por que a engenharia reversa de software é possível?

Como o hardware, o software também pode ser desmontado. Na

verdade, existe um tipo especial de software com essa função, chamado
disassembler ou desmontador. Para explicar como isso é possível,
primeiro é necessário entender como os programas de computador são
criados hoje. Vou resumir isso aqui.
A parte do computador que de fato executa os programas é o chamado
processador. Nos computadores de mesa (desktops) e laptops atuais,
normalmente é possível encontrar processadores fabricados pela Intel ou
AMD. Para ser compreendido por um processador, um programa precisa
falar sua língua: a linguagem (ou código) de máquina.

Os humanos, em teoria, não falam em linguagem de máquina. Bem,

alguns falam, mas isso é outra história. Acontece que para facilitar a
criação de programas, algumas boas almas começaram a escrever
programas onde humanos escreviam código (instruções para o
processador) numa linguagem mais próxima da falada por eles (Inglês no
caso). Assim nasceram os primeiros compiladores, que podemos
entender como programas que "traduzem" códigos em linguagens como
Assembly ou C para código de máquina.
 Segurança em softwares

Muitos softwares comerciais possuem versões de teste, que normalmente

vem com algumas limitações. Entre as principais limitações que o
cracking visa transpassar estão:

• Número de série:
Uma das proteções mais comuns de se encontrar, em que o
software se libera após a introdução de uma senha que pode ser
fixa ou variável.

• Tempo de uso limitado (Trial):

Também é um tipo de proteção bem comum, normalmente é dado
um período para experimentar o software e após isso o mesmo para
de funcionar caso não seja registrado.

• Quantidade de execuções limitadas:

O software para de funcionar assim que já atingido determinado
número de execuções.

• Funções desabilitadas:
Algumas funções importantes são desativadas (como botões ou
menus) até que o programa seja registrado.

• Arquivos-senhas (Key-File)
Proteção que pede um arquivo conteúdo correto para que o
programa seja liberado.

• Executável encriptado e proteção anti cracking:

Proteção que diminui o tamanho do software ou ofusca seu código,
e proteções que impede o uso de ferramentas de análise de
software
Ok, tem várias técnicas novas e em desenvolvimento.
Com certeza você já se deparou com algumas dessas medidas anti
cracking e talvez já tenha até burlado algumas… Eu sei fica entre nós...🤫

É preciso ressaltar de que precisamos ficar no light side da coisa, um

cavaleiro jedi em busca do equilíbrio. Existe uma discussão interessante
sobre se seria o cracking uma democratização do acesso de algumas
coisas. Fica o questionamento. Arquiteturas abertas e software livre
como visto anteriormente é tudo de bom, mas por fim é preciso ponderar
suas ações e o peso das coisas.

Vou deixar o link aqui de um vídeo muito bom sobre questões de

pirataria e propriedade intelectual, quando tiver tempo recomendo
assistir.

A propriedade intelectual é um roubo: Nintendo e a pirataria

(<-Saudoso
SNES)
 Etapas da Engenharia Reversa

• Analise estática do software (Parsing):

Procura-se determinar quais são os componentes básicos do
sistema (arquivos, rotinas, variáveis, etc.), sua localização
(achar uma rotina), e sua interação com os demais
componentes (uma variável que depende de outra). As
ferramentas usadas para fazer este tipo de análise são os Parsers.

• Analise dinâmica do software (Debugging):

É executado o software, e são monitorados valores de
variáveis, funções chamadas, etc. As ferramentas usadas
para este tipo de análise são os Debuggers.

• Informação adicional:
São analisadas todas as fontes de informações externas ao
software, como a documentação (arquivos de ajuda (help),
textos, diagramas, etc.), bancos de dados, entre outras
informações que possam ajudar na análise.

• Tratamento de dados
É decidido qual o melhor caminho a seguir com os dados obtidos
(se será feito alguma modificação na estrutura do sistema, se será
criada alguma ferramenta para ajudar no processo, etc.), e então
é aplicada a técnica escolhida.

• Avaliação dos resultados

É visualizado e avaliado o resultado final, a fim de se achar algum
defeito ou erro (bug)
 Sistemas básicos utilizados

Em nossa sociedade é utilizado um sistema numérico Decimal (de base

10), porém quando se trata de computadores, esse sistema não é
conveniente, pois há a necessidade de se interpretar estados de tensão
(Ligado/Desligado); para isso foi criado o sistema Binário (de base 2),
nesse sistema é utilizado somente os algarismos 0 e 1.
Outro sistema que utilizaremos na engenharia reversa é o Hexadecimal
(de base 16), em que são utilizados dez algarismos e seis letras {1, 2,
3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F}. Grande parte das ferramentas de
analise (Editores Hexadecimais, Debuggers, etc.) utilizam o sistema
hexadecimal para exibir os dados.
Alem dos sistemas numéricos é interessante conhecer um pouco do
padrão ASCII, que é um código numérico usado para representar
caracteres, que usa a escala decimal do 0 à 127, e é interpretado por
todos os computadores atuais.

Tabela de conversão Decimal para Hexadecimal para ASCII:

Relações de Tamanho
Bit: É como chamamos um digito
binário (0 ou 1), é o menor pedaço de
dados existente.
Byte: É um agrupamento de 8 bits. O
valor máximo é de 255 (0-
255).
Word: É um agrupamento de 2 bytes, ou
16 bits.
Double Word: É um agrupamento de 2
words, ou 32 bits.
Kilobyte: São 1024 bits (32*32 bits).
Megabyte: São 1048576 bits, ou seja,
(1024*1024 bits)
 Um Shot de Assembly (.asm)

Na engenharia reversa é imprescindível que se saiba pelo menos o básico

de Assembly, pois quando um software é revertido (através de Parsers ou
Debugger).
Além disso, é bom saber em que arquitetura está sendo executado o
código, qual CPU & é x86, x64, ARM etc? É um grande mediano ou
pequeno mediano? Também que plataforma estamos usando, é Windows,
Linux, Android etc...? Tudo isso é importante no lado mais low level da
força. Mas para nossa sorte, existem ferramentas que resolvem tudo isso
para nós e representam isso de forma fácil de abordar.

A nomenclatura vai mudar de acordo com a arquitetura. Este acima é o

modo i386 e todos os registradores possuem 32bits de tamanho
Flags da CPU

As flags são variáveis de 1 bit (pode ser 0 ou 1) que funcionam como

sinalizadores, ou seja, dependendo do valor que armazenam, fazem com
que determinado salto seja executado ou ignorado.

• Zero Flag: ZR/NZ (zero/not zero) - (zero/não zero)

• Sign Flag: NG/PL (negative/positive) - (negativo/positivo)
• Carry Flag: CY/NC (carry/no carry) - (transmite/não transmite)
• Direction Flag: DN/UP (decrement/increment) -

Pilha (Stack)
A pilha é uma estrutura onde os dados são armazenados para uso
posterior; ela é como uma pilha de livros, em que o ultimo livro
colocado será o primeiro que irá sair. Pilha é um conceito muito
importante para programação.

(Inclusive dentre os tipos de buffer overflow, o stack overflow é o ataque

mais comum e usa da pilha de processos para alocar e sobrescrever mais
do que o espaço designado gerando o vazamento de memória.)
Demonstração de Hello World em assembly

Este é um exemplo das diversas formas de imprimir na tela em seu

código assembly,
-Como diz a profecia que deve se começar pelo “Hello World”, caso
contrário estará fadado ao fracasso com a linguagem. Então se
certifique-se que este será seu primeiro print

; Exemplo de um Hello World em Assembly

; ld -m elf_i386 -s -o hello hello.o
section .text align=0
global _start
mensagem db 'Hello world', 0x0a
len equ $ - mensagem
_start:
mov eax, 4 ;SYS_write
mov ebx, 1 ;Número do file descriptor (1=stdout)
mov ecx, mensagem ;Ponteiro para a string.
mov edx, len ; tamanho da mensagem
int 0x80
mov eax, 1
int 0x8

Ponto é vírgula (;) são para fazer comentários.

O segundo comentário é para compilar para linux

(Sistema de arquivo ELF, diferente do Windows arquivos PE)

O exercício de casa é comparar o código assembly com o código em C.

 Considerações finais

Meu estimado leitor, obrigado por chegar até aqui. Espero que esse
simples pdf tenha somado em sua vida.
Reforço que se precisar entrar em contato estou à disposição, seja por
alguma dúvida, algo que não tenha ficado claro ou também para
acrescentar.
Vale dizer que claramente este é apenas um guide rápido e incompleto,
pois conteúdo de engenharia reversa é quase infinito, a partir daqui você
pode ir atrás de conhecimento mais aprofundado, vou disponibilizar
algumas fontes fenomenais que inclusive me baseei para fazer o guide.
Câmbio Desligo
// @ Zolf

• Papo Binário
•
• Roadsec
•
• HackerSploit
•
• Mini Curso Assembly