Peskovniško okolje in izolacija
Na tej strani
Zakaj izolirati agente umetne inteligence?
Agent umetne inteligence, ki izvaja kodo ali kliče orodja, se bistveno razlikuje od preprostega klepetalnega robota. Ogrožen klepetalni robot v najboljšem primeru ustvari neprijeten odgovor; ogrožen agent pa deluje – lahko izvaja sistemske ukaze, bere občutljive datoteke ali komunicira z zunanjimi storitvami. Vse doslej obravnavane obrambe so bile usmerjene v preprečevanje vdora. Peskovniško okolje spremeni pristop: predpostavlja, da do vdora sčasoma pride, in se osredotoča na omejevanje tega, kar lahko napadalec stori, ko je enkrat znotraj sistema. To je temeljni premik, zato peskovniško okolje ne nadomešča nobene od prejšnjih plasti.
1. raven: Omejitev dostopa do virov
Prva raven uporablja načelo najmanjših privilegijev za datoteke in ukaze. Ključna tehnična točka je uporaba funkcije resolve() pred primerjavo: brez nje bi pot, kot je /data/app/uploads/../../etc/passwd, začela z dovoljeno mapo in bi prestala naivno preverjanje predpone. Razrešitev dejanske poti prepreči to vrsto napada, ki ostaja eden najpogostejših napadov na agente, ki manipulirajo z datotekami.
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}")
Ukazi sledijo isti logiki z uporabo seznama dovoljenih ukazov namesto seznama blokiranih. Asimetrija je odločilna: seznam blokiranih ukazov vas prisili, da si zamislite vsak nevaren ukaz – naloga, pri kateri boste izgubili –, medtem ko seznam dovoljenih ukazov zahteva le naštevanje tistega, kar agent dejansko potrebuje, kar je pogosto le tri ali štiri ukaze.
2. raven: Nadzor odhodnega prometa
Omrežna izolacija obravnava scenarij iztoka podatkov, o katerem smo razpravljali prej. Dokler lahko agent pošlje zahtevo HTTP na katero koli domeno, lahko vsak podatek, do katerega ima dostop, zapusti vaš obseg, odhodni promet pa bo videti kot običajen aplikacijski promet. Omejitev ciljev na izrecen seznam spremeni poskus iztoka podatkov v zabeleženo izjemo.
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. raven: Izvajanje kode brez zaupanja stroju
Izvajanje kode, ki jo napiše model, je najbolj občutljiv primer. Spodnja implementacija združuje tri zaščite: preverjanje uvozov pred izvajanjem, omejitve pomnilnika in časa procesorja, nastavljene znotraj samega skripta, ter okolje, zmanjšano na najnujnejše ob zagonu podprocesa.
Pri preverjanju uvozov je potrebno opozorilo. Zanaša se na iskanje besedila in previden napadalec ga bo obšel – __import__("os") ne vsebuje iskanega niza. To preverjanje obravnavajte kot varnostno ograjo pred napakami in naivnimi poskusi, nikoli pa kot varnostno mejo. Prava meja je izoliran proces z lastnimi omejitvami virov.
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"}
Za produkcijske primere Docker zagotavlja robustnejšo izolacijo, saj se ne zanaša več na sodelovanje izvajane kode. Vsaka možnost ukaza zapre specifična vrata: --network=none odstrani vsako možnost iztoka podatkov po omrežju, --read-only prepreči trajnost shranjevanja, --memory in --cpus omejita porabo, --tmpfs dodeli nestalen in omejen delovni prostor, --security-opt=no-new-privileges pa prepove eskalacijo med izvajanjem. Zastavica --rm ob koncu uniči vsebnik in zagotavlja, da med izvajanjem ne ostane nobeno stanje.
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": ""}
Izbira prave ravni
Nalaganje vseh treh ravni na preprost klepetalni robot za pogosta vprašanja je drago in nepotrebno, medtem ko se zanašanje le na prvo raven za agenta, ki izvaja kodo, enači z nezaščito ničesar. Spodnja tabela ponuja izhodišče; prilagodite jo glede na občutljivost dostopnih podatkov, kar je pogosto pomembneje od sofisticiranosti samega agenta.
| Scenarij | Priporočena raven |
|---|---|
| Preprost klepetalni robot za vprašanja in odgovore | Dovoljenja (1. raven) |
| Agent z dostopom do API-ja | Dovoljenja + omrežje (1. in 2. raven) |
| Agent, ki izvaja kodo | Polni Docker (3. raven) |
| Večuporabniški agent | Docker + izolacija sej |
Ne glede na izbrano raven jo testirajte tako, kot bi testirali funkcijo. Peskovniško okolje, ki ga namestite in pozabite, sčasoma tiho degradira – dodana odvisnost, začasno priklopljen volumen, domena, odprta za odpravljanje težav. Ob vsaki posodobitvi agenta ponovno zaženite teste obhoda poti in prepovedanih domen: obhod peskovniškega okolja ni manjša anomalija, temveč kritičen incident.
Ključne ugotovitve
- Peskovniško okolje je bistveno, takoj ko ima agent dostop do orodij ali izvaja kodo
- Tri ravni izolacije: dovoljenja, omrežje, vsebnik – združite glede na tveganje
- Načelo najmanjših privilegijev velja za vsak vir: datoteke, omrežje, ukaze
- Docker z možnostma
--network=nonein--read-onlyzagotavlja najbolj robustno izolacijo - Izolacijo je treba redno testirati – obhod peskovniškega okolja je kritičen incident