Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Audit de sécurité et certification

Les 14 van 14 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. De la sécurité ad hoc à la conformité certifiable
  2. Savoir quel référentiel s’applique
  3. Une liste de contrôle couvrant cinq domaines
  4. L’audit exige des preuves
  5. Automatisez ce que vous pouvez
  6. Ce qu’attend un certificateur
  7. Belangrijkste punten
  8. Testez vos connaissances

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

Les leçons précédentes vous ont fourni les outils techniques pour sécuriser un système d’IA. Cependant, des contrôles de sécurité ponctuels ne suffisent pas, et la raison ne réside pas uniquement dans la bureaucratie. Ce que vous vérifiez une fois cesse de l’être dès que vous déployez la version suivante, et rien ne signale cette lacune. Les clients, les régulateurs et les partenaires exigent des preuves formelles : la démonstration que vos contrôles existent, fonctionnent et restent efficaces dans le temps. L’audit et la certification transforment vos pratiques en un cadre vérifiable et continu.

Savoir quel référentiel s’applique

Cinq référentiels se croisent dans le domaine de l’IA, chacun avec un périmètre différent. Distinguez-les avant de vous engager dans quoi que ce soit.

Standard Périmètre Pertinence pour l'IA
ISO 27001 Sécurité de l'information Fondation pour tout système traitant des données
ISO 42001 Gestion de l'IA Spécifique à l'IA : gouvernance, risques, cycle de vie
AI Act (UE) Réglementation européenne Obligatoire pour les systèmes à haut risque dans l'UE
SOC 2 Type II Contrôles de sécurité SaaS Exigé par les clients entreprises
OWASP LLM Top 10 Meilleures pratiques de sécurité LLM Liste de contrôle de référence pour l'audit technique

La distinction décisive sépare ce qui est obligatoire de ce qui est optionnel. L’AI Act de l’UE est un règlement : si votre système tombe dans la catégorie à haut risque, vous n’avez pas le choix. Les normes ISO et SOC 2 sont des certifications volontaires, généralement exigées par les clients entreprises plutôt que par les régulateurs. L’OWASP LLM Top 10 n’est pas certifiable ; c’est une référence technique et le meilleur point de départ pour un premier audit interne, car il ne coûte que du temps.

Une liste de contrôle couvrant cinq domaines

Un audit sérieux va au-delà de la technique. La liste de contrôle ci-dessous répartit ses points de contrôle sur cinq domaines, et cette répartition raconte une histoire : la gouvernance et la conformité pèsent autant que la sécurité, car une configuration technique irréprochable que personne ne possède et nulle part ne documente échouera à tout audit externe.

La criticité sépare l’obligatoire du recommandé, une distinction qui pilote ensuite une décision binaire. Le sandboxing apparaît comme recommandé plutôt qu’obligatoire, et ce classement est justifié : il ne s’applique qu’aux systèmes exécutant du code généré, tandis que le filtrage des entrées et des sorties concerne chaque application sans exception. Une liste de contrôle bien calibrée ne demande pas à un chatbot FAQ de justifier l’isolement des conteneurs.

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class ControlPoint:
    id: str
    category: str
    description: str
    criticality: str  # mandatory, recommended, optional
    compliant: bool | None = None
    evidence: str = ""
    comment: str = ""

def create_audit_checklist() -> list[ControlPoint]:
    """Creates a comprehensive AI security audit checklist."""
    return [
        # Governance
        ControlPoint("GOV-01", "Governance",
            "Documented and approved AI security policy", "mandatory"),
        ControlPoint("GOV-02", "Governance",
            "Designated AI security owner (CISO/DPO)", "mandatory"),
        ControlPoint("GOV-03", "Governance",
            "Up-to-date register of AI processing activities", "mandatory"),

        # Data
        ControlPoint("DAT-01", "Data",
            "Inventory of data sent to LLM APIs", "mandatory"),
        ControlPoint("DAT-02", "Data",
            "Anonymization/pseudonymization of personal data", "mandatory"),
        ControlPoint("DAT-03", "Data",
            "DPA signed with each AI API provider", "mandatory"),
        ControlPoint("DAT-04", "Data",
            "Defined conversation retention policy", "mandatory"),

        # Technical security
        ControlPoint("SEC-01", "Security",
            "Prompt injection: defense-in-depth implemented", "mandatory"),
        ControlPoint("SEC-02", "Security",
            "Content filtering (inputs and outputs)", "mandatory"),
        ControlPoint("SEC-03", "Security",
            "Rate limiting and abuse detection", "mandatory"),
        ControlPoint("SEC-04", "Security",
            "API keys stored in a vault (not hardcoded)", "mandatory"),
        ControlPoint("SEC-05", "Security",
            "Sandboxing for generated code execution", "recommended"),
        ControlPoint("SEC-06", "Security",
            "Monitoring and alerts on anomalies", "recommended"),

        # Red teaming
        ControlPoint("RED-01", "Red teaming",
            "Security tests before every production release", "mandatory"),
        ControlPoint("RED-02", "Red teaming",
            "Regular red teaming (quarterly minimum)", "recommended"),
        ControlPoint("RED-03", "Red teaming",
            "Red team report with remediation tracking", "mandatory"),

        # Compliance
        ControlPoint("CONF-01", "Compliance",
            "DPIA completed for AI processing activities", "mandatory"),
        ControlPoint("CONF-02", "Compliance",
            "Data subject rights implemented (access, erasure)", "mandatory"),
        ControlPoint("CONF-03", "Compliance",
            "Transparent user notice about AI usage", "mandatory"),
        ControlPoint("CONF-04", "Compliance",
            "Risk classification per the EU AI Act", "recommended"),
    ]

L’audit exige des preuves

Le champ qui change tout dans l’exécution de l’audit est evidence. Cocher “compliant” sans référence documentaire ne signifie rien pour un auditeur externe, qui demandera systématiquement ce qui étaye l’affirmation. L’exemple d’utilisation le montre clairement : la conformité GOV-01 repose sur un document nommé et daté, pas sur une déclaration d’intention.

Le troisième appel illustre le cas le plus instructif : une non-conformité associée à son plan de remédiation. Une clé API dans un fichier d’environnement n’est pas un scandale ; c’est une pratique courante. Elle échoue néanmoins au point de contrôle, et le commentaire expose la voie vers la conformité. Un audit qui ne révèle aucune non-conformité devrait susciter la suspicion : il signale généralement une liste de contrôle trop indulgente, et non un système parfait.

La décision finale est binaire et non pondérée : une seule non-conformité obligatoire fait basculer le verdict. Le taux de conformité, calculé parallèlement, mesure les progrès entre les audits ; il ne négocie jamais le verdict lui-même.

class AISecurityAudit:
    """Executes and documents an AI security audit."""

    def __init__(self, system_name: str, auditor: str):
        self.system_name = system_name
        self.auditor = auditor
        self.date = datetime.now().strftime("%Y-%m-%d")
        self.checklist = create_audit_checklist()

    def evaluate(self, point_id: str, compliant: bool, evidence: str, comment: str = ""):
        """Evaluates a control point."""
        for point in self.checklist:
            if point.id == point_id:
                point.compliant = compliant
                point.evidence = evidence
                point.comment = comment
                return
        raise ValueError(f"Unknown control point: {point_id}")

    def report(self) -> dict:
        """Generates the audit report."""
        evaluated = [p for p in self.checklist if p.compliant is not None]
        compliant = [p for p in evaluated if p.compliant]
        non_compliant = [p for p in evaluated if not p.compliant]
        not_evaluated = [p for p in self.checklist if p.compliant is None]

        # Mandatory non-compliances are blockers
        blockers = [
            p for p in non_compliant if p.criticality == "mandatory"
        ]

        return {
            "system": self.system_name,
            "auditor": self.auditor,
            "date": self.date,
            "total_controls": len(self.checklist),
            "evaluated": len(evaluated),
            "compliant": len(compliant),
            "non_compliant": len(non_compliant),
            "not_evaluated": len(not_evaluated),
            "blockers": len(blockers),
            "compliance_rate": f"{len(compliant) / max(len(evaluated), 1) * 100:.0f}%",
            "decision": "NON-COMPLIANT" if blockers else "COMPLIANT",
            "blocking_non_compliances": [
                {"id": p.id, "description": p.description, "comment": p.comment}
                for p in blockers
            ],
        }

# Usage example
audit = AISecurityAudit("Customer Support Chatbot v2.3", "security_analyst")
audit.evaluate("GOV-01", True, "Document POL-SEC-AI-2026 approved on 2026-01-15")
audit.evaluate("SEC-01", True, "Multi-layer guardrails implemented (see architecture)")
audit.evaluate("SEC-04", False, "OpenAI API key in .env environment variable",
              "Migrate to a vault (HashiCorp Vault or AWS Secrets Manager)")

result = audit.report()
print(f"Decision: {result['decision']}")
print(f"Compliance rate: {result['compliance_rate']}")

Un dernier compteur — le nombre de points non évalués — joue un rôle discret mais décisif. Il vous empêche de confondre “conforme” avec “non vérifié”, une confusion qui s’installe lorsqu’un audit s’étale sur des semaines et que personne ne se souvient où il s’est arrêté.

Automatisez ce que vous pouvez

Un audit annuel capture un instantané. Entre deux instantanés, une clé API peut être codée en dur, une limite de taux désactivée pour débloquer un client pressé, ou la modération contournée pour un test rapide. Les contrôles automatisés comblent cet écart en s’exécutant à chaque cycle d’intégration continue.

Tout ne se prête pas à l’automatisation, et vous devez le dire clairement. La recherche de clés codées en dur est mécanisable car elle inspecte le code. Les deux autres vérifications de l’exemple renvoient des valeurs codées en dur, ce qui n’a de sens que comme point de départ : en production, elles doivent réellement exercer le service — appeler l’API vingt et une fois pour confirmer l’apparition d’une erreur 429, ou soumettre du contenu de test à la modération pour confirmer sa réponse. Une vérification qui renvoie toujours vrai est pire qu’aucune vérification, car elle fabrique une confiance sans rien mesurer.

class ContinuousAudit:
    """Automatically verifies security controls on an ongoing basis."""

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

    def add_check(self, name: str, check_function):
        """Adds an automated check."""
        self.checks[name] = check_function

    def run(self) -> dict:
        """Runs all checks."""
        results = {}
        for name, check in self.checks.items():
            try:
                ok, detail = check()
                results[name] = {"status": "PASS" if ok else "FAIL", "detail": detail}
            except Exception as e:
                results[name] = {"status": "ERROR", "detail": str(e)}
        return results

# Automated checks
continuous_audit = ContinuousAudit()

def check_api_keys():
    """Verifies that no API keys are hardcoded in the codebase."""
    import subprocess
    result = subprocess.run(
        ["grep", "-r", "sk-", "src/", "--include=*.py", "-l"],
        capture_output=True, text=True,
    )
    files = result.stdout.strip().split("\n") if result.stdout.strip() else []
    return len(files) == 0, f"{len(files)} file(s) with hardcoded key"

def check_rate_limiting():
    """Verifies that rate limiting is active."""
    return True, "Rate limiting active (429 after 20 req/min)"

def check_moderation():
    """Verifies that moderation is active on the pipeline."""
    return True, "Moderation API called on inputs and outputs"

continuous_audit.add_check("api_keys_secured", check_api_keys)
continuous_audit.add_check("rate_limiting_active", check_rate_limiting)
continuous_audit.add_check("moderation_active", check_moderation)

Ce qu’attend un certificateur

Viser une certification comme ISO 42001 ou SOC 2 déplace l’effort, et vous devez le savoir avant de vous engager. La documentation vient en premier : politiques, procédures et registres à jour — le travail que les équipes d’ingénierie reportent le plus volontiers. Les preuves suivent — journaux, rapports de test, captures d’écran — et sont beaucoup plus faciles à collecter si vous les archivez au fur et à mesure plutôt que trois semaines avant l’audit. L’historique est l’exigence la plus difficile à rattraper : un SOC 2 Type II examine comment les contrôles ont fonctionné sur plusieurs mois, ce qu’aucune poussée de dernière minute ne peut fabriquer. La formation vient ensuite, et vous devez prouver qu’elle a eu lieu, ce qui implique des feuilles de présence et des supports datés. Enfin, l’amélioration continue exige de montrer que les constatations sont corrigées et retestées — exactement la boucle de revalidation du chapitre précédent, dont vous voyez maintenant la valeur : elle produit les preuves que le certificateur exigera.

Le cycle audit, correction, retest, certification n’a pas de fin. Chaque nouvelle fonctionnalité rouvre des points de contrôle, et c’est là tout le sens du mot “continu” dans “amélioration continue”.

Belangrijkste punten

  • L’audit transforme les meilleures pratiques de sécurité en preuves vérifiables
  • La liste de contrôle couvre la gouvernance, les données, la sécurité technique, le red teaming et la conformité
  • Les non-conformités obligatoires sont des blocages : elles doivent être corrigées avant le déploiement
  • L’audit continu automatise les vérifications répétitives (clés API, limite de taux, modération)
  • La certification (ISO 42001, SOC 2) exige documentation, preuves et historique : le cycle audit, correction, retest est continu, jamais ponctuel

Testez vos connaissances

Sécurité offensive et défensive : le dernier contrôle avant l’audit.

1. Qu'est-ce qu'une attaque par injection de prompt ?

Réponse : Des instructions malveillantes glissées dans les données que le modèle traite (page web, document, message) pour détourner son comportement — défense : isoler les instructions des données, valider les sorties, limiter les capacités exposées.

2. Jailbreaking vs injection de prompt : quelle est la différence ?

Réponse : Le jailbreaking tente de faire contourner ses règles au modèle par une conversation directe ; l’injection fonctionne via du contenu tiers qu’il traite. Les deux sont testés — et contrés — différemment.

3. Pourquoi un filtrage multi-couches ?

Réponse : Parce qu’aucune couche unique n’est parfaite : la modération des entrées, les garde-fous applicatifs, les contrôles de sortie et la limite de taux se complètent — la défense en profondeur appliquée à l’IA.

4. En quoi consiste une campagne de red teaming IA ?

Réponse : Attaquer méthodiquement votre propre système (scénarios d’injection, jailbreaks, exfiltration) avec une taxonomie des risques, documenter les brèches, prioriser la remédiation — puis retester.

5. Que couvre l'angle RGPD dans un déploiement OpenAI ?

Réponse : La base légale du traitement, la minimisation des données envoyées, les droits des personnes concernées et les garanties contractuelles — la conformité est conçue avec l’architecture, pas après.

Un système d’IA sûr est prouvé : taxonomie, tests offensifs, défenses en couches, audit — le cycle que ce cours vous a fait pratiquer.