Analisando Malware Golang com Ghidra

Visão Geral

Go (Golang) tornou-se uma linguagem popular para autores de malware devido às suas capacidades de compilação cruzada, linkagem estática que produz binários autossuficientes e a complexidade que introduz para engenharia reversa. Binários Go contêm todo o runtime, biblioteca padrão e todas as dependências linkadas estaticamente, resultando em binários grandes (frequentemente 5-15MB) com milhares de funções. O Ghidra luta com formatos de string específicos de Go (não terminados em nulo), nomes de função removidos e padrões de concorrência de goroutine. Ferramentas especializadas como GoResolver (Volexity, 2025) usam similaridade de grafo de fluxo de controle para desofuscar automaticamente e recuperar nomes de função em binários Go removidos ou ofuscados.

Quando Usar

• Ao investigar incidentes de segurança que exigem a análise de malware golang com ghidra
• Ao construir regras de detecção ou consultas de caça a ameaças para este domínio
• Quando analistas de SOC precisam de procedimentos estruturados para este tipo de análise
• Ao validar a cobertura de monitoramento de segurança para técnicas de ataque relacionadas

Pré-requisitos

• Ghidra 11.0+ com JDK 17+
• Plugin GoResolver (para recuperação de nomes de função)
• Kit de Ferramentas de Engenharia Reversa Go (go-re.tk)
• Python 3.9+ para scripts auxiliares
• Compreensão dos internos do runtime Go (goroutines, canais, interfaces)
• Familiaridade com a estrutura binária Go (pclntab, moduledata, itab)

Conceitos Chave

Estrutura Binária Go

Binários Go incorporam metadados ricos na estrutura pclntab (Tabela de Linha de PC), que mapeia contadores de programa para nomes de função, arquivos de origem e números de linha. Mesmo binários com símbolos removidos retêm esses metadados. A estrutura moduledata contém ponteiros para informações de tipo, itabs (tabelas de interface) e o próprio pclntab. Strings Go são armazenadas como um par ponteiro-comprimento em vez de strings C terminadas em nulo.

Recuperação de Função em Binários Removidos

Apesar da remoção de tabelas de símbolos, binários Go retêm nomes de função dentro do pclntab. No entanto, ferramentas de ofuscação como garble renomeiam funções para strings aleatórias. O GoResolver aborda isso computando assinaturas de grafo de fluxo de controle de funções ofuscadas e combinando-as com um banco de dados de funções conhecidas da biblioteca padrão Go e pacotes de terceiros.

Extração de Crate/Dependência

O gerenciamento de dependências do Go incorpora caminhos de módulo e strings de versão no binário. A extração desses revela as dependências de terceiros do malware (bibliotecas HTTP, pacotes de criptografia, frameworks C2), o que fornece insights sobre as capacidades sem engenharia reversa completa.

Fluxo de Trabalho

Etapa 1: Análise Binária Inicial

#!/usr/bin/env python3
"""Analisa metadados de binários Go para análise de malware."""
import struct
import sys
import re


def find_go_build_info(data):
    """Extrai informações de build Go do binário."""
    # Magia de informações de build Go: \xff Go buildinf:
    magic = b'\xff Go buildinf:'
    offset = data.find(magic)
    if offset == -1:
        return None

    print(f"[+] Informações de build Go no offset 0x{offset:x}")

    # Extrai a string de versão Go próxima
    go_version = re.search(rb'go\d+\.\d+(?:\.\d+)?', data[offset:offset+256])
    if go_version:
        print(f"  Versão Go: {go_version.group().decode()}")

    return offset


def find_pclntab(data):
    """Localiza a estrutura pclntab (Tabela de Linha de PC)."""
    # Bytes mágicos do pclntab variam por versão Go
    magics = {
        b'\xfb\xff\xff\xff\x00\x00': "Go 1.2-1.15",
        b'\xfa\xff\xff\xff\x00\x00': "Go 1.16-1.17",
        b'\xf1\xff\xff\xff\x00\x00': "Go 1.18-1.19",
        b'\xf0\xff\xff\xff\x00\x00': "Go 1.20+",
    }

    for magic, version in magics.items():
        offset = data.find(magic)
        if offset != -1:
            print(f"[+] pclntab encontrado em 0x{offset:x} ({version})")
            return offset, version

    return None, None


def extract_function_names(data, pclntab_offset):
    """Extrai nomes de função do pclntab."""
    if pclntab_offset is None:
        return []

    functions = []
    # Strings de nome de função seguem padrões específicos
    func_pattern = re.compile(
        rb'(?:main|runtime|fmt|net|os|crypto|encoding|io|sync|'
        rb'syscall|reflect|strings|bytes|path|time|math|sort|'
        rb'github\.com|golang\.org)[/\.][\w/.]+',
    )

    for match in func_pattern.finditer(data):
        name = match.group().decode('utf-8', errors='replace')
        if len(name) > 4 and len(name) < 200:
            functions.append(name)

    return sorted(set(functions))



…