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-12 → 2026-07-19.
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-63030
WordPress 6.9.x before 6.9.5 and 7.0.x before 7.0.2 is affected by a REST API batch endpoint route confusion issue which, combined with the author__not_in WP_Query SQL Injection (CVE-2026-60137), could allow an attacker to perform SQL Injection and achieve Remote Code Execution.
WordPress versions 6.9.x avant 6.9.5 et 7.0.x avant 7.0.2 sont vulnérables à un problème de confusion de route sur l'endpoint batch de l'API REST. Ce problème, couplé avec une injection SQL dans WP_Query (CVE-2026-60137) en utilisant la variable author__not_in, peut permettre à un attaquant de réaliser une injection SQL et d'obtenir une exécution de code à distance (RCE).
Explications :
- RCE (Remote Code Execution) : Permet à un attaquant d'exécuter des commandes à distance sur le serveur cible.
- SQL Injection : Technique permettant d'injecter des requêtes SQL malveillantes dans une application, ce qui peut compromettre la base de données.
- WP_Query : Classe de WordPress utilisée pour interroger la base de données et récupérer des posts.
Risques :
- Accès non autorisé aux données.
- Contrôle total sur le serveur par des attaquants en utilisant la vulnérabilité.
Recommandations :
- Mettre à jour WordPress vers les versions sécurisées 6.9.5 et 7.0.2.
- Surveiller les logs et l'activité du site pour détecter d'éventuelles tentatives d'exploitation.
Posts / Sources (136)
CVE-2026-15409
A Server-side request forgery (SSRF) vulnerability has been identified in the SMA1000 Appliance Work Place interface. A remote unauthenticated attacker could potentially cause the appliance to make requests to unintended location.
Une vulnérabilité de type Server-side Request Forgery (SSRF) a été identifiée dans l'interface Work Place de l'appliance SMA1000. Voici les détails :
- SSRF : Ce type de vulnérabilité permet à un attaquant d'envoyer des requêtes via un serveur compromis. L'attaquant peut faire en sorte que le serveur cible des ressources internes ou externes non autorisées.
- Dans ce cas, un attaquant distant et non authentifié pourrait exploiter cette vulnérabilité pour inciter l'appliance SMA1000 à effectuer des requêtes vers des emplacements non prévus.
- Cela peut entraîner des fuites d'informations sensibles, un accès à des systèmes internes ou d'autres activités malveillantes.
Mesures recommandées : - Mettre à jour le firmware de l'appliance SMA1000 pour corriger cette vulnérabilité. - Limiter l'accès à l'interface Work Place pour les utilisateurs non autorisés.
Il est crucial de surveiller et de protéger vos systèmes contre de telles vulnérabilités pour éviter des compromissions potentielles.
Posts / Sources (121)
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 ]
Vulnérabilité Résolue dans le Kernèlle Linux
Une vulnérabilité a été corrigée dans le noyau Linux concernant la fonction remove_waiter(), utilisée pour gérer des opérations de verrouillage. Voici les détails :
-
Contexte : remove_waiter() est utilisé lors des chemins de verrouillage lents et pour annuler un verrou proxy via rt_mutex_start_proxy_lock() lors de l'appel depuis futex_requeue().
-
Problèmes identifiés : 1. La déqueuement du rbtree (arbre rouge-noir) se produit sans que le verrou de priorité de la tâche (pi_lock) de waiter::task ne soit détenu. 2. L'état pi_blocked_on de la tâche waiter n'est pas effacé, laissant un pointeur non valide (dangling pointer) prêt pour une utilisation après libération (UAF - Use After Free). 3. rt_mutex_adjust_prio_chain() opère sur la mauvaise tâche de priorité supérieure.
-
Solution : Utiliser waiter::task au lieu de current dans toutes les opérations liées à remove_waiter() pour résoudre ces problèmes.
Cette mise à jour corrige des erreurs potentiellement dangereuses dans la gestion des priorités et des verrous au sein du noyau.
Posts / Sources (161)
CVE-2026-60137
WordPress 6.8.x before 6.8.6, 6.9.x before 6.9.5, and 7.0.x before 7.0.2 does not properly sanitise the author__not_in parameter of WP_Query, which could allow SQL Injection when a plugin or theme passes untrusted input to the parameter.
Vulnérabilité de WordPress
WordPress versions 6.8.x avant 6.8.6, 6.9.x avant 6.9.5, et 7.0.x avant 7.0.2 présentent une vulnérabilité significative dans le traitement du paramètre author__not_in de WP_Query. Voici les détails :
- Sanitisation inadéquate : Ce paramètre n'est pas correctement filtré. Cela signifie que les entrées non vérifiées peuvent être utilisées sans contrôle.
- Injection SQL (SQL Injection) : Cette faille pourrait permettre à un attaquant d'exécuter des requêtes SQL malveillantes dans la base de données. L'injection SQL est une technique où des instructions SQL sont insérées (ou "injected") via des entrées non sécurisées, ce qui peut compromettre les données.
Risques
- Accès non autorisé : Un attaquant pourrait potentiellement lire, modifier ou supprimer des données.
- Exploitation via des plugins ou thèmes : Si un plugin ou un thème utilise ce paramètre sans le filtrer correctement, cela amplifie le risque.
Recommandations
- Mettre à jour WordPress : Il est crucial de mettre à jour vers les versions sécurisées 6.8.6, 6.9.5, ou 7.0.2.
- Valider les entrées : Toujours valider et filtrer les données provenant des utilisateurs dans les développements futurs.
Posts / Sources (88)
CVE-2026-15410
Post-authentication improper control of generation of code ('Code Injection') vulnerability has been identified in the SMA1000 Appliance Management Console (AMC) which in specific conditions could potentially enable a remote authenticated attacker as administrator to execute arbitrary OS commands.
Une vulnérabilité de contrôle inapproprié de la génération de code ("Injection de Code") a été identifiée dans la SMA1000 Appliance Management Console (AMC). Voici les détails :
- Type de vulnérabilité : Post-authentification, ce qui signifie qu'elle peut être exploitée après qu'un utilisateur s'est connecté avec succès.
- Impact : Si exploité, un attaquant distant authentifié avec des droits d'administrateur pourrait exécuter des commandes système arbitraires.
- Conditions spécifiques : Cette vulnérabilité n'est pas universelle ; elle ne se manifeste que dans certaines conditions particulières.
Acronymes
- RCE (Remote Code Execution) : Exécution de code à distance, où un attaquant peut exécuter des commandes sur un système distant.
- SSRF (Server-Side Request Forgery) : Une attaque où un attaquant induit un serveur à faire des requêtes à d'autres ressources en réseau.
- XSS (Cross-Site Scripting) : Une vulnérabilité qui permet à un attaquant d’injecter des scripts malveillants dans des pages vues par d'autres utilisateurs.
La vulnérabilité requiert une attention immédiate pour éviter d'éventuels abus par des attaquants ayant déjà accès à l'interface d'administrateur de la console.
Posts / Sources (74)
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 remote code execution (RCE) avant l'authentification existe dans les versions 19.0.0, 19.1.0, 19.1.1, et 19.2.0 de React Server Components, incluant les paquets suivants :
- react-server-dom-parcel
- react-server-dom-turbopack
- react-server-dom-webpack
Cette vulnérabilité résulte d'une désérialisation non sécurisée des payloads (données envoyées) provenant des requêtes HTTP vers les points de terminaison des Server Function. Cela signifie qu'un attaquant pourrait potentiellement exécuter du code à distance sur le serveur sans nécessiter d'authentification.
Définition des acronymes :
- RCE : Remote Code Execution – Exécution de code à distance, permettant à un attaquant d'exécuter des commandes sur un système distant.
- HTTP : Hypertext Transfer Protocol – Protocole utilisé pour la transmission de données sur le web.
- Payload : Ensemble de données envoyées dans une requête, pouvant contenir des instructions pour le serveur.
Il est crucial de mettre à jour vers des versions sécurisées de React Server Components pour éviter cette vulnérabilité.
Posts / Sources (1000)
CVE-2026-56164
Missing authentication for critical function in Microsoft Office SharePoint allows an unauthorized attacker to elevate privileges over a network.
Analyse de la vulnérabilité
Vulnérabilité : Une authentification manquante pour une fonction critique dans Microsoft Office SharePoint.
- Impact : Permet à un attaquant non autorisé d'élever ses privilèges sur un réseau.
- Produits affectés : Microsoft Office SharePoint.
Détails de la vulnérabilité
- Authentification manquante : Cela signifie que certaines fonctions essentielles ne nécessitent pas de vérification d'identité, ce qui ouvre la porte à des abus.
- Élévation de privilèges : Cela fait référence à la capacité d'un attaquant à obtenir des droits d'accès plus élevés qu'il ne devrait.
Acronymes utiles
- RCE (Remote Code Execution) : Exécution de code à distance, permettant à un attaquant d'exécuter du code malveillant sur un système distant.
- SSRF (Server-Side Request Forgery) : Une attaque où l'attaquant envoie des requêtes à un serveur via une application vulnérable.
- XSS (Cross-Site Scripting) : Une vulnérabilité qui permet d’injecter des scripts malveillants dans des pages web vues par d'autres utilisateurs.
Conclusion
Cette vulnérabilité dans Microsoft Office SharePoint met en risque la sécurité des réseaux, soulignant l'importance de mettre en place une authentification stricte pour toutes les fonctions critiques.
Posts / Sources (70)
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.
Résumé de la vulnérabilité dans le noyau Linux
Dans le noyau Linux, une vulnérabilité a été résolue spécifiquement au sein de KVM (Kernel-based Virtual Machine).
Détails de la vulnérabilité :
- Commande de correction : Commit 0cb2af2ea66ad.
- Problème : Une incohérence dans le shadow paging a été identifiée, liée à un use-after-free imprévu.
- Cela se produit lorsqu'une page de mémoire (memslot) est supprimée après un changement dans le mappage d'une PDE (Page Directory Entry), ce qui crée des entrées qui ne sont plus valides.
Mécanisme de la vulnérabilité :
- Lorsqu'un mappage PDE est modifié, les entrées créées après ce changement peuvent ne pas être reconnues.
- Si la PDE modifiée pointe vers une page non-leaf, cela crée un décalage dans la correspondance des rôles (direct=1 contre direct=0), entraînant une réutilisation incorrecte de pages mémoire.
- Cette situation est problématique lors de la suppression ultérieure de la memslot, car certaines entrées persistent, ce qui peut entraîner un use-after-free.
Conséquence :
- Des appels ultérieurs, comme le dirty logging ou l'invalidation de notificateurs MMU, peuvent accéder à une mémoire qui a déjà été libérée, provoquant des comportements indésirables.
Types de menaces :
- Use-after-free : Cette vulnérabilité permet à un attaquant potentiel d'accéder à des données sensibles ou de provoquer un comportement erroné du système.
Cette vulnérabilité a des implications importantes pour la sécurisation des systèmes virtualisés utilisant KVM sur Linux.
Posts / Sources (146)
CVE-2026-46331
In the Linux kernel, the following vulnerability has been resolved: net/sched: fix pedit partial COW leading to page cache corruption tcf_pedit_act() computes the COW range for skb_ensure_writable() once before the key loop using tcfp_off_max_hint, but the hint does not account for the runtime header offset added by typed keys. This can leave part of the write region un-COW'd. Fix by moving skb_ensure_writable() inside the per-key loop where the actual write offset is known, and add overflow checking on the offset arithmetic. For negative offsets (e.g. Ethernet header edits at ingress), use skb_cow() to COW the headroom instead. Guard offset_valid() against INT_MIN, where negation is undefined.
Dans le noyau Linux, une vulnérabilité a été corrigée :
Détails de la vulnérabilité
- Problème identifié : Dans le fichier
net/sched, le traitement partiel de Copy-On-Write (COW) pouvait entraîner une corruption du cache de pages. - Fonction concernée :
tcf_pedit_act(). - Cause : La fonction calcule la plage COW pour
skb_ensure_writable()une seule fois avant la boucle de vérification des clés, en utilisanttcfp_off_max_hint. Cependant, cette aide ne prend pas en compte le décalage d'en-tête ajouté par les clés typées. Cela peut laisser une partie de la région d'écriture non COW.
Correctif appliqué
- Déplacer
skb_ensure_writable()à l'intérieur de la boucle par clé, là où le décalage d'écriture est connu. - Ajouter une vérification des débordements dans l'arithmétique des décalages.
- Pour les décalages négatifs (comme les modifications de l'en-tête Ethernet à l'entrée), utiliser
skb_cow()pour s'assurer que l'espace mémoire soit correctement géré.
Note technique
- COW (Copy-On-Write) : Technique de gestion de la mémoire où la copie d'un objet n'est effectuée que lorsqu'une modification est tentée.
- INT_MIN : Plus petite valeur possible pour un entier en informatique, dont la négation peut causer des comportements indéfinis.
Posts / Sources (119)
CVE-2026-58644
Deserialization of untrusted data in Microsoft Office SharePoint allows an unauthorized attacker to execute code over a network.
La désérialisation de données non fiables dans Microsoft Office SharePoint permet à un attaquant non autorisé d'exécuter du code à distance, ce qu'on appelle une RCE (Remote Code Execution ou exécution de code à distance). Ce type de vulnérabilité est particulièrement dangereux car il permet à un attaquant de prendre le contrôle d'un système en envoyant des données malveillantes.
Voici un résumé des termes :
- Désérialisation : Processus de conversion de données structurées, comme JSON ou XML, en objets utilisables dans le code. Si des données non fiables sont désérialisées, cela peut conduire à des exécutions de code non souhaitées.
- Microsoft Office SharePoint : Une plateforme de collaboration et de gestion de contenu qui permet aux équipes de travailler ensemble.
- RCE (Remote Code Execution) : Une vulnérabilité qui permet à un attaquant d'exécuter du code sur un système distant, souvent par l'envoi de commandes malicieuses.
En résumé, cette vulnérabilité dans SharePoint peut être exploitée par un attaquant pour exécuter des actions non autorisées sur le réseau. Il est crucial de sécuriser ces systèmes pour éviter de telles attaques.
Posts / Sources (69)
CVE-2026-46817
Vulnerability in the Oracle Payments product of Oracle E-Business Suite (component: File Transmission). Supported versions that are affected are 12.2.3-12.2.15. Easily exploitable vulnerability allows unauthenticated attacker with network access via HTTP to compromise Oracle Payments. Successful attacks of this vulnerability can result in takeover of Oracle Payments. CVSS 3.1 Base Score 9.8 (Confidentiality, Integrity and Availability impacts). CVSS Vector: (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H).
Vulnérabilité dans Oracle Payments
Une vulnérabilité a été identifiée dans le produit Oracle Payments de la suite Oracle E-Business (composant : Transmission de fichiers). Les versions concernées sont 12.2.3 à 12.2.15.
Détails de la vulnérabilité :
- Type d'attaque : Cette vulnérabilité peut être facilement exploitée par un attaquant non authentifié ayant accès au réseau via HTTP.
- Impact : Un exploit réussi peut aboutir à la prise de contrôle de Oracle Payments.
- Score CVSS (Common Vulnerability Scoring System) : 9.8 (sur 10) - Indique un risque élevé.
- Impacts sur la sécurité :
- Confidentialité : Accès non autorisé aux données.
- Intégrité : Altération de données.
- Disponibilité : Affectation de l'accessibilité des services.
CVSS Vector :
(CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H):- AV:N : Accès par réseau
- AC:L : Complexité faible
- PR:N : Pas de privilèges nécessaires
- UI:N : Pas d'interaction utilisateur requise
- S:U : Impact sur le système unique
- C:H/I:H/A:H : Impact élevé sur la confidentialité, l'intégrité et la disponibilité.
Cette vulnérabilité souligne l'importance de sécuriser les accès à Oracle Payments pour prévenir les attaques.
Posts / Sources (175)
CVE-2026-48907
A vulnerability in the JCE editor extension for Joomla allows the creation of new editor profiles for unauthenticated users, ultimately resulting in PHP code upload and execution.
Une vulnérabilité dans l'extension d'éditeur JCE pour Joomla permet aux utilisateurs non authentifiés de créer de nouveaux profils d'éditeur. Cela peut mener à:
- Upload de code PHP : Les utilisateurs peuvent télécharger des fichiers contenant du code PHP malveillant.
- Exécution de code : Une fois le code PHP téléchargé, il peut être exécuté sur le serveur, ce qui pose un risque de Remote Code Execution (RCE) (exécution de code à distance).
Définition des acronymes :
- RCE (Remote Code Execution) : Capacité d'exécuter des commandes à distance sur un serveur, souvent exploitée par des attaquants.
- Joomla : Un système de gestion de contenu (CMS) populaire pour la création de sites web.
- JCE : Un éditeur WYSIWYG (What You See Is What You Get) pour Joomla.
Cette vulnérabilité souligne l'importance de restreindre les permissions des utilisateurs non authentifiés et de mettre à jour régulièrement les extensions pour boucher les failles de sécurité.