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

OpenShell e Credenciais da AWS: Assinatura SigV4 no Supervisor

Por Fabio Douek

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

O robô no sandbox quer usar a loja de brinquedos da Amazon, que pede um bilhete especial assinado a cada visita. O robô só recebe bilhetes de mentirinha, e o adulto na porta assina um de verdade toda vez, usando uma chave que ele pega emprestada de uma gaveta trancada, uma hora de cada vez.

Isso funciona para quase tudo. Mas existe uma brecha conhecida (e o conserto já está a caminho) em que uma chave de verdade pode acabar voltando para as mãos do robô. Então a gaveta só pode guardar chaves pequenas e que duram pouco.

Este post registra como o OpenShell permite que um agente no Amazon EKS use a AWS sem deter chaves da AWS: a plataforma assume uma role de escopo restrito e assina cada request em nome do agente. Identidade, chamadas ao modelo e logs de auditoria funcionaram como projetado, e o armazenamento também, com exceção de alguns nomes de chave e dos modos de upload não padrão.

Constatações relevantes: uma fraqueza conhecida, com correção ainda não lançada, pode permitir que o agente recupere o session token real; revogar o acesso de um sandbox em execução exige antes uma mudança de policy; e a atribuição nos logs da AWS é por provider, não por sandbox. Trate as permissões da role como as permissões do agente.

Eu testei a integração do OpenShell com a AWS de ponta a ponta: uma identidade para o gateway vinda do EKS Pod Identity, uma sessão de role de uma hora renovada com antecedência e a assinatura de requests no supervisor. As chamadas para S3, Bedrock e STS funcionaram, e as tentativas de obter novas credenciais foram barradas pelo IAM.

Achados adversos: certos nomes de chave no S3 quebram a assinatura, os modos explícitos de upload rejeitam os padrões da CLI, e uma fraqueza conhecida, com correção pendente, pode devolver o session token real ao sandbox. O prognóstico depende de manter a role pequena e a sessão curta.

É reconfortante ver um agente rodar a AWS CLI, fazer upload, receber em streaming a resposta de um modelo e provar a própria identidade sem nunca receber uma chave. O design responde a um medo que muitos times de plataforma carregam em silêncio.

É igualmente importante acolher o que ele não resolve. Uma fraqueza conhecida ainda pode expor o token real, a revogação exige mais de um passo, e dois sandboxes podem parecer idênticos na trilha de auditoria. Saber disso mantém a confiança ancorada nos limites da role, e não no sandbox.

Imagine um músico de sessão que nunca toca nas fitas master: cada take passa pelo engenheiro, que o aprova com o carimbo do estúdio. O músico envia versões brutas; o que chega à gravadora vem masterizado direito e creditado à sessão do estúdio.

O ponto fraco é conhecido, e a correção está a caminho: nesta versão, o carimbo real pode acabar onde o músico consegue lê-lo. Mantenha a conta do estúdio pequena e a reserva curta, e o risco continua pequeno.

O pitch: agentes de IA no Kubernetes podem usar S3 e Bedrock sem uma única chave da AWS no ambiente, com sessões curtas renovadas automaticamente e chamadas atribuíveis a uma sessão no CloudTrail. Funcionou com a AWS CLI e o boto3 sem modificações.

O posicionamento honesto: combine com uma role de privilégio mínimo e denies explícitos para a emissão de credenciais, defina a variável de CA para uploads e dê a cada tenant o seu próprio provider. Uma fraqueza ainda não resolvida pode expor o session token, então mantenha as sessões curtas.

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

Visão Geral

O OpenShell, projeto CNCF Sandbox desde 2026-09-26, mantém as credenciais fora do ambiente do agente: o sandbox recebe um placeholder, e o supervisor coloca o valor real no lugar dele a caminho de um endpoint permitido. A parte 4 testou isso com tokens do GitHub e da Anthropic. A AWS é mais difícil, porque a maioria das APIs da AWS não aceita um token em um header. Todo request é assinado com SigV4, usando uma chave secreta que o cliente precisa ter, e no EKS a fonte natural dessa chave é uma sessão de role de curta duração.

O OpenShell 0.1.6 dá conta das duas coisas. O gateway consegue assumir uma IAM role e renovar a sessão antes que ela expire, e o supervisor consegue assinar os requests por conta própria. Assim, o agente roda a AWS CLI ou o boto3 normalmente, guarda três placeholders, e a AWS vê um request assinado corretamente pela role.

Este post, parte 5 de 6, monta isso no cluster da parte 2: o gateway recebe uma IAM role por meio do EKS Pod Identity, um provider assume uma role de sandbox com privilégio mínimo, e uma policy assina os requests para um bucket do S3, para o Bedrock e para o STS. Depois eu testo identidade, S3, Bedrock, confiança na CA, CloudTrail, uma série de ataques e o tempo de vida das credenciais. A maior parte funciona. Vários detalhes do signer não, e uma fraqueza conhecida na 0.1.6 pode expor o session token real. A parte 1 explica o gateway, o supervisor e o workload em que isso se apoia, a parte 3 o ciclo de vida e o isolamento do sandbox, e a parte 6 faz um stress test no cluster.

Arquitetura

CLUSTER EKS osh-eks · NAMESPACE openshell Pod do gateway IAM role osh-eks-gateway via EKS Pod Identity provider p5-aws aws_sts_assume_role, 1 h POD DO WORKLOAD aws CLI · boto3 · curl AWS_ACCESS_KEY_ID=openshell:… AWS_SECRET_ACCESS_KEY=openshell:… AWS_SESSION_TOKEN=openshell:… assina com placeholders, ou nem chega a assinar POD DO SUPERVISOR policy: endpoints assinados um bucket · bedrock-runtime · sts reassinatura SigV4 remove headers de assinatura do cliente, assina com a sessão real para o serviço do endpoint chaves da sessão AWS · us-east-1 STS AssumeRole osh-eks-sandbox-s3bedrock S3: um bucket Bedrock: Converse, nova-micro STS: GetCallerIdentity IAM Deny explícito na emissão de credenciais AssumeRole, renovado 5 min antes de expirar
O caminho das credenciais da AWS. As chaves reais existem apenas no gateway e no supervisor; o workload guarda placeholders.

Três peças:

  1. A identidade do gateway. O Pod do gateway recebe a IAM role osh-eks-gateway por meio de uma associação do EKS Pod Identity. Essa role faz uma única coisa: assumir roles cujos nomes começam com osh-eks-sandbox-. Os sandboxes nunca recebem uma identidade IAM própria: um binding de Pod Identity ou IRSA na ServiceAccount do sandbox injetaria um token projetado, e o driver do OpenShell rejeita Pods de workload que tenham um.
  2. O provider. Um provider do tipo aws, criado com --runtime-credentials, não guarda nenhuma chave estática. A estratégia de refresh dele, aws_sts_assume_role, faz o gateway chamar o AssumeRole do STS para a role do sandbox, por uma hora, e repetir a chamada 5 minutos antes de a sessão expirar. Os três valores da sessão se tornam as credenciais do provider.
  3. O signer. Na policy do sandbox, cada endpoint da AWS indica o provider (credential_binding) e ativa a assinatura (credential_signing: sigv4, signing_service: s3, bedrock ou sts). O supervisor remove os headers de assinatura do cliente e assina o request de novo com a sessão real, para o serviço e a região do endpoint.

A role do sandbox, osh-eks-sandbox-s3bedrock, é deliberadamente pequena: um bucket, Converse e ConverseStream em um modelo do Bedrock, e GetCallerIdentity. Ela também nega explicitamente todas as APIs de emissão de credenciais que eu consegui imaginar (sts:AssumeRole*, GetSessionToken, GetFederationToken, ecr:GetAuthorizationToken, secretsmanager:GetSecretValue, iam:* e outras). O supervisor assina qualquer API que o sandbox chame em um endpoint permitido, e não filtra as respostas, então, se a role pudesse emitir credenciais, o sandbox receberia credenciais reais no body da resposta. O IAM é o único lugar para impedir isso.

Configuração

Tudo roda no cluster da parte 2, com o OpenShell 0.1.6 e a CLI conectada por meio de um kubectl port-forward. O Terraform da parte 2 já instalou o agente do EKS Pod Identity.

Passo 1: IAM e um bucket

O terraform/ no diretório complementar cria o bucket (osh-eks-creds-<random>, acesso público bloqueado, objetos expiram após 7 dias), as duas roles e a associação do Pod Identity. A única permissão da role do gateway:

statement {
  actions   = ["sts:AssumeRole", "sts:TagSession"]
  resources = ["arn:${local.partition}:iam::${local.account_id}:role/${local.sandbox_role_prefix}*"]
}

A role do sandbox confia apenas na role do gateway, permite o bucket, bedrock:InvokeModel e InvokeModelWithResponseStream (as ações pelas quais Converse e ConverseStream são autorizados) em amazon.nova-micro-v1:0, e sts:GetCallerIdentity, e carrega o deny explícito acima. Conferi o resultado com aws iam simulate-principal-policy antes de usá-la: as ações permitidas voltaram como allowed, e as de emissão como explicitDeny.

Passo 2: O gateway, os profiles e o provider

O Pod do gateway da parte 2 subiu antes de a associação do Pod Identity existir, então ele não tem credenciais da AWS. O 01_setup.sh o reinicia, importa os provider profiles aws e aws-s3 (cópias dos exemplos do OpenShell; o gateway não vem com nenhum), cria o provider e configura o refresh dele:

openshell provider create --name p5-aws --type aws --runtime-credentials
openshell provider refresh configure p5-aws --credential-key AWS_ACCESS_KEY_ID \
  --strategy aws-sts-assume-role \
  --material role_arn="$SANDBOX_ROLE_ARN" --material session_name=p5-shared --material aws_region=us-east-1
openshell provider refresh rotate p5-aws --credential-key AWS_ACCESS_KEY_ID
$ terraform outputs -> env.sh
  ok    bucket osh-eks-creds-6c00850f
  ok    sandbox role osh-eks-sandbox-s3bedrock, gateway role osh-eks-gateway

$ kubectl rollout restart statefulset/openshell (pick up Pod Identity), then restart the port-forward
  ok    Pod Identity association present (a-cawfi2wgclsjjcvzf)
  ok    gateway restarted, port-forward back up
  ok    gateway Pod has AWS_CONTAINER_CREDENTIALS_FULL_URI (Pod Identity webhook fired)

$ import provider profiles (workspace-scoped)
  ok    imported aws
  ok    imported aws-s3

$ create provider p5-aws (type aws, --runtime-credentials)
  ok    created p5-aws

$ provider refresh configure p5-aws --strategy aws-sts-assume-role
✓ Configured refresh for p5-aws AWS_ACCESS_KEY_ID
  ok    role_arn set to the sandbox role; session_name p5-shared; region us-east-1

$ provider refresh rotate p5-aws (mint the first STS session now)
✓ Rotation requested for p5-aws AWS_ACCESS_KEY_ID (refreshed)

$ provider refresh status p5-aws
PROVIDER                  CREDENTIAL_KEY                STRATEGY                      STATUS                    RECOVERY            EXPIRES_AT            NEXT_REFRESH          LAST_REFRESH          FAILURE_CODE                                  LAST_ERROR
p5-aws                    AWS_ACCESS_KEY_ID             aws_sts_assume_role           refreshed                 -                   2026-11-01 06:08:15   2026-11-01 06:03:15   2026-11-01 05:08:15                                                 -

  ok    setup done. The provider mints the sandbox-role session; the tests attach it with --provider p5-aws
  ok    and pass --policy logs/aws-signing.p5-aws.yaml (policy_file in lib.sh) so the supervisor signs S3, Bedrock and STS.

refreshed, com a expiração daqui a uma hora e o próximo refresh 5 minutos antes dela. O gateway chamou o STS com as credenciais do Pod Identity dele por meio da cadeia padrão de credenciais do AWS SDK, algo que a pesquisa para esta série tinha deduzido do código-fonte, mas ainda não tinha visto funcionar.

Passo 3: A policy de assinatura

O provider usa o profile aws, que não tem endpoints, então é a policy do sandbox que diz onde as credenciais dele se aplicam. O primeiro dos três endpoints do bucket (os outros dois são os hosts global e path-style do S3), resumido:

s3_bucket:
  endpoints:
    - host: "${BUCKET}.s3.${REGION}.amazonaws.com"
      port: 443
      protocol: rest
      access: read-write
      enforcement: enforce
      credential_binding:
        provider: p5-aws
      credential_signing: sigv4
      signing_service: s3
  binaries:
    - path: /usr/bin/curl
    - path: /usr/local/aws-cli/v2/*/dist/aws
    # ... /usr/local/bin/aws and /usr/bin/python3.12

O Bedrock runtime fica limitado a POST /model/*/converse e /converse-stream, e o STS a POST /, que é toda ação do STS: o STS coloca o nome da ação no body, onde as regras L7 não conseguem enxergá-lo. Os scripts renderizam o nome do bucket e a região no arquivo e o passam com --policy. (A substituição de processo, --policy <(...), não funcionou: a CLI não conseguiu ler o path.)

Um profile aws combinado é necessário aqui. O OpenShell rejeita um credential_binding na policy para um provider cujo profile já lista endpoints, como o aws-s3, então um único provider só consegue assinar S3, Bedrock e STS por meio do profile sem endpoints.

Testes

Teste 1: Quem a AWS acha que o sandbox é

O 02_identity.sh cria um sandbox com o provider e a policy de assinatura, inspeciona o ambiente e chama o STS:

$ create p5-identity with --provider p5-aws and the signing policy
  ok    ready

$ the AWS_* env vars inside the sandbox are placeholders, not keys
  AWS_ACCESS_KEY_ID      placeholder  len=105  sha256=64fb6d329225…
  AWS_SECRET_ACCESS_KEY  placeholder  len=109  sha256=9e9fc115f76f…
  AWS_SESSION_TOKEN      placeholder  len=105  sha256=eb185b47cf6c…

$ aws sts get-caller-identity (signed at the supervisor)
  Arn:     arn:aws:sts::<account>:assumed-role/osh-eks-sandbox-s3bedrock/p5-shared
  role:    osh-eks-sandbox-s3bedrock
  session: p5-shared   (the provider's session_name)

$ the same through boto3 (python3.12, no AWS_CA_BUNDLE — relies on REQUESTS_CA_BUNDLE)
  boto3 Arn: arn:aws:sts::<account>:assumed-role/osh-eks-sandbox-s3bedrock/p5-shared
  ok    AWS CLI and boto3 both resolve to the sandbox-role session

As três variáveis AWS_* são placeholders: cerca de 105 caracteres cada, começando com openshell:resolve:env:, nada parecido com um access key ID de 20 caracteres. O script imprime apenas o tamanho delas e um prefixo do hash. Mesmo assim, tanto o aws sts get-caller-identity quanto o boto3 voltaram como a sessão da role do sandbox, com o nome do session_name do provider. A CLI e o boto3 assinaram o request com os placeholders; o supervisor descartou essa assinatura e assinou do jeito certo.

Teste 2: S3

O 03_s3.sh exercita o bucket: um upload pequeno, um upload e um download de 50 MiB, boto3, chaves que precisam de encoding, deletes e os dois modos explícitos de assinatura.

Saída: 03_s3.sh
$ create p5-s3 (default sigv4 auto-detect mode)
  ok    ready

$ aws s3 ls (list), then a small put
  upload: ../tmp/small.txt to s3://osh-eks-creds-6c00850f/small.txt

$ a 50 MiB upload (aws-chunked, STREAMING-UNSIGNED-PAYLOAD-TRAILER), then download + checksum
  upload ok
  download ok
  checksum matches (sha256 e6123935a397…)

$ boto3 put/list/get (python3.12)
  boto3 round-trip: 'hello from boto3'; objects now: 3

$ keys that need percent-encoding (expect SignatureDoesNotMatch or a rewritten key)
  key my\ file.txt   exit 1   error occurred (SignatureDoesNotMatch)
  key a+b.txt        exit 1   error occurred (SignatureDoesNotMatch)
  key $'caf\303\251.txt' exit 1   error occurred (SignatureDoesNotMatch)
  key a//b.txt       exit 0   upload: ../tmp/enc.bin to s3://osh-eks-creds-6c00850f/a//b.txt
  object stored for "a//b.txt": a/b.txt

$ DELETE vs POST: aws s3 rm (DELETE, read-write preset blocks it) vs delete-objects (POST ?delete)
  s3 rm:          delete failed: s3://osh-eks-creds-6c00850f/small.txt An error occurred (403) when calling the DeleteObject ope
  delete-objects: "Key": "from-boto3.txt"

$ sigv4:body mode
  1 MiB,  CLI defaults (aws-chunked + trailer): FAILED error occurred (MalformedTrailerError)
  1 MiB,  checksum when_required        : ok
  11 MiB, one PutObject, when_required : FAILED

$ sigv4:no_body mode
  1 MiB,  CLI defaults (aws-chunked + trailer): FAILED error occurred (InvalidArgument)
  1 MiB,  checksum when_required        : ok
  11 MiB, one PutObject, when_required : ok

O básico funciona. Um objeto pequeno, um objeto de 50 MiB com o checksum batendo depois da ida e volta, e um put, get e list com boto3. O upload de 50 MiB é o interessante: a AWS CLI 2.39 envia uploads com encoding aws-chunked e um checksum no final, e o modo sigv4 padrão os repassa em streaming, sem buffering.

Uma coisa que o script precisa definir antes: AWS_CA_BUNDLE. Sem ela, o aws s3 cp falha no TLS (o Teste 4 explica por quê).

Chaves que precisam de encoding quebram a assinatura. Uma chave com espaço, um + ou um caractere não ASCII falhou com SignatureDoesNotMatch. O S3 espera que o path seja codificado uma vez; o signer, usando os padrões do AWS SDK para todos os serviços, o codifica uma segunda vez e o normaliza, então a assinatura dele cobre um path diferente daquele que o S3 vê. O a//b.txt é pior: o upload informou sucesso, e o objeto fica armazenado como a/b.txt, porque o supervisor normaliza o path antes de encaminhar o request. O cliente acha que gravou uma chave e o S3 tem outra.

DELETE vs POST. O preset read-write permite GET, HEAD, OPTIONS, POST, PUT e PATCH, mas não DELETE. O aws s3 rm recebeu um 403 do supervisor, enquanto o aws s3api delete-objects, que deleta por meio de um POST, passou. Se você quer um sandbox que não consiga deletar, use a IAM role, não o preset.

Os modos explícitos de assinatura. O sigv4:body faz buffering do body e assina o hash dele; o sigv4:no_body assina apenas os headers. Com os padrões da CLI, o sigv4:body falhou até para um arquivo de 1 MiB com MalformedTrailerError, porque a CLI envia um body em chunks com um checksum no final, que esse modo não trata. Com AWS_REQUEST_CHECKSUM_CALCULATION=when_required, a CLI envia um body simples e o upload funcionou. O sigv4:no_body também falhou com os padrões da CLI, com InvalidArgument, e deu conta de tudo depois que o checksum foi desligado, inclusive um único PutObject de 11 MiB. O sigv4:body faz buffering de no máximo 10 MiB (10.485.760 bytes), e um PutObject de 11 MiB mostrou o que acontece acima disso. A CLI informou um erro de SSL: o supervisor fechou a conexão sem uma resposta HTTP, então o cliente não recebe nenhum erro do S3 nem qualquer pista sobre a causa. Um PutObject de 9 MiB funcionou, e o aws s3 cp fica abaixo do limite porque passa para multipart uploads acima de 8 MiB (o multipart_threshold padrão da CLI, que a documentação dela escreve como 8MB). Fique no modo sigv4 padrão, a menos que você tenha um motivo para não ficar.

Teste 3: Bedrock

O 04_bedrock.py roda um pequeno programa boto3 dentro de um sandbox: Converse, ConverseStream com o tempo até o primeiro token, e Converse com o modelo informado como um ARN de inference profile.

$ openshell -g osh-eks sandbox create --name p5-bedrock --provider p5-aws --policy <signing>

$ (inside p5-bedrock) python3.12 bedrock converse / converse_stream / arn
  converse {"ok": true, "text": "Pong", "stop": "end_turn", "inTok": 8, "outTok": 2}
  converse_stream {"ok": true, "ttft_ms": 278, "events": 6}
  converse_arn {"ok": false, "error": "ConnectionClosedError", "detail": "Connection was closed before we received a valid response from endpoint URL: \"https://bedrock-runtime.us-east-1.amazonaws.com/model/arn%3Aaws%3Abedrock%3Aus-east-1%3A<account>%3Ainference-profile%2"}

Converse e ConverseStream funcionaram, assinados como serviço bedrock. O tempo até o primeiro token em streaming, medido dentro do sandbox, foi de 278 ms. O ARN do modelo falhou com a conexão fechada: o ARN contém /, que vira %2F no path, e o supervisor recusa barras codificadas por padrão (allow_encoded_slash fica desligado). Ele não responde com um erro; fecha a conexão. Use model IDs, ou IDs de inference profile sem o ARN.

Teste 4: Qual variável de CA as ferramentas da AWS leem

O supervisor termina o TLS com a CA do próprio sandbox, e o OpenShell define seis variáveis apontando para ela (a saída deixa de fora DENO_CERT e GIT_SSL_CAINFO), mas não AWS_CA_BUNDLE. A parte 4 descobriu que o aws s3 ls não precisa dela. O 05_ca_trust.sh verifica o resto removendo uma variável de cada vez:

Saída: 05_ca_trust.sh
$ create p5-ca

$ what OpenShell set (paths only, not contents)
  SSL_CERT_FILE        /run/openshell-supervisor-ca/material/ca-bundle.crt
  REQUESTS_CA_BUNDLE   /run/openshell-supervisor-ca/material/ca-bundle.crt
  CURL_CA_BUNDLE       /run/openshell-supervisor-ca/material/ca-bundle.crt
  AWS_CA_BUNDLE        <unset>
  NODE_EXTRA_CA_CERTS  /run/openshell-supervisor-ca/material/ca.crt
  aws real path:       /usr/local/aws-cli/v2/2.39.3/dist/aws

$ AWS CLI v2 — which CA var does it need?
  aws cli, env as set by OpenShell               exit 0   ok
  aws cli, REQUESTS_CA_BUNDLE unset              exit 255 CERTIFICATE_VERIFY_FAILED
  aws cli, SSL_CERT_FILE unset                   exit 0   ok
  aws cli, CURL_CA_BUNDLE unset                  exit 0   ok
  aws cli, all three unset, AWS_CA_BUNDLE set    exit 0   ok
  aws cli, all four unset                        exit 255 CERTIFICATE_VERIFY_FAILED

$ boto3 — which CA var does it need?
  boto3, env as set by OpenShell                 exit 0   ok
  boto3, REQUESTS_CA_BUNDLE unset                exit 1   CERTIFICATE_VERIFY_FAILED
  boto3, REQUESTS unset, AWS_CA_BUNDLE set       exit 0   ok
  boto3, REQUESTS + AWS_CA_BUNDLE both unset     exit 1   CERTIFICATE_VERIFY_FAILED

$ aws s3 cp: the transfer client, CRT by default here, reads AWS_CA_BUNDLE only
  s3 cp, default client, as set by OpenShell     exit 1   AWS_IO_TLS_ERROR_NEGOTIATION_FAILURE
  s3 cp, default client, AWS_CA_BUNDLE set       exit 0   ok
  s3 cp, classic client, as set by OpenShell     exit 0   ok
  s3 cp, CRT client, as set by OpenShell         exit 1   AWS_IO_TLS_ERROR_NEGOTIATION_FAILURE
  s3 cp, CRT client, AWS_CA_BUNDLE set           exit 0   ok
  • As chamadas comuns da AWS CLI e o boto3 usam AWS_CA_BUNDLE se ela estiver definida e, caso contrário, REQUESTS_CA_BUNDLE, que o OpenShell define, então funcionam como estão.
  • O aws s3 cp e os outros comandos de transferência podem usar uma stack HTTP diferente: neste setup, a CLI escolheu o cliente de transferência CRT dela, que lê apenas AWS_CA_BUNDLE, e falhou no TLS até ela ser definida. O cliente de transferência clássico funciona sem ela.

A correção é uma variável com o path literal, AWS_CA_BUNDLE=/run/openshell-supervisor-ca/material/ca-bundle.crt (no ENV de uma imagem ou no sandbox create --env; $REQUESTS_CA_BUNDLE não seria expandida ali), e eu a definiria em qualquer imagem que rode a AWS CLI sob o OpenShell.

Teste 5: CloudTrail

O 06_cloudtrail.sh cria um segundo provider com o próprio nome de sessão, sobe dois sandboxes no provider compartilhado e um no segundo, faz uma chamada a partir de cada um e depois consulta o histórico de eventos do CloudTrail:

$ a second provider p5-aws-persb with its own session_name (p5-persb)
  ok    configured

$ two sandboxes on the shared provider, one on the per-sandbox provider
  ok    p5-ct-a, p5-ct-b (shared p5-shared); p5-ct-c (p5-persb)

$ one signed call from each (GetCallerIdentity is a management event)
  p5-ct-a: arn:aws:sts::<account>:assumed-role/osh-eks-sandbox-s3bedrock/p5-shared
  p5-ct-b: arn:aws:sts::<account>:assumed-role/osh-eks-sandbox-s3bedrock/p5-shared
  p5-ct-c: arn:aws:sts::<account>:assumed-role/osh-eks-sandbox-s3bedrock/p5-persb

$ CloudTrail event history by session name (lags a few minutes; polling up to ~6 min)
  Username=p5-shared (both shared sandboxes land here): 18 event(s)
  Username=p5-persb (only p5-ct-c):                    2 event(s)
  The shared session name can't tell p5-ct-a from p5-ct-b.

$ who minted those sessions: sts:AssumeRole into the sandbox role
  caller osh-eks-gateway (session eks-osh-eks-openshell--0...) -> session name p5-tmp, 3600 s, tags: 0
  caller osh-eks-gateway (session eks-osh-eks-openshell--0...) -> session name p5-shared, 3600 s, tags: 0
  caller osh-eks-gateway (session eks-osh-eks-openshell--0...) -> session name p5-persb, 3600 s, tags: 0
  S3 object reads and writes are data events: they need a trail or event data store, not shown
  in the free event history.

As contagens de eventos cobrem tudo o que está no histórico de eventos sob cada nome de sessão, incluindo execuções anteriores, não só estas três chamadas; o p5-tmp também é uma sessão de uma execução anterior do Teste 7.

O CloudTrail atribui as chamadas à sessão, e a sessão pertence ao provider. Dois sandboxes em um mesmo provider compartilham um nome de sessão, e a AWS não consegue distingui-los. Um provider por sandbox (ou por agente, ou por tenant) dá a cada um o próprio nome no CloudTrail, ao custo de mais uma sessão do STS para renovar.

As próprias chamadas AssumeRole ficam registradas sob a sessão do Pod Identity da role do gateway, com duração de 3.600 segundos. O request não adiciona tags próprias, mas a sessão herda as tags transitivas da sessão do Pod Identity, o que importa no Teste 6. Leituras e gravações de objetos no S3 são eventos de dados, que precisam de uma trilha ou de um event data store; o histórico de eventos gratuito não os mostra.

Teste 6: Ataques

O 07_attacks.sh tentou seis coisas de dentro de um mesmo sandbox. Qualquer coisa que pudesse ser uma credencial foi impressa apenas como tamanho e prefixo de hash. Deixei uma das seis, o item 2 abaixo, fora desta saída e fora do script complementar.

$ create p5-attack

$ 1. Signing needs no placeholder: unset AWS_* and curl the S3 endpoint unsigned
  PUT  HTTP 200
  GET  HTTP 200

$ 3. AssumeRole / GetSessionToken through the signed STS endpoint (stopped by the IAM deny)
  assume-role:      AccessDenied
  get-session-token:AccessDenied

$ 4. Presigned URL through the signed endpoint (S3 rejects: two auth mechanisms)
  presign produced a URL: yes (its X-Amz-Credential carries the placeholder key)
  GET presigned HTTP 400

$ 5. IMDS and the EKS Pod Identity agent (always blocked by the supervisor, whatever the policy)
curl: (7) Failed to connect to 169.254.169.254 port 80 after 0 ms: Couldn't connect to server
  169.254.169.254 (IMDS):         HTTP 000 / (connect error = blocked)
curl: (7) Failed to connect to 169.254.170.23 port 80 after 0 ms: Couldn't connect to server
  169.254.170.23 (Pod Identity):  HTTP 000 / (connect error = blocked)

$ 6. Scan the sandbox for real keys (env, /proc, ~/.aws) — only placeholders should exist
  env AWS_* values that are placeholders / total:
    3/3
  AWS_* in /proc/self/environ that are NOT placeholders: 0
  ~/.aws/credentials or ~/.aws/config: 0 file(s)
  1. A assinatura não precisa de placeholder. Com todas as variáveis AWS_* removidas, um PUT não assinado via curl para o bucket retornou 200. O supervisor assina todo request que chega a um endpoint assinado, a partir de qualquer binário que a regra lista, tenha ele apresentado uma credencial ou não. A posse não é o controle; a policy é.
  2. Um passo que deixei de fora. Ele testava uma fraqueza conhecida na 0.1.6: um placeholder que o workload coloca em um request para um endpoint assinado é resolvido para o valor real, e, por meio de um endpoint que armazena o que recebe, isso pode colocar a sessão real da AWS ao alcance do agente. Funcionou na 0.1.6. Os mantenedores sabem: um pull request aberto, o #4558, impede que requests SigV4 resolvam placeholders colocados pelo workload, porque “preserving arbitrary placeholder placement would expose resolved credentials to the signed service”. Ele não tinha sido mergeado até a 0.1.6, então deixei os detalhes fora deste post e do código complementar. Até que uma release inclua a correção, trate a sessão da role do sandbox como alcançável pelo agente.
  3. Quem barra a emissão de credenciais é o IAM, não o OpenShell. O supervisor assinou aws sts assume-role e get-session-token, e os dois receberam AccessDenied. O CloudTrail mostra o porquê: a role não permite AssumeRole, e a chamada falhou antes em sts:TagSession, porque a sessão carrega as tags transitivas do Pod Identity e a role não tem permissão para repassá-las; GetSessionToken simplesmente não pode ser chamado com credenciais de role. Então não foi o meu deny explícito que barrou essas duas, apesar do título na saída gravada acima, que eu escrevi antes de checar o CloudTrail. Ele é uma rede de segurança para o dia em que a role receber uma dessas ações: sem o deny, o supervisor assinaria essa chamada e o sandbox receberia chaves reais na resposta.
  4. Uma presigned URL falha. O aws s3 presign gera uma URL assinada com os placeholders; o S3 a rejeitou com um 400. Segundo o código-fonte, o supervisor adiciona o próprio header Authorization por cima da assinatura na query string, e o S3 recusa um request que se autentica das duas formas.
  5. O instance metadata e o agente do Pod Identity ficam bloqueados, como na parte 4.
  6. Nada a encontrar. O ambiente e o /proc guardam apenas placeholders, e não há arquivos de configuração da AWS.

Teste 7: Tempo de vida, rotação e revogação

O 08_lifetime.sh olha o status do refresh, força uma rotação e depois tenta revogar um provider de um sandbox em execução:

$ refresh status of p5-aws (EXPIRES_AT ~1h out; NEXT_REFRESH ~5 min before that)
PROVIDER                  CREDENTIAL_KEY                STRATEGY                      STATUS                    RECOVERY            EXPIRES_AT            NEXT_REFRESH          LAST_REFRESH          FAILURE_CODE                                  LAST_ERROR
p5-aws                    AWS_ACCESS_KEY_ID             aws_sts_assume_role           refreshed                 -                   2026-11-01 06:45:21   2026-11-01 06:40:21   2026-11-01 05:45:21                                                 -

$ manual rotate, then status again (a new session; EXPIRES_AT moves forward)
✓ Rotation requested for p5-aws AWS_ACCESS_KEY_ID (refreshed)
  expiry before rotate: 2026-11-01 06:45:21
  expiry after rotate:  2026-11-01 06:59:39
PROVIDER                  CREDENTIAL_KEY                STRATEGY                      STATUS                    RECOVERY            EXPIRES_AT            NEXT_REFRESH          LAST_REFRESH          FAILURE_CODE                                  LAST_ERROR
p5-aws                    AWS_ACCESS_KEY_ID             aws_sts_assume_role           refreshed                 -                   2026-11-01 06:59:39   2026-11-01 06:54:39   2026-11-01 05:59:39                                                 -

$ provider delete as revocation: a throwaway provider, then delete it and watch signing stop
  before delete: arn:aws:sts::<account>:assumed-role/osh-eks-sandbox-s3bedrock/p5-tmp

$ revocation: detach p5-aws-tmp from p5-life
  Error: × provider detachment failed (The system is not in a state required for the  operation's execution)

$ openshell policy set p5-life with no AWS endpoints, then detach and delete p5-aws-tmp
  ✓ Policy version 2 loaded (active version: 2)
  detached after 9.0 s
  ✓ Deleted provider p5-aws-tmp
  aws sts get-caller-identity: error occurred (NoCredentials)
  unsigned curl PUT to the bucket: HTTP 000

O refresh rotate emite uma nova sessão na hora: a expiração avançou. Sem ele, o gateway renova 5 minutos antes da expiração; segundo o código-fonte, um worker verifica a cada 60 segundos, os supervisors pegam os novos valores no próximo poll, e uma falha no STS é retentada a cada 60 segundos, indefinidamente.

A revogação é mais difícil do que na parte 4. Desanexar o provider do sandbox foi recusado, porque a policy do sandbox vincula os endpoints da AWS a esse provider. Tive que primeiro substituir a policy por uma sem endpoints da AWS; então o detach passou em 9,0 segundos e o provider pôde ser deletado. Depois disso, a CLI não encontrou credenciais e o request não assinado não conseguiu conectar. Planeje isso para um incidente: revogar o acesso à AWS de um sandbox em execução é uma mudança de policy mais um detach, ou deletar o sandbox. E como uma sessão copiada para fora do sandbox (Teste 6) continua válida até expirar, revogue também as sessões ativas da role no IAM.

Resumo dos Resultados

Resultado
Identidade do gatewayEKS Pod Identity após um restart do gateway; o refresh a obteve pela cadeia padrão de credenciais
Sessãoaws_sts_assume_role, 3.600 s, renovada 5 minutos antes da expiração; rotate emite na hora
No sandboxTrês placeholders, cerca de 105 caracteres cada; nenhuma chave no ambiente, no /proc ou em arquivos
Identidadeassumed-role/osh-eks-sandbox-s3bedrock/p5-shared pela CLI e pelo boto3
Básico do S3Put pequeno, 50 MiB de upload e download com checksum batendo, boto3
Chaves com espaço, +, não ASCIISignatureDoesNotMatch
Chave a//b.txtUpload informado como concluído, armazenada como a/b.txt
aws s3 rm / delete-objects403 (DELETE fora do read-write) / permitido (POST)
sigv4:body, sigv4:no_body com os padrões da CLIMalformedTrailerError, InvalidArgument
sigv4:body acima de 10 MiBConexão derrubada, informada como erro de SSL
Bedrock Converse / ConverseStreamFuncionam; primeiro token em streaming em 278 ms
Bedrock com um ARN de modeloConexão fechada (/ codificada)
Confiança na CAREQUESTS_CA_BUNDLE para as chamadas da CLI e o boto3; aws s3 cp (CRT) precisa de AWS_CA_BUNDLE
CloudTrailUm nome de sessão por provider; dois sandboxes em um mesmo provider são indistinguíveis
Request não assinado para um endpoint assinadoAssinado e aceito (200)
Placeholders colocados pelo workload em endpoints assinadosResolvidos para valores reais na 0.1.6 (correção pendente no #4558; detalhes omitidos)
AssumeRole, GetSessionTokenAccessDenied (AssumeRole: sem allow, falhou em TagSession; GetSessionToken: nunca emitido para uma sessão de role)
Presigned URL400
IMDS, agente do Pod IdentityBloqueados
RevogaçãoDetach recusado enquanto a policy vincula o provider; mudança de policy, depois detach (9,0 s)

O Que Isso Não Resolve

  • O que a role permite. O sandbox pode fazer tudo o que a role do sandbox pode, enquanto a sessão durar. O privilégio mínimo no IAM é a fronteira real. As regras REST do OpenShell enxergam métodos e paths; para APIs como o STS, que nomeiam a ação no body, elas não conseguem distinguir uma ação da outra.
  • Qual binário assina. A assinatura é por endpoint e não precisa de placeholder (Teste 6). Qualquer binário que a regra lista, curl incluído, tem os requests assinados.
  • Emissão de credenciais. Nada no OpenShell filtra qual ação do STS um request assinado chama, nem o que volta. Só o IAM impede um sandbox de transformar a assinatura em chaves reais.
  • Placeholders colocados pelo workload em endpoints assinados. Na 0.1.6 eles são resolvidos para valores reais (Teste 6), o que pode colocar a sessão real ao alcance do agente. A correção aberta, #4558, não estava na 0.1.6; até ela ser lançada, trate a sessão da role do sandbox como alcançável pelo agente, e mantenha-a curta e pequena.
  • Atribuição por sandbox. Um provider é uma sessão do STS; compartilhe-o e o CloudTrail não consegue distinguir os sandboxes (Teste 5).
  • Casos de borda do S3. Chaves com espaços, +, caracteres não ASCII ou // não são assinadas corretamente ou são reescritas (Teste 2), e os modos explícitos de assinatura não tratam os uploads padrão da CLI. O #4558 não vai mudar a reescrita do //: segundo a descrição dele, as chaves continuam na forma canônica.
  • O hardening do signer. Na 0.1.6, o signer não tem testes contra a AWS real: os únicos testes de integração dele, cinco casos de LocalStack em um arquivo, estão todos marcados com #[ignore], e o LocalStack não verifica assinaturas por padrão.

Limpeza

./99_cleanup.sh                          # sandboxes, providers, profiles
(cd terraform && terraform destroy)      # the bucket, both roles, the Pod Identity association

O 99_cleanup.sh deleta os sandboxes e providers p5- e os profiles importados, e esvazia o bucket. Em seguida, o terraform destroy deleta o bucket, as roles e a associação. O gateway continua rodando sem credenciais da AWS; reinicie-o se quiser o ambiente do Pod limpo também. O resto do cluster sai com o 99_teardown.sh da parte 2.

Veredito

O suporte do OpenShell à AWS é uma resposta real a um problema real. O agente rodou a AWS CLI e o boto3 sem modificações, fez upload de 50 MiB, recebeu uma resposta do Bedrock em streaming e provou a própria identidade, com três placeholders no ambiente e nenhuma chave em lugar nenhum do sandbox. O gateway obteve a própria identidade pelo EKS Pod Identity, manteve uma sessão de uma hora sempre renovada, e o CloudTrail mostra qual role e qual sessão fizeram cada chamada de gerenciamento; as chamadas de objetos do S3 precisam de uma trilha de eventos de dados.

Mas não é um cofre de credenciais, e os testes mostram onde ele vaza:

  • A sessão real pode voltar. Uma fraqueza conhecida na 0.1.6, com correção pendente no #4558, pode colocar o session token real ao alcance do agente. Até isso ser corrigido, assuma que um agente consegue recuperar a sessão, e dimensione a role e o tempo de vida da sessão para isso.
  • A posse não é o controle. Qualquer binário listado tem os requests assinados, com ou sem placeholder. Os endpoints da policy e as permissões da role são a fronteira.
  • O IAM tem que dizer não à emissão de credenciais. Nada no OpenShell impede um AssumeRole por um endpoint do STS assinado.
  • O caminho do S3 tem arestas a aparar: chaves codificadas quebram a assinatura, // é reescrito, os modos explícitos rejeitam os uploads padrão da CLI, e as transferências precisam de AWS_CA_BUNDLE.
  • A revogação leva dois passos, e a atribuição é por provider.

Se você roda no EKS agentes que precisam da AWS, eu ainda usaria isso em vez de dar a um sandbox qualquer identidade IAM própria: as chaves ficam fora do workload, a sessão é curta, e a fronteira pode ser revisada em um arquivo de policy e uma role. Dê a cada agente ou tenant o próprio provider e a própria role, negue explicitamente a emissão de credenciais, restrinja a role aos recursos de que a tarefa precisa, defina AWS_CA_BUNDLE na imagem, e mantenha a sessão curta até que o #4558 ou uma correção equivalente seja lançada.

A parte 6, a última da série, faz um stress test nos dois nodes em que tudo isso roda.

Comments