Izoliavimas ir smėlio dėžės principas
Šiame puslapyje
Kodėl reikia izoliuoti DI agentus?
DI agentas, vykdantis kodą arba kviečiantis įrankius, iš esmės skiriasi nuo paprasto pokalbių roboto. Kompromituotas pokalbių robotas gali sugeneruoti tik gėdingą atsakymą, o kompromituotas agentas veikia – jis gali vykdyti sistemos komandas, skaityti konfidencialius failus arba bendrauti su išorinėmis tarnybomis. Visos iki šiol nagrinėtos apsaugos priemonės buvo skirtos užkirsti kelią kompromitavimui. Smėlio dėžės (sandboxing) principas keičia šį požiūrį: jis daro prielaidą, kad kompromitavimas anksčiau ar vėliau įvyks, ir sutelkia dėmesį į tai, kaip apriboti puolėjo veiksmus jau patekus į sistemą. Tai esminis posūkis, todėl smėlio dėžė nepakeičia jokių ankstesnių apsaugos sluoksnių.
1 lygis: prieigos prie išteklių ribojimas
Pirmasis lygis taiko mažiausių privilegijų principą failams ir komandoms. Pagrindinis techninis aspektas – naudoti resolve() prieš atliekant palyginimą. Be jo, toks kelias kaip /data/app/uploads/../../etc/passwd prasideda leidžiamu katalogu ir praeitų naivų priešdėlio tikrinimą. Tikrojo kelio išsprendimas (resolving) neutralizuoja šį naršymą, kuris lieka vienu dažniausių atakų būdų prieš agentus, manipuliuojančius failais.
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}")
Komandoms taikoma ta pati logika: naudojamas leidimų sąrašas (allowlist), o ne draudimų sąrašas (blocklist). Ši asimetrija yra lemiamas veiksnys: draudimų sąrašas verčia tave įsivaizduoti kiekvieną pavojingą komandą – užduotis, kurioje pralaimėsi, – tuo tarpu leidimų sąrašui pakanka išvardyti tik tai, ko agentui iš tikrųjų reikia, dažnai tai tėra trys ar keturios komandos.
2 lygis: išeinančio srauto valdymas
Tinklo izoliacija sprendžia anksčiau aptartą duomenų nutekinimo scenarijų. Kol agentas gali siųsti HTTP užklausą į bet kurį domeną, visi duomenys, kurių jis liečia, gali palikti tavo perimetrą, o išeinantis srautas atrodys kaip įprastas programos srautas. Paskirties vietų apribojimas iki aiškaus sąrašo paverčia bandymą nutekinti duomenis užfiksuota išimtimi.
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 lygis: kodo vykdymas nepasitikint juo mašinos lygmenyje
Modelio sugeneruoto kodo vykdymas yra pats sudėtingiausias atvejis. Toliau pateiktas įgyvendinimas sujungia tris apsaugos priemones: importavimo tikrinimą prieš vykdant, atminties ir CPU laiko limitus, nustatytus pačiame skripte, bei aplinkos sumažinimą iki būtinojo minimumo paleidžiant subprocesą.
Būtina įspėti dėl importavimo tikrinimo. Jis remiasi teksto paieška, o atidus puolėjas jį apeis – __import__("os") neturi ieškomo teksto. Laikyk šį tikrinimą tik kaip apsauginę priemonę nuo klaidų ir naivių bandymų, bet niekada kaip saugumo ribos. Tikroji riba yra izoliuotas procesas su savo išteklių limitais.
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"}
Gamybiniais atvejais Docker suteikia patikimesnę izoliaciją, nes nebereikia pasikliauti vykdomo kodo bendradarbiavimu. Kiekviena komandos parinktis užveria specifines duris: --network=none pašalina bet kokią galimybę nutekinti duomenis tinklu, --read-only neleidžia išsaugoti duomenų, --memory ir --cpus riboja išteklių sunaudojimą, --tmpfs suteikia laikiną ir ribotą darbo erdvę, o --security-opt=no-new-privileges draudžia privilegijų didinimą vykdymo metu. --rm žymė sunaikina konteinerį pabaigoje, garantuodama, kad jokia būsena neišlieka nuo vieno vykdymo iki kito.
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": ""}
Tinkamo lygio pasirinkimas
Visų trijų lygių taikymas paprastam DUK pokalbių robotui yra brangu ir nereikalinga, tuo tarpu pasikliauti tik pirmuoju lygmeniu agentui, vykdančiam kodą, reiškia nieko neapsaugoti. Toliau pateikta lentelė yra atspirties taškas; koreguok ją pagal prieinamų duomenų jautrumą, kuris dažnai yra svarbesnis nei paties agento sudėtingumas.
| Scenarijus | Rekomenduojamas lygis |
|---|---|
| Paprastas klausimų ir atsakymų pokalbių robotas | Leidimai (1 lygis) |
| Agentas su API prieiga | Leidimai + Tinklas (1–2 lygiai) |
| Kodą vykdantis agentas | Pilnas Docker (3 lygis) |
| Keliems naudotojams skirtas agentas | Docker + sesijų izoliavimas |
Nepriklausomai nuo pasirinkto lygio, testuok jį taip, kaip testuotum naują funkciją. Smėlio dėžė, kurią įdiegi ir pamiršti, laikui bėgant tyliai degraduoja – pridėta priklausomybė, „laikinai“ prijungtas tomas arba domenas, atvertas trikčių šalinimui. Su kiekvienu agento atnaujinimu iš naujo paleisk kelio naršymo ir draudžiamų domenų testus: smėlio dėžės apėjimas nėra nedidelė anomalija, tai kritinis incidentas.
Svarbiausi punktai
- Smėlio dėžė yra būtina, kai tik agentas gauna prieigą prie įrankių arba vykdo kodą
- Trys izoliacijos lygiai: leidimai, tinklas, konteineris – derinkite juos pagal riziką
- Mažiausių privilegijų principas taikomas kiekvienam ištekliui: failams, tinklui, komandoms
- Docker su
--network=noneir--read-onlysuteikia patikimiausią izoliaciją - Izoliaciją reikia reguliariai testuoti – smėlio dėžės apėjimas yra kritinis incidentas