Ghostrings

Scripts para recuperar definições de strings em binários Go com análise de P-Code. Testado com x86, x86-64, ARM e ARM64.

Scripts

Golang

Estes podem ser encontrados na categoria Golang no Gerenciador de Scripts.

• GoDynamicStrings.java
  • Analisa o P-Code para encontrar estruturas de string criadas na pilha. Usa a análise de estilo "register" de nível mais baixo.
• GoFuncCallStrings.java
  • Analisa o P-Code para encontrar estruturas de string passadas diretamente a chamadas de função via registradores, sem serem gravadas na pilha. Usa análise de estilo "normalize" com o novo suporte integrado a Golang do Ghidra (consulte as notas de versão do Ghidra para versões de Golang suportadas).
• GoStaticStrings.java
  • Encontra estruturas de string Go alocadas estaticamente em memória somente leitura.
• GoKnownStrings.java
  • Procura por strings exclusivas padrão e as define. Os dados de string são carregados de data/known_strings.json.
• GoStringFiller.java
  • Preenche lacunas em go.string.* após a análise inicial, com base na ordem crescente de comprimento dos dados de string.

Existem também algumas variações especiais do script de análise de strings dinâmicas:

• GoDynamicStringsSingle.java
  • Executa a mesma análise que GoDynamicStrings.java, mas usa um único processo de descompilador. Use isso se a análise de um binário fizer com que os processos paralelos do descompilador esgotem a memória do sistema.
• GoDynamicStringsHigh.java
  • Experimental, usa a saída de P-Code da análise de estilo "normalize" de nível mais alto. Atualmente depende de um hack que desativa a eliminação de código morto no descompilador (veja https://research.nccgroup.com/2022/05/20/earlyremoval-in-the-conservatory-with-the-wrench/). Este hack quebra no Ghidra 10.2.

P-Code

Este pode ser encontrado na categoria PCode no Gerenciador de Scripts.

• PrintHighPCode.java
  • Imprime a saída de P-Code de alto nível da função atualmente selecionada no console, com um seletor para o estilo de simplificação do descompilador a ser usado. Usado principalmente para desenvolver scripts de análise de P-Code.

Fluxo de recuperação de strings

Este é o fluxo geral para usar esses scripts e recuperar definições de strings em um binário Go:

1. Limpe todas as strings incorretas ou definidas automaticamente no bloco de memória de dados somente leitura.
   • Na janela "Defined Strings", habilite a coluna "Mem Block" e filtre por bloco de memória para selecionar todas as strings em .rodata, .rdata ou __rodata. Em seguida, clique com o botão direito na listagem de código e escolha "Clear Code Bytes".
2. (Opcional) Execute GoKnownStrings.java para detectar algumas strings padrão.
3. Execute GoStaticStrings.java.
4. Execute GoFuncCallStrings.java (se a versão do binário Golang for suportada pelos recursos integrados de Golang do Ghidra).
5. Execute GoDynamicStrings.java.
6. Execute GoStringFiller.java.
   • Se detectar uma violação da ordem crescente de comprimento dos dados de string, limpe quaisquer definições de string falso-positivas nessa área e execute o script novamente. Existe uma opção para fazer isso automaticamente.
   • Se o binário estiver strippado, localize a área de strings de um byte encontradas pelo script de strings dinâmicas. Certifique-se de que seja o início das strings agrupadas sem terminação nula (mais strings devem ser definidas depois, em ordem crescente de comprimento). Crie o rótulo go.string.* na primeira string de um byte.

Configuração

Instalação

No Ghidra:

1. File -> Install Extensions -> Add extension
2. Selecione o arquivo ZIP da extensão

Desenvolvimento

Para Eclipse com o plugin GhidraDev:

1. Clone o repositório
2. File -> Import -> Projects from Folder or Archive
3. Selecione o diretório do repositório
4. GhidraDev -> Link Ghidra...
5. Selecione o projeto importado

Compilação

Compile com o Eclipse:

• GhidraDev -> Export -> Ghidra Module Extension...

Compile diretamente com o Gradle:

$ cd Ghostrings
$ gradle -PGHIDRA_INSTALL_DIR=<ghidra_install_dir>

Contexto

Um problema bem conhecido na engenharia reversa de programas Go é que a falta de terminadores nulos nas strings Go torna difícil a recuperação de definições de strings em binários compilados. Muitos dos valores de string constantes de um programa Go são armazenados juntos em um único blob gigante no build compilado, sem caracteres terminadores embutidos nos dados da string para marcar onde uma string termina e outra começa. Até mesmo um programa simples que apenas imprime "Hello world!" tem mais de 1.500 strings relacionadas ao sistema de runtime do Go e a outras bibliotecas padrão. Isso pode fazer com que implementações típicas de descoberta de strings ASCII, como a fornecida pelo Ghidra, criem definições de strings falso-positivas com dezenas de milhares de caracteres.

Em vez de strings terminadas em nulo, o Go usa uma estrutura de string que consiste em um ponteiro e um valor de comprimento. Muitas dessas estruturas de string são criadas na pilha do programa em tempo de execução, portanto, recuperar locais individuais de início de string e valores de comprimento exige a análise do código de máquina compilado. Existem alguns scripts existentes que realizam essa análise verificando certos padrões de instruções x86-64, mas eles perdem estruturas criadas com variações não tratadas de instruções que, em última análise, têm o mesmo efeito na pilha, e também são restritos a uma ISA específica.

O Ghostrings evita ambos os problemas ao trabalhar com as operações de P-Code simplificadas e independentes de arquitetura produzidas pela análise do descompilador do Ghidra.

Informações de lançamento

Copyright 2022 NCC Group. Lançado sob a licença GPLv3 (veja LICENSE).

Autor principal do projeto: James Chambers [email protected]