SecFlow

Pipeline d'analyse de menaces multi-vecteurs entièrement automatisé

Déposez n'importe quel fichier, URL, IP, domaine ou image. SecFlow l'achemine à travers des analyseurs spécialisés, raisonne sur les résultats avec l'IA et produit un rapport de sécurité professionnel avec des règles YARA, des règles SIGMA et un PDF exportable — automatiquement.

Démarrage rapide · Architecture · Rapport de sortie · Documentation

Qu'est-ce que SecFlow ?

SecFlow est un pipeline d'analyse de menaces automatisé open-source conçu pour les analystes en sécurité, les équipes SOC et les chercheurs. Au lieu d'exécuter manuellement des outils disparates et de corréler les résultats, SecFlow :

Classe votre entrée à l'aide de règles déterministes (pas d'IA au premier passage)
Achemine via le bon analyseur spécialisé grâce à des microservices HTTP
Raisonner sur les résultats de chaque passage avec l'IA Groq pour décider de l'étape suivante
Répète — en suivant les IOC, en téléchargeant les charges utiles et en pivotant entre les analyseurs
Rapporte — génère un rapport HTML PWNDoc avec des règles de détection YARA, des règles SIGMA pour SIEM, des correspondances MITRE ATT&CK et une exportation PDF en un clic

Fonctionnalités

Architecture```

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

---

## Démarrage rapide

### Prérequis

- Docker + Docker Compose
- Clés API pour Groq et VirusTotal (les niveaux gratuits fonctionnent)

### 1. Clonez le dépôt```bash
git clone https://github.com/aradhyacp/SecFlow.git
cd SecFlow/backend

2. Configurer les variables d'environnement```bash

cp .env.example .env

Modifiez `.env` avec vos clés :```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. Démarrer tous les services```bash

docker compose up -d

Cela démarre 6 conteneurs :

| Service | Port | Rôle |
|---|---|---|
| `orchestrator` | `5000` | Contrôleur de pipeline — point d'entrée principal |
| `malware-analyzer` | `5001` | Décompilation Ghidra + VirusTotal |
| `steg-analyzer` | `5002` | binwalk + zsteg + steghide + ExifTool |
| `recon-analyzer` | `5003` | ip-api + ThreatFox + OSINT |
| `web-analyzer` | `5005` | Scanner de vulnérabilités HTTP + audit d'en-têtes |
| `macro-analyzer` | `5006` | oletools (olevba) + VirusTotal |

> **Remarque :** Le premier démarrage peut prendre plusieurs minutes — l'analyseur de malware télécharge Ghidra 12.0.1 (~500 Mo) et nécessite une JVM JDK 21.

### 4. Lancez votre première analyse

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

Analyser une URL, une adresse IP ou un domaine :```bash curl -X POST http://localhost:5000/api/smart-analyze
-H "Content-Type: application/json"
-d '{"target": "192.168.1.100", "passes": 3}'

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

Ouvrez http://localhost:5000/api/report/<job_id>/html dans votre navigateur pour visualiser le rapport complet et l'exporter en PDF.

5. Lancer le frontend```bash

cd ../frontend npm install npm run dev

Ouvrez `http://localhost:5173` — le tableau de bord React vous permet de soumettre des analyses, de suivre l'avancement du pipeline en temps réel et de parcourir les résultats par analyseur.

---

## Analyseurs

### Analyseur de logiciels malveillants — Port 5001

Analyse les exécutables et les binaires avec une approche en trois couches :

- **Ghidra 12.0.1** (via `pyghidra`) — décompilation complète de toutes les fonctions en pseudo-code C
- **`objdump -d`** — désassemblage au niveau assembleur
- **VirusTotal API v3** — détections de plus de 70 moteurs antivirus, balises comportementales, réputation du fichier

**Supporté :** `exe`, `dll`, `so`, `elf`, `bin`, `o`, `out` · Max 50 Mo · Nécessite 4 Go de RAM (JVM Ghidra)

---

### Analyseur de stéganographie — Port 5002

Détecte les données cachées intégrées dans les images en utilisant plusieurs méthodes :

- **binwalk** — détecte et extrait les fichiers intégrés aux décalages binaires
- **foremost** — récupération de fichiers à partir de flux binaires bruts
- **zsteg** — détection de stéganographie LSB dans PNG/BMP
- **steghide** — détection stéganographique basée sur mot de passe dans JPEG/BMP
- **ExifTool** — extraction de métadonnées et détection d'anomalies

**Extrait les archives intégrées et les met en file d'attente pour une réanalyse** lors du prochain passage du pipeline.

**Supporté :** PNG, JPG, BMP, GIF, TIFF, WebP

---

### Analyseur de reconnaissance — Port 5003

Effectue du renseignement sur les menaces et de l'OSINT sur les identifiants réseau :

**Mode scan** (IP / domaine) :

| Module | Source | Ce qu'il vérifie |
|---|---|---|
| `ipapi` | ip-api.com | Pays, FAI, ASN, géolocalisation |
| `talos` | Cisco Talos blocklist | Réputation IP / liste noire |
| `tor` | Tor Project exit list | Détection de nœud de sortie Tor |
| `tranco` | Tranco ranking list | Rang de popularité du domaine |
| `threatfox` | abuse.ch ThreatFox | IOC actif / association de logiciels malveillants |

**Mode empreinte** (email / téléphone / nom d'utilisateur) :
- **Email** — Base de données de fuites XposedOrNot (nombre de fuites, sévérité, risque de mot de passe)
- **Téléphone** — Validation de l'opérateur, du pays et du type de ligne via NumVerify
- **Nom d'utilisateur** — Découverte de profil multithread Sagemode sur les plateformes sociales

---

### Analyseur de vulnérabilités web — Port 5005

Audite les URL et les points d'accès web :

- Analyse des en-têtes de sécurité (CSP, HSTS, X-Frame-Options, etc.)
- Empreinte technologique (serveur, frameworks, CMS)
- Analyse des réponses HTTP et suivi des chaînes de redirection
- Analyse basique des vulnérabilités pour les erreurs de configuration courantes

---

### Analyseur de macros / Office — Port 5006

Dissèque les documents Office à la recherche de macros malveillantes :

- **oletools (olevba)** — extrait et décompile les macros VBA/XLM
- **Détection d'AutoExec** — signale les macros qui s'exécutent automatiquement à l'ouverture/fermeture
- **Extraction d'IOC** — URLs, IP, chemins de fichiers intégrés dans le code de macro
- **Détection d'obfuscation** — Base64, chaînes Chr(), encodage hexadécimal
- **VirusTotal API v3** — vérification croisée de la réputation du fichier

**Supporté :** `doc`, `docx`, `docm`, `xls`, `xlsx`, `xlsm`, `xlsb`, `ppt`, `pptx`, `pptm`, `rtf`

---

## Sortie du rapport

Chaque exécution du pipeline produit **deux formats de rapport** sauvegardés dans `backend/reports/<job_id>/` :

### Rapport HTML (`report.html`)

Ouvrez dans n'importe quel navigateur. Cliquez sur **Exporter en PDF** pour imprimer — aucun rendu PDF côté serveur nécessaire, aucune dépendance.

Contient : résumé exécutif · règles YARA · règles SIGMA · TTPs MITRE · panneaux de preuves par passage · badges de moteur VirusTotal.

### Rapport JSON (`report.json`)

Sortie entièrement structurée et lisible par machine. Utilisez-le lorsque vous souhaitez :
- Alimenter directement un autre modèle d'IA pour une analyse plus approfondie
- Ingérer dans un SIEM ou un système de tickets
- Comparer deux rapports par programmation
- Construire des tableaux de bord personnalisés

Le JSON reflète exactement le HTML — chaque résultat, règle YARA, règle SIGMA, IOC et TTP est présent dans un schéma propre et typé.

Voir [`examples/`](https://github.com/aradhyacp/secflow/blob/HEAD/examples/) pour des exemples de fichiers d'entrée et [`example_reports`](https://github.com/aradhyacp/secflow/blob/HEAD/example_reports/) pour des exemples de rapports réels générés lors du développement.

---

### Résumé exécutif
Récit généré par IA (Groq `qwen/qwen3-32b`) couvrant :
- Nom de menace identifié et classification du type d'acteur
- Reconstruction de la chaîne d'attaque (étape par étape)
- Indice de confiance et score de risque global

### Règles de détection YARA
**2 à 5 règles YARA prêtes pour la production** générées par `llama-3.3-70b-versatile`, chacune :
- Nommées selon la convention `SecFlow_[CatégorieMenace]_[TypeIndicateur]`
- Contenant une syntaxe YARA 4.x valide — prêtes à être importées dans tout scanner compatible YARA
- Incluant un champ `reasoning` citant les preuves exactes de l'analyse qui ont informé la règle
- Couvrant des aspects distincts : signatures de fichiers, chaînes intégrées, indicateurs C2, signatures de packer, motifs mémoire```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
}

Règles SIGMA SIEM

2 à 4 règles SIGMA pour un déploiement SIEM immédiat, chacune :

Couvrant une source de journal différente (création de processus, réseau, DNS, événements de fichiers, registre)
Incluant une syntaxe SIGMA valide compatible avec sigma-cli 0.x et pySigma
Mappant des étiquettes aux tactiques réelles MITRE ATT&CK et aux identifiants de techniques
Importable dans 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 MITRE ATT&CK
Chaque comportement identifié est associé à des identifiants de techniques réelles avec les noms des tactiques et la justification.

### Preuves par passage
Panneaux repliables pour chaque passage de l'analyseur montrant :
- Sortie de décompilation Ghidra (bloc de code sombre, repliable)
- Désassemblage objdump (repliable)
- Détections du moteur VirusTotal (badges de sévérité avec code couleur)
- Résultats bruts de l'analyseur JSON

### Exporter en PDF
Dialogue d'impression du navigateur en un clic, préconfiguré pour l'export PDF — aucune génération PDF côté serveur nécessaire.

---

## Exemples d'exécutions du pipeline
Les fichiers d'entrée d'exemple se trouvent dans [`examples/`](https://github.com/aradhyacp/secflow/blob/HEAD/examples/) — inclut des échantillons de malwares réels (`RealMalware.exe`, `ColorBug.exe`, `EarlyEnd.exe`, des binaires ELF `.out`) et un document Office malveillant (`nuclear_motor_example.docm`). Les rapports correspondants se trouvent dans [`backend/reports/`](https://github.com/aradhyacp/secflow/blob/HEAD/backend/reports/).

### Document Office malveillant```
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

Image suspecte avec charge utile intégrée```

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)

### Domaine suspect```
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

Structure du projet```

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

---

## Modèles IA

SecFlow utilise **Groq** pour toute l'inférence IA — niveau gratuit, aucune carte de crédit nécessaire.

| Rôle | Modèle | Pourquoi |
|---|---|---|
| **Routage du pipeline** | `qwen/qwen3-32b` | Sortie JSON structurée fiable ; le mode `/no_think` ignore la chaîne de pensée pour des décisions de routage rapides |
| **Renseignement sur les menaces** | `llama-3.3-70b-versatile` | Raisonnement plus fort pour la génération YARA/SIGMA et le mapping des TTP MITRE |
| **Résumé du rapport** | `qwen/qwen3-32b` | Résumé exécutif + recommandations |

SecFlow utilise la **spécification d'API compatible OpenAI** via le SDK Python standard `openai` — aucun SDK spécifique au fournisseur n'est requis. Cela signifie que vous pouvez échanger tout fournisseur de modèle compatible OpenAI (OpenAI, Groq, Together, Ollama, etc.) en changeant simplement le `base_url` et le nom du modèle :```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")

Pourquoi Groq + niveau gratuit ? SecFlow a été conçu pour être accessible — aucune API payante requise pour exécuter l'ensemble du pipeline. Le niveau gratuit de Groq couvre tout le routage et la génération de rapports sans aucun coût. Si vous exécutez des charges de travail plus lourdes ou souhaitez sponsoriser le projet, consultez la page GitHub Sponsors.

Référence de l'API

Toutes les requêtes vont à l'orchestrateur à http://localhost:5000.

`POST /api/smart-analyze`

Soumettre un fichier ou une cible pour analyse.

Entrée de fichier :```bash curl -X POST http://localhost:5000/api/smart-analyze
-F "[email protected]"
-F "passes=4"

**Entrée cible (URL / IP / domaine):**```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`

Renvoie le rapport HTML complet de PWNDoc — ouvrez-le dans le navigateur, cliquez sur Exporter en PDF pour sauvegarder.

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

Renvoie le JSON brut des résultats pour une consommation programmatique.

`GET /api/health`

Vérification de santé — renvoie {"status": "healthy"}.

Variables d'environnement

Statut

Documentation

Contribuer

Les contributions sont les bienvenues. SecFlow est open source et activement maintenu.

Forkez aradhyacp/SecFlow
Créez une branche de fonctionnalité : git checkout -b feat/your-feature
Effectuez les modifications — consultez AGENTS.md pour les conventions d'architecture et les contrats de service
Ouvrez une pull request

Premières bonnes issues : Nouveaux modèles d'extraction IOC, améliorations des règles SIGMA, modules OSINT supplémentaires, pages d'analyse du frontend, améliorations de l'export de rapports.

Si SecFlow vous est utile dans votre travail ou votre recherche, envisagez de sponsoriser le projet — cela aide à maintenir l'infrastructure et le développement de la version gratuite.

Licence

Licence MIT — voir LICENSE pour les détails.

Conçu pour les analystes en sécurité qui ont besoin de réponses, pas de plus d'outils à jongler.

Si SecFlow vous aide, donnez-lui une étoile — cela aide d'autres à découvrir le projet.

github.com/aradhyacp/SecFlow

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

Routage piloté par IA	Groq `qwen/qwen3-32b` décide du prochain analyseur après chaque passage — aucune configuration manuelle
5 analyseurs spécialisés	Malware · Stéganographie · Reconnaissance · Vulnérabilité Web · Macro/Office
Premier passage intelligent	Règles déterministes `file` + `python-magic` au premier passage — l'IA n'est appelée que si le type est ambigu
Téléchargement et analyse	Suit les IOC — télécharge les charges utiles trouvées dans la sortie brute et les achemine vers le bon analyseur
Génération de règles YARA	Génère automatiquement 2 à 5 règles YARA déployables par analyse, chacune citant la preuve exacte qui l'a motivée
Génération de règles SIGMA	Génère automatiquement 2 à 4 règles SIGMA pour Splunk / Elastic / Sentinel — couvrant différentes sources de logs
Correspondance MITRE ATT&CK	Chaque résultat est associé à des identifiants TTP réels avec les noms des tactiques
Double format de rapport	Rapport HTML (impression au format PDF dans le navigateur) + rapport JSON structuré (à alimenter directement dans une IA pour une analyse plus poussée)
Tableau de bord React	Interface frontale complète — soumettez des analyses, visualisez l'avancement du pipeline en direct, parcourez les résultats par analyseur
Intégration VirusTotal	Les analyseurs Malware et Macro interrogent plus de 70 moteurs antivirus via l'API VT v3
Profondeur de boucle configurable	3, 4 ou 5 passages — sortie anticipée si l'IA signale l'absence de nouveaux signaux
Mode autonome	Chaque microservice d'analyseur expose sa propre API REST — utilisez-les indépendamment

`GROQ_API_KEY`	orchestrateur	✅	Routage IA + renseignement sur les menaces + génération de rapports
`VIRUSTOTAL_API_KEY`	malware, macro	✅	API VirusTotal v3 pour l'analyse de fichiers/URL
`NUMVERIFY_API_KEY`	recon	Optionnelle	Validation de numéro de téléphone (NumVerify)
`THREATFOX_API_KEY`	recon	Optionnelle	Limite de taux plus élevée sur les requêtes IOC de ThreatFox
`ipAPI_KEY`	recon	Optionnelle	Limite de taux plus élevée sur ip-api.com
`MAX_PASSES`	orchestrateur	Optionnelle	Profondeur de boucle — `3` (par défaut) / `4` / `5`

Orchestrateur + Classifieur + Moteur IA	✅ Terminé
Analyseur de malwares (Ghidra + VirusTotal)	✅ Terminé
Analyseur de stéganographie (binwalk + zsteg + steghide)	✅ Terminé
Analyseur de reconnaissance (ip-api + ThreatFox + OSINT)	✅ Terminé
Analyseur de vulnérabilités web	✅ Terminé
Analyseur de macros (oletools + VirusTotal)	✅ Terminé
Repli de téléchargement et analyse de la charge utile	✅ Terminé
Génération automatique de règles YARA	✅ Terminé
Génération automatique de règles SIGMA	✅ Terminé
Mappage des TTP MITRE ATT&CK	✅ Terminé
Rapport HTML + Rapport JSON + Export PDF	✅ Terminé
Tableau de bord React Frontend	✅ Terminé

AGENTS.md	Architecture des agents, contrats de service et instructions de codage IA
ProjectDetails.md	Spécification complète du projet et décisions de conception
docs/architecture.md	Diagrammes de composants système et de flux de données
docs/pipeline-flow.md	Logique détaillée de la boucle du pipeline et arbre de décision
docs/analyzers.md	Spécifications par analyseur : capacités et interface
docs/migration.md	Guide d'intégration pour les microservices d'analyseurs
backend/Readme.md	Configuration, développement et dépannage du backend

SecFlow

Populaires

SecFlow

Pipeline d'analyse de menaces multi-vecteurs entièrement automatisé

Qu'est-ce que SecFlow ?

Fonctionnalités

Architecture```

2. Configurer les variables d'environnement```bash

3. Démarrer tous les services```bash

5. Lancer le frontend```bash

Règles SIGMA SIEM

Image suspecte avec charge utile intégrée```

Structure du projet```

Référence de l'API

POST /api/smart-analyze

GET /api/report/<job_id>/html

GET /api/report/<job_id>/json

GET /api/health

Variables d'environnement

Statut

Documentation

Contribuer

Licence

`POST /api/smart-analyze`

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

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

`GET /api/health`