Beveiliging en sandboxing
Op deze pagina
Les herschreven op 3 november 2026 op basis van OpenAI’s Computer use-gids, de Computer use integration recipes, en de documentatie over Docker- en Playwright-netwerken. Toevoegingen: OpenAI’s vier beveiligingsregels, de bevestigingsniveaus en de erkenning van
pending_safety_checks. Correcties: de vorige versie sneed het netwerk af voor een container die de API moest aanroepen, liet de proxy zonder uitgaande toegang, accepteerdenotexample.comin een filter dat alleenexample.commoest toestaan, verbrak de log-opmaak en schatte kosten op basis van één hardcoded tarief. Bronnen: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.
Een AI controle geven: de risico’s
Computer Use geeft een AI-model de mogelijkheid om acties op een computer uit te voeren. Dat is krachtig, maar het kan gevaarlijk zijn. Een verkeerd geconfigureerde agent zou naar kwaadaardige sites kunnen navigeren, willekeurige code kunnen uitvoeren of gevoelige gegevens kunnen lekken. Dit is niet theoretisch: een bezochte pagina kan instructies bevatten die specifiek voor het model zijn geschreven, en als de omgeving het niet beperkt, zal het model deze opvolgen alsof het uw verzoek was. Beveiliging is geen optie; het is de basis van elke productie-implementatie.
OpenAI’s vier regels
OpenAI vat de beveiliging van Computer Use samen in vier regels. Pas deze toe in uw applicatie én in de runtime-omgeving, niet alleen in de instructies van het model:
- Beperk de omgeving. Gebruik een geïsoleerde browser of virtuele machine, een allowlist van sites en acties, en beperk de toegang tot wat de taak vereist.
- Behandel schermcontent als niet-vertrouwd. Tekst van een pagina, document of tool-output kan geen toestemming verlenen of gebruikersinstructies vervangen. Als een pagina lijkt op phishing of prompt-injectie, stopt de agent en vraagt hij hoe verder te gaan.
- Bevestig acties met hoge impact. Aankopen, data-overdracht, destructieve wijzigingen en alles wat moeilijk ongedaan te maken is, blijven onder gebruikerscontrole. Het typen van gevoelige informatie in een formulier geldt al als overdracht.
- Begrens en verifieer uitvoering. Stel limieten in op turns, duur of kosten; bied een manier om te annuleren; en verifieer het daadwerkelijke resultaat, niet alleen het laatste bericht van het model.
Het uitgangspunt is simpel: het verzoek van het model om te handelen is geen gebruikerstoestemming. Uw code beslist of er wordt uitgevoerd, gepauzeerd voor goedkeuring, of de controle wordt teruggegeven. Stop bij een batch acties vóór de eerste actie die bevestiging vereist.
Drie bevestigingsniveaus
OpenAI onderscheidt drie situaties, met voorbeelden die u in uw beleid kunt overnemen:
| Niveau | Voorbeelden genoemd door OpenAI |
|---|---|
| Gebruiker neemt controle terug | Laatste stap van een wachtwoordwijziging; omzeilen van een beveiligingsbarrière, zoals een HTTPS-waarschuwing |
| Bevestigen op het moment van actie | Data verwijderen, rechten of deelinstellingen wijzigen, een CAPTCHA oplossen, gedownloade software installeren of uitvoeren, namens de gebruiker verzenden of publiceren, financiële transacties, systeeminstellingen |
| Voorafgaande goedkeuring mogelijk in het initiële verzoek | Inloggen op een site die de gebruiker heeft gevraagd te bezoeken, bestanden verzenden, bestanden verplaatsen of hernoemen, overdracht van gevoelige data waarvan het specifieke gebruik is goedgekeurd |
Zonder duidelijke goedkeuring in het initiële verzoek, bevestigt u vlak voor de actie. Vraag niet te vroeg: laat de agent doorgaan met alles wat veilig is, stop dan op het risicopunt en leg de actie, het risico en hoe de data of wijziging wordt toegepast uit. Als de gebruiker weigert, wordt er niets uitgevoerd en vertelt uw code het model wat gelukt is en wat mislukt is.
Het principe van minimale rechten
Uw agent moet alleen toegang hebben tot het minimum dat nodig is om de taak te voltooien. Begin met een geïsoleerde browser—nooit de primaire browser van de gebruiker, die open sessies bevat voor e-mail, banking en interne tools. De agent heeft ook geen toegang tot het bestandssysteem nodig, behalve voor een specifieke downloadmap, geen toegang tot het interne netwerk tenzij een zakelijke applicatie dat vereist, en geen beheerdersrechten die van een mis klik een systeemincident kunnen maken. Mount geen persoonlijke bestanden, inloggegevens of de Docker-socket in de omgeving. Maak de sessie ten slotte vluchtig: verwijder data na elke run zodat een workflow nooit per ongeluk cookies of cache van de vorige hergebruikt.
Sandboxing met Docker
Twee vragen rijzen: waar draait de browser, en waar zitten de loop en de API-sleutel? OpenAI’s Docker-recept isoleert een desktop in een netwerkloze container, aangestuurd vanaf de host via docker exec: alleen de SDK op de host leest de sleutel. Dit is de strengste configuratie, maar werkt alleen voor taken die geen internet nodig hebben. Voor andere taken vereist OpenAI een omgeving waarvan het uitgaande netwerk alleen de sites van de taak toelaat.
Als u Playwright houdt en de agent moet browsen, kunt u de loop en browser in dezelfde container plaatsen, mits aan drie voorwaarden wordt voldaan: een niet-geprivilegieerde gebruiker, een browser die geen omgevingsvariabelen erft (zodat hij de sleutel niet krijgt), en uitgaand netwerk beperkt tot de sites van de taak en de 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 raadt aan de image-versie vast te pinnen. De image levert de browsers, niet de Python-bibliotheek: installeer dezelfde versie van het playwright-pakket. Draai de container niet als root, wat de sandbox van Chromium uitschakelt. Voor niet-vertrouwde sites raadt Playwright ook zijn seccomp-profiel aan, dat de systeemaanroepen toevoegt die deze sandbox nodig heeft aan het standaardprofiel van 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 voorkomt zombie-processen, en --ipc=host, aanbevolen door Playwright, voorkomt dat Chromium zonder gedeeld geheugen komt en crasht. Die instelling deelt echter de IPC-namespace van de host met de container. Als u dit liever niet opent, verhoog dan het gedeelde geheugen met --shm-size in plaats daarvan, zoals OpenAI’s recept doet voor zijn eigen container, en test op uw zwaarste pagina’s. Tot slot erft -e OPENAI_API_KEY zonder waarde de variabele van uw sessie: de sleutel verschijnt niet als platte tekst op de commandoregel.
Launch aan de Python-kant de browser met de voorzorgsmaatregelen uit OpenAI’s recept—sandbox ingeschakeld, lege omgeving, extensies en bestandstoegang uitgeschakeld—en routeer deze via de proxy uit de volgende sectie, net als de API-client:
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()
Gerichte netwerkbeperkingen
Plaats de agent-container op een intern Docker-netwerk zonder externe toegang. Een Squid-proxy sluit aan op dat netwerk en wordt de enige uitgang; de proxy is ook verbonden met een regulier netwerk. Alles wat niet expliciet is toegestaan, bestaat niet vanuit het perspectief van de agent.
# 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
Het cruciale punt: de proxy is verbonden met beide netwerken. Als u deze alleen op het interne netwerk zou starten, had hij zelf geen uitgaande toegang. api.openai.com staat op de lijst omdat de agent-code in deze opzet de API vanuit de container aanroept. De browser heeft dit niet nodig: het URL-filter in de volgende sectie blokkeert die oproepen vanaf de pagina.
URL-filtering
Een tweede, fijnmaziger barrière zit in de browser zelf. Door verzoeken te onderscheppen met page.route, vergelijkt u elke URL met de taakspecifieke allowlist—vaak korter dan die van de proxy—en breekt u de rest af, met een leesbaar logboek van elke blokkade. Pas op voor de valkuil van string-vergelijking waar OpenAI voor waarschuwt: https://example.com.evil.test mag niet doorgaan als https://example.com, en omgekeerd eindigt notexample.com op example.com. Vergelijk het schema, de exacte host (of een subdomein voorafgegaan door een punt) en de poort.
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"])
Deze laag vult de proxy aan; hij vervangt hem niet. Playwright merkt op dat page.route geen verzoeken onderschept die door een service worker worden afgehandeld, vandaar service_workers="block" in de context, en WebSockets gebruiken een ander mechanisme (page.route_web_socket). Netwerkfiltering blijft uw primaire barrière.
Gevoelige data beschermen
Informatie in screenshots maskeren
Elke screenshot gaat naar de API: alles wat op het scherm zichtbaar is, verlaat uw infrastructuur. OpenAI raadt aan inloggegevens uit paginatekst en captures te houden. Als het scherm wel gevoelige data bevat, maskeert u deze voordat u de capture naar het model stuurt. Een zwart rectangle over bekende gebieden is genoeg, mits u de coördinaten kent—waarom het standaardiseren van de viewport-grootte, zoals eerder in deze cursus behandeld, helpt. Maskeren verandert de afbeeldingsgrootte niet: coördinaten die door het model worden teruggegeven, blijven geldig.
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()
Weten wat er met captures gebeurt
Responses API-responses worden standaard opgeslagen: dat maakt chaining via previous_response_id mogelijk. Met store: false moet u elementen van eerdere turns zelf opnieuw verzenden. OpenAI merkt ook op dat store: false niet alle vormen van retentie elimineert, en input-afbeeldingen hebben hun eigen uitzonderingen: lees de data controls voordat u schermen met persoonlijke data verstuurt.
Nooit gevoelige data loggen
Hetzelfde redeneren geldt voor logs, die vaak veel langer blijven bestaan dan captures. Een logging-filter herschrijft riskante patronen voordat er wordt geschreven: wachtwoordtoewijzingen, OpenAI API-sleutels die beginnen met sk-, en reeksen van 16 cijfers die op kaartnummers lijken. Het filter werkt op het uiteindelijke bericht, dus het vangt ook op wat u zonder na te denken hebt gelogd.
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])
Twee details maken het verschil. Het instellen van record.args op None is essentieel: anders zou het reeds geformatteerde bericht opnieuw worden geformatteerd met zijn argumenten, en zou elke % in een URL het schrijven breken. En een filter op de handler geldt voor alles wat deze schrijft, terwijl een filter op een logger berichten van zijn child-loggers negeert.
API-veiligheidscontroles
Elke computer_call bevat een veld pending_safety_checks: de lijst met veiligheidscontroles die de API vraagt af te handelen voordat de acties worden uitgevoerd, elk met een id, code en message. OpenAI’s officiële voorbeeld stopt zodra deze niet leeg is. Als uw applicatie een mens deze gevallen kan laten valideren, erkent u ze expliciet door ze terug te geven in acknowledged_safety_checks, samen met de volgende screenshot. Het model kan deze goedkeuring niet namens u verlenen, en erkenning komt vóór uitvoering van de actie, nooit erna.
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
Uitvoeringslimieten
Er is ook het meest voorkomende risico: een agent die ontspoord raakt zonder iets te breken, maar twee uur draait en uw budget verbrandt. De klasse ExecutionLimits handhaaft drie plafonds—turns, duur en geschatte kosten—en gooit een uitzondering zodra er één wordt bereikt. Tarieven zijn niet hardcoded: haal ze op van het model dat u gebruikt op OpenAI’s prijs pagina, aangezien deze per model variëren.
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
Dit is slechts een schatting: het overschat input-tokens die uit de prompt-cache worden geserveerd, die tegen een verlaagd tarief worden gefactureerd, en negeert elke gehoste omgeving, die apart wordt gefactureerd. Vergelijk dit regelmatig met het daadwerkelijke gebruik van uw project. Stel plafonds in per workflow: een E2E-test van 30 seconden en een uur lange factuurinvoer vereisen niet dezelfde drempels.
Productie-beveiligingschecklist
Controleer voordat u een Computer Use-agent naar productie deployt:
- Geïsoleerde browser of desktop (container of virtuele machine), niet-geprivilegieerde gebruiker
- Uitgaand netwerk beperkt tot de sites van de taak, en tot de API als de loop in dezelfde omgeving draait
- URL-filter dat schema, host en poort vergelijkt; service workers geblokkeerd
- API-sleutel buiten code en buiten bereik van de browser gehouden (
env={}) - Schermcontent behandeld als niet-vertrouwd: stoppen en escaleren bij het eerste teken van injectie
- Menselijke bevestiging vóór aankopen, verzendingen, verwijderingen en het invoeren van gevoelige data
pending_safety_checksnooit erkend zonder menselijke validatie- Limieten op turns, duur en kosten
- Gefilterde logs, captures niet bewaard (of versleuteld)
- Geen persoonlijke bestanden, inloggegevens of Docker-socket gemount in de omgeving
- Resultaat geverifieerd in de applicatie voordat succes wordt aangekondigd
- Mechanisme voor noodstop (kill switch)
Het laatste punt wordt het vaakst vergeten, terwijl het het enige is dat helpt wanneer alle andere hebben gefaald. Een kill switch is een manier om de agent onmiddellijk te onderbreken, zonder te wachten tot hij een van zijn limieten bereikt: een STOP-bestand dat de loop elke iteratie controleert, een docker stop op de container, of een flag die uit een gedeelde variabele wordt gelezen. Test dit vóór productie, niet op de dag dat u het nodig hebt.
Belangrijkste punten
- OpenAI’s vier regels: beperk de omgeving, behandel het scherm als niet-vertrouwd, bevestig acties met hoge impact, en begrens en verifieer uitvoering
- Het verzoek van het model om te handelen is geen toestemming: uw code voert uit, schort op of geeft controle terug
- Isoleer de browser (niet-geprivilegieerde gebruiker, seccomp-profiel) en sta uitgaand verkeer alleen toe naar de sites van de taak
- Filter URLs door schema, host en poort te vergelijken—nooit via een simpele string-prefix of -suffix
- Erkent
pending_safety_checksalleen na menselijke validatie - Handhaaf limieten op turns, duur en kosten, en verifieer het daadwerkelijke resultaat