Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Segurança e isolamento (sandboxing)

Aula 12 de 14 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Dar controlo a uma IA: os riscos
  2. As quatro regras da OpenAI
  3. O princípio do privilégio mínimo
  4. Isolamento (Sandboxing) com Docker
  5. Filtragem de URL
  6. Proteção de dados sensíveis
  7. Verificações de segurança da API
  8. Limites de execução
  9. Lista de verificação de segurança para produção
  10. Pontos-chave

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, aceitava notexample.com num filtro destinado a permitir apenas example.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ívelExemplos citados pela OpenAI
O utilizador retoma o controloPasso final de uma alteração de palavra-passe; contornar uma barreira de segurança, como um aviso HTTPS
Confirmar no momento da açãoEliminar 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 inicialIniciar 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_checks nunca 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_checks apenas após validação humana
  • Impor limites de turnos, duração e custo e verificar o resultado real