---

Introdução

Há alguns meses atrás eu me interessei por um campo na área de Tecnologia que hoje (em minha opinião) é muito mal-explorado. Eu estou falando da Engenharia Reversa.

Eu sei que pode parecer um pouco chato falar disso. Mas como um bom backend, queria compartilhar sobre uma descoberta que eu fiz e compartilhar o que eu fiz sobre isso.

Afinal, o que diabos eu descobri?

Bom, eu descobri um algoritmo. Um algoritmo de engenharia reversa assustadoramente simples que (pelo o que eu entendi) serve para descobrir tipos de arquivos desconhecidos por meio de imagens.

Parece algo muito complexo. Mas, como disse anteriormente, é assustadoramente simples, mas gera resultados muito intrigantes e interessantes

Reverse Engineering Dynamic Binary Visualization

Sim. Nome grande, né?

Esse é o nome do algoritmo, e eu descobri ele por meio de um cara chamado Cristopher Domas, que hoje trabalha na Intel e foi muito reconhecido na época.

Como já disse, o algoritmo serve para analisar arquivos (a princípio, desconhecidos) e descobrir seus tipos ou pelo menos o "formato" do arquivo com esse algoritmo

Como funciona?

Vamos supor que você tenha um arquivo. Por exemplo, um Hello World em JavaScript:

• Arquivo: hello.js

  console.log("Hello World")
  

Esse arquivo é constituido de (caracteres) bytes, e esses bytes, essencialmente, são simplesmente números que vão de 0 a 255. Então, representando o arquivo hello.js em uma sequência de números, temos:

• Arquivo: hello.js (bytes em números)

  99 111 110 115 111 108 101 46 108 111 103 40 34 72 101 108 108 111 32 87 111 114 108 100 34 41 10
  

Agora temos a representação "crua" do arquivo. E é aí que o algoritmo trabalha.

Basicamente, o algoritmo simplesmente itera sobre os pares de bytes do arquivo e os trata como coordenadas em uma imagem.

1. Iterar sobre os pares de bytes no arquivo.
   Basicamente, é um loop que itera sobre cada par de bytes dentro do arquivo.

   99 111
   111 110
   110 115
   115 111
   ...
   

2. Tratar cada par como coordenada em uma imagem.
   Simplesmente pegamos o par que estamos trabalhando e usamos o primeiro item como a coordenada X da imagem e o segundo item como coordenada Y na imagem.

   (x=99,  y=111)
   (x=111, y=110)
   (x=110, y=115)
   (x=115, y=111)
   ...
   

Dessa forma, geramos a imagem. Mas o que essa imagem nos diz?

Analisando as imagens geradas

Bom, o nosso exemplo é muito simples, então vamos pular para algo mais legal, como 1 minuto da trilha sonora de Star Wars:

Ou 69 Parágrafos de Lorem Ipsum:

E também um executável Linux:

Claro, não são as imagens mais belas do mundo. Mas o mais interessante disso tudo, é que existem padrões sendo gerados. E com esses padrões é possivel identificar os padrões dos própios bytes no arquivo. Isso ajuda a identificar arquivos desconecidos em uma análise de Engenharia Reversa.

O que eu fiz com isso

Basicamente, eu implementei o algoritmo. Eu nomeei o projeto Domas, em homenagem ao Christopher Domas, quem descreveu o algoritmo.

O repositório do projeto está no meu perfil, se quiserem dar uma estrelinha lá, fiquem à vontade :)

Encerramento

A mensagem que eu quero dar com esse post é que nem sempre os campos subestimados da Tecnologia são ruins (na verdade na vida toda).

Então eu encorajo você leitor a tentar entrar em areas não só como a da Engenharia Reversa, mas como em outras mal-exploradas desse vasto mundo das programações...

Obrigado por ler, nos vemos na próxima.

---

Por Marcio Dantas