Sikkerhedsrevision og certificering
På denne side
Fra ad hoc-sikkerhed til certificerbar overholdelse
De foregående lektioner har givet dig de tekniske værktøjer til at sikre et AI-system. Men engangskontroller er ikke nok – og årsagen er ikke bare bureaukrati. Det, du verificerer én gang, holder op med at være verificeret, så snart du udgiver næste release, og intet flagger dette gab. Kunder, myndigheder og partnere kræver formel dokumentation: bevis for, at dine kontroller eksisterer, virker og holder over tid. Revision og certificering omdanner dine praksisser til et verificerbart, løbende framework.
Kend det framework, der gælder for dig
Fem frameworks krydser hinanden inden for AI, hver med sit eget omfang. Skel mellem dem, før du binder dig til noget.
| Standard | Omfang | AI-relevans |
|---|---|---|
| ISO 27001 | Informationssikkerhed | Fundament for ethvert system, der behandler data |
| ISO 42001 | AI-ledelse | AI-specifik: styring, risiko, livscyklus |
| AI Act (EU) | Europæisk regulering | Obligatorisk for højrisikosystemer i EU |
| SOC 2 Type II | Sikkerhedskontroller for SaaS | Krævet af enterprise-kunder |
| OWASP LLM Top 10 | Bedste praksis for LLM-sikkerhed | Referenceliste til teknisk revision |
Den afgørende skelnen adskiller det, der er obligatorisk, fra det, der er valgfrit. EU’s AI-forordning (AI Act) er en regulering: Hvis dit system falder ind under kategorien „højrisiko”, har du ikke mulighed for at vælge det fra. ISO-standarder og SOC 2 er frivillige certificeringer, som typisk efterspørges af enterprise-kunder snarere end af myndigheder. OWASP LLM Top 10 kan ikke certificeres – det er en teknisk reference, og det er det bedste udgangspunkt for en første intern revision, fordi det kun koster tid.
En tjekliste, der dækker fem domæner
En seriøs revision går ud over det rent tekniske. Tjeklisten nedenfor fordeler sine kontrolpunkter på fem domæner, og den fordeling fortæller en historie: Styring og overholdelse vejer lige så tungt som sikkerhed, for en fejlfri teknisk opsætning, som ingen ejer, og som ingen steder er dokumenteret, vil fejle enhver ekstern revision.
Kritikalitet adskiller det obligatoriske fra det anbefalede – en skelnen, der senere driver en binær beslutning. Sandboxing fremstår som anbefalet snarere end obligatorisk, og den rangering er berettiget: Den gælder kun for systemer, der eksekverer genereret kode, hvorimod filtrering af input og output vedrører enhver applikation uden undtagelse. En velkalibreret tjekliste beder ikke en FAQ-chatbot om at begrunde container-isolering.
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"),
]
Revision betyder at kræve beviser
Det felt, der ændrer alt i udførelsen af en revision, er evidence. At sætte flueben ved „compliant” uden en dokumentreference betyder ingenting for en ekstern revisor, som systematisk vil spørge, hvad der understøtter påstanden. Brugseksemplet viser dette tydeligt: Overholdelse af GOV-01 hviler på et navngivet, dateret dokument, ikke en hensigtserklæring.
Det tredje kald illustrerer det mest lærerige tilfælde – en manglende overholdelse parret med en udbedringsplan. En API-nøgle i en miljøfil er ikke en skandale; det er en almindelig praksis. Det fejler stadig kontrolpunktet, og kommentaren udlægger vejen til overholdelse. En revision, der ikke afslører nogen manglende overholdelser, bør vække mistanke: Det signalerer normalt en lempelig tjekliste, ikke et perfekt system.
Den endelige beslutning er binær og uvægtet: En enkelt obligatorisk manglende overholdelse vender dommen. Overholdelsesprocenten, som beregnes sideløbende, måler fremskridt mellem revisioner – den forhandler aldrig selve dommen.
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']}")
Én sidste tæller – antallet af ikke-evaluerede punkter – spiller en stille, men afgørende rolle. Den forhindrer dig i at forveksle „overholdt” med „ikke tjekket”, en forveksling, der sniger sig ind, når en revision strækker sig over uger, og ingen kan huske, hvor den stoppede.
Automatisér, hvad du kan
En årlig revision fanger et øjebliksbillede. Mellem øjebliksbillederne kan en API-nøgle blive hardcodet, en rate-limit deaktiveret for at afhjælpe en hastende kunde, eller moderering omgået til en hurtig test. Automatiserede kontroller udfylder dette gab ved at køre ved hver cyklus for continuous integration.
Ikke alt egner sig til automatisering, og det skal du sige rent ud. Søgning efter hardcodede nøgler kan mekaniseres, fordi det inspicerer kode. De to andre kontroller i eksemplet returnerer hardcodede værdier, hvilket kun giver mening som udgangspunkt: I produktion skal de faktisk udøve tjenesten – kald API’en enogtyve gange for at bekræfte, at en 429 dukker op, eller indsend testindhold til moderering for at bekræfte, at den svarer. En kontrol, der altid returnerer sand, er værre end ingen kontrol, fordi den fabrikerer tillid uden at måle noget.
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)
Hvad en certificeringsorgan forventer
At sigte mod en certificering som ISO 42001 eller SOC 2 ændrer indsatsen, og det skal du vide, før du binder dig. Dokumentation kommer først: opdaterede politikker, procedurer og registre – det arbejde, engineering-teams oftest udskyder. Beviser følger efter – logs, testrapporter, screenshots – og er langt lettere at indsamle, hvis du arkiverer dem løbende frem for tre uger før revisionen. Historik er det sværeste krav at indhente: En SOC 2 Type II undersøger, hvordan kontroller har fungeret over flere måneder, noget ingen sidste-øjebliks-indsats kan fabricere. Træning kommer næst, og du skal bevise, at den er sket, hvilket betyder daterede deltagerlister og materialer. Endelig kræver løbende forbedring, at du viser, at fund bliver rettet og retestet – præcis den revalideringscyklus fra det foregående kapitel, hvis værdi du nu ser: Den producerer de beviser, som certificeringsorganet vil kræve.
Cyklussen revision, rettelse, retest, certificering har ingen ende. Hver ny funktion genåbner kontrolpunkter, og det er netop betydningen af „løbende” i „løbende forbedring”.
Vigtige pointer
- Revision omdanner bedste praksis for sikkerhed til verificerbare beviser
- Tjeklisten dækker styring, data, teknisk sikkerhed, red teaming og overholdelse
- Obligatoriske mangler er showstoppere – de skal rettes før deployment
- Løbende revision automatiserer gentagne kontroller (API-nøgler, rate limiting, moderering)
- Certificering (ISO 42001, SOC 2) kræver dokumentation, beviser og historik: Cyklussen revision, rettelse, retest er løbende, aldrig engangs
Test din viden
Offensiv og defensiv sikkerhed: Den sidste kontrol før revisionen.
1. Hvad er et prompt injection-angreb?
Svar: Ondskabsfulde instruktioner smuglet ind i de data, som modellen behandler (webside, dokument, besked) for at kapre dens adfærd – forsvar: isolér instruktioner fra data, valider outputs, begræns eksponerede funktioner.
2. Jailbreaking vs. prompt injection: Hvad er forskellen?
Svar: Jailbreaking forsøger at få modellen til at omgå sine regler gennem direkte samtale; injection virker gennem tredjepartsindhold, den behandler. Begge testes – og imødegås – forskelligt.
3. Hvorfor flerlagsfiltrering?
Svar: Fordi intet enkelt lag er perfekt: Input-moderering, applikations-værn, output-kontroller og rate limiting supplerer hinanden – defense in depth anvendt på AI.
4. Hvad indebærer en AI red teaming-kampagne?
Svar: Metodisk angreb på dit eget system (injection-scenarier, jailbreaks, exfiltration) med en risikotaksonomi, dokumentation af brud, prioritering af udbedring – og derefter retest.
5. Hvad dækker GDPR-vinklen i en OpenAI-deployment?
Svar: Det juridiske grundlag for behandling, dataminimering for sendte data, registreredes rettigheder og kontraktmæssige sikkerhedsforanstaltninger – overholdelse designes sammen med arkitekturen, ikke bagefter.
Et sikkert AI-system er bevist: Taksonomi, offensive tests, lagdelte forsvar, revision – den cyklus, dette kursus har fået dig til at øve.