By weakness (CWE)

CWE-843: related vulnerabilities

CVEs classified under CWE-843. Understanding the weakness class helps prioritize systemic fixes over one-off patches.

43 published vulnerabilities

• CVE-2026-0162HIGH 8.8

  A flaw in Android's audio SDP (Session Description Protocol) parser allows an authenticated attacker to corrupt memory on a device by sending a specially crafted audio payload. The vulnerability stems from the parser confusing one data type for another, which can be exploited to run arbitrary code without needing special privileges. The attacker only needs valid credentials to the affected system—they don't need to trick a user into performing any action.

• CVE-2026-10910HIGH 8.8

  Google Chrome contains a type confusion vulnerability in its V8 JavaScript engine that allows an attacker to execute arbitrary code within the browser's sandbox by sending a specially crafted HTML page to a user. The vulnerability requires user interaction (clicking a link or visiting a malicious site) but no special privileges. Once exploited, an attacker gains the ability to run code inside the sandbox, potentially leading to data theft, credential capture, or lateral movement to the underlying system.

• CVE-2026-10935HIGH 8.8

  A type confusion vulnerability in Google Chrome's V8 JavaScript engine allows attackers to execute arbitrary code within the browser's sandbox by tricking users into visiting a malicious website. The vulnerability affects Chrome versions prior to 149.0.7827.53 and requires user interaction (clicking a link or visiting a page). While the code executes within the sandbox, successful exploitation could allow attackers to read, modify, or delete user data accessible to the browser.

• CVE-2026-10936HIGH 8.8

  A type confusion flaw in Chrome's V8 JavaScript engine allows attackers to execute arbitrary code within the browser's sandbox by tricking users into viewing a specially crafted webpage. The vulnerability requires user interaction (clicking a link or visiting a site) but no authentication or special privileges. Successful exploitation could give an attacker the ability to run malicious code with the same permissions as the Chrome process.

• CVE-2026-10955HIGH 8.8

  A type confusion vulnerability exists in ANGLE, the graphics abstraction layer used by Google Chrome on Windows. An attacker can craft a malicious web page that, when visited by a user, exploits this flaw to access memory outside intended boundaries. This could lead to information disclosure, data corruption, or system crashes. The vulnerability requires user interaction (visiting a malicious page) but needs no special privileges to trigger.

• CVE-2026-10962HIGH 8.8

  A type confusion vulnerability in Google Chrome's media handling allows attackers to execute malicious code within the browser's sandbox through a specially crafted webpage. The vulnerability requires user interaction (visiting a malicious page) but poses significant risk because it bypasses browser security boundaries. Chrome versions prior to 149.0.7827.53 are affected across Windows, macOS, and Linux platforms.

• CVE-2026-11076HIGH 8.8

  A type confusion vulnerability in Google Chrome's CSS handling allows attackers to execute malicious code within the browser's sandbox by tricking users into visiting a specially crafted webpage. The vulnerability affects Chrome versions prior to 149.0.7827.53 and requires user interaction (clicking a link or visiting a site), but once triggered, grants the attacker code execution capabilities despite the sandbox protections that normally isolate the browser from the rest of the system.

• CVE-2026-11662HIGH 8.8

  A type confusion vulnerability in Google Chrome's bindings mechanism allows attackers to execute arbitrary code within the Chrome sandbox by serving a specially crafted HTML page. The flaw affects Chrome versions before 149.0.7827.103 and requires user interaction (visiting a malicious page) to trigger. While sandboxed, successful exploitation could lead to complete compromise of the affected Chrome process, including data theft and system-level attacks if combined with additional vulnerabilities.

• CVE-2026-13967HIGH 8.8

  Google Chrome contains a heap buffer overflow vulnerability in its V8 JavaScript engine that could allow attackers to run malicious code within Chrome's sandbox by sending users a crafted webpage. The vulnerability requires user interaction—specifically visiting a malicious site—but once triggered, grants an attacker the ability to execute arbitrary code with the privileges of the Chrome process. This is a serious flaw because while Chrome's sandbox provides some containment, code execution within it can still lead to data theft or further system compromise.

• CVE-2026-14431HIGH 8.8

  A type confusion flaw in Chrome's V8 JavaScript engine allows attackers to run malicious code within the browser's sandbox by serving a specially crafted webpage. The vulnerability requires user interaction (visiting a malicious site) but carries high risk because it bypasses the sandbox's isolation protections and can lead to full browser compromise.

• CVE-2026-43705HIGH 8.8

  A type confusion vulnerability in Apple's WebKit engine allows attackers to cause memory corruption when users visit malicious websites. The flaw affects Safari and embedded browsers across iPhones, iPads, and Macs. An attacker would craft a webpage that confuses the browser about what type of data it's processing, leading to memory corruption that can compromise confidentiality, integrity, and availability. The attack requires user interaction (visiting the site) but no special privileges.

• CVE-2026-9983HIGH 8.8

  A type confusion vulnerability in Chrome's Skia graphics engine allows attackers to execute arbitrary code within Chrome's sandbox by tricking users into visiting a malicious website. The attacker needs no special privileges—just the ability to craft a deceptive HTML page. Once code runs in the sandbox, it gains significant capabilities including reading sensitive data, modifying content, and disrupting the browser. Chrome version 148.0.7778.216 and later patch this flaw.

• CVE-2026-45456HIGH 8.4

  A type confusion flaw in Microsoft Office allows an attacker with local access to execute arbitrary code on a machine without requiring user interaction or elevated privileges. The vulnerability stems from improper handling of incompatible data types in memory, which an attacker can exploit to gain full system compromise including reading, modifying, or deleting files. This is a local-only attack—the attacker must already have a foothold on the system, but once exploited, the impact is severe.

• CVE-2026-45641HIGH 8.4

  CVE-2026-45641 is a type confusion vulnerability in Windows Hyper-V that allows an attacker with local system access to execute arbitrary code with full privileges. The flaw stems from the hypervisor incorrectly handling resource access when different data types are confused during processing, leading to memory corruption and code execution. This is a serious local privilege escalation vector affecting multiple Windows 10 and Windows 11 versions, as well as Windows Server 2022 and 2025.

• CVE-2026-13803HIGH 8.3

  A type confusion vulnerability in Google Chrome's tab handling mechanism allows an attacker who has already compromised a renderer process to escape the browser's sandbox through a specially crafted HTML page. This is a multi-step attack: the attacker must first gain code execution within Chrome's renderer process, then leverage this type confusion flaw to break out of the sandbox entirely, potentially gaining full system access. The vulnerability affects Chrome versions before 150.0.7871.47.

• CVE-2026-58285HIGH 8.3

  Microsoft Edge (Chromium-based) contains a type confusion vulnerability that allows attackers to execute arbitrary code on a user's computer through network-based exploitation. The flaw occurs when the browser processes incompatible data types in memory, leading to a security boundary violation. Successful exploitation requires user interaction—typically visiting a malicious website or opening a crafted link—but does not require the attacker to have any elevated privileges or prior system access.

• CVE-2026-58295HIGH 8.3

  Microsoft Edge (Chromium-based) contains a type confusion vulnerability that allows attackers to bypass security features through network requests without requiring user interaction or special privileges. The vulnerability receives a HIGH severity rating due to its network-exploitable nature and potential to undermine browser security controls.

• CVE-2026-58592HIGH 8.3

  Ladybird, a web browser engine, has a memory-safety vulnerability in how it handles WebAssembly modules imported through the ESM (ECMAScript Modules) standard. When JavaScript code imports a WebAssembly function, the browser temporarily creates a function descriptor on the stack. If that descriptor is destroyed before the WebAssembly code finishes using it, the WebAssembly code ends up holding a reference to memory that's no longer valid. An attacker can exploit this stale reference to make the WebAssembly code write data to arbitrary memory locations, potentially achieving code execution within the browser's content process. The flaw requires user interaction (clicking or otherwise engaging with a malicious web page) to trigger, but no special browser features need to be enabled.

• CVE-2026-45635HIGH 8.1

  A type confusion vulnerability in Windows' Universal Plug and Play (UPnP) component allows attackers to execute code remotely on affected systems without authentication. The flaw stems from improper handling of incompatible data types in upnp.dll, which can be exploited over a network to gain full system compromise. This affects a broad range of Windows versions from Windows 10 through Windows 11, as well as Windows Server deployments.

• CVE-2026-58283HIGH 8.1

  Microsoft Edge (Chromium-based) contains a type confusion vulnerability that allows attackers to spoof content or resources over a network without requiring user interaction. The flaw arises from the browser accessing resources using incompatible data types, creating a logic gap that an unauthenticated attacker can exploit remotely. While the attack complexity is moderately high, successful exploitation could result in integrity compromise and limited information disclosure.

• CVE-2026-12390HIGH 7.8

  AzeoTech DAQFactory contains a type confusion flaw that allows attackers to execute arbitrary code when a user opens a specially crafted .ctl (control) file. The vulnerability affects DAQFactory version 21.1 and earlier. Type confusion occurs when an application mishandles data types, treating one kind of data as another—in this case, an attacker can exploit this confusion through a malicious file to gain code execution on the affected system. User interaction is required (opening the file), but no special privileges are needed beforehand.

• CVE-2026-44817HIGH 7.8

  A type confusion vulnerability in Microsoft Office Excel enables local code execution when a user opens a malicious file. An attacker would craft a specially formatted Excel document that exploits how the application handles certain data types in memory, allowing arbitrary code to run with the privileges of the user who opened the file. This is a local attack requiring user interaction—the victim must open the malicious spreadsheet—but once triggered, it grants full system compromise capabilities.

• CVE-2026-45600HIGH 7.8

  A type confusion flaw exists in Windows kernel-mode drivers that allows a user already logged into a Windows system to escalate their privileges to a higher level of access. An attacker would need valid credentials and local access to exploit this issue. The vulnerability affects recent versions of Windows 11 and Windows Server 2025.

• CVE-2026-57254HIGH 7.8

  A flaw in PDF parsing allows a specially crafted PDF file to crash applications that read or edit it. The vulnerability exists because these applications fail to properly validate data types when encountering abnormal annotations within PDF documents. An attacker can exploit this by distributing a malicious PDF that causes the application to crash when opened, resulting in a denial of service. The vulnerability requires user interaction—someone must open the PDF file—but does not require special privileges to trigger.

• CVE-2026-10022HIGH 7.5

  A type confusion flaw in Google Chrome's V8 JavaScript engine (CVE-2026-10022) allows attackers to execute arbitrary code within the browser sandbox if they can trick a user into installing a malicious Chrome extension. The vulnerability affects Chrome versions before 148.0.7778.216 and impacts Windows, macOS, and Linux systems. While the underlying Chromium severity is rated Medium by Google, the CVSS v3.1 score of 7.5 reflects the practical risk: an attacker gaining code execution inside the Chrome sandbox can read sensitive data, modify browser state, or escalate privileges. The attack requires social engineering to distribute the malicious extension, which limits opportunistic exploitation but remains a credible threat in targeted campaigns.

• CVE-2026-44628HIGH 7.5

  CVE-2026-44628 is a denial-of-service vulnerability affecting worklist servers that allows an unauthenticated attacker to crash the service by sending a specially crafted query. The attack succeeds only when specific conditions are met: the server must have a valid Called AE Title (an identifier used in DICOM medical imaging protocols), a corresponding storage directory, an expected lockfile, and at least one matching worklist record in the database. Once triggered, the crash renders the worklist service unavailable until manual restart.

• CVE-2026-57975HIGH 7.5

  Microsoft Edge (Chromium-based) contains a type confusion vulnerability that allows attackers to execute arbitrary code on a user's system through network-based attack vectors. An attacker crafts malicious content that tricks Edge into mishandling objects in memory, leading to code execution. The vulnerability requires user interaction—such as visiting a malicious website or opening a crafted file—making it a practical threat to organizations where browsing is common. The HIGH severity reflects the combination of remote attack capability and the ability to fully compromise the system.

• CVE-2026-58290HIGH 7.5

  A type confusion vulnerability in Microsoft Edge (Chromium-based) allows attackers to execute arbitrary code on a victim's system through network-based exploitation. The flaw arises from improper handling of incompatible data types in memory, which an attacker can abuse to overwrite code regions or manipulate execution flow. Successful exploitation requires user interaction—typically opening a malicious webpage—but once triggered, grants the attacker the same privileges as the logged-in user.

• CVE-2026-11463HIGH 7.3

  USCiLab Cereal, a serialization library used in C++ applications, contains a type confusion vulnerability in how it handles shared pointers during deserialization. An attacker can send specially crafted data over the network to cause the library to misinterpret object types, potentially leading to information disclosure, data corruption, or application crashes. The vulnerability affects versions up to and including 1.3.2, and exploit code has already been publicly shared.

• CVE-2026-9334HIGH 7.3

  CVE-2026-9334 is a type-confusion vulnerability in Cpanel::JSON::XS (a Perl JSON parsing library) that occurs when a specific feature called dupkeys_as_arrayref is enabled. When decoding JSON with duplicate object keys, the library crashes and attempts to dereference attacker-controlled data as a pointer. An attacker can exploit this by sending crafted JSON to any application using this library with the vulnerable setting enabled, potentially leading to denial of service or information disclosure.

• CVE-2026-11196MEDIUM 6.5

  Google Chrome versions before 149.0.7827.53 contain a type confusion bug in XML processing that allows an attacker to craft a malicious XML file. When a user opens this file in Chrome, the vulnerability can leak sensitive data from the browser's memory without requiring special user permissions or network-level access. The flaw affects Windows, macOS, and Linux users. While the attack requires user interaction (opening a file), the potential exposure of process memory makes this a notable security concern for organizations where users handle untrusted documents.

• CVE-2026-14119MEDIUM 6.5

  Google Chrome on Windows contains a type confusion vulnerability in its Bluetooth handling that could allow an attacker already present on your local network to read sensitive data from Chrome's process memory by presenting a specially crafted Bluetooth peripheral. The vulnerability affects Chrome versions before 150.0.7871.47. While the technical severity is rated Medium, the practical risk is moderated by the requirement that an attacker must already have local network access and the ability to present a malicious Bluetooth device.

• CVE-2026-14148MEDIUM 6.5

  A type confusion flaw in Google Chrome's CSS handling allows a remote attacker to trick a user into visiting a malicious webpage and potentially read sensitive data from the browser's process memory. The vulnerability requires user interaction (clicking a link or visiting a page) but no special privileges. While Chromium rates the severity as low, the ability to leak memory contents elevates practical risk for targeted attacks.

• CVE-2026-54164MEDIUM 6.5

  API Platform, a popular framework for building REST and GraphQL APIs, contains a type-confusion vulnerability in how it processes related resources. When an API accepts write requests (creating, updating, or patching data), an authenticated attacker can supply a link to a resource of the wrong type, and the system may silently accept it instead of rejecting the mismatch. This corrupts the internal integrity of the data model. The vulnerability affects versions before 4.1.30, 4.2.26, and 4.3.12, though the impact varies depending on whether the API uses older or newer PHP coding patterns.

• CVE-2026-58305MEDIUM 6.1

  Samsung's Escargot, an open-source JavaScript engine, contains a type confusion vulnerability that allows an attacker to manipulate memory pointers. The flaw requires local access and user interaction (such as opening a malicious file or visiting a compromised page), but once triggered, it can cause application crashes or data corruption. This is a memory safety issue stemming from improper type handling during resource access.

• CVE-2026-12298MEDIUM 5.4

  A memory safety vulnerability was discovered in Mozilla Firefox and Thunderbird that allows an attacker to read or modify memory during user interaction with a malicious website or email. The flaw does not enable remote code execution or denial of service, but could leak sensitive information or corrupt application state. Mozilla has released patched versions to address this issue.

• CVE-2026-12299MEDIUM 5.4

  A flaw in Firefox and Thunderbird's just-in-time (JIT) compiler causes incorrect code generation when processing web page structures (DOM). An attacker can craft a malicious webpage that, when visited, exploits this miscompilation to read small amounts of data or alter page content in the user's browser session. The vulnerability requires user interaction—specifically, visiting a compromised or attacker-controlled site—but does not allow the attacker to execute arbitrary code or crash the application.

• CVE-2026-8499MEDIUM 5.3

  The Helpfulcrowd Product Reviews plugin for WordPress contains a critical logic flaw that allows unauthenticated attackers to bypass security checks and modify the plugin's configuration settings. An attacker can send a specially crafted request with a JSON boolean value to trick the plugin's validation function into accepting unauthorized access, then write arbitrary settings into the WordPress database. This vulnerability affects versions 1.2.9 and earlier.

• CVE-2026-59152MEDIUM 5.0

  The LangSmith Client SDKs contain a vulnerability in their TracingMiddleware component that allows an attacker to read arbitrary files from a server and secretly upload them to LangSmith. An attacker with read access to a LangSmith workspace—such as a low-privilege team member, contractor, or compromised account—can exploit this to access files on any server running the vulnerable middleware, even without direct server access. This breaks the intended security boundary by granting file-read capabilities beyond what workspace permissions should allow. The vulnerability affects all LangSmith SDK versions before 0.8.18.

• CVE-2026-44640MEDIUM 4.5

  NanoMQ is an edge messaging platform that implements the MQTT protocol for lightweight IoT and edge device communication. A type confusion bug exists in versions before 0.24.14 in how the broker handles QUIC connection objects during the dialing and closing lifecycle. When the broker initiates a QUIC connection (dialing), it stores a pointer as one type (nni_quic_conn), but later during cleanup, the code misinterprets that same pointer as a different type (ex_quic_conn). This mismatch causes the broker to read and operate on invalid memory, resulting in hangs or crashes when closing connections. The issue requires local access and user interaction to trigger.

• CVE-2026-45702MEDIUM 4.4

  OP-TEE, a security-focused component running on Arm processors, contains a type confusion flaw when handling memory-sharing requests from the normal operating system. The vulnerability only affects specific OP-TEE configurations used to manage secure applications (when both SPMC mode and secure partition features are enabled). An attacker with high system privileges can trigger a denial of service, though the flaw does not expose sensitive data or allow code execution. Upgrading to OP-TEE version 4.11.0 or later resolves the issue.

• CVE-2026-10702MEDIUM 4.3

  A flaw in Firefox's JavaScript Just-In-Time (JIT) compiler can cause it to miscompile code in certain circumstances. When a user visits a malicious website, the affected browser may crash or become unstable due to incorrect code generation during compilation. This is not a memory corruption issue and does not allow attackers to steal data or take control of the system, but it does impact availability and user experience.

• CVE-2026-11785MEDIUM 4.3

  CVE-2026-11785 is a flaw in 389 Directory Server that leaks partial stack memory addresses to authenticated users through LDAP responses. An attacker with valid LDAP credentials can trigger a type confusion error during SSO token processing, causing the server to inadvertently expose memory layout information. This is a limited disclosure risk—the attacker must already be authenticated, and only partial address information is exposed—but it can provide a foothold for more advanced attacks that rely on defeating address space layout randomization (ASLR).