Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Izoliavimas ir smėlio dėžės principas

Paskaita 7 iš 14 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Kodėl reikia izoliuoti DI agentus?
  2. 1 lygis: prieigos prie išteklių ribojimas
  3. 2 lygis: išeinančio srauto valdymas
  4. 3 lygis: kodo vykdymas nepasitikint juo mašinos lygmenyje
  5. Tinkamo lygio pasirinkimas
  6. Svarbiausi punktai

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=none ir --read-only suteikia patikimiausią izoliaciją
  • Izoliaciją reikia reguliariai testuoti – smėlio dėžės apėjimas yra kritinis incidentas