Sandboxing un izolācija
Šajā lapā
Kāpēc izolēt AI aģentus?
AI aģents, kas izpilda kodu vai izsauc rīkus, fundamentāli atšķiras no vienkārša tērzēšanas bota. Apdraudēts čatbots sliktākajā gadījumā ģenerē kaunojošu atbildi; apdraudēts aģents rīkojas — tas var palaist sistēmas komandas, lasīt sensitīvus failus vai komunicēt ar ārējiem servisiem. Visas līdz šim aplūkotās aizsardzības metodes bija vērstas uz kompromitācijas novēršanu. Sandboxing maina pieeju: tas pieņem, ka kompromitācija agrāk vai vēlāk notiks, un koncentrējas uz to, lai ierobežotu uzbrucēja iespējas, tiklīdz tas ir iekļuvis sistēmā. Šī ir fundamentāla maiņa, tāpēc sandboxing neaizstāj nevienu no iepriekšējiem slāņiem.
1. līmenis: resursu piekļuves ierobežošana
Pirmais līmenis pielieto minimālo privilēģiju principu failiem un komandām. Galvenais tehniskais aspekts ir funkcijas resolve() izmantošana pirms salīdzināšanas: bez tās ceļš, piemēram, /data/app/uploads/../../etc/passwd, sākas ar atļauto direktoriju un izietu cauri naivai prefiksa pārbaudei. Reālā ceļa atrisināšana (resolve) novērš šo traversēšanu, kas joprojām ir viens no izplatītākajiem uzbrukumiem pret aģentiem, kas manipulē ar failiem.
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}")
Komandas ievēro to pašu loģiku, izmantojot atļauto sarakstu (allowlist), nevis bloķēto sarakstu (blocklist). Asimetrija ir izšķiroša: bloķētais saraksts liež tev iztēloties katru bīstamo komandu — uzdevums, kurā tu zaudēsi, — turpretī atļauto saraksts prasa tikai uzskaitīt to, kas aģentam faktiski nepieciešams, bieži vien tikai trīs vai četras komandas.
2. līmenis: izejošās satiksmes kontrole
Tīkla izolācija risina iepriekš apspriesto datu noplūdes scenāriju. Kamēr aģents var nosūtīt HTTP pieprasījumu uz jebkuru domēnu, jebkuri dati, kuriem tas pieskaras, var pamest tavu perimetru, un izejošā satiksme izskatīsies kā parasta lietotnes satiksme. Mērķu ierobežošana līdz eksplicītam sarakstam pārvērš noplūdes mēģinājumu reģistrētā izņēmumā.
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}")
3. līmenis: koda izpilde, neuzticoties tam ar mašīnu
Modeļa ģenerēta koda izpilde ir visdelikātākais gadījums. Tālāk redzamā implementācija apvieno trīs aizsardzības slāņus: importu pārbaudi pirms izpildes, atmiņas un CPU laika limitus, kas iestatīti pašā skriptā, un vidi, kas samazināta līdz absolūtajam minimumam, palaižot apakšprocesu.
Nepieciešams brīdinājums attiecībā uz importu verificēšanu. Tā balstās uz teksta meklēšanu, un izmanīgs uzbrucējs to apiet — __import__("os") nesatur meklēto virkni. Uztver šo verificēšanu kā aizsargbarjeru pret kļūdām un naiviem mēģinājumiem, nekad kā drošības robežu. Īstā robeža ir izolētais process ar saviem resursu limitiem.
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"}
Produkcijas vidēm Docker nodrošina robustāku izolāciju, jo tas vairs nepaļaujas uz izpildāmā koda sadarbību. Katra komandas opcija aizver konkrētas durvis: --network=none novērš jebkādu tīkla noplūdi, --read-only neļauj saglabāt datus, --memory un --cpus ierobežo patēriņu, --tmpfs piešķir nestabilu un limitētu darba vietu, bet --security-opt=no-new-privileges aizliedz privilēģiju paaugstināšanu izpildes laikā. Karogs --rm dzēš konteineru beigās, garantējot, ka neviena stāvokļa informācija nepāriet no vienas izpildes uz nākamo.
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": ""}
Pareizā līmeņa izvēle
Visu trīs līmeņu sakraušana vienkāršam FAQ čatbotam ir dārga un nevajadzīga, savukārt paļaušanās tikai uz pirmo līmeni aģentam, kas izpilda kodu, nozīmē neaizsargāt neko. Tālāk esošā tabula sniedz sākumpunktu; pielāgo to, ņemot vērā pieejamo datu sensitivitāti, kas bieži vien ir svarīgāka par paša aģenta sarežģītību.
| Scenārijs | Ieteicamais līmenis |
|---|---|
| Vienkāršs jautājumu un atbilžu čatbots | Atļaujas (1. līmenis) |
| Aģents ar API piekļuvi | Atļaujas + Tīkls (1.–2. līmenis) |
| Aģents, kas izpilda kodu | Pilns Docker (3. līmenis) |
| Daudzlietotāju aģents | Docker + sesiju izolācija |
Neatkarīgi no izvēlētā līmeņa, testē to tāpat kā jebkuru citu funkcionalitāti. Sandbox, ko uzstādi un aizmirsti, laika gaitā nemanāmi degradējas — jauna atkarība, „uz laiku” pievienots sējums, domēns, atvērts problēmu novēršanai. Atkārto ceļa traversēšanas un aizliegto domēnu testus ar katru aģenta atjauninājumu: sandbox apiešana nav neliela anomālija, tas ir kritisks incidents.
Galvenās atziņas
- Sandboxing ir būtisks tiklīdz aģentam ir piekļuve rīkiem vai tas izpilda kodu
- Trīs izolācijas līmeņi: atļaujas, tīkls, konteiners — kombinē atbilstoši riskam
- Minimālo privilēģiju princips attiecas uz katru resursu: failiem, tīklu, komandām
- Docker ar
--network=noneun--read-onlynodrošina visrobustāko izolāciju - Izolācija ir regulāri jātestē — sandbox apiešana ir kritisks incidents