ethan-andrews/threatintel-aggregatorPlateforme de renseignement sur les menaces auto-hébergée — agrégation de flux, triage par IA, couverture MITRE ATT&CK et ingénierie de détection intégrée à Sentinel. Fonctionne de manière autonome ou entièrement intégrée à Azure.
Une plateforme de threat intelligence auto-hébergée qui agrège les flux RSS de plus de 60 fournisseurs de sécurité, exécute un triage par IA, corrèle les résultats avec votre inventaire d'actifs RunZero, et fait remonter des alertes exploitables via un tableau de bord web en mode sombre.
Conçue pour fonctionner de manière autonome sans aucune dépendance au cloud, ou entièrement intégrée dans un environnement Azure/Entra/Sentinel — choisissez le palier qui correspond à ce que vous avez.
| Palier | Script | Triage IA | Authentification | Stockage | Ce que vous obtenez |
|---|---|---|---|---|---|
| Basic | scripts/setup-basic.sh | Désactivé | Clé API locale | Postgres local (Docker) | Agrégation de flux, extraction d'IOC, matrice MITRE, tableaux de bord — pas d'IA, pas de cloud, rien à souscrire |
| Basic + API | scripts/setup-basic-api.sh | Anthropic (direct) | Clé API locale | Postgres local (Docker) | Tout ce qui précède, plus le triage IA de sévérité/TTP/résumé |
| Azure + API | scripts/setup-azure.ps1 | Azure AI Foundry | SSO Microsoft Entra ID | Votre propre Postgres (Azure DB for PostgreSQL, etc.) | Déploiement complet sur Azure Container Apps, SSO avec rôles par utilisateur. (L'intégration du pipeline detections.ai est prévue dans une future version — voir ci-dessous.) |
Les trois exécutent exactement le même code applicatif — la seule chose qui change est quelles variables d'environnement sont définies. Voir Environment Variables pour la référence complète.```bash
./scripts/setup-basic.sh
./scripts/setup-basic-api.sh
./scripts/setup-azure.ps1
Les deux scripts bash montent un conteneur Postgres local, appliquent le schéma et génèrent `backend/.env` / `frontend/.env.local` pour vous — puis affichent les deux commandes pour réellement démarrer l'application (`pip install` + exécution du backend, `npm install` + exécution du serveur de développement frontend). `setup-azure.ps1` est une fine enveloppe autour de `infra/provision.ps1`, le véritable runbook de déploiement Azure Container Apps.
---
## Fonctionnalités
- **Agrégation de flux** — interroge plus de 60 flux RSS de sécurité Tier 1/2/3 selon un planning ; déduplique et filtre automatiquement le contenu promotionnel
- **Triage par IA** — classe chaque entrée avec une sévérité (Critical/High/Medium/Low/Informational), les TTPs MITRE ATT&CK et un résumé en langage clair. Modulaire au niveau du fournisseur : API Anthropic directe ou Azure AI Foundry, commutable via une seule variable d'environnement sans perte de fonctionnalité dans un sens comme dans l'autre
- **Extraction d'IOC** — extrait automatiquement les IPs, domaines, URLs, hachages de fichiers et CVE de chaque entrée
- **Intégration RunZero** — synchronise votre inventaire d'actifs et corrèle le renseignement sur les menaces avec les actifs en production ; correspondance sur les CVE, noms de logiciels, versions d'OS et adresses IP. Trois sous-onglets sous `RUNZERO` : **Matches** (entrées corrélées à votre inventaire, filtrables par sévérité/date/confiance/KEV), **Exposure** (statut confirmé/possible au niveau de l'organisation avec suivi de remédiation) et **Metrics** (tendances d'entrée vs. remédiation dans le temps)
- **Your Stack** — définissez les logiciels/OS de votre environnement ; re-score toutes les entrées par pertinence
- **Registre d'IOC** — registre consultable de tous les indicateurs extraits avec références croisées vers les entrées et export STIX/CSV
- **Matrice MITRE ATT&CK** — heatmap de la couverture des TTPs sur l'ensemble du renseignement ingéré
- **Tableau de bord de santé des flux** — statut d'interrogation par flux, suivi des échecs consécutifs et volume d'articles sur 7 jours
- **Detections** — une surface de revue à 9 onglets (voir ci-dessous) couvrant tout ce qui est enregistré comme détection, qu'elle soit générée par IA, importée depuis vos propres fichiers ou synchronisée depuis un espace de travail Sentinel en production
- **Authentification modulaire** — SSO Microsoft Entra ID avec accès basé sur les rôles, ou une clé API locale partagée unique sans aucune dépendance Azure. Détectée automatiquement par le frontend ; voir [Modes d'authentification](#auth-modes)
### Deux fonctionnalités liées aux détections
Ce dépôt livre en réalité deux choses liées mais utilisables indépendamment sous l'ombrelle « detections » :
1. **L'onglet `DETECTIONS`** — une surface de revue autonome, divisée en neuf sous-onglets :
- **All Detections** — le catalogue complet des analytiques enregistrées, filtrable par technique/disposition/état de revue, chacune dépliable vers sa description et son KQL complet.
- **Defender Custom Detections** — le même catalogue, verrouillé sur les détections destinées aux règles de détection personnalisées de Microsoft Defender for Endpoint plutôt qu'aux règles analytiques Sentinel.
- **Alignment Reviews** — chaque fois qu'une analytique de détection est enregistrée contre une technique MITRE, une vérification par IA compare sa couverture réelle à la description que MITRE fait lui-même de cette technique. Lorsqu'elle diverge ou ne couvre que partiellement la technique, elle atterrit ici comme élément de revue humaine avec le raisonnement de l'IA, un correctif KQL suggéré et le propre résultat de validation de ce correctif (gate statique + backtest) — jamais une suggestion aveugle.
- **Disposition Alerts** — une file de détection de pourrissement : une analytique approuvée dont la télémétrie se dégrade ou dont la règle sous-jacente commence à produire des erreurs est signalée ici pour réexamen, nommée par sa propre détection plutôt que seulement par la technique MITRE partagée.
- **Generated Hunts** — les détections sont regroupées en hunts (un par fichier importé aujourd'hui ; un par article TI/détections.ai d'origine une fois cette intégration livrée), à l'image de la fonctionnalité Hunts de Microsoft Sentinel elle-même. Un hunt peut être synchronisé dans un véritable espace de travail Sentinel sous forme d'objet `Microsoft.SecurityInsights/hunts` plus ses requêtes de recherche enregistrées constitutives (contrôlé par `SENTINEL_HUNTING_SYNC_ENABLED` et un `mode` — off/manual/auto — configurable par équipe dans Settings > API Settings ; jamais de push automatique silencieux sauf si vous l'activez).
- **Sentinel Hunts** — l'inventaire en direct de ce qui est réellement déployé dans la fonctionnalité Hunting de votre espace de travail Sentinel, tiré directement d'ARM plutôt que de l'historique de synchronisation de cette application ; inclut des suggestions de test/ajustement par requête que vous pouvez appliquer ou rejeter sur place.
- **Sentinel Analytics Rules** — la même idée pour les Analytics Rules de Microsoft Sentinel (`Microsoft.SecurityInsights/alertRules`) — un type de ressource Sentinel distinct de Hunting, puisque ce sont elles qui déclenchent réellement des incidents/alertes selon un planning — avec le même workflow d'application/rejet des suggestions d'ajustement.
- **Local Detections** — voir [Fonctionner sans Sentinel ni fournisseur d'IA](#running-without-sentinel-or-an-ai-provider-local-detections-import) ci-dessous.
- **Audit Log** (admin uniquement) — un enregistrement inter-pipelines de chaque vérification que cette application a réellement exécutée : résultats de gate/control-probe des détections générées par IA, tentatives de synchronisation de hunts Sentinel et exécutions de tests de requêtes de hunt/règles analytiques Sentinel, combinés en une seule liste paginée et filtrable — couvrant délibérément ce qu'aucun onglet de revue ne fait à lui seul.
S'exécute entièrement dans le backend principal, aucun déploiement supplémentaire nécessaire pour la surface de revue elle-même. Sa propre conception d'API suit délibérément les conventions de detections.ai ci-dessous, même si elle est entièrement autonome.
2. **Orchestrateur de pipeline detections.ai — bientôt disponible.** detections.ai dispose d'une API publique en cours de développement pour la génération de détections assistée par IA, et ce dépôt a une véritable intégration construite pour elle (`backend/detection_pipeline/orchestrator.py`) qui prend le renseignement sur les menaces trié, le vérifie contre la couverture de détection existante et génère un brouillon de KQL pour votre espace de travail Sentinel en tant que tâche planifiée. Cette intégration prendra en charge cette API une fois disponible, et ne fait pas encore partie de cette version publique. En attendant, **vous n'en avez pas besoin pour utiliser l'onglet Detections** — [Local Detections Import](#running-without-sentinel-or-an-ai-provider-local-detections-import) ci-dessous couvre le même objectif « faire entrer de vraies détections dans cette application » pour les configurations sans génération IA et sans Sentinel dès aujourd'hui.
### Fonctionner sans Sentinel ni fournisseur d'IA : Local Detections Import
Vu le nom de l'application et son argument principal, la question la plus fréquente d'un auto-hébergeur sur le tier **Basic** sera probablement *« Je n'ai ni Sentinel ni fournisseur d'IA configuré — puis-je quand même tirer quelque chose des onglets Detections/Hunts ? »* La réponse est oui : pointez l'application vers un dossier de vos propres fichiers de règles de détection (écrits à la main, exportés d'un tenant Sentinel/Defender réel, ou tirés d'un dépôt public de règles Sigma/Sentinel) et elle les cataloguera, les taguera MITRE et les validera statiquement — aucune connexion Sentinel et aucune clé `DETECTIONS_AI_API_KEY`/Anthropic requise pour tout cela.
- **Formats pris en charge, dès le premier jour :** fichiers bruts `.kql`/`.txt`/`.yar`/`.spl`-ou-toute-extension, chacun éventuellement accompagné d'un sidecar `.json`/`.yaml` (`{"file": "myrule.kql", "title": "...", "description": "...", "technique_id": "T1059.001"}`) pour les métadonnées que l'export de Microsoft lui-même n'a pas besoin de déclarer séparément ; YARA ; Suricata ; Sigma YAML (mono- ou multi-document) ; Splunk SPL ; et le JSON natif exporté par Microsoft des Analytics Rule/Hunting Query (seules les règles de type `Scheduled` portent une requête KQL brute que cette application peut évaluer — tous les autres types sont reconnus et signalés, pas silencieusement ignorés).
- **Ce qui s'exécute réellement sur un fichier importé :** validation statique (le même moteur de durabilité/findings que celui utilisé par le chemin de génération IA) pour le contenu KQL ; une vérification d'alignement MITRE également, si vous *avez* un fournisseur d'IA configuré (un axe indépendant de Sentinel — vous pouvez avoir l'un, les deux, ou aucun) ; tout ce qui dépend de Sentinel (backtesting, sondes de télémétrie, suivi de disposition) reste hors périmètre et s'affiche comme « no Sentinel connection configured » plutôt qu'une cellule vide trompeuse.
- **Où cela apparaît :** le contenu importé devient une ligne hunt/détection normale — mêmes tableaux, même workflow de revue, même affichage des techniques MITRE que tout ce que génère le pipeline IA — il apparaît donc aussi dans les vues régulières `ALL DETECTIONS`/`GENERATED HUNTS`, pas seulement dans son propre onglet. Le sous-onglet dédié **Local Detections** (sous `DETECTIONS`, admin uniquement pour déclencher un import) est l'endroit où vous le pointez vers un dossier et suivez la progression/résultats par fichier.
- **Configuration :** définissez `LOCAL_IMPORT_DIR` sur un chemin absolu dans le système de fichiers du backend (un volume monté, dans un déploiement conteneurisé) — tout ce qui est importé doit résider sous cette racine ; l'UI vous laisse choisir un sous-chemin en dessous, jamais un emplacement arbitraire du système de fichiers. Voir [Variables d'environnement](#environment-variables).
- **Essayez-le immédiatement :** `examples/local-detections-samples/` livre un petit dossier prêt à importer — deux règles KQL valides (une accompagnée d'un sidecar `.json` pour montrer ce mécanisme), une règle délibérément invalide (pour voir la bannière signalée comme invalide) et un fichier non reconnu (pour voir la bannière d'échec d'import). Pointez `LOCAL_IMPORT_DIR` dessus pour voir les trois états de résultat dès votre tout premier import, sans écrire de règle.
**Local Detections** — une exécution d'import terminée : la bannière de résumé signale les fichiers catalogués mais marqués invalides par l'analyse statique (ici, une règle qui alerte sur un seul hachage codé en dur) aux côtés de ceux importés proprement, et chaque fichier devient une ligne hunt/détection normale ci-dessous
---
## Captures d'écran
Toutes les captures ci-dessous utilisent des données synthétiques (noms d'organisations fictifs, IPs d'exemple RFC 5737, domaines `.example`) générées pour la documentation — aucun renseignement réel sur les menaces ni donnée client.
**Feed** — parcourez et filtrez les entrées de renseignement sur les menaces triées avec sévérité, tags, IOCs et TTPs
<br>
**Dashboard** — répartition de la sévérité en un coup d'œil et principales techniques MITRE ATT&CK
<br>
**MITRE ATT&CK** — heatmap matricielle complète de la couverture des techniques sur le renseignement ingéré
<br>
**Your Stack** — définissez votre environnement ; les entrées de flux sont re-scorées par pertinence
<br>
**IOCs** — registre consultable de tous les indicateurs extraits avec export STIX/CSV
<br>
**Integrations** — vue d'ensemble des connecteurs pour Sentinel, Defender et RunZero : statut configuré/activé et raccourcis vers l'onglet propre à chacun
<br>
**RunZero** — corrélation d'actifs, suivi de l'exposition au niveau de l'organisation et métriques de remédiation, le tout issu de votre inventaire RunZero
<br>
**Exposure** — organisations classées par nombre de correspondances de menaces ; cliquez sur une carte pour voir les entrées correspondantes
<br>
**Detections** — le catalogue complet des analytiques enregistrées (générées par IA et importées localement), chacune avec son statut de gate statique/backtest/revue et sa technique MITRE
<br>
**Settings** — contrôles de triage IA, surveillance de la santé des flux, scores de confiance des sources et gestion des utilisateurs
---
## Architecture```
┌─────────────────────────────────────────┐
│ Next.js 16 frontend (port 3000) │
│ Tailwind CSS · dark theme │
└──────────────┬──────────────────────────┘
│ REST API (Bearer token)
┌──────────────▼──────────────────────────┐
│ FastAPI backend (port 8000) │
│ APScheduler · slowapi rate limiting │
└──┬──────────┬──────────┬────────────┬───┘
│ │ │ │
Postgres AI provider RunZero API detections.ai
(modular: (asset sync) (coming soon --
Anthropic or see Features below)
Azure AI Foundry)
Backend (backend/) — Python 3.12 + FastAPI. Postgres pour tout le stockage (SQLite et Azure Blob Storage ont été entièrement retirés). Le fournisseur d'IA et la méthode d'authentification sont tous deux sélectionnés par variable d'environnement, et non codés en dur — voir ci-dessous.
Frontend (frontend/) — Next.js 16, JavaScript simple, Tailwind CSS. Détecte automatiquement le mode d'authentification depuis le backend au chargement.
Infra (infra/) — Modèles Azure Bicep pour Container Apps, Key Vault et Container Registry (apps.bicep + platform.bicep + app-stack.bicep, déployés via provision.ps1). Pertinent uniquement pour le niveau Azure + API.
AZURE_AD_TENANT_ID défini → mode Entra : SSO Microsoft Entra ID, rôles par utilisateur (la première connexion devient admin, tous les autres sont par défaut viewer).
AZURE_AD_TENANT_ID non défini → mode Local : une seule LOCAL_API_KEY partagée accorde l'accès admin à quiconque la possède. Pas de gestion des utilisateurs, pas de dépendance Azure. Le frontend appelle GET /api/auth/mode au chargement et affiche automatiquement l'écran de connexion correspondant — rien à configurer côté frontend.
Les deux modes émettent ensuite le même type de JWT signé par l'application, de sorte que toutes les autres routes (require_auth/require_admin) fonctionnent de manière identique quel que soit le mode ayant émis le token.
Exécutez scripts/setup-basic.sh ou scripts/setup-basic-api.sh (voir Niveaux de déploiement) — ils gèrent Postgres et la génération du .env pour vous. Ensuite :```bash
cd backend && pip install -r requirements.txt && uvicorn main:app --reload --port 8000
cd frontend && npm install && npm run dev
### Configuration manuelle```bash
cd backend
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp env.example .env # fill in required values — see Environment Variables below
uvicorn main:app --reload --port 8000
Cloner le dépôt :
git clone https://github.com/yourusername/kitploit-tool.git
cd kitploit-tool
Créer un environnement virtuel (recommandé) :
python3 -m venv venv
source venv/bin/activate # Sur Windows : venv\Scripts\activate
Installer les dépendances :
pip install -r requirements.txt
Configurer l'outil :
cp config.example.yaml config.yaml
# Modifier config.yaml selon vos besoins
Vérifier l'installation :
python kitploit.py --version
# Afficher l'aide
python kitploit.py --help
# Lancer un scan basique
python kitploit.py scan --target example.com
# Scan avec options avancées
python kitploit.py scan --target example.com --deep --output results.json
| Option | Description | Valeur par défaut |
|---|---|---|
--target | Cible à analyser | Requis |
--deep | Activer l'analyse approfondie | false |
--output | Fichier de sortie | stdout |
--threads | Nombre de threads | 10 |
--timeout | Délai d'attente en secondes | 30 |
--verbose | Mode verbeux | false |
Analyse d'un domaine unique :
python kitploit.py scan --target example.com --output rapport.json
Analyse de plusieurs cibles :
python kitploit.py scan --targets targets.txt --threads 20
Analyse avec format de sortie personnalisé :
python kitploit.py scan --target example.com --format xml --output rapport.xml
Le fichier config.yaml permet de personnaliser le comportement de l'outil :
# Configuration générale
general:
timeout: 30
threads: 10
verbose: false
# Configuration des modules
modules:
port_scanner:
enabled: true
ports: "1-1000"
vulnerability_checker:
enabled: true
severity: "high,critical"
web_crawler:
enabled: false
max_depth: 3
# Configuration de la sortie
output:
format: "json"
directory: "./results"
timestamp: true
Le module de scan de ports permet d'identifier les services exposés sur une cible.
Fonctionnalités :
Utilisation :
python kitploit.py scan --target example.com --module port_scanner --ports 80,443,8080
Ce module analyse les services détectés pour identifier les vulnérabilités connues.
Fonctionnalités :
Utilisation :
python kitploit.py scan --target example.com --module vulnerability_checker --severity critical
Le crawler web explore les applications web pour découvrir des endpoints et des ressources.
Fonctionnalités :
Utilisation :
python kitploit.py scan --target https://example.com --module web_crawler --max-depth 5
``````bash
cd frontend
npm install
cp env.local.example .env.local # set NEXT_PUBLIC_API_URL=http://localhost:8000
npm run dev
cp backend/env.example backend/.env # fill in required values docker compose up --build
Frontend → http://localhost:3000
Backend API docs → http://localhost:8000/docs
---
## Variables d'environnement
Copiez `backend/env.example` vers `backend/.env` et remplissez-le. Regroupées selon le tier qui en a besoin :
**Toujours requises :**
| Variable | Description |
|----------|-------------|
| `PG_DSN` | Chaîne de connexion Postgres |
| `JWT_SECRET_KEY` | Secret pour signer les jetons de session de l'application (`python -c "import secrets; print(secrets.token_hex(32))"`) |
**Auth — choisissez un mode :**
| Variable | Description |
|----------|-------------|
| `LOCAL_API_KEY` | Mode local : clé partagée qui accorde l'accès admin. Laissez `AZURE_AD_TENANT_ID` non défini pour activer ce mode |
| `AZURE_AD_TENANT_ID` | Mode Entra : ID de tenant pour le SSO. Le définir active le mode Entra |
| `AZURE_AD_CLIENT_ID` | Mode Entra : ID client de l'enregistrement d'application |
| `AZURE_AD_CLIENT_SECRET` | Mode Entra : secret de l'enregistrement d'application (frontend uniquement) |
| `NEXTAUTH_SECRET` | Mode Entra : secret de chiffrement de session NextAuth (frontend uniquement) |
**Triage IA — facultatif, choisissez un fournisseur (omettez les deux pour exécuter avec le triage désactivé) :**
| Variable | Description |
|----------|-------------|
| `AI_PROVIDER` | `anthropic` (par défaut) ou `azure` |
| `ANTHROPIC_API_KEY` | Clé API Anthropic directe |
| `AZURE_FOUNDRY_ENDPOINT` | Point de terminaison Azure AI Foundry, par ex. `https://<resource>.services.ai.azure.com/anthropic` |
| `AZURE_FOUNDRY_API_KEY` | Clé API Azure AI Foundry |
| `AZURE_FOUNDRY_DEPLOYMENT` | Nom du déploiement Foundry (par défaut `claude-haiku-4-5`) |
| `AZURE_FOUNDRY_API_VERSION` | Version de l'API Foundry (par défaut `2025-05-01`) |
**Facultatives :**
| Variable | Description |
|----------|-------------|
| `RUNZERO_API_TOKEN` | Active la synchronisation et la corrélation des actifs RunZero |
| `ALLOWED_ORIGINS` | Liste d'autorisation CORS séparée par des virgules (par défaut `http://localhost:3000`) |
| `ENABLE_SCHEDULER` | Définir sur `false` pour désactiver le poller de flux en arrière-plan (par défaut `true`) |
| `ARCHIVE_AFTER_DAYS` | Seuil d'archivage automatique en jours (par défaut `90`) |
| `PG_POOL_MIN` / `PG_POOL_MAX` / `PG_POOL_TIMEOUT` | Réglage du pool de connexions Postgres (valeurs par défaut `1` / `10` / `30`) |
| `LOCAL_IMPORT_DIR` | Active [Local Detections Import](#running-without-sentinel-or-an-ai-provider-local-detections-import) — chemin absolu sur le système de fichiers du backend auquel chaque import est confiné. Non défini désactive entièrement la fonctionnalité (son onglet affiche un message « not configured ») |
**Frontend** (`frontend/.env.local` ou `frontend/env.local.example`) :
| Variable | Description |
|----------|-------------|
| `NEXT_PUBLIC_API_URL` | URL du backend telle que vue par le navigateur. Intégrée au bundle JS au moment de la compilation. Laissez **non défini** pour router les appels API via le proxy same-origin intégré (`frontend/pages/api/[...proxy].js`) à la place — requis chaque fois que le backend n'a pas d'ingress public (par ex. le Container App interne uniquement du tier Azure + API) |
| `BACKEND_URL` | URL du backend telle que vue par le serveur Next.js lui-même. Utilisée par l'échange de connexion de NextAuth et, lorsque `NEXT_PUBLIC_API_URL` n'est pas défini, par le proxy same-origin qui transmet côté serveur chaque requête navigateur `/api/*` |
**Orchestrateur detections.ai — bientôt disponible** (ne fait pas encore partie de cette version publique ; documenté ici pour sa sortie prochaine. Tier Azure + API, déployable séparé — voir `backend/detection_pipeline/orchestrator.py`) :
| Variable | Description |
|----------|-------------|
| `DETECTIONS_AI_API_KEY` | Requise pour exécuter l'orchestrateur |
| `SENTINEL_WORKSPACE_ID` | ID client (GUID) de l'espace de travail Log Analytics, pour le backtesting. Facultative |
| `PIPELINE_BATCH_SIZE` | Entrées par exécution (par défaut `5`) |
| `PIPELINE_DRY_RUN` | `true` pour revendiquer et journaliser sans appeler l'API |
| `PIPELINE_LANGUAGE` | Langage de requête de détection (par défaut `kql`) |
**Synchronisation Sentinel Hunts** (facultative, désactivée par défaut — voir Settings > API Settings pour le mode on/off/manual/auto) :
| Variable | Description |
|----------|-------------|
| `SENTINEL_HUNTING_SYNC_ENABLED` | `true` pour autoriser toute tentative de synchronisation de hunt. Non défini/false est un pur no-op — zéro appel ARM |
| `AZURE_SUBSCRIPTION_ID` | Abonnement contenant l'espace de travail Sentinel |
| `AZURE_RESOURCE_GROUP` | Groupe de ressources contenant l'espace de travail Sentinel |
| `SENTINEL_WORKSPACE_NAME` | Le **nom** de l'espace de travail, pas son ID client — une valeur différente de `SENTINEL_WORKSPACE_ID` ci-dessus, que le client data-plane de backtesting utilise à la place |
---
## Déploiement Azure
L'IaC réel et actuel est `infra/apps.bicep` + `infra/platform.bicep` + `infra/app-stack.bicep`, déployé via `infra/provision.ps1` (ou le wrapper léger `scripts/setup-azure.ps1`). Il provisionne les Container Apps, les secrets adossés à Key Vault et les identités managées — Postgres lui-même n'est pas provisionné par ce dépôt ; pointez `PG_DSN` (stocké comme secret Key Vault `pg-dsn`) vers n'importe quel serveur Postgres joignable.```powershell
./scripts/setup-azure.ps1
# or directly:
cd infra
cp migration.psd1.example migration.psd1 # fill in your resource group, apps, etc.
./provision.ps1
provision.ps1 est idempotent — il peut être réexécuté sans risque après modification du manifeste. Consultez son propre commentaire d'en-tête pour la procédure complète étape par étape (plateforme → pile applicative → secrets → Easy Auth → import d'image → applications → vérifications post-déploiement).
L'orchestrateur detections.ai (un Container Apps Job planifié piloté par un bloc Orchestrator dans migration.psd1 — voir migration.psd1.example pour la structure, et stockez votre clé comme secret Key Vault DETECTIONSAIAPIKEY) ne fait pas encore partie de cette version publique — voir Two detections-related features ci-dessus.
├── backend/ │ ├── main.py # FastAPI app, all endpoints │ ├── db.py # Postgres queries │ ├── pgcompat.py # connection pool + SQLite-style placeholder translation │ ├── feed_manager.py # RSS polling, AI triage (provider-modular), scheduler │ ├── enrichment.py # IOC extraction, KEV cache, stack rematch │ ├── runzero_sync.py # RunZero asset sync and correlation engine │ ├── dedup.py # CVE deduplication logic │ ├── auth.py # Entra ID SSO + local API-key auth, app JWT sign/verify │ ├── ioc_export.py # STIX 2.1 and CSV export │ ├── stack_presets.py # Pre-built tech stack templates │ ├── detection_pipeline/ # detections.ai orchestrator, MITRE alignment-check, │ │ # Sentinel hunts/analytics-rules sync + tuning, │ │ # audit log, local_import.py (Local Detections Import) │ └── tests/ # pytest test suite, incl. fixtures/local_import/ ├── frontend/ │ ├── pages/ │ │ ├── index.js # Main app shell + tab routing │ │ └── login.js # Entra ID or local API-key login, auto-detected │ ├── lib/ │ │ ├── authMode.js # GET /api/auth/mode, cached per page load │ │ ├── authFetch.js # Bearer auth + 401-retry wrapper │ │ └── authSession.js # token storage, JWT decode/expiry helpers │ └── components/ │ ├── layout/ # TopBar, Sidebar, TabBar, TopFilterBar, TimeRangeToggle │ ├── feed/ # FeedList, FeedCard │ ├── integrations/ # IntegrationsPanel, ExposurePanel, RunZeroPanel, │ │ # RunZeroMatchesPanel, RunZeroMetricsPanel │ ├── detections/ # DetectionsPanel (tab shell) + one component per │ │ # sub-tab: DetectionsCatalogPanel, AlignmentReviewPanel, │ │ # DispositionAlertsPanel, HuntsPanel, SentinelHuntsPanel, │ │ # SentinelAnalyticsRulesPanel, LocalDetectionsPanel, │ │ # AuditPanel, plus shared TuningSuggestionBadge │ ├── settings/ # SettingsPanel, CadencePicker, SeverityCards │ └── mitre/ # MitreMatrix ├── infra/ # Azure Bicep templates + provision.ps1 ├── scripts/ # Tiered setup scripts (see Deployment tiers) └── docker-compose.yml
---
## Sources de flux
63 flux répartis en trois niveaux :
- **Niveau 1** — CISA, Cisco Talos, Fortinet Threat Signal, ESET WeLiveSecurity, Microsoft Security Blog, SentinelOne Labs, Google Project Zero, Zero Day Initiative, Check Point Research, Talos Intelligence Blog, The DFIR Report, Oracle
- **Niveau 2** — Recorded Future, Malpedia, SANS ISC, Securelist, Unit42, Proofpoint TI, Malwarebytes TI, Wiz Blog, Datadog Security Labs, ReversingLabs, Sekoia, Cyble, ANY.RUN Blog, et plus
- **Niveau 3** — BleepingComputer, Krebs on Security, Schneier on Security, The Hacker News, Dark Reading, CrowdStrike Blog, Snyk, Semgrep, et plus
---
## Sécurité
- Tous les points de terminaison API exigent `Authorization: Bearer <token>`
- Comparaison de jetons à temps constant (`secrets.compare_digest`) pour la clé d'authentification locale
- SQL paramétré partout — aucune interpolation de chaîne dans les requêtes
- CORS restreint à une liste d'origines autorisées explicite
- Les entrées LLM sont assainies avant les appels au fournisseur d'IA ; les sorties sont validées avant stockage
- Les conteneurs s'exécutent en tant que non-root avec toutes les capacités Linux supprimées
- Aucun secret intégré dans les images — chargés à l'exécution depuis `.env` / Azure Key Vault
---
## Licence
MIT — voir [LICENSE](https://github.com/ethan-andrews/threatintel-aggregator/blob/main/LICENSE).