Analyse de Malwares Golang avec Ghidra
Vue d'ensemble
Go (Golang) est devenu un langage populaire pour les auteurs de malwares en raison de ses capacités de compilation croisée, de son liaison statique qui produit des binaires autonomes, et de la complexité qu'il introduit pour le rétro-ingénierie. Les binaires Go contiennent l'intégralité de l'exécution, de la bibliothèque standard et de toutes les dépendances liées de manière statique, ce qui donne de gros binaires (souvent 5 à 15 Mo) avec des milliers de fonctions. Ghidra a du mal avec les formats de chaînes spécifiques à Go (non terminées par null), les noms de fonctions supprimés et les modèles de concurrence goroutine. Des outils spécialisés comme GoResolver (Volexity, 2025) utilisent la similarité des graphes de flux de contrôle pour désobfusquer et récupérer automatiquement les noms de fonctions dans les binaires Go obfusqués ou strippés.
Quand l'utiliser
- Lors d'enquêtes sur des incidents de sécurité nécessitant l'analyse de malwares Golang avec Ghidra
- Lors de la création de règles de détection ou de requêtes de chasse aux menaces pour ce domaine
- Lorsque les analystes SOC ont besoin de procédures structurées pour ce type d'analyse
- Lors de la validation de la couverture de surveillance de sécurité pour les techniques d'attaque associées
Prérequis
- Ghidra 11.0+ avec JDK 17+
- Plugin GoResolver (pour la récupération des noms de fonctions)
- Go Reverse Engineering Tool Kit (go-re.tk)
- Python 3.9+ pour les scripts d'aide
- Compréhension des mécanismes internes de Go (goroutines, canaux, interfaces)
- Connaissance de la structure des binaires Go (pclntab, moduledata, itab)
Concepts clés
Structure des binaires Go
Les binaires Go intègrent des métadonnées riches dans la structure pclntab (PC Line Table), qui fait correspondre les compteurs de programme aux noms de fonctions, aux fichiers source et aux numéros de ligne. Même les binaires strippés conservent ces métadonnées. La structure moduledata contient des pointeurs vers les informations de type, les itab (tables d'interface) et le pclntab lui-même. Les chaînes Go sont stockées sous forme d'une paire pointeur-longueur plutôt que de chaînes C terminées par null.
Récupération des fonctions dans les binaires strippés
Malgré la suppression des tables de symboles, les binaires Go conservent les noms de fonctions dans pclntab. Cependant, des outils d'obfuscation comme garble renomment les fonctions en chaînes aléatoires. GoResolver résout ce problème en calculant les signatures du graphe de flux de contrôle des fonctions obfusquées et en les faisant correspondre à une base de données de fonctions Go standard et de paquets tiers connus.
Extraction des dépendances (Crates/Dépendances)
La gestion des dépendances de Go intègre les chemins de modules et les chaînes de version dans le binaire. L'extraction de ces informations révèle les dépendances tierces du malware (bibliothèques HTTP, paquets de cryptographie, frameworks C2), ce qui donne un aperçu des capacités sans nécessiter un rétro-ingénierie complète.
Flux de travail
Étape 1 : Analyse initiale du binaire
#!/usr/bin/env python3
"""Analyse des métadonnées d'un binaire Go pour l'analyse de malware."""
import struct
import sys
import re
def find_go_build_info(data):
"""Extrait les informations de construction Go du binaire."""
# Go buildinfo magic : \xff Go buildinf:
magic = b'\xff Go buildinf:'
offset = data.find(magic)
if offset == -1:
return None
print(f"[+] Informations Go build à l'offset 0x{offset:x}")
# Extraire la version de Go à proximité
go_version = re.search(rb'go\d+\.\d+(?:\.\d+)?', data[offset:offset+256])
if go_version:
print(f" Version Go : {go_version.group().decode()}")
return offset
def find_pclntab(data):
"""Localise la structure pclntab (PC Line Table)."""
# Les octets magiques du pclntab varient selon la version de 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 trouvé à 0x{offset:x} ({version})")
return offset, version
return None, None
def extract_function_names(data, pclntab_offset):
"""Extrait les noms de fonctions du pclntab."""
if pclntab_offset is None:
return []
functions = []
# Les chaînes de noms de fonctions suivent des motifs spécifiques
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):
"""Extrait les chaînes de type Go (paires pointeur+longueur)."""
# Les chaînes Go ne sont pas terminées par null ; extraire les séquences lisibles
strings = []
ascii_pattern = re.compile(rb'[\x20-\x7e]{10,}')
for match in ascii_pattern.finditer(data):
s = match.group().decode('ascii')
# Filtrer les chaînes intéressantes pour les malwares
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):
"""Extrait les dépendances des modules Go du binaire."""
deps = []
# Les chemins de modules suivent le motif : 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):
"""Analyse complète d'un binaire de malware Go."""
with open(filepath, 'rb') as f:
data = f.read()
print(f"[+] Analyse du binaire Go : {filepath}")
print(f" Taille du fichier : {len(data):,} octets")
print("=" * 60)
# Build info
find_go_build_info(data)
# pclntab
pclntab_offset, go_version = find_pclntab(data)
# Fonctions
functions = extract_function_names(data, pclntab_offset)
print(f"\n[+] {len(functions)} noms de fonctions récupérés")
# Catégoriser les fonctions
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)} fonctions) :")
for fn in funcs[:10]:
print(f" {fn}")
# Dépendances
deps = extract_dependencies(data)
print(f"\n[+] Dépendances ({len(deps)}) :")
for dep in deps[:20]:
print(f" {dep}")
# Chaînes suspectes
sus_strings = extract_go_strings(data)
print(f"\n[+] Chaînes suspectes ({len(sus_strings)}) :")
for s in sus_strings[:20]:
print(f" {s}")
if __name__ == "__main__":
if len(sys.argv) < 2:
print(f"Utilisation : {sys.argv[0]} <go_binary>")
sys.exit(1)
analyze_go_binary(sys.argv[1])
Étape 2 : Script d'analyse Ghidra
# Script Ghidra (à exécuter dans le gestionnaire de scripts de Ghidra)
# Enregistrer sous AnalyzeGoBinary.py dans le répertoire des scripts Ghidra
# @category MalwareAnalysis
# @description Analyser la structure d'un binaire Go et récupérer les métadonnées
def analyze_go_binary_ghidra():
"""Script Ghidra pour l'analyse de binaires Go."""
from ghidra.program.model.mem import MemoryAccessException
program = getCurrentProgram()
memory = program.getMemory()
listing = program.getListing()
print("[+] Script d'analyse de binaire Go")
print(f" Programme : {program.getName()}")
# Trouver 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 trouvé à {addr}")
# Créer un label
program.getSymbolTable().createLabel(
addr, "go_pclntab", None,
ghidra.program.model.symbol.SourceType.ANALYSIS
)
break
# Corriger les définitions de chaînes Go
# Les chaînes Go sont ptr+len, pas terminées par null
print("[+] Correction des références de chaînes Go...")
# Rechercher les noms de fonctions contenant des chemins de paquets
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"[+] {func_count} symboles de fonctions Go trouvés")
# Exécuter
analyze_go_binary_ghidra()
Critères de validation
- Version de Go et informations de construction extraites du binaire
- pclntab localisé et analysé pour la récupération des noms de fonctions
- Dépendances tierces identifiées révélant les capacités du malware
- Fonctions du paquet main énumérées pour une analyse ciblée
- Fonctions réseau, cryptographie et exécution système catégorisées
- L'analyse Ghidra étiquette correctement les structures d'exécution Go