SecFlow

Pipeline de Análisis de Amenazas Multi-Vector Completamente Automatizado

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.

Inicio Rápido · Arquitectura · Salida del Informe · Documentación

¿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:

Clasifica su entrada utilizando reglas deterministas (sin IA en el pase 1)
Enruta a través del analizador especializado correcto mediante microservicios HTTP
Razona sobre los hallazgos de cada pase con Groq AI para decidir el siguiente paso
Repite — siguiendo IOCs, descargando payloads, pivotando entre analizadores
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

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.

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

Estado

Documentación

Contribuciones

Las contribuciones son bienvenidas. SecFlow es de código abierto y se mantiene activamente.

Haz un fork de aradhyacp/SecFlow
Crea una rama de características: git checkout -b feat/your-feature
Realiza cambios — consulta AGENTS.md para conocer las convenciones de arquitectura y contratos de servicio
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 — ayuda a mantener la infraestructura gratuita y el desarrollo en marcha.

Licencia

Licencia MIT — consulta LICENSE para más detalles.

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

#cybersecurity #threatintelligence #malwareanalysis #yara #sigma #soc #dfir #infosec #osint #reverseengineering #steganography #virustotal #ghidra #docker

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

`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`

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

AGENTS.md	Arquitectura de agentes, contratos de servicio e instrucciones de codificación de IA
ProjectDetails.md	Especificación completa del proyecto y decisiones de diseño
docs/architecture.md	Diagramas de componentes del sistema y flujo de datos
docs/pipeline-flow.md	Lógica detallada del bucle del pipeline y árbol de decisiones
docs/analyzers.md	Especificación de capacidades e interfaz por analizador
docs/migration.md	Guía de integración para los microservicios analizadores
backend/Readme.md	Guía de configuración, desarrollo y solución de problemas del backend

SecFlow

Más Populares

SecFlow

Pipeline de Análisis de Amenazas Multi-Vector Completamente Automatizado

¿Qué es SecFlow?

Características

Arquitectura```

2. Configurar variables de entorno```bash

3. Iniciar todos los servicios```bash

5. Inicia el frontend```bash

Reglas SIGMA SIEM

Imagen sospechosa con carga útil incrustada```

Estructura del Proyecto```

Referencia de API

POST /api/smart-analyze

GET /api/report/<job_id>/html

GET /api/report/<job_id>/json

GET /api/health

Variables de Entorno

Estado

Documentación

Contribuciones

Licencia

`POST /api/smart-analyze`

`GET /api/report/<job_id>/html`

`GET /api/report/<job_id>/json`

`GET /api/health`