Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Sandboxaus ja eristäminen

Oppitunti 7 / 14 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Miksi tekoälyagentit pitää eristää?
  2. Taso 1: Resurssikäytön rajoittaminen
  3. Taso 2: Lähtevän liikenteen hallinta
  4. Taso 3: Koodin suorittaminen luottamatta siihen koneella
  5. Oikean tason valinta
  6. Keskeiset asiat

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=none ja --read-only tarjoaa vankimman eristyksen
  • Eristystä on testattava säännöllisesti – sandboxin ohittaminen on kriittinen turvallisuustapahtuma