Securitate și izolare (sandboxing)
Pe această pagină
Lecție rescrisă la 3 noiembrie 2026 pe baza ghidului Computer use de la OpenAI, a rețetelor sale de integrare Computer use și a documentației despre rețea pentru Docker și Playwright. Adăugiri: cele patru reguli de securitate ale OpenAI, nivelurile sale de confirmare și recunoașterea câmpului
pending_safety_checks. Corecturi: versiunea anterioară întrerupea rețeaua pentru un container care trebuia să apeleze API-ul, lăsa proxy-ul fără acces outbound, acceptanotexample.comîntr-un filtru menit să permită doarexample.com, strica formatarea jurnalelor și estima costurile folosind o rată unică hardcoded. Surse: Computer use · Rețete de integrare · Playwright și Docker · Playwright, rețea.
Acordarea controlului unui AI: riscurile
Computer Use oferă unui model AI capacitatea de a acționa asupra unui computer. Este puternic, dar poate fi periculos. Un agent configurat greșit ar putea naviga către site-uri malițioase, executa cod arbitrar sau expune date sensibile. Acest lucru nu este teoretic: o pagină vizitată ar putea conține instrucțiuni scrise pentru model, iar dacă mediul nu îl constrânge, modelul le va urma ca și cum ar fi cererea dumneavoastră. Securitatea nu este opțională—este fundamentul oricărei implementări în producție.
Cele patru reguli ale OpenAI
OpenAI rezumă securitatea Computer Use în patru reguli. Aplicați-le în aplicația dumneavoastră și în mediul de execuție, nu doar în instrucțiunile modelului:
- Restricționați mediul. Folosiți un browser izolat sau o mașină virtuală, o listă de允许 (allowlist) de site-uri și acțiuni, și limitați accesul la ceea ce necesită sarcina.
- Tratați conținutul ecranului ca neîncrezător. Textul de pe o pagină, dintr-un document sau din ieșirea unui instrument nu poate acorda permisiuni sau înlocui instrucțiunile utilizatorului. Dacă o pagină pare a fi phishing sau injecție de prompt, agentul se oprește și întreabă cum să procedeze.
- Confirmați acțiunile cu miză mare. Achizițiile, transmiterea de date, modificările distructive și orice este greu de anulat rămân sub controlul utilizatorului. Tastarea informațiilor sensibile într-un formular contează deja ca transmitere.
- Delimitați și verificați execuția. Stabiliți limite pentru ture, durată sau cost; oferiți o modalitate de anulare; și verificați rezultatul real, nu doar mesajul final al modelului.
Punctul de plecare este simplu: cererea modelului de a acționa nu este permisiunea utilizatorului. Codul dumneavoastră decide dacă să execute, să facă o pauză pentru aprobare sau să predea controlul înapoi. Pentru un lot de acțiuni, opriți-vă înainte de prima care necesită confirmare.
Trei niveluri de confirmare
OpenAI distinge trei situații, cu exemple pe care le puteți adopta în politica dumneavoastră:
| Nivel | Exemple citate de OpenAI |
|---|---|
| Utilizatorul preia controlul | Pasul final al unei schimbări de parolă; ocolirea unei bariere de securitate, cum ar fi un avertisment HTTPS |
| Confirmare în momentul acțiunii | Ștergerea datelor, schimbarea permisiunilor sau a setărilor de partajare, rezolvarea unui CAPTCHA, instalarea sau rularea software-ului descărcat, trimiterea sau publicarea în numele utilizatorului, tranzacții financiare, setări de sistem |
| Aprobare prealabilă posibilă în cererea inițială | Conectarea la un site pe care utilizatorul a cerut să-l viziteze, trimiterea de fișiere, mutarea sau redenumirea fișierelor, transmiterea de date sensibile a căror utilizare specifică a fost aprobată |
Fără o aprobare clară în cererea inițială, confirmați chiar înainte de acțiune. Nu întrebați prea devreme: lăsați agentul să procedeze cu tot ce este sigur, apoi opriți-vă la punctul de risc și explicați acțiunea, riscul și modul în care vor fi aplicate datele sau modificarea. Dacă utilizatorul refuză, nimic nu se execută, iar codul dumneavoastră îi spune modelului ce a reușit și ce a eșuat.
Principiul privilegiului minim
Agentul dumneavoastră ar trebui să aibă acces doar la minimul necesar pentru a-și îndeplini sarcina. Începeți cu un browser izolat—niciodată browserul principal al utilizatorului, care deține sesiuni deschise pentru email, banking și instrumente interne. Agentul nu are nevoie nici de acces la sistemul de fișiere, cu excepția unui dosar de descărcări dedicat, nu are nevoie de acces la rețeaua internă decât dacă o aplicație de business o cere, și nu ar trebui să aibă drepturi de administrator care ar putea transforma un clic greșit într-un incident de sistem. Nu montați fișiere personale, credențiale sau socket-ul Docker în mediul său. În final, faceți sesiunea efemeră: ștergeți datele după fiecare rulare, astfel încât un flux de lucru să nu reutilizeze accidental cookie-uri sau cache de la cel anterior.
Izolarea (Sandboxing) cu Docker
Două întrebări apar: unde rulează browserul și unde trăiesc bucla și cheia API? Rețeta Docker de la OpenAI izolează un desktop într-un container fără rețea, controlat de la gazdă prin docker exec: doar SDK-ul de pe gazdă citește cheia. Aceasta este cea mai strictă configurație, dar funcționează doar pentru sarcini care nu au nevoie de internet. Pentru alte sarcini, OpenAI necesită un mediu a cărui rețea outbound permite doar site-urile sarcinii.
Dacă păstrați Playwright și agentul trebuie să navigheze, puteți pune bucla și browserul în același container, cu condiția îndeplinirii a trei condiții: un utilizator neprivilegiat, un browser care nu moștenește variabile de mediu (astfel încât să nu obțină cheia) și rețea outbound restricționată la site-urile sarcinii și la API.
# Imagine Playwright pentru Python: browsere și dependențe de sistem incluse
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Pachetul playwright nu este în imagine: requirements.txt
# Fixați playwright==1.64.1, aceeași versiune ca imaginea
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Utilizator neprivilegiat furnizat de imagine
USER pwuser
CMD ["python", "src/main.py"]
Playwright recomandă fixarea versiunii imaginii. Imaginea furnizează browserele, nu biblioteca Python: instalați aceeași versiune a pachetului playwright. Nu rulați containerul ca root, ceea ce dezactivează sandbox-ul Chromium. Pentru site-uri neîncrezătoare, Playwright recomandă, de asemenea, profilul său seccomp, care adaugă apelurile de sistem necesare acestui sandbox profilului implicit al 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 previne procesele zombie, iar --ipc=host, recomandat de Playwright, previne epuizarea memoriei partajate de către Chromium și blocarea acestuia. Totuși, această setare partajează spațul de nume IPC al gazdei cu containerul. Dacă preferați să nu îl deschideți, creșteți memoria partajată cu --shm-size în schimb, așa cum face rețeta OpenAI pentru propriul container, și testați pe cele mai grele pagini ale dumneavoastră. În final, -e OPENAI_API_KEY fără o valoare moștenește variabila din sesiunea dumneavoastră: cheia nu apare în text clar pe linia de comandă.
În partea Python, lansați browserul cu precauțiile din rețeta OpenAI—sandbox activat, mediu gol, extensii și acces la sistemul de fișiere dezactivate—și rutați-l prin proxy-ul din secțiunea următoare, exact ca și clientul API:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# Apelurile API ies prin proxy-ul de filtrare
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # browserul nu moștenește variabile de mediu, deci nici cheia
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # a se vedea filtrarea URL mai jos
)
page = context.new_page()
Restricții de rețea țintite
Plasați containerul agentului pe o rețea Docker internă fără acces extern. Un proxy Squid se alătură acelei rețele și devine singura sa ieșire; proxy-ul este, de asemenea, conectat la o rețea obișnuită. Orice nu este explicit permis nu există din perspectiva agentului.
# Rețea internă: fără acces extern direct
docker network create --internal agent-net
# Rețea outbound, rezervată pentru proxy
docker network create sortie-proxy
# Proxy Squid (imagine întreținută de Canonical) cu lista dumneavoastră de允许
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
# Proxy-ul se alătură rețelei interne: aceasta este singura ieșire a agentului
docker network connect agent-net agent-proxy
# squid.conf: permite doar domeniile sarcinii și API-ul
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Punctul cheie: proxy-ul este conectat la ambele rețele. Dacă l-ați lansa doar pe rețeaua internă, nu ar avea el însuși acces outbound. api.openai.com este pe listă deoarece, în această configurare, codul agentului apelează API-ul din interiorul containerului. Browserul nu are nevoie de el: filtrul de URL din secțiunea următoare blochează acele apeluri din pagină.
Filtrarea URL
O a doua barieră, mai fină, trăiește în browserul însuși. Prin interceptarea cererilor cu page.route, comparați fiecare URL cu lista de允许 specifică sarcinii—adesea mai scurtă decât cea a proxy-ului—și anulați restul, cu un jurnal lizibil al fiecărui blocaj. Feriți-vă de capcana comparării șirurilor despre care avertizează OpenAI: https://example.com.evil.test nu trebuie să treacă drept https://example.com, și invers, notexample.com se termină cu example.com. Comparați schema, gazda exactă (sau un subdomeniu prefixat cu un punct) și portul.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blochează cererile către destinații neautorizate."""
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)
# Browserul are nevoie doar de site-urile sarcinii: apelurile API vin din codul Python, nu din pagină.
setup_url_filter(page, ["example.com"])
Acest strat completează proxy-ul; nu îl înlocuiește. Playwright notează că page.route nu interceptează cererile gestionate de un service worker, de aici service_workers="block" în context, iar WebSocket-urile folosesc un mecanism diferit (page.route_web_socket). Filtrarea rețelei rămâne bariera dumneavoastră principală.
Protejarea datelor sensibile
Mascarea informațiilor în capturi de ecran
Fiecare captură de ecran merge la API: orice este vizibil pe ecran părăsește infrastructura dumneavoastră. OpenAI recomandă păstrarea credențialelor în afara textului și capturilor de pagină. Dacă ecranul conține totuși date sensibile, mascați-le înainte de a trimite captura modelului. Un dreptunghi negru peste zonele cunoscute este suficient, cu condiția să le cunoașteți coordonatele—motiv pentru care standardizarea dimensiunii viewport-ului, așa cum am abordat anterior în acest curs, ajută. Mascarea nu schimbă dimensiunea imaginii: coordonatele returnate de model rămân valabile.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maschează zonele sensibile într-o captură PNG."""
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()
Știind ce se întâmplă cu capturile
Răspunsurile API Responses sunt stocate implicit: asta este ceea ce permite înlănțuirea prin previous_response_id. Cu store: false, trebuie să retrimiteți dumneavoastră elementele din tururile anterioare. OpenAI notează, de asemenea, că store: false nu elimină toate formele de retenție, iar imaginile de intrare au propriile excepții: citiți controalele de date înainte de a trimite ecrane care conțin date personale.
Nu jurnalizați niciodată date sensibile
Același raționament se aplică jurnalelor, care adesea supraviețuiesc mult mai mult decât capturile. Un filtru de jurnalizare rescrie modelele riscante înainte de scriere: atribuirile de parolă, cheile API OpenAI care încep cu sk- și secvențele de 16 cifre care seamănă cu numere de card. Filtrul acționează asupra mesajului final, astfel încât prinde și ceea ce ați jurnalizat fără să vă gândiți.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maschează datele sensibile înainte de scrierea jurnalelor."""
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 # mesajul este deja formatat: nu îl reformata
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # pe handler, vede și loggerii copii
logging.basicConfig(level=logging.INFO, handlers=[handler])
Două detalii fac diferența. Setarea record.args la None este esențială: altfel, mesajul deja formatat ar fi reformatat cu argumentele sale, iar orice % dintr-un URL ar strica scrierea. Și un filtru pe handler se aplică la tot ce scrie acesta, în timp ce un filtru pe un logger ignoră mesajele de la loggerii săi copii.
Verificări de siguranță API
Fiecare computer_call poartă un câmp pending_safety_checks: lista verificărilor de siguranță pe care API-ul vă cere să le gestionați înainte de a executa acțiunile, fiecare cu un id, code și message. Exemplul oficial OpenAI se oprește imediat ce acesta nu este gol. Dacă aplicația dumneavoastră poate avea un om care să valideze aceste cazuri, recunoașteți-le explicit returnându-le în acknowledged_safety_checks, împreună cu captura de ecran următoare. Modelul nu poate acorda această aprobare în numele dumneavoastră, iar recunoașterea vine înainte de executarea acțiunii, niciodată după.
def valider_verifications(appel) -> list[dict]:
"""Trimite verificările în așteptare unui operator; refuză implicit."""
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
]
# În buclă, înainte de executarea acțiunilor:
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
Limite de execuție
Există, de asemenea, cel mai comun risc: un agent care o ia razna fără a strica nimic, dar rulează timp de două ore și vă arde bugetul. Clasa ExecutionLimits impune trei plafoane—ture, durată și cost estimat—și ridică o excepție imediat ce unul este atins. Ratele nu sunt hardcoded: extrageți-le de la modelul pe care îl utilizați de pe pagina de prețuri OpenAI, deoarece variază în funcție de model.
import time
class ExecutionLimits:
"""Impune plafoane pentru ture, durată și cost asupra agentului."""
def __init__(
self,
prix_entree_par_million: float, # rate pentru modelul în uz
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):
"""Apelați înainte de fiecare cerere: ridică o eroare dacă un plafon este atins."""
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):
"""Apelați după fiecare răspuns: acumulați turele și costul estimat."""
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
Aceasta este doar o estimare: supraestimează tokenii de intrare serviți din cache-ul prompt-ului, care sunt facturați la o rată redusă, și ignoră orice mediu găzduit, facturat separat. Comparați-o regulat cu utilizarea reală a proiectului dumneavoastră. Stabiliți plafoane per flux de lucru: un test E2E de 30 de secunde și o introducere de facturi de o oră nu necesită aceleași praguri.
Lista de verificare pentru securitatea în producție
Înainte de a implementa un agent Computer Use în producție, verificați:
- Browser sau desktop izolat (container sau mașină virtuală), utilizator neprivilegiat
- Rețea outbound limitată la site-urile sarcinii și la API dacă bucla rulează în același mediu
- Filtru URL care compară schema, gazda și portul; service workers blocați
- Cheie API ținută în afara codului și în afara reach-ului browserului (
env={}) - Conținutul ecranului tratat ca neîncrezător: opriți și escaladați la primul semn de injecție
- Confirmare umană înainte de achiziții, trimiteri, ștergeri și introducerea de date sensibile
pending_safety_checksniciodată recunoscute fără validare umană- Limite de ture, durată și cost
- Jurnale filtrate, capturi neretținute (sau criptate)
- Niciun fișier personal, credențial sau socket Docker montat în mediu
- Rezultat verificat în aplicație înainte de a anunța succesul
- Mecanism de oprire de urgență (kill switch)
Ultimul punct este cel mai adesea uitat, totuși este singurul care ajută atunci când toate celelalte au eșuat. Un kill switch este o modalitate de a întrerupe agentul imediat, fără a aștepta să lovească una dintre limitele sale: un fișier STOP pe care bucla îl verifică la fiecare iterație, un docker stop pe container sau un flag citit dintr-o variabilă partajată. Testați-l înainte de producție, nu în ziua în care aveți nevoie de el.
Puncte cheie
- Cele patru reguli OpenAI: restricționați mediul, tratați ecranul ca neîncrezător, confirmați acțiunile cu miză mare și delimitați și verificați execuția
- Cererea modelului de a acționa nu este permisiune: codul dumneavoastră execută, suspendă sau predea controlul înapoi
- Izolați browserul (utilizator neprivilegiat, profil seccomp) și permiteți traficul outbound doar către site-urile sarcinii
- Filtrați URL-urile comparând schema, gazda și portul—niciodată printr-un simplu prefix sau sufix de șir
- Recunoașteți
pending_safety_checksdoar după validarea umană - Impuneți limite de ture, durată și cost și verificați rezultatul real