Strumento di Verifica QA dnsmasq CVE-2026

Strumento black-box automatizzato per verificare 6 vulnerabilità di dnsmasq (maggio 2026). Invia pacchetti di attacco a un DUT attivo e riporta PASS/FAIL — non è necessario l'accesso al codice sorgente.

Avvio rapido

# Set DUT DNS to your laptop's WAN IP via GUI first, then:
sudo python3 dnsmasq_cve_verify.py --laptop <YOUR_WAN_IP> --dut <DUT_LAN_IP> --dut-pass <SSH_PASS>

# Example:
sudo python3 dnsmasq_cve_verify.py --laptop 10.0.0.211 --dut 192.168.1.1 --dut-pass '12345Asdf@'

CVE testate

Come funziona ogni test

CVE-2026-2291 (Critica — Overflow heap in extract_name)

Causa principale: union bigname dichiara char name[MAXDNAME], ma i caratteri di escape possono espandere un nome fino a 2*MAXDNAME+1 byte, causando un overflow dell'heap.

Metodo di test: Invia query DNS contenenti nomi di dominio con caratteri ad alto bit (0x80+) che vengono internamente convertiti in escape \DDD (4 byte per byte di input). Se dnsmasq crasha o smette di rispondere, è vulnerabile.

Comportamento corretto: Rifiuta i nomi sovradimensionati senza errori (FORMERR/REFUSED) oppure utilizza un buffer ingrandito.

CVE-2026-5172 (Alta — Lettura fuori dai limiti in extract_addresses)

Causa principale: Un campo rdlen falsificato consente a extract_name() di far avanzare il puntatore oltre la fine del record. L'underflow dei byte rimanenti produce un valore enorme → lettura fuori dai limiti massiccia → crash.

Metodo di test: Invia risposte DNS con record CNAME in cui rdlen è più piccolo del nome effettivamente codificato. Se dnsmasq crasha, è vulnerabile.

Comportamento corretto: Verifica che il puntatore rimanga entro il limite rdlen dichiarato dopo extract_name().

CVE-2026-4890 (Alta — Loop infinito DNSSEC NSEC)

Causa principale: Il parsing del bitmap di tipo NSEC avanza di p[1] invece di p[1]+2 (manca la dimensione dell'header della finestra). Con bitmap_length=0, il puntatore non avanza mai → loop infinito.

Metodo di test: Invia un record NSEC appositamente costruito con window=0, bitmap_length=0. Se dnsmasq smette di rispondere a TUTTE le query (si blocca, non crasha), è vulnerabile. Sfruttabile PRIMA della validazione RRSIG.

Comportamento corretto: Avanza di p[1]+2 e salta i bitmap a lunghezza zero.

CVE-2026-4891 (Moderata — Lettura heap fuori dai limiti in RRSIG)

Causa principale: rdlen in RRSIG non viene validato rispetto alla dimensione minima (18 + nome del firmatario). La lunghezza della firma calcolata va in underflow negativo → viene trattata come enorme → lettura fuori dai limiti.

Metodo di test: Invia record RRSIG con rdlen=10 (molto al di sotto del minimo di 31+ byte). Crash = vulnerabile.

Comportamento corretto: Valida rdlen >= fixed_fields + signer_name_length prima di calcolare la lunghezza della firma.

CVE-2026-4892 (Alta — Root locale tramite CLID DHCPv6)

Causa principale: I CLID DHCPv6 (fino a 65535 byte) vengono codificati in esadecimale tramite sprintf("%.2x") in daemon->packet (5131 byte). Un CLID di 3000 byte → stringa esadecimale di 6000 byte → overflow. Il processo helper gira come root.

Metodo di test: Invia SOLICIT DHCPv6 con un Client Identifier di 3000 byte. Richiede adiacenza IPv6 e --dhcp-script configurato. Crash dell'helper = vulnerabile.

Comportamento corretto: Tronca o valida la lunghezza del CLID prima della codifica esadecimale.

Nota: Alcune build vengono compilate con -DNO_DHCP6 e NON sono interessate da questa CVE.

CVE-2026-4893 (Moderata — Bypass della validazione della sorgente ECS)

Causa principale: process_reply() passa la lunghezza del record OPT (~23 byte) invece della lunghezza completa del pacchetto a check_source(). Tutti i controlli dei limiti falliscono → la funzione restituisce sempre 1 (valido).

Metodo di test: Invia query DNS con l'opzione EDNS Client Subnet contenente prefissi sorgente spoofati. Se dnsmasq rispecchia l'ECS senza validazione, è vulnerabile.

Comportamento corretto: Passa la lunghezza completa del pacchetto a check_source(), consentendo i corretti controlli dei limiti secondo la RFC 7871 Sezione 9.2.

Rimedio

Aggiornare a dnsmasq 2.92rel2 (consigliato)

• Sorgente: https://thekelleys.org.uk/dnsmasq/dnsmasq-2.92rel2.tar.xz
• Patch upstream: https://thekelleys.org.uk/dnsmasq/CVE/

Strumento automatizzato di verifica dei difetti (dnsmasq_cve_verify.py)

Lo strumento QA principale. Viene eseguito sul laptop di test, invia pacchetti di attacco al DUT e riporta un chiaro PASS/FAIL per ogni CVE. Non è necessaria alcuna modifica del DUT oltre all'accesso SSH in sola lettura per l'ispezione dello stato.

Topologia di rete

┌─────────────────────────────────────────────────────────────────────┐
│                        Testing Laptop                                │
│                                                                      │
│   LAN interface                   WAN interface                      │
│   <LAPTOP_LAN_IP>                 <LAPTOP_WAN_IP>                   │
│        │                               │                            │
│        │                          ┌────┴──────────────┐             │
│        │                          │ Malicious DNS     │             │
│        │                          │ Server (port 53)  │             │
│        │                          └────┬──────────────┘             │
│        │                               │                            │
└────────┼───────────────────────────────┼────────────────────────────┘
         │ LAN subnet                    │ WAN subnet
         │                               │
┌────────┼───────────────────────────────┼────────────────────────────┐
│        │                               │                            │
│   LAN: <DUT_LAN_IP>              WAN: <DUT_WAN_IP>                  │
│   (LAN gateway)                   (WAN uplink)                      │
│                                                                      │
│              DUT (Linksys Router)                                    │
│              dnsmasq (any version < 2.92rel2)                        │
│                                                                      │
│   resolv-file=/etc/resolv.conf                                      │
│   → nameserver <LAPTOP_WAN_IP>  ← set via GUI, forwards to us      │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Data flow:
  1. Tool sends DNS query to DUT LAN IP (port 53)
  2. DUT's dnsmasq can't resolve locally → forwards upstream to LAPTOP_WAN_IP
  3. Our malicious server on WAN interface replies with exploit payload
  4. DUT's dnsmasq processes the malicious response → crash/hang/survive
  5. Tool checks DUT state via SSH (read-only)

Esempio di configurazione (i tuoi IP saranno diversi):

Il requisito fondamentale: l'IP WAN del laptop e l'IP WAN del DUT devono essere sulla stessa sottorete, così il DUT può raggiungere il laptop come server DNS upstream.

Come funziona

┌──────────┐     ┌───────────┐     ┌──────────────────┐     ┌──────────┐
│  SETUP   │ ──► │  TRIGGER  │ ──► │  STATE INSPECT   │ ──► │  VERDICT │
│          │     │           │     │                  │     │          │
│ Start    │     │ Send DNS  │     │ SSH to DUT:      │     │ PASS:    │
│ malicious│     │ query to  │     │ - pidof dnsmasq  │     │ survived │
│ DNS srv  │     │ DUT→DUT   │     │ - PID changed?   │     │          │
│ on WAN   │     │ forwards  │     │ - dmesg crash?   │     │ FAIL:    │
│ interface│     │ to us→we  │     │ - /var/log/msg   │     │ crashed/ │
│ (10.0.0. │     │ reply w/  │     │                  │     │ hung     │
│  211:53) │     │ exploit   │     │ Liveness query   │     │          │
│          │     │ payload   │     │ (version.bind)   │     │          │
└──────────┘     └───────────┘     └──────────────────┘     └──────────┘

NOTA: lo strumento NON modifica le impostazioni del DUT. L'utente deve impostare il DNS su 10.0.0.211 tramite GUI.

Procedura di test QA

Prerequisiti

• Laptop di test con due interfacce di rete (LAN + WAN)
• Python 3.6+ con paramiko installato (pip install paramiko)
• Accesso SSH al DUT (credenziali root)
• GUI amministrativa del DUT accessibile

Passo 1: Connessione fisica

Collega il laptop di test al DUT con due cavi:

Dopo la connessione, annota gli IP del tuo laptop:

# Find your IPs
ip addr show | grep "inet "
# Example output:
#   inet 192.168.1.254/24 ...  ← this is your LAN IP
#   inet 10.0.0.211/24 ...     ← this is your WAN IP (use this for --laptop)

Passo 2: Imposta il DNS del DUT sul laptop tramite GUI

1. Apri un browser e vai alla pagina di amministrazione del DUT:
   • es., http://192.168.1.1 o http://myrouter.local
2. Accedi con le credenziali di amministratore
3. Vai su: Connettività → Impostazioni Internet → Modifica (accanto a IPv4)
4. In DNS: seleziona DNS statico
5. Imposta DNS 1 sull'IP WAN del tuo laptop (es., 10.0.0.211)
6. Fai clic su Applica
7. Attendi 5-10 secondi affinché le impostazioni abbiano effetto

Passo 3: Esegui lo strumento

cd /path/to/dnsmasq-cve-2026/

# Run all 6 CVE tests:
sudo python3 dnsmasq_cve_verify.py --laptop <YOUR_WAN_IP> --dut <DUT_LAN_IP> --dut-pass <SSH_PASSWORD>

# Example:
sudo python3 dnsmasq_cve_verify.py --laptop 10.0.0.211 --dut 192.168.1.1 --dut-pass '12345Asdf@'

Lo strumento:

1. Si collega al DUT tramite SSH (sola lettura)
2. Avvia un server DNS malevolo sull'IP WAN del tuo laptop
3. Verifica che il DUT stia inoltrando le query DNS a quel server
4. Invia i payload degli exploit per ogni CVE
5. Controlla se dnsmasq è crashato o bloccato
6. Riporta PASS/FAIL per ogni CVE

Passo 4: Leggi i risultati

• PASS = il DUT è sicuro (funzionalità non attiva o ha superato l'attacco)
• FAIL = dnsmasq è crashato o bloccato (vulnerabile!)
• ERROR = impossibile connettersi o il DUT non inoltra

Passo 5: Ripristina il DNS del DUT

1. Torna alla GUI di amministrazione del DUT
2. Connettività → Impostazioni Internet → Modifica
3. In DNS: seleziona Automatico (dal provider) oppure rimuovi la voce statica
4. Fai clic su Applica

Risoluzione dei problemi

Risultati dei test (2026-05-31)

Piattaforma dnsmasq 2.78 (OVERALL: PASS)

Piattaforma dnsmasq 2.90 (OVERALL: PASS)

Conclusione

Tutti i router Linksys testati non sono praticamente sfruttabili per nessuna delle 6 CVE nelle loro configurazioni di build di produzione. Le funzionalità pericolose (DNSSEC, DHCPv6 tramite dnsmasq) non sono compilate o non sono configurate. Le patch sono comunque consigliate come difesa in profondità.

Risultati attesi

Pre-fix (dnsmasq 2.78, build senza DNSSEC):

Pre-fix (dnsmasq 2.90 con DNSSEC abilitato):

Post-fix (dnsmasq 2.92rel2 o patch backport applicate): Tutte le 6 CVE → PASS

Requisiti

• Python 3.6+ con paramiko (pip install paramiko)
• Root/sudo sul laptop (per associare il DNS sulla porta 53)
• Accesso SSH al DUT (sola lettura — usato per i controlli dello stato dei processi)
• Laptop collegato alla LAN del DUT (rete 192.168.1.x)

Riferimento delle opzioni

Altri strumenti

Tester remoto black-box (test_dnsmasq_cve_remote.py)

Solo un controllo leggero della versione — interroga version.bind per determinare se la versione di dnsmasq è precedente alla correzione. Nessuna SSH, nessuna configurazione, nessun payload di exploit.

python3 test_dnsmasq_cve_remote.py 192.168.1.1

Script on-device (test_dnsmasq_cve_on_device.sh)

Viene eseguito direttamente sul DUT tramite SSH/seriale. Controlla la versione del binario e le opzioni di compilazione.

scp test_dnsmasq_cve_on_device.sh [email protected]:/tmp/
ssh [email protected] "sh /tmp/test_dnsmasq_cve_on_device.sh"

Server DNS malevolo (malicious_dns_server.py)

Server exploit autonomo per test manuali. Eseguilo, punta il DNS upstream del DUT verso di esso, quindi attiva query verso crash-5172.evil.test, crash-2291.evil.test, ecc.

sudo python3 malicious_dns_server.py --port 53
# Then on DUT: configure upstream → this host
# Then trigger: dig @192.168.1.1 crash-5172.evil.test

Verifica dopo la correzione

Dopo aver applicato le patch e flashato il nuovo firmware, riesegui:

sudo python3 dnsmasq_cve_verify.py --laptop <YOUR_WAN_IP> --dut <DUT_LAN_IP> --dut-pass <SSH_PASS>
# Expected: all 6 PASS

Riepilogo dei requisiti

Riferimenti

• ISPreview: https://www.ispreview.co.uk/index.php/2026/05/string-of-dnsmasq-vulnerabilities-threatens-uk-broadband-routers.html
• Help Net Security: https://www.helpnetsecurity.com/2026/05/12/dnsmasq-vulnerabilities-cve/
• Patch upstream: https://thekelleys.org.uk/dnsmasq/CVE/
• Changelog di dnsmasq: https://thekelleys.org.uk/dnsmasq/CHANGELOG