Jump to content
  • Estude binários de Windows com o novo pev

       (0 reviews)

    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:

    cpload-dblclk.png.dfb36d4c9774706bb34bb51e508fa6fa.png

    Adicionalmente, se você fizer isso no contexto de um debugger, passando os argumentos como na imagem abaixo:

    cpload-olly-arguments.png.bca94ef0b9f9f98024681d5596aeaa2f.png

    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.

    cpload-olly-bp.png.7b9a1b51fa499534a2a27d1416bfde17.png

    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


    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.


  • Similar Content

    • By Bruna Chieco
      Pesquisadores da Sayfer fizeram engenharia reversa no WhatsApp Web e acabaram encontrando "sem querer" um recurso desabilitado por padrão, ou seja, que ainda não está liberado. A função pre-released descoberta permite que a velocidade de um áudio seja acelerada. 
      Os pesquisadores, na verdade, estavam fazendo uma pesquisa sobre outro projeto quando descobriram acidentalmente que o WhatsApp tem um sinalizador para o recurso oculto que permite aos usuários alterar a taxa de reprodução de mensagens de voz.
      Uma das ferramentas de pesquisa utilizadas pelos pesquisadores permitiu essa alteração, sendo cada mensagem de voz é essencialmente uma marca de áudio com um blob de uma fonte de áudio. Para alterar a velocidade, contudo, foi necessário fazer engenharia reversa no código-fonte minimizado do WhatsApp para a web.
      Eles descobriram que o WhatsApp tem três velocidades pré-determinadas para os áudios, porém, desabilitadas. Em publicação, os pesquisadores explicam o passo a passo do que fizeram para conseguir alterar a taxa de reprodução dos áudios.
      E se você quiser saber mais sobre engenharia reversa, o Mente Binária tem um curso com 24 aulas que pode ser acessado por meio do nossos canal no YouTube:
       
    • By Felipe.Silva
      Injeção de código é uma técnica que consiste em adicionar instruções extras em um executável. Essas instruções podem ser adicionadas em vários lugares do programa, inclusive executar antes do entry point original.
      O uso mais comum para injeção de código é para fins maliciosos, onde um shellcode poderia ser inserido no executável e dar acesso remoto para um atacante. Mas um exemplo de uso "justo" para essa técnica é para fins de patching no executável quando você quer que algo seja alterado em tempo de execução no binário.
      Se você já tentou injetar código em um executável manualmente deve saber que não é uma tarefa tão divertida. Pensando neste tipo de impasse, imaginei que seria interessante ter uma ferramenta para automatizar esse tipo de manipulação de um executável. Por esse motivo criei o pei, uma ferramenta para automatizar injeção de código e outros tipos de manipulações em executáveis PE de 32-bit e 64-bit.
      O pei foi programado pensando na automação e por isso é fácil usar a ferramenta a partir de um script. Com ela você pode obter e modificar valores no executável, e é claro, injetar código.
      Antes de qualquer coisa você pode instalar o pei em seu Linux rodando os comandos abaixo:
      git clone https://github.com/Silva97/pei cd pei make sudo make install Nota: Caso use Windows e não esteja usando WSL ou um MSYS2 da vida, você pode compilar o projeto instalando o make e o MinGW (recomendo usar o Chocolatey). No entanto, o “sudo make install” não vai funcionar no Windows, você vai ter que adicionar o executável ao PATH manualmente.
      Se você não estiver a fim de compilar o executável, fiz o favor de adicionar o binário da ferramenta compilado para Windows nos releases dela. Você pode baixá-lo no link https://github.com/Silva97/pei/releases/latest.
      O uso básico da ferramenta segue o seguinte formato:
      pei [opções] <operação> <executável> [argumento] Se você quiser ver mais detalhes de como usar a ferramenta você pode rodar “pei -h”.
      Operações
      As operações são o que determinam o que a ferramenta irá fazer com o executável, indo desde exibir informações sobre ele até modificar campos dos cabeçalhos.
      show
      A operação show serve para exibir informações sobre o executável e campos dos cabeçalhos. Se você não passar argumentos para a operação por padrão ela irá exibir informações básicas do executável:

      Você também pode especificar uma combinação de letras para escolher quais campos serão exibidos, dentre elas: c (COFF header), o (optional header), d (data directories) e s (section). Exemplo:
      $ pei show test.exe co Esse comando, por exemplo, exibe o COFF header e optional header do executável.
      get
      A operação get pega o valor de um campo individual de um dos cabeçalhos (coff, optional ou section) do executável.
      Seguindo uma notação com pontos, semelhante à acessar campos de estruturas em C, você pode especificar o cabeçalho e o nome do campo para ser obtido. Por exemplo, para obter o entry point do executável o comando ficaria:
      $ pei get executavel.exe optional.entry_point '%x' 14f0 Dica: Veja o nome dos campos dos cabeçalhos usando a operação show.
      O argumento após o nome do campo é uma string de formatação idêntica a da função printf() da libc, que aceita quaisquer flags de formatação disponíveis para a função.
      Para acessar os campos de uma seção é necessário especificar o número da seção também, como demonstrado no print abaixo:

      edit
      A operação edit serve para modificar o valor de campos, onde o nome do campo é especificado de maneira idêntica à operação get.
      Você pode utilizar os operadores `=`, `|=` e `&=` que fazem exatamente a mesma coisa que na linguagem C. Exemplos:
      $ pei edit executavel.exe section.0.name = .code $ pei edit executavel.exe optional.entry_point = 0xabcd1234 Esta operação aceita números em decimal, hexadecimal ou octal na hora de definir o valor de campos numéricos.
      zeros
      Esta operação simplesmente exibe uma lista das maiores sequências de bytes nulo em cada seção do executável. É este espaço que é utilizado para injetar o código, tornando a operação útil para você poder escolher em qual seção injetar o código.
      $ pei zeros executavel.exe Section #0 '.text': 0x00000000000022fb of 13 bytes Section #1 '.data': 0x000000000000242c of 1012 bytes Section #2 '.rdata': 0x0000000000002a5b of 37 bytes Section #6 '.idata': 0x0000000000003a26 of 22 bytes Section #7 '.CRT': 0x000000000000420b of 21 bytes Section #9 '/4': 0x0000000000004649 of 23 bytes Section #10 '/19': 0x0000000000004cbe of 10 bytes Section #12 '/45': 0x000000000003e2fc of 5 bytes Section #13 '/57': 0x0000000000041019 of 8 bytes Section #15 '/81': 0x0000000000043c33 of 44 bytes Section #16 '/92': 0x0000000000045509 of 23 bytes inject - A cereja do bolo 🙂
      Esta é a operação que injeta o código. Você pode usar a opção -f para especificar o arquivo contendo o código a ser injetado, que seria um raw binary. Onde esse arquivo deve conter apenas as instruções de código de máquina a ser injetado, como um shellcode por exemplo.
      Opcionalmente, você pode usar a opção -s para especificar o número da seção que você quer injetar o código. Se a opção não for especificada, por padrão o pei vai injetar onde houver mais espaço disponível.
      $ pei -f my_code.bin inject executavel.exe Writed code of 12 bytes on offset 0x0000000000043924 of section #15 '/81' Após o código injetado, o pei insere um jump absoluto para o entry point original do executável, fazendo com que após o código injetado ser executado o fluxo de execução do programa continue normalmente.
      Outra modificação que o pei faz é desabilitar o dynamic base do executável, para evitar que o jump aponte para o endereço errado.
      Dica: Injetando Código Muito Grande
      Se você precisar injetar um código maior do que o espaço disponível apontado pela operação zeros, você pode dividir o código a ser injetado em várias partes e injetar cada parte por vez, seguindo a ordem da última até a primeira parte. Isso funciona porque o pei irá adicionar um jump no final do código para o endereço que está sendo indicado como entry point. Se você já injetou código antes, esse endereço é o endereço do código anteriormente injetado. 🙂
      Dessa forma você pode fazer um chain de saltos da primeira parte até a última e então saltar para o entry point original. Exemplo:
      $ pei inject -f parte-3.bin executavel.exe Writed code of 87 bytes on offset 0x0000000000043833 of section #15 '/81' $ pei inject -f parte-2.bin executavel.exe Writed code of 80 bytes on offset 0x0000000000044924 of section #11 '/23' $ pei inject -f parte-1.bin executavel.exe Writed code of 32 bytes on offset 0x0000000000401a15 of section #1 '.text' Isso irá criar a seguinte ordem de execução: parte-1.bin -> parte-2.bin -> parte-3.bin -> entry point. Onde as setas “->” representam os saltos.
      diff
      Esta operação exibe diferenças entre dois executáveis. Ela compara cada campo dos cabeçalhos do executável e o conteúdo das seções, e depois exibe estas diferenças no terminal. Você pode usar a opção -c (ou --color) para que a saída da operação seja colorida:

      Em vermelho são os valores no executável original que foram modificados e em verde são os valores novos no executável modificado.
      patch
      Essa operação lê um texto de entrada no mesmo formato que a saída da operação diff e replica as mesmas modificações no executável. Exemplo:
      $ pei patch executavel2.exe diff-output.txt Caso você não especifique um patch file, o pei irá ler de stdin. Assim, é possível que você faça um pipe entre uma operação de diff e patch:
      $ pei diff original.exe mod.exe | pei patch outro.exe A diferença de fazer isto e simplesmente fazer uma cópia do executável modificado, é que a ideia é replicar somente as diferenças entre os executáveis. Quaisquer outros campos não são tocados pela operação patch, o que te permite salvar alterações e replicá-las por meio de um script. 🙂
      Se você quiser, também é possível escrever um patch file manualmente, bastando imitar a saída de diff. Uma dica é que os valores dos campos originais (em vermelho) não são necessários para a operação patch, então você pode inserir somente os valores novos. Seguindo o print da saída do diff que utilizamos agora pouco como exemplo:
      optional.entry_point xxx 0x4ca33 section.0.name xxx .code section.15.characteristics xxx 0x62100040 // @O texto não faz diferença, só importa o @ no início da linha // Daqui para baixo qualquer linha que não inicie com + será ignorada. +0x43830 00 30 9f 61 62 63 0a b8 f0 14 40 00 ff e0 00 00 // O formato é: +0xoffset bytes em hexadecimal Nota: Onde há o “xxx” seriam os campos dos valores originais (em vermelho) que não são lidos pelo pei porém são necessários para imitar a saída da operação diff. Você pode colocar qualquer valor aí que não dará erro já que são ignorados.
      Você pode usar a operação patch em scripts para automatizar várias modificações em um executável ao mesmo tempo, inclusive em bytes de um determinado offset.
    • By Leandro Fróes
      Se você é da área de Segurança da Informação ou simplesmente tem interesse pelo assunto já deve ter notado que todo dia temos notícias de novos malwares surgindo, sejam eles malwares completamente novos ou variantes de um malware já conhecido. Com isto em mente, faz algum tempo que as empresas de segurança, inteligência e até mesmo pesquisadores independentes passaram a buscar métodos de automatizar não só a análise destes malwares, mas também a administração e armazenamento do arquivo em si, suas características e relacionamentos com outros arquivos demais entidades (domínios, campanhas, endereços IP, etc). Obviamente a análise automatizada não substitui a análise humana, mas já é uma ajuda e tanto considerando o número de malwares surgindo diariamente.
      Para cada uma destas necessidades descritas anteriormente existe uma ou mais ferramentas/plataformas que podem ser utilizadas para cumprir estes objetivos. Dentre elas estão plataformas de sandboxing  como Hybrid-Analysis e AnyRun, ferramentas de análise estática de arquivos como o DIE (Detect It Easy), pev, yara, capa, e também repositórios de malware como o VirusShare e o Malware Bazaar.
      Não podemos negar que todas estas ferramentas/plataformas ajudam e muito no nosso dia a dia, mas ainda assim não conseguiríamos organizar nossas informações e centralizá-las em um único lugar de forma automática, tendo em vista que as as soluções descritas acima são isoladas e não conectam umas com as outras de forma nativa. A plataforma que chegou mais próximo de atingir as quatro exigências (isto é: análise automatizada, administração, armazenamento, relacionamento com demais entidades) foi uma plataforma chamada Virus Total, também conhecido como VT, atualmente administrado pelo Google.
      Virus Total
      O Virus Total trouxe para a comunidade uma forma simples e rápida de análise de IoCs (Indicator of Compromise) e também uma API bem simples de se utilizar para fins de automação. Dentre as diversas funcionalidades da plataforma estão inclusas análise estática, checagem de assinatura utilizando uma lista gigantesca de Anti-Virus, descrição das características gerais do IoC e comentários da comunidade. Além disso, ele também possui uma versão paga (bem cara por sinal) onde você pode fazer hunting de malwares utilizando regras de Yara, download de arquivos, buscas baseadas em histórico, visualização gráfica e uma API bem mais robusta e permissiva.
      É importante deixar claro que o termo IoC não se refere apenas à arquivos e seus hash, mas também à URL, domínios e IP. Ou seja, o VT realmente acaba se tornando uma opção super viável para começar qualquer tipo de investigação.
      O cenário atual de Segurança da Informação
      Com o passar do tempo não só a comunidade, mas também o mercado de Segurança da Informação no geral passou a notar que a única forma de se posicionar contra os ataques atuais é através de contribuição. Pelo mesmo motivo que gerou a necessidade de se criar formas automatizadas de análise, a contribuição se mostra cada dia mais que necessária pois ela não impõe limites, muito pelo contrário, ela dá liberdade o suficiente para você contribuir da forma que quiser.
      Um ótimo exemplo que mostra o exercício da contribuição e o quão valioso isto pode ser é o próprio Linux, que desde sua primeira versão foi liberado para receber contribuições e hoje é um dos maiores projetos existentes na área de tecnologia, com milhares de contribuidores ao redor do mundo.
      Com isto em mente, podemos notar uma desvantagem no VT: o espaço para contribuição é limitado.
      Desafios
      Como já comentado anteriormente, as principais funcionalidades são suportadas apenas na versão paga e infelizmente não são todos que podem pagar pelo valor do serviço.
      Um dos principais motivos dessa limitação é fato do código não ser aberto, isto é, estamos presos às funcionalidades que o time do VT disponibiliza. Se o código fosse disponível para a comunidade, resolveríamos tanto o problema monetário quanto a limitação de funcionalidades disponíveis.
      Uma outra porta que seria aberta no cenário descrito acima é a seguinte: Imagine que você, sua empresa, seu time ou um grupo de amigos estão com um projeto em mãos que envolve análise, classificação, categorização ou qualquer tipo de manipulação de malware. Com o código em mãos você teria liberdade de fazer a instalação da plataforma localmente ou em um servidor do qual você controla, limitando o acesso à quem você quiser e como quiser.
      A comunidade
      Tendo estes desafios em mente, a comunidade começou a criar alternativas para resolver alguns problemas encontrados no cenário atual. A ideia do artigo não é de forma alguma dizer que uma plataforma é melhor que outra ou que o Virus Total está errado em trabalhar no modelo que trabalha, muito pelo contrário, o objetivo aqui é mostrar as várias formas que temos de se chegar no mesmo objetivo. Uns mais flexíveis, outros com mais conteúdo disponível, mas todos conseguem te ajudar a chegar no mesmo lugar:
      Saferwall: Este é o projeto mais maduro que temos atualmente quando o assunto é análise automatizada e contribuição da comunidade. Robusto e flexível para ser instalado em  diversos ambientes, o Saferwall consegue entregar informações estáticas de arquivos, detecções baseadas em assinaturas de alguns antivírus, identificações de packers e download dos arquivos submetidos anteriormente. Além disso, o Saferwall possui uma plataforma aberta e que aceita colaboração, além de disponibilizar o código para você instalar onde e como bem entender. Dentre as formas de instalação estão inclusas o minikube (indicado para ambientes de testes), em nuvem utilizando AWS e On-Premise.


      Freki: O projeto Freki foi criado por uma única pessoa, mas não deixa a desejar quando o assunto é funcionalidade e fácil instalação. Com possibilidade de ser instalado utilizando Docker, este projeto possui não só análise estática dos arquivos PE submetidos, mas também disponibiliza sua própria API e puxa informações do VT para garantir que não falte nada.


      Aleph: focando bastante na parte de inteligência, o projeto Aleph entrega para você não só informações estáticas dos arquivos submetidos, mas também análise dinâmica utilizando sandbox, visualização gráfica dos resultados e uma saída em JSON formatada para ser utilizada em backends como Elasticsearch, por exemplo. Além disso, o Aleph também consegue mapear as técnicas utilizadas pelo malware utilizando o MITRE ATT&CK Framework. Eu realmente aconselho você dar uma olhada na palestra da MBConf v3 sobre o Aleph para saber mais sobre o projeto.
       


      A tabela à seguir foi criada para facilitar a visualização das funcionalidades descritas acima. É importante deixar claro que a versão do VT utilizada para a criação da tabela é a gratuita:
       
       
      VirusTotal
      Saferwall
      Freki
      Aleph
      Análise Estática
      ✔️
      ✔️
      ✔️
      ✔️
      Análise Dinâmica
       
      X
       
      ✔️
       
      X
       
      ✔️
       
      Suporte à múltiplos SO
      ✔️
       
      ✔️
       
      X
       
      ✔️
       
      Análise de IoC de rede
      ✔️
       
      X
       
      X
       
      X
       
      Código Aberto
      X
       
      ✔️
       
      ✔️
       
      ✔️
       
      Download de arquivos
       
      X
       
      ✔️
       
      ✔️
       
      ✔️
       
      Instalação local
      X
       
      ✔️
       
      ✔️
       
      ✔️
       
      Controle total do backend
      X
       
      ✔️
       
      ✔️
       
      ✔️
       
      API
       
      ✔️
       
      ✔️
       
      ✔️
       
      X
      Como podemos ver, todos estes projetos são de código aberto, o que permite a seus usuários livre contribuição. Caso você tenha interesse em contribuir para alguns desses projetos, aqui vai uma dica: nenhum deles possui ainda análise de URL/IP/domínio de forma isolada, isto é, independente do arquivo. Tenho certeza que uma contribuição deste tipo seria bem vinda. ?
      Conclusão
      Ajudando estes projetos nós não só melhoramos a ferramenta/plataforma em si, mas ajudamos todos que a utilizam e também construímos um sistema livre e aberto de análise, inteligência e investigação.
      Se você é da área ou simplesmente curte contribuir, não deixe de dar uma olhada em cada um destes projetos e, se possível, contribuir com eles. Lembrando que quando falamos de contribuição, não há limites. Pode ser um commit, uma ideia, ajuda monetária ou um simples OBRIGADO aos desenvolvedores e contribuidores por disponibilizarem projetos tão úteis para a comunidade.
    • By Leandro Fróes
      ImHex é um editor hexadecimal gráfico multiplataforma e seu principal objetivo é ajudar na engenharia reversa e programação. O editor conta com inúmeras funcionalidades como por exemplo busca por strings, cópia de bytes em diversos formatos (C string, Python, etc), disassembling, hashing e muito mais. Além disso, o editor possibilita a criação das suas próprias templates para serem mapeadas no editor hexa (baseado em um formato de arquivo, por exemplo) através de uma linguagem de patterns:

      Dentre as novas funcionalidades adicionadas na nova release estão alguns itens da linguagem de script como por exemplo "alignTo", que alinha um valor com o que você determinar e "nextAfter", que pega o endereço logo depois de uma variável:

      Esta release também adicionou uma funcionalidade chamada Data Processor, que faz a ferramenta pré-processar os dados do arquivo sendo analisado de forma gráfica antes da análise do visualizador hexadecimal, permitindo a definição de valores e operações em regiões/bytes específicos:

      Lembrando que o ImHex possui suporte à plugins e não só o Data Processing, mas também outras funcionalidades podem ser estendidas do jeito que você quiser!
      Também foram adicionadas algumas outras funcionalidades como cores e utilização do teclado, assim como um conversor de base e habilidade de setar um endereço base no editor hexa:


      A release foi bem grande e com certeza merece uma olhada. Para fazer o download, é só clicar no botão abaixo, que te leva direto para a página de releases do projeto, onde você pode escolher qual versão quer baixar! 😉
       
    • By paulosgf
      Pessoal,
      recebi recentemente esta referência de técnicas anti-debug atualizadas por uma fonte confiável, que é a empresa Check Point.
      Não cheguei a olhar ainda, mas achei interessante de compartilhar logo com os colegas, por ser um tema de grande relevância na área de engenharia reversa.
      Abraços!
      https://research.checkpoint.com/2020/cpr-anti-debug-encyclopedia-the-check-point-anti-debug-techniques-repository/
       
×
×
  • Create New...