Segurança e isolamento (sandboxing)
Nesta página
Lição reescrita a 3 de novembro de 2026 com base no guia Computer use da OpenAI, nas suas receitas de integração Computer use e na documentação de rede do Docker e do Playwright. Adições: as quatro regras de segurança da OpenAI, os seus níveis de confirmação e o reconhecimento de
pending_safety_checks. Correções: a versão anterior cortava a rede para um contentor que precisava de chamar a API, deixava o proxy sem acesso de saída, aceitavanotexample.comnum filtro destinado a permitir apenasexample.com, quebrava a formatação dos registos e estimava custos usando uma taxa única codificada. Fontes: Computer use · Receitas de integração · Playwright e Docker · Playwright, rede.
Dar controlo a uma IA: os riscos
O Computer Use confere a um modelo de IA a capacidade de agir num computador. Isso é poderoso, mas pode ser perigoso. Um agente mal configurado pode navegar para sites maliciosos, executar código arbitrário ou expor dados sensíveis. Isto não é teórico: uma página visitada pode conter instruções escritas para o modelo e, se o ambiente não o restringir, o modelo segui-las-á como se fossem o seu pedido. A segurança não é opcional — é a base de qualquer implementação em produção.
As quatro regras da OpenAI
A OpenAI resume a segurança do Computer Use em quatro regras. Aplique-as na sua aplicação e no ambiente de execução, não apenas nas instruções do modelo:
- Restrinja o ambiente. Utilize um navegador isolado ou uma máquina virtual, uma lista de permissões de sites e ações, e limite o acesso ao estritamente necessário para a tarefa.
- Trate o conteúdo do ecrã como não confiável. O texto de uma página, documento ou saída de ferramenta não pode conceder permissão nem substituir as instruções do utilizador. Se uma página parecer phishing ou injeção de prompt, o agente para e pergunta como proceder.
- Confirme ações de alto risco. Compras, transmissão de dados, alterações destrutivas e tudo o que seja difícil de desfazer permanecem sob controlo do utilizador. Escrever informações sensíveis num formulário já conta como transmissão.
- Limite e verifique a execução. Defina limites de turnos, duração ou custo; forneça uma forma de cancelar; e verifique o resultado real, não apenas a mensagem final do modelo.
O ponto de partida é simples: o pedido do modelo para agir não é permissão do utilizador. O seu código decide se executa, pausa para aprovação ou devolve o controlo. Para um lote de ações, pare antes da primeira que exija confirmação.
Três níveis de confirmação
A OpenAI distingue três situações, com exemplos que pode adotar na sua política:
| Nível | Exemplos citados pela OpenAI |
|---|---|
| O utilizador retoma o controlo | Passo final de uma alteração de palavra-passe; contornar uma barreira de segurança, como um aviso HTTPS |
| Confirmar no momento da ação | Eliminar dados, alterar permissões ou definições de partilha, resolver um CAPTCHA, instalar ou executar software transferido, enviar ou publicar em nome do utilizador, transações financeiras, definições do sistema |
| Pré-aprovação possível no pedido inicial | Iniciar sessão num site que o utilizador pediu para visitar, enviar ficheiros, mover ou renomear ficheiros, transmitir dados sensíveis cuja utilização específica foi aprovada |
Sem uma aprovação clara no pedido inicial, confirme imediatamente antes da ação. Não pergunte demasiado cedo: deixe o agente prosseguir com tudo o que é seguro, depois pare no ponto de risco e explique a ação, o risco e como os dados ou a alteração serão aplicados. Se o utilizador recusar, nada é executado e o seu código informa o modelo sobre o que teve sucesso e o que falhou.
O princípio do privilégio mínimo
O seu agente deve ter acesso apenas ao mínimo necessário para concluir a sua tarefa. Comece com um navegador isolado — nunca o navegador principal do utilizador, que contém sessões abertas de e-mail, banca e ferramentas internas. O agente também não precisa de acesso ao sistema de ficheiros, exceto para uma pasta de transferências dedicada, não precisa de acesso à rede interna a menos que uma aplicação empresarial o exija, e não deve ter direitos de administrador que possam transformar um clique errado num incidente de sistema. Não monte ficheiros pessoais, credenciais ou o socket do Docker no seu ambiente. Por fim, torne a sessão efémera: elimine os dados após cada execução para que um fluxo de trabalho nunca reutilize acidentalmente cookies ou cache da anterior.
Isolamento (Sandboxing) com Docker
Duas questões surgem: onde é que o navegador é executado e onde residem o loop e a chave da API? A receita Docker da OpenAI isola um ambiente de trabalho num contentor sem rede, controlado a partir do anfitrião via docker exec: apenas o SDK no anfitrião lê a chave. Esta é a configuração mais restritiva, mas só funciona para tarefas que não precisam de internet. Para outras tarefas, a OpenAI exige um ambiente cuja rede de saída permita apenas os sites da tarefa.
Se mantiver o Playwright e o agente tiver de navegar, pode colocar o loop e o navegador no mesmo contentor, desde que três condições sejam cumpridas: um utilizador sem privilégios, um navegador que não herde variáveis de ambiente (para não obter a chave) e rede de saída restrita aos sites da tarefa e à API.
# Imagem Playwright para Python: navegadores e dependências do sistema incluídos
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# O pacote playwright não está na imagem: requirements.txt
# Fixar playwright==1.64.1, a mesma versão da imagem
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Utilizador sem privilégios fornecido pela imagem
USER pwuser
CMD ["python", "src/main.py"]
O Playwright recomenda fixar a versão da imagem. A imagem fornece os navegadores, não a biblioteca Python: instale a mesma versão do pacote playwright. Não execute o contentor como root, o que desativa a sandbox do Chromium. Para sites não confiáveis, o Playwright recomenda também o seu perfil seccomp, que adiciona as chamadas de sistema necessárias a esta sandbox ao perfil padrão do 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 processos zombie e --ipc=host, recomendado pelo Playwright, impede que o Chromium fique sem memória partilhada e falhe. No entanto, essa definição partilha o namespace IPC do anfitrião com o contentor. Se preferir não o abrir, aumente a memória partilhada com --shm-size em vez disso, como a receita da OpenAI faz para o seu próprio contentor, e teste nas suas páginas mais pesadas. Por fim, -e OPENAI_API_KEY sem um valor herda a variável da sua sessão: a chave não aparece em texto simples na linha de comandos.
Do lado do Python, inicie o navegador com as precauções da receita da OpenAI — sandbox ativada, ambiente vazio, extensões e acesso ao sistema de ficheiros desativados — e encaminhe-o através do proxy da secção seguinte, tal como o cliente da API:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# As chamadas à API saem através do proxy de filtragem
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # o navegador não herda variáveis de ambiente, logo não obtém a chave
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # veja a filtragem de URL abaixo
)
page = context.new_page()
Restrições de rede direcionadas
Coloque o contentor do agente numa rede Docker interna sem acesso externo. Um proxy Squid junta-se a essa rede e torna-se a sua única saída; o proxy está também ligado a uma rede regular. Tudo o que não seja explicitamente permitido não existe na perspetiva do agente.
# Rede interna: sem acesso externo direto
docker network create --internal agent-net
# Rede de saída, reservada para o proxy
docker network create sortie-proxy
# Proxy Squid (imagem mantida pela Canonical) com a sua lista de permissões
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
# O proxy junta-se à rede interna: esta é a única saída do agente
docker network connect agent-net agent-proxy
# squid.conf: permitir apenas os domínios da tarefa e a API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
O ponto chave: o proxy está ligado a ambas as redes. Se o tivesse lançado apenas na rede interna, ele próprio não teria acesso de saída. api.openai.com está na lista porque, nesta configuração, o código do agente chama a API de dentro do contentor. O navegador não precisa disso: o filtro de URL na secção seguinte bloqueia essas chamadas a partir da página.
Filtragem de URL
Uma segunda barreira, mais fina, reside no próprio navegador. Ao intercetar pedidos com page.route, compare cada URL com a lista de permissões específica da tarefa — muitas vezes mais curta que a do proxy — e aborte o resto, com um registo legível de cada bloqueio. Cuidado com a armadilha de comparação de strings que a OpenAI alerta: https://example.com.evil.test não deve passar como https://example.com e, inversamente, notexample.com termina com example.com. Compare o esquema, o anfitrião exato (ou um subdomínio prefixado com um ponto) e a porta.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Bloquear pedidos para destinos não 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)
# O navegador só precisa dos sites da tarefa: as chamadas à API vêm do seu código Python, não da página.
setup_url_filter(page, ["example.com"])
Esta camada complementa o proxy; não o substitui. O Playwright nota que page.route não interceta pedidos tratados por um service worker, daí service_workers="block" no contexto, e os WebSockets usam um mecanismo diferente (page.route_web_socket). A filtragem de rede continua a ser a sua barreira primária.
Proteção de dados sensíveis
Ofuscar informações em capturas de ecrã
Cada captura de ecrã vai para a API: tudo o que esteja visível no ecrã sai da sua infraestrutura. A OpenAI recomenda manter credenciais fora do texto da página e das capturas. Se o ecrã contiver dados sensíveis, ofusque-os antes de enviar a captura ao modelo. Um retângulo preto sobre áreas conhecidas é suficiente, desde que conheça as suas coordenadas — é por isso que padronizar o tamanho da viewport, como abordado anteriormente neste curso, ajuda. A ofuscação não altera o tamanho da imagem: as coordenadas devolvidas pelo modelo permanecem válidas.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Ofuscar áreas sensíveis numa 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 o que acontece às capturas
As respostas da Responses API são armazenadas por padrão: é isso que permite o encadeamento via previous_response_id. Com store: false, tem de reenviar manualmente os elementos de turnos anteriores. A OpenAI nota também que store: false não elimina todas as formas de retenção e que as imagens de entrada têm as suas próprias exceções: leia os seus controlos de dados antes de enviar ecrãs que contenham dados pessoais.
Nunca registar dados sensíveis
O mesmo raciocínio aplica-se aos registos, que muitas vezes sobrevivem muito mais tempo que as capturas. Um filtro de registo reescreve padrões de risco antes de escrever: atribuições de palavras-passe, chaves API da OpenAI que começam por sk- e sequências de 16 dígitos que se assemelham a números de cartão. O filtro atua na mensagem final, pelo que também apanha o que registou sem pensar.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Ofuscar dados sensíveis antes de escrever registos."""
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 # a mensagem já está formatada: não a reformate
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # no handler, também vê loggers filhos
logging.basicConfig(level=logging.INFO, handlers=[handler])
Dois detalhes fazem a diferença. Definir record.args como None é essencial: caso contrário, a mensagem já formatada seria reformulada com os seus argumentos e qualquer % num URL quebraria a escrita. E um filtro no handler aplica-se a tudo o que ele escreve, enquanto um filtro num logger ignora mensagens dos seus loggers filhos.
Verificações de segurança da API
Cada computer_call transporta um campo pending_safety_checks: a lista de verificações de segurança que a API pede para tratar antes de executar as ações, cada uma com um id, code e message. O exemplo oficial da OpenAI para assim que não estiver vazio. Se a sua aplicação puder ter um humano a validar estes casos, reconheça-os explicitamente devolvendo-os em acknowledged_safety_checks, juntamente com a captura de ecrã seguinte. O modelo não pode conceder esta aprovação em seu nome e o reconhecimento ocorre antes da execução da ação, nunca depois.
def valider_verifications(appel) -> list[dict]:
"""Submeter verificações pendentes a um operador; recusar por padrão."""
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
]
# No loop, antes de executar ações:
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 de execução
Existe também o risco mais comum: um agente que se descontrola sem quebrar nada, mas que corre durante duas horas e queima o seu orçamento. A classe ExecutionLimits impõe três tetos — turnos, duração e custo estimado — e lança uma exceção assim que um é atingido. As taxas não são codificadas: obtenha-as do modelo que está a usar na página de preços da OpenAI, uma vez que variam consoante o modelo.
import time
class ExecutionLimits:
"""Impor tetos de turnos, duração e custo ao agente."""
def __init__(
self,
prix_entree_par_million: float, # taxas para o modelo em 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):
"""Chamar antes de cada pedido: lançar erro se um teto for atingido."""
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):
"""Chamar após cada resposta: acumular turnos e custo 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
Isto é apenas uma estimativa: superestima os tokens de entrada servidos a partir da cache de prompts, que são faturados a uma taxa reduzida, e ignora qualquer ambiente alojado, faturado separadamente. Compare-o regularmente com o uso real do seu projeto. Defina tetos por fluxo de trabalho: um teste E2E de 30 segundos e uma introdução de faturas de uma hora não exigem os mesmos limiares.
Lista de verificação de segurança para produção
Antes de implementar um agente Computer Use em produção, verifique:
- Navegador ou ambiente de trabalho isolado (contentor ou máquina virtual), utilizador sem privilégios
- Rede de saída limitada aos sites da tarefa e à API, se o loop correr no mesmo ambiente
- Filtro de URL que compara esquema, anfitrião e porta; service workers bloqueados
- Chave API mantida fora do código e fora do alcance do navegador (
env={}) - Conteúdo do ecrã tratado como não confiável: parar e escalar ao primeiro sinal de injeção
- Confirmação humana antes de compras, envios, eliminações e introdução de dados sensíveis
pending_safety_checksnunca reconhecidos sem validação humana- Limites de turnos, duração e custo
- Registos filtrados, capturas não retidas (ou encriptadas)
- Sem ficheiros pessoais, credenciais ou socket do Docker montados no ambiente
- Resultado verificado na aplicação antes de anunciar sucesso
- Mecanismo de paragem de emergência (kill switch)
O último ponto é o mais frequentemente esquecido, no entanto é o único que ajuda quando todos os outros falharam. Um kill switch é uma forma de interromper o agente imediatamente, sem esperar que atinja um dos seus limites: um ficheiro STOP que o loop verifica a cada iteração, um docker stop no contentor ou uma flag lida de uma variável partilhada. Teste-o antes da produção, não no dia em que precisar dele.
Pontos-chave
- As quatro regras da OpenAI: restringir o ambiente, tratar o ecrã como não confiável, confirmar ações de alto risco e limitar e verificar a execução
- O pedido do modelo para agir não é permissão: o seu código executa, suspende ou devolve o controlo
- Isolar o navegador (utilizador sem privilégios, perfil seccomp) e permitir tráfego de saída apenas para os sites da tarefa
- Filtrar URLs comparando esquema, anfitrião e porta — nunca por um simples prefixo ou sufixo de string
- Reconhecer
pending_safety_checksapenas após validação humana - Impor limites de turnos, duração e custo e verificar o resultado real