Sigurtà u sandboxing
F'din il-paġna
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ċċettatnotexample.comf’filtru maħsub biex jippermetti bissexample.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:
| Livell | Eżempji ċċitati minn OpenAI |
|---|---|
| L-utent jerġa’ jieħu l-kontroll | Pass finali ta’ bidla tal-password; tgħaddi minn barriera tas-sigurtà, bħal twissija HTTPS |
| Ikkonferma fil-mument tal-azzjoni | Tħ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 inizjali | Login 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_checksqatt 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_checksbiss wara validazzjoni umana - Infurza limiti ta’ dawriet, tul, u spiża, u vverifika r-riżultat attwali