SecFlow

Pipeline di analisi delle minacce multi-vettore completamente automatizzata

Carica qualsiasi file, URL, IP, dominio o immagine. SecFlow lo instrada attraverso analizzatori specializzati, valuta i risultati con l'IA e produce un rapporto di sicurezza professionale con regole YARA, regole SIGMA e PDF esportabile — automaticamente.

Guida Rapida · Architettura · Output del Report · Documentazione

Cos'è SecFlow?

SecFlow è una pipeline automatizzata open-source per l'analisi delle minacce progettata per analisti di sicurezza, team SOC e ricercatori. Invece di eseguire manualmente strumenti disparati e correlare i risultati, SecFlow:

Classifica l'input utilizzando regole deterministiche (nessuna IA al primo passaggio)
Instrada attraverso l'analizzatore specializzato corretto tramite microservizi HTTP
Valuta i risultati di ogni passaggio con Groq AI per decidere il passo successivo
Ripete — seguendo gli IOC, scaricando payload, spostandosi tra gli analizzatori
Report — genera un report HTML PWNDoc con regole di rilevamento YARA, regole SIEM SIGMA, mapping MITRE ATT&CK ed esportazione PDF con un clic

Caratteristiche

Architettura```

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

---

## Avvio rapido

### Prerequisiti

- Docker + Docker Compose
- Chiavi API per Groq e VirusTotal (i livelli gratuiti funzionano)

### 1. Clona il repository```bash
git clone https://github.com/aradhyacp/SecFlow.git
cd SecFlow/backend

2. Configura le variabili d'ambiente```bash

cp .env.example .env

Modifica `.env` con le tue chiavi:```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. Avvia tutti i servizi```bash

docker compose up -d

Questo avvia 6 contenitori:

| Servizio | Porta | Ruolo |
|---|---|---|
| `orchestrator` | `5000` | Controllore della pipeline — punto di ingresso principale |
| `malware-analyzer` | `5001` | Decompilazione Ghidra + VirusTotal |
| `steg-analyzer` | `5002` | binwalk + zsteg + steghide + ExifTool |
| `recon-analyzer` | `5003` | ip-api + ThreatFox + OSINT |
| `web-analyzer` | `5005` | Scanner vulnerabilità HTTP + audit header |
| `macro-analyzer` | `5006` | oletools (olevba) + VirusTotal |

> **Nota:** Il primo avvio potrebbe richiedere diversi minuti — l'Analizzatore Malware scarica Ghidra 12.0.1 (~500 MB) e richiede una JVM JDK 21.

### 4. Esegui la tua prima analisi

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

Analizza un 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}'

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

Apri http://localhost:5000/api/report/<job_id>/html nel tuo browser per visualizzare il report completo ed esportarlo in PDF.

5. Avvia il frontend```bash

cd ../frontend npm install npm run dev

Open `http://localhost:5173` — la dashboard React consente di inviare analisi, monitorare l'avanzamento della pipeline in tempo reale e sfogliare i risultati per analizzatore.

---

## Analizzatori

### Analizzatore Malware — Porta 5001

Analizza eseguibili e binari con un approccio a tre livelli:

- **Ghidra 12.0.1** (tramite `pyghidra`) — decompilazione completa di tutte le funzioni in pseudo-codice C
- **`objdump -d`** — disassemblaggio a livello assembly
- **VirusTotal API v3** — rilevamenti da 70+ motori AV, tag comportamentali, reputazione del file

**Supportati:** `exe`, `dll`, `so`, `elf`, `bin`, `o`, `out` · Max 50 MB · Richiede 4 GB di RAM (JVM di Ghidra)

---

### Analizzatore Steganografia — Porta 5002

Rileva dati nascosti incorporati nelle immagini utilizzando molteplici metodi:

- **binwalk** — rileva ed estrae file incorporati a offset binari
- **foremost** — file carving da flussi binari grezzi
- **zsteg** — rilevamento steganografia LSB in PNG/BMP
- **steghide** — rilevamento steganografia basato su passphrase in JPEG/BMP
- **ExifTool** — estrazione metadati e rilevamento anomalie

**Estrae archivi incorporati e li mette in coda per una nuova analisi** nel successivo passaggio della pipeline.

**Supportati:** PNG, JPG, BMP, GIF, TIFF, WebP

---

### Analizzatore Ricognizione — Porta 5003

Esegue threat intelligence e OSINT su identificatori di rete:

**Modalità scansione** (IP / dominio):

| Modulo | Fonte | Cosa controlla |
|---|---|---|
| `ipapi` | ip-api.com | Paese, ISP, ASN, geolocalizzazione |
| `talos` | Cisco Talos blocklist | Reputazione IP / blacklist |
| `tor` | Tor Project exit list | Rilevamento nodo di uscita Tor |
| `tranco` | Tranco ranking list | Classifica popolarità dominio |
| `threatfox` | abuse.ch ThreatFox | Associazione IOC attivo / malware |

**Modalità impronta** (email / telefono / username):
- **Email** — database di violazioni XposedOrNot (numero di violazioni, gravità, rischio password)
- **Telefono** — validazione operatore + paese + tipo di linea NumVerify
- **Username** — scoperta multithread di profili Sagemode su piattaforme social

---

### Analizzatore Vulnerabilità Web — Porta 5005

Controlla URL e endpoint web:

- Analisi header di sicurezza (CSP, HSTS, X-Frame-Options, ecc.)
- Impronta tecnologica (server, framework, CMS)
- Analisi risposta HTTP e follow della catena di reindirizzamenti
- Scansione base delle vulnerabilità per configurazioni errate comuni

---

### Analizzatore Macro / Office — Porta 5006

Analizza documenti Office per macro dannose:

- **oletools (olevba)** — estrae e decompila macro VBA/XLM
- **Rilevamento AutoExec** — contrassegna macro che si avviano automaticamente all'apertura/chiusura
- **Estrazione IOC** — URL, IP, percorsi file incorporati nel codice macro
- **Rilevamento offuscamento** — Base64, catene Chr(), codifica esadecimale
- **VirusTotal API v3** — verifica incrociata reputazione file

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

---

## Output del Report

Ogni esecuzione della pipeline produce **due formati di report** salvati in `backend/reports/<job_id>/`:

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

Apri in qualsiasi browser. Clicca su **Esporta PDF** per stampare — nessun rendering PDF lato server necessario, nessuna dipendenza.

Contiene: sommario esecutivo · regole YARA · regole SIGMA · TTP MITRE · pannelli di evidenza per passaggio · badge motori VirusTotal.

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

Output completamente strutturato leggibile da macchina. Usalo quando vuoi:
- Inviare i risultati direttamente a un altro modello AI per un'analisi più approfondita
- Importare in un SIEM o sistema di ticketing
- Confrontare due report in modo programmatico
- Creare dashboard personalizzate

Il JSON rispecchia esattamente l'HTML — ogni risultato, regola YARA, regola SIGMA, IOC e TTP è presente in uno schema pulito e tipizzato.

Vedi [`examples/`](https://github.com/aradhyacp/secflow/blob/HEAD/examples/) per file di input di esempio e [`example_reports`](https://github.com/aradhyacp/secflow/blob/HEAD/example_reports/) per output di report reali generati durante lo sviluppo.

---

### Sommario Esecutivo
Narrativa scritta da AI (Groq `qwen/qwen3-32b`) che copre:
- Classificazione del nome della minaccia e del tipo di attore
- Ricostruzione della catena di attacco (passo dopo passo)
- Valutazione della confidenza e punteggio di rischio complessivo

### Regole di Rilevamento YARA
**2–5 regole YARA pronte per la produzione** generate da `llama-3.3-70b-versatile`, ciascuna:
- Denominate secondo la convenzione `SecFlow_[ThreatCategory]_[IndicatorType]`
- Contenenti sintassi YARA 4.x valida — pronte per essere importate in qualsiasi scanner compatibile con YARA
- Incluso un campo `reasoning` che cita l'esatta evidenza dall'analisi che ha informato la regola
- Coprendo aspetti distinti: firme di file, stringhe incorporate, indicatori C2, firme di packer, pattern di 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
}

Regole SIGMA SIEM

2–4 regole SIGMA per distribuzione immediata del SIEM, ciascuna:

Coprendo una diversa fonte di log (creazione di processi, rete, DNS, eventi di file, registro)
Inclusa sintassi SIGMA valida compatibile con sigma-cli 0.x e pySigma
Mappatura dei tag a tattiche e ID di tecniche MITRE ATT&CK reali
Importabili 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

### TTP di MITRE ATT&CK
Ogni comportamento identificato mappato a ID di tecniche reali con nomi di tattiche e motivazioni.

### Evidenze per Passaggio
Pannelli collassabili per ogni passaggio dell'analizzatore che mostrano:
- Output di decompilazione di Ghidra (blocco di codice scuro, collassabile)
- Disassemblaggio di objdump (collassabile)
- Rilevamenti dei motori VirusTotal (badge di gravità con codifica a colori)
- Risultati grezzi dell'analizzatore JSON

### Esporta PDF
Finestra di dialogo di stampa del browser con un clic preconfigurata per l'esportazione PDF — nessuna generazione PDF lato server necessaria.

---

## Esempi di Esecuzioni della Pipeline

I file di input di esempio si trovano in [`examples/`](https://github.com/aradhyacp/secflow/blob/HEAD/examples/) — includono campioni di malware reali (`RealMalware.exe`, `ColorBug.exe`, `EarlyEnd.exe`, binari ELF `.out`) e un documento Office malevolo (`nuclear_motor_example.docm`). I corrispondenti report di output si trovano in [`backend/reports/`](https://github.com/aradhyacp/secflow/blob/HEAD/backend/reports/).

### Documento Office Malevolo```
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

Immagine sospetta con payload incorporato```

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

Struttura del Progetto```

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

---

## Modelli AI

SecFlow utilizza **Groq** per tutte le inferenze AI — livello gratuito, nessuna carta di credito richiesta.

| Ruolo | Modello | Perché |
|---|---|---|
| **Routing del pipeline** | `qwen/qwen3-32b` | Output JSON strutturato affidabile; la modalità `/no_think` salta la catena di pensiero per decisioni di routing rapide |
| **Intelligence sulle minacce** | `llama-3.3-70b-versatile` | Ragionamento più forte per la generazione di YARA/SIGMA e mappatura MITRE TTP |
| **Sommario del report** | `qwen/qwen3-32b` | Riepilogo esecutivo + raccomandazioni |

SecFlow utilizza la **specifica API compatibile con OpenAI** tramite l'SDK Python standard `openai` — nessun SDK specifico del fornitore richiesto. Ciò significa che puoi scambiare qualsiasi provider di modelli compatibile con OpenAI (OpenAI, Groq, Together, Ollama, ecc.) cambiando solo `base_url` e il nome del modello:```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")

Perché Groq + livello gratuito? SecFlow è stato creato per essere accessibile — non è necessaria un'API a pagamento per eseguire l'intero flusso di lavoro. Il livello gratuito di Groq copre tutto il routing e la generazione dei report senza alcun costo. Se stai eseguendo carichi di lavoro più pesanti o vuoi sponsorizzare il progetto, consulta la pagina GitHub Sponsors.

Riferimento API

Tutte le richieste vanno all'orchestrator su http://localhost:5000.

`POST /api/smart-analyze`

Invia un file o un target per l'analisi.

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

**Input target (URL / IP / dominio):**```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`

Restituisce il report HTML completo di PWNDoc — aprilo nel browser, clicca su Esporta PDF per salvarlo.

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

Restituisce il JSON grezzo dei risultati per il consumo programmatico.

`GET /api/health`

Health check — restituisce {"status": "healthy"}.

Variabili d'Ambiente

Stato

Documentazione

Contribuire

I contributi sono benvenuti. SecFlow è open source e attivamente mantenuto.

Fork aradhyacp/SecFlow
Crea un branch per la funzionalità: git checkout -b feat/your-feature
Apporta modifiche — consulta AGENTS.md per convenzioni di architettura e contratti di servizio
Apri una pull request

Buoni primi problemi: Nuovi pattern di estrazione IOC, miglioramenti delle regole SIGMA, moduli OSINT aggiuntivi, pagine analizzatore frontend, miglioramenti dell'esportazione dei report.

Se SecFlow è utile per il tuo lavoro o ricerca, considera di sponsorizzare il progetto — aiuta a mantenere attive l'infrastruttura gratuita e lo sviluppo.

Licenza

Licenza MIT — consulta LICENSE per i dettagli.

Realizzato per analisti di sicurezza che hanno bisogno di risposte, non di altri strumenti da gestire.

Se SecFlow ti aiuta, dagli una stella — aiuta altri a scoprire il progetto.

github.com/aradhyacp/SecFlow

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

Routing basato su IA	Groq `qwen/qwen3-32b` decide l'analizzatore successivo dopo ogni passaggio — nessuna configurazione manuale
5 analizzatori specializzati	Malware · Steganografia · Ricognizione · Vulnerabilità Web · Macro/Office
Primo passaggio intelligente	Regole deterministiche di `file` + `python-magic` al passaggio 1 — L'IA viene chiamata solo quando il tipo è ambiguo
Download e analisi	Segue gli IOC — scarica i payload trovati nell'output grezzo e li instrada attraverso l'analizzatore corretto
Generazione di regole YARA	Genera automaticamente 2–5 regole YARA distribuibili per analisi, ciascuna citando l'esatta evidenza che l'ha motivata
Generazione di regole SIGMA	Genera automaticamente 2–4 regole SIGMA per Splunk / Elastic / Sentinel — coprendo diverse fonti di log
Mapping MITRE ATT&CK	Ogni risultato mappato a ID TTP reali con nomi di tattiche
Formati di report duali	Report HTML (stampa in PDF nel browser) + report JSON strutturato (alimentato direttamente all'IA per ulteriori analisi)
Dashboard React	Interfaccia utente completa — invia analisi, visualizza l'avanzamento della pipeline in tempo reale, sfoglia i risultati per analizzatore
Integrazione VirusTotal	Sia l'analizzatore Malware che Macro interrogano oltre 70 motori antivirus tramite API v3 VT
Profondità di loop configurabile	3, 4 o 5 passaggi — si ferma prima se l'IA segnala nessun ulteriore segnale
Modalità standalone	Ogni microservizio analizzatore espone la propria API REST — usali in modo indipendente

`GROQ_API_KEY`	orchestrator	✅	Routing AI + intelligence sulle minacce + generazione report
`VIRUSTOTAL_API_KEY`	malware, macro	✅	Analisi file/URL con VirusTotal API v3
`NUMVERIFY_API_KEY`	recon	Opzionale	Validazione numeri telefonici (NumVerify)
`THREATFOX_API_KEY`	recon	Opzionale	Limite di richieste più alto per query IOC su ThreatFox
`ipAPI_KEY`	recon	Opzionale	Limite di richieste più alto per ip-api.com
`MAX_PASSES`	orchestrator	Opzionale	Profondità del ciclo — `3` (default) / `4` / `5`

Orchestrator + Classifier + AI Engine	✅ Completato
Malware Analyzer (Ghidra + VirusTotal)	✅ Completato
Steg Analyzer (binwalk + zsteg + steghide)	✅ Completato
Recon Analyzer (ip-api + ThreatFox + OSINT)	✅ Completato
Web Vulnerability Analyzer	✅ Completato
Macro Analyzer (oletools + VirusTotal)	✅ Completato
Download-and-Analyze payload fallback	✅ Completato
Generazione automatica regole YARA	✅ Completato
Generazione automatica regole SIGMA	✅ Completato
Mappatura TTP MITRE ATT&CK	✅ Completato
Report HTML + Report JSON + Esportazione PDF	✅ Completato
Dashboard frontend React	✅ Completato

AGENTS.md	Architettura degli agenti, contratti di servizio e istruzioni di codifica AI
ProjectDetails.md	Specifica completa del progetto e decisioni di design
docs/architecture.md	Diagrammi dei componenti di sistema e del flusso di dati
docs/pipeline-flow.md	Logica dettagliata del ciclo della pipeline e albero decisionale
docs/analyzers.md	Specifiche delle capacità e interfaccia per ogni analizzatore
docs/migration.md	Guida all'integrazione per i microservizi degli analizzatori
backend/Readme.md	Guida alla configurazione, sviluppo e risoluzione dei problemi del backend

SecFlow

Più Popolari

SecFlow

Pipeline di analisi delle minacce multi-vettore completamente automatizzata

Cos'è SecFlow?

Caratteristiche

Architettura```

2. Configura le variabili d'ambiente```bash

3. Avvia tutti i servizi```bash

5. Avvia il frontend```bash

Regole SIGMA SIEM

Immagine sospetta con payload incorporato```

Struttura del Progetto```

Riferimento API

POST /api/smart-analyze

GET /api/report/<job_id>/html

GET /api/report/<job_id>/json

GET /api/health

Variabili d'Ambiente

Stato

Documentazione

Contribuire

Licenza

`POST /api/smart-analyze`

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

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

`GET /api/health`