OpenSandbox e Credenciais AWS: Assinatura SigV4 no Egress
Por Fabio Douek
Ir para seção
- Visão Geral
- Arquitetura
- Configuração
- Passo 1: O código de apoio
- Passo 2: Duas roles do IAM
- Passo 3: O broker, no EKS Pod Identity
- Passo 4: A imagem de egress derivada, com o addon SigV4
- Passo 5: Uma imagem de workload com boto3
- Testes
- Teste 1: Bedrock com uma chave de curto prazo, e sem assinatura
- Teste 2: Quem o sandbox é para a AWS
- Teste 3: S3, de 19 bytes a um upload multipart de 20 MiB
- Teste 4: DynamoDB, Bedrock Converse e o limite de 1 MiB
- Teste 5: O CloudTrail nomeia o sandbox
- Teste 6: Tentando tirar as credenciais
- Teste 7: Rotação, o limite de uma hora e revogação
- Teste 8: O mesmo fluxo no Kata
- Resumo dos resultados
- O que isso não resolve
- Limpeza
- Veredito
- Com o que você está se comprometendo
- Quem deveria usar
Explica (TLDR) como se eu fosse...
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.
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
Authorizationplaceholder 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.
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.- O broker cria o sandbox e assume a
osb-sandboxpara 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). - Ele grava o vault pelo proxy do servidor de lifecycle: os três valores temporários e um binding
customHeaders, oaws-sigv4, para esses hosts. A cada 30 minutos, ele substitui os valores compatch. - A AWS CLI ou o boto3 assina uma requisição com a chave placeholder, e o proxy transparente do sidecar a intercepta.
- O
system.pydo OpenSandbox casa o binding pelo headerHostda requisição e adiciona os três headersx-osb-aws-*. Até aqui, este é o vault da parte 4, sem mudanças. - 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.
- A requisição assinada sai para o host indicado no server name do TLS, passando pelo nftables como qualquer outro pacote.
- A AWS vê a sessão da role, e o CloudTrail registra o ID do sandbox como o nome da sessão.
| Credencial | Quem guarda | Tempo de vida |
|---|---|---|
A do próprio broker, role osb-broker | o pod do broker, vinda do agente do EKS Pod Identity | gerenciado pelo EKS Pod Identity |
As credenciais temporárias de um sandbox, role osb-sandbox | o broker, só enquanto grava o vault; depois disso, só o vault do sandbox, na memória do sidecar de egress | uma hora, substituídas a cada 30 minutos |
| Uma chave de curto prazo do Bedrock (só no Teste 1) | os mesmos dois lugares | nã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 sandbox | nunca válidos |
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
| Arquivo | O 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.yaml | O broker (Passo 3) |
egress/, build_egress.sh | O addon SigV4, os testes dele e a imagem de egress derivada (Passo 4) |
00_image.sh, image/Dockerfile | A imagem de workload com a AWS CLI e o boto3 (Passo 5) |
01_bedrock_bearer.py a 08_kata.py | Um script por teste |
common.py | Helpers 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-brokerconfia no EKS Pod Identity para uma única service account, aosb-brokerno namespaceopensandbox-broker. Ela pode assumir aosb-sandbox, além de uma ação read-only do IAM para a verificação do Passo 3. - A
osb-sandboxconfia apenas naosb-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:

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 addon | O sandbox vê |
|---|---|---|
traz um segundo header Host, Authorization, x-amz-content-sha256 ou X-Amz-Target | a recusa | 403 |
tem um Host diferente do server name do TLS (SNI), ou um SNI fora de .amazonaws.com | a encerra (host-sni-mismatch) | uma conexão fechada |
| é pré-assinada (a assinatura na query string) | a encaminha como veio, nunca assinada de novo | a resposta da AWS |
tem Authorization: Bearer | a recusa (bearer-on-sigv4-binding) | 403 |
| é uma chamada de credential vending | a recusa (credential-vending) | 403 |
| usa SigV4a ou um upload com chunks assinados | a recusa | 501 |
| 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 SigV4 | a assina de novo com os valores reais | a 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 oHostseja 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,GetAccessKeyInfoeDecodeAuthorizationMessagepassam. 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-runtimeassina comobedrock). Clientes S3 declaram o hash do corpo emx-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 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:
| Ataque | Resultado |
|---|---|
A. Credential vending a partir do sandbox: sts assume-role, get-session-token, get-federation-token, ecr get-login-password | As 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 placeholder | Encaminhada 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 casos | Uma 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 Identity | Os 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 header | Um 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 dela | 401, 403 e 401, como na parte 4 |
G. Um header Bearer para um host com binding SigV4 | 403 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:
- O
Hostindica 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, oHostdizia S3, e osystem.pyadicionou os três headers embora oHostnã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. - 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. Hostfora da AWS: nada adicionado. ComHost: 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 peloHoste não o compara com o server name do TLS.- 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. - Sem server name: nunca descriptografada. O
system.pydeixa 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
| Teste | Script | Execução gravada | Resultado |
|---|---|---|---|
| 1. Bedrock bearer | 01_bedrock_bearer.py | 26,6 s | HTTP 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. Identidade | 02_identity.py | 18,8 s | assumed-role/osb-sandbox/<sandbox ID> pela CLI e pelo boto3; só placeholders (11 verificações) |
| 3. S3 | 03_s3.py | 35,4 s | De 19 B a 20 MiB multipart, checksums batendo; 19 requisições assinadas, nenhuma recusada |
| 4. Outros serviços | 04_nons3_body.py | 37,1 s | DynamoDB 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. CloudTrail | 05_cloudtrail.py | 110,0 s | GetCallerIdentity e Converse sob o ID do sandbox, e o AssumeRole do broker citando esse ID, em cerca de 90 segundos |
| 6. Ataques | 06_attacks.py | 99,7 s | Nenhuma 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 vida | 07_lifetime.py | 35,7 s | Sessõ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. Kata | 08_kata.py | 102,5 s, com as duas trocas | O 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-sandboxrepetidas 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.comalcança todos os buckets, e o addon encaminha sem assinatura uma requisição sem headerAuthorization, 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 namainem 30 de outubro de 2026, comoc2f55b2(#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
h2que a parte 4 lista, e confia no parsing que o mitmproxy faz doHost, 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
bearerdo Teste 1 fica fora do alcance dele, como qualquer binding no caso do headerHostda parte 4 (#1758). Uma requisição cujoHostindicabedrock-runtimepoderia atrair a chave do Bedrock para uma conexão com outro host da AWS permitido. Se esse host citar o headerAuthorizationem 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
| Aspecto | Credenciais AWS no egress na 1.2.0, como testado |
|---|---|
| O que roda isso | O vault e o proxy de egress do OpenSandbox, mais um broker e um addon SigV4 que você constrói e mantém |
| Clientes | A AWS CLI v2 e o boto3 sem mudanças, com chaves placeholder e AWS_CA_BUNDLE |
| Serviços testados | STS, S3 (até um upload multipart de 20 MiB), DynamoDB, Bedrock (SigV4 e bearer) |
| Onde ficam os secrets | O 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 auditoria | Uma 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 vida | Uma hora (role chaining), substituída a cada 30 minutos com expectedRevision; deletar o vault corta o sandbox |
| Limites | Corpos 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 radius | Tudo 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.