Jump to content
  • Comparando executáveis

       (3 reviews)

    Fernando Mercês
     Share

    Saudações, leitores do Mente Binária! Hoje me deu vontade de falar sobre uma tarefa que eventualmente preciso fazer na empresa onde trabalho, que é a de verificar as diferenças entre arquivos executáveis, normalmente de Windows, também conhecidos por executáveis PE.

    Há vários usos ao comparar binários. É possível avaliar o que mudou na versão atual de um software em relação à anterior, descobrir o que muda em cada sample diferente de uma mesma família de malware, etc. Esses dias mesmo me foi pedido que verificasse a diferença entre 6 arquivos maliciosos, que compartilho abaixo como fiz.

    Reconhecimento básico

    Os arquivos que recebi tinham seu hash SHA-256 como nome. A primeira coisa que fiz foi checar seu tipo (usando comandos do macOS, mas o Linux tem comandos similares):

    $ file *
    fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04: PE32 executable (GUI) Intel 80386, for MS Windows
    fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9: PE32 executable (GUI) Intel 80386, for MS Windows
    fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05: PE32 executable (GUI) Intel 80386, for MS Windows
    ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd: PE32 executable (GUI) Intel 80386, for MS Windows
    ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640: PE32 executable (GUI) Intel 80386, for MS Windows
    ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e: PE32 executable (GUI) Intel 80386, for MS Windows

    Só para garantir, também chequei o SHA-256 deles e realmente bateu com o nome, o que era esperado:

    $ shasum -a256 *
    fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04  fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04
    fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9  fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9
    fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05  fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05
    ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd  ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd
    ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640  ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640
    ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e  ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e

    PS.: No Linux o comando seria sha256sum ao invés de shasum -a256.

    O próximo passo foi checar o tamanho deles:

    $ wc -c *
      396973 fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04
      396973 fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9
      396973 fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05
      396973 ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd
      396973 ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640
      396973 ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e
     2381838 total

    Aqui apresentou-se um caso atípico: os binários possuem exatamente o mesmo tamanho! Já pensei que havia grandes chances de as diferenças entre eles serem mínimas: provavelmente algo usado pelo autor do malware só para "mudar o hash" na tentativa de evitar que os antivírus detectem os arquivos idênticos, por exemplo. Essa tentativa é na verdade frustrada visto que, ao contrário do que muitos pensam, os antivírus não detectam malware por hash normalmente, já que isso seria muito custoso do ponto de vista do desempenho (seria preciso ler todos os bytes do arquivo!) e também seria muito fácil tornar um novo arquivo indetectável - bastaria alterar um único byte para um hash final completamente diferente.

    Comparação de estrutura

    Se estivéssemos tratando arquivos de texto, poderia simplesmente usar o comando diff, mas o assunto aqui é PE, então algo interessante de verificar é sua estrutura, que consiste basicamente em cabeçalhos, localizados antes das seções. Se você não sabe do que estou falando, recomendo os seguintes recursos:

    • Posts do @Leandro Fróes sobre o formato PE e suas referências.
    • Capítulo sobre PE do livro Fundamentos de Engenharia Reversa.
    • Aulas 5 e 6 do CERO, nosso Curso de Engenharia Reversa Online em vídeo.
    • Digitar "PE executable" no Google ler o que curtir.

    Depois dessa imersão no mundo dos executáveis PE, não tenho dúvidas de que você vai se apaixonar por eles também! ?

    Voltando à comparação, o que eu quero dizer com estrutura? Bem, os valores dos campos dos cabeçalhos. Por exemplo, para ver o cabeçalho COFF de um arquivo PE, usei o readpe, parte do kit de ferramentas pev:

    $ readpe -h coff fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04
    COFF/File header
        Machine:                         0x14c IMAGE_FILE_MACHINE_I386
        Number of sections:              5
        Date/time stamp:                 1401620468 (Sun, 01 Jun 2014 11:01:08 UTC)
        Symbol Table offset:             0
        Number of symbols:               0
        Size of optional header:         0xe0
        Characteristics:                 0x102
        Characteristics names
                                             IMAGE_FILE_EXECUTABLE_IMAGE
                                             IMAGE_FILE_32BIT_MACHINE

    Mas não, não usei o pev por saudosismo! A ideia de ter uma saída em texto da estrutura desses binários é depois usar o comando diff para compará-las. A primeira coisa que precisei então foi gerar um .txt contendo toda a estrutura, e não só o cabeçalho COFF, para cada um dos arquivos. Uma repetição em bash dá conta do recado:

    $ ls -1 readpe_output_*
    readpe_output_fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04.txt
    readpe_output_fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9.txt
    readpe_output_fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05.txt
    readpe_output_ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd.txt
    readpe_output_ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640.txt
    readpe_output_ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e.txt

    Eu usei o readpe sem nenhuma opção, assim ele imprime todos os cabeçalhos, incluindo os de seções. Só pra começar fiz um diff do primeiro para o segundo e não houve qualquer saída, ou seja, a estrutura dos arquivos eram idênticas! E eram mesmo:

    $ wc -c readpe_output_*
       21627 readpe_output_fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04.txt
       21627 readpe_output_fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9.txt
       21627 readpe_output_fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05.txt
       21627 readpe_output_ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd.txt
       21627 readpe_output_ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640.txt
       21627 readpe_output_ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e.txt
      129762 total
    
    $ md5 !$
    md5 readpe_output_*
    MD5 (readpe_output_fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04.txt) = 05b36b89b1165b3d619bee16f8a1d7f7
    MD5 (readpe_output_fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9.txt) = 05b36b89b1165b3d619bee16f8a1d7f7
    MD5 (readpe_output_fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05.txt) = 05b36b89b1165b3d619bee16f8a1d7f7
    MD5 (readpe_output_ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd.txt) = 05b36b89b1165b3d619bee16f8a1d7f7
    MD5 (readpe_output_ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640.txt) = 05b36b89b1165b3d619bee16f8a1d7f7
    MD5 (readpe_output_ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e.txt) = 05b36b89b1165b3d619bee16f8a1d7f7

    shocked-queen-sm.jpg.ce229f2f14bf9f1612c9250af8f45976.jpg

    Os hashes MD5 da saída em texto da estrutura de todos os arquivos batem. Eles são mesmo iguais estruturalmente!

    Passado o choque, percebi que teria que comparar o conteúdo das seções (código, dados, talvez resources, etc). Aí fui obrigado a inicializar minha VM do Janelas mesmo...

    Comparação do conteúdo das seções

    Existem alguns softwares que trabalham com PE e possuem funções de comparação de dois executáveis. Eu costumava usar o Cold Fusion (um antigo gerador de patch) pra isso, mas ele tem alguns bugs que me impediram. Achei a mesma função no Stud_PE, mas ele localiza arquivos por extensão na janela de comparação, então renomeei o primeiro e o segundo arquivo que tinha para a.exe e b.exe respectivamente.

    Ao abrir o a.exe no Stud_PE, usei o botão "File Compare", selecionei o método "Binary", setei o "Starting from" pra "Raw" e cliquei em "Compare":

    stud_pe_binary.png.f43593b53d37207b41c525fdcf7a39a7.png

    Se você não entendeu por que fiz isso, volte uma casa ou leia os tutorias de PE que indiquei. Ou pergunte que eu falo. ?

    Bem, entre esses dois caras então havia 9 bytes que o diferenciavam e eu já tinha os offsets a partir do início do arquivo. Agora é descobrir em que seção eles estavam no PE, o que são, o que comem e como eles vivem. ?

    Descobrindo como as diferenças são usadas

    Abri o executável no x64dbg (na verdade no x32dbg, já que este binário é de 32-bits) mas percebi que o entrypoint estava no endereço 013706AA. Como o ImageBase deste binário é 00400000, percebi que o ASLR estava habilitado e, antes de continuar , desabilitei-o com o DIE, como mostro neste vídeo rápido no canal Papo Binário:

    Antes de reabrir o binário no x32dbg, convém lembrar que eu tinha um offset e precisava convertê-lo para endereço virtual (VA). Isso é feito com o que alguns analisadores de PE chamam de FLC (File Location Calculator). O DIE tem, o Stud_PE tem e o pev também tem, com a ferramenta ofs2rva:

    $ ofs2rva 0x4c451 a.exe
    0x4dc51

    Mas pra não você não me acusar de saudosismo de novo, vou mostrar no Stud_PE ?

    stud_pe_flc.png.efbe2b4eb269814e9623419d9d8db653.png

    Percebe que o Stud_PE já diz que este byte pertence à seção .rdata, o que à esta altura você já sabe, caso tenha feito o trabalho de casa de estudo do PE, que é provavelmente uma seção de dados somente-leitura, então há grandes chances de nossa sequência diferentona pertencer à uma string constante, por exemplo. Fui ver no debugger como é que tava a festa. Abri o a.exe lá e dei um Ctrl+G no Dump pra ir pro endereço 44DC51:

    x32dbg_dump.png.934f997d258d268b85cf23e99677272d.png

    De fato tinha uma string lá: zuk0KRrGrP, mas ela na verdade começava em 44DC44 e pra saber quando ela era usada no malware, coloquei um breakpoint de hardware no acesso ao byte, que é o primeiro da string e cheguei à conclusão de que, como o nome sugere, é realmente uma string de identificação da campanha do malware, sempre no mesmo offset (calculei de novo usando FLC).  Agora foi só ver a dos outros e novamente recorri à uma ferramenta do pev (?), a pestr:

    $ for i in *; do echo $i; pestr -so $i | grep 0x4c444; echo; done
    fdba340bb35635934aa43b4bddd11df31f2204e73394b59756931aa2f7f59e04
    0x4c444	.rdata	identifierStrzuk0KRrGrP
    
    fdf3060eb9c39b1a2be168b1ac52c2f80171394e73fe03c4e0c57911cb9358a9
    0x4c444	.rdata	identifierStrAR0U4hr1wW
    
    fedf9d9815b3d0ad28e62f99d5dcf92ec0f5fcb90135b4bdc30bb5709ab9ff05
    0x4c444	.rdata	identifierStrswEYVkFWeg
    
    ff2f1be6f64c91fa0a144cbc3c49f1970ba8107599d5c66d494ffb5550b0f7fd
    0x4c444	.rdata	identifierStrKXaUzlBDIj
    
    ff53c7ba285ffdc2c29683bb79bb239ea59b3532f8b146523adf24d6d61fc640
    0x4c444	.rdata	identifierStrv91TJ5c3Lr
    
    ffee504e292a9f3ae6c439736881ebb314c05eac8b73d8b9c7a5a33605be658e
    0x4c444	.rdata	identifierStrOzJnvFQy2U

    Bom, daí o céu é o limite. Dá pra criar assinatura, criar um script pra extrair esse ID da campanha, enfim, missão cumprida.

    yes-baby-sm.jpg.e8177feec593858c2d9ce5484a87e6dc.jpg

    FAQ

    1. Por que você não utilizou só um comparador de arquivos qualquer, que compara os bytes em hexadecimal?

    Eu queria saber exatamente onde estavam as diferenças entre os arquivos, se na estrutura ou não. Em caso negativo, é código? Se sim, que código? Que faz o que? São dados? Usados onde? Em qual seção? Um editor hexadecimal ignorantão não me daria isso. Além disso, se os arquivos fossem diferente estruturalmente, ou em tamanho, eu queria saber antes, pra não perder tempo analisando diferenças de bytes hexa que eu não sei o que é.

    2. Existem softwares para comparar binários PE muito mais poderosos, como o BinDiff. Por que caralhas você não o usou?

    O BinDiff é pra comparar código. Minha diferença estava nos dados. Além disso, o BinDiff e seus amigos traduzem o Assembly original do binário para uma linguagem intermediária própria e comparam lógica, não instruções. É bem fodão, mas não me atendia neste caso, afinal eu já sabia que os binários eram idênticos em funcionalidade. Só queria saber onde estava a diferença exata.

    3. Percebi pela screenshot do Stud_PE que ele também compara a estrutura dos arquivos PE, então todo aquele processo com o readpe foi à toa?

    Sim, foi só pra Inglês ver. Não, brincadeira! O Stud_PE compara os cabeçalhos COFF, Optional e os diretórios de dados somente. O readpe imprime todos os cabeçalhos, incluindo todas as seções mais os imports. É outro nível, moleque! ?

    stud_pe_structure.png.b43dc07b3e0aa18ad7948610542c360b.png

    4. E quanto à executáveis ELF?

    O título não fala somente de PE propositalmente, já que a mesma técnica pode ser usada para arquivos ELF, só mudando os programas (readelf, etc).

    Por hora é só. Se você deixar sua análise abaixo ou quiser fazer um comentário/pergunta, ficarei muito grato. Considera apoiar a gente também vai. ?

    Edited by Fernando Mercês


     Share


    User Feedback

    Join the conversation

    You can post now and register later. If you have an account, sign in now to post with your account.
    Note: Your post will require moderator approval before it will be visible.

    Guest

    • This will not be shown to other users.
    • Add a review...

      ×   Pasted as rich text.   Paste as plain text instead

        Only 75 emoji are allowed.

      ×   Your link has been automatically embedded.   Display as a link instead

      ×   Your previous content has been restored.   Clear editor

      ×   You cannot paste images directly. Upload or insert images from URL.


    Guest GuzMan

      

    O Mercês é fodástico!

    Link to review
    Share on other sites


  • Similar Content

    • By Fernando Mercês
      No últmo artigo falei sobre como montar uma máquina virtual básica para ER em Windows. Agora chegou a vez do Linux, já que o mundo não é feito só de PE. 🙂
       A ideia aqui é montar um ambiente legal para reverter binários ELF. Dá uma olhada neste vídeo (em tela cheia de preferência) pra ter uma ideia do poder dessas ferramentas:
      Legal né? Então mãos à obra!
      Máquina virtual
      1 GB de memória Placa de rede em modo NAT Sistema operacional
      Utilizo a ISO netinstall do Debian 64-bits, mas como sempre você é livre para utilizar a distribuição que quiser, só que este artigo é escrito com base nesta. 😉
      Algumas dicas de instalação:
      Não utilizar seu nome verdadeiro na criação da conta de usuário. Não instalar as extensões do software virtualizador como VMware Tools ou VirtualBox Guest Additions. Não configurar nenhuma regra de firewall ou qualquer software de proteção. /etc/apt/sources.list
      Eu deixo do seguinte jeito:
      deb http://deb.debian.org/debian/ testing main contrib non-free deb-src http://deb.debian.org/debian/ testing main contrib deb http://security.debian.org/debian-security testing-security main contrib non-free deb-src http://security.debian.org/debian-security testing-security main contrib O importante aqui é ter o contrib non-free após o main, já que alguns programas como o rar não são livres.
      Depois de configurado este arquivo, é bom atualizar os pacotes existentes:
      # apt update # apt upgrade -y Instalação de software
      Agora é hora de instalar os pacotes necessários:
      # apt install man gdb binutils vim strace ltrace ht build-essential tcpdump unhide foremost sudo p7zip-full rar unrar fasm gcc-multilib git file zip unzip python3-pip GEF
      Este é um plugin para o GDB que adiciona muitos recursos:
      # pip3 install capstone keystone-engine unicorn ropper # git clone https://github.com/hugsy/gef.git # echo "source $PWD/gef/gef.py" >> ~/.gdbinit Observações finais
      Após instalar todos os softwares, é de extrema utilidade criar um snapshot da máquina virtual, pra você voltar facilmente a este estado limpo após analisar um arquivo suspeito, por exemplo. Não precisa instalar um ambiente gráfico. Existe uma distribuição Linux chamada REMnux com foco em engenharia reversa, se você preferir.
    • By Fernando Mercês
      Versão 0.1 do nosso livro "Fundamentos para Engenharia Reversa", também disponível online.
    • By Felipe.Silva
      Livro em Português sobre Assembly em constante desenvolvimento. É de autoria do @Felipe.Silva, membro da comunidade aqui! 🤗
    • By Bruna Chieco
      O Siloscape é o primeiro malware que tem como alvo os contêineres do Windows – tecnologia para empacotamento e execução de aplicativos. Segundo o ThreatPost, o malware implanta backdoors e nós de invasão para obter credenciais de usuários.
      A campanha em andamento perfura os clusters do Kubernetes – sistema de orquestração de contêineres open-source – para a implantação de backdoors, permitindo que os invasores roubem dados e credenciais do usuário ou sequestrem bancos de dados inteiros hospedados em um cluster.
      Segundo a reportagem, o malware foi descoberto pelo pesquisador de segurança da Unidade 42, Daniel Prizmant, que o apelidou de Siloscape, ou "Fuga do Silo". O malware explora vulnerabilidades conhecidas em servidores da web e bancos de dados para comprometer os nós do Kubernetes e os clusters de backdoor. 
      Prizmant fez um trabalho de engenharia reversa para conseguir se conectar ao servidor de comando e controle (C2) do Siloscape, onde descobriu que estava hospedando um total de 313 usuários. Isso implica que o Siloscape é uma pequena parte de uma campanha mais ampla, observou ele. Prizmant destaca que o Siloscape é um malware fortemente ofuscado. 
      Os pesquisadores da Unidade 42 identificaram 23 vítimas do Siloscape e disseram que as evidências indicam que a campanha foi lançada há mais de um ano, podendo ter iniciado em janeiro de 2020. 
      A recomendação é que os usuários sigam o conselho da Microsoft para não usar contêineres do Windows como um recurso de segurança. Em vez disso, a Microsoft recomenda o uso estritamente de contêineres Hyper-V para qualquer coisa que dependa da conteinerização como limite de segurança. 
    • By Leandro Fróes
      Depois de muita espera a NSA anunciou oficialmente a inclusão de um debugger no Guidra na sua versão 10.0. Depois de muita discussão sobre esta possibilidade o time de desenvolvimento do framework lançou uma release beta da versão 10.0 ontem!
      Neste momento o debugger suporta analisar aplicações em userland e consegue debuggar tanto binários Windows quanto Linux (utilizando o gdb neste caso). Para quem quer começar logo de cara o Guidra disponibiliza um tutorial de início rápido em Help -> Guidra Functionality -> Debugger -> Getting Started:

      Existem várias formas de iniciar o debugger, desde clicando com o Botão direito -> Open With -> Debugger até direto da sua Project Window do Guidra clicando no ícone de "bug" debaixo de "Tool Chest", como mostrado abaixo:

      Uma vez que a ferramenta é inicializada você deve importar o arquivo a ser depurado para a ferramenta. Uma das formas de fazer isto é simplesmente o arrastando da Project Window. Uma fez carregado podemos ver a cara do mais novo debugger do Guidra:

      Algumas das funcionalidades são: debugging remoto utilizando GDB e windbg, rodar o debugger direto no programa do qual você está analizando estaticamente e tracing de memória.
      Além disso ele também conta com as funcionalidades básicas de um debugger como utilização de breakpoints, listagem de regiões de memória mapeadas, estados dos registradores e uma interface de linha de comando própria.
      Todas as funcionalidades listadas aqui possuem sua própria View, isto é, sua própria janela dentro da ferramenta:


      Vale lembrar que esta release está em sua versão beta e tem como objetivo principal coletar o feedback da comunidade. Caso queira dar uma testada e/ou dar um feedback pra galera do Guidra basta baixar a release clicando no botão abaixo 😉.

×
×
  • Create New...