Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Audit bezpečnosti a certifikace

Lekce 14 z 14 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Od ad hoc bezpečnosti k certifikovatelnému souladu
  2. Zjisti, který rámec se na tebe vztahuje
  3. Kontrolní seznam pokrývající pět domén
  4. Audit znamená požadovat důkazy
  5. Automatizuj, co můžeš
  6. Co certifikátor očekává
  7. Klíčové poznatky
  8. Ověř si své znalosti

Od ad hoc bezpečnosti k certifikovatelnému souladu

Předchozí lekce ti poskytly technické nástroje k zabezpečení systému AI. Jednorázové bezpečnostní kontroly však nestačí – a důvodem není jen byrokracie. To, co ověříš jednou, přestává být ověřeno hned, jak nasadíš další verzi, a nic tuto mezeru neoznačí. Zákazníci, regulátoři i partneři vyžadují formální důkazy: potvrzení, že tvoje kontrolní mechanismy existují, fungují a obstojí v čase. Audit a certifikace promění tvoje postupy v ověřitelný, nepřetržitý rámec.

Zjisti, který rámec se na tebe vztahuje

V oblasti AI se protíná pět rámců, každý s jiným rozsahem. Než se k něčemu zavážeš, musíš je rozlišit.

Standard Rozsah Relevance pro AI
ISO 27001 Bezpečnost informací Základ pro jakýkoli systém zpracovávající data
ISO 42001 Řízení AI Specifické pro AI: správa, rizika, životní cyklus
AI Act (EU) Evropská regulace Povinné pro vysoce rizikové systémy v EU
SOC 2 Type II Bezpečnostní kontroly SaaS Požadováno podnikovými zákazníky
OWASP LLM Top 10 Osvědčené postupy bezpečnosti LLM Referenční kontrolní seznam pro technický audit

Rozhodující rozdíl spočívá v tom, co je povinné a co dobrovolné. Nařízení EU AI Act je závazné: pokud tvůj systém spadá do kategorie vysokého rizika, nemůžeš se mu vyhnout. Normy ISO a SOC 2 jsou dobrovolné certifikace, které typicky vyžadují spíše podnikoví zákazníci než regulátoři. OWASP LLM Top 10 není certifikovatelný – jde o technickou referenci a nejlepší výchozí bod pro první interní audit, protože stojí pouze čas.

Kontrolní seznam pokrývající pět domén

Vážný audit jde nad rámec pouhé techniky. Níže uvedený kontrolní seznam rozkládá své kontrolní body do pěti domén a toto rozložení vypovídá mnoho: správa a soulad mají stejnou váhu jako bezpečnost, protože bezchybné technické nastavení, které nikdo nevlastní a nikde nedokumentuje, u jakéhokoli externího auditu neobstojí.

Kritičnost odděluje povinné od doporučených, což je rozlišení, které později určuje binární rozhodnutí. Sandboxování se objevuje jako doporučené, nikoli povinné, a toto pořadí je oprávněné: týká se pouze systémů, které spouštějí generovaný kód, zatímco filtrování vstupů a výstupů se týká každé aplikace bez výjimky. Dobře nastavený kontrolní seznam nepožaduje po FAQ chatbotovi, aby ospravedlňoval izolaci kontejnerů.

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

Audit znamená požadovat důkazy

Pole, které mění vše při provádění auditu, je evidence. Zaškrtnutí „compliant“ bez odkazu na dokument nemá pro externího auditora žádnou váhu; ten se bude systematicky ptát, co tvrzení podporuje. Ukázka použití to jasně demonstruje: soulad s GOV-01 stojí na pojmenovaném a datovaném dokumentu, nikoli na prohlášení o záměru.

Třetí volání ilustruje nejpodnětnější případ – nesoulad paired s jeho plánem nápravy. Klíč API v souboru prostředí není skandál; je to běžná praxe. Přesto tento kontrolní bod nesplňuje a komentář nastiňuje cestu k souladu. Audit, který neodhalí žádné nesoulady, by měl vzbuzovat podezření: obvykle signalizuje příliš shovívavý kontrolní seznam, nikoli dokonalý systém.

Konečné rozhodnutí je binární a nevážené: jediný povinný nesoulad převrátí verdikt. Míra souladu, vypočítaná vedle toho, měří pokrok mezi audity – nikdy nevyjednává o samotném verdiktu.

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

Jeden poslední čítač – počet nevyhodnocených bodů – hraje tichou, ale rozhodující roli. Zabraňuje tomu, abys zaměňoval „v souladu“ s „nekontrolováno“, což je zmatek, který se plíží dovnitř, když se audit táhne týdny a nikdo si nepamatuje, kde skončil.

Automatizuj, co můžeš

Roční audit zachycuje okamžik. Mezi těmito okamžiky může být klíč API natvrdo zakódován, limit rychlosti vypnut, aby se odblokoval spěchající zákazník, nebo moderování obejit pro rychlý test. Automatizované kontroly tuto mezeru vyplňují během každého cyklu continuous integration.

Ne vše se lendí k automatizaci a měl bys to říct rovnou. Hledání natvrdo zakódovaných klíčů je mechanizovatelné, protože zkoumá kód. Ostatní dvě kontroly v příkladu vracejí natvrdo dané hodnoty, což dává smysl pouze jako výchozí bod: v produkci musí skutečně cvičit službu – zavolat API jednadvacetkrát, aby se potvrdilo, že se objeví 429, nebo odeslat testovací obsah moderování, aby se potvrdilo, že reaguje. Kontrola, která vždy vrátí true, je horší než žádná kontrola, protože vyrábí důvěru bez měření čehokoli.

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)

Co certifikátor očekává

Cílit na certifikaci, jako je ISO 42001 nebo SOC 2, posouvá úsilí jinam a měl bys to vědět, než se zavážeš. Na prvním místě je dokumentace: aktuální zásady, postupy a registry – práce, kterou inženýrské týmy nejraději odkládají. Následují důkazy – logy, zprávy z testů, screenshoty – a ty se mnohem snáze sbírají, pokud je archivuješ průběžně, nikoli tři týdny před auditem. Historie je nejtěžším požadavkem, který se dohání: SOC 2 Type II zkoumá, jak kontroly fungovaly během několika měsíců, což žádný poslední minutový spěch nedokáže vyfabrikovat. Dalším krokem je školení a musíš prokázat, že proběhlo, což znamená datované prezenční listiny a materiály. Nakonec nepřetržité zlepšování vyžaduje ukázat, že zjištění jsou opravována a znovu testována – přesně ten cyklus opětovného ověření z předchozí kapitoly, jehož hodnotu nyní vidíš: produkuje důkazy, které certifikátor bude požadovat.

Cyklus audit, oprava, opětovný test, certifikace nemá konec. Každá nová funkce znovu otevírá kontrolní body a to je právě ten význam slova „nepřetržitý“ ve „zlepšování“.

Klíčové poznatky

  • Audit promění osvědčené bezpečnostní postupy v ověřitelné důkazy
  • Kontrolní seznam pokrývá správu, data, technickou bezpečnost, red teaming a soulad
  • Povinné nesoulady jsou blokující – musí být opraveny před nasazením
  • Průběžný audit automatizuje opakující se kontroly (klíče API, limitování rychlosti, moderování)
  • Certifikace (ISO 42001, SOC 2) vyžaduje dokumentaci, důkazy a historii: cyklus audit, oprava, opětovný test je nepřetržitý, nikdy ne jednorázový

Ověř si své znalosti

Ofenzivní a defenzivní bezpečnost: finální kontrola před auditem.

1. Co je to útok prompt injection?

Odpověď: Škodlivé instrukce propašované do dat, která model zpracovává (webová stránka, dokument, zpráva), aby převzal jeho chování – obrana: izoluj instrukce od dat, validuj výstupy, omez exponované schopnosti.

2. Jailbreaking vs. prompt injection: jaký je rozdíl?

Odpověď: Jailbreaking se snaží přimět model obejít jeho pravidla prostřednictvím přímé konverzace; injection funguje prostřednictvím obsahu třetích stran, který model zpracovává. Obojí se testuje – a counteruje – odlišně.

3. Proč vícevrstvé filtrování?

Odpověď: Protože žádná jednotlivá vrstva není dokonalá: moderování vstupů, aplikační ochranné mechanismy, kontroly výstupů a limitování rychlosti se vzájemně doplňují – obrana do hloubky aplikovaná na AI.

4. Co zahrnuje kampaň red teamingu pro AI?

Odpověď: Metodické útočení na vlastní systém (scénáře injection, jailbreaky, exfiltrace) s taxonomií rizik, dokumentování průniků, prioritizace nápravy – a následné opětovné testování.

5. Co pokrývá úhel pohledu GDPR při nasazení OpenAI?

Odpověď: Právní základ pro zpracování, minimalizaci dat pro odesílaná data, práva subjektů údajů a smluvní záruky – soulad je navržen spolu s architekturou, nikoli až poté.

Bezpečný systém AI je prokazatelný: taxonomie, ofenzivní testy, vícevrstvé obrany, audit – cyklus, který jsi v tomto kurzu procvičoval.