Net::DNS : empoisonnement de cache via des identifiants prévisibles (CVE-2026-101340)
Net::DNS jusqu'à 1.57 génère les identifiants de requête DNS avec rand() de Perl, donc un observateur peut les prédire et forger des réponses (9,1 Critique).
En bref
- Net::DNS générait l'identifiant de transaction DNS de 16 bits avec
rand()de Perl, donc un attaquant qui observait une séquence pouvait prédire les identifiants suivants et injecter des réponses forgées. - Net::DNS 0.02 à 1.57 est concerné, y compris la copie utilisée par Apache SpamAssassin et d'autres outils Perl.
- La fiche CVE lui attribue un score CVSS v4.0 de 9,1 Critique. Aucune exploitation en conditions réelles n'est connue, et la faille n'est pas dans le catalogue KEV de la CISA au 2026-11-20.
- Mettez à niveau vers Net::DNS 1.58 ou une version ultérieure et redémarrez le résolveur ou l'outil qui l'utilise.
Suis-je concerné ?
Toutes ces conditions doivent être réunies pour qu'un déploiement soit exposé :
- Le Net::DNS installé est 1.57 ou antérieur, ou un outil embarque cette plage.
- L'application résout des noms DNS sur un réseau où un attaquant peut observer une séquence d'identifiants de requête. Un attaquant sur le chemin, un processus local ou une position sur un réseau partagé suffit.
- L'attaquant peut envoyer une réponse forgée qui atteint le résolveur avant la réponse légitime.
- La réponse n'est pas protégée par un mécanisme qui rejette la falsification, comme la validation DNSSEC pour une zone signée.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| Net::DNS | 0.02 à 1.57 | 1.58 |
Le correctif est sorti dans 1.58 le 2026-11-20. La fiche CVE lui attribue un score CVSS v4.0 de 9,1. Le vecteur est 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, et la faiblesse est CWE-338. La distribution comptait 120 paquets dépendants et 41 dépôts dépendants sur libraries.io au 2026-11-20. Apache SpamAssassin exige Net::DNS 1.10 ou ultérieur, donc les passerelles de messagerie qui utilisent SpamAssassin embarquent la bibliothèque.
Vérifiez la version installée :
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
Pour une application qui embarque ses dépendances, vérifiez le fichier de verrouillage ou le bundle plutôt que le Perl du système :
# cpanfile or Carton lock
grep -n 'Net::DNS' cpanfile cpanfile.snapshot 2>/dev/null
Comment corriger ?
Mettez à niveau vers Net::DNS 1.58 ou une version ultérieure et redémarrez chaque processus qui a chargé l'ancien module.
- Installez la version corrigée avec le client CPAN que vous utilisez :
cpanm Net::DNS@1.58
# or
cpan Net::DNS
- Pour un paquet de distribution, mettez-le à niveau et confirmez que la version est au moins 1.58 :
sudo apt install --only-upgrade libnet-dns-perl
perl -MNet::DNS -e 'print $Net::DNS::VERSION, "\n"'
- Pour une application qui embarque ses dépendances, mettez à jour l'épingle vers 1.58 et reconstruisez le bundle :
cpanm --installdeps .
- Redémarrez le résolveur, la passerelle de messagerie ou le processus de supervision qui utilise la bibliothèque. Un processus de longue durée garde l'ancien module en mémoire après le remplacement des fichiers.
Aucun contournement au niveau du correctif ne remplace la mise à niveau. La validation DNSSEC rejette les réponses forgées pour les zones signées, mais elle ne couvre pas les zones non signées et ne corrige pas l'identifiant prévisible. La randomisation du port source et un chemin de résolution restreint réduisent la fenêtre de l'attaquant mais ne rendent pas l'identifiant imprévisible.
Quelle est la cause racine ?
Une requête DNS porte un identifiant de transaction de 16 bits. Le résolveur associe une réponse entrante à sa requête en attente par cet identifiant, avec le nom, le type, la classe et l'adresse et le port source. L'identifiant est le champ qu'un attaquant hors chemin doit deviner, et un identifiant prévisible supprime l'essentiel de cette incertitude.
Net::DNS utilisait rand() de Perl pour générer cet identifiant. rand() n'est pas un générateur cryptographique, et sa séquence de sortie peut être reconstruite à partir des valeurs observées.
La fonction _quid vulnérable dans lib/Net/DNS/Packet.pm en 1.57 était :
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;
}
Le cache à deux couches empêche seulement un identifiant de se répéter dans une courte fenêtre. Il n'ajoute pas d'entropie. La valeur vient toujours de rand(), donc une séquence d'identifiants observés expose l'état du générateur qui les a produits. Le cache se réinitialise aussi tous les 50 appels, ce qui ne change pas le générateur sous-jacent.
Perl initialise rand() une fois par processus, sauf si le programme appelle srand(). Un résolveur qui tourne pendant des jours produit donc une longue séquence à partir d'une seule graine, et un observateur qui collecte assez de sorties peut reconstruire l'état et calculer les identifiants suivants.
Comment la faille est-elle exploitée ?
Un attaquant qui peut voir une série de requêtes DNS prédit les identifiants de transaction suivants et devance la vraie réponse avec une réponse forgée.
- L'attaquant observe une séquence de requêtes DNS et leurs identifiants de 16 bits depuis le résolveur victime. Une position sur le chemin, un processus local ou un réseau partagé suffit.
- L'attaquant reconstruit l'état du générateur à partir de la séquence observée et prédit les identifiants que le résolveur utilisera ensuite.
- L'attaquant envoie une réponse forgée avec l'identifiant prédit et les détails de la requête victime avant que le serveur légitime ne réponde.
- Le résolveur associe la réponse forgée à sa requête en attente et met en cache l'enregistrement de l'attaquant.
- Les clients suivants de ce résolveur reçoivent la réponse forgée jusqu'à l'expiration ou le remplacement de l'entrée de cache.
Aucune preuve de concept publique n'est liée dans l'avis. L'avis énonce la prédiction et le résultat de la réponse forgée mais ne publie pas de code d'exploitation, donc cet article n'en contient pas.
Comment se déroule l'attaque ?
Une séquence observée d'identifiants de requête permet à un attaquant de prédire le suivant et de gagner la course avec une réponse forgée.
la séquence d'identifiants"] --> B["Reconstruit l'état du générateur
à partir de rand()"] B --> C["Prédit le prochain
identifiant de 16 bits"] C --> D["Envoie une réponse forgée
avec l'identifiant prédit"] D --> E{"Arrive avant
la réponse légitime ?"} E -->|"Oui"| F["Le résolveur accepte
et met en cache l'enregistrement forgé"] F --> G["Les clients reçoivent
la réponse de l'attaquant"]
Que peut faire un attaquant ?
Un attaquant qui peut observer la séquence de requêtes et gagner la course de réponse peut contrôler la réponse que le résolveur met en cache pour un nom. L'avis décrit des réponses forgées injectées dans le résolveur ; il ne décrit pas d'exploit public ni d'utilisation en conditions réelles.
- Rediriger un nom vers une adresse contrôlée par l'attaquant, aussi longtemps que l'enregistrement forgé reste en cache.
- Refuser la résolution en renvoyant une réponse négative ou injoignable.
- Atteindre les clients qui font confiance au résolveur, notamment les filtres de messagerie, les contrôles de supervision et les applications internes.
- Empoisonner un nom utilisé par un contrôle de sécurité, comme une liste de blocage ou un hôte de mise à jour, et changer la décision du contrôle.
L'impact dépend de la position du résolveur et de ce à quoi ses clients font confiance. Un résolveur stub utilisé par un seul processus a une portée plus faible qu'un résolveur récursif partagé. La validation DNSSEC limite l'impact aux zones non signées.
Pourquoi le correctif fonctionne-t-il ?
Le correctif remplace rand() par un générateur à base de hachage dont la sortie ne révèle pas l'état qui l'a produite.
Le code de 1.58 dans lib/Net/DNS/Packet.pm initialise un hachage SHA-256 avec une valeur aléatoire, l'heure courante et le temps écoulé depuis l'appel précédent. Il prend ensuite les 16 premiers bits comme identifiant de transaction :
{
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 observateur ne voit que la sortie de 16 bits. La sortie est un condensat SHA-256 tronqué de la graine, de l'heure et du delta, donc la valeur observée n'expose ni la graine ni l'entrée suivante. Le mélange d'heure et de delta change entre les appels, et la graine est remplacée par les 30 octets restants de chaque condensat. Le cache à deux couches rejette toujours les identifiants utilisés lors des 50 derniers appels, au prix d'un condensat supplémentaire uniquement lorsqu'un candidat entre en collision.
Le correctif est complet pour le générateur d'identifiants. Le module exige désormais Digest::SHA, qui est un module Perl de base depuis 5.10. Un processus qui charge 1.58 obtient le nouveau générateur ; un processus qui garde l'ancien module en mémoire ne l'obtient pas.
La graine part encore de rand(0xffff), donc le générateur a au plus 16 bits d'entropie initiale plus l'heure. La différence est que la sortie est à sens unique : voir un identifiant ne dit plus à l'attaquant quelle sera l'entrée ou la sortie suivante. Le correctif de l'avis est un générateur cryptographique, pas une augmentation de l'espace des identifiants, qui reste de 16 bits.
Comment vérifier si j'ai été compromis ?
L'avis ne publie aucun indicateur de compromission, et aucune exploitation en conditions réelles n'est connue.
Une réponse forgée ressemble à une réponse DNS normale, il n'y a donc pas de signature de journal fiable. Ces vérifications sont des pistes, pas des preuves :
- Comparez les réponses pour les noms sensibles avec les serveurs faisant autorité ou un résolveur de confiance.
- Examinez les entrées de cache du résolveur pour les noms qui ont changé d'adresse sans changement administratif.
- Cherchez des requêtes ou réponses inattendues autour du moment où un nom a changé, surtout depuis un hôte qui peut voir le trafic du résolveur.
- Activez la validation DNSSEC là où les zones sont signées, et journalisez les échecs de validation.
Une entrée de cache seule ne prouve pas un empoisonnement. Le contrôle fiable est la mise à niveau, car un identifiant prédit ne laisse pas de trace distinctive.
Chronologie
- 2026-11-08 : Xiang Li signale le problème.
- 2026-11-17 : NLnet Labs partage le correctif avec le rapporteur.
- 2026-11-19 : le rapporteur vérifie le correctif.
- 2026-11-20 : Net::DNS 1.58 est publié et CVE-2026-101340 est publiée.
FAQ
Net::DNS est-il un résolveur à lui seul ?
Non. Net::DNS est une bibliothèque Perl que les applications utilisent pour construire des requêtes et analyser les réponses. L'exposition dépend de l'application : un résolveur récursif, un filtre de messagerie et un script de supervision l'utilisent différemment.
Tous les programmes qui utilisent Net::DNS sont-ils concernés ?
Non. Le programme doit résoudre des noms sur un chemin où un attaquant peut observer les identifiants de requête et injecter une réponse. Un programme qui utilise un résolveur local de confiance, ou un résolveur avec validation DNSSEC, a une exposition plus faible.
Existe-t-il une preuve de concept publique ?
Non. L'avis décrit le mécanisme de l'identifiant prévisible et le résultat de la réponse forgée mais ne publie pas de code d'exploitation.
DNSSEC corrige-t-il le problème ?
Non. La validation DNSSEC rejette les réponses forgées pour les zones signées, mais elle ne rend pas l'identifiant imprévisible et ne protège pas les zones non signées. Mettez aussi à niveau vers 1.58.
Dois-je redémarrer mon application après la mise à niveau ?
Oui. Perl charge le module dans le processus. Remplacer les fichiers sur le disque ne change pas un résolveur ou un filtre de messagerie en cours d'exécution, donc redémarrez chaque processus qui utilise Net::DNS.
Le correctif change-t-il le format des paquets DNS ?
Non. L'identifiant de transaction reste de 16 bits et le format sur le fil est inchangé. Seul le générateur qui choisit l'identifiant a changé.
Le correctif ralentit-il la génération des requêtes ?
Le chemin corrigé calcule un condensat SHA-256 par identifiant au lieu d'appeler rand(). Le coût est faible par rapport à l'aller-retour réseau, et le cache à deux couches rejette toujours les identifiants utilisés lors des 50 derniers appels, au prix d'un condensat supplémentaire uniquement lorsqu'un candidat entre en collision.
Que se passe-t-il si Digest::SHA n'est pas installé ?
Digest::SHA est un module Perl de base depuis 5.10. Si une installation Perl minimale l'omet, la fonction _quid corrigée lève une erreur au lieu de revenir à rand(). Installez le module ou utilisez une installation Perl qui l'inclut.
Net::DNS::SEC et la validation DNSSEC sont-ils concernés ?
La faille est dans le générateur d'identifiants de Net::DNS::Packet, pas dans le code de validation DNSSEC. Un résolveur qui valide DNSSEC profite aussi de la mise à niveau, et la validation rejette les réponses forgées pour les zones signées.
Mon paquet de distribution sera-t-il mis à jour ?
Cela dépend de la distribution. Le correctif amont est 1.58, publié le 2026-11-20. Une distribution qui rétroporte le correctif à une version antérieure peut être corrigée sans afficher 1.58, donc vérifiez aussi l'avis de la distribution et pas seulement la chaîne de version.
Redémarrez chaque processus qui charge Net::DNS
Après le redémarrage, relancez perl -MNet::DNS -e 'print $Net::DNS::VERSION, "\n"' et confirmez que la sortie est 1.58 ou ultérieure. La vérification confirme le module chargé par le nouveau processus.
Références
- Net::DNS, avis pour CVE-2026-101340 : https://www.net-dns.org/download/CVE-2026-101340.txt (vérifié le 20 novembre 2026)
- CVE Program, CVE-2026-101340 : https://www.cve.org/CVERecord?id=CVE-2026-101340 (vérifié le 20 novembre 2026)
- Net::DNS, version 1.58 : https://www.net-dns.org/download/Net-DNS-1.58.tar.gz (vérifié le 20 novembre 2026)
- Net::DNS, source vulnérable en 1.57,
lib/Net/DNS/Packet.pm: https://metacpan.org/dist/Net-DNS/source/lib/Net/DNS/Packet.pm?version=1.57 (vérifié le 20 novembre 2026) - Net::DNS, source corrigée en 1.58,
lib/Net/DNS/Packet.pm: https://metacpan.org/dist/Net-DNS/source/lib/Net/DNS/Packet.pm?version=1.58 (vérifié le 20 novembre 2026) - MetaCPAN, version 1.58 de Net::DNS : https://metacpan.org/release/NLNETLABS/Net-DNS-1.58 (vérifié le 20 novembre 2026)
- Libraries.io, dépendants de Net::DNS : https://libraries.io/cpan/Net-DNS (vérifié le 20 novembre 2026)
- Apache SpamAssassin, dépendance à Net::DNS dans
Makefile.PL: https://github.com/apache/spamassassin/blob/trunk/Makefile.PL (vérifié le 20 novembre 2026) - Catalogue des vulnérabilités exploitées de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)