Reverse Engineering war schon immer eine der intellektuell anspruchsvollsten Disziplinen in der Cybersicherheit. Analysten verbringen Stunden damit, Assemblerbefehle zu studieren, Datenstrukturen mental zu rekonstruieren und Ausführungspfade durch gestrippte Binärdateien zu verfolgen. Die kognitive Belastung ist enorm, und die Nachfrage nach qualifizierten Reverse Engineers übersteigt das Angebot bei Weitem.
Genau diese Lücke ist es, wo große Sprachmodelle ihre Spuren hinterlassen. In den letzten zwei Jahren hat sich KI-unterstütztes Reverse Engineering von einer Kuriosität zu einem legitimem Kraftmultiplikator entwickelt. Ghidra-Plugins, die Tausende von Funktionen in Minuten umbenennen, Binary-Ninja-Integrationen, die Shellcode in natürlicher Sprache erklären, und automatisierte Schwachstellenscanner, die über Speicherkorruptionsmuster schlussfolgern, sind alle heute verfügbar. Dies ist keine spekulative Technologie. Es sind Produktionswerkzeuge, auf die arbeitende Analysten sich verlassen.
Dieser Leitfaden behandelt den aktuellen Stand des KI-augmentierten Reverse Engineerings, die relevanten Werkzeuge, praktische Workflows zur Integration in Ihre Analyse-Pipeline und die Einschränkungen, die Sie verstehen müssen, bevor Sie einem davon vertrauen.
Die Schnittstelle von KI und Reverse Engineering
Reverse Engineering ist grundsätzlich ein Problem der Mustererkennung und Übersetzung. Sie nehmen Maschinencode, heben ihn in zunehmend abstrakte Darstellungen und rekonstruieren letztendlich die ursprüngliche Absicht des Entwicklers. LLMs zeichnen sich genau bei dieser Art strukturierter Übersetzung aus.
Die zentrale Erkenntnis hinter den aktuellen Werkzeugen ist, dass dekompilierter C-Pseudocode der natürlichen Sprache nahe genug ist, dass universelle LLMs effektiv darüber schlussfolgern können. Wenn Ghidra oder IDA Pro Decompiler-Ausgabe produziert, ist diese Ausgabe syntaktisch gültiges C. LLMs, die auf Milliarden von Quellcodezeilen trainiert wurden, können Funktionszwecke ableiten, aussagekräftige Variablennamen vorschlagen, gängige Bibliotheksmuster identifizieren und verdächtige Konstrukte markieren.
Drei Kategorien von KI-Unterstützung haben sich herausgebildet:
- Semantische Anreicherung — Umbenennung von Funktionen, Variablen und Typen basierend auf Verhaltensanalyse des dekompilierten Codes
- Erklärung und Zusammenfassung — Generierung natürlichsprachiger Beschreibungen dessen, was Codeblöcke tun
- Schwachstellenerkennung — Identifizierung von Mustern, die mit Buffer Overflows, Use-After-Free, Format-String-Bugs und anderen ausnutzbaren Bedingungen verbunden sind
Jede Kategorie hat unterschiedliche Zuverlässigkeitsprofile. Semantische Anreicherung ist überraschend genau für bekannten Bibliothekscode. Die Qualität der Erklärungen variiert mit der Modellfähigkeit. Die Schwachstellenerkennung bleibt am wenigsten zuverlässig, wird aber am aktivsten erforscht.
KI-unterstützte Dekompilierung: Ghidra-Plugins
Ghidras offene Architektur und Python/Java-Scripting-Support haben es zur primären Plattform für KI-Reverse-Engineering-Experimente gemacht. Mehrere Plugins sind zu täglichen Arbeitswerkzeugen herangereift.
GhidrAssist
GhidrAssist verbindet Ghidra direkt mit LLM-APIs (OpenAI, Anthropic oder lokale Modelle über Ollama) und bietet kontextbezogene Analyse der aktuell ausgewählten Funktion. Es sendet die dekompilierte Ausgabe zusammen mit Querverweisen und String-Daten an das Modell und gibt strukturierte Analysen zurück.
Die Installation ist unkompliziert:
# Clone the repository
git clone https://github.com/unkmc/GhidrAssist.git
# Copy the extension to Ghidra's extensions directory
cp -r GhidrAssist $GHIDRA_INSTALL_DIR/Extensions/Ghidra/
# Restart Ghidra and enable via File > Install Extensions
Einmal mit einem API-Key konfiguriert, können Sie jede Funktion mit Rechtsklick auswählen und "Explain Function" oder "Suggest Names" wählen. Das Plugin sendet das dekompilierte C zusammen mit Kontext über Aufrufkonventionen, importierte Symbole und Querverweise.
Was GhidrAssist besonders effektiv macht, ist sein Kontextfenster-Management. Anstatt die gesamte Dekompilierung des Binaries in einen Prompt zu kippen, konstruiert es fokussierte Abfragen, die die Zielfunktion, ihre unmittelbaren Aufrufer und Aufgerufenen sowie relevante String-Referenzen enthalten. Dieser fokussierte Ansatz produziert deutlich bessere Ergebnisse als naives Prompting.
GEPETTO
GEPETTO (GPT Explanation of ProcEdures To Transform Operations) war eines der ersten produktionsreifen Ghidra-KI-Plugins. Es konzentriert sich speziell auf Funktionserklärung und -umbenennung:
# GEPETTO configuration in ghidra_script.py
# Set your API provider and model
import ghidra_bridge
b = ghidra_bridge.GhidraBridge()
# Get the current function's decompiled output
current_function = b.currentProgram.getFunctionManager().getFunctionContaining(
b.currentAddress
)
decomp = b.DecompInterface()
decomp.openProgram(b.currentProgram)
results = decomp.decompileFunction(current_function, 60, None)
c_code = results.getDecompiledFunction().getC()
# Send to LLM for analysis
prompt = f"""Analyze this decompiled C function. Suggest:
1. A descriptive function name
2. Parameter names and likely types
3. A one-paragraph explanation of its purpose
```c
{c_code}
```"""
GEPETTO zeichnet sich bei der Stapelverarbeitung aus. Sie können es über die gesamte Funktionsliste eines Binaries laufen lassen und einen ersten Durchgang der Umbenennung erhalten, der ein Meer von FUN_00401000-Labels in aussagekräftige Namen wie decrypt_config_buffer oder parse_c2_response verwandelt. Die Genauigkeitsrate bei gängigen Mustern (Datei-I/O, Netzwerkoperationen, Krypto-Routinen) übersteigt typischerweise 80%.
VulChatGPT
VulChatGPT erweitert das GEPETTO-Konzept mit einem spezifischen Fokus auf Schwachstellenidentifizierung. Es analysiert dekompilierte Funktionen auf gängige Schwachstellenmuster und produziert strukturierte Berichte:
# VulChatGPT analysis prompt structure
vulnerability_prompt = """
Analyze this decompiled function for security vulnerabilities.
Focus on:
- Buffer overflow conditions (unchecked memcpy, strcpy, sprintf)
- Integer overflow/underflow in size calculations
- Use-after-free patterns
- Format string vulnerabilities
- Race conditions in shared resource access
- Unvalidated input used in sensitive operations
For each finding, provide:
- Vulnerability type
- Affected line(s)
- Severity estimate
- Exploitation difficulty
"""
Der Wert liegt hier nicht darin, dass das LLM Schwachstellen findet, die ein qualifizierter Analyst übersehen würde. Vielmehr beschleunigt es die Triage. Bei der Analyse eines Binaries mit 2.000 Funktionen spart ein automatisierter erster Durchgang, der die 50 verdächtigsten Funktionen markiert, Tage manueller Überprüfung.
Binary Ninjas Sidekick und KI-Analyse
Binary Ninja hat einen stärker integrierten Ansatz für KI-Unterstützung gewählt. Anstatt sich auf Drittanbieter-Plugins zu verlassen, hat Vector 35 KI-Funktionen direkt in die Plattform eingebaut.
Sidekick bietet eine interaktive Chat-Schnittstelle innerhalb von Binary Ninja, die kontextbewusst ist. Es weiß, welche Funktion Sie betrachten, was Ihre aktuelle Auswahl ist und welche Analyse bereits durchgeführt wurde. Diese enge Integration bedeutet, dass Sie Fragen stellen können wie "Was kontrolliert der dritte Parameter dieser Funktion?" und Antworten erhalten, die auf der tatsächlichen Binäranalyse basieren.
Die Sidekick-API ermöglicht auch Scripting:
# Binary Ninja Sidekick scripting example
from binaryninja import BinaryViewType
bv = BinaryViewType.get_view_of_file("/path/to/binary")
# Iterate functions and get AI-generated summaries
for func in bv.functions:
if func.name.startswith("sub_"):
# Request AI analysis for unnamed functions
analysis = bv.query_sidekick(
f"Analyze function at {hex(func.start)} and suggest a name"
)
if analysis.confidence > 0.8:
func.name = analysis.suggested_name
Binary Ninjas Typ-Propagierungsengine speist direkt in den KI-Kontext, sodass das Modell nicht nur rohen dekompilierten Code sieht, sondern auch wiederhergestellte Typen, Strukturen und Enum-Werte. Dies produziert merklich bessere Ergebnisse als Tools, die nur rohen Pseudocode senden.
IDA Pro KI-Integrationen
IDA Pros Dominanz im kommerziellen Reverse Engineering bedeutet, dass es erhebliche KI-Integrationsanstrengungen angezogen hat.
BinaryAI
BinaryAI verwendet Embedding-basierte Ähnlichkeitssuche, um Funktionen gegen eine Datenbank bekannten Open-Source-Codes abzugleichen. Anstatt ein LLM zu bitten, zu erraten, was eine Funktion tut, berechnet BinaryAI ein Vektor-Embedding des Kontrollflussgraphen der Funktion und der Datenflussmuster und sucht dann nach ähnlichen Funktionen in seinem indexierten Korpus.
# BinaryAI IDA plugin usage
import binaryai as bai
import idautils
import idc
# Initialize client
client = bai.Client(token="your_api_token")
# Analyze current function
func_addr = idc.get_screen_ea()
func_bytes = idc.get_bytes(func_addr, idc.get_func_attr(func_addr, idc.FUNCATTR_END) - func_addr)
# Query the BinaryAI database
results = client.search_function(func_bytes)
for match in results[:5]:
print(f"Match: {match.name} from {match.source} (confidence: {match.score:.2f})")
Dieser Ansatz ergänzt die LLM-basierte Analyse. BinaryAI zeichnet sich bei der Identifizierung statisch gelinkter Bibliotheksfunktionen (zlib, OpenSSL, SQLite) aus, während LLMs besser darin sind, benutzerdefinierte Anwendungslogik zu verstehen.
Gepetto für IDA
Die IDA-Version von Gepetto funktioniert ähnlich wie ihr Ghidra-Pendant, nutzt aber IDAs überlegene Decompiler-Ausgabe (Hex-Rays) für bessere Ergebnisse:
# Gepetto for IDA: batch rename workflow
import ida_hexrays
import ida_funcs
import openai
def analyze_all_functions():
renamed = 0
for func_ea in idautils.Functions():
func = ida_funcs.get_func(func_ea)
cfunc = ida_hexrays.decompile(func_ea)
if cfunc:
pseudocode = str(cfunc)
# Send to LLM for naming
response = openai.chat.completions.create(
model="gpt-4o",
messages=[{
"role": "user",
"content": f"Suggest a function name for:\n{pseudocode}"
}]
)
new_name = response.choices[0].message.content.strip()
if new_name and not new_name.startswith("sub_"):
ida_funcs.set_func_name(func_ea, new_name, ida_funcs.SN_CHECK)
renamed += 1
print(f"Renamed {renamed} functions")
Automatisierte Funktionsbenennung und Typwiederherstellung
Funktionsbenennung ist dort, wo KI den unmittelbarsten, greifbarsten Wert im Reverse Engineering liefert. Der Workflow ist einfach aber leistungsstark:
- Die Funktion zu Pseudocode dekompilieren
- Pseudocode plus Kontext (Strings, Imports, Querverweise) an ein LLM senden
- Die Antwort nach vorgeschlagenem Namen und Parametertypen parsen
- Die Vorschläge anwenden und Typen durch den Aufrufgraphen propagieren
Der Propagationsschritt ist kritisch. Wenn Sie korrekt identifizieren, dass FUN_00405a20 tatsächlich aes_cbc_encrypt ist, kann die Typinformation für seine Parameter (Schlüsselpuffer, IV, Klartext, Länge) an jeden Aufrufer propagiert werden, was die Lesbarkeit im gesamten Binary dramatisch verbessert.
# Type propagation after AI-assisted naming
# Ghidra script for cascading type application
from ghidra.program.model.data import StructureDataType, PointerDataType
from ghidra.program.model.symbol import SourceType
def apply_crypto_types(func, analysis_result):
"""Apply recovered types from AI analysis to a function and its callers."""
dtm = currentProgram.getDataTypeManager()
# Create structure based on AI suggestion
if analysis_result.get("struct_type"):
struct = StructureDataType(analysis_result["struct_name"], 0)
for field in analysis_result["fields"]:
struct.add(
dtm.getDataType(field["type"]),
field["size"],
field["name"],
field["comment"]
)
dtm.addDataType(struct, None)
# Rename function
func.setName(analysis_result["name"], SourceType.USER_DEFINED)
# Update parameter types
params = func.getParameters()
for i, param_info in enumerate(analysis_result.get("params", [])):
if i < len(params):
params[i].setName(param_info["name"], SourceType.USER_DEFINED)
LLM-gestützte Schwachstellenerkennung in Binaries
Die Schwachstellenerkennung in kompiliertem Code hat traditionell auf Mustererkennung (Flawfinder, RATS) oder aufwändigen formalen Methoden (symbolische Ausführung, abstrakte Interpretation) beruht. LLMs bieten einen Mittelweg: Sie können über Code-Semantik auf einer Ebene zwischen syntaktischer Mustererkennung und formaler Verifikation schlussfolgern.
Aktuelle Ansätze funktionieren am besten für bekannte Schwachstellenklassen:
# Structured vulnerability analysis pipeline
import json
def analyze_function_for_vulns(decompiled_code, context):
prompt = f"""You are a binary security analyst. Analyze this decompiled function
for exploitable vulnerabilities.
Function context:
- Binary: {context['binary_name']}
- Architecture: {context['arch']}
- Calling convention: {context['calling_convention']}
- Known imports used: {', '.join(context['imports'])}
Decompiled code:
```c
{decompiled_code}
Respond in JSON format: {{ "vulnerabilities": [ {{ "type": "buffer_overflow|use_after_free|format_string|integer_overflow|race_condition", "severity": "critical|high|medium|low", "line_reference": "approximate line in decompiled output", "description": "what the vulnerability is", "exploitation_notes": "how it might be exploited", "confidence": 0.0-1.0 }} ], "overall_risk": "critical|high|medium|low|none" }}"""
response = call_llm(prompt)
return json.loads(response)
Die zentrale Einschränkung ist die Falsch-Positiv-Rate. LLMs neigen dazu, potenzielle Probleme übermäßig zu markieren, besonders bei Zeigerarithmetik, die aufgrund von Bounds-Checks an anderer Stelle im Code tatsächlich sicher ist. Behandeln Sie LLM-Schwachstellenberichte immer als Hinweise für manuelle Untersuchung, nicht als bestätigte Befunde.
## Das Capstone-, Unicorn- und Keystone-Toolkit
Bevor KI ins Spiel kam, hat die Capstone/Unicorn/Keystone-Suite das Fundament für programmatische Binäranalyse gelegt. Diese Werkzeuge bleiben wesentliche Bausteine und passen gut zu LLM-unterstützten Workflows.
**Capstone** ist ein Disassemblierungs-Framework mit Unterstützung mehrerer Architekturen:
```python
from capstone import Cs, CS_ARCH_X86, CS_MODE_64
CODE = b"\x55\x48\x89\xe5\x48\x83\xec\x10\x89\x7d\xfc\x8b\x45\xfc\x83\xc0\x01"
md = Cs(CS_ARCH_X86, CS_MODE_64)
md.detail = True
for insn in md.disasm(CODE, 0x1000):
print(f"0x{insn.address:x}:\t{insn.mnemonic}\t{insn.op_str}")
groups = [insn.group_name(g) for g in insn.groups]
Unicorn bietet CPU-Emulation für dynamische Analyse:
from unicorn import Uc, UC_ARCH_X86, UC_MODE_64
from unicorn.x86_const import UC_X86_REG_RAX, UC_X86_REG_RIP
mu = Uc(UC_ARCH_X86, UC_MODE_64)
ADDRESS = 0x1000000
mu.mem_map(ADDRESS, 2 * 1024 * 1024)
mu.mem_write(ADDRESS, CODE)
STACK_ADDR = 0x2000000
mu.mem_map(STACK_ADDR, 1024 * 1024)
trace = []
def hook_code(uc, address, size, user_data):
trace.append(address)
mu.hook_add(unicorn.UC_HOOK_CODE, hook_code)
mu.emu_start(ADDRESS, ADDRESS + len(CODE))
print(f"RAX = {mu.reg_read(UC_X86_REG_RAX)}")
Keystone übernimmt das Assemblieren und vervollständigt den Kreislauf:
from keystone import Ks, KS_ARCH_X86, KS_MODE_64
ks = Ks(KS_ARCH_X86, KS_MODE_64)
encoding, count = ks.asm("mov rax, 0x1337; ret")
print(f"Assembled {count} instructions: {bytes(encoding).hex()}")
Die Stärke der Kombination dieser Werkzeuge mit LLMs liegt im Aufbau automatisierter Analyse-Pipelines. Sie können Capstone zum Disassemblieren verwenden, die Ausgabe an ein LLM für semantische Analyse senden, die LLM-Vorschläge verwenden, um Unicorn-Emulationspfade zu lenken, und Keystone verwenden, um Test-Payloads zu generieren.
PyGhidra: Python-First Reverse-Engineering-Pipelines
PyGhidra (ehemals pyhidra) lässt Sie Ghidras Analyse-Engine als Python-Bibliothek ausführen, ohne die GUI zu starten. Dies ist transformativ für den Aufbau automatisierter Pipelines:
import pyghidra
with pyghidra.open_program("/path/to/malware.bin") as flat_api:
program = flat_api.getCurrentProgram()
func_manager = program.getFunctionManager()
results = {}
for func in func_manager.getFunctions(True):
decomp = flat_api.DecompInterface()
decomp.openProgram(program)
decomp_result = decomp.decompileFunction(func, 120, None)
if decomp_result.depiledFunction():
c_code = decomp_result.getDecompiledFunction().getC()
analysis = analyze_with_llm(c_code)
results[func.getName()] = analysis
generate_analysis_report(results, "/path/to/report.json")
PyGhidra ermöglicht CI/CD-artige Binäranalyse. Sie können eine Pipeline einrichten, die automatisch neue Malware-Samples verarbeitet, KI-angereicherte Analyseberichte generiert und Hochprioritätselemente für menschliche Überprüfung markiert:
#!/bin/bash
# Automated malware analysis pipeline
SAMPLE_DIR="/incoming/samples"
REPORT_DIR="/reports"
for sample in "$SAMPLE_DIR"/*.bin; do
filename=$(basename "$sample" .bin)
echo "Analyzing: $filename"
python3 analyze_binary.py \
--input "$sample" \
--output "$REPORT_DIR/${filename}.json" \
--model claude-sonnet \
--max-functions 500 \
--confidence-threshold 0.7
python3 triage_report.py "$REPORT_DIR/${filename}.json"
done
Erstellung benutzerdefinierter Analyseskripte mit LLM-Unterstützung
Der leistungsstärkste Ansatz ist nicht die Verwendung von Standard-Plugins, sondern der Aufbau benutzerdefinierter Analyseskripte, die auf Ihre spezifischen Ziele zugeschnitten sind. LLMs können Ihnen beim Schreiben dieser Skripte helfen:
# Custom malware config extractor using LLM-guided analysis
import struct
import re
class ConfigExtractor:
def __init__(self, binary_path, llm_client):
self.binary_path = binary_path
self.llm = llm_client
self.config = {}
def find_config_function(self, decompiled_functions):
for name, code in decompiled_functions.items():
response = self.llm.query(
f"Does this function initialize a malware configuration "
f"structure? Look for patterns like: setting C2 URLs, "
f"encryption keys, sleep intervals, persistence mechanisms.\n\n"
f"```c\n{code}\n```\n\n"
f"Respond with YES or NO and a confidence score."
)
if "YES" in response and self.parse_confidence(response) > 0.75:
return name, code
return None, None
def extract_config_values(self, config_func_code):
response = self.llm.query(
f"Extract all configuration values from this function. "
f"Identify C2 servers, encryption keys, file paths, "
f"registry keys, and timing values.\n\n"
f"```c\n{config_func_code}\n```\n\n"
f"Respond in JSON format with field names and values."
)
return self.parse_json_response(response)
def parse_confidence(self, response):
match = re.search(r'(\d+\.?\d*)', response.split("confidence")[-1])
return float(match.group(1)) if match else 0.0
def parse_json_response(self, response):
try:
json_match = re.search(r'\{.*\}', response, re.DOTALL)
if json_match:
return json.loads(json_match.group())
except json.JSONDecodeError:
pass
return {}
Ethische Überlegungen und Einschränkungen
KI-unterstütztes Reverse Engineering wirft wichtige Fragen auf, die Praktiker adressieren müssen.
Genauigkeit und Übervertrauen. LLMs produzieren plausibel klingende Analysen, die völlig falsch sein können. Eine Funktion, die für das Modell wie AES-128-Verschlüsselung aussieht, könnte tatsächlich ein benutzerdefinierter XOR-Cipher mit einer zufällig ähnlichen Struktur sein. Vertrauen Sie KI-Analysen nie ohne Überprüfung. Behandeln Sie sie als Hypothesengenerator, nicht als Orakel.
Geistiges Eigentum. Die Verwendung von KI zum Reverse Engineering proprietärer Software wirft rechtliche Fragen auf, die je nach Jurisdiktion variieren. Der DMCA in den USA hat Ausnahmen für Sicherheitsforschung und Interoperabilität, aber die Grenzen sind nicht immer klar. Dokumentieren Sie Ihren Zweck und konsultieren Sie Rechtsberater bei der Arbeit an kommerziellen Zielen.
Modelldatenleck. Wenn Sie dekompilierten Code an eine Cloud-LLM-API senden, kann dieser Code protokolliert, für Training verwendet oder einer Vorladung unterliegen. Für sensible Ziele (staatliche Malware, klassifizierte Binaries, Kundenaufträge unter NDA) verwenden Sie ausschließlich lokale Modelle. Ollama mit einem fähigen Modell wie Llama 3 oder Mixtral bietet angemessene Analysequalität, ohne dass Daten Ihre Maschine verlassen.
Adversariale Robustheit. Malware-Autoren erforschen bereits Techniken, um KI-Analyse zu verwirren. Das Einfügen irreführender String-Referenzen, das Hinzufügen von totem Code, der gutartigen Bibliotheksfunktionen ähnelt, und die Verwendung von Obfuskationsmustern, die spezifisch auf LLM-Verständnis abzielen, sind alles aufkommende Techniken. Erwarten Sie ein Wettrüsten.
Fähigkeitsverfall. Übermäßiges Vertrauen auf KI-Analyse kann grundlegende Reverse-Engineering-Fähigkeiten erodieren. Junior-Analysten, die lernen, "Funktion erklären" zu klicken, bevor sie den Code selbst lesen, entwickeln möglicherweise nie das tiefe Verständnis, das für neuartige Herausforderungen benötigt wird. Nutzen Sie KI als Beschleuniger, nicht als Ersatz fürs Lernen.
Die Zukunft: Autonome Binäranalyse-Agenten
Die nächste Grenze sind agentische Systeme, die mehrstufige Binäranalyse autonom durchführen können. Anstatt einzelne Fragen über einzelne Funktionen zu beantworten, werden diese Systeme Binaries navigieren, Hypothesen bilden und testen und umfassende Analyseberichte erstellen.
Frühe Prototypen existieren bereits. Forschungssysteme können ein Binary nehmen, seinen Einstiegspunkt identifizieren, Ausführungspfade verfolgen, interessante Funktionen identifizieren, sie auf Schwachstellen analysieren und strukturierte Berichte erstellen, alles ohne menschliches Eingreifen. Die Architektur sieht typischerweise so aus:
# Autonomous binary analysis agent architecture
agent:
planning_model: claude-sonnet
analysis_model: claude-sonnet
tools:
- ghidra_decompile
- ghidra_xrefs
- ghidra_strings
- unicorn_emulate
- capstone_disasm
- yara_scan
workflow:
- step: initial_triage
actions: [identify_packer, check_imports, extract_strings]
- step: unpack_if_needed
condition: is_packed
actions: [dump_unpacked, reanalyze]
- step: function_analysis
actions: [identify_interesting_functions, analyze_top_50]
- step: vulnerability_scan
actions: [check_memory_safety, check_crypto_usage]
- step: report_generation
actions: [compile_findings, assign_severity, generate_report]
Der limitierende Faktor ist nicht die Modellfähigkeit, sondern die Zuverlässigkeit der Tool-Integration. Ein LLM dazu zu bringen, Ghidra-APIs korrekt aufzurufen, die Ergebnisse zu interpretieren und über nächste Schritte zu entscheiden, erfordert sorgfältige Entwicklung der Agentenschleife. Halluzinierte API-Aufrufe, fehlinterpretierte Adressen und endlose Analyseschleifen sind häufige Fehlermodi.
Innerhalb des nächsten Jahres erwarten Sie, dass kommerzielle Plattformen agentenbasierte Analyse als Kernfunktion liefern. Die Analysten, die sowohl die KI-Fähigkeiten als auch die zugrunde liegenden Reverse-Engineering-Grundlagen verstehen, werden diejenigen sein, die diese Werkzeuge am effektivsten einsetzen. Die Technologie verstärkt Expertise. Sie ersetzt sie nicht.
Heute Anfangen
Wenn Sie KI jetzt in Ihren Reverse-Engineering-Workflow integrieren möchten, beginnen Sie hier:
Installieren Sie GhidrAssist und konfigurieren Sie es mit Ihrem bevorzugten LLM-Anbieter. Verwenden Sie es an einem Binary, das Sie bereits manuell analysiert haben, um Ihr Vertrauen in seine Ausgabe zu kalibrieren.
Richten Sie ein lokales Modell mit Ollama für sensible Arbeit ein. Llama 3 70B mit Q4_K_M-Quantisierung bietet gute Analysequalität auf einer Maschine mit 48 GB RAM.
Erstellen Sie ein PyGhidra-Skript, das Funktionen stapelweise verarbeitet und einen JSON-Bericht generiert. Beginnen Sie mit Funktionsbenennung und erweitern Sie zur Schwachstellenanalyse.
Etablieren Sie Überprüfungsgewohnheiten. Für jeden KI-Vorschlag, den Sie akzeptieren, verbringen Sie dreißig Sekunden damit, ihn gegen den tatsächlichen Code zu bestätigen. Dies baut Intuition dafür auf, wann die KI richtig liegt und wann sie fabuliert.
Verfolgen Sie Ihre Metriken. Messen Sie, wie viele KI-Vorschläge Sie akzeptieren versus ablehnen und wie oft akzeptierte Vorschläge sich bei tieferer Analyse als falsch herausstellen. Diese Daten helfen Ihnen, Ihren Workflow zu kalibrieren.
Die Werkzeuge sind da. Die Modelle sind fähig genug, um nützlich zu sein. Die Analysten, die sie durchdacht in disziplinierte Workflows integrieren, werden einen signifikanten Vorteil gegenüber denen haben, die KI entweder komplett ignorieren oder ihr blind vertrauen.