Base de données CVE

Erreur de validation de l'origine dans .NET permet à un attaquant non autorisé de divulguer des informations sur le réseau.

Allocation de ressources sans limites ni limitation dans ASP.NET Core permet à un attaquant non autorisé de provoquer un déni de service via le réseau.

Adobe Commerce is affected by an Improper Neutralization of Special Elements Used in a Template Engine vulnerability that could result in arbitrary code execution in the context of the current user. An attacker could exploit this vulnerability to execute arbitrary code. Exploitation of this issue does not require user interaction. Scope is changed.

N-central est vulnérable à une exécution de code à distance pré-authentification. Ce problème affecte N-central : avant 2026.3.1.14.

Une vulnérabilité dans le filtre de contrôle d'accès à l'API interne de N-central permet un accès non autorisé aux API internes. Ceci est corrigé dans N-central 2026.3 HF3 et 2026.4

RouterOS contient une faille de gestion des arguments dans le chemin de connexion SSH impliquant des noms d'utilisateur commençant par un caractère interdit, permettant de modifier le masque de stratégie RouterOS de confiance, entraînant une élévation de privilèges. L'exploitation nécessite une session SSH non authentifiée pour atteindre l'assistant de connexion RouterOS. Ce problème a été corrigé dans les versions : 6.49.21 (Long-term), 7.23.4 (Long-term) et 7.24.2 (Stable)

RouterOS ne compare pas la clé publique RSA complète lors de la correspondance d'une demande d'authentification SSH avec une clé d'utilisateur autorisée, vérifiant le type de clé et le module mais omettant l'exposant. Comme la vérification de signature utilise la clé fournie par le client, un attaquant connaissant un module RSA autorisé peut fournir une clé avec exposant un, forger une signature valide et ouvrir un canal de commande SSH en tant qu'utilisateur cible sans la clé privée. Ce problème a été corrigé dans les versions : 6.49.21 (Long-term), 7.23.4 (Long-term) et 7.24.2 (Stable)

Un contournement d'authentification dans N-central < 2026.3 HF 3 mène à un contournement d'authentification dans les API internes uniquement

Tycon Systems TPDIN-Monitor-WEB3 versions 2.2.9 et antérieures sont vulnérables à une vulnérabilité d'autorisation manquante. Cela pourrait permettre à un attaquant d'extraire les identifiants système, les configurations ou le contenu flash.

Dans Ignition 8.1.53 et versions antérieures, le paramètre Gateway "Create Project Role(s)" était livré vide, ce qui permettait à tout utilisateur authentifié de créer des projets (s'il peut exécuter des gateway scripts). Ignition 8.1.54 restreint la création de projets aux sessions Designer et ne s'appuie plus sur ce paramètre. La série 8.3 n'est pas affectée.

La neutralisation incorrecte des séquences CRLF dans IXON VPN Client avant la version 1.4.7 permet à un attaquant d'exécuter des commandes en tant que root ou SYSTEM. Les valeurs de configuration acceptées par le service local sont écrites dans un fichier consommé ultérieurement par un sous-processus privilégié, sans que les séquences de fin de ligne soient neutralisées, ce qui permet d'introduire des directives supplémentaires dans ce fichier. L'interface de configuration accepte les modifications sans authentifier ni vérifier l'origine du demandeur. La configuration injectée persiste sur le disque après les redémarrages du client et du système d'exploitation, et la connexion VPN continue de fonctionner normalement, de sorte qu'aucun changement de comportement n'est visible pour l'utilisateur.

Tycon Systems TPDIN-Monitor-WEB3 versions 2.2.9 et antérieures sont vulnérables à une vulnérabilité de type cross-site request forgery. Cela pourrait permettre à un attaquant d'effectuer des opérations modifiant l'état sur l'appareil.

Tycon Systems TPDIN-Monitor-WEB3 versions 2.2.9 et antérieures sont vulnérables à une vulnérabilité d'utilisation d'identifiant codé en dur. Cela pourrait permettre à un attaquant d'intercepter des informations sensibles ou des identifiants.

Dans le noyau Linux, la vulnérabilité suivante a été résolue : HID: magicmouse: empêcher la récursion non bornée dans magicmouse_raw_event() magicmouse_raw_event() traite les paquets DOUBLE_REPORT_ID (0xf7), qui regroupent deux rapports tactiles en un seul, en divisant le paquet et en s'appelant elle-même sur chaque moitié. La seule protection contre l'emballement de la récursion est un contrôle "size < 1", qui arrête les appels de taille nulle mais ne limite pas la profondeur de récursion. Un périphérique HID malveillant correspondant à ce pilote peut envoyer un rapport commençant par DOUBLE_REPORT_ID et rempli avec la séquence [0xf7, 0x00]. Chaque niveau consomme deux octets et effectue une récursion sur le reste, de sorte qu'un rapport entrant allant jusqu'à HID_MAX_BUFFER_SIZE (16 KiB) provoque environ 8000 appels imbriqués. Cela épuise facilement la pile du noyau de 16 KiB, conduisant à un stack overflow : un panic avec CONFIG_VMAP_STACK, ou une corruption de mémoire sans elle. Un double rapport n'encapsule jamais que deux rapports normaux ; il n'est jamais légitimement imbriqué. Refuser de ré-entrer dans le cas DOUBLE_REPORT_ID à partir d'un appel récursif afin que la profondeur de récursion soit limitée à deux, tandis que tous les paquets valides continuent d'être analysés exactement comme avant.

Dans le noyau Linux, la vulnérabilité suivante a été résolue : HID: pidff: correction d'une écriture hors limites lorsque hid->inputs est vide hid_pidff_init_with_quirks() dérive son input_dev de list_entry(hid->inputs.next, struct hid_input, list) sans vérifier d'abord que hid->inputs n'est pas vide. Le membre list de struct hid_input se trouve à l'offset 0, donc sur une liste vide list_entry() renvoie &hid->inputs lui-même et le chargement suivant hidinput->input lit un membre sans rapport de struct hid_device. dev est alors un pointeur confondu au niveau des types, et l'initialisation du retour de force écrit à travers lui : chaque set_bit(FF_*, dev->ffbit) stocke 8 octets à dev + 192, au-delà de la fin de l'objet auquel dev est en réalité un alias, et input_ff_create() ajoute d'autres écritures d'un pointeur de tas et de deux pointeurs de fonction. Jusqu'à hid-universal-pidff, le seul appelant était hid_pidff_init() depuis usbhid, qui s'exécute sous HID_CLAIMED_INPUT et a donc toujours au moins un hid_input. universal_pidff_probe() démarre le périphérique avec HID_CONNECT_DEFAULT & ~HID_CONNECT_FF puis appelle directement hid_pidff_init_with_quirks() chaque fois que le descripteur contient une page d'usage PID, contournant ainsi cette barrière. Un descripteur de rapport dont la seule collection d'application est sur HID_UP_PID laisse hid->inputs vide alors que hid_connect() réussit encore via la revendication hidraw, de sorte que probe atteint le list_entry() non protégé. L'écriture se produit dans le chemin de sonde USB, sur la file de travail du hotplug, donc brancher un périphérique malveillant suffit à la déclencher ; aucun logiciel d'attaque ni utilisateur connecté n'est requis. KASAN signale une écriture hors limites de 8 octets dans hid_pidff_init_with_quirks() atteinte depuis universal_pidff_probe(). Vérifier que la liste est vide avant de dériver dev et renvoyer -ENODEV, comme le font déjà les autres pilotes HID de retour de force. universal_pidff_probe() propage l'erreur et déroule. Découvert par XBOW, trié par Baul Lee <[email protected]>

In the Linux kernel, the following vulnerability has been resolved: HID: nintendo: fix out-of-bounds read in joycon_ctlr_read_handler() joycon_ctlr_read_handler() casts an incoming HID input report to struct joycon_input_report and parses it, guarding the cast only with a 12-byte length check: if (size >= 12) /* make sure it contains the input report */ joycon_parse_report(ctlr, (struct joycon_input_report *)data); struct joycon_input_report is 49 bytes: a 13-byte header followed by a union whose IMU arm is 36 bytes. For an IMU report joycon_parse_report() -> joycon_parse_imu_report() walks that union (struct offsets 13..48), so a report of exactly 12 bytes with data[0] == JC_INPUT_IMU_DATA passes the guard yet is read up to 37 bytes past its declared length. The over-read bytes are decoded into accelerometer/gyroscope values and forwarded to userspace through the "(IMU)" input device, leaking driver-internal memory. data[0] and size are fully controlled by a malicious or spoofed Joy-Con/Pro Controller. Receive buffers are sized to the maximum report length, so this is an over-read within the allocation rather than a slab OOB, but the decoded bytes still reach userspace. The sibling subcmd path in joycon_ctlr_handle_event() already bounds the same cast correctly: if (size < sizeof(struct joycon_input_report) || data[0] != JC_INPUT_SUBCMD_REPLY) break; Use the same sizeof(struct joycon_input_report) bound here.

In the Linux kernel, the following vulnerability has been resolved: HID: nintendo: register input device after capabilities are set input_register_device() exposes the device to userspace immediately. In joycon_input_create() it was called before joycon_config_rumble() configures the FF_RUMBLE capability and the memless force-feedback device, so a concurrent EVIOCSFF could dereference a NULL dev->ff. Registering early also means the initial udev event lacks button and axis information, which can make input managers ignore the device. Move input_register_device() to the end of joycon_input_create(), after all capabilities, the IMU input device and the force-feedback callbacks have been configured.

In the Linux kernel, the following vulnerability has been resolved: HID: nintendo: stop device IO before hid_hw_stop on probe failure nintendo_hid_probe() calls hid_device_io_start() before joycon_init() and joycon_leds_create(). If either fails, the error path jumps to err_close which calls hid_hw_close()/hid_hw_stop() without first calling hid_device_io_stop(). hid_hw_stop() does not stop device IO, so hid_input_report() may still run and access driver data that is being torn down, resulting in a use-after-free. Add an err_io_stop label that calls hid_device_io_stop() before hid_hw_close(), and point the two post-io_start error paths at it.

In the Linux kernel, the following vulnerability has been resolved: HID: ft260: fix stack-use-after-return write in I2C read race ft260_i2c_read() points dev->read_buf at a caller-supplied buffer (often an on-stack variable), arms a completion and waits up to five seconds for the device to return the data. The HID input callback ft260_raw_event() runs in the input/IRQ path, independent of the dev->lock mutex held by the read path, and copies the device-supplied payload into dev->read_buf after a plain NULL check. These two paths share read_buf, read_idx and read_len with no serialization. If the device delays its response until the read times out, ft260_i2c_read() resets the controller, clears read_buf and returns, unwinding the stack frame the buffer lived in. A response that arrives at that moment lets ft260_raw_event() pass the NULL check and then memcpy() the device-controlled payload into the now-freed stack location, a bounded but attacker-influenced stack-use-after-return write triggerable by malicious or malfunctioning hardware. Add a dedicated spinlock that serializes every access to read_buf, read_idx and read_len. ft260_raw_event() now holds it across the NULL check, the memcpy and the index update, while the read path takes it when arming and when clearing the buffer, so the teardown can no longer slip between the check and the copy.

In the Linux kernel, the following vulnerability has been resolved: HID: sensor: custom: Fix use-after-free in enable_sensor enable_sensor_store() can call set_power_report_state(), which dereferences sensor_inst->power_state and sensor_inst->report_state. These pointers refer to entries in sensor_inst->fields. Create the field attributes before exposing the enable_sensor sysfs attribute, so enable_sensor cannot be accessed before the state it depends on has been initialized. On remove, delete enable_sensor before freeing the field attributes, so a concurrent sysfs write cannot dereference freed memory through power_state or report_state.