Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Sigurtà u sandboxing

Lezzjoni 12 / 14 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Tagħti lill-AI kontroll: ir-riskji
  2. Erba’ regoli ta’ OpenAI
  3. Il-prinċipju tal-inqas privileġġ
  4. Sandboxing b’Docker
  5. Filtrazzjoni tal-URL
  6. Protezzjoni tad-data sensittiva
  7. Verifiki tas-sigurtà tal-API
  8. Limiti ta’ eżekuzzjoni
  9. Lista ta’ kontroll tas-sigurtà għall-produzzjoni
  10. Punti Ewlenin

Lezzjoni miktuba mill-ġdid fit-3 ta’ Novembru 2026 ibbażata fuq il-gwida Computer use ta’ OpenAI, ir-riċetti ta’ integrazzjoni tagħha, u d-dokumentazzjoni tan-netwerking ta’ Docker u Playwright. Żidiet: erba’ regoli tas-sigurtà ta’ OpenAI, il-livelli ta’ konferma tagħha, u r-rikonoxximent ta’ pending_safety_checks. Korrezzjonijiet: il-verżjoni preċedenti qatgħet in-netwerk għal kontejner li kellu bżonn isejjaħ l-API, ħalliet il-proxy mingħajr aċċess ‘il barra, aċċettat notexample.com f’filtru maħsub biex jippermetti biss example.com, ħarbet il-formatjar tal-logs, u stmaw l-ispejjeż bl-użu ta’ rata waħda ffissata. Sorsi: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.

Tagħti lill-AI kontroll: ir-riskji

Computer Use jagħti lill-mudell tal-AI l-abbiltà li jaġixxi fuq kompjuter. Dan huwa qawwi, iżda jista’ jkun perikoluż. Aġent ikkonfigurat ħażin jista’ jinnaviga lejn siti malizzjużi, jesegwixxi kodiċi arbitrarju, jew jesponi data sensittiva. Dan mhuwiex teoretiku: paġna li tiġi żżurata tista’ fiha struzzjonijiet miktuba għall-mudell, u jekk l-ambjent ma jillimitahx, il-mudell isegwihom daqslikieku kienu t-talba tiegħek. Is-sigurtà mhix għażla—hija l-fondazzjoni ta’ kwalunkwe dispjegament fil-produzzjoni.

Erba’ regoli ta’ OpenAI

OpenAI tissintetizza s-sigurtà ta’ Computer Use f’erba’ regoli. Applikahom fl-applikazzjoni tiegħek u fl-ambjent ta’ runtime, mhux biss fl-istruzzjonijiet tal-mudell:

  • Irrestrinġi l-ambjent. Uża browser iżolat jew magna virtwali, lista bajda ta’ siti u azzjonijiet, u llimita l-aċċess għal dak li teħtieġ il-kompitu.
  • Ittratta l-kontenut tal-iskrin bħala mhux affidabbli. It-test minn paġna, dokument, jew output ta’ għodda ma jistax jagħti permess jew jissostitwixxi l-istruzzjonijiet tal-utent. Jekk paġna tidher bħal phishing jew injezzjoni ta’ prompt, l-aġent jieqaf u jistaqsi kif għandu jipproċedi.
  • Ikkonferma azzjonijiet b’riskju għoli. Xirjiet, trażmissjoni ta’ data, bidliet distruttivi, u kull ħaġa diffiċli biex tħassar tibqa’ taħt il-kontroll tal-utent. It-tipjar ta’ informazzjoni sensittiva f’formola diġà tgħodd bħala trażmissjoni.
  • Illimita u vverifika l-eżekuzzjoni. Stabbilixxi limiti fuq id-dawriet, it-tul, jew l-ispiża; ipprovdi mod biex tikkanċella; u vverifika r-riżultat attwali, mhux biss il-messaġġ finali tal-mudell.

Il-punt tat-tluq huwa sempliċi: it-talba tal-mudell biex jaġixxi mhix permess tal-utent. Il-kodiċi tiegħek jiddeċiedi jekk jesegwixxix, jippawsax għall-approvazzjoni, jew jirritornax il-kontroll. Għal lott ta’ azzjonijiet, waqaf qabel l-ewwel waħda li teħtieġ konferma.

Tliet livelli ta’ konferma

OpenAI tiddistingwi tliet sitwazzjonijiet, b’eżempji li tista’ tadotta fil-politika tiegħek:

LivellEżempji ċċitati minn OpenAI
L-utent jerġa’ jieħu l-kontrollPass finali ta’ bidla tal-password; tgħaddi minn barriera tas-sigurtà, bħal twissija HTTPS
Ikkonferma fil-mument tal-azzjoniTħassir ta’ data, bidla ta’ permessi jew settings ta’ kondiviżjoni, soluzzjoni ta’ CAPTCHA, installazzjoni jew tħaddim ta’ softwer imniżżel, tibgħat jew tippubblika f’isem l-utent, tranżazzjonijiet finanzjarji, settings tas-sistema
Approvazzjoni minn qabel possibbli fit-talba inizjaliLogin f’sit li l-utent talab li jżur, tibgħat fajls, tmexxi jew tibdel ismijiet ta’ fajls, trażmissjoni ta’ data sensittiva li l-użu speċifiku tagħha ġie approvat

Mingħajr approvazzjoni ċara fit-talba inizjali, ikkonferma eżatt qabel l-azzjoni. Titlobx kmieni wisq: ħalli l-aġent jipproċedi fuq kull ħaġa li hija sikura, imbagħad waqaf fil-punt tar-riskju u spjega l-azzjoni, ir-riskju, u kif id-data jew il-bidla se tiġi applikata. Jekk l-utent jirrifjuta, xejn ma jesegwixxi, u l-kodiċi tiegħek jgħid lill-mudell x’irnexxa u x’falla.

Il-prinċipju tal-inqas privileġġ

L-aġent tiegħek għandu jkollu aċċess biss għall-minimu meħtieġ biex jikkompleta l-kompitu tiegħu. Ibda b’browser iżolat—qatt il-browser primarju tal-utent, li fih sessjonijiet miftuħa għall-email, il-banking, u għodod interni. L-aġent lanqas ma għandu bżonn aċċess għas-sistema tal-fajls ħlief għal folder dedikat għat-tniżżil, ma għandux bżonn aċċess għan-netwerk intern ħlief jekk applikazzjoni tan-negozju teħtieġu, u m’għandux ikollu drittijiet ta’ amministratur li jistgħu jibdew inċident fis-sistema minn klikk żbaljat. Timmountjax fajls personali, kredenzjali, jew is-socket ta’ Docker fl-ambjent tiegħu. Fl-aħħar nett, agħmel is-sessjoni effimera: ħassar id-data wara kull ġirja sabiex fluss ta’ ħidma qatt ma jerġa’ juża b’mod aċċidentali cookies jew cache mill-waħda ta’ qabel.

Sandboxing b’Docker

Jinqalgħu żewġ mistoqsijiet: fejn qed jaħdem il-browser, u fejn jgħixu l-linja u l-API key? Ir-riċetta ta’ Docker ta’ OpenAI tiżola desktop f’kontejner mingħajr netwerk, ikkontrollat mill-host permezz ta’ docker exec: biss l-SDK fuq l-host jaqra ċ-ċavetta. Din hija l-konfigurazzjoni l-aktar stretta, iżda taħdem biss għal kompiti li ma jeħtiġux l-internet. Għal kompiti oħra, OpenAI teħtieġ ambjent li n-netwerk ‘il barra tiegħu jippermetti biss is-siti tal-kompitu.

Jekk iżżomm Playwright u l-aġent irid jibbrawżja, tista’ tpoġġi l-linja u l-browser fl-istess kontejner, sakemm jintlaħqu tliet kundizzjonijiet: utent mingħajr privileġġi, browser li ma jwirtix varjabbli tal-ambjent (sabiex ma jiksbix iċ-ċavetta), u netwerk ‘il barra ristrett għas-siti tal-kompitu u l-API.

# Playwright image for Python: browsers and system dependencies included
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# The playwright package isn't in the image: requirements.txt
# Pin playwright==1.64.1, the same version as the image
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Non-privileged user provided by the image
USER pwuser

CMD ["python", "src/main.py"]

Playwright jirrakkomanda li tiffissa l-verżjoni tal-immaġni. L-immaġni tipprovdi l-browsers, mhux il-librerija Python: installa l-istess verżjoni tal-pakkett playwright. Mhux biżżejjed li tħaddem il-kontejner bħala root, li jiddiżattiva s-sandbox ta’ Chromium. Għal siti mhux affidabbli, Playwright jirrakkomanda wkoll il-profil seccomp tiegħu, li jżid is-sejħiet tas-sistema li dan is-sandbox jeħtieġ mal-profil default ta’ Docker.

docker run --rm --init \
  --network agent-net \
  --security-opt seccomp=seccomp_profile.json \
  --ipc=host \
  --memory=2g --cpus=1.5 --pids-limit=256 \
  -e OPENAI_API_KEY \
  computer-use-agent

--init jipprevjeni proċessi zombie, u --ipc=host, rakkomandat minn Playwright, jipprevjeni lil Chromium milli joħroġ mill-memorja kondiviża u jaqa’. Madankollu, dik l-impostazzjoni taqsam l-ispazju tal-ismijiet IPC tal-host mal-kontejner. Jekk tippreferi li ma tiftaħx dan, żid il-memorja kondiviża b’--shm-size minflok, kif tagħmel ir-riċetta ta’ OpenAI għall-kontejner tagħha stess, u ttestja fuq il-paġni l-aktar tqal tiegħek. Fl-aħħar nett, -e OPENAI_API_KEY mingħajr valur jiret il-varjabbli mis-sessjoni tiegħek: iċ-ċavetta ma tidhirx b’test ċar fuq il-linja tal-kmand.

Fuq in-naħa ta’ Python, neddi l-browser bil-prekawzjonijiet mir-riċetta ta’ OpenAI—sandbox attivata, ambjent vojt, estensjonijiet u aċċess għas-sistema tal-fajls diżattivati—u rrottah permezz tal-proxy mit-taqsima li jmiss, eżatt bħall-klijent tal-API:

from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright

PROXY = "http://agent-proxy:3128"

# API calls go out through the filtering proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # the browser inherits no environment variables, so not the key
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # see URL filtering below
)
page = context.new_page()

Restrizzjonijiet tan-netwerk immirati

Poġġi l-kontejner tal-aġent fuq netwerk intern ta’ Docker mingħajr aċċess estern. Proxy Squid jingħaqad ma’ dak in-netwerk u jsir l-uniku ħruġ tiegħu; il-proxy huwa wkoll imqabbad ma’ netwerk regolari. Kull ħaġa li mhijiex permessa b’mod espliċitu ma teżistix mill-perspettiva tal-aġent.

# Internal network: no direct external access
docker network create --internal agent-net
# Outbound network, reserved for the proxy
docker network create sortie-proxy

# Squid proxy (image maintained by Canonical) with your allowlist
docker run -d --name agent-proxy --network sortie-proxy \
  -v "$PWD/squid.conf:/etc/squid/squid.conf:ro" \
  ubuntu/squid:6.6-24.04_beta

# The proxy joins the internal network: this is the agent's only exit
docker network connect agent-net agent-proxy
# squid.conf: allow only the task's domains and the API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Il-punt ewlieni: il-proxy huwa mqabbad maż-żewġ netwerks. Jekk tniedieh fuq in-netwerk intern biss, ma jkollu l-ebda aċċess ‘il barra huwa stess. api.openai.com huwa fil-lista għax, f’dan il-setup, il-kodiċi tal-aġent isejjaħ l-API minn ġewwa l-kontejner. Il-browser ma għandux bżonnu: il-filtru tal-URL fit-taqsima li jmiss jimblokaw dawk is-sejħiet mill-paġna.

Filtrazzjoni tal-URL

Barriera sekonda, aktar fina, tgħix fil-browser innifsu. Billi tinterċetta t-talbiet b’page.route, qabbel kull URL mal-lista bajda speċifika għall-kompitu—spesso iqsar minn dik tal-proxy—u waqqaf il-bqija, b’loġġ li jista’ jinqara ta’ kull blokk. Oqgħod attent għall-insidja tal-komparazzjoni tal-istring li twissi dwarha OpenAI: https://example.com.evil.test m’għandux jgħaddi bħala https://example.com, u bl-istess mod notexample.com jispiċċa b’example.com. Qabbel l-iskema, l-host eżatt (jew subdomain prefissat b’punt), u l-port.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Block requests to unauthorized destinations."""

    def autorisee(url: str) -> bool:
        parties = urlparse(url)
        hote = parties.hostname or ""
        return (
            parties.scheme == "https"
            and parties.port in (None, 443)
            and any(hote == d or hote.endswith("." + d) for d in allowed_domains)
        )

    def check_navigation(route):
        if autorisee(route.request.url):
            route.continue_()
        else:
            print(f"  BLOQUÉ : {route.request.url}")
            route.abort()

    page.route("**/*", check_navigation)


# The browser only needs the task's sites: API calls come from your Python code, not the page.
setup_url_filter(page, ["example.com"])

Dan il-livell jikkomplementa l-proxy; ma jissostitwixxihx. Playwright jinnota li page.route ma jinterċettax it-talbiet immaniġġjati minn service worker, għalhekk service_workers="block" fil-kuntest, u l-WebSockets jużaw mekkaniżmu differenti (page.route_web_socket). Il-filtrazzjoni tan-netwerk tibqa’ l-barriera primarja tiegħek.

Protezzjoni tad-data sensittiva

Maskra tal-informazzjoni fl-iscreenshots

Kull screenshot imur lejn l-API: kull ħaġa viżibbli fuq l-iskrin toħroġ mill-infrastruttura tiegħek. OpenAI tirrakkomanda li żżomm il-kredenzjali barra mit-test tal-paġna u mill-qabdiet. Jekk l-iskrin fih data sensittiva, agħmilha moħbija qabel ma tibgħat il-qabda lill-mudell. Rettangolu iswed fuq żoni magħrufa huwa biżżejjed, sakemm tkun taf il-koordinati tagħhom—għalhekk l-istandardizzazzjoni tad-daqs tal-viewport, kif kopert qabel f’dan il-kors, tgħin. Il-maskra ma tbiddilx id-daqs tal-immaġni: il-koordinati rritornati mill-mudell jibqgħu validi.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Mask sensitive areas in a PNG capture."""
    img = Image.open(io.BytesIO(screenshot_bytes))
    draw = ImageDraw.Draw(img)

    for x, y, w, h in regions:
        draw.rectangle([x, y, x + w, y + h], fill="black")

    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return buffer.getvalue()

Nafu x’jiġri mill-qabdiet

Ir-risposti tar-Responses API huma maħżuna b’mod default: dan huwa li jippermetti l-katina permezz ta’ previous_response_id. B’store: false, trid terġa’ tibgħat elementi minn dawriet preċedenti int stess. OpenAI tinnota wkoll li store: false ma teliminax il-forom kollha ta’ ritenzjoni, u l-immaġnijiet tal-input għandhom l-eċċezzjonijiet tagħhom stess: aqra l-kontrolli tad-data tagħha qabel ma tibgħat skrinijiet li fihom data personali.

Qatt ma tloġġja data sensittiva

L-istess raġunar japplika għal-logs, li spiss jibqgħu ħajjin ħafna aktar mill-qabdiet. Filtru tal-logging jerġa’ jikteb mudelli riskjużi qabel ma jikteb: assenjazzjonijiet tal-password, ċwievet tal-API ta’ OpenAI li jibdew b’sk-, u sekwenzi ta’ 16-il ċifra li jixbhu numri tal-kards. Il-filtru jaġixxi fuq il-messaġġ finali, allura jaqbad ukoll dak li loġġjajt mingħajr ma ħsibt.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Mask sensitive data before writing logs."""

    PATTERNS = [
        (re.compile(r"password['\"]?\s*[:=]\s*['\"]?[^\s,}]+", re.IGNORECASE), "password=***"),
        (re.compile(r"\bsk-[A-Za-z0-9_-]{20,}"), "sk-***"),
        (re.compile(r"\b\d{16}\b"), "****-****-****-****"),
    ]

    def filter(self, record):
        msg = record.getMessage()
        for pattern, replacement in self.PATTERNS:
            msg = pattern.sub(replacement, msg)
        record.msg = msg
        record.args = None  # message is already formatted: don't reformat it
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # on the handler, it also sees child loggers
logging.basicConfig(level=logging.INFO, handlers=[handler])

Żewġ dettalji jagħmlu d-differenza. Li tpoġġi record.args għal None huwa essenzjali: inkella, il-messaġġ diġà fformatjat jiġi fformatjat mill-ġdid bl-argumenti tiegħu, u kull % f’URL ikisser il-kitba. U filtru fuq il-handler japplika għal kull ma jikteb, filwaqt li filtru fuq logger jinjora l-messaġġi mil-loggers tat-tfal tiegħu.

Verifiki tas-sigurtà tal-API

Kull computer_call iġorr kamp pending_safety_checks: il-lista ta’ verifiki tas-sigurtà li l-API titloblek tittratta qabel ma tesegwixxi l-azzjonijiet, kull waħda b’id, code, u message. L-eżempju uffiċjali ta’ OpenAI jieqaf malli dan ma jkunx vojt. Jekk l-applikazzjoni tiegħek tista’ jkollha bniedem jivvalida dawn il-każijiet, irrikonoxxihom b’mod espliċitu billi tirritornahom f’acknowledged_safety_checks, flimkien mas-screenshot li jmiss. Il-mudell ma jistax jagħti din l-approvazzjoni f’ismek, u r-rikonoxximent jiġi qabel l-eżekuzzjoni tal-azzjoni, qatt wara.

def valider_verifications(appel) -> list[dict]:
    """Submit pending checks to an operator; refuse by default."""
    if not appel.pending_safety_checks:
        return []
    for verification in appel.pending_safety_checks:
        print(f"Vérification de sécurité [{verification.code}] : {verification.message}")
    if input("Autoriser ces actions ? [o/N] ").strip().lower() != "o":
        raise RuntimeError("Actions refusées par l'opérateur")
    return [
        {"id": v.id, "code": v.code, "message": v.message}
        for v in appel.pending_safety_checks
    ]


# In the loop, before executing actions:
acquittees = valider_verifications(appel)
executer_actions(page, appel.actions)
sortie = {
    "type": "computer_call_output",
    "call_id": appel.call_id,
    "output": {
        "type": "computer_screenshot",
        "image_url": f"data:image/png;base64,{capturer_ecran(page)}",
        "detail": "original",
    },
}
if acquittees:
    sortie["acknowledged_safety_checks"] = acquittees

Limiti ta’ eżekuzzjoni

Hemm ukoll ir-riskju l-aktar komuni: aġent li jitlaq mill-binarji mingħajr ma jkisser xejn, iżda jaħdem għal sagħtejn u jaħraq il-baġit tiegħek. Il-klassi ExecutionLimits timponi tliet soqfa—dawriet, tul, u spiża stmata—u tgħolli eċċezzjoni malli tintlaħaq waħda. Ir-rati mhumiex iffissati fil-kodiċi: iġbedhom mill-mudell li qed tuża fuq il-paġna tal-prezzijiet ta’ OpenAI, peress li jvarjaw skont il-mudell.

import time

class ExecutionLimits:
    """Enforce turn, duration, and cost ceilings on the agent."""

    def __init__(
        self,
        prix_entree_par_million: float,  # rates for the model in use
        prix_sortie_par_million: float,
        max_tours: int = 50,
        max_duree_s: int = 300,
        max_cout_usd: float = 5.0,
    ):
        self.prix_entree = prix_entree_par_million
        self.prix_sortie = prix_sortie_par_million
        self.max_tours = max_tours
        self.max_duree = max_duree_s
        self.max_cout = max_cout_usd
        self.debut = time.monotonic()
        self.tours = 0
        self.cout = 0.0

    def verifier(self):
        """Call before each request: raise an error if a ceiling is reached."""
        if self.tours >= self.max_tours:
            raise RuntimeError(f"Limite de tours atteinte ({self.max_tours})")
        if time.monotonic() - self.debut >= self.max_duree:
            raise RuntimeError(f"Durée maximale dépassée ({self.max_duree} s)")
        if self.cout >= self.max_cout:
            raise RuntimeError(f"Budget dépassé ({self.cout:.2f} $)")

    def compter(self, response):
        """Call after each response: accumulate turns and estimated cost."""
        self.tours += 1
        self.cout += response.usage.input_tokens / 1_000_000 * self.prix_entree
        self.cout += response.usage.output_tokens / 1_000_000 * self.prix_sortie

Din hija biss stima: tispiża żejda t-tokens tal-input moqdija mill-cache tal-prompt, li huma ffratturati b’rata mnaqqsa, u tinjora kwalunkwe ambjent ospitat, iffratturat separatament. Qabbelha regolarment mal-użu attwali tal-proġett tiegħek. Stabbilixxi soqfa għal kull fluss ta’ ħidma: test E2E ta’ 30 sekonda u daħla ta’ fattura ta’ siegħa ma jsejħux għall-istess limiti.

Lista ta’ kontroll tas-sigurtà għall-produzzjoni

Qabel ma tiddispjega aġent ta’ Computer Use fil-produzzjoni, ivverifika:

  • Browser jew desktop iżolat (kontejner jew magna virtwali), utent mingħajr privileġġi
  • Netwerk ‘il barra limitat għas-siti tal-kompitu, u għall-API jekk il-linja taħdem fl-istess ambjent
  • Filtru tal-URL li jqabbel l-iskema, l-host, u l-port; service workers imblukkati
  • Ċavetta tal-API miżżuma barra mill-kodiċi u barra mill-portata tal-browser (env={})
  • Kontenut tal-iskrin ittrattat bħala mhux affidabbli: waqaf u eskala fl-ewwel sinjal ta’ injezzjoni
  • Konferma umana qabel xirjiet, tibgħat, tħassir, u daħla ta’ data sensittiva
  • pending_safety_checks qatt ma ġew irrikonoxxuti mingħajr validazzjoni umana
  • Limiti ta’ dawriet, tul, u spiża
  • Logs iffiltrati, qabdiet mhux miżmuma (jew ikkrittati)
  • L-ebda fajl personali, kredenzjali, jew socket ta’ Docker imwaħħla fl-ambjent
  • Riżultat ivverifikat fl-applikazzjoni qabel ma tħabbar is-suċċess
  • Mekkaniżmu ta’ waqfa ta’ emerġenza (kill switch)

L-aħħar punt huwa dak li spiss jintesa, madankollu huwa l-uniku wieħed li jgħin meta l-oħrajn kollha jkunu fallew. Kill switch huwa mod biex tinterrrompi l-aġent immedjatament, mingħajr ma tistenna sa ma jolqot wieħed mil-limiti tiegħu: fajl STOP li l-linja tiċċekkja f’kull iterazzjoni, docker stop fuq il-kontejner, jew flag moqrija minn varjabbli kondiviża. Ittestjah qabel il-produzzjoni, mhux il-jum li jkollok bżonnha.

Punti Ewlenin

  • Erba’ regoli ta’ OpenAI: irrestrinġi l-ambjent, ittratta l-iskrin bħala mhux affidabbli, ikkonferma azzjonijiet b’riskju għoli, u illimita u vverifika l-eżekuzzjoni
  • It-talba tal-mudell biex jaġixxi mhix permess: il-kodiċi tiegħek jesegwixxi, jissospendi, jew jirritorna l-kontroll
  • Iżola l-browser (utent mingħajr privileġġi, profil seccomp) u ppermetti traffiku ‘il barra biss lejn is-siti tal-kompitu
  • Iffiltra l-URLs billi tqabbel l-iskema, l-host, u l-port—qatt b’prefiss jew suffiss sempliċi tal-istring
  • Irrikonoxxi pending_safety_checks biss wara validazzjoni umana
  • Infurza limiti ta’ dawriet, tul, u spiża, u vverifika r-riżultat attwali