Sandboxing e isolamento
In questa pagina
Perché isolare gli agenti AI?
Un agente AI che esegue codice o chiama strumenti è fondamentalmente diverso da un semplice chatbot. Un chatbot compromesso produce, nel peggiore dei casi, una risposta imbarazzante; un agente compromesso agisce: può eseguire comandi di sistema, leggere file sensibili o comunicare con servizi esterni. Tutte le difese affrontate finora miravano a prevenire la compromissione. Il sandboxing cambia l’approccio: presume che la compromissione avverrà inevitabilmente e si concentra sul limitare ciò che un attaccante può fare una volta all’interno. Questo è un cambiamento fondamentale, motivo per cui il sandboxing non sostituisce nessuno degli strati precedenti.
Livello 1: Limitare l’accesso alle risorse
Il primo livello applica il principio del minimo privilegio a file e comandi. Il punto tecnico chiave è usare resolve() prima del confronto: senza di esso, un percorso come /data/app/uploads/../../etc/passwd inizia con la directory consentita e supererebbe un controllo di prefisso ingenuo. Risolvere il percorso reale sventa questa traversata, che rimane uno degli attacchi più comuni contro gli agenti che manipolano file.
import os
from pathlib import Path
class SandboxPermissions:
"""Controlla i permessi di accesso alle risorse."""
def __init__(self, allowed_folder: str, allowed_commands: list[str]):
self.allowed_folder = Path(allowed_folder).resolve()
self.allowed_commands = set(allowed_commands)
def verify_path(self, path: str) -> bool:
"""Verifica che un percorso sia all'interno della cartella consentita."""
resolved_path = Path(path).resolve()
try:
resolved_path.relative_to(self.allowed_folder)
return True
except ValueError:
return False
def verify_command(self, command: str) -> bool:
"""Verifica che un comando sia nella allowlist."""
cmd_base = command.split()[0] if command else ""
return cmd_base in self.allowed_commands
def read_file(self, path: str) -> str:
"""Lettura sicura con verifica del percorso."""
if not self.verify_path(path):
raise PermissionError(
f"Accesso negato: {path} è fuori dalla cartella consentita"
)
return Path(path).read_text()
# Utilizzo
sandbox = SandboxPermissions(
allowed_folder="/data/app/uploads",
allowed_commands=["ls", "cat", "wc"],
)
# OK: file nella cartella consentita
try:
content = sandbox.read_file("/data/app/uploads/report.txt")
except PermissionError as e:
print(f"Bloccato: {e}")
# Bloccato: tentativo di path traversal
try:
content = sandbox.read_file("/data/app/uploads/../../etc/passwd")
except PermissionError as e:
print(f"Bloccato: {e}")
I comandi seguono la stessa logica, utilizzando una allowlist piuttosto che una blocklist. L’asimmetria è decisiva: una blocklist ti costringe a immaginare ogni comando pericoloso, un esercizio che perderai, mentre una allowlist richiede solo di enumerare ciò di cui l’agente ha effettivamente bisogno, spesso solo tre o quattro comandi.
Livello 2: Controllare il traffico in uscita
L’isolamento di rete affronta lo scenario di esfiltrazione discusso in precedenza. Finché l’agente può inviare una richiesta HTTP a qualsiasi dominio, qualsiasi dato che tocca può lasciare il tuo perimetro e il traffico in uscita sembrerà normale traffico applicativo. Limitare le destinazioni a un elenco esplicito trasforma un tentativo di esfiltrazione in un’eccezione registrata nei log.
import subprocess
class NetworkSandbox:
"""Controlla le comunicazioni di rete dell'agente."""
def __init__(self, allowed_domains: list[str]):
self.allowed_domains = set(allowed_domains)
def is_allowed_request(self, url: str) -> bool:
"""Verifica che un URL sia nella allowlist."""
from urllib.parse import urlparse
domain = urlparse(url).hostname
return domain in self.allowed_domains
def secure_fetch(self, url: str) -> str:
"""Richiesta HTTP con verifica del dominio."""
if not self.is_allowed_request(url):
raise PermissionError(f"Dominio non consentito: {url}")
import urllib.request
with urllib.request.urlopen(url, timeout=10) as resp:
return resp.read().decode()
sandbox_net = NetworkSandbox(
allowed_domains=["api.openai.com", "api.anthropic.com"]
)
# OK
try:
sandbox_net.secure_fetch("https://api.openai.com/v1/models")
except PermissionError as e:
print(e)
# Bloccato: esfiltrazione verso un dominio esterno
try:
sandbox_net.secure_fetch("https://attacker.com/collect")
except PermissionError as e:
print(f"Bloccato: {e}")
Livello 3: Eseguire codice senza fidarsi della macchina
Eseguire codice scritto da un modello è il caso più delicato. L’implementazione seguente combina tre protezioni: verifica degli import prima dell’esecuzione, limiti di memoria e tempo CPU impostati all’interno dello script stesso e un ambiente ridotto al minimo indispensabile all’avvio del subprocess.
È necessaria un’avvertenza riguardo alla verifica degli import. Si basa sulla ricerca di testo e un attaccante esperto la eluderà: __import__("os") non contiene la stringa cercata. Considera questa verifica come una guida contro errori e tentativi ingenui, mai come un confine di sicurezza. Il vero confine è il processo isolato con i suoi limiti di risorse.
import subprocess
import tempfile
import os
class ExecutionSandbox:
"""Esegue codice generato dal modello in un ambiente isolato."""
def __init__(self, timeout: int = 10, max_memory_mb: int = 256):
self.timeout = timeout
self.max_memory = max_memory_mb
def execute_python(self, code: str) -> dict:
"""Esegue codice Python in un processo isolato."""
# Controlli di sicurezza prima dell'esecuzione
dangerous_imports = ["os", "subprocess", "shutil", "socket", "requests"]
for imp in dangerous_imports:
if f"import {imp}" in code or f"from {imp}" in code:
return {
"success": False,
"error": f"Import vietato: {imp}",
"output": "",
}
# Crea un file temporaneo
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
# Aggiungi restrizioni all'inizio dello script
wrapper = f"""
import resource
import sys
# Limita la memoria
resource.setrlimit(resource.RLIMIT_AS, ({self.max_memory * 1024 * 1024}, {self.max_memory * 1024 * 1024}))
# Limita il tempo CPU
resource.setrlimit(resource.RLIMIT_CPU, ({self.timeout}, {self.timeout}))
# Codice utente
{code}
"""
f.write(wrapper)
temp_file = f.name
try:
result = subprocess.run(
["python3", temp_file],
capture_output=True,
text=True,
timeout=self.timeout,
env={"PATH": "/usr/bin", "HOME": "/tmp"},
)
return {
"success": result.returncode == 0,
"output": result.stdout[:5000],
"error": result.stderr[:2000] if result.returncode != 0 else "",
}
except subprocess.TimeoutExpired:
return {"success": False, "error": "Timeout superato", "output": ""}
finally:
os.unlink(temp_file)
# Utilizzo
sandbox = ExecutionSandbox(timeout=5, max_memory_mb=128)
# OK: calcolo semplice
result = sandbox.execute_python("print(sum(range(100)))")
print(result) # {"success": True, "output": "4950\n", "error": ""}
# Bloccato: tentativo di accesso al sistema
result = sandbox.execute_python("import os; os.listdir('/')")
print(result) # {"success": False, "error": "Import vietato: os"}
Per i casi di produzione, Docker offre un isolamento più robusto perché non si basa più sulla collaborazione del codice eseguito. Ogni opzione di comando chiude una porta specifica: --network=none rimuove qualsiasi possibilità di esfiltrazione di rete, --read-only previene la persistenza, --memory e --cpus limitano il consumo, --tmpfs concede uno spazio di lavoro volatile e limitato, e --security-opt=no-new-privileges vieta l’escalation durante l’esecuzione. Il flag --rm distrugge il container alla fine, garantendo che nessuno stato sopravviva da un’esecuzione all’altra.
class DockerSandbox:
"""Esegue codice in un container Docker effimero."""
def __init__(self, image: str = "python:3.12-slim"):
self.image = image
def execute(self, code: str, timeout: int = 10) -> dict:
"""Esegue codice in un container isolato."""
cmd = [
"docker", "run", "--rm",
"--network=none", # Nessuna rete
"--memory=256m", # Limite di memoria
"--cpus=0.5", # Limite CPU
"--read-only", # Filesystem in sola lettura
"--tmpfs=/tmp:size=50m", # Spazio temporaneo limitato
"--security-opt=no-new-privileges",
self.image,
"python3", "-c", code,
]
try:
result = subprocess.run(
cmd, capture_output=True, text=True, timeout=timeout
)
return {
"success": result.returncode == 0,
"output": result.stdout[:5000],
"error": result.stderr[:2000],
}
except subprocess.TimeoutExpired:
return {"success": False, "error": "Timeout", "output": ""}
Scegliere il livello giusto
Accatastare tutti e tre i livelli su un semplice chatbot per FAQ è costoso e inutile, mentre affidarsi solo al primo livello per un agente che esegue codice equivale a non proteggere nulla. La tabella seguente fornisce un punto di partenza; adattala in base alla sensibilità dei dati accessibili, che spesso conta più della sofisticazione dell’agente.
| Scenario | Livello consigliato |
|---|---|
| Chatbot semplice Q&A | Permessi (Livello 1) |
| Agente con accesso API | Permessi + Rete (Livelli 1-2) |
| Agente che esegue codice | Docker completo (Livello 3) |
| Agente multi-utente | Docker + isolamento sessione |
Qualunque livello tu scelga, testalo come testeresti una funzionalità. Un sandbox che installi e poi dimentichi si degrada silenziosamente nel tempo: una dipendenza aggiunta, un volume montato “temporaneamente”, un dominio aperto per la risoluzione dei problemi. Riesegui i test di path traversal e di dominio vietato con ogni aggiornamento dell’agente: un bypass del sandbox non è un’anomalia minore, è un incidente critico.
Punti chiave
- Il sandboxing è essenziale non appena un agente ha accesso a strumenti o esegue codice
- Tre livelli di isolamento: permessi, rete, container; combinati in base al rischio
- Il principio del minimo privilegio si applica a ogni risorsa: file, rete, comandi
- Docker con
--network=nonee--read-onlyfornisce l’isolamento più robusto - L’isolamento deve essere testato regolarmente: un bypass del sandbox è un incidente critico