Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Sandboxáil agus leithlisiú

Ceacht 7 as 14 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Cén fáth gníomhairí AI a leithlisiú?
  2. Leibhéal 1: Rochtain acmhainní a shrianta
  3. Leibhéal 2: Trácht amach a rialú
  4. Leibhéal 3: Cód a fheidhmiú gan muinín a bheith agat as leis an meaisín
  5. An leibhéal ceart a roghnú
  6. Príomhphointí

Cén fáth gníomhairí AI a leithlisiú?

Tá gníomhaire AI a fheidhmíonn cód nó a ghlaonn uirlisí bunúsach difriúil ó chatbot simplí. Is é an toradh is measa ar chatbot atá curtha i mbaol ná freagra náireach; ach gníomhaíonn gníomhaire atá curtha i mbaol—is féidir leis ordaithe córais a rith, comhaid íogaire a léamh, nó teachtaireachtaí a sheoladh chuig seirbhísí seachtracha. Bhí sé mar aidhm ag na cosaintí go léir a pléadh go dtí seo comhbhrú a chosc. Athraíonn an tsandboxáil an cur chuige: glacann sí leis go dtarlóidh comhbhrú ar deireadh thiar agus díritheann sí ar theorannú a dhéanamh ar an méid is féidir le hionsaitheoir a dhéanamh nuair a bheidh sé istigh. Is athrú bunúsach é seo, agus is é an fáth nach gcuireann an tsandboxáil in ionad aon cheann de na sraitheanna roimhe seo.

Leibhéal 1: Rochtain acmhainní a shrianta

Cuirtear prionsabal na pribhléide is lú i bhfeidhm ar chomhaid agus ar ordaithe sa chéad leibhéal. Is é an pointe teicniúil lárnach ná resolve() a úsáid roimh chur i gcomparáid: gan é, thosódh conair mar /data/app/uploads/../../etc/passwd leis an gcomhadlann cheadaithe agus rachadh sé trí sheiceáil réamhthosaigh naïve. Cuireann an conair fhíor a réiteach an trasnú seo ar ceal, rud a fhanann mar cheann de na hionsaithe is coitianta i gcoinne gníomhairí a láimhseálann comhaid.

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

Leanann ordaithe an loighic chéanna, ag baint úsáide as liosta ceadaithe seachas liosta blocála. Is cinntitheach an neamhshiméadracht: cuireann liosta blocála ort gach ordú contúirteach a shamhlú—cleachtadh a chaillefidh tú—ach ní éilíonn liosta ceadaithe ach na rudaí a theastaíonn ón ngníomhaire go díreach a liostú, go minic trí nó ceithre ordú amháin.

Leibhéal 2: Trácht amach a rialú

Déileálann leithlisiú líonra leis an gcás sceite a pléadh cheana. Fad is atá an gníomhaire in ann iarratas HTTP a sheoladh chuig aon fhearann, is féidir le haon sonraí a dteagmháiltear leo do theorainn a fhágáil, agus cosnóidh an trácht amach cosúil le trácht gnáthfheidhmchláir. Má shriantar ceann scríbe go dtí liosta sainráite, déantar iarracht sceite a thiontú ina eisceacht logáilte.

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

Leibhéal 3: Cód a fheidhmiú gan muinín a bheith agat as leis an meaisín

Is é cód a scríobh samhail a rith an cás is deacra. Comhcheanglaíonn an cur i bhfeidhm thíos trí chosaint: seiceáil allmhairithe roimh fheidhmiú, teorainneacha cuimhne agus ama LAP a shocraítear laistigh den script féin, agus timpeallacht a laghdaítear go dtí an t-íosmhéid nuair a sheoltar an fophróiseas.

Tá rabhadh ag teastáil maidir le fíorú allmhairithe. Braitheann sé ar chuardach téacs, agus seachnóidh ionsaitheoir cúramach é—níl an teaghrán cuardaigh le fáil in __import__("os")". Meas an fíorú seo mar ráille cosanta i gcoinne botúin agus iarrachtaí naïve, ach riamh mar theorainn slándála. Is é an teorainn fhíor ná an próiseas leithlisithe lena theorainneacha acmhainní.

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

I gcásanna táirgeachta, soláthraíonn Docker leithlisiú níos láidre toisc nach mbraitheann sé a thuilleadh ar chomhoibriú an chóid atá á fheidhmiú. Dúnann gach rogha ordaithe doras sonrach: baineann --network=none aon fhéidearthacht sceite líonra, coscaíonn --read-only buanú, cuireann --memory agus --cpus teorainn le tomhaltas, tugann --tmpfs spás oibre so-ghalaithe agus teoranta, agus toirmíscíonn --security-opt=no-new-privileges éalú le linn feidhmiú. Scriosann an bratach --rm an tsoitheach ag an deireadh, rud a ráthaíonn nach maireann aon staid ó fheidhmiú amháin go dtí an chéad cheann eile.

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

An leibhéal ceart a roghnú

Tá sé costasach agus míriachtanach na trí leibhéal a charnadh ar chatbot FAQ simplí, ach ní chosnaíonn sé rud ar bith má bhraitheann tú ar an gcéad leibhéal amháin do ghníomhaire a fheidhmíonn cód. Soláthraíonn an tábla thíos pointe tosaigh; coigeartaigh é bunaithe ar íogaireacht na sonraí atá inrochtana, rud a bhíonn tábhachtach go minic níos mó ná castacht an ghníomhaire.

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

Cibé leibhéal a roghnaíonn tú, déan tástáil air mar a dhéanfá ar ghné. Meathlaíonn sandbox a shuiteálann tú agus a ndéanann tú dearmad di go ciúin le himeacht ama—spleáchas breise, toirt feistithe “go sealadach”, fearann oscailte chun fadhbanna a réiteach. Rith tástálacha trasnaithe conaire agus fearainn toirmiscthe arís le gach nuashonrú gníomhaire: ní neamhghnáchacht bheag é sárú sandbox, is eachtra thábhachtach í.

Príomhphointí

  • Tá sandboxáil riachtanach chomh luath agus a bhíonn rochtain ag gníomhaire ar uirlisí nó nuair a fheidhmíonn sé cód
  • Trí leibhéal leithlisithe: ceadanna, líonra, coimeádán—comhcheangail de réir riosca
  • Baineann prionsabal na pribhléide is lú le gach acmhainn: comhaid, líonra, ordaithe
  • Soláthraíonn Docker le --network=none agus --read-only an leithlisiú is láidre
  • Ní mór leithlisiú a thástáil go rialta—is eachtra thábhachtach é sárú sandbox