Audit de sécurité et certification

De la sécurité ad hoc à la conformité certifiable

Les lecons précédentes vous ont donné les outils techniques pour sécuriser un système IA. Mais la sécurité ponctuelle ne suffit pas : les clients, les régulateurs et les partenaires exigent des preuves formelles. L’audit de sécurité et la certification transforment vos pratiques en un cadre vérifiable et continu.

Cadres de référence pour l’audit IA

Les standards applicables

Construire un programme d’audit

Checklist d’audit sécurité IA

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class PointControle:
    id: str
    categorie: str
    description: str
    criticite: str  # obligatoire, recommande, optionnel
    conforme: bool | None = None
    preuve: str = ""
    commentaire: str = ""

def creer_checklist_audit() -> list[PointControle]:
    """Crée une checklist complète d'audit sécurité IA."""
    return [
        # Gouvernance
        PointControle("GOV-01", "Gouvernance",
            "Politique de sécurité IA documentée et approuvée", "obligatoire"),
        PointControle("GOV-02", "Gouvernance",
            "Responsable sécurité IA désigné (CISO/DPO)", "obligatoire"),
        PointControle("GOV-03", "Gouvernance",
            "Registre des traitements IA à jour", "obligatoire"),

        # Données
        PointControle("DAT-01", "Données",
            "Inventaire des données envoyées aux APIs LLM", "obligatoire"),
        PointControle("DAT-02", "Données",
            "Anonymisation/pseudonymisation des données personnelles", "obligatoire"),
        PointControle("DAT-03", "Données",
            "DPA signé avec chaque fournisseur d'API IA", "obligatoire"),
        PointControle("DAT-04", "Données",
            "Politique de rétention des conversations définie", "obligatoire"),

        # Sécurité technique
        PointControle("SEC-01", "Sécurité",
            "Prompt injection : défenses en profondeur implémentées", "obligatoire"),
        PointControle("SEC-02", "Sécurité",
            "Filtrage de contenu (entrées et sorties)", "obligatoire"),
        PointControle("SEC-03", "Sécurité",
            "Rate limiting et détection d'abus", "obligatoire"),
        PointControle("SEC-04", "Sécurité",
            "Clés API stockées dans un vault (pas en dur)", "obligatoire"),
        PointControle("SEC-05", "Sécurité",
            "Sandboxing pour l'exécution de code généré", "recommande"),
        PointControle("SEC-06", "Sécurité",
            "Monitoring et alertes sur les anomalies", "recommande"),

        # Red teaming
        PointControle("RED-01", "Red teaming",
            "Tests de sécurité avant chaque mise en production", "obligatoire"),
        PointControle("RED-02", "Red teaming",
            "Red teaming régulier (trimestriel minimum)", "recommande"),
        PointControle("RED-03", "Red teaming",
            "Rapport de red teaming avec suivi des remédiations", "obligatoire"),

        # Conformité
        PointControle("CONF-01", "Conformité",
            "AIPD réalisée pour les traitements IA", "obligatoire"),
        PointControle("CONF-02", "Conformité",
            "Droits des personnes implémentés (accès, effacement)", "obligatoire"),
        PointControle("CONF-03", "Conformité",
            "Information transparente aux utilisateurs sur l'usage de l'IA", "obligatoire"),
        PointControle("CONF-04", "Conformité",
            "Classification du risque selon l'AI Act", "recommande"),
    ]

Exécution de l’audit

class AuditSecuriteIA:
    """Exécute et documente un audit de sécurité IA."""

    def __init__(self, nom_systeme: str, auditeur: str):
        self.nom_systeme = nom_systeme
        self.auditeur = auditeur
        self.date = datetime.now().strftime("%Y-%m-%d")
        self.checklist = creer_checklist_audit()

    def evaluer(self, point_id: str, conforme: bool, preuve: str, commentaire: str = ""):
        """Évalue un point de contrôle."""
        for point in self.checklist:
            if point.id == point_id:
                point.conforme = conforme
                point.preuve = preuve
                point.commentaire = commentaire
                return
        raise ValueError(f"Point de contrôle inconnu : {point_id}")

    def rapport(self) -> dict:
        """Génère le rapport d'audit."""
        evalues = [p for p in self.checklist if p.conforme is not None]
        conformes = [p for p in evalues if p.conforme]
        non_conformes = [p for p in evalues if not p.conforme]
        non_evalues = [p for p in self.checklist if p.conforme is None]

        # Non-conformités obligatoires = bloquantes
        bloquantes = [
            p for p in non_conformes if p.criticite == "obligatoire"
        ]

        return {
            "systeme": self.nom_systeme,
            "auditeur": self.auditeur,
            "date": self.date,
            "total_controles": len(self.checklist),
            "evalues": len(evalues),
            "conformes": len(conformes),
            "non_conformes": len(non_conformes),
            "non_evalues": len(non_evalues),
            "bloquantes": len(bloquantes),
            "taux_conformite": f"{len(conformes) / max(len(evalues), 1) * 100:.0f}%",
            "decision": "NON CONFORME" if bloquantes else "CONFORME",
            "non_conformites_bloquantes": [
                {"id": p.id, "description": p.description, "commentaire": p.commentaire}
                for p in bloquantes
            ],
        }

# Exemple d'utilisation
audit = AuditSecuriteIA("Chatbot Service Client v2.3", "analyste_securite")
audit.evaluer("GOV-01", True, "Document POL-SEC-IA-2026 approuvé le 15/01/2026")
audit.evaluer("SEC-01", True, "Guardrails multi-couche implémentés (voir architecture)")
audit.evaluer("SEC-04", False, "Clé API OpenAI en variable d'environnement .env",
              "Migrer vers un vault (HashiCorp Vault ou AWS Secrets Manager)")

resultat = audit.rapport()
print(f"Décision : {resultat['decision']}")
print(f"Taux de conformité : {resultat['taux_conformite']}")

Audit continu et automatisé

class AuditContinu:
    """Vérifie automatiquement les contrôles de sécurité en continu."""

    def __init__(self):
        self.verifications = {}

    def ajouter_verification(self, nom: str, fonction_check):
        """Ajoute une vérification automatisée."""
        self.verifications[nom] = fonction_check

    def executer(self) -> dict:
        """Exécute toutes les vérifications."""
        resultats = {}
        for nom, check in self.verifications.items():
            try:
                ok, detail = check()
                resultats[nom] = {"statut": "OK" if ok else "ECHEC", "detail": detail}
            except Exception as e:
                resultats[nom] = {"statut": "ERREUR", "detail": str(e)}
        return resultats

# Vérifications automatisées
audit_continu = AuditContinu()

def check_cles_api():
    """Vérifie qu'aucune clé API n'est en dur dans le code."""
    import subprocess
    result = subprocess.run(
        ["grep", "-r", "sk-", "src/", "--include=*.py", "-l"],
        capture_output=True, text=True,
    )
    fichiers = result.stdout.strip().split("\n") if result.stdout.strip() else []
    return len(fichiers) == 0, f"{len(fichiers)} fichier(s) avec clé en dur"

def check_rate_limiting():
    """Vérifie que le rate limiting est actif."""
    return True, "Rate limiting actif (429 après 20 req/min)"

def check_moderation():
    """Vérifie que la modération est active sur le pipeline."""
    return True, "API Moderation appelée sur entrées et sorties"

audit_continu.ajouter_verification("cles_api_securisees", check_cles_api)
audit_continu.ajouter_verification("rate_limiting_actif", check_rate_limiting)
audit_continu.ajouter_verification("moderation_active", check_moderation)

Préparer une certification

La certification (ISO 42001, SOC 2) nécessite :

1. Documentation — politiques, procédures, registres à jour
2. Preuves — logs, rapports de test, captures d’écran
3. Historique — montrer que les contrôles sont en place depuis plusieurs mois
4. Formation — prouver que l’équipe est formée aux risques IA
5. Amélioration continue — montrer que les trouvailles sont corrigées et retestées

Points clés à retenir

• L’audit transforme les bonnes pratiques de sécurité en preuves vérifiables
• La checklist couvre gouvernance, données, sécurité technique, red teaming et conformité
• Les non-conformités obligatoires sont bloquantes — elles doivent être corrigées avant déploiement
• L’audit continu automatise les vérifications répétitives (clés API, rate limiting, modération)
• La certification (ISO 42001, SOC 2) demande documentation, preuves et historique
• Le cycle audit, correction, retest, certification est un processus continu, pas un événement ponctuel