Net::DNS: envenenamiento de caché por identificadores predecibles (CVE-2026-101340)
Net::DNS hasta 1.57 genera los ID de consulta DNS con rand() de Perl, así que un observador puede predecirlos y falsificar respuestas (9.1).
Resumen
- Net::DNS generaba el identificador de transacción DNS de 16 bits con
rand()de Perl, así que un atacante que observaba una secuencia podía predecir los identificadores siguientes e inyectar respuestas falsificadas. - Net::DNS 0.02 a 1.57 está afectado, incluida la copia que usa Apache SpamAssassin y otras herramientas Perl.
- El registro CVE le asigna una puntuación CVSS v4.0 9.1 Crítica. No se conoce explotación en el mundo real y no está en el catálogo KEV de CISA al 2026-11-20.
- Actualice a Net::DNS 1.58 o posterior y reinicie el resolutor o la herramienta que lo usa.
¿Estoy afectado?
Todas estas condiciones deben cumplirse para que un despliegue esté expuesto:
- El Net::DNS instalado es 1.57 o anterior, o una herramienta incluye ese rango.
- La aplicación resuelve nombres DNS en una red donde un atacante puede observar una secuencia de identificadores de consulta. Un atacante en el camino, un proceso local o una posición en una red compartida es suficiente.
- El atacante puede enviar una respuesta falsificada que llegue al resolutor antes de la respuesta legítima.
- La respuesta no está protegida por un mecanismo que rechace la falsificación, como la validación DNSSEC para una zona firmada.
| Rama | Versiones afectadas | Versión corregida |
|---|---|---|
| Net::DNS | 0.02 a 1.57 | 1.58 |
El arreglo se publicó en 1.58 el 2026-11-20. El registro CVE le asigna una puntuación CVSS v4.0 9.1. El vector es CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N, y la debilidad es CWE-338. La distribución tenía 120 paquetes dependientes y 41 repositorios dependientes en libraries.io el 2026-11-20. Apache SpamAssassin requiere Net::DNS 1.10 o posterior, así que las pasarelas de correo que usan SpamAssassin incluyen la biblioteca.
Compruebe la versión instalada:
perl -MNet::DNS -e 'print $Net::DNS::VERSION, "\n"'
# Debian and Ubuntu package
dpkg -l libnet-dns-perl | tail -1
# RPM package
rpm -q perl-Net-DNS
Para una aplicación que incluye sus dependencias, revise el archivo de bloqueo o el bundle en lugar del Perl del sistema:
# cpanfile or Carton lock
grep -n 'Net::DNS' cpanfile cpanfile.snapshot 2>/dev/null
¿Cómo lo corrijo?
Actualice a Net::DNS 1.58 o posterior y reinicie cada proceso que cargó el módulo antiguo.
- Instale la versión corregida con el cliente CPAN que use:
cpanm Net::DNS@1.58
# or
cpan Net::DNS
- Para un paquete de distribución, actualícelo y confirme que la versión es al menos 1.58:
sudo apt install --only-upgrade libnet-dns-perl
perl -MNet::DNS -e 'print $Net::DNS::VERSION, "\n"'
- Para una aplicación que incluye sus dependencias, actualice la fijación a 1.58 y reconstruya el bundle:
cpanm --installdeps .
- Reinicie el resolutor, la pasarela de correo o el proceso de supervisión que usa la biblioteca. Un proceso de larga duración mantiene el módulo antiguo en memoria después de reemplazar los archivos.
Ningún rodeo a nivel de parche sustituye la actualización. La validación DNSSEC rechaza las respuestas falsificadas para zonas firmadas, pero no cubre las zonas sin firmar y no corrige el identificador predecible. La aleatorización del puerto de origen y una ruta de resolución restringida reducen la ventana del atacante pero no hacen impredecible el identificador.
¿Cuál es la causa raíz?
Una consulta DNS lleva un identificador de transacción de 16 bits. El resolutor asocia una respuesta entrante con su consulta pendiente por ese identificador, junto con el nombre, el tipo, la clase y la dirección y el puerto de origen. El identificador es el campo que un atacante fuera del camino tiene que adivinar, y un identificador predecible elimina la mayor parte de esa incertidumbre.
Net::DNS usaba rand() de Perl para generar ese identificador. rand() no es un generador criptográfico, y su secuencia de salida puede reconstruirse a partir de los valores observados.
La función _quid vulnerable en lib/Net/DNS/Packet.pm en 1.57 era:
my ( $cache1, $cache2, $limit );
sub _quid { ## generate (short-term) unique query ID
my $self = shift;
my $id = $self->{id};
$cache1->{$id}++ if $id; # cache non-zero ID
return $id if defined $id;
( $cache2, $cache1, $limit ) = ( $cache1, {0 => 1}, 50 ) unless $limit--;
$id = int rand(0xffff); # two layer ID cache
$id = int rand(0xffff) while $cache1->{$id}++ + exists( $cache2->{$id} );
return $self->{id} = $id;
}
La caché de dos capas solo evita que un identificador se repita en una ventana corta. No añade entropía. El valor sigue viniendo de rand(), así que una secuencia de identificadores observados expone el estado del generador que los produjo. La caché también se reinicia cada 50 llamadas, lo que no cambia el generador subyacente.
Perl inicializa rand() una vez por proceso a menos que el programa llame a srand(). Un resolutor que se ejecuta durante días produce una secuencia larga a partir de una sola semilla. Un observador que recoge suficientes salidas puede reconstruir el estado y calcular los identificadores siguientes.
¿Cómo se explota?
Un atacante que puede ver una serie de consultas DNS predice los identificadores de transacción siguientes y se adelanta a la respuesta real con una respuesta falsificada.
- El atacante observa una secuencia de consultas DNS y sus identificadores de 16 bits desde el resolutor víctima. Una posición en el camino, un proceso local o una red compartida es suficiente.
- El atacante reconstruye el estado del generador a partir de la secuencia observada y predice los identificadores que usará el resolutor después.
- El atacante envía una respuesta falsificada con el identificador predicho y los detalles de la consulta víctima antes de que responda el servidor legítimo.
- El resolutor asocia la respuesta falsificada con su consulta pendiente y almacena en caché el registro del atacante.
- Los clientes posteriores de ese resolutor reciben la respuesta falsificada hasta que la entrada de caché caduca o se reemplaza.
El aviso no enlaza ninguna prueba de concepto pública. Describe la predicción y el resultado de la respuesta falsificada pero no publica código de explotación, así que este artículo no incluye ninguno.
¿Cómo se desarrolla el ataque?
Una secuencia observada de identificadores de consulta permite a un atacante predecir el siguiente y ganar la carrera con una respuesta falsificada.
la secuencia de identificadores"] --> B["Reconstruye el estado
del generador de rand()"] B --> C["Predice el siguiente
identificador de 16 bits"] C --> D["Envía una respuesta falsificada
con el identificador predicho"] D --> E{"¿Llega antes de
la respuesta legítima?"} E -->|"Sí"| F["El resolutor acepta
y guarda el registro falsificado"] F --> G["Los clientes reciben
la respuesta del atacante"]
¿Qué puede hacer un atacante?
Un atacante que puede observar la secuencia de consultas y ganar la carrera de respuesta puede controlar la respuesta que el resolutor guarda para un nombre. El aviso describe respuestas falsificadas inyectadas en el resolutor; no describe un exploit público ni un uso en el mundo real.
- Redirigir un nombre a una dirección controlada por el atacante, mientras el registro falsificado permanezca en caché.
- Denegar la resolución devolviendo una respuesta negativa o inalcanzable.
- Alcanzar a los clientes que confían en el resolutor, incluidos filtros de correo, comprobaciones de supervisión y aplicaciones internas.
- Envenenar un nombre usado por un control de seguridad, como una lista de bloqueo o un host de actualización, y cambiar la decisión del control.
El impacto depende de la posición del resolutor y de lo que confíen sus clientes. Un resolutor stub usado por un solo proceso tiene un alcance menor que un resolutor recursivo compartido. La validación DNSSEC limita el impacto a las zonas sin firmar.
¿Por qué funciona la corrección?
El arreglo sustituye rand() por un generador basado en hash cuya salida no revela el estado que la produjo.
El código de 1.58 en lib/Net/DNS/Packet.pm inicializa un hash SHA-256 con un valor aleatorio, la hora actual y el tiempo desde la llamada anterior. Toma los primeros 16 bits como identificador de transacción:
{
use constant HASH => defined eval { require Digest::SHA };
my $hash = HASH ? Digest::SHA->new(256) : undef;
my $mark = time();
my $seed = int rand(0xffff);
my $prng = sub { ## PRNG using truncated hash
croak 'missing prerequisite: "Digest::SHA"' unless HASH;
my $time = time();
( my $delta_t, $mark ) = ( $time - $mark, $time );
$hash->add($seed);
$hash->add($time);
$hash->add($delta_t);
( my $random, $seed ) = unpack 'na*', $hash->digest;
return $random;
};
my ( $cache1, $cache2, $limit );
sub _quid { ## generate (short-term) "unique" query TxID
my $self = shift;
my $id = $self->{id};
$cache1->{$id}++ if $id; # cache non-zero TxID
return $id if defined $id;
$id = &$prng(); # two layer TxID cache
( $limit, $cache2, $cache1 ) = ( 50, $cache1, {0 => 1} ) unless $limit--;
$id = &$prng() while $cache1->{$id}++ + exists( $cache2->{$id} );
return $self->{id} = $id;
}
}
Un observador solo ve la salida de 16 bits. La salida es un resumen SHA-256 truncado de la semilla, la hora y el delta, así que el valor observado no expone la semilla ni la entrada siguiente. La mezcla de hora y delta cambia entre llamadas, y la semilla se reemplaza por los 30 bytes restantes de cada resumen. La caché de dos capas sigue rechazando los identificadores usados en las últimas 50 llamadas, con un resumen adicional solo cuando un candidato colisiona.
El arreglo es completo para el generador de identificadores. El módulo ahora requiere Digest::SHA, que es un módulo Perl básico desde 5.10. Un proceso que carga 1.58 obtiene el nuevo generador; un proceso que mantiene el módulo antiguo en memoria no.
La semilla aún parte de rand(0xffff), así que el generador tiene como máximo 16 bits de entropía inicial más la hora. La diferencia es que la salida es unidireccional: ver un identificador ya no dice al atacante cuál será la entrada o la salida siguiente. El arreglo del aviso es un generador criptográfico, no un aumento del espacio de identificadores, que sigue siendo de 16 bits.
¿Cómo compruebo si estuve comprometido?
El aviso no publica indicadores de compromiso y no se conoce explotación en el mundo real.
Una respuesta falsificada parece una respuesta DNS normal, así que no hay una firma de registro fiable. Estas comprobaciones son pistas, no pruebas:
- Compare las respuestas para nombres sensibles con los servidores autoritativos o un resolutor de confianza.
- Revise las entradas de caché del resolutor para nombres que cambiaron de dirección sin un cambio administrativo.
- Busque consultas o respuestas inesperadas alrededor del momento en que cambió un nombre, sobre todo desde un host que puede ver el tráfico del resolutor.
- Active la validación DNSSEC donde las zonas estén firmadas y registre los fallos de validación.
Una entrada de caché sola no prueba un envenenamiento. El control fiable es la actualización, porque un identificador predicho no deja una huella distintiva.
Cronología
- 2026-11-08: Xiang Li informa del problema.
- 2026-11-17: NLnet Labs comparte el parche con el reportero.
- 2026-11-19: el reportero verifica el parche.
- 2026-11-20: se publica Net::DNS 1.58 y se publica CVE-2026-101340.
Preguntas frecuentes
¿Net::DNS es un resolutor por sí solo?
No. Net::DNS es una biblioteca Perl que las aplicaciones usan para construir consultas y analizar respuestas. La exposición depende de la aplicación: un resolutor recursivo, un filtro de correo y un script de supervisión la usan de forma distinta.
¿Todos los programas que usan Net::DNS están afectados?
No. El programa debe resolver nombres en una ruta donde un atacante pueda observar los identificadores de consulta e inyectar una respuesta. Un programa que usa un resolutor local de confianza, o un resolutor con validación DNSSEC, tiene una exposición menor.
¿Existe una prueba de concepto pública?
No. El aviso describe el mecanismo del identificador predecible y el resultado de la respuesta falsificada pero no publica código de explotación.
¿DNSSEC corrige el problema?
No. La validación DNSSEC rechaza las respuestas falsificadas para zonas firmadas, pero no hace impredecible el identificador y no protege las zonas sin firmar. Actualice también a 1.58.
¿Debo reiniciar mi aplicación después de actualizar?
Sí. Perl carga el módulo en el proceso. Reemplazar los archivos en disco no cambia un resolutor o un filtro de correo en ejecución, así que reinicie cada proceso que use Net::DNS.
¿El arreglo cambia el formato de los paquetes DNS?
No. El identificador de transacción sigue siendo de 16 bits y el formato en el cable no cambia. Solo cambió el generador que elige el identificador.
¿El arreglo ralentiza la generación de consultas?
La ruta corregida calcula un resumen SHA-256 por identificador en lugar de llamar a rand(). El coste es pequeño comparado con el viaje de ida y vuelta por la red, y la caché de dos capas sigue rechazando los identificadores usados en las últimas 50 llamadas, con un resumen adicional solo cuando un candidato colisiona.
¿Qué pasa si Digest::SHA no está instalado?
Digest::SHA es un módulo Perl básico desde 5.10. Si una instalación Perl mínima lo omite, la función _quid corregida genera un error en lugar de volver a rand(). Instale el módulo o use una instalación Perl que lo incluya.
¿Net::DNS::SEC y la validación DNSSEC están afectados?
La falla está en el generador de identificadores de Net::DNS::Packet, no en el código de validación DNSSEC. Un resolutor que valida DNSSEC también se beneficia de la actualización, y la validación rechaza las respuestas falsificadas para zonas firmadas.
¿Se actualizará mi paquete de distribución?
Depende de la distribución. El arreglo upstream es 1.58, publicado el 2026-11-20. Una distribución que retroporte el parche a una versión anterior puede estar corregida sin mostrar 1.58, así que revise también el aviso de la distribución y no solo la cadena de versión.
Reinicie cada proceso que carga Net::DNS
Después del reinicio, vuelva a ejecutar perl -MNet::DNS -e 'print $Net::DNS::VERSION, "\n"' y confirme que la salida es 1.58 o posterior. La comprobación confirma el módulo que carga el nuevo proceso.
Referencias
- Net::DNS, aviso para CVE-2026-101340: https://www.net-dns.org/download/CVE-2026-101340.txt (verificado el 20 de noviembre de 2026)
- CVE Program, CVE-2026-101340: https://www.cve.org/CVERecord?id=CVE-2026-101340 (verificado el 20 de noviembre de 2026)
- Net::DNS, versión 1.58: https://www.net-dns.org/download/Net-DNS-1.58.tar.gz (verificado el 20 de noviembre de 2026)
- Net::DNS, código vulnerable en 1.57,
lib/Net/DNS/Packet.pm: https://metacpan.org/dist/Net-DNS/source/lib/Net/DNS/Packet.pm?version=1.57 (verificado el 20 de noviembre de 2026) - Net::DNS, código corregido en 1.58,
lib/Net/DNS/Packet.pm: https://metacpan.org/dist/Net-DNS/source/lib/Net/DNS/Packet.pm?version=1.58 (verificado el 20 de noviembre de 2026) - MetaCPAN, versión 1.58 de Net::DNS: https://metacpan.org/release/NLNETLABS/Net-DNS-1.58 (verificado el 20 de noviembre de 2026)
- Libraries.io, dependientes de Net::DNS: https://libraries.io/cpan/Net-DNS (verificado el 20 de noviembre de 2026)
- Apache SpamAssassin, dependencia de Net::DNS en
Makefile.PL: https://github.com/apache/spamassassin/blob/trunk/Makefile.PL (verificado el 20 de noviembre de 2026) - Catálogo de vulnerabilidades explotadas de CISA: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (verificado el 20 de noviembre de 2026)