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, ligação estática que produz binários autocontidos e a complexidade que introduz para engenharia reversa. Binários Go contêm todo o runtime, biblioteca padrão e todas as dependências estaticamente ligadas, resultando em binários grandes (geralmente 5-15MB) com milhares de funções. Ghidra enfrenta dificuldades com formatos de string específicos do Go (não terminados em nulo), nomes de função removidos (stripped) e padrões de concorrência de goroutines. Ferramentas especializadas como GoResolver (Volexity, 2025) usam similaridade de grafos de fluxo de controle para deobfuscar e recuperar automaticamente nomes de funções em binários Go ofuscados ou com símbolos removidos.
Quando Usar
- Ao investigar incidentes de segurança que exigem 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)
- Go Reverse Engineering Tool Kit (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 do Go (pclntab, moduledata, itab)
Conceitos Chave
Estrutura Binária do Go
Binários Go incorporam metadados ricos na estrutura pclntab (PC Line Table), que mapeia contadores de programa para nomes de função, arquivos fonte e números de linha. Mesmo binários com símbolos removidos (stripped) 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ções em Binários com Símbolos Removidos
Apesar da remoção das 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. GoResolver aborda isso computando assinaturas de grafos de fluxo de controle de funções ofuscadas e comparando-as com um banco de dados de funções conhecidas da biblioteca padrão Go e de pacotes de terceiros.
Extração de Dependências (Crates/Dependencies)
O gerenciamento de dependências do Go incorpora caminhos de módulos e versões nos binários. Extraí-los revela dependências de terceiros do malware (bibliotecas HTTP, pacotes de criptografia, frameworks C2), o que fornece insights sobre suas capacidades sem a necessidade de engenharia reversa completa.
Fluxo de Trabalho
Passo 1: Análise Binária Inicial
#!/usr/bin/env python3
"""Analisar metadados de binário Go para análise de malware."""
import struct
import sys
import re
def find_go_build_info(data):
"""Extrair informações de construção do Go do binário."""
# Magic do Go buildinfo: \xff Go buildinf:
magic = b'\xff Go buildinf:'
offset = data.find(magic)
if offset == -1:
return None
print(f"[+] Informações de construção do Go no offset 0x{offset:x}")
# Extrair versão do Go próxima
go_version = re.search(rb'go\d+\.\d+(?:\.\d+)?', data[offset:offset+256])
if go_version:
print(f" Versão do Go: {go_version.group().decode()}")
return offset
def find_pclntab(data):
"""Localizar a estrutura pclntab (PC Line Table)."""
# Os bytes mágicos do pclntab variam conforme a versão do 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):
"""Extrair nomes de função do pclntab."""
if pclntab_offset is None:
return []
functions = []
# Strings de nomes 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))
def extract_go_strings(data):
"""Extrair strings no estilo Go (pares ponteiro+comprimento)."""
# Strings Go não são terminadas em nulo; extrair sequências legíveis
strings = []
ascii_pattern = re.compile(rb'[\x20-\x7e]{10,}')
for match in ascii_pattern.finditer(data):
s = match.group().decode('ascii')
# Filtrar strings interessantes para malware
interesting = [
'http', 'https', 'tcp', 'udp', 'dns',
'cmd', 'shell', 'exec', 'upload', 'download',
'encrypt', 'decrypt', 'key', 'token', 'password',
'c2', 'beacon', 'agent', 'implant', 'bot',
'mutex', 'persist', 'registry', 'scheduled',
]
if any(kw in s.lower() for kw in interesting):
strings.append(s)
return strings
def extract_dependencies(data):
"""Extrair dependências de módulos Go do binário."""
deps = []
# Caminhos de módulo seguem o padrão: github.com/user/repo
dep_pattern = re.compile(
rb'((?:github\.com|gitlab\.com|golang\.org|gopkg\.in|'
rb'go\.etcd\.io|google\.golang\.org)/[^\x00\s]{5,80})'
)
for match in dep_pattern.finditer(data):
dep = match.group().decode('utf-8', errors='replace')
deps.append(dep)
unique_deps = sorted(set(deps))
return unique_deps
def analyze_go_binary(filepath):
"""Análise completa de binário de malware Go."""
with open(filepath, 'rb') as f:
data = f.read()
print(f"[+] Analisando binário Go: {filepath}")
print(f" Tamanho do arquivo: {len(data):,} bytes")
print("=" * 60)
# Informações de construção
find_go_build_info(data)
# pclntab
pclntab_offset, go_version = find_pclntab(data)
# Funções
functions = extract_function_names(data, pclntab_offset)
print(f"\n[+] {len(functions)} nomes de função recuperados")
# Categorizar funções
categories = {
"network": [], "crypto": [], "os_exec": [],
"file_io": [], "main": [], "third_party": [],
}
for f in functions:
if 'net/' in f or 'http' in f.lower():
categories["network"].append(f)
elif 'crypto' in f:
categories["crypto"].append(f)
elif 'os/exec' in f or 'syscall' in f:
categories["os_exec"].append(f)
elif 'os.' in f or 'io/' in f:
categories["file_io"].append(f)
elif f.startswith('main.'):
categories["main"].append(f)
elif 'github.com' in f or 'golang.org' in f:
categories["third_party"].append(f)
for cat, funcs in categories.items():
if funcs:
print(f"\n [{cat}] ({len(funcs)} funções):")
for fn in funcs[:10]:
print(f" {fn}")
# Dependências
deps = extract_dependencies(data)
print(f"\n[+] Dependências ({len(deps)}):")
for dep in deps[:20]:
print(f" {dep}")
# Strings suspeitas
sus_strings = extract_go_strings(data)
print(f"\n[+] Strings suspeitas ({len(sus_strings)}):")
for s in sus_strings[:20]:
print(f" {s}")
if __name__ == "__main__":
if len(sys.argv) < 2:
print(f"Uso: {sys.argv[0]} <go_binary>")
sys.exit(1)
analyze_go_binary(sys.argv[1])
Passo 2: Script de Análise no Ghidra
# Script Ghidra (executar dentro do gerenciador de scripts do Ghidra)
# Salvar como AnalyzeGoBinary.py no diretório de scripts do Ghidra
# @category MalwareAnalysis
# @description Analisar estrutura binária Go e recuperar metadados
def analyze_go_binary_ghidra():
"""Script Ghidra para análise de binário Go."""
from ghidra.program.model.mem import MemoryAccessException
program = getCurrentProgram()
memory = program.getMemory()
listing = program.getListing()
print("[+] Script de Análise de Binário Go")
print(f" Programa: {program.getName()}")
# Encontrar pclntab
pclntab_magics = [
bytes([0xf0, 0xff, 0xff, 0xff]), # Go 1.20+
bytes([0xf1, 0xff, 0xff, 0xff]), # Go 1.18-1.19
bytes([0xfa, 0xff, 0xff, 0xff]), # Go 1.16-1.17
bytes([0xfb, 0xff, 0xff, 0xff]), # Go 1.2-1.15
]
for magic in pclntab_magics:
addr = memory.findBytes(
program.getMinAddress(), magic, None, True, None
)
if addr:
print(f"[+] pclntab encontrado em {addr}")
# Criar rótulo
program.getSymbolTable().createLabel(
addr, "go_pclntab", None,
ghidra.program.model.symbol.SourceType.ANALYSIS
)
break
# Corrigir definições de string Go
# Strings Go são ptr+len, não terminadas em nulo
print("[+] Corrigindo referências a strings Go...")
# Pesquisar nomes de função contendo caminhos de pacote
symbol_table = program.getSymbolTable()
func_count = 0
for symbol in symbol_table.getAllSymbols(True):
name = symbol.getName()
if ('.' in name and
any(pkg in name for pkg in
['main.', 'runtime.', 'net.', 'crypto.', 'os.']):
func_count += 1
print(f"[+] Encontrados {func_count} símbolos de função Go")
# Executar
analyze_go_binary_ghidra()
Critérios de Validação
- Versão do Go e informações de construção extraídas do binário
- pclntab localizado e analisado para recuperação de nomes de função
- Dependências de terceiros identificadas, revelando capacidades do malware
- Funções do pacote principal enumeradas para análise direcionada
- Funções de rede, criptografia e execução de SO categorizadas
- Análise do Ghidra rotula corretamente estruturas do runtime Go