Fernando Mercês

Batizado com nome herdado da estrela binária VV Cephei, o Linux.Cephei é provavelmente o primeiro file infector para executáveis ELF (utilizados nos sistemas baseados em Linux, entre outros) escrito na linguagem Nim. Isso mesmo, o autor é um tanto excêntrico e disse em seu blog que o Linux.Cephei é inofensivo (por enquanto) e fez somente para participar de um concurso de programação. O vírus é do tipo que chamamos de prepender, ou seja, ele adiciona algo "antes" da execução de um programa saudável, no caso, de um binário ELF. A técnica para isso é a alteração de seu entrypoint. Nos testes que fizemos aqui, o Linux.Cephei só funcionou com binários compilados estaticamente: $ uname -a Linux malinux 4.9.0-4-amd64 #1 SMP Debian 4.9.51-1 (2017-09-28) x86_64 GNU/Linux $ cat /etc/debian_version 9.2 $ cat h.c #include <stdio.h> int main(void) { printf("ola mundo do bem!\n"); return 0; } $ gcc -static -o hello h.c $ ./hello ola mundo do bem! $ chmod +x linux.cephei $ ./linux.cephei $ ./hello Did you know that VV Cephei, also known as HD 208816, is an eclipsing binary star system located in the constellation Cepheus, approximately 5,000 light years from Earth? It is both a B[e] star and shell star. Awesome! https://en.wikipedia.org/wiki/VV_Cephei The more you know... :) ola mundo do bem! $ gcc -o hello h.c $ ./linux.cephei $ ./hello ola mundo do bem! Perceba que ele injetou seu código com sucesso no binário hello, mas somente quando foi compilado estaticamente. Além da linguagem exótica, ultimamente não se vê muitos file infectors já que a moda de infectar executáveis passou. De qualquer forma, é bom ficar de olho. Com códigos como o do Linux.Ceiphei, vírus podem permanecer ocultos num sistema por muito tempo. E pouca gente usa antivírus no Linux, mesmo tendo uma alternativa livre como o ClamAV.

O que é Engenharia Reversa? Engenharia reversa de software é a técnica para entender como um trecho de código funciona sem possuir seu código-fonte. É aplicável em diversas áreas da tecnologia como: Análise de malware Reimplementação de software e protocolos Correção de bugs Análise de vulnerabilidades Adição/Alteração de recursos no software Proteções anti-pirataria Alguns termos e abreviações para a engenharia reversa incluem: RCE (Reverse Code Engineering), RE, e reversing. Como funciona? Quando um programa tradicional é construído, o resultado final é um arquivo executável que possui uma série de instruções em código de máquina para que o processador de determinada arquitetura possa executar. Com ajuda de software específicos, profissionais com conhecimentos dessa linguagem (em nosso caso, Assembly) podem entender como o programa funciona e, assim, estudá-lo ou até fazer alterações no mesmo. O treinamento O CERO (Curso de Engenharia Reversa Online) é um treinamento básico de engenharia reversa gratuito publicado no nosso canal no YouTube Papo Binário, graças ao suporte dos nossos apoiadores. O instrutor @Fernando Mercês é Pesquisador de Ameaças na Trend Micro, onde atua como investigador de ciber crime, utilizando engenharia reversa e técnicas de inteligência de ameaças no time de Pesquisa de Ameaças Futuras (FTR). Criador de várias ferramentas livres na área, com frequência apresenta suas pesquisas nos principais eventos de segurança no Brasil e no exterior. É também professor e fundador da Mente Binária, uma instituição de ensino e pesquisa sem fins lucrativos comprometida com o ensino de computação no Brasil. Aulas publicadas Aula 0 - Como funciona a Engenharia Reversa Aula 1 - Sistemas de Numeração Aula 2 - Arquivos Aula 3 - Arquivos binários Aula 4 - Strings de texto Aula 5 - Executável PE - Apresentação Aula 6 - Executável PE - Seções e endereçamento Aula 7 - Executável PE - Imports Table Aula 8 - Executável ELF - Apresentação Aula 9 - Executável ELF - Símbolos, PLT e GOT Aula 10 - Win32 API Aula 11 - Linux syscalls Aula 12 - Assembly - Instruções e registradores Aula 13 - Assembly - Repetições e saltos Aula 14 - Assembly - Convenções de chamada de função Aula 15 - Funções e pilha Aula 16 - Breakpoints de software Aula 17 - Quebrando o crackme do Cruehead (Parte 1) Aula 18 - Quebrando o crackme do Cruehead (Parte 2) Aula 19 - Compressão de executáveis Aula 20 - Descompressão e reconstrução da IAT Aula 21 - Breakpoints de memória Aula 22 - Rastreando instruções (tracing) Aula 23 - Strings ofuscadas Aula 24 - Anti-debug Pré-requisitos Máquina virtual com Ubuntu Máquina virtual com Windows 7 Lógica de programação. Desejável ter assistido o treinamento gratuito Programação Moderna em C.

O que é C? C é uma linguagem de programação criada na década de 60 e utilizada largamente até os dias atuais. É comum se ouvir que “metade do Universo é escrito em C” e de fato é impressionante o número de aplicações de base escritas nesta linguagem. Exemplos incluem: Linux, Apache httpd, PHP, Java, Perl, Ruby, Python e a API do Windows. Por que estudar C? Acreditamos que o estudo da linguagem C é muito benéfico para o profissional que lida com computadores, independente da área. Estudar C nos obriga a focar nas bases da computação, entender como os dados são manipulados em memória pelo sistema operacional e pelo processador, suas limitações e condições para funcionamento. Algumas vantagens de se estudar C são: Pouca coisa "vem pronta" em C, nos forçando a implementar e entender as limitações da computação atual. O programador tem controle quase total do contexto do programa. É uma linguagem comercial, principalmente na era dos embarcados. Mas C não é velho? A linguagem foi criada há muito tempo, mas continua sendo atualizada e utilizada. Basta olhar o índice TIOBE, que mede as linguagens mais em alta no mundo, para comprovar o que dissemos. A última atualização na especificação padrão foi em 2011 mas os compiladores adicionam extensões periodicamente. O gcc (GNU Compiler Collection) e o Visual Studio, da Microsoft, são bem famosos, mas há também o clang que ganhou bastante espaço recentemente. O treinamento O treinamento Programação Moderna em C é gratuito aborda aspectos modernos da linguagem, bem como do ecossistema para desenvolvimento de aplicações em C, como o SO, editores de texto, IDE’s, etc. O curso está no YouTube, no nosso canal Papo Binário. São 20 aulas em 23 vídeos. O instrutor @Fernando Mercês é Pesquisador de Ameaças na Trend Micro, onde atua como investigador de ciber crime, utilizando engenharia reversa e técnicas de inteligência de ameaças no time de Pesquisa de Ameaças Futuras (FTR). Criador de várias ferramentas livres na área, com frequência apresenta suas pesquisas nos principais eventos de segurança no Brasil e no exterior. É também professor e fundador da Mente Binária, uma instituição de ensino e pesquisa sem fins lucrativos comprometida com o ensino de computação no Brasil. Aulas publicadas Aula 0: Preparando o ambiente Aula 1: Funções main() e printf() Aula 2: Variáveis booleanas e do tipo char Aula 3: Variáveis do tipo int Aula 4: Variáveis do tipo float Aula 5: Arrays Aula 6: Operadores aritiméticos Aula 7: Operadores lógicos Aula 8: Operadores bit-a-bit Aula 9: Condicional if Aula 10: Repetições (Parte 1/2) Aula 10: Repetições (Parte 2/2) Aula 11: Ponteiros (Parte 1/2) Aula 11: Ponteiros (Parte 2/2) Aula 12: Indexação de arrays e ponteiros Aula 13: Alocação dinâmica de memória Aula 14 - Estruturas e Uniões Aula 15 - Funções Aula 16 - Macros Aula 17 - Escopo e classes de armazenamento Aula 18 - Projeto readpe (Parte 1/3) Aula 19 - Projeto readpe (Parte 2/3) Aula 20 - Projeto readpe (Parte 3/3) Pré-requisitos Máquina física ou virtual com Linux. Básico do shell do Linux. Lógica de programação é desejável.

Você gosta de software de código aberto? Gosta quando encontra um programa bem feito, que atende a sua necessidade, sem custo, é atualizado, os desenvolvedores colocam novos recursos, você pode até opinar, sugerir mudanças e várias são aceitas? Saiba que por trás destes milhares de programas livres há um mundo de pessoas que dedicam seu tempo (muitas vezes seu tempo livre) para entregar software de qualidade pra você sem nem te conhecer. Isso é muito louvável. Agora mesmo estou usando o WordPress para escrever este artigo, um software de código aberto. Não paguei nada por ele e ainda modifico da maneira que eu quiser, respeitando sua licença. Não é fantástico isso? Para este artigo motivei-me dos vários programas de código aberto que já vi nascerem e morrerem por falta de apoio, então resolvi escrever um manual de como ajudar a manter os programas que você gosta no ar. Preparado? O primeiro passo é entender o que é de código aberto (ou open source). Eu poderia tentar explicar com minhas palavras, mas há um vídeo que literalmente desenhou e explicou com LEGO. Incrível, não? E com legendas em Português do Brasil. Por favor assista, mesmo que você pense que já saiba o que é: Se você usa algum software de código aberto (e eu tenho certeza que sim), você pode ajudar com: Tradução - Nem todo mundo fala inglês no mundo. É importante que um software socialmente viável seja acessível e você pode contribuir com isso ajudando a traduzir as novas versões para sua língua nativa. Divulgação - Publicar no seu site, seu Twitter, Facebook ou qualquer outra rede social sobre sua experiência com o software, estimulando outras pessoas a o utilizarem. Reconhecimento - Enviar um e-mail de agradecimento aos desenvolvedores. - Publicar na sua rede social, ou na dos desenvolvedores (se houver) um depoimento sobre sua experiência com o software. - Se o software está no Github e você tem uma conta de usuário lá, é só ir na página dele e começar a segui-lo (follow) e dar uma estrelinha (star) também. - Se o software está no SourceForge você pode dar uma estrelinha (star), avaliar o software (rating) e também dar seu comentário (user reviews). Preferência - Mesmo que haja um software proprietário equivalente, estimular o uso de software de código aberto é muito importante. Ele é socialmente mais justo e depois de ver o vídeo do item 1 você já deve saber o motivo. Documentação - Se você já domina algum recurso do software, é legal escrever algo no seu blog ou gravar um vídeo no YouTube ensinando outras pessoas a fazê-lo. Isso faz com que mais e mais usuários sejam beneficiados e aumenta as chances de adesão do software em questão. - Ajudar a escrever a documentação oficial do software, coisa que te faz aprender muito e toma muito tempo dos desenvolvedores. Tempo este que eles poderiam dedicar a corrigir problemas e adicionar novos recursos. Só depende de você. Suporte - Se cadastrar nos fórums e listas de discussão sobre o software para ajudar outros usuários te faz estudar muito, ajudar muito e contribuir muito com o ecossistema que mantém o software vivo! Código - Claro que se você conhecer a linguagem de programação utilizada no software você pode – e deve – contribuir via código. Só tome cuidado com o egocentrismo aqui. Não é porque você fez um patch que ele tem que ser aceito. O software de código aberto é democrático e não serve pra você tentar provar pra ninguém que é bom. Basta querer ajudar e atender ao pedido de todos, não do seu ego. - Se você é programador e costuma desenvolver software freeware por exemplo, considera transformar em código aberto. Ele vai crescer muito mais e ter muito mais adeptos. Você pode se espantar com o tamanho que o projeto pode assumir quando se tem a colaboração da comunidade open source. Reportar problemas - Se você acreditar que encontrou um problema no software (bug), avise aos desenvolvedores. Normalmente isso é feito por um sistema de bug tracking ou issue tracking. Com certeza no site do desenvolvedor você terá mais informações sobre como fazê-lo. Pode ser que te peçam logs e outras informações para que eles possam reproduzir o erro e corrigir, mas vale a pena continuar e ir até o fim. Você vai ajudar muita gente no final. Doações - Muitas equipes que desenvolvem software de código aberto precisam de dinheiro para comprarem hardware, aluguel de infraestrutura ou mesmo para promoverem eventos entre os desenvolvedores para alinharem o futuro do software. Doando você pode ajudar nisso. Se você tiver condições, apoie. Se informar - Empresas como Microsoft, Apple, Red Hat, dentre outras são grandes contribuidoras com projetos de código aberto, inclusive com o Linux. - Software livre e software de código aberto são diferentes. O primeiro movimento é criado pelo Richard Stallman, que explica as diferenças aqui. Essa lista não é definitiva e naturalmente deve haver várias outras formas de ajudar, mas escolhi escrever sobre as mais simples, que estão somente há alguns cliques de distância de você. Nos anos que venho dedicando a apoiar os projetos de código aberto, inclusive criando alguns, fiquei muito surpreso com as colaborações que meus projetos receberam e também tive a oportunidade de contribuir com muitos outros. Isso significa ajuda efetiva para pessoas e projetos. De verdade. As empresas também gostam disso (afinal são pessoas que trabalham nelas né!?) e várias propostas de emprego já surgiram através do Github. Não fica de fora dessa. O mundo open source precisa de você. E as pessoas também.

É raro termos um artigo não técnico aqui no Mente Binária, mas este tema merece, creio. A proposta aqui é criarmos uma lista de filmes, séries e documentários que envolvam especificamente o tema informática (não vale tecnologia em geral, pois do contrário a lista ficaria gigante!) organizados por ano de lançamento. Preparado? Então pega a pipoca! 2019 Unidade 42 2017 Ghost in the Shell (A Vigilante do Amanhã: Ghost in the Shell) 2016 Hackers Hacker (Anonymous) Cyberwar ZeroDays 2015 Terminal F/Chasing Edward Snowden (Snowdens store flugt) Mr. Robot Hacker's Game Deep Web Blackhat (Hacker) 2014 Who Am I - Invasores: Nenhum Sistema Está Salvo The Internet's Own Boy: The Story of Aaron Swartz (O Menino da Internet: A História de Aaron Swartz) The Hackers Wars Citizenfour Algorithm Sillicon Valley Halt and Catch Fire 2013 We Steal Secrets: The Story of WikiLeaks Terms and Conditions May Apply TPB AFK: The Pirate Bay Away from Keyboard Her (Ela) Downloaded DEFCON 2012 We Are Legion: The Story of the Hacktivists 2011 Black Mirror 2010 Tron: Legacy (Tron: O Legado) 2008 Hackers Are People Too 2007 Live Free or Die Hard (Duro de Matar 4.0) 2006 Steal This Film 2005 Hard Candy (Menina Má.Com) 2001 The Code Revolution OS Antitrust (Ameaça Virtual) Artificial Intelligence: AI (A.I.: Inteligência Artificial) 2000 Takedown (Caçada Virtual) 1999 The Matrix (Matrix) Pirates of Silicon Valley (Piratas da Informática: Piratas do Vale do Silício) 1996 Lawnmower Man 2: Beyond Cyberspace (O Passageiro do Futuro 2) 1995 Ghost in the Shell (O Fantasma do Futuro) The Net (A Rede) Johnny Mnemonic (Johnny Mnemonic: O Cyborg do Futuro) Hackers - Piratas de Computador 1992 The Lawnmower Man (O Passageiro do Futuro) 1984 Triumph of The Nerds Hackers: Wizards of the Electronic Age 1983 Wargames 1982 Tron (Tron: Uma Odisséia Eletrônica) Esqueci de algum? Sugere aí nos comentários que adiciono! No canal Papo Binário já falei sobre algum destes títulos também. ?

Desde 2013 que estamos trabalhando duro numa nova versão do pev, nosso toolkit para análise de binários PE (Portable Executable), o formato utilizado pelos executáveis (EXE, DLL, OCX, etc) do Windows. O pev é um projeto em que me sinto muito feliz de fazer parte e o principal motivo é que existe algo de muito forte e especial nele: colaboração. Quase 30 pessoas contribuíram com o projeto de alguma forma (código, testes, empacotamento, etc) e hoje ele está presente nos repositórios das principais distribuições Linux, inclusive as focadas em segurança de alguma forma. Outro ponto importante é que ele começou como um projeto de faculdade lá em 2010, junto com outros alunos. Como a faculdade nem laboratório de pesquisa tinha, fizemos o nosso próprio grupo, batizado de Coding 40°, em homenagem ao calor da nossa cidade. O projeto atraiu muitos colaboradores, incluindo um que já commitou mais que eu no repositório e redefiniu, de forma muito profissional, toda a infraestrutura por trás do pev e da libpe. Foi o Jardel Weyrich. Sério, dá pra detectar que um projeto teve sucesso quando aparece alguém que já contribuiu com mais código para ele do que você! Por último, mas não menos importante: o pev é livre. E na boa, até agradeço as centenas de programadores que fizeram analisadores de PE proprietários, porque me motivaram a iniciar o pev. Era preciso um analisador de binários PE de código aberto, que permitisse estudantes e curiosos entender como um PE é parseado, que campos são importantes, por que a análise estática é tão poderosa, etc. Hoje, mesmo com todos os bugs que ainda hão de surgir (fora os que já surgiram e ainda não conseguimos corrigir!). Quero agradecer, de forma permanente, a todos que se envolvem ou se envolveram de alguma forma com o pev: usando, avisando-nos sobre bugs, contribuindo com código, ideias, testes, tudo importa! Obrigado, de coração. Emoções à parte, vamos partir para a análise de binários e falar das novidades do pev 0.80, lançado hoje! Acontece que um binário PE pode esconder muitas informações importantes antes mesmo de ser executado. Por exemplo, com a ferramenta readpe, do pev, você vai descobrir que um executável PE é dividido em cabeçalhos e seções e eles armazenam várias informações interessantes, por exemplo: $ readpe arquivo.exe DOS Header Magic number: 0x5a4d (MZ) Bytes in last page: 144 Pages in file: 3 Relocations: 0 Size of header in paragraphs: 4 Minimum extra paragraphs: 0 Maximum extra paragraphs: 65535 Initial (relative) SS value: 0 Initial SP value: 0xb8 Initial IP value: 0 Initial (relative) CS value: 0 Address of relocation table: 0x40 Overlay number: 0 OEM identifier: 0 OEM information: 0 PE header offset: 0x80 COFF/File header Machine: 0x14c IMAGE_FILE_MACHINE_I386 Number of sections: 3 Date/time stamp: 1425562907 (Thu, 05 Mar 2015 13:41:47 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 Optional/Image header Magic number: 0x10b (PE32) Linker major version: 11 Linker minor version: 0 Size of .text section: 0x2a800 Size of .data section: 0x3400 Size of .bss section: 0 Entrypoint: 0x2c78e Address of .text section: 0x2000 Address of .data section: 0x2e000 ImageBase: 0x400000 Alignment of sections: 0x2000 Alignment factor: 0x200 Major version of required OS: 4 Minor version of required OS: 0 Major version of image: 0 Minor version of image: 0 Major version of subsystem: 4 Minor version of subsystem: 0 Size of image: 0x34000 Size of headers: 0x200 Checksum: 0 Subsystem required: 0x2 (IMAGE_SUBSYSTEM_WINDOWS_GUI) DLL characteristics: 0x8540 DLL characteristics names IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE IMAGE_DLLCHARACTERISTICS_NX_COMPAT IMAGE_DLLCHARACTERISTICS_NO_SEH IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE Size of stack to reserve: 0x100000 Size of stack to commit: 0x1000 Size of heap space to reserve: 0x100000 Size of heap space to commit: 0x1000 Data directories Directory IMAGE_DIRECTORY_ENTRY_IMPORT: 0x2c738 (83 bytes) Directory IMAGE_DIRECTORY_ENTRY_RESOURCE: 0x2e000 (12728 bytes) Directory IMAGE_DIRECTORY_ENTRY_BASERELOC: 0x32000 (12 bytes) Directory IMAGE_DIRECTORY_ENTRY_IAT: 0x2000 (8 bytes) Directory IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR: 0x2008 (72 bytes) Imported functions Library Name: mscoree.dll Functions Function Name: _CorExeMain export directory not found Sections Section Name: .text Virtual Address: 0x2000 Physical Address: 0x2a794 Size: 0x2a800 (174080 bytes) Pointer To Data: 0x200 Relocations: 0 Characteristics: 0x60000020 Characteristic Names IMAGE_SCN_CNT_CODE IMAGE_SCN_MEM_EXECUTE IMAGE_SCN_MEM_READ Section Name: .rsrc Virtual Address: 0x2e000 Physical Address: 0x31b8 Size: 0x3200 (12800 bytes) Pointer To Data: 0x2aa00 Relocations: 0 Characteristics: 0x40000040 Characteristic Names IMAGE_SCN_CNT_INITIALIZED_DATA IMAGE_SCN_MEM_READ Section Name: .reloc Virtual Address: 0x32000 Physical Address: 0xc Size: 0x200 (512 bytes) Pointer To Data: 0x2dc00 Relocations: 0 Characteristics: 0x42000040 Characteristic Names IMAGE_SCN_CNT_INITIALIZED_DATA IMAGE_SCN_MEM_DISCARDABLE IMAGE_SCN_MEM_READ Só olhando para este cabeçalho, já dá pra dizer muita coisa sobre esse binário. Por exemplo, é possível inferir que ele foi compilado em 5 de março de 2015, é um executável de janelas (GUI – Graphical User Interface) e na Import Table dele tem apenas uma entrada, uma função chamada _CorExeMain importada da biblioteca mscoree.dll. Isso já dá a dica que esse é binário foi compilado em .NET. Como eu sei disso? É que eu já vi vários binários em .NET e todos eles importam somente essa função. Não se preocupe, com o tempo você também pega os macetes! Claro que, para estudar os binários de forma eficiente é legal ler também outros tutoriais sobre o assunto. O que mais gosto em Português é O formato PE, da Vovó Vicky, isso mesmo, uma simpática senhora, médica, do Sul do país que adora arquivos PE. ❤️ Voltando ao nosso binário, vamos dar uma olhada nas strings presentes nele com o pestr: $ pestr -so arquivo.exe 0x2d81e .rsrc FileDescription 0x2d840 .rsrc Gynx 0x2d852 .rsrc FileVersion 0x2d86c .rsrc 1.0.0.0 0x2d882 .rsrc InternalName 0x2d89c .rsrc Gynx.exe 0x2d8b6 .rsrc LegalCopyright 0x2d8d4 .rsrc Copyright 0x2d8ea .rsrc 2015 0x2d8fe .rsrc OriginalFilename A lista de strings completa é bem maior, mas eu cortei só para mostrar algumas. Primeira pergunta que pode surgir aqui é: por que fizemos um programa pestr se já existe o programa strings? Bem, você pode notar pela saída que dizemos muito mais que a string (texto) em si. Sabemos em que seção ela está e o offset (posição) no arquivo. Além disso, o pestr imprime strings ASCII e Unicode. No meio das strings tem outra informação de data, que reforça o ano da data de compilação. Tem também o nome original do arquivo (quando o programador compilou). Se você pesquisar no Google pelo nome do arquivo, já vai encontrar muita coisa! Continuando nossa análise, vamos ver com o pescan se tem algo estranho neste arquivo: $ pescan -v ~/dotnet file entropy: 5.252392 (normal) fpu anti-disassembly: no imagebase: normal - 0x400000 entrypoint: normal - va: 0x2c78e - raw: 0x2a98e DOS stub: normal TLS directory: not found timestamp: normal - Thu, 05 Mar 2015 13:41:47 UTC section count: 3 sections section .text: normal section .rsrc: normal section .reloc: small length A baixa entropia sugere que o binário não está comprimido (packed) e tudo parece estar normal. Isso significa que o binário não está protegido, não que seu código não seja malicioso. Agora, já entrando nos novos recursos, que tal saber os hashes deste arquivo? Buscando por eles no Google também é possível encontrar algumas informações. Ao invés de calcular um por um, utilizando vários programas, o pev conta com o pehash, que faz tudo pra você: $ pehash -a arquivo.exe file filepath: /home/user/arquivo.exe md5: 1f4c40ff46297bdc5a595cd574e0db64 sha1: 2bc6fa6558988d628dd4b95d0741405685c1c232 sha256: b823a04f49463e410c9f823baade182eb283ba073b40c6d8cc443a570a9a1df6 ssdeep: 3072:yLYmWbfXGKJy7DFR9KwHS+MASjB5jL0S9Q0VwuUcu:AYmWbfX3y7DFR9KwHS+MAS/js0VhU imphash: f34d5f2d4577ed6d9ceec516c1f5a744 headers header header_name: IMAGE_DOS_HEADER md5: 919f1c12cf0d1cd93d7f1077f13ac374 sha1: 3d43712e5606b4640b85f5f0e25e9db8ed552074 sha256: c46a3fc444808f3b86a7e757e5202d16f8ea9bf1c6aff2cabc593e7d0f2c9ad2 ssdeep: 3:WlWUqt/vllnln:idqP header header_name: IMAGE_COFF_HEADER md5: 15174f39bbe557d104f169053af5c7a2 sha1: 21f9311fa5e1a7c8724c657db39ef2fbb1b896ce sha256: 7430166bd1b2d5c400f2f5fb60c90393b50388b97e877aa7cf0c3057a413a85f ssdeep: 3:HHJl/fkn:HHJlkn header header_name: IMAGE_OPTIONAL_HEADER md5: 3b079fa2a88b6901db907bc47dee2d67 sha1: 21c1c517743170c94d1ade608ff7d2746fd7e3ea sha256: 0fec7657e9361e8262af5872bf3784a7647b6978f3d0e35a419d2f410c8654a0 ssdeep: 3:6FZ//llAlFlllXNB//llrllel/dglPt1l9tllH:pfGwlN sections section section_name: .text md5: 973d11759194c14071aa6963de8f55c7 sha1: 1934e0085c8776e3243bf658e95b8943d4f91bc9 sha256: e68349bfcb04b20c11973ce27770570ebb22c8c7750133d073f15f7ec9eeda38 ssdeep: 3072:XLYmWbfXGKJy7DFR9KwHS+MASjB5jL0S9Q0VwuUc:bYmWbfX3y7DFR9KwHS+MAS/js0VhU section section_name: .rsrc md5: 9d498bee08b1cf075d8aca022f1e16e9 sha1: f938a8c23185b023bb5dd12082013c2a628bc0d3 sha256: eb7454309df90fea2d01c887b0040e8237353919efc06a7081a7abb15091283a ssdeep: 24:3A5t/ug9GXBEiViKZWIDDOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:weg90VWIDZ6Kp+l4BhDqFWSfbNtm section section_name: .reloc md5: 37ab911460a0b274ffa9f4e388ec933b sha1: 7c9eac3b843c9a7ab8ef08aac5c14e4c51b2c703 sha256: fb50df3b064d126999295b35f1a151f8fbe7e3593e306a9255a534999843f5b2 ssdeep: 3:LlQl:S Achou que teria os hashes do arquivo somente? Pois é, o pev surpreende mesmo! O pehash calcula MD5, SHA1, SHA-256 e ssdeep (uma técnica de fuzzy hash que vale a pena pesquisar sobre!) para cada cabeçalho e seção. Além disso, a partir das funções importadas do binário o pehash calcula o imphash, que já expliquei no artigo Entendendo o imphash. Tanto o imphash quanto o ssdeep podem ser utilizados, de maneiras diferentes, para saber se um arquivo é parecido com outro, se são variantes do mesmo código-fonte, mas neste caso o imphash não ajuda por ser um binário .NET (todos eles importam aquela mesma função única que comentei acima). Também é possível, com o peres (criação do Marcelo Fleury), extrair os recursos e checar, por exemplo, o manifesto em XML dos arquivo: $ peres -x arquivo.exe Save On: resources/icons/2.ico Save On: resources/icons/3.ico Save On: resources/icons/4.ico Save On: resources/icons/5.ico Save On: resources/icons/6.ico Save On: resources/icons/7.ico Save On: resources/icons/8.ico Save On: resources/groupicons/32512.ico Save On: resources/versions/1.rc Save On: resources/manifests/1.xml $ cat resources/manifests/1.xml <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/> <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2"> <security> <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3"> <requestedExecutionLevel level="asInvoker" uiAccess="false"/> </requestedPrivileges> </security> </trustInfo> </assembly> O ícone utilizado também é extraído (groupicons) mas ele é quebrado em várias imagens (icons) e precisam ser reconstruídos se você precisar do ícone original do arquivo. De qualquer forma, você pode calcular o hash deles e comparar com os dos ícones de outros arquivos, se for essa a intenção. Uma outra novidade é o programa cpload, para analisar arquivos .cpl (Control Panel Applets). Ele é presente somente na versão do pev para Windows, pois serve para analisar binários dinamicamente. Este formato é um pouco diferente do EXE convencional (na verdade um CPL é uma “DLL que executa com dois cliques”). Na época o formato desses arquivos era muito pouco conhecido e até escrevi um artigo para a Wikipédia em Português sobre. Com o cpload, é possível enviar para a função presente no arquivo .cpl todas as mensagens que ela deve reconhecer. Assim o analista pode ver qual delas dispara o código. No exemplo abaixo, a mensagem CPL_DBLCLK (clique duplo) foi enviada para um .cpl presente no Windows chamado joy.cpl. Veja que o programa executa e mostra uma janela: Adicionalmente, se você fizer isso no contexto de um debugger, passando os argumentos como na imagem abaixo: O cpload força um software breakpoint antes do carregamento do arquivo .cpl pela função LoadLibrary() e antes da entrada na CPLApplet(), que é a função principal de um arquivo .cpl, o que permite ao analista enxergar o trecho exato de código dele, sem precisar debugar processos do sistema como o rundll32.exe. E ainda sobre o pev, os plugins de formato de saída estão dando um show (ideia do Jan Seidl e portada para plugins pelo Jardel). Olha só como fica a saída se você pedir ao pedis, nosso disassembler, para disassemblar o entrypoint de um binário PE em JSON: $ pedis --format json --entrypoint PUTTY.EXE { "54eb0": "6a 60 push 0x60", "54eb2": "68 70 7b 47 00 push 0x477b70", "54eb7": "e8 08 21 00 00 call 0x456fc4", "54ebc": "bf 94 00 00 00 mov edi, 0x94", "54ec1": "8b c7 mov eax, edi", "54ec3": "e8 b8 fa ff ff call 0x454980", "54ec8": "89 65 e8 mov [ebp-0x18], esp", "54ecb": "8b f4 mov esi, esp", "54ecd": "89 3e mov [esi], edi", "54ecf": "56 push esi", "54ed0": "ff 15 e0 d2 45 00 call dword [0x45d2e0]", "54ed6": "8b 4e 10 mov ecx, [esi+0x10]", "54ed9": "89 0d 48 e1 47 00 mov [0x47e148], ecx", "54edf": "8b 46 04 mov eax, [esi+0x4]", "54ee2": "a3 54 e1 47 00 mov [0x47e154], eax", "54ee7": "8b 56 08 mov edx, [esi+0x8]", "54eea": "89 15 58 e1 47 00 mov [0x47e158], edx", "54ef0": "8b 76 0c mov esi, [esi+0xc]", "54ef3": "81 e6 ff 7f 00 00 and esi, 0x7fff", "54ef9": "89 35 4c e1 47 00 mov [0x47e14c], esi", "54eff": "83 f9 02 cmp ecx, 0x2", "54f02": "74 0c jz 0x454f10", "54f04": "81 ce 00 80 00 00 or esi, 0x8000", "54f0a": "89 35 4c e1 47 00 mov [0x47e14c], esi", "54f10": "c1 e0 08 shl eax, 0x8", "54f13": "03 c2 add eax, edx", "54f15": "a3 50 e1 47 00 mov [0x47e150], eax", "54f1a": "33 f6 xor esi, esi", "54f1c": "56 push esi", "54f1d": "8b 3d d8 d2 45 00 mov edi, [0x45d2d8]", "54f23": "ff d7 call edi0x454f25", "54f25": "66 81 38 4d 5a cmp word [eax], 0x5a4d", "54f2a": "75 1f jnz 0x454f4b", "54f2c": "8b 48 3c mov ecx, [eax+0x3c]", "54f2f": "03 c8 add ecx, eax", "54f31": "81 39 50 45 00 00 cmp dword [ecx], 0x4550", "54f37": "75 12 jnz 0x454f4b", "54f39": "0f b7 41 18 movzx eax, word [ecx+0x18]", "54f3d": "3d 0b 01 00 00 cmp eax, 0x10b", "54f42": "74 1f jz 0x454f63", "54f44": "3d 0b 02 00 00 cmp eax, 0x20b", "54f49": "74 05 jz 0x454f50", "54f4b": "89 75 e4 mov [ebp-0x1c], esi", "54f4e": "eb 27 jmp 0x454f77", "54f50": "83 b9 84 00 00 00 0e cmp dword [ecx+0x84], 0xe", "54f57": "76 f2 jbe 0x45504b", "54f59": "33 c0 xor eax, eax", "54f5b": "39 b1 f8 00 00 00 cmp [ecx+0xf8], esi", "54f61": "eb 0e jmp 0x454f71", "54f63": "83 79 74 0e cmp dword [ecx+0x74], 0xe", "54f67": "76 e2 jbe 0x45504b", "54f69": "33 c0 xor eax, eax", "54f6b": "39 b1 e8 00 00 00 cmp [ecx+0xe8], esi", "54f71": "0f 95 c0 setnz al", "54f74": "89 45 e4 mov [ebp-0x1c], eax", "54f77": "56 push esi", "54f78": "e8 b4 28 00 00 call 0x457831", "54f7d": "59 pop ecx", "54f7e": "85 c0 test eax, eax", "54f80": "75 21 jnz 0x454fa3", "54f82": "83 3d 94 e1 47 00 01 cmp dword [0x47e194], 0x1", "54f89": "75 05 jnz 0x454f90", "54f8b": "e8 56 44 00 00 call 0x4593e6", "54f90": "6a 1c push 0x1c", "54f92": "e8 d8 42 00 00 call 0x45926f", "54f97": "68 ff 00 00 00 push 0xff", "54f9c": "e8 be fb ff ff call 0x454b5f", "54fa1": "59 pop ecx", "54fa2": "59 pop ecx", "54fa3": "e8 65 47 00 00 call 0x45970d", "54fa8": "89 75 fc mov [ebp-0x4], esi", "54fab": "e8 e9 25 00 00 call 0x457599", "54fb0": "85 c0 test eax, eax", "54fb2": "7d 08 jge 0x454fbc", "54fb4": "6a 1b push 0x1b", "54fb6": "e8 d0 fe ff ff call 0x454e8b", "54fbb": "59 pop ecx", "54fbc": "ff 15 a8 d1 45 00 call dword [0x45d1a8]", "54fc2": "a3 00 e9 47 00 mov [0x47e900], eax", "54fc7": "e8 af 4d 00 00 call 0x459d7b", "54fcc": "a3 8c e1 47 00 mov [0x47e18c], eax", "54fd1": "e8 03 4d 00 00 call 0x459cd9", "54fd6": "85 c0 test eax, eax", "54fd8": "7d 08 jge 0x454fe2", "54fda": "6a 08 push 0x8", "54fdc": "e8 aa fe ff ff call 0x454e8b", "54fe1": "59 pop ecx", "54fe2": "e8 bf 4a 00 00 call 0x459aa6", "54fe7": "85 c0 test eax, eax", "54fe9": "7d 08 jge 0x454ff3", "54feb": "6a 09 push 0x9", "54fed": "e8 99 fe ff ff call 0x454e8b", "54ff2": "59 pop ecx", "54ff3": "6a 01 push 0x1", "54ff5": "e8 95 fb ff ff call 0x454b8f", "54ffa": "59 pop ecx", "54ffb": "89 45 d8 mov [ebp-0x28], eax", "54ffe": "3b c6 cmp eax, esi", "55000": "74 07 jz 0x455009", "55002": "50 push eax", "55003": "e8 83 fe ff ff call 0x454e8b", "55008": "59 pop ecx", "55009": "89 75 bc mov [ebp-0x44], esi", "5500c": "8d 45 90 lea eax, [ebp-0x70]", "5500f": "50 push eax", "55010": "ff 15 ac d1 45 00 call dword [0x45d1ac]", "55016": "e8 2e 4a 00 00 call 0x459a49", "5501b": "89 45 e0 mov [ebp-0x20], eax", "5501e": "f6 45 bc 01 test byte [ebp-0x44], 0x1", "55022": "74 06 jz 0x45502a", "55024": "0f b7 45 c0 movzx eax, word [ebp-0x40]", "55028": "eb 03 jmp 0x45502d", "5502a": "6a 0a push 0xa", "5502c": "58 pop eax", "5502d": "50 push eax", "5502e": "ff 75 e0 push dword [ebp-0x20]", "55031": "56 push esi", "55032": "56 push esi", "55033": "ff d7 call edi0x455035", "55035": "50 push eax", "55036": "e8 93 3b ff ff call 0x448bce", "5503b": "8b f8 mov edi, eax", "5503d": "89 7d d4 mov [ebp-0x2c], edi", "55040": "39 75 e4 cmp [ebp-0x1c], esi", "55043": "75 06 jnz 0x45504b", "55045": "57 push edi", "55046": "e8 6f fc ff ff call 0x454cba", "5504b": "e8 8c fc ff ff call 0x454cdc", "55050": "eb 2b jmp 0x45507d", "55052": "8b 45 ec mov eax, [ebp-0x14]", "55055": "8b 08 mov ecx, [eax]", "55057": "8b 09 mov ecx, [ecx]", "55059": "89 4d dc mov [ebp-0x24], ecx", "5505c": "50 push eax", "5505d": "51 push ecx", "5505e": "e8 75 48 00 00 call 0x4598d8", "55063": "59 pop ecx", "55064": "59 pop ecx", "55065": "c3 ret" Os formatos de saída suportados por todos os programas do toolkit incluem JSON, XML, CSV e o padrão, texto. Assim o pev se faz útil para quem quer automatizar o processo de análise estática de binários PE, para salvar em um banco de dados para consulta posterior, por exemplo. A documentação para a versão 0.80 está pronta e recomendo fortemente que você a leia se quiser aproveitar o máximo do toolkit. O changelog completo também está disponível. Despeço-me com a certeza de que fizemos um bom trabalho e de que o software livre é viável, funciona e é, principalmente, algo prazeroso de se manter, que pode ajudar pessoas e empresas a atingirem seus objetivos, sem custo. Confere lá: https://github.com/merces/pev

No dia-a-dia da programação, análise de binários e outras áreas relacionadas à segurança da informação é comum profissionais precisarem de conversões rápidas de dados, normalmente números e strings. Muitas vezes recorremos a sites, scripts, programas gráficos, calculadores e outros, mas como nos sentimos mais confortáveis na linha de comando, foi lá que decidi fazer algo. Há alguns anos iniciei um projeto que chamei de bashacks, que é um conjunto de funções em bash para as mais variadas tarefas, mas percebi que muitas vezes não sei que tipo de informação estou tratando e gostaria de ver rapidamente diversas conversões para um certo tipo de dado (um número por exemplo), para ver qual deles faz mais sentido. Foi aí que pensei em criar o eXamine, cujo nome veio do comando homônimo do gdb (GNU Debugger). Trata-se de um software de linha de comando para o que chamo de conversão indiscriminada e irresponsável de dados. Para ficar ainda mais enxuto, e também roubando a ideia do gdb, eu o chamo de x. Então supondo que você na sua análise você tenha encontrado um número hexadecimal, por exemplo, 0x585ca92c e deseja ver as conversões possíveis para ele. É só mandar pro x: $ echo 0x585ca92c | x Hex string: 30783538356361393263 Byte array: \x30\x78\x35\x38\x35\x63\x61\x39\x32\x63 URL encoding: %30%78%35%38%35%63%61%39%32%63 ROT13: 0k585pn92p Signed int: 1482467628 Unsigned int: 1482467628 Float: 9.70477e+14 Hexadecimal: 0x585ca92c Octal: 013027124454 Binary: 0b1011000010111001010100100101100 IPv4: 88.92.169.44 Timestamp: Fri, 23 Dec 2016 04:33:48 UTC/GMT-0 O jeito correto de interpretar a saída do eXamine é: se a entrada for tratada como x, então é y, ou seja, no exemplo, se o número for tratado como string (texto), então os bytes em hexadecimal equivalente são 30 78 35 38 35 63 61 39 32 e 63. Já se for tratado como número, então a conversão para inteiro fica 1482467628. Ainda tratando como número, pode ser o endereço IPv4 88.92.169.44 ou a data/hora de hoje. Qual é o certo? A resposta é: depende de como você quer tratar. Vê o que faz mais sentido pra sua análise e vai na fé. Sabemos que bytes são bytes e como serão usados depende da interpretação dada. 0x41 pode ser utilizado num programa como um inteiro de 8 bits, ou como parte de um inteiro de 16, 32 ou 64-bits, ou mesmo como o caractere ‘A’ (depende de como o programa usa essa informação). O eXamine não te ajuda nisso, mas imprime como saída algumas conversões possíveis e deixa você decidir. Por exemplo, você pode passar uma string para ele: $ echo 'feliz natal' | x Hex string: 66656c697a206e6174616c Byte array: \x66\x65\x6c\x69\x7a\x20\x6e\x61\x74\x61\x6c URL encoding: %66%65%6C%69%7A%20%6E%61%74%61%6C ROT13: sryvm angny Signed int: 0 Unsigned int: 0 Float: 0 Hexadecimal: 00 Octal: 0 Binary: 0b ASCII char: NUL RGB: (0, 0, 0) IPv4: 0.0.0.0 Timestamp: Thu, 01 Jan 1970 00:00:00 UTC/GMT-0 As saídas numéricas neste caso ficam zeradas e cabe a você saber que isso faz sentido, afinal, não passei um número como entrada. É possível também utilizá-lo no modo interativo. Neste caso, primeiro comandei x, depois digitei o número 65: $ x 65 Hex string: 3635 Byte array: \x36\x35 URL encoding: %36%35 ROT13: 65 Signed int: 65 Unsigned int: 65 Float: 0 Hexadecimal: 0x41 Octal: 0101 Binary: 0b1000001 ASCII char: A RGB: (0, 0, 65) IPv4: 0.0.0.65 Timestamp: Thu, 01 Jan 1970 00:01:05 UTC/GMT-0 Ainda há muito o que fazer no eXamine. Há várias conversões possíveis com strings, inteiros de outros tamanhos, hashes, etc. Se você tiver alguma sugestão de conversão, basta abrir uma issue na página do projeto no Github e a discutimos lá. Se souber programar em C, ficarei feliz em receber seu pull request após a discussão.