segunda-feira, 16 de novembro de 2026 Edição nº 240
Buscar
Avaliação · Infraestrutura · 62 min de leitura

OpenSandbox e Credenciais AWS: Assinatura SigV4 no Egress

Por Fabio Douek

Ir para seção
Explica (TLDR) como se eu fosse...
O que é isso?

Imagine um robô ajudante que precisa de um cartão da biblioteca, mas você nunca quer que ele segure o cartão de verdade. Então ele carrega um cartão de mentirinha, e um guarda na porta troca pelo cartão de verdade no caminho até o balcão da biblioteca, e depois o pega de volta.

O guarda é rigoroso: se o robô pede um segundo cartão, ou diz que vai à biblioteca enquanto caminha para a loja de brinquedos, a resposta é não. O cartão de verdade continua com o guarda, bem ao lado do robô, então os adultos dão a ele um cartão que só serve para uma tarefa pequena e o trocam por um novo a cada meia hora.

Este post testa uma forma de permitir que o código de um agente de IA chame a AWS sem deter chaves da AWS: o OpenSandbox 1.2.0, projeto Apache 2.0 da Agentic AI Foundation, no Amazon EKS. Um broker assume uma sessão de role do IAM por sandbox, e um proxy ao lado do sandbox assina cada requisição com essas credenciais temporárias.

A atribuição é limpa: o CloudTrail registrou as chamadas do sandbox ao STS e ao Bedrock sob o ID dele. A exposição residual, porém, é relevante. Dentro das permissões da role, o sandbox atua como o principal enquanto estiver rodando, as credenciais ficam no mesmo pod que o código não confiável, e o proxy de assinatura é código customizado que pertence ao operador.

A queixa principal é um agente que precisa chamar a AWS, mas nunca deveria guardar uma chave AWS. A intervenção: um broker emite credenciais de role de uma hora por sandbox, e um proxy no pod do sandbox assina cada requisição com elas enquanto o sandbox guarda placeholders. Eu testei isso no Amazon EKS com S3, DynamoDB, Bedrock e STS.

Toda chamada dentro dos limites funcionou, e toda tentativa de emitir novas credenciais, fazer spoof de um host no binding da AWS ou encontrar uma chave falhou. Contraindicações: corpos de requisição acima de cerca de 1 MiB fora do S3 são cortados, e as chaves reais dividem o pod (no Kata, a máquina virtual) com o código.

Há alívio em dar a um agente acesso à AWS sem o medo silencioso de uma chave parada no ambiente dele. Nas minhas execuções, o sandbox nunca guardou nada além de placeholders, e toda chamada à AWS ainda rodou sob um nome que dá para rastrear: o próprio ID do sandbox, que o CloudTrail mostrou nas chamadas que ele registra.

A conversa mais difícil é sobre o que esse acesso ainda significa. Enquanto estiver rodando, o sandbox pode fazer tudo o que a role permite, as chaves ficam a um container de distância, e o proxy de assinatura é código que agora pertence ao seu time, e no qual o time precisa confiar. O conforto vem de uma role restrita, não do proxy.

Pense no proxy de egress como o tour manager da banda. O músico no palco trabalha com um nome substituto, e o manager assina cada reserva de show na saída com a assinatura real da banda, então S3, DynamoDB e Bedrock aceitam a chamada.

O manager recusa três coisas: contratar um segundo manager, mandar um contrato para uma casa de shows diferente da que está no envelope, e assinar um contrato longo demais para ler antes, acima de cerca de um megabyte fora do S3. O problema é que a assinatura real viaja na mesma van que o músico.

A história é acesso à AWS sem nenhuma chave AWS no sandbox. Um broker no Amazon EKS dá a cada sandbox do OpenSandbox a própria sessão de role do IAM de uma hora, e o proxy de egress assina as requisições com ela, então a AWS CLI e o boto3 funcionam sem mudanças com chaves placeholder. O CloudTrail nomeia o sandbox por trás das chamadas que registra.

O posicionamento honesto tem limites sobre os quais os compradores vão perguntar. O proxy de assinatura é código de apoio, não uma feature do OpenSandbox, corpos fora do S3 acima de cerca de 1 MiB são cortados, e o sandbox pode fazer tudo o que a role permite enquanto roda.

GitHub Veja o código-fonte aqui: opensandbox-aws-credentials

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 trata dessa mudança.

Este post, parte 5 de 6, dá aos sandboxes no cluster EKS da parte 2 acesso à AWS sem colocar uma chave AWS neles. A parte 4 mostrou o Credential Vault adicionando uma credencial como header, mas a maioria das APIs da AWS precisa de uma assinatura SigV4 calculada a partir da chave secreta, do horário e da própria requisição, algo que nenhum header adicionado consegue fornecer. Então o fluxo tem três peças: um broker que assume uma sessão de role do IAM por sandbox e grava as credenciais temporárias no vault, que as adiciona às requisições para a AWS como três headers, e um pequeno addon no sidecar de egress que remove esses headers e assina a requisição de novo. O sandbox roda a AWS CLI e o boto3 sem modificações, com chaves placeholder.

O broker e o addon são meu código de apoio, não features do OpenSandbox; a 1.2.0 fornece o vault, o proxy de egress e o ponto de extensão, um script extra do mitmproxy embutido em uma imagem de egress derivada. O que eu encontrei:

  • Os clientes padrão funcionaram sem mudanças. STS, S3 (até um upload multipart de 20 MiB), DynamoDB e Bedrock responderam à AWS CLI, e STS, S3 e Bedrock ao boto3, em um sandbox que só guardava placeholders. O CloudTrail registrou as chamadas ao STS e ao Bedrock sob o ID do sandbox, e o mesmo fluxo rodou no Kata.
  • O Bedrock nem precisou do addon. Uma API key de curto prazo do Bedrock é um bearer token, e o vault trocou o header Authorization placeholder por ela.
  • Os limites são específicos. Corpos de requisição acima de cerca de 1 MiB para serviços que não sejam o S3 são cortados. E, enquanto estiver rodando, o sandbox pode fazer tudo o que a role permite, a partir de um pod que guarda as credenciais reais; um conjunto de credenciais tirado desse pod continua válido por até uma hora.

A parte 3 trata do ciclo de vida do sandbox, dos pools e da troca para o Kata, e a parte 6 faz um stress test nos mesmos dois nodes, com o addon incluído. Tudo aqui roda em runc, exceto o Teste 8, com o egress do servidor no modo dns+nft. Todos os números vêm das minhas execuções de 1º de novembro de 2026 (UTC); quando algo vem do código ou da documentação da AWS, eu aviso.

Arquitetura

Uma assinatura SigV4 é um HMAC sobre o método, o path, a query, um conjunto de headers, o hash do corpo e um timestamp, com a chave derivada da secret access key (documentação da AWS). O session token pode viajar como header; a assinatura precisa ser calculada onde o secret está. Em um pod de sandbox, o único lugar que vê toda requisição e pode guardar um secret é o sidecar de egress.

broker de credenciais namespace opensandbox-broker EKS Pod Identity: role osb-broker API em 127.0.0.1, via port-forward rotaciona cada sandbox a cada 30 min AWS · US-EAST-1 STS AssumeRole na osb-sandbox GetCallerIdentity S3 DynamoDB Bedrock Runtime CloudTrail registra o ID do sandbox como nome da sessão POD DO SANDBOX · SEM POD IDENTITY · SEM CHAVE AWS container do sandbox AWS CLI v2 e boto3 AWS_ACCESS_KEY_ID= AKIA_OSB_PLACEHOLDER AWS_SECRET_ACCESS_KEY= osb-placeholder-secret AWS_CA_BUNDLE: CA do proxy consultas ao IMDS desligadas sem session token sem ID da conta SIDECAR DE EGRESS · IMAGEM DERIVADA CREDENTIAL VAULT binding aws-sigv4 três valores do STS customHeaders nos hosts AWS OPENSANDBOX 1.2.0 system.py casa o binding pelo Host adiciona três headers x-osb-aws-* ADDON DE EGRESS sigv4_resign.py remove os três headers exige Host igual ao SNI do TLS fixa o upstream nele recusa credential vending assina de novo com SigV4 S3: o hash declarado do corpo outros: hash do corpo, até 1 MiB na dúvida, bloqueia proxy DNS e nftables deny por padrão; oito hostnames AWS permitidos 1 AssumeRole: sessão = ID do sandbox, 1 h, session policy 2 grava o vault, faz patch a cada 30 min 3 4 5 6 recusada ou encerrada 7 lado confiável assinada com a chave placeholder assinada com as credenciais reais recusada ou encerrada
O fluxo que todos os testes abaixo executam. O broker (azul) é o único componente deste fluxo com credenciais AWS próprias: uma sessão do EKS Pod Identity para a role osb-broker. Ele assume a role osb-sandbox uma vez por sandbox e grava o resultado no vault do sandbox. O sandbox assina com uma chave placeholder (cinza); o system.py do OpenSandbox adiciona os três valores temporários como headers, e o addon os remove e assina a requisição de novo com os valores reais (verde). Uma requisição que o addon não consegue assinar com segurança é recusada com 403 ou 501, ou tem a conexão fechada (vermelho). O colchete verde representa todos os serviços da AWS que o sandbox chama, incluindo o STS.
  1. O broker cria o sandbox e assume a osb-sandbox para ele: chaves placeholder, uma policy que nega por padrão e permite oito hostnames da AWS, o credential proxy e uma sessão do STS de uma hora com o nome do sandbox, restringida por uma session policy (Passo 2).
  2. Ele grava o vault pelo proxy do servidor de lifecycle: os três valores temporários e um binding customHeaders, o aws-sigv4, para esses hosts. A cada 30 minutos, ele substitui os valores com patch.
  3. A AWS CLI ou o boto3 assina uma requisição com a chave placeholder, e o proxy transparente do sidecar a intercepta.
  4. O system.py do OpenSandbox casa o binding pelo header Host da requisição e adiciona os três headers x-osb-aws-*. Até aqui, este é o vault da parte 4, sem mudanças.
  5. Depois, o mitmproxy roda o addon, que remove os três headers, verifica a requisição e ou a assina de novo, ou a recusa.
  6. A requisição assinada sai para o host indicado no server name do TLS, passando pelo nftables como qualquer outro pacote.
  7. A AWS vê a sessão da role, e o CloudTrail registra o ID do sandbox como o nome da sessão.
CredencialQuem guardaTempo de vida
A do próprio broker, role osb-brokero pod do broker, vinda do agente do EKS Pod Identitygerenciado pelo EKS Pod Identity
As credenciais temporárias de um sandbox, role osb-sandboxo broker, só enquanto grava o vault; depois disso, só o vault do sandbox, na memória do sidecar de egressuma hora, substituídas a cada 30 minutos
Uma chave de curto prazo do Bedrock (só no Teste 1)os mesmos dois lugaresnão mais que a sessão a partir da qual foi gerada
Os placeholders (AKIA_OSB_PLACEHOLDER, osb-placeholder-secret; AWS_BEARER_TOKEN_BEDROCK no Teste 1)o ambiente do sandboxnunca válidos
⚠️ Um proxy de assinatura transforma o sandbox no principal do IAM. O addon assina o que o sandbox envia, então o sandbox pode fazer tudo o que a role permite, incluindo qualquer chamada cuja resposta traga credenciais: sts:AssumeRole, ecr:GetAuthorizationToken, s3express:CreateSession e similares. É por isso que a role e toda session policy carregam um Deny explícito nessas ações, o addon as recusa antes de assinar, e a role permite pouca coisa além disso (Passos 2 e 4, Teste 6).

Configuração

Passo 1: O código de apoio

Os scripts rodam no cluster da parte 2 e usam dois diretórios vizinhos: ../opensandbox-eks para o servidor, o env.sh e o registry do ECR, e ../opensandbox-lifecycle, da parte 3, para o helper de port-forward e o server_config.py, o único script que muda a configuração do servidor. Rode antes os scripts 01_cluster.sh a 04_install.sh da parte 2 e o 00_image.sh da parte 4. Você também precisa do Terraform 1.9 ou mais recente e do uv, de um bucket S3 já existente em us-east-1, indicado por AWS_TEST_BUCKET em um arquivo de secrets fora do repositório (a variável OSB_SECRETS_ENV aponta para ele), e de acesso, no Bedrock, ao inference profile us.anthropic.claude-haiku-4-5-20251001-v1:0.

git clone https://github.com/fabiodouek/my2centsai-blog-samples.git
cd my2centsai-blog-samples/opensandbox-aws-credentials
uv sync
ArquivoO que faz
01_iam.sh, terraform/As duas roles do IAM, a associação do Pod Identity e uma tabela de teste no DynamoDB (Passo 2)
broker/, 02_broker.sh, manifests/broker.yamlO broker (Passo 3)
egress/, build_egress.shO addon SigV4, os testes dele e a imagem de egress derivada (Passo 4)
00_image.sh, image/DockerfileA imagem de workload com a AWS CLI e o boto3 (Passo 5)
01_bedrock_bearer.py a 08_kata.pyUm script por teste
common.pyHelpers compartilhados e o scrubber da saída

Os testes rodam como uv run python 02_identity.py e assim por diante. Cada um pede ao broker os próprios sandboxes, que carregam o label example=opensandbox-aws-credentials, os deleta no final (também em caso de falha) e sai com 1 se uma verificação falhar. Os scripts leem o arquivo de secrets com um parser, nunca fazem source dele, imprimem o bucket como example-bucket e a conta como 123456789012, e mostram um erro da AWS só pelo código de erro.

Passo 2: Duas roles do IAM

O 01_iam.sh roda o Terraform com um state próprio, separado do da parte 2:

  • A osb-broker confia no EKS Pod Identity para uma única service account, a osb-broker no namespace opensandbox-broker. Ela pode assumir a osb-sandbox, além de uma ação read-only do IAM para a verificação do Passo 3.
  • A osb-sandbox confia apenas na osb-broker; nenhum pod tem uma associação do Pod Identity para ela. Ela permite o bucket de teste (list, get, put, delete e abortar um upload multipart), as ações de item da tabela de teste, query e scan, um inference profile do Bedrock e o modelo dele, e chaves de curto prazo do Bedrock. Depois, ela nega explicitamente todas as ações desta lista:
[
  "sts:Assume*", "sts:GetDelegatedAccessToken", "sts:GetFederationToken",
  "sts:GetServiceBearerToken", "sts:GetSessionToken", "sts:GetWebIdentityToken",
  "sts:SetContext", "sts:SetSourceIdentity", "sts:TagSession",
  "s3express:CreateSession",
  "ecr:GetAuthorizationToken", "ecr-public:GetAuthorizationToken",
  "codeartifact:GetAuthorizationToken",
  "redshift:GetClusterCredentials", "redshift:GetClusterCredentialsWithIAM",
  "redshift-serverless:GetCredentials",
  "secretsmanager:GetSecretValue",
  "iam:*"
]

Esse é o broker/vending_actions.json, com as quebras de linha refeitas. Os statements de Allow estão no sandbox_permissions.json, e tanto a policy da role (Terraform) quanto toda session policy (o broker) são montadas a partir dos dois arquivos, então elas não têm como divergir. Um Deny explícito vence qualquer Allow, inclusive um adicionado à role depois.

A trust policy tem uma linha que não é óbvia:

data "aws_iam_policy_document" "sandbox_trust" {
  statement {
    actions = ["sts:AssumeRole", "sts:TagSession"]
    principals {
      type        = "AWS"
      identifiers = [aws_iam_role.broker.arn]
    }
  }
}

resource "aws_iam_role" "sandbox" {
  name                 = "osb-sandbox"
  assume_role_policy   = data.aws_iam_policy_document.sandbox_trust.json
  max_session_duration = 7200   # two hours on purpose: see Test 7
}

O EKS Pod Identity adiciona à sessão do broker tags com o cluster, o namespace, a service account e o pod, e essas tags são transitivas: elas viajam junto com o AssumeRole do broker, então a trust policy precisa permitir sts:TagSession. Em uma verificação separada, fora das gravações, remover essa ação da trust policy fez o AssumeRole do broker falhar em até 10 segundos com AccessDenied em sts:TagSession. A role permite duas horas de propósito; o Teste 7 mostra por quê.

01_iam.sh: o Terraform e as verificações dele
$ ./01_iam.sh

== terraform apply
cluster osb-eks, Region us-east-1 (full output: logs/terraform-apply.log)
Plan: 6 to add, 0 to change, 0 to destroy.
aws_iam_role.broker: Creation complete after 1s
aws_eks_pod_identity_association.broker: Creation complete after 0s
aws_iam_role.sandbox: Creation complete after 9s
aws_iam_role_policy.sandbox: Creation complete after 1s
aws_iam_role_policy.broker: Creation complete after 1s
aws_dynamodb_table.test: Creation complete after 17s
Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
   took 24s

== checks
  ok    IAM role osb-broker exists
  ok    IAM role osb-sandbox exists
  ok    Pod Identity association for opensandbox-broker/osb-broker
  ok    no Pod Identity association in namespace opensandbox (the sandboxes')
  ok    DynamoDB table osb-cred-test is ACTIVE
   took 5s

Seis recursos em 24 segundos, 17 deles gastos na tabela do DynamoDB, e nenhuma associação do Pod Identity no namespace dos sandboxes. No console, por um login read-only com a conta mascarada:

A página da role osb-sandbox no console do IAM: descrição "OpenSandbox part 5: assumed by osb-broker once per sandbox", criada em 1º de novembro de 2026, às 06:21 UTC, ARN arn:aws:iam::123456789012:role/osb-sandbox, duração máxima de sessão de 2 horas e uma policy do tipo Customer inline, osb-sandbox-test-access. A conta aparece como my-account (123456789012).

Passo 3: O broker, no EKS Pod Identity

O EKS Pod Identity funciona por service account e, portanto, por pod: uma associação na service account dos sandboxes entregaria o endpoint de credenciais do Pod Identity ao container não confiável (como o Pod Identity funciona). Então os sandboxes não recebem nenhuma, e um broker separado recebe: um Deployment de uma réplica em um namespace próprio, com automountServiceAccountToken: false e um label restricted de Pod Security. A API dele escuta em 127.0.0.1 dentro do próprio pod, então só um kubectl port-forward chega até ela; os scripts de teste abrem um por conta própria.

Quando um teste pede um sandbox, o broker faz três coisas. Simplificado a partir do broker/broker.py:

AWS_HOSTS = [
    "sts.amazonaws.com", "sts.us-east-1.amazonaws.com",
    "s3.us-east-1.amazonaws.com", "*.s3.us-east-1.amazonaws.com",
    "s3.amazonaws.com", "*.s3.amazonaws.com",
    "dynamodb.us-east-1.amazonaws.com", "bedrock-runtime.us-east-1.amazonaws.com",
]

sb = SandboxSync.create(
    image=image,
    env={
        "AWS_ACCESS_KEY_ID": "AKIA_OSB_PLACEHOLDER",
        "AWS_SECRET_ACCESS_KEY": "osb-placeholder-secret",
        "AWS_REGION": "us-east-1", "AWS_DEFAULT_REGION": "us-east-1",
        "AWS_CA_BUNDLE": "/opt/opensandbox/merged-ca-certificates.pem",
        "AWS_EC2_METADATA_DISABLED": "true",
    },
    network_policy=NetworkPolicy(
        default_action="deny",
        egress=[NetworkRule(action="allow", target=host) for host in AWS_HOSTS],
    ),
    credential_proxy=CredentialProxyConfig(enabled=True),
    connection_config=connection(),        # the server's in-cluster Service, through its proxy
)
creds = sts.assume_role(
    RoleArn=SANDBOX_ROLE_ARN,
    RoleSessionName=sb.id,                 # what CloudTrail shows for every call
    Policy=session_policy(),               # the role's Allow statements and the Deny again
    DurationSeconds=3600,
)["Credentials"]
sb.credential_vault.create(
    credentials=[
        {"name": "aws-akid", "source": {"type": "inline", "value": creds["AccessKeyId"]}},
        {"name": "aws-secret", "source": {"type": "inline", "value": creds["SecretAccessKey"]}},
        {"name": "aws-token", "source": {"type": "inline", "value": creds["SessionToken"]}},
    ],
    bindings=[{
        "name": "aws-sigv4",
        "match": {"schemes": ["https"], "hosts": AWS_HOSTS,
                  "methods": ["GET", "HEAD", "POST", "PUT", "DELETE"], "paths": ["/*"]},
        "auth": {"type": "customHeaders", "headers": [
            {"name": "x-osb-aws-access-key-id", "credential": "aws-akid"},
            {"name": "x-osb-aws-secret-access-key", "credential": "aws-secret"},
            {"name": "x-osb-aws-session-token", "credential": "aws-token"},
        ]},
    }],
)

Os SDKs assinam com qualquer chave que recebem, então o placeholder só precisa existir; os underscores dele evitam que ele case com o padrão AKIA[0-9A-Z]{16} que os secret scanners procuram. Não há AWS_SESSION_TOKEN nem AWS_ACCOUNT_ID, que mudaria o DynamoDB para um endpoint baseado na conta, fora da allowlist. O AWS_CA_BUNDLE é a lição do Teste 3 da parte 4: a AWS CLI só confiou na CA do proxy por meio dessa variável ou da REQUESTS_CA_BUNDLE, que não é documentada.

A cada 1.800 segundos, metade da sessão, o broker assume a role de novo e substitui os três valores em um único patch que leva a revisão do vault como expectedRevision. Se o vault responde 404, como depois de um restart do sidecar ou de uma pausa, ele grava o vault de novo.

O 02_broker.sh faz o build e o push da imagem do broker, faz o deploy dela (um rollout de 44 segundos) e verifica, de dentro do pod do broker, que o Pod Identity deu credenciais a ele e que o Deny da role do sandbox é real. Deixei de fora as linhas de whoami da gravação, que são anteriores ao máximo de duas horas da role; o Teste 7 mostra o resultado atual.

== checks
  ok    EKS Pod Identity injected its credentials endpoint into the broker pod

  $ python broker.py deny-check
    session osb-deny-check of osb-sandbox, with the session policy (key ASIA…, expires 2026-11-01T07:46:43Z)
                                      sts:AssumeRole: AccessDenied on sts:TagSession with no reason; asking AWS why (authorization id <id>, about a minute)
      sts:AssumeRole                  ok    AccessDenied on sts:TagSession: explicit deny in the role policy and the session policy (AWS's authorization details)
      ecr:GetAuthorizationToken       ok    AccessDenied: explicit deny in identity-based policy
      secretsmanager:GetSecretValue   ok    AccessDenied: explicit deny in identity-based policy
      iam:ListRoles                   ok    AccessDenied: explicit deny in identity-based policy
    all 4 refused, each shown to be by the explicit Deny
  ok    deny-check: AWS refused every credential-vending call (its last line says how many it showed the Deny refused)

O deny-check assume a osb-sandbox com a session policy, como para um sandbox, e chama quatro ações que o Deny cobre. Três recusas citaram o deny explícito. O AssumeRole foi recusado em sts:TagSession (as tags do Pod Identity vão junto, e o Deny lista essa ação também) só com um authorization ID, então o broker pediu ao IAM que explicasse a recusa (GetRequestAuthorizationDetails, uma API em preview): um deny explícito tanto na policy da role quanto na session policy. Este é o único lugar em que a segunda camada aparece, porque, dentro de um sandbox, o addon recusa essas chamadas antes que a AWS as veja (Teste 6).

Passo 4: A imagem de egress derivada, com o addon SigV4

O processo de egress do OpenSandbox carrega primeiro o próprio system.py no mitmproxy e depois os scripts indicados em OPENSANDBOX_EGRESS_MITMPROXY_SCRIPT (launch.go). Uma requisição de criação não consegue definir essa variável: o servidor só repassa uma allowlist de variáveis OPENSANDBOX_EGRESS_* e rejeita o resto (constants.py, helpers.py; pelo código, não testei). Então o caminho é uma imagem com a variável embutida, e o [egress] image do servidor apontando para ela:

ARG BASE
FROM ${BASE}

COPY sigv4_resign.py /var/egress/custom/sigv4_resign.py

# Fail the build, not the sidecar: load the addon with the image's own python3 and mitmproxy.
RUN PYTHONDONTWRITEBYTECODE=1 /usr/bin/python3 -c "import importlib.util as u; \
s = u.spec_from_file_location('sigv4_resign', '/var/egress/custom/sigv4_resign.py'); \
m = u.module_from_spec(s); s.loader.exec_module(m); \
assert all(callable(getattr(m, hook, None)) for hook in ('requestheaders', 'request', 'responseheaders', 'response'))"

ENV OPENSANDBOX_EGRESS_MITMPROXY_SCRIPT=/var/egress/custom/sigv4_resign.py

O BASE é o mirror da imagem de egress 1.2.0 que a parte 2 criou no ECR, fixado por digest. A imagem vale para o servidor inteiro, então todo sidecar roda o addon, incluindo o tráfego para GitHub e Anthropic da parte 4; requisições sem os três headers passam byte a byte, o que os testes do addon verificam.

O addon tem cerca de 800 linhas de Python só com a standard library, rodando sobre o mitmproxy 11.0.2 da imagem. Ele remove os três headers de toda requisição que os carrega e então:

Uma requisição que…O addonO sandbox vê
traz um segundo header Host, Authorization, x-amz-content-sha256 ou X-Amz-Targeta recusa403
tem um Host diferente do server name do TLS (SNI), ou um SNI fora de .amazonaws.coma encerra (host-sni-mismatch)uma conexão fechada
é pré-assinada (a assinatura na query string)a encaminha como veio, nunca assinada de novoa resposta da AWS
tem Authorization: Bearera recusa (bearer-on-sigv4-binding)403
é uma chamada de credential vendinga recusa (credential-vending)403
usa SigV4a ou um upload com chunks assinadosa recusa501
vai para um serviço que não é o S3 com um corpo que pode seguir em streaming (acima de 1 MiB, chunked, ou HTTP/2 sem tamanho)a encerra (body-may-stream-without-payload-hash)uma conexão fechada
qualquer outra coisa assinada com SigV4a assina de novo com os valores reaisa resposta da AWS

Algumas regras merecem uma frase cada:

  • Host e SNI. Como o vault escolhe o binding pelo header Host (#1758), o addon exige que o Host seja igual ao server name do TLS e fixa a conexão upstream nesse nome antes de assinar.
  • Credential vending. No STS, é uma allowlist: só GetCallerIdentity, GetAccessKeyInfo e DecodeAuthorizationMessage passam. Fora do STS, é uma blocklist (chamadas de token de ECR, CodeArtifact, S3 Express, IAM e Redshift), verificada de novo quando o corpo chega.
  • O que é assinado, e quando. A região e o serviço vêm do credential scope do cliente (bedrock-runtime assina como bedrock). Clientes S3 declaram o hash do corpo em x-amz-content-sha256, então uma requisição ao S3 é assinada quando os headers chegam, e o corpo segue em streaming. Os outros serviços são assinados a partir do SHA-256 do corpo, então o addon precisa ter o corpo inteiro antes, e o mitmproxy desta imagem faz streaming de qualquer corpo acima de 1 MiB (stream_large_bodies: 1m), então uma requisição com corpo maior é encerrada.
  • Falha. Qualquer exceção em uma requisição que trazia os headers a encerra.
  • Corpos de erro. Nas requisições que assinou, o addon retém os corpos de erro da AWS (4xx e 5xx) e substitui o key ID real e o session token por [REDACTED] se a AWS os ecoar; uma resposta que ele não consegue limpar é encerrada. Os testes cobrem isso, e nenhuma execução gravada passou por esse caso.

Cada decisão é uma linha de log que começa com credential proxy: [sigv4], no nível warn. A parte 4 viu linhas credential proxy: chegarem em lotes; com esse prefixo e um flush depois de cada linha, uma única requisição bastou, em uma verificação feita antes destas gravações. Os testes são 197 testes unitários e 17 testes end-to-end que rodam um mitmdump real atrás do próprio system.py do OpenSandbox, no laptop e dentro da imagem de egress 1.2.0. O build_egress.sh roda os testes unitários, faz o build para linux/amd64, faz o push e troca o servidor com o server_config.py da parte 3:

build_egress.sh: build, push e a troca do servidor
$ ./build_egress.sh

== preconditions
  ok    base image opensandbox-eks/egress:release-1.2.0 in ECR (sha256:a3d30246e557...)
  ok    addon unit tests: 197 passed in 0.94s
  ok    server now: runtime=runc egress_image=base egress_mode=dns+nft ingress=gateway
   took 6s

== build and push opensandbox-eks/egress-sigv4:release-1.2.0-197d79bc310b
  FROM opensandbox-eks/egress@sha256:a3d30246e557... (release-1.2.0), linux/amd64 (full output: logs/build-egress.log)
  ok    build-time check: the image's python3 loaded sigv4_resign.py with all four hooks
  ok    pushed opensandbox-eks/egress-sigv4:release-1.2.0 and :release-1.2.0-197d79bc310b
  ok    digest sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719
   took 6s

== switch the server's [egress] image
server now:    runtime=runc egress_image=base egress_mode=dns+nft ingress=gateway   (revision 17)
server wanted: runtime=runc egress_image=opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719 egress_mode=dns+nft ingress=gateway
  config.toml: changes:
    --- running config.toml
    +++ new config.toml
    @@ -20,3 +20,3 @@
     [egress]
    -image = "opensandbox-eks/egress:release-1.2.0"
    +image = "opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719"
     mode = "dns+nft"
  helm upgrade: revision 17 -> 18 (deployed) in 19 s, manifests changed
  server pod opensandbox-server-7c8b74fc7c-fjxbl replaced opensandbox-server-775f8ddf57-z5ll2, ready=true
  ok    server /health: {"status":"healthy"}
  ok    server /version: {"version":"1.2.0"}
  ok    release revision 18 is deployed
  ok    the server pod runs with: runtime=runc egress_image=opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719 egress_mode=dns+nft ingress=gateway
  ok    gateway kept: server.gateway and [ingress] mode = gateway, host from values/server-gateway.yaml
  The server pod was replaced: a kubectl port-forward started before this has ended. The Python
  scripts in this directory start their own; restart yours if you use one.
   took 42s

egress image: <registry>/opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719
new sandboxes with an egress sidecar now run the SigV4 addon; restart any port-forward to the server

Os 197 testes unitários passaram, a verificação no build carregou o addon com o próprio Python da imagem, e a troca foi uma linha do config.toml e um Helm upgrade de 19 segundos (42 segundos com as verificações). O servidor referencia a imagem por digest, então nenhum node consegue rodar um build mais antigo sob a mesma tag.

Passo 5: Uma imagem de workload com boto3

A imagem egress-tools:1 da parte 4 tem a AWS CLI v2 2.39.3, mas não o boto3, e um sandbox aqui não consegue fazer pip install de nada: a policy dele só permite hosts da AWS. O 00_image.sh faz o build da opensandbox-eks/aws-tools:1 a partir dela com boto3==1.43.123, a mesma versão fixada no broker, e faz o push para o ECR.

Testes

As execuções abaixo são as gravadas, sem as linhas de port-forward e de limpeza, e com o prefixo da chave do broker encurtado para ASIA…. Uma criação pelo broker (o sandbox, o AssumeRole e a gravação do vault) levou de 6,0 a 6,7 segundos em runc, pelos timestamps do cast.

Teste 1: Bedrock com uma chave de curto prazo, e sem assinatura

O Bedrock aceita API keys de curto prazo como bearer tokens, que o boto3 e a AWS CLI enviam quando AWS_BEARER_TOKEN_BEDROCK está definida. Uma chave é bedrock-api-key- mais o base64 de uma URL pré-assinada com SigV4 para CallWithBearerToken, e ela não pode durar mais que a sessão que a gerou. Com bedrock_bearer ligado, o broker gera uma a partir da sessão do sandbox, no formato do token generator da AWS (localmente; nada vai para a AWS), guarda a chave no vault e vincula o host do Bedrock com um binding bearer em vez do binding SigV4. O sandbox recebe um AWS_BEARER_TOKEN_BEDROCK placeholder.

O Teste 5 da parte 4 mostrou um binding bearer substituindo um header Authorization que o próprio sandbox tinha definido, contra o servidor de eco. A pergunta aqui é se isso vale para o header que os AWS SDKs montam para o Bedrock:

== 1. a sandbox whose Bedrock key is a bearer binding
  sandbox d8ce9fc1-2a61-4c12-ae13-f4165408ea69  vault revision 1  credentials expire 2026-11-01T18:03:04Z  bedrock_bearer=True
  $ env | grep -E '^AWS_(BEARER|ACCESS|SECRET)' | sort
      AWS_ACCESS_KEY_ID=AKIA_OSB_PLACEHOLDER
      AWS_BEARER_TOKEN_BEDROCK=bedrock-api-key-osb-placeholder
      AWS_SECRET_ACCESS_KEY=osb-placeholder-secret
      exit code 0
  PASS  the sandbox holds a placeholder bearer token
  PASS  the bearer value is not a real key

== 2. Converse over the bearer path (boto3 reads AWS_BEARER_TOKEN_BEDROCK)
  $ python3 (boto3 bedrock-runtime converse, pinned Haiku model)
      HTTP 200 | reply: Ready
      exit code 0
  $ aws bedrock-runtime converse --model-id us.anthropic.claude-haiku-4-5-20251001-v1:0 --messages ...
      exit code 0

Depois, o lado do vault. O script faz uma chamada SigV4 ao STS como controle: o addon a registra, o que faz o flush do log do sidecar, então qualquer linha que ainda estivesse esperando nele aparece:

== 3. what the sidecar did
  $ aws sts get-caller-identity   # a SigV4 call: the addon logs it, which flushes the sidecar's log
  control: the addon's `re-signed` line for the STS call reached the log: True
  PASS  the sidecar log flushed (the STS call's re-signed line is in it)
        log: credential proxy: [sigv4] re-signed POST sts.us-east-1.amazonaws.com/ service=sts region=us-east-1 key=ASIA... payload=sha256 hook=request
  vault: `applied binding=bedrock-bearer` lines: 2
        log: credential proxy: applied binding=bedrock-bearer revision=1 host=bedrock-runtime.us-east-1.amazonaws.com method=POST headers=Authorization substitutions=
        log: ... 1 more line(s)
  addon lines in this window (the STS control call included): 1; re-signed: 0; refused bearer-on-sigv4-binding: 0

== 4. the result
  RESULT  the vault replaced the placeholder Authorization header: the call worked over the bearer path,
          and the addon did not re-sign it. A Bedrock short-term key needs no SigV4 re-signing.
  PASS  bearer path: the call succeeded with a placeholder token, the vault logged `applied binding=bedrock-bearer`, and the addon neither re-signed nor refused it

Vale. O sandbox enviou só o placeholder, e o Bedrock respondeu: o boto3 recebeu HTTP 200 e uma resposta, e a AWS CLI saiu com 0. O vault registrou duas linhas applied binding=bedrock-bearer para as duas chamadas, a que aparece acima com headers=Authorization: ele trocou o placeholder pela chave real. A única linha do addon nessa janela foi a da chamada de controle ao STS, então o re-signed: 0 do script conta só requisições ao Bedrock. Neste modo, o binding SigV4 deixa de fora o host do Bedrock, então as requisições ao Bedrock não levaram nenhum dos três headers dele, e o addon nem as assinou nem as recusou. Uma gravação anterior, sem a chamada de controle, não mostrou nenhuma linha applied binding; com a linha do addon fazendo o flush do log, as duas apareceram, o que bate com a constatação da parte 4 de que essas linhas chegam em lotes.

Então, para o Bedrock Runtime, o vault padrão e uma chave de curto prazo bastam. A role precisa de bedrock:CallWithBearerToken (a minha só permite chaves de curto prazo), e, segundo a documentação, chaves bearer cobrem só ações do Bedrock e do Bedrock Runtime, não do Agents.

Teste 2: Quem o sandbox é para a AWS

O 02_identity.py faz a mesma pergunta de duas formas, de dentro do sandbox:

== 1. the broker makes a sandbox and gives it credentials
  sandbox 94548e3a-ca99-447c-8b9b-1a24e92cea23  vault revision 1  credentials expire 2026-11-01T13:46:07Z  bedrock_bearer=False

== 2. the sandbox's identity, from the AWS CLI and from boto3
  $ aws sts get-caller-identity --query Arn --output text
      arn:aws:sts::123456789012:assumed-role/osb-sandbox/94548e3a-ca99-447c-8b9b-1a24e92cea23
      exit code 0
  $ python3 -c 'print(boto3.client("sts").get_caller_identity()["Arn"])'
      arn:aws:sts::123456789012:assumed-role/osb-sandbox/94548e3a-ca99-447c-8b9b-1a24e92cea23
      exit code 0
  PASS  the AWS CLI returns the assumed-role ARN with the sandbox ID as the session name  (session name 94548e3a-ca99-447c-8b9b-1a24e92cea23)
  PASS  boto3 returns the same ARN

  session name = 94548e3a-ca99-447c-8b9b-1a24e92cea23
  sandbox id   = 94548e3a-ca99-447c-8b9b-1a24e92cea23
  PASS  session name equals the sandbox ID

Os dois clientes receberam assumed-role/osb-sandbox/<sandbox ID>: as requisições deles saíram assinadas com AKIA_OSB_PLACEHOLDER e chegaram ao STS assinadas pelo addon. Isto é tudo o que o sandbox guarda:

== 3. what the sandbox holds: placeholders only
  $ env | grep '^AWS_' | sort
      AWS_ACCESS_KEY_ID=AKIA_OSB_PLACEHOLDER
      AWS_CA_BUNDLE=/opt/opensandbox/merged-ca-certificates.pem
      AWS_DEFAULT_REGION=us-east-1
      AWS_EC2_METADATA_DISABLED=true
      AWS_REGION=us-east-1
      AWS_SECRET_ACCESS_KEY=osb-placeholder-secret
      exit code 0

As 11 verificações passaram, incluindo: nenhum AWS_SESSION_TOKEN ou AWS_ACCOUNT_ID, e nenhuma chave temporária em variável alguma nem nos arquivos em /root, /home, /tmp e /etc.

Teste 3: S3, de 19 bytes a um upload multipart de 20 MiB

O 03_s3.py lista, faz upload de 19 bytes, de 5 MiB em um único PutObject e de 20 MiB como upload multipart, baixa o objeto de 20 MiB, compara os checksums e faz um put e um list com o boto3:

As operações no S3
== 2. listing
  $ aws s3 ls

      aws: [ERROR]: An error occurred (AccessDenied) when calling the ListBuckets operation ...
      exit code 254
  PASS  aws s3 ls without a bucket is denied (no s3:ListAllMyBuckets)  (AccessDenied)
  $ aws s3 ls s3://example-bucket/ | head -3
      2026-10-30 02:38:37         32 from-sandbox.txt
      2026-10-30 02:38:32         20 hello.txt
      exit code 0
  PASS  aws s3 ls s3://example-bucket/ works

== 3. uploads: 19 bytes, 5 MiB (one PutObject), 20 MiB (multipart)
  $ wc -c /tmp/small.txt /tmp/five.bin /tmp/twenty.bin
            19 /tmp/small.txt
       5242880 /tmp/five.bin
      20971520 /tmp/twenty.bin
      26214419 total
      exit code 0
  $ aws s3 cp /tmp/small.txt s3://example-bucket/osb-test/05db70cb-4284-4d96-9604-d5a8c7c64c16/small.txt --only-show-errors
      (no output)
      exit code 0
  PASS  19-byte upload
  $ aws s3 cp /tmp/five.bin s3://example-bucket/osb-test/05db70cb-4284-4d96-9604-d5a8c7c64c16/five.bin --only-show-errors
      (no output)
      exit code 0
  PASS  5 MiB upload (single PutObject)
  $ aws s3 cp /tmp/twenty.bin s3://example-bucket/osb-test/05db70cb-4284-4d96-9604-d5a8c7c64c16/twenty.bin --only-show-errors
      (no output)
      exit code 0
  PASS  20 MiB upload (multipart)
  $ aws s3 ls s3://example-bucket/osb-test/05db70cb-4284-4d96-9604-d5a8c7c64c16/
      2026-11-01 12:46:47    5242880 five.bin
      2026-11-01 12:46:46         19 small.txt
      2026-11-01 12:46:48   20971520 twenty.bin
      exit code 0

== 4. download the 20 MiB object and compare checksums
  $ aws s3 cp s3://example-bucket/osb-test/05db70cb-4284-4d96-9604-d5a8c7c64c16/twenty.bin /tmp/twenty.back --only-show-errors
      (no output)
      exit code 0
  sha256 before upload  8e7b25f19c282be8...
  sha256 after download 8e7b25f19c282be8...
  PASS  20 MiB round trip: the checksums match

== 5. boto3 from inside the sandbox
  $ python3 (boto3 put_object + list_objects_v2)
      put_object ok; list_objects_v2 sees: boto3.txt, five.bin, small.txt, twenty.bin
      exit code 0
  PASS  boto3 put_object and list_objects_v2

Tudo funcionou, e o objeto de 20 MiB voltou com o mesmo SHA-256. O aws s3 ls sem bucket foi negado de propósito: listar todos os buckets exige s3:ListAllMyBuckets, que a role não tem. Depois, o lado do sidecar:

== 6. what the sidecar did (its log, event and payload type only)
  addon events: {'re-signed': 19}
  payload types re-signed: {'sha256': 7, 'STREAMING-UNSIGNED-PAYLOAD-TRAILER': 6, 'UNSIGNED-PAYLOAD': 6}
  PASS  the addon re-signed the S3 requests  (19 re-signed)
  PASS  the addon refused or killed none of them

Dezenove requisições assinadas, nenhuma recusada ou encerrada. Desde 15 de janeiro de 2025 (botocore 1.36.0, AWS CLI 2.23.0), a AWS CLI e o boto3 fazem upload com encoding aws-chunked e um trailer de checksum, declarado como STREAMING-UNSIGNED-PAYLOAD-TRAILER (integridade de dados nos SDKs). Os chunks não são assinados, então assinar de novo só muda headers, e o addon deixou o corpo de 20 MiB seguir em streaming. Clientes S3 declaram um desses tipos de payload em x-amz-content-sha256, e é isso que permite ao S3 escapar do limite de 1 MiB.

Teste 4: DynamoDB, Bedrock Converse e o limite de 1 MiB

Corpos pequenos para outros serviços também funcionam, assinados assim que o corpo inteiro chega. Um round trip de PutItem e GetItem no DynamoDB e uma chamada Converse ao Bedrock:

DynamoDB e Bedrock Converse com SigV4
== 2. DynamoDB PutItem and GetItem (SigV4, small body)
  $ aws dynamodb put-item --table-name osb-cred-test --item '{"pk":{"S":"item-e7019e72"},"note":{"S":"written through the addon"}}'
      (no output)
      exit code 0
  PASS  DynamoDB PutItem
  $ aws dynamodb get-item --table-name osb-cred-test --key ... --query Item.note.S --output text
      written through the addon
  PASS  DynamoDB GetItem returns what PutItem wrote

== 3. Bedrock Converse (SigV4) on the pinned Haiku model
  $ aws bedrock-runtime converse --model-id us.anthropic.claude-haiku-4-5-20251001-v1:0 --messages ... --query output.message.content[0].text
      ready
      exit code 0
  PASS  Bedrock Converse returns a reply

Depois, o limite. O DynamoDB limita um item a 400 KB, então o script usa BatchWriteItem com itens de cerca de 290 KB, três em uma requisição e depois quatro:

Montando os dois batches
== 4. the 1 MiB limit on a non-S3 body
  $ python3 /tmp/build.py  # 3 items of 290 KB
      under-e7019e72: 3 items, request body 870,259 bytes (0.83 MiB)
      exit code 0
  $ python3 /tmp/build.py  # 4 items of 290 KB
      over-e7019e72: 4 items, request body 1,160,335 bytes (1.11 MiB)
      exit code 0
  $ aws dynamodb batch-write-item --request-items file:///tmp/under.json   # 0.83 MiB
      {
          "UnprocessedItems": {}
      }
      exit code 0
  $ aws dynamodb get-item ... under-0 --query Item.pk.S --output text
      under-e7019e72-0
  PASS  a 0.83 MiB DynamoDB body is signed and forwarded
  PASS  DynamoDB processed every item (UnprocessedItems empty) and the first item can be read back  (unprocessed key count 0)
  $ aws dynamodb batch-write-item --request-items file:///tmp/over.json   # 1.11 MiB
      exit code 255; client saw: connection closed
        log: credential proxy: [sigv4] killed POST dynamodb.us-east-1.amazonaws.com/ reason=body-may-stream-without-payload-hash service=dynamodb
        log: credential proxy: [sigv4] killed POST dynamodb.us-east-1.amazonaws.com/ reason=body-may-stream-without-payload-hash service=dynamodb
        log: ... 1 more line(s)
  PASS  the 1.11 MiB request fails on the client
  PASS  the client saw a closed connection, not an AWS answer or a 403  (connection closed)
  PASS  the sidecar log says killed ... reason=body-may-stream-without-payload-hash  (3 line(s))
  $ aws dynamodb get-item ... over-0 --query Item.pk.S --output text
      None
  PASS  nothing reached DynamoDB: the item is not there

O batch de 870.259 bytes (0,83 MiB) foi assinado e gravado: UnprocessedItems voltou vazio, e o primeiro item dele foi lido de volta. O batch de 1.160.335 bytes (1,11 MiB) nunca chegou ao DynamoDB: o cliente viu uma conexão fechada, o sidecar registrou três linhas killed idênticas (os retries da CLI, eu acho), e o primeiro item do batch não estava na tabela depois. Não é um 403 porque o mitmproxy não consegue responder localmente por um corpo que já está enviando em streaming, então o motivo só aparece no log do sidecar.

Pelo código do addon, e não por esta execução, o mesmo limite vale para qualquer serviço que não seja o S3: qualquer BatchWriteItem acima de cerca de 1 MiB (o próprio DynamoDB permite 16 MB por requisição), um Converse do Bedrock com imagens ou documentos grandes, e requisições HTTP/2 com corpo, mas sem Content-Length. A AWS CLI e o boto3 enviam HTTP/1.1 com o tamanho do corpo.

Teste 5: O CloudTrail nomeia o sandbox

O 05_cloudtrail.py faz uma chamada ao STS e uma ao Bedrock a partir de um sandbox novo e depois consulta o histórico de eventos do CloudTrail com as minhas próprias credenciais (o profile default) até os eventos aparecerem:

== 2. CloudTrail event history (the default AWS profile)
  waiting for CloudTrail ... 0 s (have: nothing)
  waiting for CloudTrail ... 31 s (have: Converse)
  waiting for CloudTrail ... 61 s (have: Converse)

== 3. the events
  2026-11-01T13:46:29Z  sts      GetCallerIdentity  role osb-sandbox  session 853b2917-c187-4e4c-863b-6777a01acb59
  2026-11-01T13:46:30Z  bedrock  Converse           role osb-sandbox  session 853b2917-c187-4e4c-863b-6777a01acb59
  2026-11-01T13:46:27Z  sts      AssumeRole         role osb-broker   session eks-osb-eks-osb-broker-9548f802-b151-4252-90f8-750f9eb2cddf
      AssumeRole: roleSessionName = 853b2917-c187-4e4c-863b-6777a01acb59, durationSeconds = 3600, caller = assumed-role/osb-broker/eks-osb-eks-osb-broker-9548f802-b151-4252-90f8-750f9eb2cddf
  PASS  STS GetCallerIdentity is in event history under the sandbox's session name
  PASS  the AssumeRole event names the sandbox ID as roleSessionName
  PASS  the AssumeRole was made by the broker's role session
  PASS  Bedrock Converse is in event history under the same session name
  PASS  the events are in this account

O Converse estava no histórico de eventos na segunda consulta (31 segundos), e os outros dois na quarta, cerca de um minuto e meio depois das chamadas; a documentação do CloudTrail diz que a entrega leva em média cerca de 5 minutos e não é garantida. As chamadas do sandbox ficam sob o user name <sandbox ID>, e o evento AssumeRole do broker liga os dois: roleSessionName com o ID do sandbox, durationSeconds 3600. O console mostra o mesmo filtro:

O Event history do CloudTrail em us-east-1, filtrado pelo User name 853b2917-c187-4e4c-863b-6777a01acb59, com dois eventos: Converse de bedrock.amazonaws.com às 13:46:30 e GetCallerIdentity de sts.amazonaws.com às 13:46:29, em 1º de novembro de 2026. A conta aparece como my-account (123456789012).

O histórico de eventos é gratuito, mas guarda só management events, e o Converse do Bedrock é um deles. Chamadas a objetos do S3 e a itens do DynamoDB são data events, registrados só por um trail pelo qual você paga ($0,10 por 100.000 data events entregues); o CloudTrail Lake, o outro caminho, deixou de aceitar novos clientes em 31 de maio de 2026, como diz o banner do screenshot. Não configurei um trail, então os uploads do Teste 3 não aparecem aqui.

Teste 6: Tentando tirar as credenciais

O 06_attacks.py dá a um sandbox as credenciais padrão e tenta sete formas de tirar algo real dele:

AtaqueResultado
A. Credential vending a partir do sandbox: sts assume-role, get-session-token, get-federation-token, ecr get-login-passwordAs três chamadas ao STS recusadas pelo addon com 403 antes da assinatura; ECR inacessível (fora da allowlist)
B. Uma URL pré-assinada gerada no sandbox com a chave placeholderEncaminhada sem mudanças; o S3 respondeu 403; nenhuma chave temporária na resposta
C. O spoof do Host da parte 4, contra o binding da AWS, em cinco casosUma requisição com um Host que indicava outro host com binding foi encerrada; uma conexão para um endereço do S3 ainda chegou ao STS (o upstream é fixado no nome TLS); nada foi adicionado quando nenhum binding casou ou a conexão não foi descriptografada
D. O instance metadata service e o agente do Pod IdentityOs dois dão timeout (curl exit 28); nenhuma variável AWS_CONTAINER_*
E. Uma busca por uma chave temporária, um session token ou os três nomes de headerUm canary plantado foi encontrado, então a busca funciona; depois, 0 arquivos em /root, /home, /tmp, /etc, /var e /opt, e 0 em /proc/*/environ
F. A API do sidecar sem o token dela401, 403 e 401, como na parte 4
G. Um header Bearer para um host com binding SigV4403 com x-osb-egress-refused: bearer-on-sigv4-binding

Primeiro, o credential vending:

== A. credential-vending calls from inside the sandbox
  $ aws sts assume-role --role-arn arn:aws:iam::123456789012:role/osb-sandbox --role-session-name escape
      exit code 254; client saw: Unknown (the CLI cannot parse the addon's 403); the addon's reason: credential-vending
        log: credential proxy: [sigv4] refused 403 POST sts.us-east-1.amazonaws.com/ reason=credential-vending service=sts
  PASS  sts assume-role: refused, no credential returned  (1 log line(s))
  $ aws sts get-session-token
      exit code 254; client saw: Unknown (the CLI cannot parse the addon's 403); the addon's reason: credential-vending
        log: credential proxy: [sigv4] refused 403 POST sts.us-east-1.amazonaws.com/ reason=credential-vending service=sts
  PASS  sts get-session-token: refused, no credential returned  (1 log line(s))
  $ aws sts get-federation-token --name escape
      exit code 254; client saw: Unknown (the CLI cannot parse the addon's 403); the addon's reason: credential-vending
        log: credential proxy: [sigv4] refused 403 POST sts.us-east-1.amazonaws.com/ reason=credential-vending service=sts
  PASS  sts get-federation-token: refused, no credential returned  (1 log line(s))
  $ aws ecr get-login-password --region us-east-1
      exit code 255; client saw: could not connect; output 96 characters
  PASS  ecr get-login-password: no token (the ECR host is not on the allow list)

Cada chamada ao STS recebeu o 403 do addon (credential-vending) e nunca foi assinada, então a AWS nunca a viu; a CLI informa Unknown porque o corpo de erro do addon não está no formato do STS. O ecr get-login-password nem conseguiu conectar: nenhum host do ECR está na allowlist. O Deny da role está por trás disso, mas o addon responde primeiro, e é por isso que só o deny-check do Passo 3 mostra essa camada.

Depois, o spoof do Host que vazou na parte 4:

== C. Host / SNI spoofing (#1758)
  PASS  an allowed AWS IP resolved for the spoof tests
  SNI sts, Host s3 (another bound host):
      curl exit 92, no HTTP answer
        log: credential proxy: [sigv4] killed GET s3.us-east-1.amazonaws.com/ reason=host-sni-mismatch sni=sts.us-east-1.amazonaws.com
  PASS  SNI sts, Host s3: connection killed, host-sni-mismatch logged  (curl exit 92)
  control, SNI sts, Host sts:
      HTTP/2 302 ; binding applied: 1 log line(s)
  PASS  control: a request for the bound host shows 'applied binding' in the log
  PASS  an S3 address resolved for the pin test
  3. SNI sts, Host other.example.com (no binding matches):
      HTTP/2 302 ; answered by the sts host: True; binding applied: 0; request signed: 0
  PASS  3. SNI sts, Host other.example.com (no binding matches): no credential applied; the answer is the connected host's own
  4. SNI sts, dialed to an S3 address (the upstream is pinned to the SNI name):
      HTTP/2 302 ; answered by the sts host: True; binding applied: 1; request signed: 0
  PASS  4. SNI sts, dialed to an S3 address (the upstream is pinned to the SNI name): STS answers and the binding applied is sts's
  5. allowed IP, no SNI, Host s3:
      HTTP/1.1 302 Found; answered by the sts host: True; addon or vault log lines: 0
  PASS  5. no SNI: passed through undecrypted, so neither the vault nor the addon saw it (no log line) and nothing was added
  note  what each case proves: 1 kills a decrypted request whose Host names a bound host other than the SNI; 3 and 5 show nothing is added when no binding matches or the connection is never decrypted; 4 shows the upstream follows the SNI name, not the dialed address

Cada caso mostra algo diferente, e só dois deles dizem respeito ao addon:

  1. O Host indica outro host com binding: o addon encerra a requisição. O vazamento da parte 4, apontado para a AWS: a conexão foi para o STS, o Host dizia S3, e o system.py adicionou os três headers embora o Host não batesse com o nome TLS. O addon só age sobre requisições que os carregam, então a linha de encerramento dele (curl exit 92) prova que eles foram adicionados, sobre HTTPS.
  2. O controle: uma requisição simples ao STS registrou applied binding, que apareceu no log graças ao flush feito pela linha do próprio addon para a mesma requisição.
  3. Host fora da AWS: nada adicionado. Com Host: other.example.com, nenhum binding casou, embora o nome TLS, o STS, tenha binding, e o STS respondeu com o próprio redirect. Se o vault tivesse adicionado os três headers, o addon teria encerrado a requisição. Junto com o caso 1, isso confirma sobre HTTPS o que a parte 4 leu no código: o vault escolhe o binding pelo Host e não o compara com o server name do TLS.
  4. Conectada a um endereço do S3: fixada de volta no STS. O curl conectou a um endereço IP do S3 enquanto enviava o nome do STS no TLS e no Host. No modo transparente, o upstream seria o endereço ao qual o cliente conectou, mas o addon o define como o server name do TLS, então o STS respondeu e o binding aplicado foi o do STS. O curl não enviou assinatura, então nada foi assinado; segundo o código do addon, uma requisição SigV4 é assinada depois da fixação.
  5. Sem server name: nunca descriptografada. O system.py deixa passar uma conexão TLS sem SNI sem interceptá-la (system.py), então o STS respondeu diretamente, em HTTP/1.1, enquanto os casos descriptografados receberam HTTP/2. Isso é o egress, não o addon.

Em nenhum caso uma requisição saiu com as credenciais para um host diferente do que estava no server name do TLS dela.

Isso contorna o #1758 só para o binding da AWS, porque o addon só verifica requisições que carregam os três headers dele. Outro binding no mesmo vault, como o binding bearer do Bedrock do Teste 1 ou um token do GitHub, continuaria exposto exatamente como na parte 4.

Ataques B, D, E, F e G, como gravados
== B. a presigned URL made with the placeholder key
  $ python3 (boto3 generate_presigned_url, no network call)
      https://example-bucket.s3.amazonaws.com/osb-test/never-written.txt?AWSAccessKeyId=AKIA_OSB_PLACEHOLDER&Signature=IEKFGdOzYhqh0ux26TKeJJPMpgw%3D&Expires=1793540969
      exit code 0
  $ curl <presigned URL>
      HTTP 403
        log: credential proxy: [sigv4] presigned GET example-bucket.s3.amazonaws.com/osb-test/never-written.txt reason=query-auth-forwarded-unchanged
  PASS  presigned URL with the placeholder key is rejected by S3 (403)  (HTTP 403)
  PASS  the addon forwarded it unchanged and logged presigned ... query-auth-forwarded-unchanged
  PASS  the response holds no temporary key

== D. the metadata services
  EC2 instance metadata (169.254.169.254): curl exit 28; HTTP -
  PASS  EC2 instance metadata is unreachable
  Pod Identity agent (169.254.170.23): curl exit 28; HTTP -
  PASS  Pod Identity agent is unreachable
  PASS  no AWS_CONTAINER_* credentials variables in the sandbox

== E. search the sandbox for a temporary key or session token
  PASS  the scans can find a key (a made-up canary in a file and in a process environment)  (1 file, 1 process)
  $ grep -rIlE '<temporary key | session token | carrier header name>' /root /home /tmp /etc /var /opt | wc -l
      0
  $ cat /proc/*/environ | grep -cE '<same patterns>'
      0
  PASS  no file holds a temporary key, a session token or a carrier header  (0 file(s))
  PASS  no process environment holds one  (0 match(es))

== F. the sidecar's API without its token
  GET 127.0.0.1:18080/credential-vault          -> HTTP 401
  PASS  sidecar API /credential-vault refuses a caller without its token  (HTTP 401)
  GET 127.0.0.1:18080/credential-vault/_active  -> HTTP 403
  PASS  sidecar API /credential-vault/_active refuses a caller without its token  (HTTP 403)
  GET 127.0.0.1:18080/policy                    -> HTTP 401
  PASS  sidecar API /policy refuses a caller without its token  (HTTP 401)

== G. a Bearer header on a SigV4-bound host
  $ curl -X POST https://dynamodb.us-east-1.amazonaws.com/ -H 'Authorization: Bearer ...'
      HTTP/2 403
      x-osb-egress-refused: bearer-on-sigv4-binding
  PASS  403 with x-osb-egress-refused: bearer-on-sigv4-binding

O boto3 pré-assinou a URL do B com SigV2, o padrão dele para o S3; o addon a encaminhou intacta e o S3 rejeitou a chave placeholder. A busca do E primeiro encontrou um canary plantado, então os zeros dela significam algo. A recusa do Bearer usou um POST: em uma execução anterior, não gravada, um GET com o mesmo header, que não tem Content-Length em HTTP/2, foi encerrado em vez disso (curl exit 92). As 24 verificações passaram.

Teste 7: Rotação, o limite de uma hora e revogação

O 07_lifetime.py acompanha as credenciais de um sandbox ao longo de uma rotação, um conflito e uma revogação:

== 1. a sandbox, and the clock on its credentials
  sandbox 8683e68a-faf9-4321-bd05-72f9c2317b83  vault revision 1  credentials expire 2026-11-01T18:03:33Z  bedrock_bearer=False
  revision 1; expires in 3598 s (the role-chaining cap: one hour)
  the broker's timer rotates in 1800 s (half the session: 1,800 s)
  PASS  session length is the one-hour cap  (3598 s)
  PASS  rotation is due at half the session
  $ aws sts get-caller-identity --query Arn --output text
      arn:aws:sts::123456789012:assumed-role/osb-sandbox/8683e68a-faf9-4321-bd05-72f9c2317b83
      exit code 0
  PASS  AWS call before the rotation

A sessão dura uma hora (restavam 3.598 segundos quando o script a leu), e o timer do broker a substituiria depois de 1.800. O script não espera meia hora; ele força rotações pela API do broker:

Rotações forçadas e uma revisão desatualizada
== 2. force a rotation: the same sandbox keeps working
  refresh -> revision 1 -> 2; new expiry 2026-11-01 18:03:35 UTC
  PASS  the vault revision went up
  PASS  the credentials are new (a later expiry than before)  (2026-11-01 18:03:33 UTC -> 2026-11-01 18:03:35 UTC)
  PASS  expiry moved out by a new full session  (3598 s left)
  $ aws sts get-caller-identity --query Arn --output text
      arn:aws:sts::123456789012:assumed-role/osb-sandbox/8683e68a-faf9-4321-bd05-72f9c2317b83
      exit code 0
  PASS  the sandbox's AWS call after the rotation

== 3. a patch with the right revision works, one with a stale revision conflicts
  refresh with expected_revision=2 -> revision 3
  PASS  expected_revision = current revision: accepted
  refresh with expected_revision=1 (stale) -> HTTP 409, vault_status 409, revision now 3
  PASS  a stale expected_revision is refused with 409 or 412  (HTTP 409)
  PASS  the body reports a revision conflict (not 'vault not ready')
  PASS  the vault's own revision (in the conflict answer) is the accepted one, and the broker kept it
  $ aws sts get-caller-identity --query Arn --output text
      arn:aws:sts::123456789012:assumed-role/osb-sandbox/8683e68a-faf9-4321-bd05-72f9c2317b83
      exit code 0
  PASS  the sandbox's AWS call after the conflict
  note  412 is also what the vault answers when it is not Ready (the sidecar is starting), so the broker's body tells the two apart

== 4. the broker's own timer
  skipped: the broker patches the vault every 1,800 s from the last rotation, with the vault's expected revision.
  (run with --wait-loop to watch one; the unit tests in broker/ cover the loop, including the retry after a failure)

Uma rotação levou o vault da revisão 1 para a 2 com uma nova sessão completa (3.598 segundos restantes), e a próxima chamada do sandbox funcionou sem restart. Uma rotação com o expected_revision certo passou (revisão 3); uma com revisão desatualizada recebeu HTTP 409, como no Teste 7 da parte 4, e não mudou nada. O vault usa 412 para “ainda não está pronto”, então o broker repassa o status dele. Testes unitários cobrem o timer do próprio broker; o --wait-loop acompanha uma rotação dele (cerca de 30 minutos) e não foi gravado.

O limite vem da própria identidade do broker, que o whoami verifica dentro do pod do broker:

== 5. why the cap matters: the broker's identity
  $ python broker.py whoami   (in the broker pod)
      broker identity: arn:aws:sts::<account>:assumed-role/osb-broker/eks-osb-eks-osb-broker-722fe53a-7004-4ebf-85e7-5beefa9f2cbb
        AWS_CONTAINER_CREDENTIALS_FULL_URI: set
        AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE: set
        credentials from: container-role
        a two-hour AssumeRole of osb-sandbox: The requested DurationSeconds exceeds the 1 hour session limit for roles assumed by role chaining.
  PASS  the broker's identity is a role session from EKS Pod Identity (container-role)
  PASS  a two-hour AssumeRole is refused for role chaining, not for the role's own maximum
  note  the role allows two hours (max_session_duration = 7200); the broker's session is a role session, so its AssumeRole is role chaining: at most 3,600 s

As credenciais do broker são uma sessão de role do Pod Identity (container-role), então as chamadas AssumeRole dele são role chaining. Com a role permitindo duas horas, o whoami pediu duas: a AWS recusou com “the 1 hour session limit for roles assumed by role chaining”, o limite que a referência do AssumeRole descreve. É por isso que o broker pede 3.600 segundos e faz a rotação na metade disso.

Depois, a revogação, no meio da sessão:

== 6. revoke mid-session: delete the vault
  DELETE /sandboxes/{id}/vault -> vault: revoked; next rotation: None
  PASS  the broker reports the vault revoked and stops rotating
  $ aws sts get-caller-identity --query Arn --output text
      exit code 254; client saw: InvalidClientTokenId
  PASS  the sandbox's next AWS call fails after the vault is deleted: STS rejects the placeholder key  (InvalidClientTokenId)
  PASS  the sidecar added no credential and signed nothing  (0 line(s))
  PASS  the broker refuses to rotate a revoked sandbox  (HTTP 409)
  the sandbox itself is still running: still running 6

Deletar o vault cortou o sandbox na hora: nada foi adicionado nem assinado, então a próxima chamada chegou ao STS com a assinatura do placeholder e foi rejeitada (InvalidClientTokenId). Na parte 4, um vault deletado parava a credencial, não o tráfego; aqui, a AWS recusa o tráfego. O sandbox continuou rodando, e o broker se recusou a fazer a rotação dele de novo (409). As credenciais em si continuam válidas na AWS por até uma hora; só estão fora do alcance do sandbox.

Teste 8: O mesmo fluxo no Kata

O 08_kata.py troca o servidor para o Kata (kata-qemu) com o switch_runtime.sh da parte 3, roda uma vez o fluxo de identidade, S3 e Bedrock, e volta para runc:

== 2. a sandbox with AWS credentials, under Kata
  sandbox 79edb7ec-37b9-492d-870d-6fe02b80f09c  vault revision 1  credentials expire 2026-11-01T14:55:29Z  bedrock_bearer=False
  pod runtimeClassName: kata-qemu
  node kernel 6.18.56-125.164.amzn2023.x86_64; the sandbox sees kernel 6.18.35
  PASS  the pod runs with runtimeClassName kata-qemu
  PASS  the sandbox's kernel is the VM's, not the node's
  PASS  placeholder keys only

== 4. the addon, inside the Kata pod
  addon lines: 8; re-signed: 8; refused or killed: 0
  PASS  the addon re-signed the requests and refused none
A troca para o Kata, e o fluxo dentro da VM
== 1. switch the server to Kata (kata-qemu)
  $ ../opensandbox-lifecycle/switch_runtime.sh kata
server now:    runtime=runc egress_image=opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719 egress_mode=dns+nft ingress=gateway   (revision 24)
server wanted: runtime=kata-qemu egress_image=opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719 egress_mode=dns+nft ingress=gateway
  config.toml: changes:
    --- running config.toml
    +++ new config.toml
    @@ -26 +26,6 @@
     path = "/data/opensandbox.db"
    +
    +# from opensandbox-lifecycle/values/runtime-kata-qemu.toml
    +[secure_runtime]
    +type = "kata"
    +k8s_runtime_class = "kata-qemu"
  helm upgrade: revision 24 -> 25 (deployed) in 18 s, manifests changed
  server pod opensandbox-server-66d4f8f6bb-5tdgk replaced opensandbox-server-7c8b74fc7c-wbqmg, ready=true
  ok    server /health: {"status":"healthy"}
  ok    server /version: {"version":"1.2.0"}
  ok    release revision 25 is deployed
  ok    the server pod runs with: runtime=kata-qemu egress_image=opensandbox-eks/egress-sigv4@sha256:658c0839bf3a66a7ffcc906d159b7fd37a5da542a822fda411896dcd31d2d719 egress_mode=dns+nft ingress=gateway
  ok    gateway kept: server.gateway and [ingress] mode = gateway, host from values/server-gateway.yaml
  The server pod was replaced: a kubectl port-forward started before this has ended. The Python
  scripts in this directory start their own; restart yours if you use one.
switched to kata-qemu in 30 s
== 3. identity, S3 and Bedrock from inside the VM
  $ aws sts get-caller-identity --query Arn --output text
      arn:aws:sts::123456789012:assumed-role/osb-sandbox/79edb7ec-37b9-492d-870d-6fe02b80f09c
      exit code 0
  PASS  assumed-role ARN with the sandbox ID as the session name
  $ aws s3 cp /tmp/five.bin s3://example-bucket/osb-test/79edb7ec-37b9-492d-870d-6fe02b80f09c/five.bin --only-show-errors
      (no output)
      exit code 0
  $ aws s3 cp s3://example-bucket/osb-test/79edb7ec-37b9-492d-870d-6fe02b80f09c/five.bin /tmp/five.back --only-show-errors
      (no output)
      exit code 0
  upload/download 5 MiB: identical
  PASS  S3 upload and download under Kata, bytes identical
  $ aws bedrock-runtime converse --model-id us.anthropic.claude-haiku-4-5-20251001-v1:0 --messages ...
      Ready
      exit code 0
  PASS  Bedrock Converse under Kata

O pod rodou com runtimeClassName: kata-qemu, e o sandbox viu o kernel do guest (6.18.35), não o do node (6.18.56). A caller identity, um round trip de 5 MiB no S3 com bytes idênticos e uma chamada Converse ao Bedrock funcionaram, e o addon assinou 8 requisições e não recusou nenhuma. A criação pelo broker levou 15,2 segundos, cerca de 2,4 vezes a do runc (a parte 3 mediu 1,9 vez, sem o sidecar e a gravação do vault). As trocas levaram 30 segundos na ida e 29 na volta.

O Kata muda onde os processos do sandbox rodam, não como as requisições dele são assinadas, e não separa o sandbox das credenciais dele: o Kata representa um pod como uma única VM, com o sidecar e o vault incluídos.

Resumo dos resultados

TesteScriptExecução gravadaResultado
1. Bedrock bearer01_bedrock_bearer.py26,6 sHTTP 200 com um token placeholder; o vault registrou o binding bearer dele nas duas chamadas; o addon nem as assinou nem as recusou (4 verificações)
2. Identidade02_identity.py18,8 sassumed-role/osb-sandbox/<sandbox ID> pela CLI e pelo boto3; só placeholders (11 verificações)
3. S303_s3.py35,4 sDe 19 B a 20 MiB multipart, checksums batendo; 19 requisições assinadas, nenhuma recusada
4. Outros serviços04_nons3_body.py37,1 sDynamoDB e Converse funcionaram; batch de 0,83 MiB gravado e lido de volta, batch de 1,11 MiB encerrado, nada gravado (10 verificações)
5. CloudTrail05_cloudtrail.py110,0 sGetCallerIdentity e Converse sob o ID do sandbox, e o AssumeRole do broker citando esse ID, em cerca de 90 segundos
6. Ataques06_attacks.py99,7 sNenhuma credencial chegou ao sandbox; uma requisição com um Host que indicava outro host com binding foi encerrada, e o upstream ficou fixado no nome TLS (24 verificações)
7. Tempo de vida07_lifetime.py35,7 sSessões de uma hora, rotação em 1.800 s; um pedido de duas horas recusado por role chaining; revisão desatualizada 409; deletar o vault parou as chamadas (18 verificações)
8. Kata08_kata.py102,5 s, com as duas trocasO mesmo fluxo em uma VM; 8 requisições assinadas, nenhuma recusada (8 verificações)

Os oito scripts saíram com 0 e todas as verificações passando, em 7 minutos e 46 segundos no total (cada execução inclui o início do próprio port-forward). Os Testes 1 e 4 a 8 são gravações posteriores, do mesmo dia, feitas depois que aumentei o máximo da role para duas horas e acrescentei verificações.

O que isso não resolve

Em nenhum teste uma chave real apareceu no sandbox: nem no ambiente dele, nem nos ambientes dos processos, nem nos arquivos que vasculhei (Testes 2 e 6), e nenhuma chamada de credential vending passou (Teste 6). O que o design não faz é igualmente específico.

  • As credenciais reais ficam ao lado do código em que você não confia. O vault está na memória do sidecar de egress, no pod e no network namespace do sandbox, e, no Kata, na mesma VM (o Kata roda um pod como uma única VM, segundo a documentação dele). No Teste 6, a API do sidecar recusou o sandbox sem o token dela, como na parte 4. Um escape do container do sandbox cai ao lado de credenciais. No Kata, são as credenciais deste sandbox, dentro da VM dele. No runc, é root no node: o vault de todo sandbox no mesmo node, a instance role do node e, se o broker roda nesse node, o token de Pod Identity dele, com o qual um atacante pode assumir a osb-sandbox repetidas vezes enquanto controlar o node. Nada nesta demo manteve o broker fora dos nodes dos sandboxes: o manifest dele não tem affinity, e o cluster tem dois nodes. Rode o broker em nodes que não rodam sandboxes, com um node group separado ou affinity mais taints. Isso vem do manifest e de como o Pod Identity funciona; não testei um escape.
  • O sandbox pode usar as permissões da role enquanto estiver rodando. O addon assina o que o sandbox envia, e o broker continua fazendo a rotação, então o acesso dura o tempo de vida do sandbox; qualquer conjunto de credenciais continua válido na AWS por até uma hora, revogado ou não. A minha role de teste podia ler, gravar e deletar objetos em um bucket e itens em uma tabela, e chamar um modelo, então um agente que se comportasse mal poderia ter deletado os objetos desse bucket ou gastado com esse modelo. Restrinja a role à tarefa. E a allowlist é uma fronteira de credenciais, não de dados: *.s3.us-east-1.amazonaws.com alcança todos os buckets, e o addon encaminha sem assinatura uma requisição sem header Authorization, então um sandbox poderia gravar no bucket de outra pessoa que aceite gravações anônimas, ou por uma URL que outra pessoa pré-assinou para o próprio bucket, que o addon encaminha sem mudanças. Isso vem do código e da allowlist; não testei.
  • URLs pré-assinadas precisam vir do lado confiável. O sandbox não consegue pré-assinar nada útil com a chave placeholder (Teste 6). Uma URL pré-assinada no lado confiável (o broker precisaria de uma chamada para isso) passaria sem mudanças; os testes do addon cobrem isso, e não rodei isso no cluster. Uma URL assim é uma credencial para a única operação dela até expirar, e uma pré-assinada com credenciais temporárias carrega o session token na query string (documentação do S3).
  • O design do próprio OpenSandbox para isso ainda não assina requisições da AWS. O OSEP-0025 adiciona uma credencial exchange: o egress pede headers a um serviço resolver a cada requisição. O resolver recebe o método, o host, o path e os headers, mas não o corpo (o resolver de teste aceita exatamente esses quatro campos), e o OSEP lista a assinatura do corpo como trabalho futuro, com a primeira implementação voltada para o perfil Fast Sandbox. A maioria das APIs da AWS assina um hash do corpo, então um resolver que nunca o vê não consegue assiná-las; o S3, cujos clientes declaram esse hash em um header, é a exceção, pela minha leitura. Nada disso está em uma release estável até 7 de novembro de 2026. Os contratos foram mergeados na main em 30 de outubro de 2026, como c2f55b2 (#2495); o OSEP (agora marcado como implementing), o #2500 e o #2501 vieram em 1º de novembro, e o #2534 e o #2535 em 2 de novembro. A pre-release 1.2.1-rc.1, de 4 de novembro, é a primeira a trazê-lo.
  • O addon tem limites próprios. Corpos acima de cerca de 1 MiB para serviços que não são o S3 (Teste 4), requisições ao S3 acima de 1 MiB que não declaram o hash do payload (a AWS CLI e o boto3 sempre declaram), uploads com chunks assinados e SigV4a são recusados ou encerrados. Ele também roda sobre o mitmproxy 11.0.2 da imagem de egress 1.2.0, com os alertas abertos do h2 que a parte 4 lista, e confia no parsing que o mitmproxy faz do Host, do nome TLS e do corpo.
  • O bearer binding do Bedrock não é verificado contra o server name do TLS. O addon só verifica requisições que carregam os três headers dele, então o binding bearer do Teste 1 fica fora do alcance dele, como qualquer binding no caso do header Host da parte 4 (#1758). Uma requisição cujo Host indica bedrock-runtime poderia atrair a chave do Bedrock para uma conexão com outro host da AWS permitido. Se esse host citar o header Authorization em um corpo de resposta, a chave chega ao sandbox (o caso do host que reflete, da parte 4): o OpenSandbox só mascara os headers de resposta, e o addon só limpa respostas a requisições que ele assinou. Isso vem do código; não testei.
  • A lista de vending não está completa. O addon permite três ações do STS e bloqueia uma lista de chamadas de token, e a role nega mais, mas nenhum dos dois cobre todas as formas de transformar uma requisição assinada em uma credencial; cognito-identity:GetOpenIdTokenForDeveloperIdentity é uma que nenhum dos dois lista. O que realmente sustenta a defesa é a curta lista de Allow da role e a allowlist de oito hosts, que não alcança nenhum host do Cognito.
  • Uma pausa ainda apaga o vault (#1366, partes 3 e 4). O broker o grava de novo quando uma rotação não o encontra. Uma rotação que vence durante a pausa falha e é retentada a cada 60 segundos, então as credenciais voltam em até cerca de um minuto depois do resume, ou até 30 minutos depois se nenhuma rotação venceu. Um sandbox pausado por mais tempo do que as credenciais dele duram não recebe nenhuma até o broker reiniciar, porque o broker desiste quando as credenciais de um sandbox expiram com a rotação ainda falhando. Isso vem do código do broker; não testei.

Nada disso desfaz o resultado principal. Um sandbox que assina com um placeholder e recebe uma sessão de uma hora, exclusiva dele e nomeada no CloudTrail, é melhor que um com uma chave no ambiente, onde um env a imprimiria.

Limpeza

Cada teste deleta os próprios sandboxes, objetos no S3 e itens da tabela. Quando terminar a parte 5:

kubectl --context osb-eks delete namespace opensandbox-broker      # the broker
./01_iam.sh destroy                                                # both roles, the association, the table
python3 ../opensandbox-lifecycle/server_config.py --egress-image base   # the server back on the 1.2.0 egress image
../opensandbox-lifecycle/switch_runtime.sh runc                    # only if 08_kata.py was interrupted

O bucket de teste é seu e continua lá; delete os repositórios do ECR opensandbox-eks/broker, opensandbox-eks/aws-tools e opensandbox-eks/egress-sigv4 se não precisar deles (o degrau SigV4 da parte 6 usa o egress-sigv4, então mantenha-o até lá). 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

Funciona, com os clientes padrão. Um broker, o vault e cerca de 800 linhas de addon permitem que a AWS CLI e o boto3 rodem sem mudanças em um sandbox que nunca guardou uma chave: STS, S3 até um upload multipart de 20 MiB, DynamoDB e Bedrock, o CloudTrail nomeando o sandbox nas chamadas que registra, e as chamadas de identidade, S3 e Bedrock no Kata. O Bedrock só precisou de uma chave de curto prazo em um binding bearer. Toda tentativa que fiz de dentro para tirar uma credencial falhou, e o spoof do Host da parte 4 é encerrado para o binding da AWS.

A assinatura, porém, é minha, não do OpenSandbox: a 1.2.0 oferece o vault e um ponto de extensão, e o broker, a fixação do Host, as verificações de vending e a assinatura são código que seria seu e que você testaria de novo a cada imagem de egress. O design do próprio projeto, o OSEP-0025, chegou à pre-release 1.2.1-rc.1 em 4 de novembro, e o resolver dele ainda nunca vê o corpo de uma requisição. E o modelo de segurança é a role: enquanto estiver rodando, o sandbox pode fazer o que a role permite, a partir de um pod que guarda chaves válidas por uma hora.

Com o que você está se comprometendo

AspectoCredenciais AWS no egress na 1.2.0, como testado
O que roda issoO vault e o proxy de egress do OpenSandbox, mais um broker e um addon SigV4 que você constrói e mantém
ClientesA AWS CLI v2 e o boto3 sem mudanças, com chaves placeholder e AWS_CA_BUNDLE
Serviços testadosSTS, S3 (até um upload multipart de 20 MiB), DynamoDB, Bedrock (SigV4 e bearer)
Onde ficam os secretsO vault do sandbox, no sidecar de egress dele, no pod do sandbox (e, pelo design do Kata, na VM dele); o broker só os guarda enquanto grava o vault; a própria sessão de Pod Identity do broker, que pode assumir a osb-sandbox, fica no pod do broker
Identidade e auditoriaUma sessão de role por sandbox, com o nome dele; histórico de eventos para management events, um trail pago para data events de S3 e DynamoDB
Tempo de vidaUma hora (role chaining), substituída a cada 30 minutos com expectedRevision; deletar o vault corta o sandbox
LimitesCorpos acima de cerca de 1 MiB para serviços que não são o S3 são encerrados; sem SigV4a nem uploads com chunks assinados; URLs pré-assinadas só do lado confiável
Blast radiusTudo o que a role permite, durante o tempo de vida do sandbox; um conjunto de credenciais tirado do pod funciona por até uma hora, mesmo depois da revogação

Quem deveria usar

Serve para um time que quer que agentes chamem alguns serviços da AWS para uma tarefa sem guardar chaves, por exemplo um agente que lê e grava em um bucket e chama um modelo do Bedrock. Se o Bedrock é tudo de que ele precisa, use o bearer binding do Teste 1 e dispense o addon: você ainda precisa de algo como o broker para gerar a chave e fazer a rotação dela, e o sandbox só deveria ter permissão para o host do Bedrock Runtime (o broker de apoio permite os oito; restrinja AWS_HOSTS para esse modo), já que esse binding não é verificado contra o nome TLS. Caso contrário, mantenha a role por tarefa e a allowlist restrita aos serviços que ela usa, mantenha o broker em nodes que não rodam sandboxes, defina AWS_CA_BUNDLE e trate o addon como código seu, testado a cada nova imagem de egress.

Ainda não serve para workloads que enviam corpos grandes para serviços que não são o S3 (documentos grandes no Bedrock, batches grandes no DynamoDB), para nada que precise de SigV4a, nem para um threat model em que o sandbox e as credenciais dele não podem dividir um pod. A parte 6 coloca o addon na escada de overhead de egress dela, nos mesmos dois nodes.

Comments