Seguridad y aislamiento (sandboxing)
En esta página
Lección reescrita el 3 de noviembre de 2026 basándose en la guía Computer use de OpenAI, sus recetas de integración para Computer use y la documentación de redes de Docker y Playwright. Novedades: las cuatro reglas de seguridad de OpenAI, sus niveles de confirmación y el reconocimiento de
pending_safety_checks. Correcciones: la versión anterior cortaba la red de un contenedor que necesitaba llamar a la API, dejaba el proxy sin acceso de salida, aceptabanotexample.comen un filtro destinado a permitir soloexample.com, rompía el formato de los registros y estimaba costes usando una tarifa única hardcodeada. Fuentes: Computer use · Recetas de integración · Playwright y Docker · Playwright, redes.
Dar control a una IA: los riesgos
Computer Use otorga a un modelo de IA la capacidad de actuar sobre un ordenador. Esto es potente, pero puede ser peligroso. Un agente mal configurado podría navegar hacia sitios maliciosos, ejecutar código arbitrario o exponer datos sensibles. Esto no es teórico: una página visitada podría contener instrucciones escritas para el modelo y, si el entorno no lo restringe, el modelo las seguirá como si fueran tu solicitud. La seguridad no es opcional; es la base de cualquier despliegue en producción.
Las cuatro reglas de OpenAI
OpenAI resume la seguridad de Computer Use en cuatro reglas. Aplícalas en tu aplicación y en el entorno de ejecución, no solo en las instrucciones del modelo:
- Restringe el entorno. Usa un navegador aislado o una máquina virtual, una lista blanca de sitios y acciones, y limita el acceso a lo estrictamente necesario para la tarea.
- Trata el contenido de la pantalla como no fiable. El texto de una página, documento o salida de una herramienta no puede conceder permiso ni sustituir las instrucciones del usuario. Si una página parece phishing o inyección de prompts, el agente se detiene y pregunta cómo proceder.
- Confirma acciones de alto riesgo. Las compras, la transmisión de datos, los cambios destructivos y cualquier cosa difícil de deshacer permanecen bajo control del usuario. Escribir información sensible en un formulario ya cuenta como transmisión.
- Acota y verifica la ejecución. Establece límites en turnos, duración o coste; proporciona una forma de cancelar; y verifica el resultado real, no solo el mensaje final del modelo.
El punto de partida es simple: la solicitud del modelo para actuar no es el permiso del usuario. Tu código decide si ejecutar, pausar para aprobación o devolver el control. Para un lote de acciones, detente antes de la primera que requiera confirmación.
Tres niveles de confirmación
OpenAI distingue tres situaciones, con ejemplos que puedes adoptar en tu política:
| Nivel | Ejemplos citados por OpenAI |
|---|---|
| El usuario retoma el control | Paso final de un cambio de contraseña; eludir una barrera de seguridad, como una advertencia HTTPS |
| Confirmar en el momento de la acción | Borrar datos, cambiar permisos o configuraciones de uso compartido, resolver un CAPTCHA, instalar o ejecutar software descargado, enviar o publicar en nombre del usuario, transacciones financieras, configuraciones del sistema |
| Preaprobación posible en la solicitud inicial | Iniciar sesión en un sitio que el usuario pidió visitar, enviar archivos, mover o renombrar archivos, transmitir datos sensibles cuyo uso específico fue aprobado |
Sin una aprobación clara en la solicitud inicial, confirma justo antes de la acción. No preguntes demasiado pronto: deja que el agente proceda con todo lo seguro, detente en el punto de riesgo y explica la acción, el riesgo y cómo se aplicarán los datos o el cambio. Si el usuario rechaza, nada se ejecuta y tu código indica al modelo qué tuvo éxito y qué falló.
El principio de mínimo privilegio
Tu agente debe tener acceso solo a lo estrictamente necesario para completar su tarea. Comienza con un navegador aislado; nunca uses el navegador principal del usuario, que mantiene sesiones abiertas de correo, banca y herramientas internas. El agente tampoco necesita acceso al sistema de archivos excepto para una carpeta de descargas dedicada, no necesita acceso a la red interna a menos que una aplicación empresarial lo requiera, y no debe tener derechos de administrador que puedan convertir un clic erróneo en un incidente del sistema. No montes archivos personales, credenciales ni el socket de Docker en su entorno. Por último, haz que la sesión sea efímera: borra los datos después de cada ejecución para que un flujo de trabajo nunca reutilice accidentalmente cookies o caché de la anterior.
Aislamiento (sandboxing) con Docker
Surgen dos preguntas: ¿dónde se ejecuta el navegador y dónde residen el bucle y la clave de API? La receta de Docker de OpenAI aísla un escritorio en un contenedor sin red, controlado desde el host mediante docker exec: solo el SDK en el host lee la clave. Esta es la configuración más estricta, pero solo funciona para tareas que no necesitan internet. Para otras tareas, OpenAI requiere un entorno cuya red de salida permita solo los sitios de la tarea.
Si mantienes Playwright y el agente debe navegar, puedes poner el bucle y el navegador en el mismo contenedor, siempre que se cumplan tres condiciones: un usuario sin privilegios, un navegador que no herede variables de entorno (para que no obtenga la clave) y una red de salida restringida a los sitios de la tarea y a la API.
# Imagen de Playwright para Python: navegadores y dependencias del sistema incluidos
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# El paquete playwright no está en la imagen: requirements.txt
# Fija playwright==1.64.1, la misma versión que la imagen
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Usuario sin privilegios proporcionado por la imagen
USER pwuser
CMD ["python", "src/main.py"]
Playwright recomienda fijar la versión de la imagen. La imagen proporciona los navegadores, no la biblioteca de Python: instala la misma versión del paquete playwright. No ejecutes el contenedor como root, lo que desactiva el sandbox de Chromium. Para sitios no fiables, Playwright también recomienda su perfil seccomp, que añade las llamadas al sistema que este sandbox necesita al perfil predeterminado de 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 evita procesos zombi y --ipc=host, recomendado por Playwright, evita que Chromium se quede sin memoria compartida y se bloquee. Sin embargo, esa configuración comparte el espacio de nombres IPC del host con el contenedor. Si prefieres no abrirlo, aumenta la memoria compartida con --shm-size en su lugar, como hace la receta de OpenAI para su propio contenedor, y prueba con tus páginas más pesadas. Por último, -e OPENAI_API_KEY sin un valor hereda la variable de tu sesión: la clave no aparece en texto plano en la línea de comandos.
En el lado de Python, lanza el navegador con las precauciones de la receta de OpenAI (sandbox activado, entorno vacío, extensiones y acceso al sistema de archivos desactivados) y enrútalo a través del proxy de la siguiente sección, igual que el cliente de la API:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# Las llamadas a la API salen a través del proxy de filtrado
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # el navegador no hereda variables de entorno, así que no la clave
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # ver filtrado de URL más abajo
)
page = context.new_page()
Restricciones de red específicas
Coloca el contenedor del agente en una red interna de Docker sin acceso externo. Un proxy Squid se une a esa red y se convierte en su única salida; el proxy también está conectado a una red normal. Todo lo que no esté explícitamente permitido no existe desde la perspectiva del agente.
# Red interna: sin acceso externo directo
docker network create --internal agent-net
# Red de salida, reservada para el proxy
docker network create sortie-proxy
# Proxy Squid (imagen mantenida por Canonical) con tu lista blanca
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
# El proxy se une a la red interna: esta es la única salida del agente
docker network connect agent-net agent-proxy
# squid.conf: permitir solo los dominios de la tarea y la API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
El punto clave: el proxy está conectado a ambas redes. Si lo lanzaras solo en la red interna, no tendría acceso de salida por sí mismo. api.openai.com está en la lista porque, en esta configuración, el código del agente llama a la API desde dentro del contenedor. El navegador no lo necesita: el filtro de URL de la siguiente sección bloquea esas llamadas desde la página.
Filtrado de URL
Una segunda barrera, más fina, reside en el propio navegador. Interceptando solicitudes con page.route, compara cada URL con la lista blanca específica de la tarea (a menudo más corta que la del proxy) y aborta el resto, con un registro legible de cada bloqueo. Cuidado con la trampa de comparación de cadenas que advierte OpenAI: https://example.com.evil.test no debe pasar como https://example.com, y a la inversa, notexample.com termina en example.com. Compara el esquema, el host exacto (o un subdominio prefijado con un punto) y el puerto.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Bloquea solicitudes a destinos no autorizados."""
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)
# El navegador solo necesita los sitios de la tarea: las llamadas a la API vienen de tu código Python, no de la página.
setup_url_filter(page, ["example.com"])
Esta capa complementa al proxy; no lo sustituye. Playwright señala que page.route no intercepta solicitudes gestionadas por un service worker, de ahí service_workers="block" en el contexto, y los WebSockets usan un mecanismo diferente (page.route_web_socket). El filtrado de red sigue siendo tu barrera principal.
Protección de datos sensibles
Ofuscar información en capturas de pantalla
Cada captura de pantalla va a la API: cualquier cosa visible en la pantalla sale de tu infraestructura. OpenAI recomienda mantener las credenciales fuera del texto de la página y de las capturas. Si la pantalla contiene datos sensibles, ofúscalos antes de enviar la captura al modelo. Un rectángulo negro sobre áreas conocidas es suficiente, siempre que conozcas sus coordenadas; por eso estandarizar el tamaño del viewport, como se cubrió anteriormente en este curso, ayuda. La ofuscación no cambia el tamaño de la imagen: las coordenadas devueltas por el modelo siguen siendo válidas.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Ofusca áreas sensibles en una captura 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()
Saber qué ocurre con las capturas
Las respuestas de la Responses API se almacenan por defecto: eso es lo que permite el encadenamiento mediante previous_response_id. Con store: false, debes reenviar tú mismo los elementos de turnos anteriores. OpenAI también señala que store: false no elimina todas las formas de retención, y las imágenes de entrada tienen sus propias excepciones: lee sus controles de datos antes de enviar pantallas que contengan datos personales.
Nunca registrar datos sensibles
El mismo razonamiento se aplica a los registros, que a menudo sobreviven mucho más que las capturas. Un filtro de registros reescribe patrones de riesgo antes de escribir: asignaciones de contraseñas, claves de API de OpenAI que comienzan por sk- y secuencias de 16 dígitos que se parecen a números de tarjeta. El filtro actúa sobre el mensaje final, por lo que también captura lo que registraste sin pensar.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Ofusca datos sensibles antes de escribir los registros."""
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 # el mensaje ya está formateado: no reformatearlo
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # en el handler, también ve los logger hijos
logging.basicConfig(level=logging.INFO, handlers=[handler])
Dos detalles marcan la diferencia. Establecer record.args en None es esencial: de lo contrario, el mensaje ya formateado se volvería a formatear con sus argumentos, y cualquier % en una URL rompería la escritura. Y un filtro en el handler se aplica a todo lo que escribe, mientras que un filtro en un logger ignora los mensajes de sus logger hijos.
Comprobaciones de seguridad de la API
Cada computer_call lleva un campo pending_safety_checks: la lista de comprobaciones de seguridad que la API te pide gestionar antes de ejecutar las acciones, cada una con un id, code y message. El ejemplo oficial de OpenAI se detiene tan pronto como no está vacío. Si tu aplicación puede tener un humano que valide estos casos, reconócelos explícitamente devolviéndolos en acknowledged_safety_checks, junto con la siguiente captura de pantalla. El modelo no puede conceder esta aprobación en tu nombre, y el reconocimiento ocurre antes de la ejecución de la acción, nunca después.
def valider_verifications(appel) -> list[dict]:
"""Envía las comprobaciones pendientes a un operador; rechaza por defecto."""
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
]
# En el bucle, antes de ejecutar acciones:
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
Límites de ejecución
También existe el riesgo más común: un agente que se descontrola sin romper nada, pero que funciona durante dos horas y quema tu presupuesto. La clase ExecutionLimits impone tres techos (turnos, duración y coste estimado) y lanza una excepción tan pronto como se alcanza uno. Las tarifas no están hardcodeadas: obténlas del modelo que estás usando en la página de precios de OpenAI, ya que varían según el modelo.
import time
class ExecutionLimits:
"""Impone techos de turnos, duración y coste al agente."""
def __init__(
self,
prix_entree_par_million: float, # tarifas para el modelo en uso
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):
"""Llama antes de cada solicitud: lanza un error si se alcanza un techo."""
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):
"""Llama después de cada respuesta: acumula turnos y coste estimado."""
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
Esto es solo una estimación: sobreestima los tokens de entrada servidos desde la caché del prompt, que se facturan a una tarifa reducida, e ignora cualquier entorno alojado, que se factura por separado. Compáralo regularmente con el uso real de tu proyecto. Establece techos por flujo de trabajo: una prueba E2E de 30 segundos y una entrada de facturas de una hora no requieren los mismos umbrales.
Lista de comprobación de seguridad para producción
Antes de desplegar un agente de Computer Use en producción, verifica:
- Navegador o escritorio aislado (contenedor o máquina virtual), usuario sin privilegios
- Red de salida limitada a los sitios de la tarea y a la API si el bucle se ejecuta en el mismo entorno
- Filtro de URL que compara esquema, host y puerto; service workers bloqueados
- Clave de API mantenida fuera del código y fuera del alcance del navegador (
env={}) - Contenido de la pantalla tratado como no fiable: detener y escalar ante el primer signo de inyección
- Confirmación humana antes de compras, envíos, borrados e introducción de datos sensibles
pending_safety_checksnunca reconocido sin validación humana- Límites de turnos, duración y coste
- Registros filtrados, capturas no retenidas (o cifradas)
- Sin archivos personales, credenciales ni socket de Docker montados en el entorno
- Resultado verificado en la aplicación antes de anunciar el éxito
- Mecanismo de parada de emergencia (kill switch)
El último punto es el que se olvida con más frecuencia, pero es el único que ayuda cuando todos los demás han fallado. Un kill switch es una forma de interrumpir el agente inmediatamente, sin esperar a que alcance uno de sus límites: un archivo STOP que el bucle comprueba en cada iteración, un docker stop en el contenedor o una bandera leída desde una variable compartida. Pruébalo antes de la producción, no el día que lo necesites.
Puntos clave
- Las cuatro reglas de OpenAI: restringir el entorno, tratar la pantalla como no fiable, confirmar acciones de alto riesgo y acotar y verificar la ejecución
- La solicitud del modelo para actuar no es un permiso: tu código ejecuta, suspende o devuelve el control
- Aísla el navegador (usuario sin privilegios, perfil seccomp) y permite el tráfico de salida solo a los sitios de la tarea
- Filtra las URL comparando esquema, host y puerto; nunca por un simple prefijo o sufijo de cadena
- Reconoce
pending_safety_checkssolo después de la validación humana - Impón límites de turnos, duración y coste, y verifica el resultado real