GhidraEmu

Este plugin experimental do Ghidra permite que você lide facilmente com a emulação de pcode nativo. Não são mais necessários scripts; basta usá-lo diretamente no Ghidra. Ele pode ser especialmente útil para trabalhar com uma variedade de processadores exóticos que não são suportados por emuladores comuns.

Se o processador/vm for suportado pelo Ghidra para engenharia reversa, ele pode ser emulado! Por exemplo, a emulação de instruções eBPF é demonstrada abaixo:

O que ele pode fazer

Em essência, o plugin é um wrapper estendido ao redor das classes do pacote ghidra.app.emulator. Veja o que foi implementado:

• Funciona com todas as arquiteturas que o Ghidra suporta, então você pode adicionar processadores exóticos e emulá-los
• Emulação de contexto de CPU, pilha e heap
• Aplicação de bytes corrigidos por meio da GUI do Ghidra para alterar o curso da emulação
• Breakpoints para controlar o processo de emulação
• Exibição de bytes alterados durante a emulação no ByteViewer
• Hook de algumas funções da libc (embora ainda seja fraco)

Embora a emulação de PCode idealmente implique unificação, a maioria dos processadores exige sua própria abordagem. Sinta-se à vontade para relatar quaisquer problemas que encontrar. Eu realmente gostaria de testar todos os processadores, mas isso é dificilmente possível.

O que ele não pode

• Entrar em funções de bibliotecas externas (restrições do EmulatorHelper)
• Emulação de syscalls

Todas as janelas do plugin em um só conjunto

Recursos

Janela de menu

Contém todas as janelas do plugin: visualização da Pilha, dos Registradores, dos Breakpoints e a Janela Principal.

Janela pop-up

Contém atalhos para definir o início e o fim da emulação, breakpoints e aplicar bytes alterados ao estado do emulador.

Visualização de registradores

Altere os registradores como quiser. Definir o registrador de link (seta verde) ajudará o emulador a entender qual registrador contém o endereço de retorno. O plugin sabe como isso funciona por meio da pilha, do registrador lr e dos registradores AARCH64 e MIPS. Se você tiver um exótico, selecione o registrador de link e pressione o botão.

Visualização da pilha

Quando você abre seu programa no СodeBrowser, o GhidraEmu mapeia o espaço da pilha automaticamente. O ponteiro de pilha será definido no meio do intervalo da pilha. Isso permite que você defina valores no topo ou na base dos quadros de pilha. Role a visualização se você tiver travamentos ao atualizar ou redefinir. Durante o processo de emulação, se o programa precisar de mais espaço para a pilha, o plugin o alocará automaticamente.

Visualização de breakpoints

Visualização de RAM

Se bytes forem alterados durante a emulação, você os verá no clássico ByteViewer. Não se preocupe, eles serão restaurados aos seus valores originais após pressionar o botão "Reset".

Aplicar bytes corrigidos

Se você fez alterações, informe ao emulador sobre os bytes alterados (a pilha é atualizada automaticamente -- não é necessário). Depois de alterar, selecione-os (eles ficarão verdes) e pressione esta opção (ou use o atalho "M").

Console

Aqui o plugin imprime as informações de saída. Por exemplo, mensagens de erro de emulação como esta:

Novo recurso - Jump Over

O recurso "Jump Over" permite que você avance uma instrução se não quiser emular a atual por algum motivo. Como o processo de emulação será abortado caso seja detectada uma tentativa de leitura de memória não inicializada, esse recurso permite contorná-la. Veja um exemplo. Aqui está uma das primeiras instruções em muitos programas x86_64, a gravação do canary da pilha:

MOV RAX, qword ptr FS:[0x28]

Vamos apenas tentar "trapacear" um pouco e pular por cima dela aumentando o valor do PC. Para fazer isso, pare na instrução que você não deseja emular e pressione a tecla de atalho J. Caso contrário, continuar a execução resultaria em um erro de leitura de memória não inicializada.

Novo recurso - Step Over

Se você parar em uma instrução que leva a uma sub-rotina (chamada interna) e quiser emular tudo até a próxima instrução (o clássico "step over"), pressione a tecla de atalho F6, e certamente isso acontecerá:

Antes de começar

Alguns pontos importantes a considerar:

• Não se esqueça de analisar seu programa no Ghidra; o emulador depende disso.
• Como já mencionado, defina o registrador de link se você tiver um processador/vm exótico.
• Se o processador do seu binário precisar de certos segmentos de memória de acordo com a especificação, não se esqueça de criá-los na janela MemoryMap do Ghidra e inicializá-los com zeros. Caso contrário, o emulador reclamará de espaços de memória desconhecidos durante operações de leitura/escrita e interromperá o processo de emulação. Se um bloco de memória existir, mas não estiver inicializado com zeros e for necessário ao emulador, o plugin tentará inicializá-lo para que a emulação continue.
• Se você alterou algum byte por meio do ByteViewer, o plugin não os restaurará aos valores originais ao redefinir o estado da emulação.
• Antes de fechar o projeto no Ghidra, você deve pressionar o botão "Reset" e redefinir o estado da última emulação, caso isso ainda não tenha sido feito. Isso é importante porque, no momento do fechamento, as transações de repintura das instruções rastreadas no Listing não serão executadas, bem como as transações de restauração dos bytes do programa após a emulação. Isso pode levar não apenas a contemplar o "velho papagaio amarelo", que é o menor dos problemas, mas também a que os bytes modificados permaneçam como tais e não retornem aos seus valores originais (a menos que o projeto seja revertido no Ghidra, é claro).

Instalação

1. Use o gradle para compilar a extensão: GHIDRA_INSTALL_DIR=${GHIDRA_HOME} gradle e use o Ghidra para instalá-la: File → Install Extensions...

2. No CodeBrowser, vá em File → Configure → Miscellaneous e marque a caixa de seleção do plugin GhidraEmu.

Comentários

Encontrou algum bug ao usar o plugin ou tem ideias para melhorias? Não seja tímido, abra uma nova issue e eu resolvo.

Trabalhos futuros

As restrições do EmulatorHelper não permitem usar o espaço do programa em outro. Portanto, sua biblioteca compartilhada externa, por exemplo, nunca saberá sobre o espaço de memória do programa e vice-versa. Então você não pode emulá-la como um único processo com um único espaço de memória. Deixe-me saber se estou esquecendo de algo aqui.