Cette page présente les vulnérabilités les plus discutées sur les sources publiques (Fediverse, Bluesky, GitHub, blogs) sur la période analysée.
Période analysée : 2026-07-05 → 2026-07-12.
Les données sont collectées via Vulnerability-Lookup (CIRCL) et enrichies automatiquement afin d’aider à la priorisation de la veille et de la remédiation.
📌 Légende :
- CVSS : score officiel de sévérité technique.
- EPSS : probabilité d’exploitation observée.
- VLAI : estimation de sévérité basée sur une analyse IA du contenu de la vulnérabilité.
- CISA KEV : vulnérabilité activement exploitée selon la CISA.
- seen / exploited : signaux observés dans les sources publiques.
CVE-2026-48282
ColdFusion versions 2025.9, 2023.20 and earlier are affected by an Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') vulnerability that could lead to arbitrary code execution in the context of the current user. Exploitation of this issue does not require user interaction. Scope is changed.
Les versions de ColdFusion 2025.9, 2023.20 et antérieures présentent une vulnérabilité connue sous le nom de Path Traversal (traversée de répertoire), qui permet de contourner les limitations de chemins dans des répertoires restreints. Cette vulnérabilité peut entraîner une exécution de code arbitraire dans le contexte de l'utilisateur actuel.
Détails de la vulnérabilité :
- Path Traversal : Il s'agit d'une méthode par laquelle un attaquant peut accéder à des fichiers ou des répertoires en dehors des limites définies par le système, en manipulant les chemins d'accès.
- Exécution de code arbitraire : Cela permet à un attaquant d'exécuter des commandes malveillantes sur le serveur, ce qui peut compromettre la sécurité de l'application.
Caractéristiques :
- Sans interaction utilisateur : L'exploitation de cette vulnérabilité ne nécessite aucune action de la part de l'utilisateur. Cela la rend particulièrement dangereuse.
- Changement de portée : Cela signifie que l'impact de la vulnérabilité a été ajusté, ce qui pourrait affecter davantage d'utilisateurs ou de systèmes.
Il est donc impératif de mettre à jour les installations affectées pour se protéger contre cette faille.
Posts / Sources (115)
CVE-2026-53359
In the Linux kernel, the following vulnerability has been resolved: KVM: x86: Fix shadow paging use-after-free due to unexpected role Commit 0cb2af2ea66ad ("KVM: x86: Fix shadow paging use-after-free due to unexpected GFN") fixed a shadow paging mismatch between stored and computed GFNs; the bug could be triggered by changing a PDE mapping from outside the guest, and then deleting a memslot. The rmap_remove() call would miss entries created after the PDE change because the GFN of the leaf SPTE does not match the GFN of the struct kvm_mmu_page. A similar hole however remains if the modified PDE points to a non-leaf page. In this case the gfn can be made to match, but the role does not match: the original large 2MB page creates a kvm_mmu_page with direct=1, while the new 4KB needs a kvm_mmu_page with direct=0. However, kvm_mmu_get_child_sp() does not compare the role, and therefore reuses the page. The next step is installing a leaf (4KB) SPTE on the new path which records an rmap entry under the gfn resolved by the walk. But when that child is zapped its parent kvm_mmu_page has direct=1 and kvm_mmu_page_get_gfn() computes the gfn for the 4KB page as sp->gfn + index instead of using sp->shadowed_translation[] (or sp->gfns[] in older kernels). It therefore fails to remove the recorded entry. When the memslot is dropped the shadow page is freed but the rmap entry survives, as in the scenario that was already fixed. Code that later walks that gfn (dirty logging, MMU notifier invalidation, and so on) dereferences an sptep that lies in the freed page, causing the use-after-free.
Vulnérabilité dans le noyau Linux (CVE non spécifié)
Une vulnérabilité a été corrigée dans le noyau Linux, plus précisément dans KVM (Kernel-based Virtual Machine) pour les architectures x86. Voici les détails :
-
Conséquence : Cette vulnérabilité permet un Use-After-Free, c'est-à-dire que du code malveillant peut accéder à de la mémoire qui a déjà été libérée.
-
Contexte : Un bug se produisait lors d'une incohérence entre les GFNs (Guest Frame Numbers) enregistrés et calculés en raison d'un changement de mappage PDE (Page Directory Entry) à partir de l'extérieur d'une machine virtuelle.
-
Problème : Si le PDE modifié pointait vers une page non-feuille, il était possible que le GFN corresponde mais que les rôles des pages ne s'alignent pas. Par exemple :
- Page d'origine 2MB : crée une kvm_mmu_page avec
direct=1. - Nouvelle page 4KB : nécessite une kvm_mmu_page avec
direct=0.
- Page d'origine 2MB : crée une kvm_mmu_page avec
-
Situation : La fonction
kvm_mmu_get_child_sp()ne compare pas ces rôles, menant à la réutilisation d'une page incorrecte et causant des erreurs lors de l'invalidation de la mémoire. -
Impact : Quand une memslot est supprimée, la page d'ombre est libérée mais l'entrée rmap (Reverse Mapping) reste. Cela peut entraîner des accès à une page libérée lors de certaines opérations (comme le journal des modifications), entraînant le Use-After-Free.
Cette correction améliore la sécurité et la stabilité du système en empêchant l'accès à des zones mémoire potentiellement compromettantes.
Posts / Sources (79)
CVE-2026-20896
Gitea Docker image versions up to and including 1.26.2 use REVERSE_PROXY_TRUSTED_PROXIES=* by default, allowing any source IP to impersonate a user when reverse-proxy authentication headers such as X-WEBAUTH-USER are enabled.
Vulnérabilité dans l'image Docker de Gitea
Les versions de l'image Docker de Gitea jusqu'à la version 1.26.2 présentent une vulnérabilité importante. Voici les points clés à retenir :
-
Configuration par défaut : Les versions concernées utilisent REVERSE_PROXY_TRUSTED_PROXIES=* par défaut. Cela signifie que toutes les adresses IP peuvent être considérées comme de confiance.
-
Problème de sécurité : Cette configuration permet à n'importe quel utilisateur de se faire passer pour un autre. Cela se produit lorsque des en-têtes d'authentification via un proxy inverse, comme X-WEBAUTH-USER, sont activés.
-
Conséquences : L'impact est sérieux, car un attaquant peut potentiellement usurper l'identité d'un utilisateur légitime en manipulant les en-têtes, ce qui entraîne des problèmes de sécurité avec l'accès aux données ou aux fonctionnalités.
Terminologie
- RCE (Remote Code Execution) : Exécution de code à distance.
- SSRF (Server-Side Request Forgery) : Un type d'attaque où le serveur est trompé pour effectuer des requêtes malveillantes.
- XSS (Cross-Site Scripting) : Un type de faille qui permet d'injecter du code malveillant dans une page web.
Recommandations
- Mettre à jour vers une version de Gitea supérieure à 1.26.2 pour corriger cette vulnérabilité.
- Revoir la configuration des proxys inverses pour s'assurer que seuls les adresses IP fiables peuvent être utilisées.
Posts / Sources (69)
CVE-2026-55255
Langflow is a tool for building and deploying AI-powered agents and workflows. Prior to 1.9.1, an Insecure Direct Object Reference (IDOR) vulnerability in /api/v1/responses endpoint allows an authenticated attacker to execute any flow belonging to another user by specifying the victim's flow ID in the request. This vulnerability is fixed in 1.9.1.
Langflow est un outil permettant de créer et de déployer des agents et des workflows alimentés par l'IA. Avant la version 1.9.1, une vulnérabilité de référence directe d'objet non sécurisée (IDOR pour Insecure Direct Object Reference) a été détectée dans le point d'accès /api/v1/responses.
Détails de la vulnérabilité :
- Type de vulnérabilité : IDOR
- Impact :
- Un attaquant authentifié peut exécuter n'importe quel flux appartenant à un autre utilisateur.
- Cela se produit en spécifiant l'ID du flux de la victime dans la requête.
Résumé :
- La vulnérabilité a été corrigée dans la version 1.9.1.
- Il est essentiel de mettre à jour vers cette version pour protéger les données des utilisateurs.
Notes :
- Un IDOR se produit lorsque des identifiants d'objet sont exposés et sont accessibles sans vérification appropriée des autorisations.
- Assurez-vous que chaque utilisateur ne peut accéder qu'à ses propres ressources pour éviter des abus.
Il est recommandé de toujours utiliser les dernières versions des logiciels pour bénéficier des correctifs de sécurité.
Posts / Sources (60)
CVE-2026-43499
In the Linux kernel, the following vulnerability has been resolved: rtmutex: Use waiter::task instead of current in remove_waiter() remove_waiter() is used by the slowlock paths, but it is also used for proxy-lock rollback in rt_mutex_start_proxy_lock() when invoked from futex_requeue(). In the latter case waiter::task is not current, but remove_waiter() operates on current for the dequeue operation. That results in several problems: 1) the rbtree dequeue happens without waiter::task::pi_lock being held 2) the waiter task's pi_blocked_on state is not cleared, which leaves a dangling pointer primed for UAF around. 3) rt_mutex_adjust_prio_chain() operates on the wrong top priority waiter task Use waiter::task instead of current in all related operations in remove_waiter() to cure those problems. [ tglx: Fixup rt_mutex_adjust_prio_chain(), add a comment and amend the changelog ]
Résumé de la vulnérabilité dans le noyau Linux
Une vulnérabilité a été corrigée dans le noyau Linux concernant la fonction remove_waiter() utilisée par les chemins de slowlock. Cette fonction est aussi employée pour le rollback de proxy-lock dans rt_mutex_start_proxy_lock() lorsqu'elle est appelée depuis futex_requeue().
Problèmes constatés :
- Utilisation incorrecte de
current: La fonctionremove_waiter()opérait surcurrentau lieu dewaiter::taskpour l'opération de déqueue, entraînant plusieurs problèmes : - Déqueue sans verrouillage : Le déqueue se produit sans que
waiter::task::pi_locksoit tenu. - État non réinitialisé : L'état
pi_blocked_onde la tâche en attente n'est pas nettoyé, laissant un pointeur sur un objet désalloué (UAF, ou Use After Free). - Priorité incorrecte : La fonction
rt_mutex_adjust_prio_chain()travaille sur la tâche en attente avec une priorité incorrecte.
Solution apportée :
- L'utilisation de
waiter::taskplutôt que decurrentdans toutes les opérations liées àremove_waiter()a été mise en place pour résoudre ces problèmes.
Cette correction améliore la sécurité et la stabilité du système lors de la gestion des mutex en temps réel (rt_mutex).
Posts / Sources (47)
CVE-2026-50656
Microsoft is aware of an elevation of privilege in the Microsoft Malware Protection Engine in Microsoft Defender publicly referred to as "RoguePlanet ".
Microsoft est conscient d'une élévation de privilège dans le Microsoft Malware Protection Engine de Microsoft Defender, communément appelée "RoguePlanet".
Détails :
-
Élévation de privilège : Cela signifie qu'un attaquant peut obtenir des droits d'accès supérieurs à ceux qui lui sont normalement autorisés, ce qui peut lui permettre de contrôler davantage le système.
-
Microsoft Defender : C'est un logiciel de sécurité intégré à Windows, conçu pour protéger contre les malwares et autres menaces.
Menaces associées :
- RoguePlanet : Bien que peu d'informations soient disponibles, il s'agit d'une vulnérabilité qui peut permettre à un attaquant de tirer parti du moteur de protection contre les malwares pour exécuter des actions non autorisées.
Acronymes :
- RCE (Remote Code Execution) : Exécution de code à distance, permettant à un attaquant d'exécuter des commandes sur un système distant.
- SSRF (Server-Side Request Forgery) : Technique qui incite un serveur à faire des requêtes à d'autres serveurs potentiellement malveillants.
- XSS (Cross-Site Scripting) : Une vulnérabilité qui permet à des attaquants d'injecter des scripts malveillants dans des pages web vues par d'autres utilisateurs.
Cette vulnérabilité dans le produit de Microsoft peut représenter un risque sérieux si elle n'est pas corrigée rapidement.
Posts / Sources (92)
CVE-2026-46242
In the Linux kernel, the following vulnerability has been resolved: eventpoll: fix ep_remove struct eventpoll / struct file UAF ep_remove() (via ep_remove_file()) cleared file->f_ep under file->f_lock but then kept using @file inside the critical section (is_file_epoll(), hlist_del_rcu() through the head, spin_unlock). A concurrent __fput() taking the eventpoll_release() fastpath in that window observed the transient NULL, skipped eventpoll_release_file() and ran to f_op->release / file_free(). For the epoll-watches-epoll case, f_op->release is ep_eventpoll_release() -> ep_clear_and_put() -> ep_free(), which kfree()s the watched struct eventpoll. Its embedded ->refs hlist_head is exactly where epi->fllink.pprev points, so the subsequent hlist_del_rcu()'s "*pprev = next" scribbles into freed kmalloc-192 memory. In addition, struct file is SLAB_TYPESAFE_BY_RCU, so the slot backing @file could be recycled by alloc_empty_file() -- reinitializing f_lock and f_ep -- while ep_remove() is still nominally inside that lock. The upshot is an attacker-controllable kmem_cache_free() against the wrong slab cache. Pin @file via epi_fget() at the top of ep_remove() and gate the critical section on the pin succeeding. With the pin held @file cannot reach refcount zero, which holds __fput() off and transitively keeps the watched struct eventpoll alive across the hlist_del_rcu() and the f_lock use, closing both UAFs. If the pin fails @file has already reached refcount zero and its __fput() is in flight. Because we bailed before clearing f_ep, that path takes the eventpoll_release() slow path into eventpoll_release_file() and blocks on ep->mtx until the waiter side's ep_clear_and_put() drops it. The bailed epi's share of ep->refcount stays intact, so the trailing ep_refcount_dec_and_test() in ep_clear_and_put() cannot free the eventpoll out from under eventpoll_release_file(); the orphaned epi is then cleaned up there. A successful pin also proves we are not racing eventpoll_release_file() on this epi, so drop the now-redundant re-check of epi->dying under f_lock. The cheap lockless READ_ONCE(epi->dying) fast-path bailout stays.
Résumé de la vulnérabilité dans le noyau Linux
Dans le noyau Linux, une vulnérabilité a été corrigée concernant eventpoll. Voici les détails :
- Problème identifié : Dans la fonction
ep_remove, le champfile->f_epa été nettoyé sous f_lock, mais le code continuait à utiliser@filedans une section critique. - Un appel concurrent à
__fput()a observé une valeur temporaire NULL, ce qui a contournéeventpoll_release_file()et a mené à une libération incorrecte de la mémoire. - Cela a conduit à une écriture dans une mémoire déjà libérée, ce qui est une Use After Free (UAF). Cela peut être exploité par un attaquant.
Termes clés
- RCE (Remote Code Execution) : Exécution de code à distance, exploitant des vulnérabilités pour exécuter du code malveillant.
- SSRF (Server Side Request Forgery) : Forçage d'un serveur à faire des requêtes qu'il ne devrait pas, souvent vers des systèmes internes.
- XSS (Cross-Site Scripting) : Injection de scripts malveillants dans des pages web vues par d'autres utilisateurs.
Correctifs
- Pour éviter ce problème, une technique de « pouvant être épinglée » (pinning) a été introduite. Cela implique de garder
@fileactif, ce qui empêche que sa référence descende à zéro pendant que la mémoire est utilisée. Cela empêche la libération inappropriée du mémoire, fermant ainsi les vecteurs d’attaque.
Cette correction renforce la sécurité en empêchant certains scénarios d'utilisation concurrente erronés, garantissant l'intégrité des structures de données.
Posts / Sources (61)
CVE-2026-50746
A malicious actor with access to the network could exploit an Improper Access Control vulnerability found in UniFi Connect Application to execute a Command Injection on the host device.
Un acteur malveillant ayant accès au réseau pourrait exploiter une vulnérabilité de Contrôle d'Accès Inapproprié (Improper Access Control) présente dans l'application UniFi Connect. Cette vulnérabilité permettrait d'exécuter une Injection de Commande (Command Injection) sur l'appareil hôte.
Explications :
- Contrôle d'Accès Inapproprié : Cela signifie que les protections censées restreindre l'accès ne fonctionnent pas correctement. Un utilisateur non autorisé pourrait accéder à des fonctions réservées.
- Injection de Commande : Il s'agit d'un type de vulnérabilité où un attaquant peut envoyer des commandes malveillantes à un système, ce qui lui permet d'exécuter des actions indésirables ou de contrôler l'appareil.
En résumé, cette vulnérabilité pourrait permettre à un attaquant de prendre le contrôle de l'appareil sur lequel l'application UniFi Connect est installée.
Posts / Sources (28)
CVE-2025-5777
Insufficient input validation leading to memory overread when the NetScaler is configured as a Gateway (VPN virtual server, ICA Proxy, CVPN, RDP Proxy) OR AAA virtual server
Traduction et Explication
-
Problème : Il y a une validation des entrées insuffisante qui peut entraîner une lecture de mémoire excessive.
-
Produit concerné : Le NetScaler, lorsqu'il est configuré comme un Gateway (serveur VPN virtuel, ICA Proxy, CVPN, RDP Proxy) ou comme un serveur virtuel AAA (Authentication, Authorization, and Accounting).
Concepts clés
-
Validation des entrées : C'est le processus consistant à vérifier les données fournies par un utilisateur ou un système avant de les traiter. Une validation insuffisante laisse des failles exploitables.
-
Lecture de mémoire excessive : Cela se produit lorsque des données sont lues au-delà des limites prévues, ce qui peut entraîner la divulgation d'informations sensibles ou provoquer un comportement imprévisible.
Risques associés
-
Accès non autorisé : Un attaquant pourrait potentiellement exploiter cette faille pour accéder à des informations qui ne devraient pas être accessibles.
-
Impact sur la sécurité : Cela peut compromettre la confidentialité et l'intégrité des données gérées par le NetScaler.
En résumé, cette vulnérabilité nécessite une attention rapide pour s'assurer que les mécanismes de validation des entrées sont robustes, surtout dans les configurations de passerelle et d'authentification.
Posts / Sources (956)
CVE-2025-55182
A pre-authentication remote code execution vulnerability exists in React Server Components versions 19.0.0, 19.1.0, 19.1.1, and 19.2.0 including the following packages: react-server-dom-parcel, react-server-dom-turbopack, and react-server-dom-webpack. The vulnerable code unsafely deserializes payloads from HTTP requests to Server Function endpoints.
Une vulnérabilité de exécution de code à distance (RCE) pré-authentification existe dans les versions 19.0.0, 19.1.0, 19.1.1 et 19.2.0 des React Server Components, y compris les packages suivants :
- react-server-dom-parcel
- react-server-dom-turbopack
- react-server-dom-webpack
Détails sur la vulnérabilité :
- La vulnérabilité permet à un attaquant d'exécuter du code à distance sans authentification préalable.
- Le code vulnérable désérialise de manière non sécurisée des chargeurs utiles (payloads) provenant de requêtes HTTP vers des points de terminaison (endpoints) de Server Function.
Acronymes :
- RCE (Remote Code Execution) : Exécution de code non autorisé sur un serveur à distance.
- HTTP (HyperText Transfer Protocol) : Protocole utilisé pour la transmission de données sur le Web.
- Server Function : Fonctionnalités côté serveur qui traitent des requêtes et génèrent des réponses.
Il est essentiel que les utilisateurs concernés mettent à jour leurs packages vers une version sécurisée pour éviter les risques d'exploitation.
Posts / Sources (1000)
CVE-2026-11405
The web server binary /bin/httpd contains a hidden backdoor authentication mechanism in the login() function at 004c88b8. - The function contains a normal authentication path using MD5/hash-based password verification (prod_encode64/PasswordToMd5/check_rand_key). - After normal authentication fails, it calls GetValue("sys.rzadmin.password") to read a backdoor password from the device configuration. - It performs a direct strcmp() comparison (plaintext, not hashed) between the config value and the user-supplied password. A successful match grants role=2 (admin-level access) and creates a valid session. The rzadmin username is never checked — any username works with the backdoor
Voici une traduction et explication du texte concernant une vulnérabilité de sécurité :
-
Le binaire du serveur web /bin/httpd contient un mécanisme d'authentification caché dans la fonction login() située à l'adresse 004c88b8.
-
La fonction inclut un chemin d'authentification standard utilisant la vérification de mots de passe basée sur MD5 (une méthode de hachage) via prod_encode64/PasswordToMd5/check_rand_key.
-
Lorsque l'authentification normale échoue, elle appelle GetValue("sys.rzadmin.password") pour lire un mot de passe de backdoor (porte dérobée) depuis la configuration de l'appareil.
-
Une comparaison directe avec strcmp() est effectuée (en texte clair, et non hachée) entre la valeur de configuration et le mot de passe fourni par l'utilisateur.
-
Si la comparaison réussit, l'accès avec le rôle role=2 (niveau d'administrateur) est accordé et une session valide est créée.
-
L'utilisateur « rzadmin » n'est jamais vérifié, ce qui signifie que n'importe quel nom d'utilisateur fonctionne avec cette porte dérobée.
Acronymes utiles : - RCE : Remote Code Execution (exécution de code à distance) - SSRF : Server-Side Request Forgery (forgery de requête côté serveur) - XSS : Cross-Site Scripting (script intersite)
Conclusion : Cette vulnérabilité représente un risque majeur pour la sécurité des systèmes, permettant un accès non autorisé aux fonctions administratives.
Posts / Sources (23)
CVE-2026-41940
cPanel and WHM versions after 11.40 contain an authentication bypass vulnerability in the login flow that allows unauthenticated remote attackers to gain unauthorized access to the control panel.
Vulnérabilité dans cPanel et WHM
Les versions de cPanel et WHM après la version 11.40 présentent une vulnérabilité d'évasion d'authentification dans le processus de connexion. Voici les détails :
- Type de vulnérabilité : Évasion d'authentification
- Impact : Permet à des attaquants distants non authentifiés d'accéder de manière non autorisée au panneau de contrôle.
- Conséquences : Les attaquants peuvent exploiter cette vulnérabilité pour exécuter des actions non autorisées sur le système, compromettant ainsi sa sécurité.
Informations supplémentaires
- cPanel : Un panneau de contrôle d'hébergement web populaire utilisé pour gérer des services de serveur.
- WHM (Web Host Manager) : Utilisé par les administrateurs pour gérer des comptes et serveurs de cPanel.
En résumé, cette vulnérabilité met en risque la sécurité des systèmes utilisant cPanel et WHM, et il est recommandé de mettre à jour vers la version la plus récente pour corriger ce problème.