Sécurité et isolation (sandboxing)
In questa pagina
Leçon réécrite le 3 novembre 2026 sur la base du guide Computer use d’OpenAI, de ses recettes d’intégration Computer use, et de la documentation réseau de Docker et Playwright. Ajouts : les quatre règles de sécurité d’OpenAI, ses niveaux de confirmation et la prise en compte de
pending_safety_checks. Corrections : la version précédente coupait le réseau d’un conteneur devant appeler l’API, laissait le proxy sans accès sortant, acceptaitnotexample.comdans un filtre censé n’autoriser queexample.com, cassait le formatage des logs et estimait les coûts avec un taux unique codé en dur. Sources : Computer use · Recettes d’intégration · Playwright et Docker · Playwright, réseau.
Donner le contrôle à une IA : les risques
Computer Use donne à un modèle d’IA la capacité d’agir sur un ordinateur. C’est puissant, mais cela peut être dangereux. Un agent mal configuré pourrait naviguer vers des sites malveillants, exécuter du code arbitraire ou exposer des données sensibles. Ce n’est pas théorique : une page visitée pourrait contenir des instructions écrites pour le modèle, et si l’environnement ne le contraint pas, le modèle les suivra comme s’il s’agissait de ta demande. La sécurité n’est pas optionnelle : c’est le fondement de tout déploiement en production.
Les quatre règles d’OpenAI
OpenAI résume la sécurité de Computer Use en quatre règles. Applique-les dans ton application et dans l’environnement d’exécution, pas seulement dans les instructions du modèle :
- Restreins l’environnement. Utilise un navigateur ou une machine virtuelle isolé(e), une liste blanche de sites et d’actions, et limite l’accès à ce que la tâche exige.
- Traite le contenu de l’écran comme non fiable. Le texte issu d’une page, d’un document ou d’une sortie d’outil ne peut pas accorder de permission ni remplacer les instructions de l’utilisateur. Si une page ressemble à du hameçonnage ou à une injection de prompt, l’agent s’arrête et demande comment procéder.
- Confirme les actions à enjeux élevés. Les achats, la transmission de données, les modifications destructrices et tout ce qui est difficile à annuler restent sous le contrôle de l’utilisateur. Taper des informations sensibles dans un formulaire compte déjà comme une transmission.
- Délimite et vérifie l’exécution. Fixe des limites de tours, de durée ou de coût ; prévois un moyen d’annuler ; et vérifie le résultat réel, pas seulement le message final du modèle.
Le point de départ est simple : la demande d’agir du modèle n’est pas une permission de l’utilisateur. C’est ton code qui décide d’exécuter, de mettre en pause pour approbation ou de rendre la main. Pour un lot d’actions, arrête-toi avant la première qui nécessite une confirmation.
Trois niveaux de confirmation
OpenAI distingue trois situations, avec des exemples que tu peux adopter dans ta politique :
| Niveau | Exemples cités par OpenAI |
|---|---|
| L’utilisateur reprend la main | Dernière étape d’un changement de mot de passe ; contournement d’une barrière de sécurité, comme un avertissement HTTPS |
| Confirmation au moment de l’action | Suppression de données, modification de permissions ou de paramètres de partage, résolution d’un CAPTCHA, installation ou exécution de logiciels téléchargés, envoi ou publication au nom de l’utilisateur, transactions financières, paramètres système |
| Pré-approbation possible dans la demande initiale | Connexion à un site que l’utilisateur a demandé de visiter, envoi de fichiers, déplacement ou renommage de fichiers, transmission de données sensibles dont l’usage spécifique a été approuvé |
Sans approbation claire dans la demande initiale, confirme juste avant l’action. Ne demande pas trop tôt : laisse l’agent procéder sur tout ce qui est sûr, puis arrête-toi au point de risque et explique l’action, le risque, et comment les données ou le changement seront appliqués. Si l’utilisateur refuse, rien ne s’exécute, et ton code indique au modèle ce qui a réussi et ce qui a échoué.
Le principe du moindre privilège
Ton agent ne doit avoir accès qu’au strict nécessaire pour accomplir sa tâche. Commence par un navigateur isolé — jamais le navigateur principal de l’utilisateur, qui contient des sessions ouvertes pour les e-mails, la banque et les outils internes. L’agent n’a pas non plus besoin d’accès au système de fichiers, sauf pour un dossier de téléchargement dédié, n’a pas besoin d’accès au réseau interne sauf si une application métier l’exige, et ne doit pas avoir de droits d’administrateur qui pourraient transformer un mauvais clic en incident système. Ne monte pas de fichiers personnels, d’identifiants ou le socket Docker dans son environnement. Enfin, rends la session éphémère : supprime les données après chaque exécution pour qu’un flux de travail ne réutilise jamais accidentellement des cookies ou du cache de l’exécution précédente.
Isolation (sandboxing) avec Docker
Deux questions se posent : où le navigateur s’exécute-t-il, et où vivent la boucle et la clé API ? La recette Docker d’OpenAI isole un bureau dans un conteneur sans réseau, contrôlé depuis l’hôte via docker exec : seul le SDK sur l’hôte lit la clé. C’est la configuration la plus stricte, mais elle ne fonctionne que pour les tâches n’ayant pas besoin d’internet. Pour les autres tâches, OpenAI exige un environnement dont le réseau sortant n’autorise que les sites de la tâche.
Si tu gardes Playwright et que l’agent doit naviguer, tu peux mettre la boucle et le navigateur dans le même conteneur, à condition de respecter trois conditions : un utilisateur non privilégié, un navigateur qui n’hérite pas des variables d’environnement (pour qu’il ne récupère pas la clé), et un réseau sortant restreint aux sites de la tâche et à l’API.
# Image Playwright pour Python : navigateurs et dépendances système inclus
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Le paquet playwright n'est pas dans l'image : requirements.txt
# Épingler playwright==1.64.1, la même version que l'image
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Utilisateur non privilégié fourni par l'image
USER pwuser
CMD ["python", "src/main.py"]
Playwright recommande d’épingler la version de l’image. L’image fournit les navigateurs, pas la bibliothèque Python : installe la même version du paquet playwright. N’exécute pas le conteneur en root, ce qui désactive le sandbox de Chromium. Pour les sites non fiables, Playwright recommande aussi son profil seccomp, qui ajoute à Docker les appels système dont ce sandbox a besoin par rapport au profil par défaut.
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 empêche les processus zombies, et --ipc=host, recommandé par Playwright, évite que Chromium ne manque de mémoire partagée et ne plante. Cependant, ce paramètre partage l’espace de noms IPC de l’hôte avec le conteneur. Si tu préfères ne pas l’ouvrir, augmente la mémoire partagée avec --shm-size à la place, comme le fait la recette d’OpenAI pour son propre conteneur, et teste sur tes pages les plus lourdes. Enfin, -e OPENAI_API_KEY sans valeur hérite la variable de ta session : la clé n’apparaît pas en clair dans la ligne de commande.
Côté Python, lance le navigateur avec les précautions de la recette d’OpenAI — sandbox activé, environnement vide, extensions et accès au système de fichiers désactivés — et fais-le passer par le proxy de la section suivante, tout comme le client API :
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# Les appels API sortent via le proxy de filtrage
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # le navigateur n'hérite d'aucune variable d'environnement, donc pas la clé
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # voir le filtrage d'URL ci-dessous
)
page = context.new_page()
Restrictions réseau ciblées
Place le conteneur de l’agent sur un réseau Docker interne sans accès externe. Un proxy Squid rejoint ce réseau et devient sa seule sortie ; le proxy est aussi connecté à un réseau classique. Tout ce qui n’est pas explicitement autorisé n’existe pas du point de vue de l’agent.
# Réseau interne : pas d'accès externe direct
docker network create --internal agent-net
# Réseau sortant, réservé au proxy
docker network create sortie-proxy
# Proxy Squid (image maintenue par Canonical) avec ta liste blanche
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
# Le proxy rejoint le réseau interne : c'est la seule sortie de l'agent
docker network connect agent-net agent-proxy
# squid.conf : autoriser uniquement les domaines de la tâche et l'API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Le point clé : le proxy est connecté aux deux réseaux. Si tu l’avais lancé uniquement sur le réseau interne, il n’aurait lui-même aucun accès sortant. api.openai.com est dans la liste car, dans cette configuration, le code de l’agent appelle l’API depuis l’intérieur du conteneur. Le navigateur n’en a pas besoin : le filtre d’URL de la section suivante bloque ces appels depuis la page.
Filtrage d’URL
Une seconde barrière, plus fine, réside dans le navigateur lui-même. En interceptant les requêtes avec page.route, compare chaque URL à la liste blanche spécifique à la tâche — souvent plus courte que celle du proxy — et aborte le reste, avec un log lisible de chaque blocage. Attention au piège de la comparaison de chaînes qu’OpenAI signale : https://example.com.evil.test ne doit pas passer pour https://example.com, et inversement notexample.com se termine par example.com. Compare le schéma, l’hôte exact (ou un sous-domaine préfixé par un point), et le port.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Bloque les requêtes vers des destinations non autorisées."""
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)
# Le navigateur n'a besoin que des sites de la tâche : les appels API viennent de ton code Python, pas de la page.
setup_url_filter(page, ["example.com"])
Cette couche complète le proxy ; elle ne le remplace pas. Playwright note que page.route n’intercepte pas les requêtes gérées par un service worker, d’où service_workers="block" dans le contexte, et les WebSockets utilisent un mécanisme différent (page.route_web_socket). Le filtrage réseau reste ta barrière principale.
Protection des données sensibles
Masquage des informations dans les captures d’écran
Chaque capture d’écran va à l’API : tout ce qui est visible à l’écran quitte ton infrastructure. OpenAI recommande de garder les identifiants hors du texte et des captures de page. Si l’écran contient néanmoins des données sensibles, masque-les avant d’envoyer la capture au modèle. Un rectangle noir sur des zones connues suffit, à condition d’en connaître les coordonnées — c’est pourquoi standardiser la taille de la fenêtre, comme vu plus tôt dans ce cours, aide. Le masquage ne change pas la taille de l’image : les coordonnées renvoyées par le modèle restent valides.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Masque les zones sensibles dans une capture 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()
Savoir ce qu’il advient des captures
Les réponses de l’API Responses sont stockées par défaut : c’est ce qui permet l’enchaînement via previous_response_id. Avec store: false, tu dois renvoyer toi-même les éléments des tours précédents. OpenAI note aussi que store: false n’élimine pas toutes les formes de rétention, et que les images en entrée ont leurs propres exceptions : lis ses contrôles de données avant d’envoyer des écrans contenant des données personnelles.
Ne jamais logger de données sensibles
Le même raisonnement s’applique aux logs, qui survivent souvent bien plus longtemps que les captures. Un filtre de log réécrit les motifs à risque avant l’écriture : affectations de mots de passe, clés API OpenAI commençant par sk-, et séquences de 16 chiffres ressemblant à des numéros de carte. Le filtre agit sur le message final, donc il attrape aussi ce que tu as loggé sans y penser.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Masque les données sensibles avant l'écriture des 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 # le message est déjà formaté : ne pas le reformater
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # sur le handler, il voit aussi les loggers enfants
logging.basicConfig(level=logging.INFO, handlers=[handler])
Deux détails font la différence. Mettre record.args à None est essentiel : sinon, le message déjà formaté serait reformaté avec ses arguments, et tout % dans une URL casserait l’écriture. Et un filtre sur le handler s’applique à tout ce qu’il écrit, alors qu’un filtre sur un logger ignore les messages de ses loggers enfants.
Vérifications de sécurité de l’API
Chaque computer_call porte un champ pending_safety_checks : la liste des vérifications de sécurité que l’API te demande de traiter avant d’exécuter les actions, chacune avec un id, un code et un message. L’exemple officiel d’OpenAI s’arrête dès qu’elle n’est pas vide. Si ton application permet à un humain de valider ces cas, acquitte-les explicitement en les renvoyant dans acknowledged_safety_checks, accompagnés de la capture d’écran suivante. Le modèle ne peut pas accorder cette approbation en ton nom, et l’acquittement intervient avant l’exécution des actions, jamais après.
def valider_verifications(appel) -> list[dict]:
"""Soumet les vérifications en attente à un opérateur ; refuse par défaut."""
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
]
# Dans la boucle, avant d'exécuter les 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
Limites d’exécution
Il y a aussi le risque le plus courant : un agent qui part en vrille sans rien casser, mais tourne pendant deux heures et brûle ton budget. La classe ExecutionLimits impose trois plafonds — tours, durée et coût estimé — et lève une exception dès que l’un est atteint. Les tarifs ne sont pas codés en dur : récupère-les depuis le modèle que tu utilises sur la page de tarification d’OpenAI, car ils varient selon le modèle.
import time
class ExecutionLimits:
"""Impose des plafonds de tours, de durée et de coût à l'agent."""
def __init__(
self,
prix_entree_par_million: float, # tarifs pour le modèle utilisé
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):
"""Appeler avant chaque requête : lève une erreur si un plafond est atteint."""
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):
"""Appeler après chaque réponse : accumule les tours et le coût estimé."""
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
Ce n’est qu’une estimation : elle surestime les jetons d’entrée servis depuis le cache de prompt, qui sont facturés à un tarif réduit, et ignore tout environnement hébergé, facturé séparément. Compare-la régulièrement à l’usage réel de ton projet. Fixe des plafonds par flux de travail : un test E2E de 30 secondes et une saisie de facture d’une heure n’appellent pas les mêmes seuils.
Checklist de sécurité pour la production
Avant de déployer un agent Computer Use en production, vérifie :
- Navigateur ou bureau isolé (conteneur ou machine virtuelle), utilisateur non privilégié
- Réseau sortant limité aux sites de la tâche, et à l’API si la boucle s’exécute dans le même environnement
- Filtre d’URL qui compare schéma, hôte et port ; service workers bloqués
- Clé API gardée hors du code et hors de portée du navigateur (
env={}) - Contenu de l’écran traité comme non fiable : arrêt et escalade au premier signe d’injection
- Confirmation humaine avant achats, envois, suppressions et saisie de données sensibles
pending_safety_checksjamais acquittés sans validation humaine- Limites de tours, de durée et de coût
- Logs filtrés, captures non conservées (ou chiffrées)
- Aucun fichier personnel, identifiant ou socket Docker monté dans l’environnement
- Résultat vérifié dans l’application avant d’annoncer le succès
- Mécanisme d’arrêt d’urgence (kill switch)
Le dernier point est le plus souvent oublié, pourtant c’est le seul qui aide quand tous les autres ont échoué. Un kill switch est un moyen d’interrompre l’agent immédiatement, sans attendre qu’il atteigne l’une de ses limites : un fichier STOP que la boucle vérifie à chaque itération, un docker stop sur le conteneur, ou un drapeau lu depuis une variable partagée. Teste-le avant la production, pas le jour où tu en as besoin.
Punti chiave
- Les quatre règles d’OpenAI : restreindre l’environnement, traiter l’écran comme non fiable, confirmer les actions à enjeux élevés, et délimiter et vérifier l’exécution
- La demande d’agir du modèle n’est pas une permission : ton code exécute, suspend ou rend la main
- Isole le navigateur (utilisateur non privilégié, profil seccomp) et n’autorise le trafic sortant que vers les sites de la tâche
- Filtre les URL en comparant schéma, hôte et port — jamais par un simple préfixe ou suffixe de chaîne
- N’acquitte
pending_safety_checksqu’après validation humaine - Impose des limites de tours, de durée et de coût, et vérifie le résultat réel