Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Audit di sicurezza e certificazione

Lezione 14 di 14 Aggiornata il 28 luglio 2026 Avanzato
In questa pagina
  1. Dalla sicurezza ad hoc alla conformità certificabile
  2. Sapere quale framework applicare
  3. Una checklist che copre cinque domini
  4. Audit significa richiedere prove
  5. Automatizza ciò che puoi
  6. Cosa si aspetta un certificatore
  7. Punti chiave
  8. Metti alla prova le tue conoscenze

Dalla sicurezza ad hoc alla conformità certificabile

Le lezioni precedenti ti hanno fornito gli strumenti tecnici per mettere in sicurezza un sistema di IA. Ma i controlli di sicurezza una tantum non bastano, e la ragione non è solo burocrazia. Ciò che verifichi una volta smette di essere verificato non appena pubblichi la release successiva, e nulla segnala questa lacuna. Clienti, enti regolatori e partner richiedono prove formali: la dimostrazione che i tuoi controlli esistano, funzionino e resistano nel tempo. Audit e certificazione trasformano le tue pratiche in un framework verificabile e continuo.

Sapere quale framework applicare

Cinque framework si intersecano nell’ambito dell’IA, ognuno con un ambito diverso. Distingui prima di impegnarti in qualsiasi cosa.

Standard Ambito Rilevanza per l'IA
ISO 27001 Sicurezza delle informazioni Fondamento per qualsiasi sistema che elabora dati
ISO 42001 Gestione dell'IA Specifico per l'IA: governance, rischi, ciclo di vita
AI Act (UE) Regolamentazione europea Obbligatorio per i sistemi ad alto rischio nell'UE
SOC 2 Type II Controlli di sicurezza SaaS Richiesto dai clienti enterprise
OWASP LLM Top 10 Best practice di sicurezza per LLM Checklist di riferimento per audit tecnici

La distinzione decisiva separa ciò che è obbligatorio da ciò che è opzionale. L’AI Act dell’UE è un regolamento: se il tuo sistema rientra nella categoria ad alto rischio, non puoi sottrarti. Gli standard ISO e il SOC 2 sono certificazioni volontarie, tipicamente richieste dai clienti enterprise piuttosto che dagli enti regolatori. L’OWASP LLM Top 10 non è certificabile: è un riferimento tecnico ed è il miglior punto di partenza per un primo audit interno perché costa solo tempo.

Una checklist che copre cinque domini

Un audit serio va oltre la tecnica. La checklist seguente distribuisce i suoi punti di controllo su cinque domini, e questa distribuzione racconta una storia: governance e conformità pesano quanto la sicurezza, perché una configurazione tecnica impeccabile che nessuno possiede e da nessuna parte documentata fallirà qualsiasi audit esterno.

La criticità separa l’obbligatorio dal raccomandato, una distinzione che guida successivamente una decisione binaria. Il sandboxing appare come raccomandato piuttosto che obbligatorio, e questa classifica è giustificata: si applica solo ai sistemi che eseguono codice generato, mentre il filtraggio degli input e degli output riguarda ogni applicazione senza eccezioni. Una checklist ben calibrata non chiede a un chatbot FAQ di giustificare l’isolamento dei container.

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 significa richiedere prove

Il campo che cambia tutto nell’esecuzione dell’audit è evidence. Spuntare “compliant” senza un riferimento documentale non significa nulla per un auditor esterno, che chiederà sistematicamente cosa supporta l’affermazione. L’esempio d’uso lo mostra chiaramente: la conformità GOV-01 si basa su un documento nominato e datato, non su una dichiarazione di intenti.

La terza chiamata illustra il caso più istruttivo: una non conformità abbinata al suo piano di rimedio. Una chiave API in un file di ambiente non è uno scandalo; è una pratica comune. Tuttavia, fallisce comunque il punto di controllo, e il commento delinea il percorso verso la conformità. Un audit che non emerge alcuna non conformità dovrebbe sollevare sospetti: di solito segnala una checklist indulgente, non un sistema perfetto.

La decisione finale è binaria e non ponderata: una singola non conformità obbligatoria ribalta il verdetto. Il tasso di conformità, calcolato contestualmente, misura i progressi tra un audit e l’altro, ma non negozia mai il verdetto stesso.

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 ultimo contatore — il numero di punti non valutati — svolge un ruolo silenzioso ma decisivo. Ti impedisce di confondere “conforme” con “non controllato”, una confusione che si insinua quando un audit si protrae per settimane e nessuno ricorda dove si è interrotto.

Automatizza ciò che puoi

Un audit annuale cattura un’istantanea. Tra un’istantanea e l’altra, una chiave API può essere hardcodata, un rate limit disabilitato per sbloccare un cliente frettoloso, o la moderazione bypassata per un test rapido. I controlli automatizzati colmano questa lacuna eseguendosi ad ogni ciclo di integrazione continua.

Non tutto si presta all’automazione, e dovresti dirlo chiaramente. La ricerca di chiavi hardcodate è meccanizzabile perché ispeziona il codice. Gli altri due controlli nell’esempio restituiscono valori hardcodati, il che ha senso solo come punto di partenza: in produzione, devono effettivamente esercitare il servizio — chiamare l’API ventuno volte per confermare che appaia un 429, o inviare contenuti di test alla moderazione per confermare che risponda. Un controllo che restituisce sempre vero è peggio di nessun controllo, perché genera fiducia senza misurare nulla.

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)

Cosa si aspetta un certificatore

Puntare a una certificazione come ISO 42001 o SOC 2 sposta lo sforzo, e dovresti saperlo prima di impegnarti. La documentazione viene prima: politiche, procedure e registri aggiornati, il lavoro che i team di ingegneria rimandano più volentieri. Seguono le prove: log, report di test, screenshot, ed è molto più facile raccoglierle se le archivi man mano che procedi piuttosto che tre settimane prima dell’audit. La storia è il requisito più difficile da recuperare: un SOC 2 Type II esamina come i controlli hanno operato nell’arco di diversi mesi, qualcosa che nessuna spinta dell’ultimo minuto può fabbricare. La formazione viene dopo, e devi dimostrare che è avvenuta, il che significa fogli presenza datati e materiali. Infine, il miglioramento continuo richiede di mostrare che le scoperte vengono risolte e ritestate — esattamente il ciclo di rivalidazione del capitolo precedente, il cui valore ora vedi: produce le prove che il certificatore richiederà.

Il ciclo audit, correzione, retest, certificazione non ha fine. Ogni nuova funzionalità riapre i punti di controllo, e questo è proprio il significato di “continuo” in “miglioramento continuo”.

Punti chiave

  • L’audit trasforma le best practice di sicurezza in prove verificabili
  • La checklist copre governance, dati, sicurezza tecnica, red teaming e conformità
  • Le non conformità obbligatorie sono bloccanti: devono essere risolte prima del deployment
  • L’audit continuo automatizza i controlli ripetitivi (chiavi API, rate limiting, moderazione)
  • La certificazione (ISO 42001, SOC 2) richiede documentazione, prove e storia: il ciclo audit, correzione, retest è continuo, mai una tantum

Metti alla prova le tue conoscenze

Sicurezza offensiva e difensiva: il controllo finale prima dell’audit.

1. Cos'è un attacco di prompt injection?

Risposta: Istruzioni malevole inserite nei dati che il modello elabora (pagina web, documento, messaggio) per dirottarne il comportamento — difesa: isolare le istruzioni dai dati, validare gli output, limitare le capacità esposte.

2. Jailbreaking vs. prompt injection: qual è la differenza?

Risposta: Il jailbreaking cerca di far aggirare al modello le sue regole attraverso la conversazione diretta; l’injection agisce tramite contenuti di terze parti che esso elabora. Entrambi vengono testati — e contrastati — in modo diverso.

3. Perché il filtraggio a più livelli?

Risposta: Perché nessun singolo livello è perfetto: moderazione degli input, guardrail applicativi, controlli degli output e rate limiting si completano a vicenda — difesa in profondità applicata all’IA.

4. Cosa comporta una campagna di red teaming per l'IA?

Risposta: Attaccare metodicamente il proprio sistema (scenari di injection, jailbreak, esfiltrazione) con una tassonomia dei rischi, documentare le violazioni, dare priorità alla remediation — e poi ritestare.

5. Cosa copre l'angolazione GDPR in un deployment OpenAI?

Risposta: La base giuridica per l’elaborazione, la minimizzazione dei dati inviati, i diritti degli interessati e le garanzie contrattuali — la conformità è progettata con l’architettura, non dopo.

Un sistema di IA sicuro è dimostrato: tassonomia, test offensivi, difese a strati, audit — il ciclo che questo corso ti ha fatto praticare.