Egress e Credential Vault do OpenSandbox: Hands-On no Amazon EKS
Por Fabio Douek
Ir para seção
- Visão Geral
- Arquitetura
- Configuração
- Passo 1: O código complementar
- Passo 2: Uma imagem de workload com os clientes
- Passo 3: Um servidor echo como destino permitido
- Passo 4: Um sandbox com uma policy e um vault
- Testes
- Teste 1: Sem policy, sem sidecar
- Teste 2: Regras, um patch em runtime e uma conexão que sobrevive à própria regra
- Teste 3: A CA do proxy, e quais clientes confiam nela
- Teste 4: Credenciais reais para GitHub e Anthropic
- Teste 5: Todos os tipos de auth, e substituições
- Teste 6: Extraindo as credenciais
- Teste 7: Rotação e revogação
- Teste 8: Pausa e retomada apagam o vault
- Teste 9: O que vai para o log
- Resumo dos resultados
- O que o vault não resolve
- Limpeza
- Veredito
- Com o que você está se comprometendo
- Quem deve usar
Explica (TLDR) como se eu fosse...
Imagine um robô ajudante em uma sala de brinquedos com uma porta só, e um guarda na porta que fica com todas as chaves de verdade. O robô só carrega chaves de mentirinha. Quando ele chega a uma porta pela qual pode passar, o guarda coloca a chave de verdade no lugar, então o robô nunca encosta nela.
Eu tentei enganar o guarda. A maioria dos truques falhou: o robô não conseguiu achar as chaves nem escapar por outro caminho. Um truque funcionou: quando o robô gritou o nome de outra porta, o guarda entregou a chave daquela porta. E depois que a sala de brinquedos tirou uma soneca, o guarda tinha esquecido todas as chaves.
Este post testa um controle que mantém credenciais de API longe do código que um agente de IA executa: o Credential Vault do OpenSandbox 1.2.0, um projeto Apache 2.0 da Agentic AI Foundation, no Amazon EKS. O sandbox guarda placeholders, e um proxy no mesmo pod adiciona a credencial real às requisições de saída aprovadas.
O achado relevante é um defeito em aberto. O proxy escolheu a credencial a partir de um header que o sandbox escreve, então uma requisição para um host aprovado recebeu a credencial de outro host. Há uma correção proposta, mas sem merge. Os registros de auditoria são parciais, e uma pausa apaga as credenciais armazenadas.
A queixa principal é um agente que precisa de API keys reais, mas nunca deveria conseguir lê-las. A intervenção é um proxy ao lado do sandbox que guarda as chaves e as adiciona às requisições aprovadas, enquanto o sandbox só tem placeholders. Eu testei no Amazon EKS com credenciais do GitHub e da Anthropic.
Variáveis de ambiente, registros de processos, arquivos e os serviços de metadados não revelaram nada. Um defeito conhecido se reproduziu: uma requisição para um host aprovado recebeu a credencial de outro host, porque o proxy confia em um header que o sandbox escreve. Efeitos colaterais: uma pausa apaga as chaves, e as linhas de auditoria chegam atrasadas, em lotes.
Existe um conforto real em ouvir que as chaves nunca vivem onde o código arriscado roda. Isso permite entregar trabalho de verdade a um agente, pushes no git e chamadas a modelos, sem aquele zumbido baixo de preocupação com o que ele poderia copiar. Nas minhas execuções, essa promessa se manteve na maior parte: o ambiente, os processos e os arquivos do sandbox só tiveram placeholders.
A conversa mais difícil é sobre o único truque que funcionou. Nomear outro host bastou para obter a chave daquele host, e a correção ainda espera o merge. Some a isso um vault que esquece tudo na pausa e logs que chegam em lotes, e a confiança vira algo que você precisa continuar verificando.
Pense no sidecar de egress como um produtor de palco na única porta da sala de ensaio. Quem toca lá dentro carrega um passe substituto, e quando segue para uma casa de show da lista, o produtor troca pelo verdadeiro. Toda chamada que eu tentei, GitHub, pushes no git e uma API de modelo, entrou no tempo certo.
A nota desafinada estava em como o produtor lia o setlist: pelo grito de quem tocava, não pelo lugar para onde realmente ia, então o passe de uma casa de show foi parar em outra. Uma pausa também esvazia os bolsos do produtor, e o registro de quem recebeu qual passe chega atrasado, em lotes.
A história são chaves que nunca entram no sandbox. O OpenSandbox 1.2.0 adiciona credenciais reais do GitHub e da Anthropic no egress, então um agente pode fazer push de código e chamar um modelo tendo apenas placeholders. No Amazon EKS isso funcionou em todas as execuções, e todas as formas diretas que eu tentei para ler as chaves armazenadas de dentro falharam.
O posicionamento honesto vem com ressalvas sobre as quais os compradores vão perguntar. Uma falha conhecida deixou uma requisição para um host aprovado obter a chave de outro host, e a correção dela ainda não teve merge. As credenciais somem na pausa, e a trilha de auditoria são linhas de log que chegam em lotes.
Visão Geral
O OpenSandbox é um projeto da Agentic AI Foundation, um directed fund da Linux Foundation, desde o anúncio de 22 de outubro de 2026; a parte 1 cobre essa mudança.
Este post, parte 4 de 6, testa os dois recursos que sustentam o ângulo da série, ser dono do sandbox e manter as chaves fora dele, no cluster EKS da parte 2. O sidecar de egress restringe o sandbox a uma allowlist deny-by-default. O Credential Vault, construído sobre o sidecar, adiciona credenciais reais às requisições de saída, então o código no sandbox só tem placeholders. Nove testes cobrem quando um sandbox ganha um sidecar, os tipos de regra, a autoridade certificadora do proxy, credenciais reais, substituições, tentativas de vazamento, rotação, pausa e logging.
O vault funcionou com serviços reais: a API do GitHub, git clone e git push para um repositório de teste privado, e a Anthropic Messages API autenticaram a partir de um sandbox cujo ambiente só tinha strings osb-placeholder-*. A exceção é a que mais importa. Com credenciais fictícias na release 1.2.0, uma requisição para um host permitido que levava o header Host de outro binding recebeu a credencial desse binding, nos dois sentidos. Eu rodei isso sobre HTTP puro, e o código escolhe o binding do mesmo jeito para HTTPS. Essa é a #1758, aberta desde 8 de setembro de 2026; a correção dela para HTTPS, o PR #1759, ainda estava aberta em 7 de novembro de 2026. O Teste 6 tem os detalhes, e o Resumo dos resultados, o resto.
A parte 3 cobre o ciclo de vida do sandbox, os pools e a troca para Kata, a parte 5 se apoia neste post para assinar requisições da AWS no egress, e a parte 6 faz um stress test nos mesmos dois nodes. Tudo aqui roda sob runc, com o egress do servidor no modo dns+nft, como a parte 2 deixou. Todos os números vêm das minhas execuções de 1º de novembro de 2026 (UTC), e eu aviso quando uma execução não está nas gravações.
Arquitetura
O sidecar e o workload são dois containers em um pod, então compartilham um network namespace: as mesmas interfaces, a mesma tabela de roteamento e o mesmo 127.0.0.1. É assim que o sidecar consegue direcionar o tráfego do workload sem a cooperação do workload. Ele é o único container em execução com a capability NET_ADMIN (o init container execd-installer roda privilegiado por um momento para desligar o IPv6 e depois sai), e instala regras de redirecionamento e de filtro para o namespace inteiro; o container de workload tem a NET_ADMIN removida, então não consegue desfazê-las. O mesmo compartilhamento também é o ponto fraco do vault, como O que o vault não resolve explica.
dns+nft) fiscaliza todo pacote que sai, inclusive as conexões do próprio proxy. Em portas que não sejam 80 e 443, ou com o credential proxy desligado, as conexões do workload encontram o nftables diretamente; nas portas 80 e 443 com o proxy ligado, é a conexão upstream do proxy que o nftables descarta. Azul é o lado confiável, verde é o tráfego permitido, vermelho é o que o nftables descarta.- Um cliente confiável grava o vault, credenciais e bindings, pela API do sidecar na porta 18080, com o egress token do sandbox. Aqui é o SDK Python, pelo proxy do servidor de lifecycle. As leituras devolvem nomes e uma revisão, nunca um valor.
- O proxy DNS responde
NXDOMAINpara um nome que a policy não permite e encaminha um nome permitido ao CoreDNS. Os endereços da resposta entram nos allow sets do nftables pelo TTL do registro mais 60 segundos (de 60 a 360 segundos), renovados enquanto uma conexão estiver aberta. - As portas 80 e 443 são redirecionadas para o proxy transparente (mitmdump), que apresenta um certificado assinado pela CA do sidecar.
- O proxy lê o vault ativo por um socket Unix privado e escolhe o binding cujos scheme, host, porta, método e path batem. O host vem do header
Hostda requisição. Sem correspondência, a requisição segue inalterada. - A conexão do próprio proxy com o upstream sai pelo nftables como qualquer outro pacote.
- Um upstream permitido recebe a credencial real. Valores injetados dentro de headers de resposta são substituídos por
[REDACTED]; os bodies de resposta não são tocados. - Todo o resto encontra o nftables diretamente, e um endereço que nenhuma regra ou lease permite é descartado. O nftables aceita pacotes de conexões estabelecidas antes de qualquer regra (Teste 2).
O vault tem pré-requisitos rígidos: o egress do servidor no modo dns+nft, uma network policy na requisição de criação, credentialProxy.enabled e o egress token que o servidor configura para cada sandbox (guia do Credential Vault). A policy deve ser deny-by-default; default-allow ainda funciona na 1.2.0, mas registra um warning de deprecação. Veja o que cada camada fez nas minhas execuções:
| O sandbox tentou | Policy | O que respondeu | O que o sandbox viu | Teste |
|---|---|---|---|---|
https://example.org/ | deny, allow pypi.org | proxy DNS | NXDOMAIN (curl exit 6) | 1, 2 |
https://github.com/ | allow *.github.com | proxy DNS | NXDOMAIN (curl exit 6) | 2 |
1.1.1.2 | allow 1.0.0.1/32 | nftables | timeout (curl exit 28) | 2 |
1.1.1.1 porta 80 | allow 1.1.1.1/32 porta 443 | nftables | timeout (curl exit 28) | 2 |
| O serviço de metadados da instância e o agente do Pod Identity | deny, sem regra para eles | nada (consistente com o nftables descartando a conexão upstream do proxy) | timeout (curl exit 28) | 6 |
api.github.com/user com um token placeholder | allow, binding bearer | proxy e vault | um usuário autenticado | 4 |
127.0.0.1:18080/credential-vault | qualquer | a API do sidecar | HTTP 401 | 6 |
O exit 6 é o “couldn’t resolve host” do curl, e o exit 28, o timeout dele: um nome negado falha como um domínio inexistente, e um pacote descartado, como um host inalcançável. Nenhum dos dois diz ao código no sandbox que uma policy estava envolvida.
Configuração
Passo 1: O código complementar
Os scripts rodam no cluster da parte 2 e usam dois diretórios vizinhos: ../opensandbox-eks para o endereço do servidor, a API key e o env.sh, e ../opensandbox-lifecycle, da parte 3, para o keeper do port-forward e, no caso do 08_pause_wipe.py, o registry de snapshots de que a pausa e a retomada precisam. Rode primeiro os scripts 01_cluster.sh a 07_first_sandbox.py da parte 2.
git clone https://github.com/fabiodouek/my2centsai-blog-samples.git
cd my2centsai-blog-samples/opensandbox-egress
| Arquivo | O que faz |
|---|---|
00_image.sh, image/Dockerfile | A imagem de workload (Passo 2) |
00_echo.sh, manifests/echo-server.yaml | O servidor echo (Passo 3) |
01_sidecar.py a 08_pause_wipe.py | Um script por teste; os Testes 8 e 9 compartilham o 08 |
98_cleanup.py | Deleta os sandboxes que estes scripts deixaram para trás |
common.py | Os helpers da parte 2, o parser de segredos, o scrubber |
Cada script marca os seus sandboxes com example=opensandbox-egress, dá a eles um TTL de 20 minutos, os deleta no final (também em caso de falha), sai com 1 se uma verificação falhar e inicia o port-forward para o servidor em 127.0.0.1:18080 se nada responder ali. Só o 04_vault_services.py usa credenciais reais, um token fine-grained do GitHub com acesso de push a um repositório de teste privado e uma API key da Anthropic, lidas de um arquivo de segredos fora do repositório com um parser de linhas, nunca com source. Os outros testes usam valores inventados dummy-<label>-<hex>. Toda a saída passa por um scrubber que substitui o token e a key, e as formas base64 deles, por <redacted>.
Passo 2: Uma imagem de workload com os clientes
A imagem Python da parte 2 não tem curl, git, Node nem a AWS CLI, que o teste da CA compara. O 00_image.sh constrói uma que os tem, para linux/amd64, a partir da mesma base do ECR Public:
FROM public.ecr.aws/docker/library/python:3.12-slim
ARG AWSCLI_VERSION=2.39.3
RUN apt-get update \
&& apt-get install -y --no-install-recommends ca-certificates curl git nodejs unzip procps iproute2 \
&& curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-${AWSCLI_VERSION}.zip" -o /tmp/awscli.zip \
&& unzip -q /tmp/awscli.zip -d /tmp \
&& /tmp/aws/install \
&& rm -rf /tmp/aws /tmp/awscli.zip /var/lib/apt/lists/* \
&& pip install --no-cache-dir requests
./00_image.sh
Ele faz push de opensandbox-eks/egress-tools:1 usando uma config do Docker descartável. O build e o push levaram 62,7 segundos na gravação.
Passo 3: Um servidor echo como destino permitido
Para ver como fica uma requisição quando ela chega, eu precisava de um destino que me contasse. O manifests/echo-server.yaml é um pequeno servidor Python no namespace opensandbox que responde a qualquer método em qualquer path com o que recebeu, em JSON: método, path, cada header, o body e qual dos seus dois listeners aceitou a conexão. Dois Services apontam para esse único pod:
apiVersion: v1
kind: Service
metadata: { name: echo, namespace: opensandbox }
spec:
selector: { app: echo }
ports: [{ name: http, port: 80, targetPort: 8080 }]
---
apiVersion: v1
kind: Service
metadata: { name: echo-alt, namespace: opensandbox }
spec:
selector: { app: echo }
ports: [{ name: http, port: 80, targetPort: 8081 }]
Os dois listeners permitem que o teste do header Host saiba para onde uma requisição foi de fato, diga o header Host dela o que disser, e um path /stream envia uma linha por segundo para o teste de conexão aberta. O servidor fala HTTP puro na porta 80 de propósito: o proxy intercepta a 80, além da 443, e um binding com schemes: ["http"] injeta ali (o Teste 5 confirma).
./00_echo.sh
O script aplica o manifest, espera o rollout e busca /probe pelos dois Services a partir de um pod descartável.
Passo 4: Um sandbox com uma policy e um vault
Nada muda no servidor. A parte 2 já definiu [egress] mode = "dns+nft" e a imagem de egress da 1.2.0, e o servidor roda os sandboxes sob runc. Um sandbox recebe o sidecar e o credential proxy pela sua requisição de criação. Simplificado a partir do common.py e do 06_leaks.py:
sb = SandboxSync.create(
workload_image(), # egress-tools:1 from Step 2
connection_config=connection("proxy"), # through the server's proxy
metadata=own_metadata(SCRIPT, RUN), # example=opensandbox-egress
network_policy=NetworkPolicy(
default_action="deny",
egress=[NetworkRule(action="allow", target="echo.opensandbox.svc.cluster.local")],
),
credential_proxy=CredentialProxyConfig(enabled=True),
env={"CARRIER_A": "osb-placeholder-a"},
timeout=timedelta(minutes=20),
resource={"cpu": "500m", "memory": "1Gi"},
)
sb.credential_vault.create(
credentials=[{"name": "cred-a", "source": {"type": "inline", "value": dummy_a}}],
bindings=[{
"name": "bind-a",
"match": {"hosts": ["echo.opensandbox.svc.cluster.local"], "schemes": ["http"]},
"auth": {"type": "apiKey", "name": "x-binding-a", "credential": "cred-a"},
}],
)
O vault é gravado depois do create, pelo lado confiável, e o SDK alcança a API do sidecar pelo proxy do servidor, como alcança o execd na parte 2. O valor é write-only: credential_vault.get() devolve nomes, bindings e uma revisão.
Testes
Todas as execuções abaixo são as gravadas, resumidas: eu tirei as linhas em que um script reiniciava o port-forward e as linhas de limpeza. Na saída do Teste 4, o login do GitHub foi substituído por example-org e as linhas que mostram a URL do repositório de teste foram removidas.
Teste 1: Sem policy, sem sidecar
O 01_sidecar.py cria dois sandboxes. O A não tem network policy. O B tem defaultAction: deny, uma regra de allow para pypi.org e o credential proxy ligado.
== A: no network policy
pod 9ca405ab-5203-43b4-b722-f442e5b2f823-0: containers ['sandbox'], init containers ['execd-installer']
PASS A has no egress container
https://pypi.org/simple/ reached (http 200)
PASS A reaches https://pypi.org/simple/
https://example.org/ reached (http 200)
PASS A reaches https://example.org/
== B: networkPolicy deny + allow pypi.org, credentialProxy enabled
pod ba420421-4b1e-4d87-b6df-c61765897fbd-0: containers ['sandbox', 'egress'], init containers ['execd-installer']
PASS B has an egress container (found: egress)
egress policy as the sidecar enforces it: {'defaultAction': 'deny', 'egress': [{'action': 'allow', 'target': 'pypi.org'}]}
PASS B reaches the allowed pypi.org (http 200)
PASS B cannot reach example.org (not in the policy) (curl rc 6)
O sidecar só existe quando a requisição de criação traz uma networkPolicy. Sem ela, o pod tem um único container e o tráfego de saída não é filtrado, e a lista always-deny do operador (deny.always), que vive no sidecar, também não se aplica. Se você roda OpenSandbox para outras pessoas, um sandbox sem policy é um sandbox sem controle de egress nenhum, então torne a policy obrigatória no que quer que crie os sandboxes para você.
Teste 2: Regras, um patch em runtime e uma conexão que sobrevive à própria regra
O 02_rules.py roda um sandbox sob deny-default com cinco regras: um FQDN, um wildcard, um CIDR, um IP restrito a uma porta e o servidor echo pelo nome. Aqui não há credential proxy, então nada é interceptado: são só o DNS e o nftables.
As verificações das regras, resumidas
policy: {'defaultAction': 'deny', 'egress': [{'action': 'allow', 'target': 'pypi.org'}, {'action': 'allow', 'target': '*.github.com'}, {'action': 'allow', 'target': '1.0.0.1/32'}, {'action': 'allow', 'target': '1.1.1.1/32', 'ports': [443]}, {'action': 'allow', 'target': 'echo.opensandbox.svc.cluster.local'}]}
== 1. FQDN rule
pypi.org (allowed) reached (http 200)
example.org (not listed) refused (curl rc 6)
== 2. wildcard *.github.com
api.github.com (sub-label) reached (http 200)
github.com (the apex) refused (curl rc 6)
== 3. CIDR rule 1.0.0.1/32 (a direct-IP dial)
1.0.0.1 (in the CIDR) reached (http 301)
1.1.1.2 (not listed) refused (curl rc 28)
== 4. port-scoped rule 1.1.1.1/32 TCP 443
1.1.1.1:443 (allowed port) reached (http 301)
1.1.1.1:80 (same IP, other port) refused (curl rc 28)
== 5. runtime patch: add example.org
policy now: ['example.org', 'pypi.org', '*.github.com', '1.0.0.1/32', '1.1.1.1/32', 'echo.opensandbox.svc.cluster.local']
example.org (after the patch) reached (http 200)
Todo tipo de regra fez o que a documentação diz. O wildcard casa com um subdomínio, não com o apex. Regras restritas a uma porta, novas no BatchSandbox na 1.2.0, só funcionam no modo dns+nft e nunca em um domínio, porque os nomes são filtrados na camada DNS. O patch_egress_rules passou a valer na requisição seguinte. O servidor echo era alcançável pelo FQDN: o proxy DNS encaminha nomes permitidos ao CoreDNS, então o nome de um Service funciona como um nome público.
Depois, o comportamento que a #2329 relata. O script inicia um stream de 40 linhas do servidor echo, uma linha por segundo, apaga a regra do servidor echo aos quatro segundos e tenta duas conexões novas:
== 6. an established connection outlives a tightened policy (#2329)
echo.opensandbox.svc.cluster.local by name reached (http 200)
stream started: 4 line(s) after 4 s
policy tightened, echo server removed: ['example.org', 'pypi.org', '*.github.com', '1.0.0.1/32', '1.1.1.1/32']
a NEW connection by name refused (curl rc 6)
a NEW connection by ClusterIP refused (curl rc 28)
the open stream after the removal:
tick 39/40
tick 40/40
PASS the established connection delivered all 40 ticks (40 lines)
A remoção barrou conexões novas, por nome e por endereço, mas o stream aberto entregou os 40 ticks: o nftables aceita pacotes de conexões estabelecidas antes de qualquer regra, então restringir uma policy nunca corta uma conexão aberta. Em um fluxo de “instalar e depois fechar o acesso”, uma conexão aberta durante a instalação sobrevive ao bloqueio. O PR #2346 propõe uma flag opt-in dropEstablished para a API de policy; ele ainda estava aberto em 7 de novembro de 2026. Até lá, feche o acesso antes de rodar o código em que você não confia, não depois.
Teste 3: A CA do proxy, e quais clientes confiam nela
Com o credential proxy ligado, toda conexão HTTPS na porta 443 que envia um server name termina no sidecar, que assina um certificado para o host solicitado com a própria CA. Os clientes precisam confiar nessa CA, ou falham. O 03_ca_trust.py olha o que o bootstrap do execd prepara e depois faz uma chamada HTTPS a partir de quatro clientes. Os quatro confiaram nela:
O que o bootstrap preparou, e os quatro clientes
== what the bootstrap set up
-rw-r--r--. 1 root root 237035 Nov 1 12:40 merged-ca-certificates.pem
-rw-r--r--. 1 root root 1172 Nov 1 12:40 mitmproxy-ca-cert.pem
REQUESTS_CA_BUNDLE=/opt/opensandbox/merged-ca-certificates.pem
SSL_CERT_FILE=/opt/opensandbox/merged-ca-certificates.pem
NODE_EXTRA_CA_CERTS=/opt/opensandbox/mitmproxy-ca-cert.pem
AWS_CA_BUNDLE=<unset>
CURL_CA_BUNDLE=<unset>
GIT_SSL_CAINFO=<unset>
opensandbox-mitmproxy-ca.crt
== the same HTTPS call from four clients
curl trusts the CA: HTTP 200
Python requests trusts the CA: HTTP 200
Node trusts the CA: HTTP 200
AWS CLI v2 trusts the CA: aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the GetCallerIdentity operation: The security token included in the request is invalid.
== who signs the certificate the sandbox sees
* subject: CN=api.github.com
* issuer: CN=mitmproxy; O=mitmproxy
Dois arquivos aparecem em /opt/opensandbox: o sidecar exporta a sua CA para lá (1.172 bytes), e o bootstrap do execd espera por ela e grava um bundle que junta as raízes públicas e essa CA (237.035 bytes). O bootstrap aponta REQUESTS_CA_BUNDLE e SSL_CERT_FILE para o bundle combinado e NODE_EXTRA_CA_CERTS para a CA, e coloca a CA no diretório do store do sistema operacional (a última linha, de /usr/local/share/ca-certificates/). Ele não define AWS_CA_BUNDLE. A chamada da AWS CLI usa chaves inventadas contra o STS: InvalidClientTokenId significa que o TLS funcionou e a AWS rejeitou as chaves, enquanto um cliente que não confia na CA para no handshake.
Eu esperava que a AWS CLI v2 falhasse aqui. Não falhou, então o script muda uma configuração por vez no mesmo sandbox para descobrir por quê:
| Ambiente (AWS CLI 2.39.3, imagem Debian) | Resultado |
|---|---|
| Como o bootstrap deixa | Confia na CA |
REQUESTS_CA_BUNDLE e SSL_CERT_FILE não definidas, então só o store do sistema operacional | Falha |
Só REQUESTS_CA_BUNDLE definida | Confia na CA |
Só SSL_CERT_FILE definida | Falha |
Só AWS_CA_BUNDLE definida | Confia na CA |
As duas falhas foram iguais:
aws: [ERROR]: SSL validation failed for https://sts.us-east-1.amazonaws.com/ [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1082)
Na minha execução, a AWS CLI v2 não confiou na CA pelo diretório do store do sistema operacional nem pela SSL_CERT_FILE, só pela REQUESTS_CA_BUNDLE, que o bootstrap por acaso define, ou pela AWS_CA_BUNDLE (ou pela configuração ca_bundle no config dela). O código do botocore explica por quê: ele sempre entrega à sua biblioteca HTTP um arquivo de CA explícito, o dele próprio, a menos que receba outra instrução, então nunca consulta o store do sistema operacional, e lê a REQUESTS_CA_BUNDLE como um fallback que a documentação de variáveis de ambiente da CLI não lista.
A regra prática: em qualquer imagem em que a AWS CLI ou o boto3 rode atrás do proxy, defina você mesmo AWS_CA_BUNDLE=/opt/opensandbox/merged-ca-certificates.pem, o bundle combinado que o bootstrap grava. O padrão funciona hoje por um fallback não documentado, e um entrypoint que redefina a REQUESTS_CA_BUNDLE o quebra. O broker da parte 5 define AWS_CA_BUNDLE para todo sandbox.
Teste 4: Credenciais reais para GitHub e Anthropic
O 04_vault_services.py é o único teste com credenciais reais. O sandbox pode alcançar api.github.com, github.com e api.anthropic.com, e nada mais. O ambiente dele recebe dois placeholders, e o vault recebe os valores reais, com um binding por serviço (do script):
sb.credential_vault.create(
credentials=[
credential("github-token", github_token),
credential("github-basic", basic_credential("x-access-token", github_token)),
credential("anthropic-key", anthropic_key),
],
bindings=[
binding("github-api", ["api.github.com"], {"type": "bearer", "credential": "github-token"}),
binding("github-git", ["github.com"], {"type": "basic", "credential": "github-basic"}),
binding("anthropic", ["api.anthropic.com"], {"type": "apiKey", "name": "x-api-key", "credential": "anthropic-key"}),
],
)
Uma credencial basic guarda o user:password já codificado (aqui x-access-token:<token>, que o GitHub aceita para git sobre HTTPS), e o binding o envia como Authorization: Basic <value>. Dentro do sandbox, todo comando usa o placeholder: curl -H "Authorization: Bearer $GITHUB_TOKEN", um git clone simples e x-api-key: $ANTHROPIC_API_KEY.
sandbox 439b1d78-43c5-4c17-950d-f319e5a67617; vault revision 1: ['anthropic-key', 'github-basic', 'github-token'] / ['anthropic', 'github-api', 'github-git']
(values are write-only: the sanitized state above has names and revisions, never a value)
== what the sandbox holds
ANTHROPIC_API_KEY=osb-placeholder-anthropic
GITHUB_TOKEN=osb-placeholder-github
PASS the sandbox env has only the placeholders
== bearer: GitHub API with the placeholder
authenticated as example-org
PASS api.github.com sees an authenticated user (bearer injected over the placeholder) (authenticated as example-org)
== basic: git clone and push to the test repo, throwaway branch osb-test-bd774df525
8373223 Initial commit
PASS git clone of the private repo authenticates (no credentials in the sandbox) (8373223 Initial commit)
PASS git push to the throwaway branch succeeds
git push --delete rc 0; git ls-remote rc 0, branch absent
PASS the throwaway branch is deleted from the remote and absent from ls-remote
== apiKey: Anthropic Messages API with the placeholder
ready
PASS api.anthropic.com returns a completion (ready)
== the real values are nowhere in the sandbox
PASS env, /proc/*/environ and git config hold no real token or key
Os três autenticaram. A API do GitHub devolveu o usuário do token, então o binding bearer substituiu o header Authorization que levava o placeholder (o Teste 5 mostra isso diretamente). O git clone e o git push de uma branch descartável funcionaram sem credential helper; o script apagou a branch, confirmou com git ls-remote que ela tinha sumido, e nunca toca na branch padrão. A API da Anthropic devolveu uma completion de uma palavra do claude-haiku-4-5. Nenhum dos valores reais estava no ambiente, em nenhum /proc/*/environ nem no git config. É a promessa do vault funcionando; o Teste 6 é sobre até onde ela se sustenta.
Teste 5: Todos os tipos de auth, e substituições
O 05_substitutions.py associa seis credenciais fictícias ao servidor echo em cinco bindings, um por tipo de auth (o customHeaders usa duas), separados por glob de path (/bearer/*, /basic/* e assim por diante), e lê o que chega:
O que o servidor echo recebeu
== auth types: the sandbox sends no credential
bearer Authorization = Bearer dummy-bearer-45970947
basic Authorization = Basic c3ZjOmR1bW15LWJhc2ljLWU2ZWI1NTk1
apiKey X-Api-Key = dummy-apikey-db8e4cc4
custom X-Tenant = dummy-tenant-45d1cfcd X-Trace = dummy-trace-fda9e071
== bearer replaces a header the sandbox sets itself
sandbox sent Authorization: Bearer sandbox-own-value
echo received Authorization: Bearer dummy-bearer-45970947
PASS the injected bearer replaced the sandbox's own Authorization header
== substitutions: the sandbox sends PLACEHOLDER_TOKEN
sandbox ran: curl -sS -m 15 -X POST -H 'Content-Type: application/json' -H 'X-Custom: PLACEHOLDER_TOKEN' -d '{"token":"PLACEHOLDER_TOKEN"}' 'http://echo.opensandbox.svc.cluster.local/sub/PLACEHOLDER_TOKEN/resource?key=PLACEHOLDER_TOKEN'
echo received path : /sub/dummy-sub-38c6ba26/resource?key=dummy-sub-38c6ba26
echo received header : X-Custom: dummy-sub-38c6ba26
echo received body : {"token":"dummy-sub-38c6ba26"}
PASS the placeholder itself did not arrive anywhere
== a request outside every binding gets nothing injected
/other/x: injected headers none
PASS no binding matches /other/*: nothing is injected
Cada tipo de header chegou, e o bearer injetado substituiu um header Authorization que o próprio sandbox tinha definido, que é o que faz os placeholders do Teste 4 funcionarem. O quinto binding é um passthrough (sem header) com uma substituição: o sandbox enviou o literal PLACEHOLDER_TOKEN no path, na query, em um header e em um body JSON, e o servidor echo recebeu a credencial nos quatro lugares. As substituições são opt-in, literais e case-sensitive, e ignoram bodies comprimidos e multipart. Um path que nenhum binding cobre não recebeu nada.
Note que o sandbox leu esses valores do body da resposta do servidor echo. O proxy oculta valores injetados só nos headers de resposta, então um upstream permitido que reflete uma requisição devolve a credencial, e é por isso que eu nunca associei um segredo real ao servidor echo.
Teste 6: Extraindo as credenciais
Host do outro recebeu a credencial do outro binding, nos dois sentidos. O proxy escolhe o binding pelo header Host, não pelo lugar para onde a conexão vai. A minha execução provou isso sobre HTTP puro; o código da 1.2.0 escolhe o binding do mesmo jeito para HTTPS e nunca verifica o server name do TLS, então o HTTPS deve se comportar igual até a correção sair. Um sandbox que pode alcançar qualquer host cuja resposta ele consegue ler pode puxar para essa conexão qualquer binding cujos scheme, método e path a requisição satisfaça. Essa é a #1758; a correção, o PR #1759, cobre só HTTPS e ainda estava aberta em 7 de novembro de 2026.
O 06_leaks.py monta um sandbox deny-default que pode alcançar os dois Services do echo e associa uma credencial fictícia a cada um: cred-a como header x-binding-a no echo (listener 8080), cred-b como x-binding-b no echo-alt (listener 8081). Depois, ele tenta cinco formas de extrair uma credencial. O script roda o spoof por último, como seção 5; aqui ele vem primeiro:
== 5. the Host-header spoof (#1758): which injected headers reach which listener
control, connect echo.opensandbox.svc.cluster.local: reached listener 8080 (echo), Host echo.opensandbox.svc.cluster.local, injected ['x-binding-a']
control, connect echo-alt.opensandbox.svc.cluster.local: reached listener 8081 (echo-alt), Host echo-alt.opensandbox.svc.cluster.local, injected ['x-binding-b']
PASS control: each host draws its own credential
spoof, connect to echo-alt, Host: echo: reached listener 8081 (echo-alt), Host echo.opensandbox.svc.cluster.local, injected ['x-binding-a']
the credential bound to echo.opensandbox.svc.cluster.local arrived on the connection to echo-alt.opensandbox.svc.cluster.local
spoof, connect to echo, Host: echo-alt: reached listener 8080 (echo), Host echo-alt.opensandbox.svc.cluster.local, injected ['x-binding-b']
the credential bound to echo-alt.opensandbox.svc.cluster.local arrived on the connection to echo.opensandbox.svc.cluster.local
HOST-SPOOF VERDICT (#1758, release 1.2.0): LEAK
Os controles mostram cada host recebendo só a própria credencial. Nos spoofs, curl http://echo-alt.../spoof -H 'Host: echo...' se conectou ao echo-alt, e o campo listener prova que a requisição chegou lá, mas o proxy casou o binding pelo header Host e adicionou x-binding-a; o inverso entregou x-binding-b ao listener 8080. Os valores que chegaram eram os segredos fictícios, que o sandbox nunca teve, então o veredito não pode vir de headers que ele mesmo definiu. E como o servidor echo reflete o que recebe, o sandbox leu cada credencial alheia direto da resposta.
A execução é sobre HTTP puro com bindings http, em que não existe server name do TLS. Para HTTPS, eu li o código da 1.2.0 em vez de rodá-lo: no caminho padrão, o proxy pega o host do header Host (:authority no HTTP/2) para todo scheme (_request_host, usado por _binding_matches), e nada nesse caminho lê o server name (SNI); só o live mode experimental, uma opção apenas para desenvolvimento que vem desligada por padrão, verifica isso. No modo transparente, o proxy encaminha para o endereço ao qual o sandbox se conectou, como o campo listener mostrou sobre HTTP. Então um sandbox com permissão para api.github.com e para qualquer host cujas respostas ele consiga ler (um site de paste, um coletor de webhooks, o próprio servidor dele) deve conseguir enviar Host: api.github.com para lá e receber o token do GitHub de volta. A parte 5, no Teste 6, rodou depois o caso HTTPS com bindings da AWS: em uma conexão cujo server name do TLS era o STS, um Host que nomeava o S3 recebeu os headers do vault, e um Host fora dos bindings não recebeu nenhum, o que confirma a seleção pelo Host. O PR #1759 adiciona a verificação que falta, o SNI precisa estar entre os hosts do binding, e, pela própria descrição, não afeta os bindings http. Então o caso HTTPS fica aberto até o #1759 sair, e o caso HTTP continua aberto depois dele.
As outras quatro tentativas falharam, como deveriam:
Tentativas 1 a 4, como gravadas
== 1. read it from inside
CARRIER_A=osb-placeholder-a
CARRIER_B=osb-placeholder-b
file search: 115 find_rc=0 (file count, then find/cat exit status)
searched 228,482 characters of environment, process and file contents
PASS env holds only placeholders
PASS neither dummy credential is in env, /proc/*/environ, /proc/*/cmdline or small files
== 2. the sidecar's API from inside the pod (shared network namespace)
GET 127.0.0.1:18080/credential-vault -> HTTP 401
GET 127.0.0.1:18080/credential-vault/_active -> HTTP 403
GET 127.0.0.1:18080/policy -> HTTP 401
== 3. instance metadata and the Pod Identity agent
IMDS 169.254.169.254 http=000 curl_rc=28
Pod Identity agent 169.254.170.23 http=000 curl_rc=28
== 4. direct-IP dials
1.1.1.1 (no rule) refused (curl rc 28)
echo ClusterIP before any DNS lookup refused (curl rc 28)
| Tentativa | Resultado |
|---|---|
Ambiente, /proc/*/environ, /proc/*/cmdline e os arquivos pequenos legíveis (abaixo de 64 KiB) em /etc, /root, /home, /tmp, /opt e /run no filesystem do próprio container: a busca não entrou em volumes montados, então o volume /opt/opensandbox compartilhado com o sidecar não foi vasculhado (115 arquivos; 228.482 caracteres no total) | Só placeholders; nenhum dos valores fictícios em lugar nenhum |
A API do sidecar em 127.0.0.1:18080, que o workload alcança porque o namespace é compartilhado | 401 para /credential-vault e /policy: a API exige o egress token, que o container de workload não tem. 403 para /credential-vault/_active, o path de onde o proxy busca os valores reais, que só o socket Unix privado do sidecar serve |
O serviço de metadados da instância EC2 (requisição de token IMDSv2) em 169.254.169.254 e o agente do EKS Pod Identity em 169.254.170.23 | Timeouts: nenhuma regra permite nenhum dos dois endereços. Eram conexões na porta 80 com o proxy ligado, então o timeout é consistente com o nftables descartando a conexão upstream do próprio proxy |
Uma conexão direta a 1.1.1.1, e ao ClusterIP do Service do echo antes de resolver o nome dele | Timeouts: um nome permitido só libera os seus endereços depois que o proxy DNS o resolve |
O resultado dos metadados merece uma nota. Nada no sidecar isenta endereços link-local: sob deny-default, o IMDS e o agente do Pod Identity ficam inalcançáveis porque nenhuma regra os permite, e uma regra de allow para 169.254.0.0/16 os abriria. O IMDS tem uma segunda barreira neste cluster: a parte 2 definiu o hop limit do IMDS dos nodes como 1, então os pods não conseguem um token IMDSv2 de jeito nenhum. O agente do Pod Identity não tem essa barreira, já que existe para responder aos pods; aqui, é a policy que o mantém fora de alcance.
Teste 7: Rotação e revogação
O 07_rotation.py associa uma credencial fictícia (X-Api-Key no servidor echo), depois a rotaciona e a apaga com o sandbox rodando:
revision = sb.credential_vault.get().revision
sb.credential_vault.patch(expected_revision=revision,
credentials={"replace": [credential("rotating", v2)]})
A execução da rotação
== 1. before rotation
request echo received X-Api-Key = dummy v1 (HTTP 200)
== 2. patch with the right expectedRevision
expectedRevision=1 -> accepted; vault revision is now 2
request, same sandbox, no restart echo received X-Api-Key = dummy v2 (HTTP 200)
== 3. patch with a stale expectedRevision
expectedRevision=1 (stale, current is 2) -> HTTP 409
request after the refused patch echo received X-Api-Key = dummy v2 (HTTP 200)
== 4. delete as revocation
vault deleted
next request: reached the echo server with no credential (HTTP 200)
PASS after delete no credential is injected (reached the echo server with no credential)
A rotação é limpa. Um patch com a revisão atual a levou de 1 para 2, e a requisição seguinte na mesma sessão levou o valor novo, sem restart. Um patch com um expectedRevision desatualizado recebeu HTTP 409 e não mudou nada. O status importa se você escreve o loop de retry: a docstring do SDK para vaults roteados pelo servidor menciona 412, e o sidecar usa 412 para “vault not ready” (pré-requisitos ausentes), então, nesta release, trate o 409 como o conflito e leia a revisão de novo.
A revogação é onde as minhas expectativas estavam erradas. Eu planejei “depois do delete, a requisição é recusada”, mas ela chegou ao servidor echo com HTTP 200 e sem X-Api-Key. Para o proxy, um vault ausente não é um erro, então apagar o vault remove o segredo, e só a network policy decide se o host continua alcançável. Se a revogação também precisa cortar o acesso, tire o host da policy também, e lembre do Teste 2: isso não fecha uma conexão que já está aberta.
Teste 8: Pausa e retomada apagam o vault
No Kubernetes, o vault vive só na memória do processo do sidecar. O 08_pause_wipe.py associa uma credencial fictícia, grava um arquivo marcador, pausa o sandbox (o root filesystem vai para o ECR e o pod é deletado, como na parte 3) e o retoma:
A execução de pausa e retomada
== 1. before pause
request echo received X-Api-Key = the dummy value
PASS the credential is injected
== 2. pause
state Paused after 7 s
== 3. resume
resumed in 8 s
marker file after resume: 'written before pause'
PASS the root filesystem came back (marker file)
credential_vault.get(): HTTP 404 (no vault)
PASS the vault is empty after resume
== 4. the same request after resume
request echo received X-Api-Key = no credential
PASS no credential is injected
== 5. the trusted caller re-creates the vault
request echo received X-Api-Key = the dummy value
PASS the credential is injected again
Os arquivos voltaram; o vault não. Depois da retomada, credential_vault.get() devolveu 404, e a mesma requisição saiu sem credencial, o que, como no Teste 7, significa que ela ainda saiu. Gravar o vault de novo restaurou a injeção. Essa é a #1366, aberta desde julho de 2026 e ainda aberta em 7 de novembro de 2026: no Kubernetes, a pausa deleta o pod, e o novo sidecar começa vazio. A 1.2.0 preserva o vault entre pausa e retomada só no profile Fast Sandbox.
Na prática, isso significa que o vault não é algo que você grava uma vez na criação. O que quer que retome os sandboxes precisa recriar o vault, então precisa dos valores reais, ou de acesso a onde quer que eles estejam, no momento da retomada. Um sandbox retomado por qualquer outra coisa roda sem credenciais, e as requisições dele ainda saem.
Teste 9: O que vai para o log
A última seção do 08_pause_wipe.py procura a trilha de auditoria. O proxy registra uma linha por injeção, com o nome do binding, nunca o valor. Eu demorei um pouco para vê-las:
== 6. audit trail: the sidecar log
after the re-created vault's single request: 0 'applied binding=' line(s) in the resumed pod's sidecar log
after 90 more requests: 83 'applied binding=' line(s), 180 egress.outbound event(s)
{"level":"warn","ts":"2026-11-01T12:42:02.771Z","logger":"opensandbox.egress","msg":"[mitmproxy] credential proxy: applied binding=echo-key revision=1 host=echo.opensandbox.svc.cluster.local method=GE
PASS the sidecar log carries 'credential proxy: applied binding=' lines (names, no values) once enough output has accumulated
(O script corta a linha em 200 caracteres. A linha completa continua com o método, os nomes dos headers e as superfícies de substituição.)
Depois de uma requisição, o log do sidecar não tinha nenhuma linha applied binding=. Depois de mais 90, tinha 83 das 91, no nível warn e com o prefixo [mitmproxy]. Em um sandbox de teste anterior, fora da gravação, eu contei 0 linhas depois de 1 requisição, 43 depois de 61, 109 depois de 121, 174 depois de 181 e 239 depois de 241. Pela minha leitura do código-fonte do processo de egress (sem instrumentação): o lado Go repassa só as linhas do mitmdump que começam com credential proxy:, no nível warn, e descarta o resto. Os lotes são inferência minha: o mitmdump escreve em um pipe, então o Python faz buffer da saída. De qualquer forma, uma única requisição pode não deixar rastro por muito tempo, e se a leitura do buffering estiver certa, linhas ainda no buffer quando um pod é deletado nunca chegam; eu não testei isso.
O outro stream de log são os eventos estruturados do lado Go: 180 eventos egress.outbound nas mesmas requisições, que registram hosts e endereços resolvidos, não credenciais. E não há métricas de auditoria. A OSEP-0012, o design do Credential Vault, sugere campos de auditoria e métricas opensandbox_credential_proxy_*; nenhum dos dois existe no código da 1.2.0. O egress exporta, sim, métricas OpenTelemetry para DNS, negações de policy e atualizações do nftables quando você fornece um endpoint OTLP, mas nada por credencial.
Resumo dos resultados
| Teste | Script | Execução gravada | Resultado |
|---|---|---|---|
| 1. Sem policy vs deny-by-default | 01_sidecar.py | 21,0 s | Sidecar só com uma networkPolicy |
| 2. Regras e #2329 | 02_rules.py | 86,1 s (um stream de 40 s) | Todo tipo de regra se manteve; um stream aberto sobreviveu à sua regra |
| 3. A CA do proxy | 03_ca_trust.py | 29,3 s | AWS CLI v2 só via REQUESTS_CA_BUNDLE ou AWS_CA_BUNDLE |
| 4. Serviços reais | 04_vault_services.py | 20,2 s | GitHub, git e Anthropic autenticaram com placeholders |
| 5. Tipos de auth e substituições | 05_substitutions.py | 19,1 s | Os cinco tipos de auth e as quatro superfícies de substituição funcionaram |
| 6. Extraindo as credenciais | 06_leaks.py | 43,5 s | Quatro tentativas falharam; o spoof do header Host vazou nos dois sentidos |
| 7. Rotação e revogação | 07_rotation.py | 14,8 s | Revisão desatualizada: 409; o delete faz as requisições saírem sem credencial |
| 8. Pausa e retomada | 08_pause_wipe.py | 52,7 s, com o Teste 9 | Pausado em 7 s, retomado em 8 s; o vault sumiu (404) |
| 9. O que vai para o log | 08_pause_wipe.py | mesma execução do Teste 8 | Só nomes, em lotes (0 depois de 1 requisição, 83 depois de 91) |
Os oito scripts saíram com 0 e todas as verificações passaram, em 4 minutos e 47 segundos no total. O spoof não é uma verificação de pass/fail: o 06_leaks.py registra o veredito dele como um achado e sai com 0 de qualquer jeito, então o LEAK fica ao lado de controles que passaram e de quatro tentativas que falharam. Nas minhas execuções anteriores naquele dia, a pausa levou de 7 a 11 segundos e a retomada, de 6 a 8.
O que o vault não resolve
O vault cumpre o que promete quanto ao que o sandbox guarda: os valores reais nunca apareceram no ambiente do sandbox, nos ambientes dos seus processos nem no seu git config (Teste 4), os valores fictícios não estavam em nenhum arquivo que eu vasculhei (Teste 6), e a API do sidecar recusou o sandbox. O que ele não faz é igualmente específico.
- Ele escolhe a credencial a partir de um header que o sandbox escreve (#1758). O Teste 6 tem a evidência e o escopo. Até o PR #1759 sair para HTTPS, e para bindings
httpmesmo depois disso, a allowlist é a fronteira real: um sandbox só deve alcançar hosts que não consigam refletir uma requisição de volta para ele, e só hosts cujas credenciais ele possa usar em conjunto. Isso descarta uma allowlist genérica da web ao lado de um binding valioso. O diff do PR também mira um layout antigo do script do proxy, então ele precisa de um rebase antes de poder ter merge. - Os bindings valem para o host inteiro, a menos que você restrinja o escopo (#1776). Um binding sem métodos ou paths é normalizado para todos os métodos comuns e
/*, e a configuração que exige escopos explícitos,OPENSANDBOX_EGRESS_CREDENTIAL_VAULT_REQUIRE_SCOPED_MATCH, vem desligada por padrão. Ela é uma das configurações de egress que uma requisição de criação pode definir. Os meus bindings do Teste 4 também valiam para o host inteiro: o token do GitHub teria sido adicionado a uma requisição para qualquer path emapi.github.com, com qualquer um dos cinco métodos padrão (GET, POST, PUT, PATCH e DELETE). Eu não testei o modo com escopo. - Uma pausa esquece tudo (#1366). Teste 8. O seu control plane é responsável por recriar o vault depois de toda retomada, e um sandbox que ele deixar passar continua enviando as suas requisições, sem credenciais.
- A trilha de auditoria é rasa. Linhas de log com nomes de bindings, repassadas em lotes, e nenhuma métrica (Teste 9). Se você precisa responder “qual sandbox usou qual credencial, quando”, vai ter que reconstruir isso a partir de logs de container que podem atrasar ou perder o final.
- Os bodies de resposta não são ocultados. Só os headers de resposta são. Uma API que ecoa a requisição, ou uma página de erro que cita o header
Authorization, coloca a credencial na frente do sandbox. O Teste 5 mostra isso com o servidor echo. - O segredo real vive no mesmo pod que o código em que você não confia. O sidecar guarda todos os valores em memória, no mesmo network namespace e no mesmo kernel que o workload. Nos meus testes, a fronteira foi o token da API do sidecar e a capability
NET_ADMINque o workload não tem, e as duas se mantiveram. Mas qualquer coisa que escape do container do sandbox (um bug de kernel, um container escape sob runc) cai ao lado dos segredos. O Kata representa um pod como uma VM, com o sidecar incluído, então ele protege o node, não o sidecar. - O proxy tem alertas de dependências conhecidos e em aberto. As release notes da 1.2.0 listam cinco alertas abertos do Dependabot na library
h2da imagem de egress, dois deles CVEs de request smuggling que dependem de uma migração para o mitmproxy 12. Em 7 de novembro de 2026, eu não encontrei nenhuma issue acompanhando essa migração.
Nada disso torna o vault inútil; torna-o uma camada. Um placeholder no sandbox ainda é melhor do que um token real no ambiente dele, onde qualquer env ou cat /proc/self/environ o imprimiria.
Limpeza
Cada script deleta os próprios sandboxes. Depois de uma execução interrompida, delete o que sobrou e, em seguida, o servidor echo:
uv run python 98_cleanup.py # sandboxes with example=opensandbox-egress only
./00_echo.sh delete # the echo Deployment, both Services and the ConfigMap
O 04_vault_services.py deleta a sua branch descartável no repositório de teste no fluxo normal e de novo em todo caminho de falha, e imprime uma mensagem bem visível se não conseguir; confira as branches do repositório se você chegar a vê-la. A imagem egress-tools:1 fica no ECR com as outras imagens do cluster. Entre sessões, escale os nodes para zero a partir do diretório da parte 2, e remova tudo com o teardown dela:
../opensandbox-eks/08_scale.sh down
../opensandbox-eks/99_teardown.sh
Veredito
As regras do sidecar de egress se mantiveram em todos os testes. O deny-by-default é um campo na requisição de criação, as regras podem receber patch em runtime, a infraestrutura da CA faz curl, Python e Node funcionarem atrás do proxy sem mudanças, e o vault fez o que importa: um sandbox fez push para um repositório privado e chamou uma API de modelo enquanto o ambiente dele só tinha placeholders. Tudo o que eu tentei de dentro para ler uma credencial armazenada diretamente (o ambiente, /proc, arquivos, a API do sidecar, os serviços de metadados) falhou.
O ponto fraco é a seleção do binding. Na 1.2.0, um sandbox que alcança um host cujas respostas ele lê pode puxar para essa conexão qualquer binding cujos scheme, método e path a requisição satisfaça. A execução mostrou isso sobre HTTP, e o código diz que o HTTPS se comporta igual; a correção para HTTPS é um pull request desde 8 de setembro, sem nenhum review de aprovação até 7 de novembro de 2026. O resto eu colocaria no planejamento, em vez de me preocupar: um vault que uma pausa apaga, uma revogação que deixa o host alcançável, conexões que sobrevivem a uma policy mais restrita e uma trilha de auditoria em lotes.
Com o que você está se comprometendo
| Aspecto | O sidecar de egress e o Credential Vault na 1.2.0, como testados |
|---|---|
| Cobertura | Só sandboxes criados com uma networkPolicy; sem ela não há sidecar nem filtragem |
| Enforcement | Nomes no proxy DNS, pacotes no nftables (dns+nft); conexões abertas sobrevivem a uma policy mais restrita (#2329) |
| Clientes | curl, Python requests e Node confiam na CA do proxy de fábrica; a AWS CLI v2, por um fallback não documentado, então defina AWS_CA_BUNDLE |
| Onde vivem os segredos | Na memória do sidecar, no mesmo pod e network namespace que o workload; o sandbox guarda placeholders |
| Qual credencial é usada | Escolhida pelo header Host, sobre HTTP (testado) e HTTPS (pelo código; rodado na parte 5 com bindings da AWS) (#1758; a correção para HTTPS, o PR #1759, aberta em 7 de novembro de 2026), válida para o host inteiro, a menos que tenha escopo (#1776) |
| Rotação e revogação | patch com expectedRevision (409 em caso de conflito), efetivo na requisição seguinte; o delete para a credencial, não o tráfego |
| Pausa e retomada | O vault é apagado; o seu control plane o grava de novo (#1366) |
| Auditoria | Linhas de log só com nomes, repassadas em lotes; sem métricas de credenciais |
Quem deve usar
O vault serve para um time que já controla o que os seus sandboxes podem alcançar e quer as credenciais fora do ambiente do sandbox: um agente de código com acesso a um host Git e a uma API de modelo, digamos, com uma policy deny-by-default que lista só esses hosts. Mantenha a allowlist curta, mantenha fora dela os hosts que refletem requisições, restrinja os bindings aos paths que você usa, defina AWS_CA_BUNDLE nas suas imagens e faça com que o que quer que retome os sandboxes recrie os vaults deles. Nesses termos, é uma melhoria real em relação a entregar o token ao agente.
Ele ainda não serve para um sandbox que precisa de acesso amplo à web e de credenciais valiosas ao mesmo tempo, nem para uma estratégia de compliance que dependa de uma trilha de auditoria por credencial. A parte 5 leva o mesmo vault para a AWS, onde uma credencial não pode simplesmente ser adicionada como header, e assina as requisições no egress em vez disso.