Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Revision de sécurité et certification

Lektion 14 av 14 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  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. Automatise ce que tu peux
  6. Ce qu’attend un certificateur
  7. Viktiga punkter
  8. Teste tes connaissances

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

Les leçons précédentes t’ont donné les outils techniques pour sécuriser un système d’IA. Mais des vérifications de sécurité ponctuelles ne suffisent pas, et la raison ne se limite pas à la bureaucratie. Ce que tu vérifies une fois cesse de l’être dès que tu livres la version suivante, et rien ne signale cette lacune. Les clients, les régulateurs et les partenaires exigent des preuves formelles : la preuve que tes contrôles existent, fonctionnent et tiennent dans la durée. L’audit et la certification transforment tes 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. Distingue-les avant de t’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 Management 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 Bonnes 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 ton système tombe dans la catégorie à haut risque, tu n’as pas le choix. Les normes ISO et le 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 c’est 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’isolation par 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 « conforme » sans référence à un document ne signifie rien pour un auditeur externe, qui demandera systématiquement ce qui étaye l’affirmation. L’exemple d’usage 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 éveiller les soupçons : il signale généralement une liste de contrôle trop indulgente, pas 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, mais 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 t’empêche de confondre « conforme » avec « non vérifié », une confusion qui s’installe quand un audit s’étale sur des semaines et que personne ne se souvient où il s’est arrêté.

Automatise ce que tu peux

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

Tout ne se prête pas à l’automatisation, et tu dois 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 que l’absence de 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 tu dois le savoir avant de t’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 bien plus faciles à collecter si tu les archives 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, quelque chose qu’aucune poussée de dernière minute ne peut fabriquer. La formation vient ensuite, et tu dois 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 tu vois 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 « continu » dans « amélioration continue ».

Viktiga punkter

  • L’audit transforme les bonnes 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 débit, modération)
  • La certification (ISO 42001, SOC 2) exige documentation, preuves et historique : le cycle audit, correction, retest est continu, jamais ponctuel

Teste tes 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 passe par 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 n’est parfaite : la modération des entrées, les garde-fous applicatifs, les contrôles de sortie et la limitation de débit se complètent — la défense en profondeur appliquée à l’IA.

4. Que comprend une campagne de red teaming IA ?

Réponse : Attaquer méthodiquement ton 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é se conçoit avec l’architecture, pas après.

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