Version: 1.0.0

Cert-IX MVP1 — Matrice de Conformité de Base (38 Services)

Date : 2026-02-22
Périmètre : Niveau minimum de conformité pour le lancement sur les flux critiques
Remédiation estimée : 2–4 jours (validé ci-dessous)

Table des Matières

Matrice de Conformité des Services (38 services)
Flux Critiques & Dépendances
Synthèse des Écarts P0/P1/P2
Plan de Remédiation par Flux
Stratégie de Tests E2E par Flux
Gel des Contrats d'Événements Kafka
Critères Go/No-Go
Calendrier

1. Matrice de Conformité des Services

Légende

Symbole	Signification
✅	Implémenté et vérifié
⚠️	Partiellement implémenté / nécessite un renforcement
❌	Manquant / non implémenté
N/A	Non applicable pour ce type de service

Dimensions de Conformité

#	Dimension	Code
A	Authentification/Autorisation & Contrôle d'Accès	`AUTHN`
B	Journalisation d'Audit (qui/quoi/quand + traceId)	`AUDIT`
C	Gestion des Secrets (aucun secret codé en dur)	`SECRETS`
D	Chiffrement en Transit (TLS) + au Repos	`CHIFFR`
E	Validation des Entrées/Assainissement + Limitation de Débit	`ENTREE`
F	Supervision/Alertes (santé, logs, APM)	`SUPERV`

1.1 Services d'Administration

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
1	admin-backend	P1	✅ JWT+Passport, RBAC via `rbac.service`, liste noire de tokens (Redis)	✅ Middleware `authAuditLogger`, `session.service.createAuditLog`, persisté en BDD	⚠️ Variables d'env via validation Joi ; `DB_SSL` par défaut `false`	⚠️ En-têtes Helmet ; `DB_SSL=false` par défaut ; cookie de session `secure` uniquement en prod	✅ Middleware Joi `validate` sur toutes les routes	⚠️ Logger Winston ; aucun agent APM détecté	Aucun	PG (cert_ix_admin), Redis, BDD auth, BDD assets, BDD messages
2	admin-ui	P1	✅ Auth JWT via API admin-backend	N/A (frontend)	✅ Aucun secret dans le code client	✅ HTTPS via Nginx/Kong	✅ DOMPurify, validation côté client	⚠️ Elastic APM RUM	Consommateur de l'API admin-backend	admin-backend

1.2 Services d'Authentification & d'Identité

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
3	qr-auth-service	P0	✅ JWT+session, CSRF (Redis), WebAuthn, MFA, empreinte appareil, liste noire tokens, détection bots, réputation IP	✅ Classe `AuditLogger` avec hachages inviolables (chaîne SHA-384), double écriture BDD+Kafka, tags conformité (SOC2/RGPD/PCI)	⚠️ Variables d'env ; `CSRF_ENCRYPTION_KEY` retombe sur `crypto.randomBytes` (éphémère)	⚠️ Kafka SSL configurable mais `ssl: process.env.KAFKA_SSL === 'true'` ; Redis TLS conditionnel	✅ Validation Joi, intégration CAPTCHA, validation email, patterns injection SQL, limitation de débit (BDD, 10 req/15min auth)	⚠️ Logs structurés ; pas d'APM	Producteur : 50+ topics (événements auth, CSRF, sessions, sécurité)	PG (cert_ix_auth), Redis, Kafka, captcha-service
4	qr-auth-ui	P1	✅ Interface connexion/inscription/2FA/WebAuthn	N/A (frontend)	✅ Aucun secret côté client	✅ HTTPS	✅ Validation côté client, DOMPurify	⚠️ Elastic APM RUM	N/A	qr-auth-service
5	otp-service	P0	✅ Auth JWT, support TOTP	✅ Événements d'audit Kafka	⚠️ Variables d'env via config	✅ Kafka TLS, Redis TLS configurable	✅ Limitation de débit (Redis)	⚠️ Logger uniquement	Producteur : événements OTP	PG, Redis, Kafka
6	captcha-service	P1	✅ Auth par clé API pour service-à-service	✅ Événements d'audit Kafka	⚠️ Variables d'env	✅ Kafka TLS, serveur TLS	✅ Validation de défi, limitation de débit	⚠️ Logger uniquement	Producteur : événements CAPTCHA	Redis, Kafka

1.3 Services Frontend Client

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
7	client-dashboard	P0	✅ AuthContext avec JWT, gestion de session, CapabilityGate (par niveau), navigation basée sur les permissions	N/A (frontend)	✅ Aucun secret ; stockage de token chiffré (CryptoJS)	✅ HTTPS, en-têtes de sécurité dans layout.js	✅ DOMPurify sur toutes les entrées, Joi côté client	✅ Elastic APM RUM	N/A	qr-auth-service, toutes les API backend via Kong
8	client-verifier-ui	P1	✅ Vérification d'email par token	N/A (frontend)	✅ Aucun secret	✅ HTTPS	✅ Validation des entrées	⚠️ Elastic APM RUM	N/A	qr-auth-service
9	payment-ui	P1	✅ Auth par session depuis le flux de paiement	N/A (frontend)	✅ Aucun secret ; Stripe.js gère PCI	✅ HTTPS, Stripe Elements (PCI DSS)	✅ Validation Zod	⚠️ Elastic APM RUM	N/A	checkout-orchestration, Stripe

1.4 Services de Gestion des Actifs

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
10	asset-management-service	P0	⚠️ Validation de permissions via Kafka (avec fallback auth) ; pas de middleware JWT direct	⚠️ Service d'événements de sécurité ; audit via événements Kafka sur CRUD	⚠️ Variables d'env ; service de chiffrement utilise une clé env	⚠️ Kafka TLS configurable ; `encryption.service.js` pour données au repos	⚠️ Limitation de débit dans la config ; validation dans les routes	⚠️ Logger uniquement	Producteur : événements CRUD actifs, sync quotas ; Consommateur : réponses permissions	PG (cert_ix_assets), Redis, Kafka
11	asset-verification-service	P1	✅ Middleware auth JWT (Go)	⚠️ Journalisation BDD des tentatives de vérification	⚠️ Variables d'env ; clé HMAC dans env	✅ Serveur TLS (Go), endpoints HTTPS	✅ Validation des entrées sur les requêtes de vérification	⚠️ Logs structurés Go	Producteur : événements de vérification	PG (cert_ix_asset_verification), Redis
12	assets-sync-service	P1	⚠️ Auth Kafka SCRAM pour le broker ; pas d'auth HTTP (interne)	❌ Aucune journalisation d'audit trouvée	⚠️ Variables d'env ; identifiants Kafka SCRAM	✅ Kafka TLS via config SCRAM	⚠️ Validateur de confiance pour l'intégrité des données	❌ Aucune supervision	Consommateur : événements actifs ; Producteur : événements de sync	PG, Kafka

1.5 Services de Vulnérabilités & Scan

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
13	vulnerability-management-service (Go)	P0	✅ Middleware auth JWT avec isolation par tenant	⚠️ Audit dans la couche service ; pas de table d'audit dédiée	⚠️ Variables d'env ; validation de config	✅ Serveur TLS, BDD TLS, Kafka TLS	✅ Validation des requêtes, middleware de sécurité (CORS, en-têtes)	⚠️ Logs structurés Go	Producteur : événements vulnérabilités ; Consommateur : événements scan, réponses capacités	PG (cert_ix_vulnerabilities), Redis, Kafka, ES
14	vulnerability-classifier-service (Go)	P1	✅ Middleware auth JWT	⚠️ Suivi des scans via Redis	⚠️ Variables d'env	✅ TLS configurable	⚠️ Validation basique	⚠️ Logs Go	Consommateur : résultats de scan ; Producteur : vulnérabilités classifiées	PG (cert_ix_vuln_classifier), Redis, Kafka
15	vulnerability-policy-service (Go)	P1	✅ Middleware auth JWT	⚠️ Audit au niveau config	⚠️ Variables d'env	✅ TLS configurable	⚠️ Validation de modèle	⚠️ Logs Go	Consommateur : événements vulnérabilités ; Producteur : décisions de politique	PG (cert_ix_vuln_policy), Redis, Kafka
16	vulnerability-remediation-service (Go)	P1	✅ Middleware auth JWT	⚠️ Audit au niveau config	⚠️ Variables d'env	✅ TLS configurable	✅ Validation de modèle, validation middleware auth	⚠️ Logs Go	Consommateur : événements vulnérabilités ; Producteur : tâches de remédiation	PG (cert_ix_vuln_remediation), Redis, Kafka
17	go-tools (9 moteurs de scan)	P0	✅ Middleware auth JWT (`pkg/middleware/auth.go`)	✅ `pkg/scanner/audit.go` — piste d'audit des scans avec rétention	⚠️ Variables d'env via config	✅ Serveur TLS, ES TLS	✅ Limitation de débit (Redis), validation des entrées	⚠️ Logs Go	Producteur : résultats de scan ; Consommateur : requêtes de scan	PG (cert_ix_tools_service), Redis, Kafka, ES
18	scan-api-service (Go)	P0	✅ Auth JWT + auth par clé API (`api_key_service`)	✅ Dépôt de journaux d'appels pour audit API	⚠️ Variables d'env	✅ TLS, Kafka TLS	✅ Validation, limitation de débit	⚠️ Logs Go	Producteur : dispatch de scans vers les moteurs	PG, Redis, Kafka
19	scan-worker-service (Go)	P1	❌ Service interne, pas d'auth HTTP (consommateur Kafka uniquement)	❌ Aucune journalisation d'audit	⚠️ Variables d'env	⚠️ Kafka TLS configurable	❌ Pas de validation d'entrée HTTP (Kafka uniquement)	❌ Aucune supervision	Consommateur : tâches de scan ; Producteur : résultats de scan	Kafka

1.6 Services de Conformité & Audit

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
20	compliance-guard-service	P1	❌ Aucun middleware d'auth trouvé	❌ Aucune journalisation d'audit	❌ Aucune gestion des secrets	❌ Aucune config TLS	❌ Aucune validation	❌ Aucune supervision	N/A	asset-verification-service
21	compliance-management-service (Go)	P1	⚠️ Références auth dans la couche service	✅ Journal d'activité dans le service, producteur Kafka	⚠️ Variables d'env	✅ TLS configurable	✅ Validation au niveau dépôt	⚠️ Logs Go	Producteur : événements de conformité	PG, Redis, Kafka
22	compliance-management-service (Node, inutilisé)	P2	❌ Non utilisé	❌ Non utilisé	❌ Non utilisé	❌ Non utilisé	❌ Non utilisé	❌ Non utilisé	N/A	N/A
23	audit-evidence-service	P1	⚠️ Middleware de déchiffrement PQC uniquement	⚠️ Audit dans le middleware	❌ Aucune gestion des secrets	❌ Aucune config TLS	❌ Aucune validation	❌ Aucune supervision	N/A	PG

1.7 Services de Paiement

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
24	payment-processing-service (Go)	P0	✅ Middleware auth, vérification d'existence utilisateur	❌ Aucune journalisation d'audit trouvée	⚠️ Variables d'env ; Vault AppRole configuré mais non intégré dans le code	✅ Serveur TLS, BDD TLS, Redis TLS, Kafka TLS	✅ Middleware de limitation de débit, validation OTP	⚠️ Logs Go	Producteur : événements de paiement ; Consommateur : événements OTP	PG, Redis, Kafka, Stripe
25	checkout-orchestration-service (Go)	P0	⚠️ Auth au niveau config ; pas de middleware JWT sur les routes	⚠️ Événements d'audit Kafka	⚠️ Variables d'env ; Vault configuré mais non intégré	✅ TLS, BDD TLS, Kafka TLS, Redis TLS	✅ Limitation de débit (Redis), validation du checkout	⚠️ Logs Go	Producteur : événements checkout ; Consommateur : données de plans	PG, Redis, Kafka
26	invoice-service (Go)	P1	❌ Aucun middleware d'auth trouvé	❌ Aucune journalisation d'audit	⚠️ Variables d'env ; Vault configuré mais non intégré	✅ Serveur TLS, BDD TLS	❌ Pas de limitation de débit, pas de validation d'entrée	❌ Aucune supervision	Consommateur : événements de paiement ; Producteur : événements de facturation	PG, Kafka, R2 (Cloudflare)
27	account-provisioning-service (Go)	P1	⚠️ Auth dans le service de provisionnement	❌ Aucune journalisation d'audit	⚠️ Variables d'env ; Vault configuré mais non intégré	✅ Serveur TLS, BDD TLS	❌ Pas de limitation de débit	❌ Aucune supervision	Consommateur : événements d'abonnement ; Producteur : événements de provisionnement	PG (cert_ix_subscription), Kafka

1.8 Services Agent & Télémétrie

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
28	agent-gateway-service (Go)	P1	✅ Auth d'enregistrement agent, JWT	✅ Audit dans le service agent + dépôt	⚠️ Variables d'env	✅ TLS, Kafka TLS	✅ Validation, limitation de débit	⚠️ Logs Go	Producteur : événements agent	PG, Redis, Kafka
29	agent-ingestion-gateway (Go)	P1	⚠️ Auth au niveau config	⚠️ Audit au niveau config	⚠️ Variables d'env	✅ TLS configurable	⚠️ Validation au niveau config	⚠️ Logs Go	Producteur : télémétrie vers Kafka	Kafka, Redis
30	agent-stream-processor (Go)	P2	❌ Pas d'auth (consommateur Kafka interne)	⚠️ Audit dans les processeurs	⚠️ Variables d'env	✅ TLS configurable	⚠️ Validation au niveau config	⚠️ Logs Go	Consommateur : télémétrie ; Producteur : données traitées	PG, Kafka, Redis
31	bits (bitcollector + sentinel)	P2	⚠️ mTLS pour agent-vers-gateway ; sentinel a auth ES	⚠️ Sentinel a un audit basé sur ES	⚠️ Variables d'env + config YAML	⚠️ TLS configurable pour connexions ES	⚠️ Validation basique	❌ Aucune supervision	Agent → Gateway (HTTP)	agent-gateway, ES

1.9 Services de Support

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
32	email-service	P0	⚠️ Auth Kafka pour le broker ; pas d'auth HTTP (interne)	✅ Journalisation d'audit email, config de sécurité	⚠️ Variables d'env ; clé API SendGrid dans env	✅ Serveur TLS, Kafka TLS	✅ Limitation de débit, validation de sécurité email	⚠️ Logger	Consommateur : événements auth, réinitialisation mot de passe, plan gratuit, etc.	Kafka, SendGrid, PG
33	notification-service	P1	⚠️ Middleware de déchiffrement PQC uniquement	⚠️ Audit dans le middleware	❌ Aucune gestion des secrets	❌ Aucune config TLS trouvée	❌ Pas de limitation de débit	❌ Aucune supervision	Consommateur : événements de notification	Kafka
34	bobby-service	P2	❌ Aucune auth trouvée	❌ Aucun audit	❌ Aucune gestion des secrets	❌ Pas de TLS	❌ Aucune validation	❌ Aucune supervision	N/A	API IA/LLM
35	nvd-service	P2	❌ Aucune auth trouvée	❌ Aucun audit	❌ Aucune gestion des secrets	❌ Pas de TLS	❌ Aucune validation	❌ Aucune supervision	N/A	API NVD
36	subscription-service (Go)	P0	✅ Auth JWT, isolation par tenant	✅ Suivi d'utilisation, audit dans les services	⚠️ Variables d'env	✅ TLS, BDD TLS, Kafka TLS, Redis TLS	✅ Validation, limitation de débit	⚠️ Logs Go	Producteur : réponses capacités, événements quotas ; Consommateur : requêtes capacités, plan gratuit, sync quotas	PG (cert_ix_subscription), Redis, Kafka
37	teams-management-service (Go)	P1	✅ Auth JWT	⚠️ Champs d'audit au niveau modèle	⚠️ Variables d'env	✅ TLS configurable	⚠️ Validation de modèle	⚠️ Logs Go	Producteur : événements d'équipe	PG, Redis, Kafka
38	quota-sync-service (Go)	P1	❌ Pas d'auth (consommateur Kafka interne)	❌ Aucune journalisation d'audit	⚠️ Variables d'env	⚠️ Kafka TLS configurable	❌ Pas de validation (interne)	❌ Aucune supervision	Consommateur : événements sync quotas ; Producteur : sync quotas abonnement	PG, Kafka

1.10 Services Statiques/Contenu

#	Service	Criticité	A:AUTHN	B:AUDIT	C:SECRETS	D:CHIFFR	E:ENTREE	F:SUPERV	Rôle Kafka	Dépendances
—	docs (Docusaurus)	P2	N/A (statique)	N/A	N/A	✅ HTTPS via Nginx	N/A	⚠️ APM RUM	N/A	Nginx
—	cert-ix-blog	P2	⚠️ Connexion admin pour gestion du blog	❌ Aucun audit	⚠️ Variables d'env	✅ HTTPS	⚠️ Validation basique	⚠️ APM RUM	N/A	MongoDB
—	cert-ix-v1-landing-site-v1	P2	N/A (statique + API messages)	❌ Aucun audit	⚠️ Variables d'env	✅ HTTPS	⚠️ Validation basique	⚠️ APM RUM	N/A	PG (API messages)

2. Flux Critiques & Dépendances

Flux 1 : Inscription & Connexion Utilisateur (P0)

client-dashboard → qr-auth-ui → qr-auth-service → captcha-service
                                       ↓
                              PG (cert_ix_auth) + Redis
                                       ↓
                              Kafka → email-service (email de vérification)
                              Kafka → subscription-service (activation plan gratuit)
                              Kafka → account-provisioning-service (configuration tenant)

Services : qr-auth-service, qr-auth-ui, client-dashboard, captcha-service, email-service, subscription-service, account-provisioning-service
Topics Kafka : cert-ix.auth.user.registered.success, cert-ix.subscription.plan.free.request, cert-ix.subscription.plan.free.activated

Flux 2 : Scan de Vulnérabilités (P0)

client-dashboard → Kong → scan-api-service → Kafka → go-tools (9 moteurs)
                                                         ↓
                                              Kafka → vulnerability-management-service
                                                         ↓
                                              Kafka → vulnerability-classifier-service
                                              Kafka → vulnerability-remediation-service
                                              Kafka → vulnerability-policy-service

Services : client-dashboard, scan-api-service, go-tools, vulnerability-management-service, vulnerability-classifier-service
Topics Kafka : cert-ix.scans.{engine}.{priority}, cert-ix.scan-results, cert-ix.scans.events

Flux 3 : Gestion des Actifs (P0)

client-dashboard → Kong → asset-management-service → Kafka (vérification permissions)
                                       ↓
                              PG (cert_ix_assets) + Redis
                                       ↓
                              Kafka → quota-sync-service → subscription-service
                              Kafka → assets-sync-service

Services : client-dashboard, asset-management-service, quota-sync-service, subscription-service, assets-sync-service
Topics Kafka : cert-ix.asset.created/updated/deleted, cert-ix.quota.sync.assets

Flux 4 : Paiement & Abonnement (P0)

client-dashboard → payment-ui → checkout-orchestration-service → payment-processing-service → Stripe
                                                                          ↓
                                                               Kafka → invoice-service
                                                               Kafka → account-provisioning-service
                                                               Kafka → subscription-service

Services : payment-ui, checkout-orchestration-service, payment-processing-service, invoice-service, account-provisioning-service, subscription-service
Topics Kafka : cert-ix.payment.*, cert-ix.checkout.*, cert-ix.subscription.*

Flux 5 : Conformité & Audit (P1)

client-dashboard → Kong → admin-backend → compliance-management-service (Go)
                                       → audit-evidence-service
                                       → compliance-guard-service → asset-verification-service

Services : admin-backend, compliance-management-service, audit-evidence-service, compliance-guard-service, asset-verification-service

Flux 6 : Télémétrie Agent (P2)

bits (bitcollector) → agent-gateway-service → agent-ingestion-gateway → Kafka → agent-stream-processor → PG

Services : bits, agent-gateway-service, agent-ingestion-gateway, agent-stream-processor

3. Synthèse des Écarts P0/P1/P2

P0 — BLOQUANT (À corriger impérativement avant le lancement)

ID	Service	Type d'Écart	Description	Effort
P0-01	asset-management-service	AUTHN	Pas de middleware JWT direct — repose sur une vérification de permissions Kafka avec fallback qui accorde l'accès quand Kafka est indisponible	4h
P0-02	asset-management-service	AUDIT	Pas de piste d'audit structurée avec traceId/correlationId	4h
P0-03	checkout-orchestration-service	AUTHN	Pas de middleware JWT sur les routes HTTP ; auth au niveau config uniquement	3h
P0-04	payment-processing-service	AUDIT	Aucune journalisation d'audit pour les opérations de paiement (exigence PCI DSS)	4h
P0-05	email-service	AUTHN	Pas d'auth HTTP (service interne) — nécessite une auth service-à-service ou une vérification d'isolation réseau	2h
P0-06	admin-backend	CHIFFR	`DB_SSL` par défaut à `false` — doit être `true` par défaut en production	1h
P0-07	Tous les services Go	SECRETS	Tous utilisent directement les variables d'env — vérifier qu'aucun secret n'est codé en dur dans docker-compose ou .env commité dans git	2h
P0-08	Tous les services	SUPERV	Pas de tableau de bord centralisé de vérification de santé ; la plupart des services ont des endpoints de santé mais pas d'alertes	4h
P0-09	scan-worker-service	AUDIT	Aucune journalisation d'audit — l'exécution des scans doit être auditable	3h
P0-10	qr-auth-service	SECRETS	`CSRF_ENCRYPTION_KEY` retombe sur `crypto.randomBytes` éphémère — doit être une variable d'env persistante	1h

P1 — IMPORTANT (À corriger pour le lancement, peut être reporté à J+2 si bloqué)

ID	Service	Type d'Écart	Description	Effort
P1-01	compliance-guard-service	AUTHN	Pas d'auth, pas d'audit, pas de TLS, pas de validation — le service entier nécessite une base de sécurité	6h
P1-02	audit-evidence-service	AUTHN	Uniquement middleware PQC ; pas d'auth JWT, pas de validation, pas de TLS	4h
P1-03	notification-service	AUTHN	Uniquement middleware PQC ; pas d'auth, pas de TLS, pas de limitation de débit	4h
P1-04	invoice-service	AUTHN	Pas de middleware d'auth, pas d'audit, pas de limitation de débit, pas de validation d'entrée	4h
P1-05	account-provisioning-service	AUDIT	Pas de journalisation d'audit pour le provisionnement de tenant	3h
P1-06	assets-sync-service	AUDIT	Pas de journalisation d'audit pour les opérations de synchronisation	2h
P1-07	quota-sync-service	AUDIT	Pas de journalisation d'audit, pas de supervision	2h
P1-08	admin-backend	ENTREE	Pas de middleware de limitation de débit (uniquement au niveau session)	3h
P1-09	Tous les services Node.js	CHIFFR	Les valeurs par défaut Kafka SSL et Redis TLS varient — nécessitent des valeurs par défaut uniformes à `true`	3h
P1-10	Intégration Vault	SECRETS	Vault AppRole configuré pour les services de paiement mais NON intégré dans le code Go — utilise toujours les variables d'env	8h

P2 — POST-MVP

ID	Service	Type d'Écart	Description	Effort
P2-01	bobby-service	TOUT	Aucune base de sécurité — service assistant IA	8h
P2-02	nvd-service	TOUT	Aucune base de sécurité — récupérateur de données CVE	4h
P2-03	agent-stream-processor	AUTHN	Pas d'auth (consommateur Kafka interne)	2h
P2-04	bits	SUPERV	Pas de supervision/alertes pour l'agent	2h
P2-05	cert-ix-blog	AUDIT	Pas de journalisation d'audit pour les actions admin	2h
P2-06	compliance-management-service (Node)	TOUT	Inutilisé — devrait être supprimé ou marqué comme obsolète	1h
P2-07	Tous les services	SUPERV	Agent APM manquant dans la plupart des services backend	8h

4. Plan de Remédiation par Flux

Flux 1 : Inscription & Connexion — Jour 1 (8h)

Tâche	Service	ID Écart	Effort	Responsable
Corriger CSRF_ENCRYPTION_KEY pour exiger une variable d'env	qr-auth-service	P0-10	1h	—
Vérifier que email-service est isolé réseau ou ajouter auth service	email-service	P0-05	2h	—
Vérifier l'absence de secrets codés en dur dans docker-compose/.env	Tout le flux auth	P0-07	2h	—
Ajouter des alertes de vérification de santé pour les services du flux auth	qr-auth, captcha, email	P0-08	3h	—

Test de fumée : Inscription → vérification email → connexion → obtention JWT → accès tableau de bord → déconnexion

Flux 2 : Scan de Vulnérabilités — Jour 1-2 (10h)

Tâche	Service	ID Écart	Effort	Responsable
Ajouter la journalisation d'audit au scan-worker-service	scan-worker-service	P0-09	3h	—
Vérifier la complétude de la piste d'audit du scan-api-service	scan-api-service	—	2h	—
Ajouter des alertes de vérification de santé pour le flux scan	go-tools, scan-api	P0-08	2h	—
Vérifier que Kafka TLS est appliqué pour les topics de scan	Tous les services de scan	P1-09	3h	—

Test de fumée : Créer un scan → dispatch vers le moteur → obtenir les résultats → visualiser dans le tableau de bord

Flux 3 : Gestion des Actifs — Jour 2 (8h)

Tâche	Service	ID Écart	Effort	Responsable
Ajouter un middleware JWT à asset-management-service	asset-management-service	P0-01	4h	—
Ajouter une journalisation d'audit structurée avec traceId	asset-management-service	P0-02	4h	—

Test de fumée : CRUD actif → vérification de propriété → sync quotas → mise à jour abonnement

Flux 4 : Paiement & Abonnement — Jour 2-3 (11h)

Tâche	Service	ID Écart	Effort	Responsable
Ajouter un middleware JWT aux routes checkout-orchestration	checkout-orchestration	P0-03	3h	—
Ajouter la journalisation d'audit à payment-processing-service	payment-processing	P0-04	4h	—
Corriger la valeur par défaut DB_SSL à true dans admin-backend	admin-backend	P0-06	1h	—
Ajouter auth + audit à invoice-service	invoice-service	P1-04	3h	—

Test de fumée : Sélection du plan → checkout → paiement Stripe → facture générée → abonnement actif

Flux 5 : Conformité & Audit — Jour 3 (6h)

Tâche	Service	ID Écart	Effort	Responsable
Ajouter une base de sécurité au compliance-guard-service	compliance-guard	P1-01	6h	—

Test de fumée : Lancer une vérification de conformité → visualiser les résultats → exporter les preuves

Transversal — Jour 3-4 (8h)

Tâche	Périmètre	ID Écart	Effort	Responsable
Uniformiser les valeurs par défaut Kafka SSL + Redis TLS	Tous les services	P1-09	3h	—
Ajouter la limitation de débit à admin-backend	admin-backend	P1-08	3h	—
Tableau de bord centralisé de vérification de santé	Tous les services P0	P0-08	2h	—

5. Stratégie de Tests E2E par Flux

Principe : Tester par flux, pas par service

Chaque flux dispose d'un script de test de fumée qui valide la chaîne complète de bout en bout.

Flux 1 : Test E2E Auth

# scripts/e2e/test-auth-flow.sh
# 1. Obtenir le token CSRF
# 2. Obtenir le défi CAPTCHA
# 3. Inscrire l'utilisateur (POST /api/v1/register/individual)
# 4. Vérifier l'email (GET /api/v1/register/verify-email/:token)
# 5. Se connecter (POST /api/v1/auth/login)
# 6. Vérifier que le JWT fonctionne (GET /api/v1/auth/check-session)
# 7. Vérifier l'activation de l'abonnement (GET /api/v1/subscriptions/current)
# 8. Se déconnecter (POST /api/v1/auth/logout)
# 9. Vérifier que le token est en liste noire (GET /api/v1/auth/check-session → 401)
# CRITÈRE DE RÉUSSITE : Toutes les étapes retournent les codes de statut attendus

Flux 2 : Test E2E Scan

# scripts/e2e/test-scan-flow.sh
# 1. Connexion → obtenir JWT
# 2. Créer un actif (POST /api/v1/assets)
# 3. Vérifier la propriété (POST /api/v1/verification/proofs)
# 4. Lancer un scan (POST /api/v1/scans)
# 5. Interroger le statut du scan (GET /api/v1/scans/:id) jusqu'à complétion
# 6. Obtenir les résultats du scan (GET /api/v1/scans/:id/results)
# 7. Vérifier la création de vulnérabilité dans vuln-mgmt (GET /api/v1/vulnerabilities)
# CRITÈRE DE RÉUSSITE : Le scan se termine, les résultats sont disponibles, la vulnérabilité est synchronisée

Flux 3 : Test E2E Actifs

# scripts/e2e/test-asset-flow.sh
# 1. Connexion → obtenir JWT
# 2. Créer un actif (POST /api/v1/assets)
# 3. Lire l'actif (GET /api/v1/assets/:id)
# 4. Mettre à jour l'actif (PATCH /api/v1/assets/:id)
# 5. Vérifier la mise à jour du quota (GET /api/v1/subscriptions/current → usage)
# 6. Supprimer l'actif (DELETE /api/v1/assets/:id)
# 7. Vérifier la décrémentation du quota
# CRITÈRE DE RÉUSSITE : Le CRUD fonctionne, les quotas se synchronisent en moins de 30s

Flux 4 : Test E2E Paiement

# scripts/e2e/test-payment-flow.sh
# 1. Connexion → obtenir JWT
# 2. Obtenir les plans (GET /api/v1/plans)
# 3. Créer une session de checkout (POST /api/v1/checkout/sessions)
# 4. Simuler le webhook Stripe (POST /api/v1/webhooks/stripe)
# 5. Vérifier la mise à jour de l'abonnement (GET /api/v1/subscriptions/current)
# 6. Vérifier la création de la facture (GET /api/v1/invoices)
# CRITÈRE DE RÉUSSITE : Niveau d'abonnement mis à jour, facture existante

6. Gel des Contrats d'Événements Kafka

Topics Gelés (v1.0 — rétrocompatible)

Tous les schémas de topics ci-dessous sont gelés pour le MVP1. Tout changement doit être rétrocompatible (ajout de champs uniquement).

Pattern de Topic	Producteur	Consommateur(s)	Version du Schéma
`cert-ix.auth.user.registered.success`	qr-auth-service	email-service, subscription-service	v1.0
`cert-ix.auth.user.login.success`	qr-auth-service	email-service	v1.0
`cert-ix.subscription.plan.free.request`	qr-auth-service	subscription-service	v1.0
`cert-ix.subscription.plan.free.activated`	subscription-service	email-service	v1.0
`cert-ix.subscription.capability-request`	vuln-mgmt-service	subscription-service	v1.0
`cert-ix.subscription.capability-response`	subscription-service	vuln-mgmt-service	v1.0
`cert-ix.scans.{engine}.{priority}`	scan-api-service	workers go-tools	v1.0
`cert-ix.scan-results`	go-tools	results-processor	v1.0
`cert-ix.scans.events`	go-tools	vuln-mgmt-service	v1.0
`cert-ix.asset.created/updated/deleted`	asset-mgmt-service	assets-sync, quota-sync	v1.0
`cert-ix.quota.sync.assets`	asset-mgmt-service	quota-sync-service	v1.0
`cert-ix.subscription.quota.sync`	quota-sync-service	subscription-service	v1.0
`cert-ix.payment.*`	payment-processing	invoice-service, account-provisioning	v1.0
`cert-ix.checkout.*`	checkout-orchestration	payment-processing	v1.0

Règles de Versionnage des Schémas

En-tête : Chaque message Kafka DOIT inclure l'en-tête schema-version: "1.0"
Additif uniquement : De nouveaux champs peuvent être ajoutés ; les champs existants ne peuvent pas être supprimés ou renommés
Tolérance du consommateur : Tous les consommateurs DOIVENT ignorer les champs inconnus
Changements cassants : Nécessitent un nouveau topic (ex. : cert-ix.auth.user.registered.success.v2)

7. Critères Go/No-Go

Critères Go (TOUS doivent être remplis)

#	Critère	Méthode de Vérification
1	Tous les écarts P0 remédiés	Revue de code + vérification de déploiement
2	Les 4 tests de fumée E2E des flux passent	Scripts de test automatisés sur staging
3	Aucun secret codé en dur dans aucun service déployé	Audit `grep` des docker-compose, .env, code source
4	TLS appliqué sur tous les endpoints externes	Test `curl -k` contre Kong + tous les ports publics
5	Kafka SSL activé pour tous les producteurs/consommateurs	Audit de config + test de connexion
6	Redis TLS activé pour tous les services	Audit de config + test de connexion
7	Flux auth : inscription → connexion → accès → déconnexion fonctionne E2E	Test de fumée Flux 1
8	Flux scan : création → scan → résultats fonctionne E2E	Test de fumée Flux 2
9	Flux paiement : checkout → paiement → abonnement actif fonctionne E2E	Test de fumée Flux 4
10	Tous les services P0 ont des endpoints de santé qui répondent	Script de vérification de santé
11	Contrats d'événements Kafka gelés et documentés	Ce document
12	Les journaux d'audit existent pour les événements auth (connexion/déconnexion/inscription)	Vérification par requête BDD

Déclencheurs No-Go

Tout écart P0 non remédié
Tout test de fumée E2E de flux en échec
Secret codé en dur trouvé dans la configuration de production
TLS non appliqué sur un endpoint exposé à l'extérieur
Contournement d'authentification possible sur un service P0
Flux de paiement cassé (intégration Stripe)

8. Calendrier

Jour 1 (8h) — Flux Auth + Scan

Horaire	Tâche	Services
0-1h	Corriger CSRF_ENCRYPTION_KEY, vérifier les secrets	qr-auth-service
1-3h	Vérifier l'isolation de email-service, ajouter alertes de santé	email-service, captcha
3-6h	Ajouter la journalisation d'audit au scan-worker-service	scan-worker-service
6-8h	Vérifier Kafka TLS du flux scan, écrire tests de fumée Flux 1+2	Tous les services de scan

Jour 2 (8h) — Flux Actifs + Paiement

Horaire	Tâche	Services
0-4h	Ajouter middleware JWT + audit à asset-management-service	asset-management-service
4-7h	Ajouter JWT à checkout-orchestration, audit à payment-processing	services de paiement
7-8h	Corriger la valeur par défaut DB_SSL, écrire tests de fumée Flux 3+4	admin-backend

Jour 3 (8h) — Transversal + P1 Critiques

Horaire	Tâche	Services
0-3h	Uniformiser les valeurs par défaut Kafka SSL + Redis TLS	Tous les services
3-6h	Ajouter la limitation de débit à admin-backend	admin-backend
6-8h	Base de sécurité pour compliance-guard-service	compliance-guard

Jour 4 (4h) — Validation + Go/No-Go

Horaire	Tâche	Services
0-2h	Exécuter les 4 tests de fumée E2E sur staging	Tous
2-3h	Corriger les échecs des tests de fumée	Selon besoin
3-4h	Revue finale Go/No-Go selon les critères	Tous

Effort total estimé : ~28h (3,5 jours ouvrés)

Annexe : Graphe de Dépendances des Services

                    ┌─────────────────┐
                    │  client-dashboard│
                    │  (Next.js)       │
                    └────────┬────────┘
                             │ HTTPS
                    ┌────────▼────────┐
                    │   Kong Gateway   │
                    │   (Proxy API)    │
                    └────────┬────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
  ┌─────▼─────┐     ┌───────▼───────┐    ┌──────▼──────┐
  │qr-auth-svc│     │asset-mgmt-svc │    │scan-api-svc │
  │  (Fastify) │     │  (Fastify)    │    │   (Go)      │
  └─────┬─────┘     └───────┬───────┘    └──────┬──────┘
        │                    │                    │
        │ Kafka              │ Kafka              │ Kafka
        ▼                    ▼                    ▼
  ┌───────────┐     ┌───────────────┐    ┌──────────────┐
  │email-svc  │     │quota-sync-svc │    │go-tools (x9) │
  │captcha-svc│     │assets-sync-svc│    │scan-worker   │
  └───────────┘     └───────┬───────┘    └──────┬───────┘
                            │                    │
                            ▼                    ▼
                    ┌───────────────┐    ┌──────────────┐
                    │subscription-  │    │vuln-mgmt-svc │
                    │service (Go)   │    │classifier-svc│
                    └───────┬───────┘    │policy-svc    │
                            │            │remediation   │
                            ▼            └──────────────┘
                    ┌───────────────┐
                    │payment-proc   │
                    │checkout-orch  │
                    │invoice-svc    │
                    │acct-provision │
                    └───────────────┘

Annexe : Distribution des Types d'Écarts de Conformité

Type d'Écart	Nombre P0	Nombre P1	Nombre P2	Total
AUTHN/AUTHZ	3	4	1	8
AUDIT	3	4	1	8
SECRETS	2	1	0	3
CHIFFREMENT	1	1	0	2
ENTRÉE	0	1	0	1
SUPERVISION	1	0	1	2
TOUT (base complète)	0	0	2	2
Total	10	11	5	26

Table des Matières​

1. Matrice de Conformité des Services​

Légende​

Dimensions de Conformité​

1.1 Services d'Administration​

1.2 Services d'Authentification & d'Identité​

1.3 Services Frontend Client​

1.4 Services de Gestion des Actifs​

1.5 Services de Vulnérabilités & Scan​

1.6 Services de Conformité & Audit​

1.7 Services de Paiement​

1.8 Services Agent & Télémétrie​

1.9 Services de Support​

1.10 Services Statiques/Contenu​

2. Flux Critiques & Dépendances​

Flux 1 : Inscription & Connexion Utilisateur (P0)​

Flux 2 : Scan de Vulnérabilités (P0)​

Flux 3 : Gestion des Actifs (P0)​

Flux 4 : Paiement & Abonnement (P0)​

Flux 5 : Conformité & Audit (P1)​

Flux 6 : Télémétrie Agent (P2)​

3. Synthèse des Écarts P0/P1/P2​

P0 — BLOQUANT (À corriger impérativement avant le lancement)​

P1 — IMPORTANT (À corriger pour le lancement, peut être reporté à J+2 si bloqué)​

P2 — POST-MVP​

4. Plan de Remédiation par Flux​

Flux 1 : Inscription & Connexion — Jour 1 (8h)​

Flux 2 : Scan de Vulnérabilités — Jour 1-2 (10h)​

Flux 3 : Gestion des Actifs — Jour 2 (8h)​

Flux 4 : Paiement & Abonnement — Jour 2-3 (11h)​

Flux 5 : Conformité & Audit — Jour 3 (6h)​

Transversal — Jour 3-4 (8h)​

5. Stratégie de Tests E2E par Flux​

Principe : Tester par flux, pas par service​

Flux 1 : Test E2E Auth​

Flux 2 : Test E2E Scan​

Flux 3 : Test E2E Actifs​

Flux 4 : Test E2E Paiement​

6. Gel des Contrats d'Événements Kafka​

Topics Gelés (v1.0 — rétrocompatible)​

Règles de Versionnage des Schémas​

7. Critères Go/No-Go​

Critères Go (TOUS doivent être remplis)​

Déclencheurs No-Go​

8. Calendrier​

Jour 1 (8h) — Flux Auth + Scan​

Jour 2 (8h) — Flux Actifs + Paiement​

Jour 3 (8h) — Transversal + P1 Critiques​

Jour 4 (4h) — Validation + Go/No-Go​

Annexe : Graphe de Dépendances des Services​

Annexe : Distribution des Types d'Écarts de Conformité​