OGhidra conecta Grandes Modelos de Lenguaje (LLMs) vía Ollama con la plataforma de ingeniería inversa Ghidra, lo que permite el análisis binario impulsado por IA a través del lenguaje natural. Interactúa con Ghidra mediante consultas conversacionales y automatiza flujos de trabajo complejos de ingeniería inversa.
# OGhidra 3 - Ingeniería inversa impulsada por IA con Ghidra
Para la versión que utiliza un Orchestrator inspirado en Claude, consulta https://github.com/llnl/OGhidra/tree/orchestrator
**OGhidra** une los Grandes Modelos de Lenguaje con la plataforma de ingeniería inversa de Ghidra, permitiendo análisis de binarios impulsados por IA a través del lenguaje natural. Analiza binarios de forma conversacional, automatiza flujos de trabajo complejos y mantén total privacidad con modelos de IA locales.
Tutorial de configuración en YouTube
[](https://www.youtube.com/watch?v=hBD92FUgR0Y)
---
## ¿Qué es OGhidra?
OGhidra mejora Ghidra con capacidades de IA, permitiéndote:
- **Análisis en lenguaje natural** - Haz preguntas sobre funciones, cadenas e importaciones en inglés sencillo
- **Flujos de trabajo automatizados** - Renombra funciones, detecta patrones, genera informes completos
- **Modelos de IA locales** - Privacidad total con modelos que se ejecutan en tu hardware (Ollama)
- **Soporte de IA en la nube** - Conéctate a API externas (OpenAI, Google Gemini, Anthropic Claude)
- **Detección de malware** - Coincidencia automática de patrones para más de 12 técnicas de evasión e inyección
- **Enumeración inteligente** - Construye grafos de conocimiento consultables a partir del análisis de binarios
- **Análisis multi-instancia** - Ejecuta múltiples instancias de Ghidra para análisis en paralelo
### Cómo funciona
```mermaid
graph TD
A[User Query] --> B[Planning Phase]
B --> C{Execution Phase}
C -- Tool Calls --> D[Ghidra/LLM]
D --> C
C --> E[Review Phase]
E -- Agentic Loop --> B
E --> F[Final Response]
style E fill:#f9f,stroke:#333,stroke-width:2px
style B fill:#bbf,stroke:#333,stroke-width:2px
```
**Bucle agéntico**: OGhidra utiliza un sistema de planificación adaptativa. Después de cada ciclo de ejecución, los resultados se revisan y la IA puede optar por recopilar más información o refinar su análisis antes de ofrecer la respuesta final.
---
## Inicio rápido
### Requisitos previos
1. **Python 3.12+** - Verifica la versión: `python --version`
2. **Ghidra 12.0.3** (Recomendado) - Descárgalo desde [Ghidra Releases](https://github.com/NationalSecurityAgency/ghidra/releases)
- La ruta de compilación/instalación del plugin está documentada para Ghidra 12.0.3
- Probado con: Ghidra 11.0.3, 11.3.2, 12.0.2, 12.0.3
3. **Java 21** - Requerido para compilar la extensión de Ghidra 12.0.3: `java -version`
4. **Ollama** (opcional, para modelos locales) - Instálalo desde [ollama.com](https://ollama.com/)
### Instalación
```bash
# Clone repository
git clone https://github.com/LLNL/OGhidra.git
cd OGhidra
# Install dependencies (choose one)
uv sync # Using UV (recommended)
pip install -r requirements.txt # Using pip
# Configure environment
cp .env.example .env
# Edit .env with your settings
```
### Configuración del plugin de Ghidra
Los pasos de compilación del plugin OGhidraMCP a continuación están dirigidos a Ghidra 12.0.3 (recomendado).
También hay un tutorial en video de YouTube: https://www.youtube.com/watch?v=hBD92FUgR0Y
#### Compilación de la extensión GhidraMCP
Como desarrollador, necesitarás compilar la extensión GhidraMCP antes de instalarla en Ghidra:
1. **Requisitos previos**:
- Ghidra 12.0.3 instalado
- Java 21
2. **Opción 1: Usar los scripts de compilación automatizados**:
- Windows:
```bat
# Set the path to your Ghidra installation (will attempt to find last run copy of Ghidra if not set)
set GHIDRA_INSTALL_DIR=C:\path\to\ghidra_12.0.3_PUBLIC
# Run the build script
build_ghidra_plugin.bat
```
- Unix/Linux/Mac:
```bash
# Set the path to your Ghidra installation (will attempt to find the last run copy of Ghidra if not set)
export GHIDRA_INSTALL_DIR=/path/to/ghidra_12.0.3_PUBLIC
# Run the build script (make it executable first if needed)
chmod +x build_ghidra_plugin.sh
./build_ghidra_plugin.sh
```
3. **Opción 2: Proceso de compilación manual**:
- Crea/actualiza `OGhidraMCP/gradle.properties` con la ruta de instalación de Ghidra:
```properties
GHIDRA_INSTALL_DIR=/absolute/path/to/ghidra_12.0.3_PUBLIC
```
- En Unix/Linux/macOS:
```bash
cd OGhidraMCP
$GHIDRA_INSTALL_DIR/support/gradle/gradlew buildExtension --info
```
- En Windows:
```bat
cd OGhidraMCP
"%GHIDRA_INSTALL_DIR%\support\gradle\gradlew.bat" buildExtension --info
```
4. **Localiza la extensión compilada**:
- El archivo zip de la extensión se crea en `OGhidraMCP/dist/`
- El nombre del archivo será algo como `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`
#### Instalación de la extensión GhidraMCP
Una vez que hayas compilado la extensión correctamente:
1. **Instalar en Ghidra**:
- Abre Ghidra -> **File** -> **Install Extensions**
- Haz clic en **Add Extension** (ícono de signo más verde)
- Navega hasta tu directorio `OGhidraMCP/dist/`
- Selecciona el archivo zip de la extensión recién compilada (p. ej., `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`)
- Reinicia Ghidra
2. **Habilitar el plugin**:
- Abre un proyecto de Ghidra
- **File** → **Configure** → **Enable Developer**
- Habilita el plugin `OGhidraMCP`
- El servidor se iniciará en `http://localhost:8080/methods`
> **DEBES TENER EL CODE BROWSER ABIERTO**
### Descargar modelos de IA
```bash
# For Ollama (local models)
ollama pull gemma3:27b # Good balance (20GB RAM)
ollama pull nomic-embed-text # Embedding model for RAG
# Alternative models
ollama pull gpt-oss:120b # High quality (80GB RAM)
ollama pull devstral-2:123b # High quality (80GB RAM)
ollama pull devstral-2:123b-cloud # Cloud Model
```
### Iniciar OGhidra
```bash
# GUI Mode (recommended)
uv run main.py --ui
# Interactive CLI
uv run main.py --interactive
# In interactive CLI, test connection
health
```
Si iniciaste el modo GUI, usa:
```bash
curl http://localhost:8080/methods
```
---
## Configuración
Edita `.env` para configurar tu proveedor de IA:
### Opción 1: Modelos locales (Ollama)
```env
LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://localhost:11434/
OLLAMA_MODEL=gemma3:27b
OLLAMA_EMBEDDING_MODEL=nomic-embed-text
```
### Opción 2: API externas
```env
LLM_PROVIDER=external
EXTERNAL_PROVIDER=google
EXTERNAL_API_KEY=your-api-key-here
EXTERNAL_MODEL=gemini-3.1-flash-lite-preview
EXTERNAL_EMBEDDING_MODEL=gemini-embedding-001
```
### Opción 3: API personalizada compatible con OpenAI
```env
LLM_PROVIDER=custom_api
CUSTOM_API_URL=https://api.example.com/v1/chat/completions
CUSTOM_API_KEY=your-api-key-here
CUSTOM_API_MODEL=your-model-name
CUSTOM_API_EMBEDDING_MODEL=your-embedding-model
```
### Ajustes de gestión de contexto
Ajusta según la ventana de contexto de tu modelo:
```env
# Context budget in tokens (adjust to your model's limit)
CONTEXT_BUDGET=100000 # 100K tokens for mid-size models
# 200K+ for frontier models
# Execution settings
MAX_EXECUTION_STEPS=5 # Steps per planning cycle
MAX_AGENTIC_CYCLES=3 # How many plan-execute-review loops
AGENTIC_LOOP_ENABLED=true # Enable adaptive replanning
```
---
## Características principales
### 1. Botones de herramientas inteligentes (GUI)
Acceso con un clic a tareas comunes de ingeniería inversa:
| Tool | Description |
| ---------------------------- | ----------------------------------------------- |
| **Analyze Current Function** | Análisis profundo del comportamiento de la función seleccionada |
| **Rename Current Function** | La IA sugiere nombres significativos basados en el análisis |
| **Rename All Functions** | Renombrado masivo con opciones Smart/Full/Rename-Only |
| **Analyze Imports** | Identifica librerías y dependencias externas |
| **Analyze Strings** | Encuentra URL, credenciales, datos de configuración |
| **Generate Report** | Evaluación integral de seguridad |
### 2. Modos de tarea
Establece objetivos de análisis especializados:
```python
# In GUI: Use "Task Mode" dropdown
# In CLI: set task_mode <mode>
task_mode malware # Malware analysis with pattern detection
task_mode vuln # Vulnerability research focus
task_mode general # General reverse engineering
```
### 3. Detección de patrones de malware
Detección automática de más de 12 patrones de malware:
- **Evasión**: PEB Walking, Dynamic API Resolution, Anti-Debug, Anti-VM
- **Inyección**: Process Injection (Local/Remote)
- **Persistencia**: Registry, File System Hooks
- **Ofuscación**: String Encoding, API Hashing
- **Escalada de privilegios**: Token manipulation, UAC bypass
Los patrones activan alertas automáticas en el contexto de la IA con mapeos MITRE ATT&CK.
### 4. Enumeración inteligente
Construye conocimiento enriquecido y consultable a partir del análisis de binarios:
```
# Enumerate all functions with AI summaries
# Choose from:
- Rename Only: Only process generic function names
- Smart Enumeration: Focus on security-relevant functions
- Full Enumeration: Analyze every function in the binary
```
Características:
- Extracción de metadatos estructurados (LOC, complejidad, operaciones)
- Optimización de búsqueda semántica
- Ensamblaje de contexto basado en intenciones
- Soporte multivecctor para recuperación precisa
### 5. Gestión de sesiones
Guarda y restaura sesiones de análisis:
```python
# Save progress
File → Save Session
# Load previous work
File → Load Session
# Auto-save after bulk operations
# Sessions include:
- Analyzed functions with summaries
- RAG vectors for semantic search
- Performance statistics
- UI state
```
---
## Configuración del backend
OGhidra admite dos tipos de backend:
- **MCP** — Se integra con el servidor GhidraMCP y requiere que el cliente de Ghidra esté ejecutándose durante el análisis
- **PyGhidra** — Admite análisis sin interfaz gráfica sin el cliente de Ghidra y elimina el componente de servidor requerido por MCP
### Selección de un backend
Usa la siguiente opción de línea de comandos para elegir un backend:
```bash
--ghidra-backend={http,pyghidra}
```
| Opción de backend | Descripción |
|----------------|-------------|
| `http` | Usa el backend GhidraMCP |
| `pyghidra` | Usa el backend PyGhidra |
---
## Configuración de PyGhidra
### Usar un proyecto de Ghidra existente
Especifica un archivo de proyecto de Ghidra (`.gpr`) al iniciar OGhidra:
```bash
--pyghidra-project=/path/to/project.gpr
```
PyGhidra requiere un proyecto de Ghidra válido para poder iniciar OGhidra.
---
### Seleccionar un programa
Especifica qué binario dentro del proyecto de Ghidra debe analizarse:
```bash
--pyghidra-program=<program_name>
```
ejemplo de llamada para seleccionar un programa en un proyecto de Ghidra:
```bash
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-project=/path/to/project.gpr --pyghidra-program=<program_name>
```
Requisitos:
- El nombre del programa debe coincidir exactamente con el nombre que se muestra en la GUI del proyecto de Ghidra
- Esta opción es obligatoria cuando se utiliza un proyecto existente
- No especificar un programa impedirá que OGhidra se inicie
---
### Iniciar un binario directamente
También puedes proporcionar una ruta de binario directamente:
```bash
--pyghidra-binary=/path/to/binary
```
Cuando se usa esta opción, PyGhidra automáticamente:
1. Crea un nuevo proyecto de Ghidra (`.gpr`)
2. Importa el binario
3. Lanza el binario en OGhidra para su análisis
ejemplo de llamada para iniciar un binario directamente:
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-binary=/path/to/binary
---
## Flujos de trabajo comunes
### Analizar un binario sospechoso
1. **Carga el binario en Ghidra** y ábrelo en CodeBrowser
2. **Habilita el plugin OGhidraMCP** (File → Configure)
3. **Inicia OGhidra**: `uv run main.py --ui`
4. **Configura el modo de tarea**: Selecciona "malware" en el menú desplegable
5. **Ejecuta Smart Enumeration**: Haz clic en "Rename All Functions" → "Smart Enumeration"
6. **Haz preguntas**: "¿Cuáles son las funciones de alto riesgo?" o "Muéstrame la comunicación de red"
### Generar informe de seguridad
```bash
# In GUI: Click "Generate Report" button
# Report includes:
- Executive Summary
- Function Inventory (renamed functions with behavior)
- Security Analysis (high-risk functions, patterns)
- Import Analysis
- String Analysis
- Recommendations
```
### Investigar una función específica
1. **Navega hasta la función en Ghidra**
2. **Haz clic en "Analyze Current Function"**
3. **Haz preguntas de seguimiento**:
- "¿Qué hace esta función?"
- "¿Es vulnerable a un desbordamiento de búfer?"
- "¿Qué otras funciones llaman a esta?"
---
## Características avanzadas
### RAG (Generación aumentada por recuperación)
OGhidra utiliza embeddings vectoriales para la búsqueda semántica sobre las funciones analizadas:
```env
# Enable in .env
RESULT_CACHE_ENABLED=true
TIERED_CONTEXT_ENABLED=true
```
Beneficios:
- Recuerda análisis anteriores entre sesiones
- Encuentra funciones similares semánticamente
- Reduce llamadas redundantes a la LLM
### Optimización de contexto
La compresión de contexto por niveles conserva la información relevante:
```env
CURRENT_LOOP_MAX_CHARS=2000 # Recent: full detail
PREV_LOOP_MAX_CHARS=400 # Previous: summaries
OLDER_LOOP_MAX_CHARS=100 # Older: references only
```
### Registro de LLM
Realiza un seguimiento de todas las interacciones de IA para depuración:
```env
LLM_LOGGING_ENABLED=true
LLM_LOG_FILE=logs/llm_interactions.log
LLM_LOG_FORMAT=json
```
---
## Solución de problemas
### Problemas de conexión con Ghidra
```bash
# Verify plugin is loaded
# Open up codebrowser!
# Check server is running
curl http://localhost:8080/methods
```
### Problemas de conexión con Ollama
```bash
# Verify Ollama is running
ollama list
# Check connectivity
curl http://localhost:11434/api/tags
# Restart Ollama service
ollama serve
```
### Respuestas vacías / Desbordamiento de contexto
```env
# Reduce context budget
CONTEXT_BUDGET=50000
# Enable compaction
COMPACTION_ENABLED=true
COMPACTION_THRESHOLD=0.75
```
### Rendimiento lento
1. **Usa modelos más pequeños**: Cambia a `gemma3:9b`
2. **Reduce los trabajadores en paralelo**: Establece `max_workers=2` en operaciones masivas
3. **Desactiva los embeddings vectoriales**: `RESULT_CACHE_ENABLED=false`
4. **Aumenta el retraso de las solicitudes**: `CUSTOM_API_REQUEST_DELAY=2.0`
---
## Descripción general de la arquitectura
```
┌─────────────────────────────────────────────────────────────┐
│ OGhidra UI │
│ (GUI / Interactive CLI) │
└────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Bridge (src/bridge.py) │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ • Agentic Loop: Plan → Execute → Review → Replan │ │
│ │ • Tool Router: Ghidra client, LLM client, CAG manager │ │
│ │ • Context Manager: Budget allocation, compression │ │
│ └────────────────────────────────────────────────────────┘ │
└───────────┬────────────────────────┬────────────────────────┘
│ │
▼ ▼
┌───────────────────────┐ ┌─────────────────────────┐
│ Ghidra Client │ │ LLM Clients │
│ • GhidraMCP Plugin │ │ • Ollama (local) │
│ • Binary operations │ │ • External APIs │
│ • Decompilation │ │ • Custom endpoints │
└───────────────────────┘ └─────────────────────────┘
│ │
└────────────┬───────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ CAG Manager (Knowledge System) │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ • Vector Store: Semantic search over functions │ │
│ │ • Pattern Detector: 12+ malware techniques │ │
│ │ • Metadata Extractor: Structured function analysis │ │
│ │ • Session Store: Persistent analysis state │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
---
## Contribuciones
¡Agradecemos las contribuciones! Áreas de interés:
- **Nuevos patrones de malware** para detección
- **Integraciones de proveedores de LLM**
- **Mejoras de UI/UX**
- **Optimizaciones de rendimiento**
- **Documentación** y ejemplos
Consulta [CODE_OF_CONDUCT.md](https://github.com/llnl/oghidra/blob/main/CODE_OF_CONDUCT.md) para conocer las pautas de la comunidad.
---
## Cita
Si utilizas OGhidra en tu investigación, por favor cita:
```bibtex
@software{oghidra2025,
title = {OGhidra: AI-Powered Reverse Engineering with Ghidra},
author = {Enoch Wang},
year = {2025},
url = {https://github.com/LLNL/OGhidra}
}
```
---
## Agradecimientos
OGhidra se basa en excelentes proyectos de código abierto:
- **[Ghidra](https://github.com/NationalSecurityAgency/ghidra)** — Plataforma de ingeniería inversa de la NSA
- **[Ollama](https://ollama.com/)** — Entorno de ejecución de LLM local
- **[LaurieWired/GhidraMCP](https://github.com/LaurieWired/GhidraMCP)** — Plugin original de Ghidra MCP
- **[starsong/GhydraMCP](https://github.com/starsong/GhydraMCP)** — Implementación mejorada de MCP
---
## Licencia
OGhidra se distribuye bajo los términos de la licencia BSD 3-Clause con una alternativa de licencia comercial.
Consulta [LICENSE](https://github.com/llnl/oghidra/blob/main/LICENSE) y [NOTICE.md](https://github.com/llnl/oghidra/blob/main/NOTICE.md) para más detalles.
**LLNL-CODE-2013290**
---
## Soporte
- **Problemas**: [GitHub Issues](https://github.com/LLNL/OGhidra/issues)
- **Discusiones**: [GitHub Discussions](https://github.com/LLNL/OGhidra/discussions)
- **Escríbeme directamente por correo**: [email protected]