SecFlow

Pipeline de Análise de Ameaças Multivetorial Totalmente Automatizado

Insira qualquer arquivo, URL, IP, domínio ou imagem. O SecFlow o encaminha por analisadores especializados, raciocina sobre os resultados com IA e produz um relatório de segurança profissional com regras YARA, regras SIGMA e PDF exportável — automaticamente.

Quick Start · Architecture · Report Output · Docs

O que é o SecFlow?

O SecFlow é um pipeline de análise de ameaças automatizado e de código aberto criado para analistas de segurança, equipes de SOC e pesquisadores. Em vez de executar manualmente ferramentas distintas e correlacionar resultados, o SecFlow:

Classifica sua entrada usando regras determinísticas (sem IA na primeira passagem)
Encaminha para o analisador especializado correto por meio de microsserviços HTTP
Raciocina sobre os resultados de cada passagem com a IA Groq para decidir o próximo passo
Repete — seguindo IOCs, baixando payloads, fazendo pivô entre analisadores
Relata — gera um relatório HTML PWNDoc com regras de detecção YARA, regras SIEM SIGMA, mapeamentos MITRE ATT&CK e exportação em PDF com um clique

Recursos

Arquitetura```

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

---

## Início Rápido

### Pré-requisitos

- Docker + Docker Compose
- Chaves de API para Groq e VirusTotal (níveis gratuitos funcionam)

### 1. Clone o repositório```bash
git clone https://github.com/aradhyacp/SecFlow.git
cd SecFlow/backend

2. Configurar variáveis de ambiente```bash

cp .env.example .env

Edite `.env` com suas chaves:```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 os serviços```bash

docker compose up -d

Isto inicia 6 contentores:

| Serviço | Porta | Função |
|---|---|---|
| `orchestrator` | `5000` | Controlador do pipeline — ponto de entrada principal |
| `malware-analyzer` | `5001` | Decompilação Ghidra + VirusTotal |
| `steg-analyzer` | `5002` | binwalk + zsteg + steghide + ExifTool |
| `recon-analyzer` | `5003` | ip-api + ThreatFox + OSINT |
| `web-analyzer` | `5005` | Scanner de vulnerabilidades HTTP + auditoria de cabeçalhos |
| `macro-analyzer` | `5006` | oletools (olevba) + VirusTotal |

> **Nota:** A primeira inicialização pode levar vários minutos — o Malware Analyzer baixa o Ghidra 12.0.1 (~500 MB) e requer uma JVM JDK 21.

### 4. Execute sua primeira análise

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

Analise uma URL, IP ou domínio:```bash curl -X POST http://localhost:5000/api/smart-analyze
-H "Content-Type: application/json"
-d '{"target": "192.168.1.100", "passes": 3}'

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

Abra http://localhost:5000/api/report/<job_id>/html no seu navegador para visualizar o relatório completo e exportar para PDF.

5. Iniciar o frontend```bash

cd ../frontend npm install npm run dev

Abra `http://localhost:5173` — o painel React permite que você envie análises, acompanhe o progresso do pipeline em tempo real e navegue pelos resultados por analisador.

---

## Analisadores

### Analisador de Malware — Porta 5001

Analisa executáveis e binários com uma abordagem de três camadas:

- **Ghidra 12.0.1** (via `pyghidra`) — descompilação completa de todas as funções para pseudo-código C
- **`objdump -d`** — desmontagem em nível de assembly
- **VirusTotal API v3** — detecções de mais de 70 mecanismos AV, tags comportamentais, reputação de arquivo

**Suportados:** `exe`, `dll`, `so`, `elf`, `bin`, `o`, `out` · Máx. 50 MB · Requer 4 GB de RAM (JVM do Ghidra)

---

### Analisador de Esteganografia — Porta 5002

Detecta dados ocultos embutidos em imagens usando múltiplos métodos:

- **binwalk** — detecta e extrai arquivos embutidos em offsets binários
- **foremost** — recuperação de arquivos a partir de streams binários brutos
- **zsteg** — detecção de esteganografia LSB em PNG/BMP
- **steghide** — detecção de esteganografia baseada em senha em JPEG/BMP
- **ExifTool** — extração de metadados e detecção de anomalias

**Extrai arquivos compactados embutidos e os coloca na fila para re-análise** na próxima passagem do pipeline.

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

---

### Analisador de Reconhecimento — Porta 5003

Realiza inteligência de ameaças e OSINT em identificadores de rede:

**Modo de varredura** (IP / domínio):

| Módulo | Fonte | O que verifica |
|---|---|---|
| `ipapi` | ip-api.com | País, ISP, ASN, geolocalização |
| `talos` | Lista de bloqueio Cisco Talos | Reputação IP / lista negra |
| `tor` | Lista de saída do Projeto Tor | Detecção de nó de saída Tor |
| `tranco` | Lista de classificação Tranco | Rank de popularidade do domínio |
| `threatfox` | abuse.ch ThreatFox | IOC ativo / associação a malware |

**Modo de pegada digital** (e-mail / telefone / nome de usuário):
- **E-mail** — Banco de dados de violações do XposedOrNot (contagem de violações, gravidade, risco de senha)
- **Telefone** — Validação de operadora + país + tipo de linha do NumVerify
- **Nome de usuário** — Descoberta de perfil multithreaded do Sagemode em plataformas sociais

---

### Analisador de Vulnerabilidades Web — Porta 5005

Audita URLs e endpoints web:

- Análise de cabeçalhos de segurança (CSP, HSTS, X-Frame-Options, etc.)
- Identificação de tecnologia (servidor, frameworks, CMS)
- Análise de resposta HTTP e acompanhamento de cadeia de redirecionamentos
- Varredura básica de vulnerabilidades para configurações incorretas comuns

---

### Analisador de Macro / Office — Porta 5006

Disseca documentos do Office em busca de macros maliciosas:

- **oletools (olevba)** — extrai e descompila macros VBA/XLM
- **Detecção de AutoExec** — sinaliza macros que são executadas automaticamente ao abrir/fechar
- **Extração de IOC** — URLs, IPs, caminhos de arquivo embutidos no código da macro
- **Detecção de ofuscação** — Base64, cadeias Chr(), codificação hexadecimal
- **VirusTotal API v3** — verificação cruzada de reputação de arquivo

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

---

## Saída do Relatório

Cada execução do pipeline produz **dois formatos de relatório** salvos em `backend/reports/<job_id>/`:

### Relatório HTML (`report.html`)

Abra em qualquer navegador. Clique em **Exportar PDF** para imprimir — sem necessidade de renderização PDF no servidor, sem dependências.

Contém: resumo executivo · regras YARA · regras SIGMA · TTPs MITRE · painéis de evidências por passagem · selos de mecanismos VirusTotal.

### Relatório JSON (`report.json`)

Saída totalmente estruturada e legível por máquina. Use quando quiser:
- Alimentar descobertas diretamente em outro modelo de IA para análise mais aprofundada
- Ingerir em um SIEM ou sistema de tickets
- Comparar dois relatórios programaticamente
- Construir painéis personalizados

O JSON espelha exatamente o HTML — cada descoberta, regra YARA, regra SIGMA, IOC e TTP está presente em um esquema limpo e tipado.

Veja [`examples/`](https://github.com/aradhyacp/secflow/blob/main/examples) para arquivos de entrada de exemplo e [`example_reports`](https://github.com/aradhyacp/secflow/blob/main/example_reports) para saídas reais de relatórios gerados durante o desenvolvimento.

---

### Resumo Executivo
Narrativa escrita por IA (Groq `qwen/qwen3-32b`) cobrindo:
- Nome da ameaça identificada e classificação do tipo de ator
- Reconstrução da cadeia de ataque (passo a passo)
- Classificação de confiança e pontuação geral de risco

### Regras de Detecção YARA
**2–5 regras YARA prontas para produção** geradas por `llama-3.3-70b-versatile`, cada uma:
- Nomeada com a convenção `SecFlow_[CategoriaDaAmeaça]_[TipoDeIndicador]`
- Contendo sintaxe YARA 4.x válida — pronta para importar em qualquer scanner compatível com YARA
- Incluindo um campo `reasoning` citando a evidência exata da análise que fundamentou a regra
- Abrangendo aspectos distintos: assinaturas de arquivo, strings embutidas, indicadores C2, assinaturas de empacotadores, padrões de memória```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 Regras

2–4 regras SIGMA para implantação imediata em SIEM, cada:

- Cobrindo uma fonte de log diferente (process creation, network, DNS, file events, registry)
- Incluindo sintaxe SIGMA válida compatível com sigma-cli 0.x e pySigma
- Mapeando tags para táticas e IDs de técnicas reais do MITRE ATT&CK
- Importáveis para 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
Cada comportamento identificado mapeado para IDs reais de técnicas com nomes de táticas e raciocínio.

### Evidências por Passagem
Painéis recolhíveis para cada passagem do analisador mostrando:
- Saída de descompilação do Ghidra (bloco de código escuro, recolhível)
- Desmontagem do objdump (recolhível)
- Detecções do mecanismo VirusTotal (badges de gravidade codificados por cores)
- Resultados brutos do analisador em JSON

### Exportar PDF
Diálogo de impressão do navegador com um clique pré-configurado para exportação em PDF — nenhuma geração de PDF no lado do servidor necessária.

---

## Exemplos de Execuções do Pipeline
Arquivos de entrada de exemplo estão em [`examples/`](https://github.com/aradhyacp/secflow/blob/main/examples) — inclui amostras reais de malware (`RealMalware.exe`, `ColorBug.exe`, `EarlyEnd.exe`, binários ELF `.out`) e um documento malicioso do Office (`nuclear_motor_example.docm`). As saídas de relatório correspondentes estão em [`backend/reports/`](https://github.com/aradhyacp/secflow/blob/main/backend/reports).

### Documento Malicioso do 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

Imagem Suspeita com Payload Incorporado```

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)

### Domínio Suspeito```
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

Estrutura do Projeto```

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 usa **Groq** para toda inferência de IA — nível gratuito, sem necessidade de cartão de crédito.

| Função | Modelo | Motivo |
|---|---|---|
| **Roteamento de pipeline** | `qwen/qwen3-32b` | Saída JSON estruturada confiável; modo `/no_think` pula a cadeia de pensamento para decisões rápidas de roteamento |
| **Inteligência de ameaças** | `llama-3.3-70b-versatile` | Raciocínio mais forte para geração de YARA/SIGMA e mapeamento MITRE TTP |
| **Resumo de relatório** | `qwen/qwen3-32b` | Resumo executivo + recomendações |

SecFlow usa a **especificação de API compatível com OpenAI** através do SDK Python padrão `openai` — não é necessário SDK específico do fornecedor. Isto significa que você pode trocar para qualquer provedor de modelo compatível com OpenAI (OpenAI, Groq, Together, Ollama, etc.) alterando apenas a `base_url` e o nome do 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 que Groq + nível gratuito? O SecFlow foi construído para ser acessível — nenhuma API paga é necessária para executar todo o pipeline. O nível gratuito do Groq cobre todo o roteamento e geração de relatórios sem custo. Se você estiver executando cargas de trabalho mais pesadas ou quiser patrocinar o projeto, veja a página GitHub Sponsors.

Referência da API

Todas as requisições vão para o orquestrador em http://localhost:5000.

`POST /api/smart-analyze`

Envie um arquivo ou alvo para análise.

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

**Entrada alvo (URL / IP / domínio):**```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`

Retorna o relatório HTML completo do PWNDoc — abra no navegador, clique em Exportar PDF para salvar.

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

Retorna o JSON bruto dos achados para consumo programático.

`GET /api/health`

Verificação de saúde — retorna {"status": "healthy"}.

Variáveis de Ambiente

Status

Documentação

Contribuindo

Contribuições são bem-vindas. O SecFlow é open source e mantido ativamente.

Faça um fork do aradhyacp/SecFlow
Crie um branch de funcionalidade: git checkout -b feat/your-feature
Faça as alterações — consulte AGENTS.md para convenções de arquitetura e contratos de serviço
Abra um pull request

Boas primeiras issues: Novos padrões de extração de IOC, melhorias em regras SIGMA, módulos OSINT adicionais, páginas de analisador no frontend, melhorias na exportação de relatórios.

Se o SecFlow é útil para o seu trabalho ou pesquisa, considere patrocinar o projeto — ajuda a manter a infraestrutura gratuita e o desenvolvimento em andamento.

Licença

Licença MIT — veja LICENSE para detalhes.

Construído para analistas de segurança que precisam de respostas, não de mais ferramentas para gerenciar.

Se o SecFlow te ajuda, dê uma estrela — ajuda outros a descobrirem o projeto.

github.com/aradhyacp/SecFlow

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

Roteamento Orientado por IA	Groq `qwen/qwen3-32b` decide o próximo analisador após cada passagem — sem configuração manual
5 Analisadores Especializados	Malware · Esteganografia · Reconhecimento · Vulnerabilidade Web · Macro/Office
Primeira Passagem Inteligente	Regras determinísticas `file` + `python-magic` na primeira passagem — IA só é chamada quando o tipo é ambíguo
Baixar e Analisar	Segue IOCs — baixa payloads encontrados na saída bruta e os encaminha pelo analisador correto
Geração de Regras YARA	Gera automaticamente 2 a 5 regras YARA implantáveis por análise, cada uma citando a evidência exata que a motivou
Geração de Regras SIGMA	Gera automaticamente 2 a 4 regras SIGMA para Splunk / Elastic / Sentinel — cobrindo diferentes fontes de log
Mapeamento MITRE ATT&CK	Cada descoberta mapeada para IDs TTP reais com nomes de táticas
Formatos de Relatório Duplo	Relatório HTML (imprimir em PDF no navegador) + relatório JSON estruturado (alimentar diretamente a IA para análise adicional)
Painel React	Interface de usuário completa — enviar análises, visualizar progresso do pipeline em tempo real, navegar pelos resultados por analisador
Integração com VirusTotal	Tanto o analisador de Malware quanto o de Macro consultam mais de 70 mecanismos AV via API v3 do VT
Profundidade de Loop Configurável	3, 4 ou 5 passagens — sai mais cedo se a IA sinalizar que não há mais sinais
Modo Autônomo	Cada microsserviço analisador expõe sua própria API REST — use-os de forma independente

`GROQ_API_KEY`	orchestrator	✅	Roteamento de IA + inteligência de ameaças + geração de relatórios
`VIRUSTOTAL_API_KEY`	malware, macro	✅	Análise de arquivo/URL da API v3 do VirusTotal
`NUMVERIFY_API_KEY`	recon	Opcional	Validação de número de telefone (NumVerify)
`THREATFOX_API_KEY`	recon	Opcional	Limite de taxa mais alto em consultas de IOC do ThreatFox
`ipAPI_KEY`	recon	Opcional	Limite de taxa mais alto no ip-api.com
`MAX_PASSES`	orchestrator	Opcional	Profundidade do loop — `3` (padrão) / `4` / `5`

Orquestrador + Classificador + Motor de IA	✅ Completo
Analisador de Malware (Ghidra + VirusTotal)	✅ Completo
Analisador de Esteganografia (binwalk + zsteg + steghide)	✅ Completo
Analisador de Recon (ip-api + ThreatFox + OSINT)	✅ Completo
Analisador de Vulnerabilidades Web	✅ Completo
Analisador de Macros (oletools + VirusTotal)	✅ Completo
Fallback de download e análise de payload	✅ Completo
Geração Automática de Regras YARA	✅ Completo
Geração Automática de Regras SIGMA	✅ Completo
Mapeamento de TTPs MITRE ATT&CK	✅ Completo
Relatório HTML + Relatório JSON + Exportar PDF	✅ Completo
Painel Frontend React	✅ Completo

AGENTS.md	Arquitetura de agentes, contratos de serviço e instruções de codificação de IA
ProjectDetails.md	Especificação completa do projeto e decisões de design
docs/architecture.md	Diagramas de componentes do sistema e fluxo de dados
docs/pipeline-flow.md	Lógica detalhada do loop do pipeline e árvore de decisão
docs/analyzers.md	Especificação de capacidade e interface por analisador
docs/migration.md	Guia de integração para os microsserviços analisadores
backend/Readme.md	Guia de configuração, desenvolvimento e solução de problemas do backend

SecFlow

Mais Populares

SecFlow

Pipeline de Análise de Ameaças Multivetorial Totalmente Automatizado

O que é o SecFlow?

Recursos

Arquitetura```

2. Configurar variáveis de ambiente```bash

3. Iniciar todos os serviços```bash

5. Iniciar o frontend```bash

SIGMA SIEM Regras

Imagem Suspeita com Payload Incorporado```

Estrutura do Projeto```

Referência da API

POST /api/smart-analyze

GET /api/report/<job_id>/html

GET /api/report/<job_id>/json

GET /api/health

Variáveis de Ambiente

Status

Documentação

Contribuindo

Licença

`POST /api/smart-analyze`

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

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

`GET /api/health`