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-06-28 â 2026-07-05.
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-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 Suite (composant : File Transmission). Les versions concernées sont les suivantes : 12.2.3 à 12.2.15.
Détails de la vulnérabilité
- Facilité d'exploitation : Cette vulnérabilité est facilement exploitable par un attaquant non authentifié ayant accÚs au réseau via HTTP.
- Impact potentiel : Les attaques réussies peuvent entraßner la prise de contrÎle de l'application Oracle Payments.
- Scores CVSS :
- CVSS 3.1 Base Score : 9.8, indiquant de graves impacts sur la confidentialité, l'intégrité et la disponibilité.
Terminologie
- CVSS (Common Vulnerability Scoring System) : SystÚme de notation qui évalue la gravité des vulnérabilités.
- Confidentialité : Protection des informations contre une divulgation non autorisée.
- Intégrité : Assurance que les données sont authentiques et non altérées.
- Disponibilité : Garantir que les services sont accessibles lorsque nécessaire.
Les administrateurs de systÚmes concernés doivent évaluer l'impact de cette vulnérabilité et prendre les mesures nécessaires pour la corriger.
Posts / Sources (102)
CVE-2026-45659
Deserialization of untrusted data in Microsoft Office SharePoint allows an authorized attacker to execute code over a network.
Résumé des failles de sécurité
- ProblÚme : Une désérialisation de données non fiables dans Microsoft Office SharePoint.
-
DĂ©sĂ©rialisation : Processus de conversion de donnĂ©es en un objet utilisable. Si les donnĂ©es proviennent d'une source non fiable, cela peut ĂȘtre exploitĂ©.
-
Impact : Permet à un attaquant autorisé d'exécuter du code à distance (RCE : Remote Code Execution) sur un réseau.
- Autorisé : Cela signifie qu'un utilisateur ayant des accÚs légitimes peut effectuer cette attaque, augmentant le risque.
Exemples d'attaques similaires
- SSRF : Server-Side Request Forgery, une attaque oĂč un attaquant manipule un serveur pour effectuer des requĂȘtes non autorisĂ©es.
- XSS : Cross-Site Scripting, qui permet d'injecter du code malveillant dans les pages web visitées par d'autres utilisateurs.
Mesures Ă prendre
- Mettre à jour Microsoft Office SharePoint pour corriger la vulnérabilité.
- Auditer les permissions des utilisateurs pour limiter les accÚs non nécessaires.
- Surveiller les activités suspectes sur le réseau.
La vigilance et la mise en conformité avec les meilleures pratiques de sécurité sont essentielles pour réduire les risques liés à de telles vulnérabilités.
Posts / Sources (170)
CVE-2026-48558
SimpleHelp versions 5.5.15 and prior and 6.0 pre-release versions contain an authentication bypass vulnerability in the OIDC authentication flow. When OIDC authentication is configured, identity tokens submitted during login are accepted without verifying their cryptographic signature. In a vulnerable configuration, a remote, unauthenticated attacker can submit a forged token containing arbitrary identity claims to obtain a fully authenticated technician session. In some configurations, this may also allow bypass of multi-factor authentication. No user interaction is required.
Vulnérabilité d'authentification dans SimpleHelp
Les versions 5.5.15 et antérieures, ainsi que les versions préliminaires 6.0 de SimpleHelp, présentent une vulnérabilité d'esquive d'authentification dans le flux d'authentification OIDC (OpenID Connect).
Détails de la vulnérabilité :
- OIDC est utilisé pour permettre l'authentification des utilisateurs via des identités tierces.
- Dans cette vulnérabilité, les jetons d'identité soumis lors de la connexion sont acceptés sans vérification de leur signature cryptographique.
- Conséquence : Un attaquant distant, non authentifié, peut soumettre un jeton falsifié contenant des revendications d'identité arbitraires.
- Cela permet d'obtenir une session de technicien complÚtement authentifiée.
- Dans certaines configurations, cela pourrait Ă©galement permettre de contourner l'authentification multi-facteur (MFA).
Impact :
- Aucun interinteraction utilisateur n'est requise, rendant l'attaque plus facile à réaliser.
Acronymes :
- OIDC : OpenID Connect, un protocole d'authentification.
- MFA : Authentification Multi-Facteur, une méthode de sécurité qui nécessite plusieurs moyens de vérification.
Cette vulnérabilité souligne l'importance de vérifier les signatures des jetons d'identité et de configurer correctement les mécanismes d'authentification.
Posts / Sources (105)
CVE-2019-8943
WordPress through 5.0.3 allows Path Traversal in wp_crop_image(). An attacker (who has privileges to crop an image) can write the output image to an arbitrary directory via a filename containing two image extensions and ../ sequences, such as a filename ending with the .jpg?/../../file.jpg substring.
Vulnérabilité WordPress - CVE
- Produit concerné : WordPress
- Version : Jusqu'Ă 5.0.3
- Type de vulnérabilité : Path Traversal (traversée de répertoire)
Description
WordPress présente une vulnérabilité de Path Traversal dans la fonction wp_crop_image(). Cette faille permet à un attaquant, qui dispose des droits nécessaires pour recadrer une image, de manipuler le chemin d'enregistrement de l'image résultante.
DĂ©tails de l'attaque
- Impact : Un attaquant peut écrire une image de sortie dans un répertoire arbitraire.
- MĂ©thode : L'attaquant utilise un nom de fichier qui contient :
- Deux extensions d'image (par exemple
.jpg?). - Des séquences de répertoires parent (
../), ce qui lui permet de naviguer dans le systĂšme de fichiers.
Exemples de noms de fichiers malveillants : nom_image.jpg?/../../fichier.jpg.
Conclusion
Cette vulnérabilité peut permettre un accÚs non autorisé aux fichiers du systÚme, compromettant ainsi la sécurité du serveur. Il est recommandé de mettre à jour WordPress à une version corrigée pour éviter les abus.
Posts / Sources (69)
CVE-2026-8451
Insufficient input validation in NetScaler ADC and NetScaler Gateway leading to memory overread if NetScaler ADC or NetScaler Gateway is configured as a SAML IDP
Analyse de la vulnérabilité CVE
- Produits concernés : NetScaler ADC et NetScaler Gateway.
- ProblÚme identifié : Validation d'entrée insuffisante.
Détails de la vulnérabilité :
- Cette faille peut entraßner une lecture de mémoire excessive (memory overread) si le produit est configuré comme Identity Provider (IDP) pour le SAML (Security Assertion Markup Language).
Conséquences potentielles :
- La lecture de mémoire excessive peut permettre à un attaquant d'accéder à des informations sensibles ou de provoquer un comportement imprévu dans l'application.
Explications des acronymes :
- SAML : Protocole utilisé pour l'authentification et l'échange d'informations d'identité.
- IDP : Fournisseur d'identité, qui gÚre l'authentification des utilisateurs.
- Memory overread : Situation oĂč le programme lit des donnĂ©es d'une zone de mĂ©moire qui ne lui appartient pas, potentiellement exposant des donnĂ©es sensibles.
Importance de corriger la vulnérabilité :
- Il est crucial de veiller à une validation adéquate des entrées afin d'éviter ces types de failles qui compromettent la sécurité des systÚmes.
Posts / Sources (55)
CVE-2026-43503
In the Linux kernel, the following vulnerability has been resolved: net: skbuff: propagate shared-frag marker through frag-transfer helpers Two frag-transfer helpers (__pskb_copy_fclone() and skb_shift()) fail to propagate the SKBFL_SHARED_FRAG bit in skb_shinfo()->flags when moving frags from source to destination. __pskb_copy_fclone() defers the rest of the shinfo metadata to skb_copy_header() after copying frag descriptors, but that helper only carries over gso_{size,segs, type} and never touches skb_shinfo()->flags; skb_shift() moves frag descriptors directly and leaves flags untouched. As a result, the destination skb keeps a reference to the same externally-owned or page-cache-backed pages while reporting skb_has_shared_frag() as false. The mismatch is harmful in any in-place writer that uses skb_has_shared_frag() to decide whether shared pages must be detoured through skb_cow_data(). ESP input is one such writer (esp4.c, esp6.c), and a single nft 'dup to <local>' rule -- or any other nf_dup_ipv4() / xt_TEE caller -- is enough to land a pskb_copy()'d skb in esp_input() with the marker stripped, letting an unprivileged user write into the page cache of a root-owned read-only file via authencesn-ESN stray writes. Set SKBFL_SHARED_FRAG on the destination whenever frag descriptors were actually moved from the source. skb_copy() and skb_copy_expand() share skb_copy_header() too but linearize all paged data into freshly allocated head storage and emerge with nr_frags == 0, so skb_has_shared_frag() returns false on its own; they need no change. The same omission exists in skb_gro_receive() and skb_gro_receive_list(). The former moves the incoming skb's frag descriptors into the accumulator's last sub-skb via two paths (a direct frag-move loop and the head_frag + memcpy path); the latter chains the incoming skb whole onto p's frag_list. Downstream skb_segment() reads only skb_shinfo(p)->flags, and skb_segment_list() reuses each sub-skb's shinfo as the nskb -- both p and lp must carry the marker. The same omission also exists in tcp_clone_payload(), which builds an MTU probe skb by moving frag descriptors from skbs on sk_write_queue into a freshly allocated nskb. The helper falls into the same family and warrants the same fix for consistency; no TCP TX-side in-place writer is currently known to reach a user page through this gap, but a future consumer depending on the marker would regress silently. The same omission exists in skb_segment(): the per-iteration flag merge takes only head_skb's flag, and the inner switch that rebinds frag_skb to list_skb on head_skb-frags exhaustion does not fold the new frag_skb's flag into nskb. Fold frag_skb's flag at both sites so segments drawing frags from frag_list members carry the marker.
Résumé de la vulnérabilité dans le noyau Linux
Une vulnérabilité a été corrigée dans le noyau Linux, spécifiquement dans la gestion des fragments de paquets réseau :
- Vulnérabilité : Ceci concerne les aides à la transférer les fragments (
frag-transfer helpers) qui ne propagent pas correctement l'indicateurSKBFL_SHARED_FRAG(un marqueur signalant que les fragments sont partagés) lorsqu'ils déplacent des fragments d'une source vers une destination.
DĂ©tails techniques :
- Fonctions concernées :
__pskb_copy_fclone()-
skb_shift() -
Ces fonctions omettent de mettre Ă jour l'indicateur dans
skb_shinfo()->flags, entraĂźnant une incohĂ©rence. Cela donne un faux rĂ©sultat Ăskb_has_shared_frag(), indiquant qu'il n'y a pas de fragments partagĂ©s lorsqu'en rĂ©alitĂ©, ils existent. -
Conséquences potentielles : Cela pourrait permettre aux utilisateurs non privilégiés d'écrire dans le cache de pages d'un fichier en lecture seule appartenant à root à travers des écritures non autorisées.
Rappel des acronymes :
- RCE : Remote Code Execution (exécution de code à distance)
- SSRF : Server Side Request Forgery (forçage de requĂȘte cĂŽtĂ© serveur)
- XSS : Cross-Site Scripting (script intersite)
Remédiation :
La correction consiste à s'assurer que SKBFL_SHARED_FRAG est correctement établi sur la destination dÚs qu'un fragment est déplacé de la source. Les fonctions comme skb_copy() et skb_copy_expand() ne nécessitent pas de modifications car elles renvoient nr_frags == 0.
Posts / Sources (81)
CVE-2026-8037
OS Command Injection Remote Code Execution Vulnerability in API in Progress ADC Products allows an un-authenticated attacker to execute arbitrary commands on the LoadMaster appliance by exploiting unsanitized input in multiple command endpoints
Vulnérabilité d'Injection de Commande OS - Exécution de Code à Distance (RCE)
- Une vulnérabilité d'injection de commande OS a été identifiée dans l'API des produits Progress ADC.
- Cette faille permet à un attaquant non authentifié d'exécuter des commandes arbitraires sur l'appliance LoadMaster.
- L'exploitation de cette vulnérabilité repose sur des entrées non assainies dans plusieurs points d'accÚs de commande.
Explications des termes :
- RCE (Remote Code Execution) : Exécution de code malveillant sur un systÚme distant à l'aide d'une vulnérabilité.
- Injection de Commande : Technique d'attaque oĂč un attaquant insĂšre des commandes dans un systĂšme afin de les exĂ©cuter.
- API (Application Programming Interface) : Interface qui permet Ă des applications de communiquer entre elles.
Cette vulnérabilité pose un risque majeur, car des attaquants peuvent prendre le contrÎle de l'appliance LoadMaster en exploitant cette faille. La mise à jour et la sécurisation des points d'accÚs sont essentielles pour éviter une telle exploitation.
Posts / Sources (46)
CVE-2026-55200
libssh2 through 1.11.1, fixed in commit 7acf3df contains an out-of-bounds write vulnerability in ssh2_transport_read() that fails to enforce upper bounds on packet_length field. Remote attackers can send crafted SSH packets with excessively large packet_length values to corrupt heap memory and achieve remote code execution.
Vulnérabilité libssh2 (CVE non spécifiée)
- Produit concerné : libssh2 jusqu'à la version 1.11.1.
- Correction : ProblÚme résolu dans le commit 7acf3df.
Détails de la vulnérabilité :
- Une vulnérabilité de écriture hors limites dans la fonction ssh2_transport_read().
- Cette faille ne respecte pas les limites supérieures du champ packet_length (longueur du paquet).
Implications :
- Des attaquants distants peuvent envoyer des paquets SSH malveillants avec des valeurs de packet_length excessivement grandes.
- Cela peut corrompre la mémoire heap (zone de mémoire dynamique) et permettre l'exécution de code à distance (RCE, Remote Code Execution).
Terminologie :
- RCE : Exécution de code à distance, permettant à un attaquant d'exécuter des commandes sur un systÚme à distance.
- Ăcriture hors limites : Ăcrire dans une zone de mĂ©moire non allouĂ©e, ce qui peut entraĂźner des comportements imprĂ©vus ou des failles de sĂ©curitĂ©.
Il est crucial de mettre à jour libssh2 à une version corrigée pour éviter cette vulnérabilité.
Posts / Sources (63)
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.
Vulnérabilité dans le noyau Linux
Une vulnérabilité a été corrigée dans le noyau Linux :
- Composant concerné : eventpoll.
- ProblÚme identifié : Dans la fonction
ep_remove(), la structureeventpoll/filesubissait une utilisation aprÚs libération (Use-After-Free, UAF). Lorsqueep_remove_file()était appelé,file->f_epétait réinitialisé sousfile->f_lock, mais@fileétait encore utilisé dans la section critique. - Conséquence : Cela permettait à un concurrent d'exécuter
__fput(), ce qui pouvait mener à des actions non sécurisées sur de la mémoire déjà libérée, rendant la machine vulnérable.
Concepts clés à comprendre :
- UAF (Use-After-Free) : Cela se produit lorsqu'un programme continue d'utiliser un morceau de mémoire aprÚs qu'il a été libéré.
- kmem_cache_free() : Fonction pour libérer une mémoire qui a été allouée.
- hlist_del_rcu() : Fonction qui manipule des listes liées en toute sécurité en environnement concurrent.
Solutions apportées :
- Pinning d'@file : On maintien la rĂ©fĂ©rence Ă
@fileviaepi_fget()au dĂ©but deep_remove(). Cela empĂȘche la rĂ©fĂ©rence de descendre Ă zĂ©ro, maintenant le structeventpollactif durant les opĂ©rations critiques. - VĂ©rification des conditions de concurrence : Un pincement rĂ©ussi garantit qu'il n'y a pas de compĂ©tition avec
eventpoll_release_file()pour cet événement, simplifiant ainsi le traitement.
Cette correction renforce la sécurité des interactions avec les structures de fichiers et d'événements, limitant les possibilités d'exploitation par des attaquants.