Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Biztonsági audit és tanúsítás

14. lecke 14 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. Az eseti biztonságtól a tanúsítható megfelelőségig
  2. Tudd, melyik keretrendszer vonatkozik rád
  3. Öt területet lefedő ellenőrzőlista
  4. Az audit a bizonyítékok követelését jelenti
  5. Automatizáld, amit lehet
  6. Mit vár el egy tanúsító?
  7. Főbb megállapítások
  8. Teszteld a tudásod

Az eseti biztonságtól a tanúsítható megfelelőségig

Az előző leckék megadták neked azokat a technikai eszközöket, amelyekkel biztonságossá teheted az AI-rendszereidet. De az egyszeri biztonsági ellenőrzések nem elegendőek – és ennek oka nem csupán a bürokrácia. Amit egyszer ellenőrzöl, az a következő verzió kiadásával máris ellenőrizetlenné válik, és semmi sem jelzi ezt a rést. Az ügyfelek, szabályozó hatóságok és partnerek formális bizonyítékot követelnek: igazolást arról, hogy az ellenőrzési pontjaid léteznek, működnek, és idővel is megállják a helyüket. Az audit és a tanúsítás a gyakorlataidat ellenőrizhető, folyamatos keretrendszerré alakítja.

Tudd, melyik keretrendszer vonatkozik rád

Öt keretrendszer metszi egymást az AI területén, mindegyik eltérő hatókörrel. Mielőtt bármit is vállalnál, tedd különbséget közöttük.

Standard Hatókör AI-relevancia
ISO 27001 Információbiztonság Alap bármilyen adatot feldolgozó rendszerhez
ISO 42001 AI-menedzsment AI-specifikus: irányítás, kockázat, életciklus
AI Act (EU) Európai szabályozás Kötelező a magas kockázatú rendszerekre az EU-ban
SOC 2 Type II SaaS biztonsági kontrollok Vállalati ügyfelek követelik
OWASP LLM Top 10 LLM biztonsági legjobb gyakorlatok Technikai audit referencia-listája

A döntő különbségtétel a kötelező és az önkéntes elemek között húzódik. Az EU AI Act egy rendelet: ha a rendszered a magas kockázatú kategóriába esik, nincs lehetőséged kivonni magad alóla. Az ISO-szabványok és a SOC 2 önkéntes tanúsítványok, amelyeket jellemzően nem a szabályozók, hanem a vállalati ügyfelek követelnek meg. Az OWASP LLM Top 10 nem tanúsítható – ez egy technikai referencia, és a legjobb kiindulópont egy első belső audithoz, mivel csak időbe kerül.

Öt területet lefedő ellenőrzőlista

Egy komoly audit túlmutat a technikán. Az alábbi ellenőrzőlista az ellenőrzési pontokat öt területre osztja szét, és ez az eloszlás sokat elárul: az irányítás és a megfelelőség ugyanolyan súllyal bír, mint a biztonság, mert egy hibátlan technikai felépítés, amelynek nincs gazdája és sehol sincs dokumentálva, bármely külső auditon elbukik.

A kritikalitás választja el a kötelezőt az ajánlottól; ez a megkülönböztetés később bináris döntést驱动. A homokozó (sandboxing) ajánlottként, nem pedig kötelezőként jelenik meg, és ez a rangsorolás indokolt: csak azoknál a rendszereknél alkalmazandó, amelyek generált kódot futtatnak, míg a bemeneti és kimeneti szűrés kivétel nélkül minden alkalmazást érint. Egy jól kalibrált ellenőrzőlista nem kérdezi meg egy FAQ chatbotot, hogy indokolja meg a konténer-elkülönítést.

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"),
    ]

Az audit a bizonyítékok követelését jelenti

Az a mező, amely mindent megváltoztat az audit végrehajtásában, az evidence (bizonyíték). A „megfelelő“ bepipálása dokumentumhivatkozás nélkül semmit sem ér egy külső auditor számára, aki szisztematikusan megkérdezi, mi támasztja alá az állítást. A használati példa ezt világosan mutatja: a GOV-01 megfelelősége egy névvel és dátummal ellátott dokumentumon alapul, nem pedig egy szándéknyilatkozaton.

A harmadik hívás illusztrálja a legtanulságosabb esetet – egy meg nem felelést a hozzá tartozó javítási tervvel párosítva. Egy API-kulcs egy környezeti fájlban nem botrány; ez gyakori gyakorlat. Ettől még megbukik az ellenőrzési ponton, és a megjegyzés vázolja a megfeleléshez vezető utat. Egy olyan audit, amely egyetlen meg nem felelést sem tár fel, gyanút kell hogy keltsen: ez általában egy túl engedékeny ellenőrzőlistát jelez, nem pedig egy tökéletes rendszert.

A végső döntés bináris és súlyozatlan: egyetlen kötelező meg nem felelés is megfordítja az ítéletet. A mellette számított megfelelőségi arány az auditok közötti fejlődést méri – sosem tárgyalja felül magát az ítéletet.

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']}")

Egy utolsó számláló – a ki nem értékelt pontok száma – csendes, de döntő szerepet játszik. Megakadályozza, hogy összekeverd a „megfelelőt“ a „nem ellenőrzöttel“, ami könnyen előfordul, amikor egy audit heteken át húzódik, és senki nem emlékszik, hol állt meg.

Automatizáld, amit lehet

Az éves audit egy pillanatfelvételt rögzít. A pillanatfelvételek között egy API-kulcs beékelődhet a kódba, egy sebességkorlátozást kikapcsolhatnak egy sürgető ügyfél miatt, vagy egy gyors teszt kedvéért megkerülhetik a moderációt. Az automatizált ellenőrzések töltik be ezt a rést azáltal, hogy minden folyamatos integrációs ciklusban lefutnak.

Nem minden alkalmas automatizálásra, és ezt egyenesen ki is kell mondani. A beékelődött kulcsok keresése gépesíthető, mivel ez a kód inspectálását jelenti. A példában szereplő másik két ellenőrzés hardcoded értékeket ad vissza, ami csak kiindulópontként van értelme: éles környezetben ténylegesen tesztelniük kell a szolgáltatást – hívják meg az API-t huszonegyszer, hogy megerősítsék a 429-es hiba megjelenését, vagy küldjenek teszt tartalmat a moderációnak, hogy lássák, reagál-e. Egy olyan ellenőrzés, amely mindig igazat ad vissza, rosszabb, mint a semmilyen, mert bizalmat gyárt anélkül, hogy bármit is mérne.

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)

Mit vár el egy tanúsító?

Ha olyan tanúsítványra pályázol, mint az ISO 42001 vagy a SOC 2, az megváltoztatja a ráfordítást, és ezt érdemes tudnod, mielőtt elköteleződnél mellette. Az első helyen a dokumentáció áll: naprakész irányelvek, eljárásrendek és nyilvántartások – ez az a munka, amelyet a mérnöki csapatok a leggyakrabban halogatnak. Ezt követi a bizonyíték – naplók, tesztjelentések, képernyőmentések –, amelyet sokkal könnyebb összegyűjteni, ha menet közben archiválod őket, nem pedig három héttel az audit előtt. A történetiség a legnehezebben pótolható követelmény: egy SOC 2 Type II azt vizsgálja, hogyan működtek a kontrollok több hónap alatt, amit semmilyen utolsó pillanatos erőfeszítés nem tud hamisítani. Ezután jön a képzés, és bizonyítanod kell, hogy megtörtént, ami dátumozott jelenléti íveket és anyagokat jelent. Végül a folyamatos fejlesztés megköveteli, hogy bemutasd: a feltárt hiányosságokat kijavították és újra tesztelték – pontosan ez az előző fejezetből ismert újraérvényesítési ciklus, amelynek értékét most már látod: ez állítja elő azokat a bizonyítékokat, amelyeket a tanúsító kérni fog.

Az audit, javítás, újratesztelés, tanúsítás ciklusnak nincs vége. Minden új funkció újra megnyitja az ellenőrzési pontokat, és ez a „folyamatos“ szó valódi jelentése a „folyamatos fejlesztés“ kifejezésben.

Főbb megállapítások

  • Az audit a biztonsági legjobb gyakorlatokat ellenőrizhető bizonyítékokká alakítja
  • Az ellenőrzőlista lefedi az irányítást, az adatkezelést, a technikai biztonságot, a red teaminget és a megfelelőséget
  • A kötelező meg nem felelések blokkolók – ezeket deployment előtt ki kell javítani
  • A folyamatos audit automatizálja az ismétlődő ellenőrzéseket (API-kulcsok, sebességkorlátozás, moderáció)
  • A tanúsítás (ISO 42001, SOC 2) dokumentációt, bizonyítékot és történetiséget igényel: az audit-javítás-újratesztelés ciklus folyamatos, sosem egyszeri

Teszteld a tudásod

Támadó és védekező biztonság: az utolsó kontroll az audit előtt.

1. Mi az a prompt injection támadás?

Válasz: Rosszindulatú utasítások, amelyeket a modell által feldolgozott adatokba (weboldal, dokumentum, üzenet) csempésznek, hogy eltérítsék annak viselkedését – védekezés: az utasítások és az adatok elkülönítése, a kimenetek validálása, a kitett képességek korlátozása.

2. Jailbreaking vs. prompt injection: mi a különbség?

Válasz: A jailbreaking arra tesz kísérletet, hogy közvetlen beszélgetéssel rávegye a modellt a szabályai megkerülésére; az injection harmadik féltől származó tartalmakon keresztül működik, amelyeket a modell feldolgoz. Mindkettőt másképp tesztelik – és másképp hárítják.

3. Miért szükséges a többrétegű szűrés?

Válasz: Mert egyetlen réteg sem tökéletes: a bemeneti moderáció, az alkalmazás szintű védőkorlátok, a kimeneti kontrollok és a sebességkorlátozás kiegészítik egymást – ez a mélységi védelem alkalmazása az AI-ra.

4. Miből áll egy AI red teaming kampány?

Válasz: A saját rendszered módszeres megtámadásából (injection szcenáriók, jailbreakek, adatlopás) egy kockázati taxonómia alapján, a jogsértések dokumentálásából, a javítások prioritási sorrendbe állításából – majd az újratesztelésből.

5. Mit fed le a GDPR szempont egy OpenAI telepítésnél?

Válasz: Az adatkezelés jogalapját, a továbbított adatok minimalizálását, az érintetti jogokat és a szerződéses garanciákat – a megfelelőséget az architektúrával együtt tervezik meg, nem utólag.

Egy biztonságos AI-rendszer bizonyított: taxonómia, támadó tesztek, rétegzett védelem, audit – ez a ciklus, amelyet ezen a kurzuson gyakoroltál.