aradhyacp/secflowTubería automatizada de análisis de amenazas impulsada por IA que enruta archivos, URLs, IPs, dominios o imágenes a través de analizadores de seguridad especializados y genera informes profesionales PWNDoc con reglas YARA y Sigma integradas.
<div align="center">
<img src="https://img.shields.io/badge/SecFlow-Threat%20Analysis%20Pipeline-critical?style=for-the-badge&logo=shield&logoColor=white" alt="SecFlow">
# SecFlow
### Pipeline de Análisis de Amenazas Multi-Vector Completamente Automatizado
[](https://python.org)
[](https://docker.com)
[](https://flask.palletsprojects.com)
[](https://groq.com)
[](https://virustotal.com)
[](LICENSE)
[](https://github.com/aradhyacp/SecFlow/pulls)
**Ingrese cualquier archivo, URL, IP, dominio o imagen. SecFlow lo enruta a través de analizadores especializados, razona sobre los hallazgos con IA y produce un informe de seguridad profesional con reglas YARA, reglas SIGMA y PDF exportable, automáticamente.**
<img src="https://raw.githubusercontent.com/aradhyacp/SecFlow/main/SecFlowSocialCard.jpg" alt="Tarjeta Social de SecFlow">
[Inicio Rápido](#-quick-start) · [Arquitectura](#architecture) · [Salida del Informe](#report-output) · [Documentación](#-documentation)
</div>
---
## ¿Qué es SecFlow?
SecFlow es un **pipeline de análisis de amenazas automatizado de código abierto** diseñado para analistas de seguridad, equipos SOC e investigadores. En lugar de ejecutar manualmente herramientas dispares y correlacionar resultados, SecFlow:
1. **Clasifica** su entrada utilizando reglas deterministas (sin IA en el pase 1)
2. **Enruta** a través del analizador especializado correcto mediante microservicios HTTP
3. **Razona** sobre los hallazgos de cada pase con Groq AI para decidir el siguiente paso
4. **Repite** — siguiendo IOCs, descargando payloads, pivotando entre analizadores
5. **Informa** — genera un informe HTML PWNDoc con reglas de detección YARA, reglas SIEM SIGMA, mapeos MITRE ATT&CK y exportación a PDF con un clic
---
## Características
| Característica | Detalle |
|---|---|
| **Enrutamiento impulsado por IA** | Groq `qwen/qwen3-32b` decide el siguiente analizador después de cada pase — sin configuración manual |
| **5 Analizadores Especializados** | Malware · Esteganografía · Reconocimiento · Vulnerabilidad Web · Macro/Office |
| **Primer Pase Inteligente** | Reglas deterministas `file` + `python-magic` en el pase 1 — la IA solo se llama cuando el tipo es ambiguo |
| **Descargar y Analizar** | Sigue IOCs — descarga payloads encontrados en la salida sin procesar y los enruta al analizador correcto |
| **Generación de Reglas YARA** | Genera automáticamente 2–5 reglas YARA desplegables por análisis, cada una citando la evidencia exacta que la motivó |
| **Generación de Reglas SIGMA** | Genera automáticamente 2–4 reglas SIGMA para Splunk / Elastic / Sentinel — cubriendo diferentes fuentes de registro |
| **Mapeo MITRE ATT&CK** | Cada hallazgo mapeado a IDs de TTP reales con nombres de tácticas |
| **Formatos de Informe Duales** | Informe HTML (imprimir a PDF en el navegador) + informe JSON estructurado (alimentar directamente a IA para análisis adicional) |
| **Panel React** | Interfaz de usuario completa — enviar análisis, ver el progreso del pipeline en vivo, explorar resultados por analizador |
| **Integración con VirusTotal** | Tanto los analizadores de Malware como de Macro consultan 70+ motores antivirus a través de VT API v3 |
| **Profundidad de Bucle Configurable** | 3, 4 o 5 pases — sale temprano si la IA indica que no hay más señales |
| **Modo Independiente** | Cada microservicio de analizador expone su propia API REST — úselos de forma independiente |
## Arquitectura```
User Input (file / URL / IP / domain / image)
│
▼
┌────────────────────────────────┐
│ Input Classifier │ file + python-magic → deterministic rule
│ (Rule-based, pass 1 only) │ unknown type? → Groq AI fallback
└───────────────┬────────────────┘
│ first analyzer selected
▼
┌────────────────────────────────────────────────────────┐
│ Analyzer Loop (N = 3 / 4 / 5 passes) │
│ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ Run Analyzer (HTTP → Docker microservice) │ │
│ │ Malware · Steg · Recon · Web · Macro │ │
│ └───────────────┬──────────────────────────────────┘ │
│ │ findings + raw_output │
│ ┌───────────────▼──────────────────────────────────┐ │
│ │ AI Routing Engine (Groq qwen/qwen3-32b) │ │
│ │ IOC extraction → next_tool + target │ │
│ └───────────────┬──────────────────────────────────┘ │
│ │ │
│ ┌───────┴──────────────────┐ │
│ next tool null │
│ │ │ │
│ │ Download HTTP payloads │
│ │ from raw_output → re-analyze │
│ └──────────────── repeat ────────────────────┘│
└─────────────────┬──────────────────────────────────────┘
│
▼
┌────────────────────────────────┐
│ Findings Store │ All passes · all findings accumulated
└───────────────┬────────────────┘
│
▼
┌────────────────────────────────────────────┐
│ Threat Intelligence Engine │
│ (Groq llama-3.3-70b-versatile) │
│ ├─ Threat Summary + MITRE ATT&CK TTPs │
│ ├─ YARA Detection Rules (2–5 rules) │
│ └─ SIGMA SIEM Rules (2–4 rules) │
└───────────────┬────────────────────────────┘
│
▼
┌────────────────────────────────┐
│ PWNDoc HTML Report │ Groq summary → browser-rendered HTML
│ │ One-click Export PDF button
└────────────────────────────────┘
```
---
## Inicio rápido
### Requisitos previos
- Docker + Docker Compose
- Claves API para Groq y VirusTotal (los niveles gratuitos funcionan)
### 1. Clonar el repositorio```bash
git clone https://github.com/aradhyacp/SecFlow.git
cd SecFlow/backend
```
### 2. Configurar variables de entorno```bash
cp .env.example .env
```
Edita `.env` con tus claves:```env
# Required
GROQ_API_KEY=your_groq_api_key_here
VIRUSTOTAL_API_KEY=your_vt_api_key_here
# Optional — unlock additional OSINT capabilities
NUMVERIFY_API_KEY=your_numverify_key # Phone number lookups
THREATFOX_API_KEY=your_threatfox_key # Higher ThreatFox rate limits
ipAPI_KEY=your_ipapi_key # Higher ip-api.com rate limits
# Pipeline control
MAX_PASSES=3 # 3 | 4 | 5
```
### 3. Iniciar todos los servicios```bash
docker compose up -d
```
Esto inicia 6 contenedores:
| Service | Port | Role |
|---|---|---|
| `orchestrator` | `5000` | Controlador de canalización — punto de entrada principal |
| `malware-analyzer` | `5001` | Descompilación de Ghidra + VirusTotal |
| `steg-analyzer` | `5002` | binwalk + zsteg + steghide + ExifTool |
| `recon-analyzer` | `5003` | ip-api + ThreatFox + OSINT |
| `web-analyzer` | `5005` | Escáner de vulnerabilidades HTTP + auditoría de cabeceras |
| `macro-analyzer` | `5006` | oletools (olevba) + VirusTotal |
> **Nota:** El primer inicio puede tardar varios minutos — el Analizador de Malware descarga Ghidra 12.0.1 (~500 MB) y requiere una JVM JDK 21.
### 4. Ejecuta tu primer análisis
**Analiza un archivo:**```bash
curl -X POST http://localhost:5000/api/smart-analyze \
-F "file=@/path/to/suspicious.exe" \
-F "passes=3"
```
**Analiza una URL, IP o dominio:**```bash
curl -X POST http://localhost:5000/api/smart-analyze \
-H "Content-Type: application/json" \
-d '{"target": "192.168.1.100", "passes": 3}'
```
**Respuesta:**```json
{
"job_id": "a1b2c3d4",
"findings": [...],
"report_paths": {
"json": "/api/report/a1b2c3d4/json",
"html": "/api/report/a1b2c3d4/html"
}
}
```
Abre `http://localhost:5000/api/report/<job_id>/html` en tu navegador para ver el informe completo y exportarlo a PDF.
### 5. Inicia el frontend```bash
cd ../frontend
npm install
npm run dev
```
Abre `http://localhost:5173` — el panel de React permite enviar análisis, ver el progreso de la tubería en tiempo real y explorar resultados por analizador.
---
## Analizadores
### Analizador de Malware — Puerto 5001
Analiza ejecutables y binarios con un enfoque de tres capas:
- **Ghidra 12.0.1** (mediante `pyghidra`) — descompilación completa de todas las funciones a pseudocódigo C
- **`objdump -d`** — desensamblado a nivel de ensamblador
- **VirusTotal API v3** — detecciones de más de 70 motores AV, etiquetas de comportamiento, reputación de archivos
**Soportados:** `exe`, `dll`, `so`, `elf`, `bin`, `o`, `out` · Máx. 50 MB · Requiere 4 GB de RAM (JVM de Ghidra)
---
### Analizador de Esteganografía — Puerto 5002
Detecta datos ocultos incrustados en imágenes usando múltiples métodos:
- **binwalk** — detecta y extrae archivos incrustados en offsets binarios
- **foremost** — recuperación de archivos a partir de flujos binarios en bruto
- **zsteg** — detección de esteganografía LSB en PNG/BMP
- **steghide** — detección de esteganografía basada en contraseña en JPEG/BMP
- **ExifTool** — extracción de metadatos y detección de anomalías
**Extrae archivos comprimidos incrustados y los pone en cola para reanálisis** en la siguiente pasada de la tubería.
**Soportados:** PNG, JPG, BMP, GIF, TIFF, WebP
---
### Analizador de Reconocimiento — Puerto 5003
Realiza inteligencia de amenazas y OSINT sobre identificadores de red:
**Modo escaneo** (IP / dominio):
| Módulo | Fuente | Qué comprueba |
|---|---|---|
| `ipapi` | ip-api.com | País, ISP, ASN, geolocalización |
| `talos` | Lista negra de Cisco Talos | Reputación IP / lista negra |
| `tor` | Lista de nodos de salida de Tor Project | Detección de nodo de salida Tor |
| `tranco` | Lista de ranking Tranco | Rango de popularidad del dominio |
| `threatfox` | Abuse.ch ThreatFox | IOC activo / asociación con malware |
**Modo huella** (correo electrónico / teléfono / nombre de usuario):
- **Correo electrónico** — Base de datos de violaciones XposedOrNot (recuento de violaciones, gravedad, riesgo de contraseña)
- **Teléfono** — Validación de operador, país y tipo de línea de NumVerify
- **Nombre de usuario** — Descubrimiento de perfiles multihilo Sagemode en plataformas sociales
---
### Analizador de Vulnerabilidades Web — Puerto 5005
Audita URLs y puntos finales web:
- Análisis de cabeceras de seguridad (CSP, HSTS, X-Frame-Options, etc.)
- Identificación de tecnologías (servidor, frameworks, CMS)
- Análisis de respuestas HTTP y seguimiento de cadenas de redirección
- Escaneo básico de vulnerabilidades para configuraciones incorrectas comunes
---
### Analizador de Macros / Office — Puerto 5006
Analiza documentos de Office en busca de macros maliciosas:
- **oletools (olevba)** — extrae y descompila macros VBA/XLM
- **Detección de AutoExec** — marca macros que se ejecutan automáticamente al abrir/cerrar
- **Extracción de IOCs** — URLs, IPs, rutas de archivo incrustadas en el código de la macro
- **Detección de ofuscación** — Base64, cadenas Chr(), codificación hexadecimal
- **VirusTotal API v3** — verificación cruzada de reputación de archivos
**Soportados:** `doc`, `docx`, `docm`, `xls`, `xlsx`, `xlsm`, `xlsb`, `ppt`, `pptx`, `pptm`, `rtf`
---
## Salida de Informes
Cada ejecución de tubería produce **dos formatos de informe** guardados en `backend/reports/<job_id>/`:
### Informe HTML (`report.html`)
Ábrelo en cualquier navegador. Haz clic en **Exportar PDF** para imprimir — no se necesita renderizado de PDF en el servidor, sin dependencias.
Contiene: resumen ejecutivo · reglas YARA · reglas SIGMA · TTPs MITRE · paneles de evidencia por pasada · insignias de motores de VirusTotal.
### Informe JSON (`report.json`)
Salida completamente estructurada y legible por máquina. Úsalo cuando quieras:
- Enviar los hallazgos directamente a otro modelo de IA para análisis más profundo
- Incorporarlos a un SIEM o sistema de tickets
- Comparar dos informes mediante programación
- Construir paneles personalizados
El JSON refleja exactamente el HTML — cada hallazgo, regla YARA, regla SIGMA, IOC y TTP está presente en un esquema limpio y tipado.
Consulta [`examples/`](https://github.com/aradhyacp/secflow/blob/main/examples) para archivos de entrada de muestra y [`example_reports`](https://github.com/aradhyacp/secflow/blob/main/example_reports) para salidas de informes reales generadas durante el desarrollo.
---
### Resumen Ejecutivo
Narrativa escrita por IA (Groq `qwen/qwen3-32b`) que cubre:
- Nombre de la amenaza identificada y clasificación del tipo de actor
- Reconstrucción de la cadena de ataque (paso a paso)
- Calificación de confianza y puntuación de riesgo general
### Reglas de Detección YARA
**2–5 reglas YARA listas para producción** generadas por `llama-3.3-70b-versatile`, cada una:
- Nombrada con la convención `SecFlow_[CategoríaAmenaza]_[TipoIndicador]`
- Contiene sintaxis YARA 4.x válida — lista para importar en cualquier escáner compatible con YARA
- Incluye un campo `reasoning` que cita la evidencia exacta del análisis que fundamenta la regla
- Cubre aspectos distintos: firmas de archivos, cadenas incrustadas, indicadores C2, firmas de empaquetadores, patrones de memoria```yara
rule SecFlow_Trojan_C2StringIndicator {
meta:
description = "Detects C2 callback string found in Ghidra decompilation"
author = "SecFlow AI"
severity = "high"
strings:
$c2 = "evil.sh/drop.exe"
$ua = "Mozilla/4.0 (compatible; MSIE 6.0)"
condition:
any of them
}
```
### Reglas SIGMA SIEM
**2–4 reglas SIGMA** para implementación inmediata en SIEM, cada una:
- Cubriendo una **fuente de registro diferente** (creación de procesos, red, DNS, eventos de archivos, registro)
- Incluyendo sintaxis SIGMA válida compatible con `sigma-cli` 0.x y pySigma
- Mapeando etiquetas a tácticas e IDs de técnicas reales de MITRE ATT&CK
- Importable en Splunk, Elastic Security, Microsoft Sentinel, Chronicle, QRadar```yaml
title: Detect Suspicious AutoExec Macro Execution
id: f2a3b1c4-...
status: experimental
logsource:
category: process_creation
product: windows
detection:
selection:
CommandLine|contains:
- 'EXCEL.EXE'
- '/automation'
condition: selection
level: high
tags:
- attack.execution
- attack.t1137.001
```
### TTPs de MITRE ATT&CK
Cada comportamiento identificado se asigna a IDs de técnicas reales con nombres de tácticas y razonamiento.
### Evidencia por Pasada
Paneles plegables para cada pasada del analizador que muestran:
- Salida de descompilación de Ghidra (bloque de código oscuro, plegable)
- Desensamblado de objdump (plegable)
- Detecciones del motor de VirusTotal (insignias de gravedad codificadas por colores)
- Hallazgos sin procesar del analizador en JSON
### Exportar PDF
Diálogo de impresión del navegador con un clic preconfigurado para exportación a PDF; no se necesita generación de PDF en el servidor.
---
## Ejemplos de Ejecuciones del Pipeline
Los archivos de entrada de ejemplo están en [`examples/`](https://github.com/aradhyacp/secflow/blob/main/examples) — incluyen muestras reales de malware (`RealMalware.exe`, `ColorBug.exe`, `EarlyEnd.exe`, binarios ELF `.out`) y un documento malicioso de Office (`nuclear_motor_example.docm`). Las salidas de informes correspondientes están en [`backend/reports/`](https://github.com/aradhyacp/secflow/blob/main/backend/reports).
### Documento Malicioso de Office```
Input: invoice.xlsm
Passes: 3
Pass 1 ─ Rule: .xlsm extension → Macro Analyzer
olevba: AutoExec macro found
IOC: http://evil.sh/drop.exe
VT: 12/70 engines flagged
Pass 2 ─ AI: URL found in IOCs → Web Analyzer
http://evil.sh/drop.exe — alive, 302 redirect to CDN
Pass 3 ─ AI: no further tool, but HTTP URL in raw_output
Download: drop.exe → Malware Analyzer
Ghidra: C2 callback string, packed PE
VT: 45/70 detections — Trojan.GenericKDZ
Report ─ PWNDoc HTML generated
YARA: 4 rules (string, byte sig, packer, C2 domain)
SIGMA: 3 rules (process_creation, network, registry)
MITRE: T1566.001, T1059.005, T1071.001
```
### Imagen sospechosa con carga útil incrustada```
Input: profile.png
Passes: 3
Pass 1 ─ Rule: image/png → Steg Analyzer
binwalk: embedded ELF binary at offset 0x8200
Archive extracted → queued for re-analysis
Pass 2 ─ Queue: extracted ELF → Malware Analyzer
Ghidra: C2 callout to 192.168.1.100
objdump: packed UPX section
Pass 3 ─ AI: IP found → Recon Analyzer
Talos: blacklisted
Tor: confirmed exit node
ThreatFox: associated with AsyncRAT
Report ─ Full chain documented
YARA: 3 rules (ELF magic, UPX sig, C2 string)
SIGMA: 2 rules (network_connection, dns_query)
```
### Dominio Sospechoso```
Input: malicious-domain.ru
Passes: 3
Pass 1 ─ Rule: domain regex → Recon Analyzer
ipapi: RU, ISP: HostMaster LLC
Talos: on blocklist
ThreatFox: linked to Raccoon Stealer, confidence 95
Pass 2 ─ AI: ThreatFox hit → Web Analyzer
/login endpoint returns 200, harvesting form detected
Pass 3 ─ AI: no futher signals — loop exits early
Report ─ Executive summary + TTPs + SIGMA network rules
```
---
## Estructura del Proyecto```
SecFlow/
├── backend/
│ ├── compose.yml # All 6 services on secflow-net
│ ├── .env.example # All required + optional API keys
│ │
│ ├── orchestrator/ # Pipeline controller (port 5000)
│ │ ├── app/
│ │ │ ├── routes.py # POST /api/smart-analyze
│ │ │ ├── orchestrator.py # Pipeline loop + download-and-analyze
│ │ │ ├── classifier/
│ │ │ │ ├── classifier.py # file + python-magic type detection
│ │ │ │ └── rules.py # Deterministic routing rules
│ │ │ ├── ai/
│ │ ├── engine.py # Groq qwen/qwen3-32b routing decisions
│ │ ├── threat_intel.py # YARA rules + SIGMA rules + threat summary
│ │ │ │ └── keywords.txt # Grep fallback keyword list
│ │ │ ├── adapters/ # Translate analyzer responses → contract
│ │ │ │ ├── malware_adapter.py
│ │ │ │ ├── steg_adapter.py
│ │ │ │ ├── recon_adapter.py
│ │ │ │ ├── web_adapter.py
│ │ │ │ └── macro_adapter.py
│ │ │ ├── store/
│ │ │ │ └── findings_store.py # Thread-safe findings accumulator
│ │ │ └── reporter/
│ │ │ └── report_generator.py # PWNDoc HTML + Export PDF
│ │ ├── Dockerfile
│ │ └── requirements.txt
│ │
│ ├── Malware-Analyzer/ # Ghidra + objdump + VirusTotal (port 5001)
│ ├── Steg-Analyzer/ # binwalk + zsteg + steghide (port 5002)
│ ├── Recon-Analyzer/ # ip-api + ThreatFox + OSINT (port 5003)
│ ├── Web-Analyzer/ # HTTP vuln scanner (port 5005)
│ └── macro-analyzer/ # oletools + VirusTotal (port 5006)
│
├── frontend/ # React + Vite dashboard (port 5173)
│ └── src/
│ ├── pages/dashboard/ # Per-analyzer pages + smart pipeline UI
│ ├── components/ # Reusable UI components
│ └── pages/LandingPage.jsx # Public landing page
│
├── examples/ # Sample input files for testing
│ ├── RealMalware.exe # Real malware sample
│ ├── ColorBug.exe / EarlyEnd.exe # PE test samples
│ ├── sample.out / sample2.out # ELF binaries
│ └── nuclear_motor_example.docm # Malicious Office document
│
├── docs/ # Architecture + pipeline + analyzer docs
├── AGENTS.md # Agent architecture + coding conventions
└── Readme.md
```
---
## Modelos de IA
SecFlow utiliza **Groq** para toda la inferencia de IA — nivel gratuito, sin necesidad de tarjeta de crédito.
| Rol | Modelo | Por qué |
|---|---|---|
| **Enrutamiento del pipeline** | `qwen/qwen3-32b` | Salida JSON estructurada confiable; el modo `/no_think` omite la cadena de pensamiento para decisiones de enrutamiento rápidas |
| **Inteligencia de amenazas** | `llama-3.3-70b-versatile` | Razonamiento más sólido para la generación de YARA/SIGMA y el mapeo de TTP de MITRE |
| **Resumen del informe** | `qwen/qwen3-32b` | Resumen ejecutivo + recomendaciones |
SecFlow utiliza la **especificación de API compatible con OpenAI** a través del SDK estándar de Python `openai` — sin necesidad de SDK específico del proveedor. Esto significa que puedes cambiar a cualquier proveedor de modelos compatible con OpenAI (OpenAI, Groq, Together, Ollama, etc.) cambiando solo la `base_url` y el nombre del modelo:```python
from openai import OpenAI
# Groq (current — free tier)
client = OpenAI(api_key=GROQ_API_KEY, base_url="https://api.groq.com/openai/v1")
# OpenAI (drop-in swap)
client = OpenAI(api_key=OPENAI_API_KEY) # base_url defaults to api.openai.com
# Local Ollama (fully offline)
client = OpenAI(api_key="ollama", base_url="http://localhost:11434/v1")
```
**¿Por qué Groq + nivel gratuito?** SecFlow fue diseñado para ser accesible: no se requiere API paga para ejecutar todo el pipeline. El nivel gratuito de Groq cubre todo el enrutamiento y la generación de informes sin costo. Si estás ejecutando cargas de trabajo más pesadas o deseas patrocinar el proyecto, consulta la página de [GitHub Sponsors](https://github.com/sponsors/aradhyacp).
---
## Referencia de API
Todas las solicitudes van al orquestador en `http://localhost:5000`.
### `POST /api/smart-analyze`
Envía un archivo o objetivo para su análisis.
**Entrada de archivo:**```bash
curl -X POST http://localhost:5000/api/smart-analyze \
-F "[email protected]" \
-F "passes=4"
```
**Entrada objetivo (URL / IP / domain):**```bash
curl -X POST http://localhost:5000/api/smart-analyze \
-H "Content-Type: application/json" \
-d '{"target": "https://suspicious-site.com", "passes": 5}'
```
### `GET /api/report/<job_id>/html`
Devuelve el informe HTML completo de PWNDoc — ábrelo en el navegador y haz clic en **Export PDF** para guardarlo.
### `GET /api/report/<job_id>/json`
Devuelve el JSON sin procesar de los hallazgos para consumo programático.
### `GET /api/health`
Health check — devuelve `{"status": "healthy"}`.
---
## Variables de Entorno
| Variable | Servicio | Requerido | Descripción |
|---|---|---|---|
| `GROQ_API_KEY` | orchestrator | ✅ | Enrutamiento de IA + inteligencia de amenazas + generación de informes |
| `VIRUSTOTAL_API_KEY` | malware, macro | ✅ | Análisis de archivos/URLs de VirusTotal API v3 |
| `NUMVERIFY_API_KEY` | recon | Opcional | Validación de números de teléfono (NumVerify) |
| `THREATFOX_API_KEY` | recon | Opcional | Límite de tasa más alto en consultas IOC de ThreatFox |
| `ipAPI_KEY` | recon | Opcional | Límite de tasa más alto en ip-api.com |
| `MAX_PASSES` | orchestrator | Opcional | Profundidad del bucle — `3` (predeterminado) / `4` / `5` |
---
## Estado
| Componente | Estado |
|---|---|
| Orchestrator + Classifier + AI Engine | ✅ Completado |
| Malware Analyzer (Ghidra + VirusTotal) | ✅ Completado |
| Steg Analyzer (binwalk + zsteg + steghide) | ✅ Completado |
| Recon Analyzer (ip-api + ThreatFox + OSINT) | ✅ Completado |
| Web Vulnerability Analyzer | ✅ Completado |
| Macro Analyzer (oletools + VirusTotal) | ✅ Completado |
| Download-and-Analyze payload fallback | ✅ Completado |
| YARA Rule Auto-Generation | ✅ Completado |
| SIGMA Rule Auto-Generation | ✅ Completado |
| MITRE ATT&CK TTP Mapping | ✅ Completado |
| HTML Report + JSON Report + Export PDF | ✅ Completado |
| React Frontend Dashboard | ✅ Completado |
---
## Documentación
| Documento | Descripción |
|---|---|
| [AGENTS.md](https://github.com/aradhyacp/secflow/blob/main/AGENTS.md) | Arquitectura de agentes, contratos de servicio e instrucciones de codificación de IA |
| [ProjectDetails.md](https://github.com/aradhyacp/secflow/blob/main/ProjectDetails.md) | Especificación completa del proyecto y decisiones de diseño |
| [docs/architecture.md](https://github.com/aradhyacp/secflow/blob/main/docs/architecture.md) | Diagramas de componentes del sistema y flujo de datos |
| [docs/pipeline-flow.md](https://github.com/aradhyacp/secflow/blob/main/docs/pipeline-flow.md) | Lógica detallada del bucle del pipeline y árbol de decisiones |
| [docs/analyzers.md](https://github.com/aradhyacp/secflow/blob/main/docs/analyzers.md) | Especificación de capacidades e interfaz por analizador |
| [docs/migration.md](https://github.com/aradhyacp/secflow/blob/main/docs/migration.md) | Guía de integración para los microservicios analizadores |
| [backend/Readme.md](https://github.com/aradhyacp/secflow/blob/main/backend/Readme.md) | Guía de configuración, desarrollo y solución de problemas del backend |
---
## Contribuciones
Las contribuciones son bienvenidas. SecFlow es de código abierto y se mantiene activamente.
1. Haz un fork de [aradhyacp/SecFlow](https://github.com/aradhyacp/SecFlow)
2. Crea una rama de características: `git checkout -b feat/your-feature`
3. Realiza cambios — consulta [AGENTS.md](https://github.com/aradhyacp/secflow/blob/main/AGENTS.md) para conocer las convenciones de arquitectura y contratos de servicio
4. Abre un pull request
**Buenas primeras incidencias:** Nuevos patrones de extracción de IOC, mejoras en reglas SIGMA, módulos OSINT adicionales, páginas de analizadores en el frontend, mejoras en la exportación de informes.
Si SecFlow te es útil en tu trabajo o investigación, considera [patrocinar el proyecto](https://github.com/sponsors/aradhyacp) — ayuda a mantener la infraestructura gratuita y el desarrollo en marcha.
---
## Licencia
Licencia MIT — consulta [LICENSE](https://github.com/aradhyacp/secflow/blob/main/LICENSE) para más detalles.
---
<div align="center">
**Construido para analistas de seguridad que necesitan respuestas, no más herramientas con las que lidiar.**
Si SecFlow te ayuda, dale una estrella — ayuda a otros a descubrir el proyecto.
[github.com/aradhyacp/SecFlow](https://github.com/aradhyacp/SecFlow)
---
`#cybersecurity` `#threatintelligence` `#malwareanalysis` `#yara` `#sigma` `#soc` `#dfir` `#infosec` `#osint` `#reverseengineering` `#steganography` `#virustotal` `#ghidra` `#docker` `#python` `#openSource` `#automation` `#mitre` `#attackframework` `#secops` `#blueTeam` `#incidentResponse` `#siem` `#edr` `#ioc` `#pwndoc` `#groq` `#llm` `#aiSecurity`
</div>