Ir para conteúdo
  • Injeção e manipulação de executáveis com o pei

       (1 análise)

    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:

    image.png.dcd2fc90ed1aab06f2a5aecd6f5b4215.png

    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:

    image.png.c1baa8c26827228cfa2ec0332ad6ec1f.png

    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:

    image.png.8f339ca05937ec64fb554e79a734a21c.png

    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.


    Revisão: Leandro Fróes
    • Curtir 2
    • l33t 2

    Feedback do Usuário

    Participe da conversa

    Você pode postar agora e se cadastrar mais tarde. Se você tem uma conta, faça o login para postar com sua conta.
    Nota: Sua postagem exigirá aprovação do moderador antes de ficar visível.

    Visitante

    • Isso não será mostrado para outros usuários.
    • Adicionar um análise...

      ×   Você colou conteúdo com formatação.   Remover formatação

        Apenas 75 emojis são permitidos.

      ×   Seu link foi automaticamente incorporado.   Mostrar como link

      ×   Seu conteúdo anterior foi restaurado.   Limpar o editor

      ×   Não é possível colar imagens diretamente. Carregar ou inserir imagens do URL.


    Visitante Zasgardiano

       1 de 1 membros acharam esta análise útil 1 / 1 membro

    Parabéns excelente ferramenta e muito bem documentada no github. Show!

    Link para a análise
    Compartilhar em outros sites


  • Conteúdo Similar

×
×
  • Criar Novo...