Audit di sicurezza e certificazione
In questa pagina
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.