SecFlow

Vollautomatisierte Multi-Vektor-Bedrohungsanalyse-Pipeline

Legen Sie jede Datei, URL, IP, Domain oder jedes Bild ab. SecFlow leitet sie durch spezialisierte Analysatoren, bewertet die Ergebnisse mit KI und erstellt automatisch einen professionellen Sicherheitsbericht mit YARA-Regeln, SIGMA-Regeln und exportierbarem PDF.

Schnellstart · Architektur · Bericht Ausgabe · Dokumentation

Was ist SecFlow?

SecFlow ist eine Open-Source automatisierte Bedrohungsanalyse-Pipeline, die für Sicherheitsanalysten, SOC-Teams und Forscher entwickelt wurde. Anstatt manuell verschiedene Tools auszuführen und Ergebnisse zu korrelieren, tut SecFlow:

Klassifiziert Ihre Eingabe mit deterministischen Regeln (kein KI in Durchgang 1)
Leitet es über HTTP-Mikrodienste an den richtigen spezialisierten Analysator weiter
Bewertet die Ergebnisse jedes Durchgangs mit Groq KI, um den nächsten Schritt zu entscheiden
Wiederholt — IOCs folgen, Payloads herunterladen, zwischen Analysatoren wechseln
Berichtet — erstellt einen PWNDoc HTML-Bericht mit YARA-Erkennungsregeln, SIGMA SIEM-Regeln, MITRE ATT&CK-Zuordnungen und PDF-Export mit einem Klick

Funktionen

Architektur```

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 └────────────────────────────────┘

---

## Schnellstart

### Voraussetzungen

- Docker + Docker Compose
- API-Schlüssel für Groq und VirusTotal (kostenlose Stufen funktionieren)

### 1. Repository klonen```bash
git clone https://github.com/aradhyacp/SecFlow.git
cd SecFlow/backend

2. Umgebungsvariablen konfigurieren```bash

cp .env.example .env

Bearbeite `.env` mit deinen Schlüsseln:```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. Starte alle Dienste```bash

docker compose up -d

Dies startet 6 Container:

| Service | Port | Rolle |
|---|---|---|
| `orchestrator` | `5000` | Pipeline-Controller — Haupt-Einstiegspunkt |
| `malware-analyzer` | `5001` | Ghidra-Dekompilierung + VirusTotal |
| `steg-analyzer` | `5002` | binwalk + zsteg + steghide + ExifTool |
| `recon-analyzer` | `5003` | ip-api + ThreatFox + OSINT |
| `web-analyzer` | `5005` | HTTP-Schwachstellenscanner + Header-Audit |
| `macro-analyzer` | `5006` | oletools (olevba) + VirusTotal |

> **Hinweis:** Der erste Start kann mehrere Minuten dauern — der Malware Analyzer lädt Ghidra 12.0.1 (~500 MB) herunter und benötigt eine JDK-21-JVM.

### 4. Führen Sie Ihre erste Analyse durch

**Analysieren Sie eine Datei:**```bash
curl -X POST http://localhost:5000/api/smart-analyze \
  -F "file=@/path/to/suspicious.exe" \
  -F "passes=3"

Analysieren Sie eine URL, IP oder Domain:```bash curl -X POST http://localhost:5000/api/smart-analyze
-H "Content-Type: application/json"
-d '{"target": "192.168.1.100", "passes": 3}'

**Antwort:**```json
{
  "job_id": "a1b2c3d4",
  "findings": [...],
  "report_paths": {
    "json": "/api/report/a1b2c3d4/json",
    "html": "/api/report/a1b2c3d4/html"
  }
}

Öffnen Sie http://localhost:5000/api/report/<job_id>/html in Ihrem Browser, um den vollständigen Bericht anzuzeigen und als PDF zu exportieren.

5. Starten Sie das Frontend```bash

cd ../frontend npm install npm run dev

Öffnen Sie `http://localhost:5173` — das React-Dashboard ermöglicht das Einreichen von Analysen, die Echtzeit-Verfolgung des Pipeline-Fortschritts und das Durchsuchen der Ergebnisse pro Analyzer.

---

## Analysatoren

### Malware-Analysator — Port 5001

Analysiert ausführbare Dateien und Binärdateien mit einem dreistufigen Ansatz:

- **Ghidra 12.0.1** (via `pyghidra`) — vollständige Dekompilierung aller Funktionen in C-Pseudocode
- **`objdump -d`** — Disassemblierung auf Assembly-Ebene
- **VirusTotal API v3** — Erkennung durch 70+ AV-Engines, Verhaltenstags, Dateireputation

**Unterstützt:** `exe`, `dll`, `so`, `elf`, `bin`, `o`, `out` · Maximal 50 MB · Erfordert 4 GB RAM (Ghidra JVM)

---

### Steganographie-Analysator — Port 5002

Erkennt versteckte Daten in Bildern mit mehreren Methoden:

- **binwalk** — erkennt und extrahiert eingebettete Dateien an binären Offsets
- **foremost** — Datei-Carving aus rohen Binärströmen
- **zsteg** — LSB-Steganographie-Erkennung in PNG/BMP
- **steghide** — passwortbasierte Steganographie-Erkennung in JPEG/BMP
- **ExifTool** — Metadatenextraktion und Anomalieerkennung

**Extrahiert eingebettete Archive und stellt sie für eine erneute Analyse in den nächsten Pipeline-Durchlauf.**

**Unterstützt:** PNG, JPG, BMP, GIF, TIFF, WebP

---

### Aufklärungs-Analysator — Port 5003

Führt Threat Intelligence und OSINT für Netzwerk-Identifikatoren durch:

**Scan-Modus** (IP/Domain):

| Modul | Quelle | Prüfung |
|---|---|---|
| `ipapi` | ip-api.com | Land, ISP, ASN, Geolokalisierung |
| `talos` | Cisco Talos-Blockliste | IP-Reputation / Blacklist |
| `tor` | Tor-Projekt-Ausgangsliste | Erkennung von Tor-Exit-Knoten |
| `tranco` | Tranco-Rangliste | Domain-Popularitätsrang |
| `threatfox` | abuse.ch ThreatFox | Aktive IOC / Malware-Zuordnung |

**Footprint-Modus** (E-Mail/Telefon/Benutzername):
- **E-Mail** — XposedOrNot-Datenbank für Sicherheitsverletzungen (Anzahl der Verstöße, Schweregrad, Passwortrisiko)
- **Telefon** — NumVerify-Anbieter, Land und Leitungstyp-Validierung
- **Benutzername** — Sagemode-Multithread-Profile-Findung auf sozialen Plattformen

---

### Web-Schwachstellen-Analysator — Port 5005

Audits URLs und Web-Endpunkte:

- Analyse von Sicherheits-Headern (CSP, HSTS, X-Frame-Options usw.)
- Technologie-Fingerprinting (Server, Frameworks, CMS)
- HTTP-Antwortanalyse und Verfolgung von Weiterleitungsketten
- Grundlegendes Schwachstellen-Scanning auf häufige Fehlkonfigurationen

---

### Makro-/Office-Analysator — Port 5006

Zerlegt Office-Dokumente auf schädliche Makros:

- **oletools (olevba)** — extrahiert und dekompiliert VBA/XLM-Makros
- **AutoExec-Erkennung** — markiert Makros, die beim Öffnen/Schließen automatisch ausgeführt werden
- **IOC-Extraktion** — URLs, IPs, Dateipfade, die in Makrocode eingebettet sind
- **Erkennung von Verschleierungen** — Base64, Chr()-Ketten, Hex-Kodierung
- **VirusTotal API v3** — Dateireputations-Quervergleich

**Unterstützt:** `doc`, `docx`, `docm`, `xls`, `xlsx`, `xlsm`, `xlsb`, `ppt`, `pptx`, `pptm`, `rtf`

---

## Berichtsausgabe

Jeder Pipeline-Durchlauf erzeugt **zwei Berichtsformate**, die unter `backend/reports/<job_id>/` gespeichert werden:

### HTML-Bericht (`report.html`)

In jedem Browser öffnen. Klicken Sie auf **Export PDF**, um zu drucken — kein serverseitiges PDF-Rendering erforderlich, keine Abhängigkeiten.

Enthält: Zusammenfassung · YARA-Regeln · SIGMA-Regeln · MITRE TTPs · Beweistafeln pro Durchlauf · VirusTotal-Engine-Badges.

### JSON-Bericht (`report.json`)

Vollständig strukturierte, maschinenlesbare Ausgabe. Verwenden Sie dies, wenn Sie:
- Ergebnisse direkt in ein anderes KI-Modell zur tiefergehenden Analyse einspeisen möchten
- In ein SIEM- oder Ticketsystem importieren möchten
- Zwei Berichte programmatisch vergleichen möchten
- Benutzerdefinierte Dashboards erstellen möchten

Das JSON spiegelt das HTML exakt wider — jeder Befund, jede YARA-Regel, SIGMA-Regel, jeder IOC und jede TTP ist in einem sauberen, typisierten Schema vorhanden.

Siehe [`examples/`](https://github.com/aradhyacp/secflow/blob/HEAD/examples/) für Beispieleingabedateien und [`example_reports`](https://github.com/aradhyacp/secflow/blob/HEAD/example_reports/) für echte Berichtsausgaben, die während der Entwicklung erstellt wurden.

---

### Zusammenfassung

KI-geschriebener Bericht (Groq `qwen/qwen3-32b`) mit:
- Identifikation der Bedrohung und Klassifikation des Akteurstyps
- Rekonstruktion der Angriffskette (Schritt für Schritt)
- Vertrauensbewertung und Gesamtrisikobewertung

### YARA-Erkennungsregeln

**2–5 produktionsreife YARA-Regeln**, generiert von `llama-3.3-70b-versatile`, jede:
- Benannt nach der Konvention `SecFlow_[ThreatCategory]_[IndicatorType]`
- Enthält gültige YARA 4.x-Syntax — bereit zum Import in jeden YARA-kompatiblen Scanner
- Enthält ein `reasoning`-Feld, das die genauen Beweise aus der Analyse zitiert, die die Regel begründen
- Abdeckung verschiedener Aspekte: Dateisignaturen, eingebettete Zeichenfolgen, C2-Indikatoren, Packer-Signaturen, Speichermuster```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
}

SIGMA SIEM Regeln

2–4 SIGMA Regeln für die sofortige SIEM-Bereitstellung, jede:

Abdeckung einer unterschiedlichen Protokollquelle (Prozesserstellung, Netzwerk, DNS, Dateiereignisse, Registrierung)
Einschließlich gültiger SIGMA-Syntax, kompatibel mit sigma-cli 0.x und pySigma
Zuordnung von Tags zu echten MITRE ATT&CK-Taktiken und Technik-IDs
Importierbar in 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

### MITRE ATT&CK TTPs
Jedes identifizierte Verhalten wird echten Technik-IDs mit Taktiknamen und Begründung zugeordnet.

### Evidenz pro Durchlauf
Einklappbare Panels für jeden Analyzer-Durchlauf mit:
- Ghidra-Dekompilierungsausgabe (dunkler Codeblock, einklappbar)
- objdump-Disassemblierung (einklappbar)
- VirusTotal-Engine-Erkennungen (farbcodierte Schweregrad-Badges)
- Rohe Analysator-Ergebnisse (JSON)

### PDF-Export
Ein-Klick-Browserdruckdialog, vorkonfiguriert für PDF-Export — keine serverseitige PDF-Generierung erforderlich.

---

## Beispielhafte Pipeline-Läufe
Beispieldateien befinden sich in [`examples/`](https://github.com/aradhyacp/secflow/blob/HEAD/examples/) — enthalten echte Malware-Beispiele (`RealMalware.exe`, `ColorBug.exe`, `EarlyEnd.exe`, `.out` ELF-Binärdateien) und ein bösartiges Office-Dokument (`nuclear_motor_example.docm`). Die entsprechenden Berichtsausgaben befinden sich in [`backend/reports/`](https://github.com/aradhyacp/secflow/blob/HEAD/backend/reports/).

### Bösartiges Office-Dokument```
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

Verdächtiges Bild mit eingebetteter Nutzlast```

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)

### Verdächtige Domain```
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

Projektstruktur```

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

---

## KI-Modelle

SecFlow verwendet **Groq** für alle KI-Inferenzen – kostenlose Stufe, keine Kreditkarte erforderlich.

| Rolle | Modell | Grund |
|---|---|---|
| **Pipeline-Routing** | `qwen/qwen3-32b` | Zuverlässige strukturierte JSON-Ausgabe; `/no_think`-Modus überspringt die Gedankenkette für schnelle Routing-Entscheidungen |
| **Bedrohungsanalyse** | `llama-3.3-70b-versatile` | Stärkere Argumentation für die Generierung von YARA/SIGMA und MITRE-TTP-Zuordnung |
| **Zusammenfassung des Berichts** | `qwen/qwen3-32b` | Zusammenfassung für die Führungsebene + Empfehlungen |

SecFlow verwendet die **OpenAI-kompatible API-Spezifikation** über das standardmäßige `openai`-Python-SDK – kein anbieterspezifisches SDK erforderlich. Das bedeutet, Sie können jeden OpenAI-kompatiblen Modellanbieter (OpenAI, Groq, Together, Ollama usw.) austauschen, indem Sie einfach die `base_url` und den Modellnamen ändern:```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")

Warum Groq + kostenloser Tarif? SecFlow wurde so entwickelt, dass es zugänglich ist — für die vollständige Pipeline ist keine kostenpflichtige API erforderlich. Der kostenlose Tarif von Groq deckt das gesamte Routing und die Berichterstellung ohne Kosten ab. Wenn Sie schwerere Arbeitslasten ausführen oder das Projekt sponsern möchten, besuchen Sie die Seite GitHub Sponsors.

API-Referenz

Alle Anfragen gehen an den Orchestrator unter http://localhost:5000.

`POST /api/smart-analyze`

Reichen Sie eine Datei oder ein Ziel zur Analyse ein.

Dateieingabe:```bash curl -X POST http://localhost:5000/api/smart-analyze
-F "[email protected]"
-F "passes=4"

**Zieleingabe (URL / IP / Domäne):**```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`

Gibt den vollständigen PWNDoc HTML-Bericht zurück – im Browser öffnen, auf Export PDF klicken, um zu speichern.

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

Gibt das rohe Findings-JSON für die programmatische Nutzung zurück.

`GET /api/health`

Gesundheitscheck – gibt {"status": "healthy"} zurück.

Umgebungsvariablen

Status

Dokumentation

Mitwirken

Beiträge sind willkommen. SecFlow ist Open Source und wird aktiv gepflegt.

Fork aradhyacp/SecFlow
Erstellen Sie einen Feature-Branch: git checkout -b feat/your-feature
Nehmen Sie Änderungen vor – siehe AGENTS.md für Architekturkonventionen und Dienstverträge
Öffnen Sie einen Pull-Request

Gute erste Aufgaben: Neue IOC-Extraktionsmuster, SIGMA-Regelverbesserungen, zusätzliche OSINT-Module, Frontend-Analysatorseiten, Berichtsexportverbesserungen.

Wenn SecFlow für Ihre Arbeit oder Forschung nützlich ist, erwägen Sie, das Projekt zu sponsern – es hilft, die kostenlose Infrastruktur und Entwicklung am Laufen zu halten.

Lizenz

MIT-Lizenz – siehe LICENSE für Details.

Entwickelt für Sicherheitsanalysten, die Antworten brauchen, nicht noch mehr Werkzeuge, die sie jonglieren müssen.

Wenn SecFlow Ihnen hilft, geben Sie ihm einen Stern – es hilft anderen, das Projekt zu entdecken.

github.com/aradhyacp/SecFlow

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

KI-gesteuertes Routing	Groq `qwen/qwen3-32b` entscheidet nach jedem Durchgang über den nächsten Analysator — keine manuelle Konfiguration
5 spezialisierte Analysatoren	Malware · Steganographie · Aufklärung · Webschwachstellen · Makro/Office
Intelligenter erster Durchgang	Deterministische Regeln von `file` + `python-magic` im ersten Durchgang — KI wird nur bei mehrdeutigem Typ aufgerufen
Herunterladen und Analysieren	Folgt IOCs — lädt in Rohausgabe gefundene Payloads herunter und leitet sie an den richtigen Analysator weiter
YARA-Regelgenerierung	Generiert automatisch 2–5 einsatzbereite YARA-Regeln pro Analyse, jede mit genauen Nachweisen, die sie begründen
SIGMA-Regelgenerierung	Generiert automatisch 2–4 SIGMA-Regeln für Splunk / Elastic / Sentinel — die verschiedene Logquellen abdecken
MITRE ATT&CK-Zuordnung	Jede Erkenntnis wird echten TTP-IDs mit Taktiknamen zugeordnet
Zwei Berichtsformate	HTML-Bericht (im Browser als PDF druckbar) + strukturierter JSON-Bericht (direkt an KI zur weiteren Analyse verfütterbar)
React Dashboard	Vollständige Frontend-Benutzeroberfläche — Analysen einreichen, Live-Pipeline-Fortschritt anzeigen, Ergebnisse pro Analysator durchsuchen
VirusTotal Integration	Sowohl Malware- als auch Makro-Analysatoren fragen 70+ AV-Engines über VT API v3 ab
Konfigurierbare Schleifentiefe	3, 4 oder 5 Durchgänge — frühzeitiger Abbruch, wenn KI keine weiteren Signale meldet
Standalone-Modus	Jeder Analysator-Mikrodienst stellt eine eigene REST-API bereit — unabhängig nutzbar

`GROQ_API_KEY`	orchestrator	✅	KI-Routing + Bedrohungsinformationen + Berichtserstellung
`VIRUSTOTAL_API_KEY`	malware, macro	✅	VirusTotal API v3 Datei-/URL-Analyse
`NUMVERIFY_API_KEY`	recon	Optional	Telefonnummernvalidierung (NumVerify)
`THREATFOX_API_KEY`	recon	Optional	Höheres Ratenlimit für ThreatFox IOC-Abfragen
`ipAPI_KEY`	recon	Optional	Höheres Ratenlimit für ip-api.com
`MAX_PASSES`	orchestrator	Optional	Schleifentiefe – `3` (Standard) / `4` / `5`

Orchestrator + Klassifikator + KI-Engine	✅ Abgeschlossen
Malware-Analysator (Ghidra + VirusTotal)	✅ Abgeschlossen
Steg-Analysator (binwalk + zsteg + steghide)	✅ Abgeschlossen
Recon-Analysator (ip-api + ThreatFox + OSINT)	✅ Abgeschlossen
Web-Schwachstellenanalysator	✅ Abgeschlossen
Makro-Analysator (oletools + VirusTotal)	✅ Abgeschlossen
Download-and-Analyze Payload-Fallback	✅ Abgeschlossen
Automatische YARA-Regelerstellung	✅ Abgeschlossen
Automatische SIGMA-Regelerstellung	✅ Abgeschlossen
MITRE ATT&CK TTP-Zuordnung	✅ Abgeschlossen
HTML-Bericht + JSON-Bericht + PDF-Export	✅ Abgeschlossen
React-Frontend-Dashboard	✅ Abgeschlossen

AGENTS.md	Agentenarchitektur, Dienstverträge und KI-Codierungsanweisungen
ProjectDetails.md	Vollständige Projektspezifikation und Designentscheidungen
docs/architecture.md	Systemkomponenten- und Datenflussdiagramme
docs/pipeline-flow.md	Detaillierte Pipeline-Schleifenlogik und Entscheidungsbaum
docs/analyzers.md	Fähigkeiten und Schnittstellenspezifikation pro Analysator
docs/migration.md	Integrationsleitfaden für die Analysator-Mikrodienste
backend/Readme.md	Backend-Einrichtung, Entwicklung und Fehlerbehebungsleitfaden

SecFlow

Beliebteste

SecFlow

Vollautomatisierte Multi-Vektor-Bedrohungsanalyse-Pipeline

Was ist SecFlow?

Funktionen

Architektur```

2. Umgebungsvariablen konfigurieren```bash

3. Starte alle Dienste```bash

5. Starten Sie das Frontend```bash

SIGMA SIEM Regeln

Verdächtiges Bild mit eingebetteter Nutzlast```

Projektstruktur```

API-Referenz

POST /api/smart-analyze

GET /api/report/<job_id>/html

GET /api/report/<job_id>/json

GET /api/health

Umgebungsvariablen

Status

Dokumentation

Mitwirken

Lizenz

`POST /api/smart-analyze`

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

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

`GET /api/health`