79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

Débordement de tampon via le mot de passe PDF de Poppler (CVE-2026-107705)

Poppler 0.42.0 à 26.10.0 déborde un tampon de pile avec un mot de passe R6 trop long, ce qui plante le processus (8,3 Élevée, corrigé en 26.11.0).

En bref

  • La fonction Decrypt::revision6Hash() de Poppler copie un mot de passe R6 dans deux tampons de pile de 15 296 octets sans vérifier qu'il fait au plus 127 octets.
  • Les applications qui transmettent un mot de passe fourni par l'utilisateur à libpoppler, libpoppler-glib, libpoppler-cpp ou à l'API C++ sont concernées. Les outils en ligne de commande de Poppler tronquent le mot de passe et ne le sont pas.
  • La fiche CVE lui attribue un score CVSS v4.0 8,3 Élevée et CVSS v3.1 6,5 Moyenne. Aucune exploitation réelle n'est connue, et la faille n'est pas dans le catalogue KEV de la CISA au 2026-11-20.
  • Mettez à niveau vers Poppler 26.11.0 ou vers le paquet corrigé de votre distribution. Voir « Comment corriger ? » pour la solution de contournement à 127 octets.

Suis-je concerné ?

Une application est concernée uniquement lorsqu'elle utilise une version affectée de Poppler et lui transmet un mot de passe de plus de 127 octets.

  • Elle utilise une version affectée de Poppler, de 0.42.0 à 26.10.0, via libpoppler, libpoppler-glib, libpoppler-cpp, les liaisons Qt ou une copie embarquée.
  • Elle accepte un mot de passe pour un PDF chiffré en R6/AESV3, qui utilise AES-256.
  • Elle transmet ce mot de passe à Poppler sans le tronquer à 127 octets.
  • Le mot de passe peut dépasser 127 octets.

Un PDF malveillant seul ne déclenche pas le débordement. Le mot de passe est une entrée distincte. Un service qui accepte un PDF et un mot de passe du même appelant non fiable constitue l'exposition réaliste. Une visionneuse de bureau n'est concernée que si elle transmet un mot de passe de plus de 127 octets.

Les outils pdftoppm, pdftotext et les autres outils en ligne de commande de Poppler stockent le mot de passe dans un tampon de 33 octets en 26.10.0. Ils le tronquent à 32 octets et ne peuvent pas atteindre le débordement.

Branche Versions affectées Version corrigée
Poppler amont 0.42.0 à 26.10.0 26.11.0
Ubuntu 26.10 Antérieures à 26.07.0-2ubuntu1.1 26.07.0-2ubuntu1.1
Ubuntu 26.04 LTS Antérieures à 26.01.0-2ubuntu0.3 26.01.0-2ubuntu0.3
Ubuntu 24.04 LTS Antérieures à 24.02.0-1ubuntu9.11 24.02.0-1ubuntu9.11
Ubuntu 22.04 LTS Antérieures à 22.02.0-2ubuntu0.15 22.02.0-2ubuntu0.15
Debian 13 (trixie) 25.03.0-5+deb13u4 et antérieures Aucun paquet corrigé au 2026-11-20
Debian 12 (bookworm) 22.12.0-2+deb12u3 et antérieures Aucun paquet corrigé au 2026-11-20
Debian sid et forky Antérieures à 26.07.0-4 26.07.0-4

La fiche CVE lui attribue un score CVSS v4.0 8,3 Élevée. Le vecteur est CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N. La fiche liste aussi CVSS v3.1 6,5 Moyenne avec le vecteur CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H. La faiblesse est CWE-121, un débordement de tampon sur la pile.

Ubuntu 20.04 LTS et les versions antérieures sont indiquées comme nécessitant une évaluation et n'ont pas de paquet corrigé. La page Ubuntu a été mise à jour le 2026-11-09. Le suivi Debian indiquait Debian 12 et Debian 13 comme vulnérables au 2026-11-20.

Vérifiez la version exécutée :

# Poppler utilities version. The library package follows the same source release.
pdftoppm -v

# Debian or Ubuntu: installed poppler-utils version
dpkg-query -W -f='${Version}\n' poppler-utils

# Fedora, RHEL or CentOS Stream
rpm -q poppler

# Arch Linux
pacman -Q poppler

# macOS with Homebrew
brew list --versions poppler

Une application qui embarque sa propre copie de Poppler, par exemple un Flatpak, un Snap ou un wheel linguistique, doit être mise à jour séparément. Le paquet système ne modifie pas la copie embarquée.

Comment corriger ?

Mettez à niveau vers Poppler 26.11.0 ou une version ultérieure, ou vers le paquet corrigé publié par votre distribution. Le correctif amont est le commit 60e19a30 et il est inclus dans la version 26.11.0.

  1. Sur Ubuntu 22.04, 24.04, 26.04 ou 26.10, mettez à jour le paquet et confirmez la version :
sudo apt update
sudo apt install --only-upgrade poppler-utils
pdftoppm -v

Le nom du paquet de la bibliothèque principale suit le soname. Par exemple, c'est libpoppler118 sur Ubuntu 22.04 et libpoppler134 sur Ubuntu 24.04. La mise à niveau de poppler-utils installe la nouvelle bibliothèque principale. Si votre application utilise les liaisons GLib ou C++, le paquet de liaison dépend de cette bibliothèque principale et récupère le correctif avec elle.

  1. Sur Debian 12 ou Debian 13, aucun paquet corrigé n'était disponible le 2026-11-20. Attendez la mise à jour de sécurité, compilez 26.11.0 depuis l'archive de publication ou appliquez le commit 60e19a30 au paquet. Debian sid et forky disposent de 26.07.0-4, qui inclut le correctif.

  2. Sur Fedora 44 ou Fedora 45, mettez à niveau les paquets :

sudo dnf upgrade poppler poppler-glib poppler-cpp

La spécification de paquet Fedora contient le correctif sous la forme poppler-26.08.0-decrypt-password-length.patch dans Fedora 44 et Fedora 45. Fedora 43 ne le contient pas.

  1. Sur Arch Linux, mettez à niveau le paquet roulant :
sudo pacman -Syu poppler

Arch disposait de poppler 26.11.0-1 le 2026-11-20.

  1. Sur macOS avec Homebrew, mettez à niveau la formule :
brew upgrade poppler

Homebrew disposait de poppler 26.11.0 le 2026-11-20.

  1. Dans un conteneur, reconstruisez l'image à partir d'une base qui contient le paquet corrigé et recréez le conteneur. Tirer une nouvelle étiquette d'image ne suffit pas si l'image contient encore l'ancienne couche de bibliothèque.

Si vous ne pouvez pas encore mettre à niveau, limitez le mot de passe avant qu'il n'atteigne Poppler :

  1. Rejetez tout mot de passe de plus de 127 octets à la frontière de l'API, dans le formulaire de connexion ou dans l'enveloppe en ligne de commande qui appelle Poppler.
  2. Testez avec un mot de passe de 500 octets contre une compilation affectée et confirmez que l'application renvoie une erreur de validation au lieu d'atteindre la bibliothèque.

La solution de contournement ferme le chemin vers revision6Hash() pour le code que vous contrôlez. Elle ne corrige pas les autres appelants du même processus. Elle ne protège pas non plus une application qui transmet le mot de passe à Poppler par un chemin que vous ne contrôlez pas.

Quelle est la cause racine ?

Decrypt::revision6Hash() dimensionne ses tampons de pile K1 et E pour un mot de passe de 127 octets, mais il calcule la longueur de copie à partir du GooString non borné que makeFileKey() lui transmet.

Poppler est une bibliothèque de rendu PDF utilisée par des visionneuses de bureau, des suites bureautiques et des convertisseurs de documents. Elle implémente les gestionnaires de chiffrement définis par la norme PDF. La révision 6 (R6), aussi appelée AESV3, est le schéma AES-256 utilisé par les PDF chiffrés modernes. Sa dérivation de clé est l'algorithme 2.B de l'ISO 32000-2 : une boucle qui construit une chaîne de 64 blocs, la hache et recommence.

Decrypt::makeFileKey() gère les chemins du mot de passe propriétaire et du mot de passe utilisateur. Pour R5 et R6, elle limite un tampon local test à 127 octets, puis appelle revision6Hash() avec l'objet mot de passe d'origine :

len = userPassword->size();
if (len > 127) {
    len = 127;                 // clamps the local test[] copy only
}
memcpy(test, userPassword->c_str(), len);
...
revision6Hash(userPassword, test, nullptr);   // full password, no cap

C'est poppler/Decrypt.cc:126-136 à l'étiquette poppler-26.10.0. Le chemin propriétaire est identique aux lignes 86-96.

revision6Hash() lit ensuite la longueur complète et l'utilise pour dimensionner la copie :

unsigned char K1[64 * (127 + 64 + 48)];
unsigned char E[64 * (127 + 64 + 48)];
...
int inputPasswordLength = inputPassword->size();
...
sequenceLength = inputPasswordLength + KLength + userKeyLength;
totalLength = 64 * sequenceLength;
memcpy(K1, inputPassword->c_str(), inputPasswordLength);
...
for (int i = 1; i < 64; ++i) {
    memcpy(K1 + (i * sequenceLength), K1, sequenceLength);
}

C'est poppler/Decrypt.cc:1767-1793 à la même étiquette.

Les tableaux contiennent 15 296 octets chacun, c'est-à-dire 64 blocs de 239 octets. Le 239 est la taille d'un bloc du tableau : la limite de 127 octets du mot de passe, plus une réserve de 64 octets pour K, plus 48 octets de clé utilisateur. Le code fixe KLength à 32, donc chaque bloc a 32 octets de marge au-delà d'une séquence propriétaire de 207 octets.

Le premier memcpy écrit le mot de passe et le suivant écrit K. La boucle copie ensuite le bloc croissant 63 fois de plus.

La copie quitte K1 dès que sequenceLength dépasse 239 octets. sequenceLength est la longueur du mot de passe plus les 32 octets de K et, sur le chemin propriétaire, 48 octets de clé utilisateur. Cela se produit au-delà de 159 octets sur le chemin propriétaire. Sur le chemin utilisateur, la séquence n'ajoute que les 32 octets de K, donc cela se produit au-delà de 207 octets.

La fiche CVE décrit le déclencheur comme un mot de passe de plus de 127 octets, la limite R6. Le seuil exact du code est plus élevé, car le tableau est dimensionné pour une séquence de 239 octets.

Un mot de passe utilisateur de 500 octets produit une séquence de 532 octets, et la boucle écrit 34 048 octets au total. La même longueur pilote les écritures dans E dans la boucle de chiffrement.

Rien dans makeFileKey() ne rejette un mot de passe long. La spécification R6 limite le mot de passe à 127 octets, mais le code n'applique cette limite qu'à son propre tampon test. La fonction transmet ensuite la chaîne complète à revision6Hash().

Le chemin d'appel commence à PDFDoc::checkEncryption() (poppler/PDFDoc.cc:405), passe par SecurityHandler::checkEncryption() (poppler/SecurityHandler.cc:77) et StandardSecurityHandler::authorize() (poppler/SecurityHandler.cc:284), et atteint Decrypt::makeFileKey(). Toute application qui ouvre un PDF R6 via la bibliothèque et fournit un mot de passe emprunte ce chemin.

Comment la faille est-elle exploitée ?

Un attaquant qui contrôle la saisie du mot de passe d'une application concernée peut la planter, ou corrompre sa pile. L'attaquant fournit un mot de passe assez long pour pousser la copie au-delà des tampons, par exemple 500 octets, pour un PDF chiffré en R6. Le mot de passe n'a pas besoin d'être correct : revision6Hash() s'exécute avant la comparaison du hachage.

  1. L'attaquant trouve une application qui accepte un PDF R6/AESV3 et un mot de passe provenant du même appelant non fiable, par exemple un service de conversion ou une API qui ouvre des documents protégés.
  2. L'attaquant fournit n'importe quel PDF chiffré en R6. Le contenu n'a pas d'importance ; le PDF doit seulement sélectionner la révision 6.
  3. L'attaquant fournit un mot de passe assez long pour franchir le seuil, par exemple 500 caractères A.
  4. L'application transmet le mot de passe à PDFDoc ou à poppler_document_new_from_stream().
  5. makeFileKey() limite son tampon local test mais transmet le mot de passe complet à revision6Hash().
  6. revision6Hash() calcule sequenceLength à partir de la longueur complète et copie 64 blocs dans K1, au-delà du tampon de 15 296 octets.
  7. Le processus plante ou continue avec une pile corrompue, selon la disposition et les protections.

Le rapport public contient un petit pilote et une commande qpdf qui reproduisent le plantage. Voici le code du rapporteur, réduit à l'appel qui transmet le mot de passe :

std::optional<GooString> user;
user.emplace(std::string(argv[2]));
auto doc = std::make_unique<PDFDoc>(std::make_unique<GooString>(argv[1]), std::nullopt, user);

Le PDF est un fichier R6 normal :

qpdf --encrypt "userpw" "ownerpw" 256 -- dummy.pdf enc2.pdf
qpdf --show-encryption enc2.pdf | head -3   # expect R = 6

L'exécution du pilote avec un mot de passe utilisateur de 500 octets fait signaler l'écriture par AddressSanitizer :

WRITE of size 532 at 0x... thread T0
#0 ... in memcpy
#1 ... in revision6Hash .../poppler/Decrypt.cc:1792
#2 ... in Decrypt::makeFileKey .../poppler/Decrypt.cc:136
#3 ... in StandardSecurityHandler::authorize .../poppler/SecurityHandler.cc:284

Avec un mot de passe propriétaire de 200 octets, le même chemin signale WRITE of size 280 depuis l'appel propriétaire à Decrypt.cc:96. Le rapporteur a reproduit le plantage sur une compilation AddressSanitizer de master 8dfee73a et sur un paquet Ubuntu publié via libvips 8.x. Le rapport montre le plantage pour un mot de passe propriétaire de 200 octets et un mot de passe utilisateur de 500 octets. Le rapport ne démontre pas d'exécution de code.

Comment se déroule l'attaque ?

Un attaquant qui contrôle la saisie du mot de passe envoie un mot de passe assez long pour pousser la copie au-delà des tampons à une application qui ouvre un PDF R6. La longueur non limitée entraîne la copie au-delà des tampons de pile.

flowchart LR A["L'attaquant fournit un
long mot de passe R6"] --> B["L'application le transmet
à libpoppler"] B --> C["PDFDoc ouvre un PDF
R6/AESV3"] C --> D["makeFileKey limite seulement
son tampon test local"] D --> E["revision6Hash : aucun contrôle
de la longueur complète"] E --> F["K1 et E débordent
des tampons de 15 296 octets"] F --> G["Plantage ou corruption
de la pile"]

Que peut faire un attaquant ?

L'attaquant peut planter le processus et corrompre la pile. La fiche CVE attribue une disponibilité Élevée et une intégrité Faible, et ne revendique pas d'exécution de code.

  • Le contrôle de la saisie du mot de passe est nécessaire. Un PDF seul ne suffit pas.
  • La cible doit utiliser une version affectée de Poppler et ouvrir un PDF chiffré en R6.
  • L'application doit transmettre le mot de passe à Poppler sans limite de 127 octets.
  • Sur un service qui convertit des documents non fiables, une requête peut planter un processus de travail, et des requêtes répétées peuvent le maintenir hors service.
  • Sur une visionneuse de bureau, l'attaquant doit amener l'utilisateur à saisir un mot de passe assez long pour franchir le seuil de copie, ce qui est un chemin beaucoup plus étroit.

Le rapport décrit une exécution de code potentielle selon la disposition de la pile et les protections, mais ne la démontre pas. L'impact sur la confidentialité est Aucun dans les deux vecteurs CVSS. L'attaquant n'obtient pas le contenu des fichiers ni une fuite de mémoire avec cette faille telle qu'elle est décrite.

Pourquoi le correctif fonctionne-t-il ?

Le correctif tronque le mot de passe à 127 octets avant qu'il n'atteigne revision6Hash(). La longueur qui dimensionne les copies ne peut donc plus dépasser les tampons.

@@ -57,16 +57,18 @@
 static void sha512(unsigned char *msg, int msgLen, unsigned char *hash);

+constexpr int kMaxPasswordLength = 127;
+
 //------------------------------------------------------------------------
 // Decrypt
 //------------------------------------------------------------------------
@@ -74,20 +76,18 @@
     unsigned char fx, fy;
-    int len, i, j;
+    int i, j;

     *ownerPasswordOk = false;

     if (encRevision == 5 || encRevision == 6) {

         // check the owner password
-        if (ownerPassword) {
+        if (ownerPasswordA) {
             //~ this is supposed to convert the password to UTF-8 using "SASLprep"
-            len = ownerPassword->size();
-            if (len > 127) {
-                len = 127;
-            }
-            memcpy(test, ownerPassword->c_str(), len);
+            const std::string ownerPassword = ownerPasswordA->toStr().substr(0, kMaxPasswordLength);
+            const int len = ownerPassword.size();
+            memcpy(test, ownerPassword.c_str(), len);
             memcpy(test + len, ownerKey->c_str() + 32, 8);
             memcpy(test + len + 8, userKey->c_str(), 48);
             sha256(test, len + 56, test);
             if (encRevision == 6) {
                 // test contains the initial SHA-256 hash as input K.
                 revision6Hash(ownerPassword, test, userKey->c_str());
             }

makeFileKey() construit maintenant une std::string à partir du mot de passe et en prend les 127 premiers octets. Elle utilise cette chaîne pour le tampon local test et pour l'appel à revision6Hash(). revision6Hash() prend la chaîne par référence, donc son inputPasswordLength est la longueur tronquée. Le chemin propriétaire à Decrypt.cc:88 et le chemin utilisateur à Decrypt.cc:126 sont tous deux modifiés.

Le correctif est complet pour ce chemin. revision6Hash() n'est appelé que depuis les branches propriétaire et utilisateur de makeFileKey(). Chaque appel transmet désormais la chaîne limitée. Les anciennes révisions de chiffrement utilisent makeFileKey2(), qui limite son entrée à 32 octets et n'appelle pas revision6Hash().

La même version porte le tampon de mot de passe des outils en ligne de commande de 33 à 128 octets. Les outils acceptent jusqu'à 127 octets et ne peuvent toujours pas dépasser la limite.

Comment vérifier si j'ai été compromis ?

Aucun indicateur de compromission n'est publié, et aucune exploitation en conditions réelles n'est connue.

Recherchez les plantages lors de l'ouverture de PDF chiffrés. Le contrôle fortify de la glibc affiche *** buffer overflow detected ***. AddressSanitizer affiche un rapport WRITE of size ... dans revision6Hash.

# Core dumps from the last 30 days
coredumpctl list --since "30 days ago"

# Kernel and service logs for the fortify or stack protector message
journalctl --since "30 days ago" | grep -iE "buffer overflow detected|stack smashing detected"

Un résultat est une piste, pas une preuve. Le débordement peut planter le processus avant qu'il n'écrive le moindre journal applicatif. Une tentative échouée peut ne laisser qu'un core dump ou rien.

Chronologie

  • 2026-10-04 : Aziz Elbelaychy reproduit le débordement sur master 8dfee73a de Poppler avec AddressSanitizer.
  • 2026-10-05 : Le ticket GitLab public 1814 est créé. La fiche CVE indique cette date comme date publique.
  • 2026-10-07 : La demande de fusion 2398 est ouverte avec le correctif.
  • 2026-10-08 : CVE-2026-107705 est publiée par VulnCheck.
  • 2026-10-09 : La demande de fusion 2398 est fusionnée dans le commit 60e19a30.
  • 2026-11-05 : Poppler 26.11.0 est publié avec « Properly apply password length limit ».
  • 2026-11-20 : La CVE n'est pas dans le catalogue KEV de la CISA, et aucune exploitation n'est connue.

Chronologie de CVE-2026-107705 : rapport public le 2026-10-05, correctif fusionné le 2026-10-09, version publiée le 2026-11-05
Figure 1 : Du rapport public à la version corrigée en 31 jours. Source : ticket GitLab 1814 de Poppler, demande de fusion 2398 et notes de version, vérifié le 20 novembre 2026.

FAQ

Un PDF malveillant suffit-il à déclencher le débordement ?

Non. L'attaquant doit aussi contrôler le mot de passe et le rendre assez long pour franchir le seuil de copie. Un PDF qui sélectionne seulement le chiffrement R6 ne suffit pas.

pdftoppm et pdftotext sont-ils concernés ?

Non. En 26.10.0 et antérieur, les outils en ligne de commande stockent le mot de passe dans un tampon de 33 octets et le tronquent à 32 octets. La version 26.11.0 porte le tampon à 128 octets, ce qui limite toujours le mot de passe à 127 octets.

S'agit-il d'une exécution de code à distance ?

Non. Le rapport décrit un plantage au minimum et une exécution de code potentielle selon la disposition de la pile et les protections. La fiche CVE attribue une disponibilité Élevée et une intégrité Faible.

Faut-il le bon mot de passe ?

Non. revision6Hash() s'exécute avant la comparaison du hachage, donc tout mot de passe assez long pour franchir le seuil atteint le débordement, correct ou non.

Quels schémas de chiffrement sont concernés ?

Seule la révision 6, le schéma AESV3/AES-256. La révision 5 et les anciens schémas RC4 et AES-128 n'appellent pas revision6Hash().

Debian 12 ou Debian 13 sont-ils corrigés ?

Non. Le suivi de sécurité Debian indiquait les deux comme vulnérables le 2026-11-20. Debian sid et forky disposent de 26.07.0-4, qui inclut le correctif. Les lecteurs de Debian 12 et Debian 13 ont besoin de la mise à jour de sécurité lorsqu'elle paraîtra, ou de la compilation amont 26.11.0.

Trouvez les copies de Poppler vulnérables dans vos images avec Ostorlab

L'analyse de composition logicielle d'Ostorlab inventorie la version de Poppler dans vos images de conteneurs afin que vous puissiez repérer les versions antérieures à 26.11.0. Aziz Elbelaychy a signalé la faille.

Références

  • CVE Program, « CVE-2026-107705 » : https://www.cve.org/CVERecord?id=CVE-2026-107705 (vérifié le 20 novembre 2026)
  • VulnCheck, « Poppler 0.42.0 through 26.10.0 Stack Buffer Overflow via Decrypt::revision6Hash() » : https://www.vulncheck.com/advisories/poppler-0.42.0-through-26.10.0-stack-buffer-overflow-via-decrypt-revision6hash (vérifié le 20 novembre 2026)
  • Poppler, ticket GitLab 1814, « Stack buffer overflow in Decrypt::revision6Hash() with passwords longer than 127 bytes (R6/AESV3) » : https://gitlab.freedesktop.org/poppler/poppler/-/work_items/1814 (vérifié le 20 novembre 2026)
  • Poppler, demande de fusion 2398, « Decrypt: Properly apply password length limit » : https://gitlab.freedesktop.org/poppler/poppler/-/merge_requests/2398 (vérifié le 20 novembre 2026)
  • Poppler, poppler/Decrypt.cc à l'étiquette poppler-26.10.0 : https://gitlab.freedesktop.org/poppler/poppler/-/blob/poppler-26.10.0/poppler/Decrypt.cc (vérifié le 20 novembre 2026)
  • Poppler, poppler/Decrypt.cc à l'étiquette poppler-26.11.0 : https://gitlab.freedesktop.org/poppler/poppler/-/blob/poppler-26.11.0/poppler/Decrypt.cc (vérifié le 20 novembre 2026)
  • Poppler, « Poppler 26.11.0 » : https://poppler.freedesktop.org/ (vérifié le 20 novembre 2026)
  • Poppler, commit 60e19a30 : https://gitlab.freedesktop.org/poppler/poppler/-/commit/60e19a30152560fcccfb2ae7f7559eda560c0160 (vérifié le 20 novembre 2026)
  • Ubuntu, « CVE-2026-107705 » : https://ubuntu.com/security/CVE-2026-107705 (vérifié le 20 novembre 2026)
  • Debian, « CVE-2026-107705 » : https://security-tracker.debian.org/tracker/CVE-2026-107705 (vérifié le 20 novembre 2026)
  • Fedora, spécification poppler : https://src.fedoraproject.org/rpms/poppler/blob/f45/f/poppler.spec (vérifié le 20 novembre 2026)
  • Arch Linux, paquet poppler : https://archlinux.org/packages/extra/x86_64/poppler/ (vérifié le 20 novembre 2026)
  • Homebrew, formule poppler : https://formulae.brew.sh/formula/poppler (vérifié le 20 novembre 2026)
  • CISA, catalogue des vulnérabilités exploitées : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)