Auditas saugumo srityje ir sertifikavimas
Šiame puslapyje
Nuo ad hoc saugumo iki sertifikuojamos atitikties
Ankstesnės pamokos suteikė tau techninių įrankių dirbtinio intelekto sistemai apsaugoti. Tačiau vienkartinių saugumo patikrų nepakanka – ir priežastis yra ne tik biurokratija. Tai, ką patikrini vieną kartą, nustoja būti patikrinta iškart, kai paleidi kitą versiją, ir niekas nepažymi šios spragos. Klientai, reguliuojančios institucijos ir partneriai reikalauja oficialių įrodymų: įrodymų, kad tavo kontrolės mechanizmai egzistuoja, veikia ir išlieka veiksmingi laikui bėgant. Auditas ir sertifikavimas paverčia tavo praktiką patikrinama, nuolatine sistema.
Žinok, kuri sistema taikoma
Dirbtinio intelekto srityje susikerta penkios sistemos, kurių kiekviena turi skirtingą taikymo sritį. Prieš įsipareigodamas bet kam, jas atskirk.
| Standard | Scope | AI relevance |
|---|---|---|
| ISO 27001 | Information security | Foundation for any system processing data |
| ISO 42001 | AI management | AI-specific: governance, risk, lifecycle |
| AI Act (EU) | European regulation | Mandatory for high-risk systems in the EU |
| SOC 2 Type II | SaaS security controls | Required by enterprise customers |
| OWASP LLM Top 10 | LLM security best practices | Reference checklist for technical audit |
Lemiamas skirtumas yra tarp to, kas privaloma, ir to, kas neprivaloma. ES Dirbtinio intelekto aktas yra reglamentas: jei tavo sistema patenka į didelės rizikos kategoriją, neturi pasirinkimo. ISO standartai ir SOC 2 yra savanoriški sertifikatai, kuriuos dažniau reikalauja įmonių klientai, o ne reguliuotojai. OWASP LLM Top 10 nėra sertifikuojamas – tai techninė nuoroda ir geriausias atspirties taškas pirmajam vidiniam auditui, nes kainuoja tik laiką.
Kontrolinis sąrašas, apimantis penkias sritis
Rimtas auditas eina toliau nei vien technika. Toliau pateiktas kontrolinis sąrašas paskirsto kontrolės punktus penkioms sritims, ir šis pasiskirstymas daug ką pasako: valdymas ir atitiktis sveria tiek pat, kiek ir saugumas, nes tobula techninė sąranga, kurios niekas neprisimauna ir kuri niekur nėra dokumentuota, neišlaikys jokio išorinio audito.
Svarbumas atskiria privalomus punktus nuo rekomenduojamų – tai skirtumas, kuris vėliau lemia binarinį sprendimą. Izoliuota aplinka (sandboxing) įvardijama kaip rekomenduojama, o ne privaloma, ir tai pagrįsta: ji taikoma tik sistemoms, vykdančioms sugeneruotą kodą, tuo tarpu įvesties ir išvesties filtravimas rūpi kiekvienai programai be išimties. Gerai suderintas kontrolinis sąrašas nereikalauja, kad FAQ pokalbių robotas pateisintų konteinerių izoliavimą.
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"),
]
Auditas reiškia reikalavimą pateikti įrodymus
Laukas, kuris viską keičia vykdant auditą, yra evidence. Pažymėti „compliant“ be nuorodos į dokumentą išoriniam auditoriui nieko nereiškia; jis sistemingai klaus, kas pagrindžia šį teiginį. Naudojimo pavyzdys tai aiškiai parodo: GOV-01 atitiktis remiasi įvardytu ir datuotu dokumentu, o ne ketinimų deklaracija.
Trečiasis kvietimas iliustruoja labiausiai pamokantį atvejį – neatitiktį, susietą su jos šalinimo planu. API raktas aplinkos faile nėra skandalas; tai įprasta praktika. Vis dėlto tai neatitinka kontrolės punkto, o komentare nubrėžiamas kelias link atitikties. Auditas, kuris neiškelia jokių neatitikčių, turėtų kelti įtarimą: tai dažniausiai signalizuoja apie pernelyg švelnų kontrolinį sąrašą, o ne apie tobulą sistemą.
Galutinis sprendimas yra binary ir nesveriamas: viena privaloma neatitiktis pakeičia verdiktą. Atitikties rodiklis, apskaičiuojamas greta, matuoja pažangą tarp auditų – jis niekada nederybina dėl paties verdikto.
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']}")
Paskutinis skaitiklis – neįvertintų punktų skaičius – atlieka tylų, bet lemiamą vaidmenį. Jis neleidžia supainioti „atitinka“ su „nepatikrinta“, kas nutinka, kai auditas tęsiasi savaites ir niekas nebeprisimena, kur jis sustojo.
Automatizuok tai, ką gali
Metinis auditas fiksuoja momentinę nuotrauką. Tarp šių momentų API raktas gali būti įkoduotas tiesiai į kodą, greičio ribojimas gali būti išjungtas norint greitai išspręsti kliento problemą, arba moderavimas gali būti apeitas greitam testui. Automatinės patikros užpildo šią spragą, veikdamos kiekviename nuolatinės integrijos cikle.
Ne viską galima automatizuoti, ir tai reikia pasakyti tiesiai. Koduotų raktų paieška yra mechanizuojama, nes ji tikrina kodą. Kiti du pavyzdžio patikrinimai grąžina fiksuotas reikšmes, kas turi prasmę tik kaip starto taškas: gamyboje jie turi realiai išbandyti tarnybą – iškvieskite API dvidešimt vieną kartą, kad patvirtintumėte, jog gaunamas 429 klaidos kodas, arba pateikite testinį turinį moderavimui, kad patvirtintumėte jo reakciją. Patikra, kuri visada grąžina „true“, yra blogiau nei jokia patikra, nes ji kuria klaidingą pasitikėjimą nieko nematuodama.
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)
Ko tikisi sertifikuotojas
Siekimas gauti tokį sertifikatą kaip ISO 42001 arba SOC 2 pakeičia pastangų pobūdį, ir tai turi žinoti prieš įsipareigodamas. Dokumentacija yra pirmoje vietoje: atnaujintos politikos, procedūros ir registrai – tai darbas, kurį inžinerijos komandos lengviausiai atideda vėliau. Toliau eina įrodymai – žurnalai, testų ataskaitos, ekrano kopijos – ir juos daug lengviau surinkti, jei archyvuoji juos eigai vykstant, o ne likus trims savaitėms iki audito. Istorija yra sunkiausias reikalavimas, kurį reikia pasivyti: SOC 2 Type II nagrinėja, kaip kontrolės mechanizmai veikė kelis mėnesius, ir to joks paskutinės minutės šturmas negali sukurti. Toliau eina mokymai, ir turi įrodyti, kad jie vyko, o tai reiškia datuotus dalyvių sąrašus ir medžiagą. Galiausiai, nuolatinis tobulinimas reikalauja parodyti, kad nustatyti trūkumai yra ištaisomi ir pertestuojami – tai būtent tas pakartotinio patvirtinimo ciklas iš ankstesnio skyriaus, kurio vertę dabar matai: jis sukuria įrodymus, kurių reikalaus sertifikuotojas.
Audito, taisymo, pertestavimo ir sertifikavimo ciklas neturi pabaigos. Kiekviena nauja funkcija iš naujo atveria kontrolės punktus, ir tai yra tikroji žodžio „nuolatinis“ reikšmė frazėje „nuolatinis tobulinimas“.
Svarbiausi punktai
- Auditas paverčia saugumo gerąją praktiką patikrinamais įrodymais
- Kontrolinis sąrašas apima valdymą, duomenis, techninį saugumą, „raudonosios komandos“ testavimą ir atitiktį
- Privalomos neatitikties yra kliūtys – jos turi būti ištaisytos prieš diegiant
- Nuolatinis auditas automatizuoja pasikartojančias patikras (API raktai, greičio ribojimas, moderavimas)
- Sertifikavimas (ISO 42001, SOC 2) reikalauja dokumentacijos, įrodymų ir istorijos: audito, taisymo ir pertestavimo ciklas yra nuolatinis, niekada vienkartis
Patikrink savo žinias
Puolamasis ir gynybinis saugumas: paskutinė kontrolė prieš auditą.
1. Kas yra prompt injection ataka?
Atsakymas: Kenkėjiškos instrukcijos, įterptos į duomenis, kuriuos modelis apdoroja (tinklalapis, dokumentas, žinutė), siekiant perimti jo elgseną – gynyba: atskirti instrukcijas nuo duomenų, tikrinti išvestis, riboti atskleistas galimybes.
2. „Jailbreaking“ ir prompt injection: koks skirtumas?
Atsakymas: „Jailbreaking“ bando priversti modelį apeiti savo taisykles tiesioginio pokalbio metu; injection veikia per trečiųjų šalių turinį, kurį modelis apdoroja. Abu yra testuojami – ir neutralizuojami – skirtingai.
3. Kodėl reikia daugiasluoksnio filtravimo?
Atsakymas: Nes nė vienas sluoksnis nėra tobulas: įvesties moderavimas, programos apsaugos mechanizmai, išvesties kontrolė ir greičio ribojimas papildo vienas kitą – tai į gylį orientuota gynyba, pritaikyta dirbtiniam intelektui.
4. Ką apima dirbtinio intelekto „raudonosios komandos“ kampanija?
Atsakymas: Metodinį savo sistemos atakavimą (injekcijos scenarijai, „jailbreak“, duomenų nutekinimas) naudojant rizikos taksonomiją, pažeidimų dokumentavimą, taisymo prioritetų nustatymą – ir vėlesnį pertestavimą.
5. Ką apima GDPR aspektas diegiant OpenAI?
Atsakymas: Teisinį duomenų tvarkymo pagrindą, duomenų minimizavimą siunčiamiems duomenims, duomenų subjektų teises ir sutartines apsaugos priemones – atitiktis projektuojama kartu su architektūra, o ne po jos.
Saugi dirbtinio intelekto sistema yra įrodoma: taksonomija, puolamieji testai, daugiasluoksnė gynyba, auditas – tai ciklas, kurį šiame kurse praktikavai.