Przejdź do głównej treści
Polski— Wybierz język
Menu

Piaskownice i izolacja

Lekcja 7 z 14 Zaktualizowano 28 lipca 2026 Zaawansowany
Na tej stronie
  1. Dlaczego izolować agentów AI?
  2. Poziom 1: Ograniczenie dostępu do zasobów
  3. Poziom 2: Kontrola ruchu wychodzącego
  4. Poziom 3: Wykonywanie kodu bez powierzania mu maszyny
  5. Wybór odpowiedniego poziomu
  6. Kluczowe wnioski

Dlaczego izolować agentów AI?

Agent AI, który wykonuje kod lub wywołuje narzędzia, fundamentalnie różni się od prostego chatbota. Skompromitowany chatbot generuje co najwyżej zawstydzającą odpowiedź; skompromitowany agent działa – może uruchamiać polecenia systemowe, odczytywać wrażliwe pliki lub komunikować się z usługami zewnętrznymi. Wszystkie dotychczas omówione mechanizmy obronne miały na celu zapobieganie kompromitacji. Piaskownica zmienia podejście: zakłada, że do kompromitacji w końcu dojdzie, i skupia się na ograniczeniu tego, co atakujący może zrobić po dostaniu się do środka. To fundamentalna zmiana, dlatego piaskownica nie zastępuje żadnej z poprzednich warstw.

Poziom 1: Ograniczenie dostępu do zasobów

Pierwszy poziom stosuje zasadę najmniejszych uprawnień do plików i poleceń. Kluczowym aspektem technicznym jest użycie resolve() przed porównaniem: bez niego ścieżka taka jak /data/app/uploads/../../etc/passwd zaczyna się od dozwolonego katalogu i przeszłaby naiwną kontrolę prefiksu. Rozwiązanie rzeczywistej ścieżki udaremnia ten atak typu traversal, który pozostaje jednym z najczęstszych przeciwko agentom manipulującym plikami.

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}")

Polecenia podlegają tej samej logice, stosując białą listę zamiast czarnej. Asymetria jest decydująca: czarna lista zmusza cię do wyobrażenia sobie każdego niebezpiecznego polecenia – ćwiczenia, które przegrasz – podczas gdy biała lista wymaga jedynie wymienienia tego, czego agent faktycznie potrzebuje, często są to zaledwie trzy lub cztery polecenia.

Poziom 2: Kontrola ruchu wychodzącego

Izolacja sieciowa adresuje scenariusz eksfiltracji omawiany wcześniej. Dopóki agent może wysłać żądanie HTTP do dowolnej domeny, wszelkie dane, których dotknie, mogą opuścić twoją strefę, a ruch wychodzący będzie wyglądał jak zwykły ruch aplikacji. Ograniczenie miejsc docelowych do wyraźnej listy zamienia próbę eksfiltracji w zarejestrowany wyjątek.

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}")

Poziom 3: Wykonywanie kodu bez powierzania mu maszyny

Uruchamianie kodu napisanego przez model to najbardziej delikatny przypadek. Poniższa implementacja łączy trzy zabezpieczenia: sprawdzanie importów przed wykonaniem, limity pamięci i czasu CPU ustawione wewnątrz samego skryptu oraz środowisko zredukowane do absolutnego minimum przy uruchamianiu podprocesu.

Konieczne jest ostrzeżenie dotyczące weryfikacji importów. Opiera się ona na wyszukiwaniu tekstu, a uważny atakujący ją ominie – __import__("os") nie zawiera wyszukiwanego ciągu. Traktuj tę weryfikację jako barierę ochronną przed błędami i naiwnymi próbami, nigdy jako granicę bezpieczeństwa. Prawdziwą granicą jest izolowany proces z jego limitami zasobów.

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"}

W przypadkach produkcyjnych Docker zapewnia bardziej solidną izolację, ponieważ nie polega już na współpracy wykonywanego kodu. Każda opcja polecenia zamyka konkretne drzwi: --network=none usuwa wszelką możliwość eksfiltracji sieciowej, --read-only zapobiega utrwalaniu danych, --memory i --cpus limitują zużycie, --tmpfs przyznaje ulotną i ograniczoną przestrzeń roboczą, a --security-opt=no-new-privileges zabrania eskalacji uprawnień podczas wykonywania. Flaga --rm niszczy kontener na końcu, gwarantując, że żaden stan nie przetrwa z jednego wykonania do drugiego.

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": ""}

Wybór odpowiedniego poziomu

Nakładanie wszystkich trzech poziomów na prostego chatbota FAQ jest kosztowne i niepotrzebne, podczas gdy poleganie wyłącznie na pierwszym poziomie dla agenta wykonującego kod oznacza brak jakiejkolwiek ochrony. Poniższa tabela stanowi punkt wyjścia; dostosuj ją w zależności od wrażliwości dostępnych danych, co często ma większe znaczenie niż zaawansowanie samego agenta.

Scenariusz Zalecany poziom
Prosty chatbot Q&A Uprawnienia (Poziom 1)
Agent z dostępem do API Uprawnienia + Sieć (Poziomy 1-2)
Agent wykonujący kod Pełny Docker (Poziom 3)
Agent wieloużytkownikowy Docker + izolacja sesji

Niezależnie od wybranego poziomu, testuj go tak, jak testujesz funkcjonalność. Piaskownica, którą instalujesz i o której zapominasz, po cichu degraduje się w czasie – dodana zależność, tymczasowo podpięty wolumin, domena otwarta do celów rozwiązywania problemów. Przy każdej aktualizacji agenta ponownie uruchamiaj testy przejścia przez ścieżki i niedozwolonych domen: obejście piaskownicy to nie drobna anomalia, to incydent krytyczny.

Kluczowe wnioski

  • Piaskownica jest niezbędna, gdy tylko agent ma dostęp do narzędzi lub wykonuje kod
  • Trzy poziomy izolacji: uprawnienia, sieć, kontener – łącz je w zależności od ryzyka
  • Zasada najmniejszych uprawnień dotyczy każdego zasobu: plików, sieci, poleceń
  • Docker z opcjami --network=none i --read-only zapewnia najbardziej solidną izolację
  • Izolację należy regularnie testować – obejście piaskownicy to incydent krytyczny