Type confusion in V8 (Chrome's JavaScript engine) in versions prior to 152.0.7977.82 enables unauthenticated remote attackers to execute arbitrary code within Chrome's renderer sandbox by enticing a user to visit a specially crafted HTML page. The flaw exploits V8's type system, allowing an attacker to manipulate object type metadata in the JavaScript heap to gain controlled memory access and code execution inside the renderer process. No public exploit or CISA KEV listing has been identified at time of analysis, though V8 type confusion vulnerabilities in Chrome have historically attracted rapid weaponization given the browser's enormous attack surface and attacker interest.
Unauthenticated stacked SQL injection in SciPhi-AI R2R through version 3.6.6 lets remote attackers execute arbitrary SQL by manipulating the index name parameter of the vector index creation endpoint. Because the index name is interpolated directly into a CREATE INDEX statement and executed under the PostgreSQL superuser account, an attacker can run arbitrary DDL and DML via semicolon-separated statements, fully compromising the backing database. Publicly available exploit code exists (reported by VulnCheck), though there is no public exploit identified as being used in active attacks.
Arbitrary OS command execution in GeoNetwork before 4.4.12 and 4.2.17 arises because the Saxon XSLT processor that renders formatters runs without FEATURE_SECURE_PROCESSING and with Java extension functions (ALLOW_EXTERNAL_FUNCTIONS) enabled. A user privileged enough to upload a formatter can supply a malicious .xsl stylesheet that invokes java.lang.Runtime.exec() or java.lang.ProcessBuilder, running commands as the GeoNetwork process user. No public exploit is identified at time of analysis, though the vendor GHSA advisory and public reporting describe the technique in detail.
OS command injection in D-Link DNS-320 ShareCenter firmware 2.06B01 allows a remote authenticated attacker to execute arbitrary operating system commands by supplying a crafted value for the fileurl parameter in the File Sharing CGI handler (/cgi/file_sharing.cgi). The vulnerability carries a CVSS 4.0 base score of 8.5 with high-privilege requirement but yields full system-level compromise on success, including subsequent-system impact. A public exploit has been disclosed, materially lowering the barrier to exploitation for any remaining deployments of this legacy NAS appliance.
OS command injection in D-Link DNS-340L firmware 1.01B04 allows authenticated remote attackers to execute arbitrary operating system commands by manipulating the `callback_url` or `sync_interval` arguments passed to the `/cgi-bin/dropbox.cgi` CGI handler. A public proof-of-concept exploit exists, raising the likelihood of opportunistic exploitation against exposed NAS devices. No patch has been identified at time of analysis, and the DNS-340L is likely an end-of-life product with no vendor remediation roadmap.
Pre-authentication remote buffer overflow in Tenda HG10 router firmware version 300001138 allows unauthenticated network attackers to execute arbitrary code by sending an oversized Username value to the Boa Web Server's /boaform/formLogin endpoint. The formLogin function performs no bounds checking on the supplied credential field, enabling stack or heap corruption reachable directly from the WAN or LAN interface without any prior authentication. A public proof-of-concept exploit has been disclosed on GitHub, materially lowering the bar for exploitation. No public exploit identified at time of analysis is overridden here: publicly available exploit code exists.
Remote code execution in NousResearch Hermes Agent 0.18.2-0.21.0 allows an unauthenticated attacker to execute arbitrary OS commands in the victim's process context by supplying a malicious git repository containing a crafted `.git/config` that sets `core.fsmonitor` to an attacker-controlled binary or script. Exploitation is triggered the moment a user opens the malicious repository and sends any message, causing the agent's internal git status call to invoke the injected command and expose the full process environment - including configured LLM provider API keys. A public exploit writeup exists (manifold.security), and a patch was released as commit f6234d0.
Unauthenticated SQL injection in SciPhi-AI R2R through version 3.6.6 exposes the application database to blind data exfiltration via the retrieval search endpoint's filter key parameter. The root cause is direct string interpolation of attacker-controlled filter keys into SQL WHERE clauses with no parameterization or escaping, enabling both time-based and boolean-based extraction techniques. A publicly available proof-of-concept exploit exists (VulnCheck, GitHub issue #2308), materially elevating the practical risk beyond the theoretical; no CISA KEV listing at time of analysis.
Unauthenticated arbitrary file upload in GeoNetwork prior to versions 4.4.12 and 4.2.17 allows remote attackers to write malicious XSLT or ZIP formatter files directly to the server's formatter directory without any authorization check. Because GeoNetwork processes uploaded `.xsl` formatter files server-side via a Java XSLT engine when rendering metadata records, attackers can weaponize this upload into a remote code execution chain by embedding Java extension function calls within the XSLT payload. No public exploit has been confirmed at time of analysis, but The Hacker News coverage explicitly frames this as unauthenticated RCE, and the exploitation path (malicious XSLT to Java extension-function execution) is a well-documented Java attack technique.
Heap buffer overflow in zlib 1.3.1.2 through 1.3.2 allows remote attackers to corrupt memory via crafted input to applications using the non-blocking gzwrite API. The gz_vacate() function fails to bounds-check a memmove() when stale external buffer pointers are present after a write stall, reachable by calling gzprintf() or gzvprintf() in that state. A publicly available proof-of-concept exploit exists; no vendor-released patch has been identified at time of analysis.
Prototype pollution in toml-node (npm package `toml` by BinaryMuse) prior to 4.1.2 allows unauthenticated remote attackers to write arbitrary keys onto Object.prototype by supplying a crafted TOML document to `toml.parse()`. The vulnerability exploits a path desynchronization bug in the compiler's duplicate-key guard - comma-joined tracking paths diverge from dot-joined traversal paths, allowing `__proto__` traversal through scalar values into the real JavaScript prototype chain. Injected properties propagate process-wide in Node.js and can enable denial of service, authorization bypass, or code execution via application gadget chains; the GHSA advisory includes working proof-of-concept code, and a fix is available in version 4.1.2.
Uncontrolled recursion in toml-node (npm package `toml`, ~47 million monthly downloads) allows remote unauthenticated attackers to crash any Node.js process that parses attacker-controlled TOML input. The Peggy 5.1.0-generated recursive-descent parser has no depth limit in the mutual recursion between `peg$parsevalue`, `peg$parsearray`, and `peg$parseinline_table_entry`; a ~5-6 KB payload of deeply nested arrays reliably exhausts the call stack and raises an uncatchable `RangeError` that terminates the request worker or process. A confirmed PoC is documented in the GHSA advisory; a patch is available in version 4.2.0 released July 13, 2026.
Buffer overflow in Tenda HG10 router firmware version 300001138 enables network-accessible authenticated attackers to overflow memory in the Boa embedded web server's WLAN configuration handler, potentially achieving arbitrary code execution. The vulnerable parameter is `ssid` within the `/boaform/formWlanSetup` endpoint, which lacks input length validation per CWE-120. A public proof-of-concept is hosted on GitHub, concretely lowering the exploitation bar; no vendor patch has been identified at time of analysis.
Path traversal in OpenList prior to v4.2.3 allows any authenticated user holding the PermAddOfflineDownload permission to write, truncate, or overwrite arbitrary files accessible to the OpenList process via the SimpleHttp offline-download tool. The attacker controls a remote HTTP server that returns a crafted Content-Disposition header containing path-traversal sequences; OpenList uses the attacker-supplied filename without containment validation to construct a file path via filepath.Join relative to a per-task temporary directory, allowing traversal outside that directory. No public exploit has been identified at time of analysis, though the GHSA advisory details the exact vulnerable function and the fix commit is publicly accessible, significantly lowering the effort required to develop one.
Quadratic algorithmic complexity (O(D²)) in stream-json's pick, ignore, filter, and replace path filters allows an attacker supplying a small, deeply-nested JSON document to block the Node.js event loop for seconds to minutes, effectively causing denial of service. The root cause is that filter-base.js recomputes the full dot-separated path string by rejoining the entire nesting stack on every checkable token - so a document of depth D incurs O(D²) CPU work regardless of byte size. All applications passing untrusted or large JSON through a string or RegExp filter (including the library's flagship README example pick({filter: 'data'})) are affected in versions up to and including 3.4.0. A proof-of-concept is included in the published GHSA advisory; no public exploit or CISA KEV listing has been identified at time of analysis.
Privilege elevation in Microsoft's Azure AI Language cloud service lets a remote, unauthenticated attacker reach a critical function that lacks authentication (CWE-306), gaining elevated privileges over the network. Rated CVSS 10.0 with a scope change (S:C), the flaw is disclosed and fixed by Microsoft via MSRC; no public exploit code or CISA KEV listing is indicated, so this is no public exploit identified at time of analysis.
Privilege elevation in Microsoft Azure Active Directory B2C lets an unauthenticated remote attacker abuse a user-controlled key (CWE-639) to bypass authorization checks and gain elevated privileges across a network. The flaw carries a maximum CVSS 10.0 with a changed scope, reflecting that a successful attack against the shared identity platform can compromise the confidentiality and integrity of resources belonging to other principals or tenants. No public exploit identified at time of analysis, and it is not listed in CISA KEV.
Cross-site scripting in MapLibre GL JS before 6.4.1 lets an attacker who controls map style attribution strings or user-supplied custom attributions bypass the library's HTML sanitizer and run arbitrary JavaScript in the victim's browser. The flaw is a sanitizer bug in DOM.sanitize(): iterating the live attributes collection while deleting attributes shifts indexes, so a dangerous event handler placed immediately after another removed attribute (e.g. onload/ontoggle) survives cleaning and fires when the attribution control writes the content to innerHTML. No public exploit or KEV listing exists, but the fix commit ships working payloads (e.g. `<details open onload ontoggle=alert(1)>`) as regression tests, making a POC trivially reconstructable.
Privilege elevation in Microsoft Copilot Studio lets a network-based, unauthenticated attacker bypass cryptographic signature verification (CWE-347) to gain elevated privileges across a scope boundary, per CVSS:3.1 AV:N/PR:N/S:C rated 10.0. The flaw appears to involve forged or improperly validated JWT tokens, per the 'Jwt Attack' tagging, and because Copilot Studio is a multi-tenant cloud service the scope-change vector implies impact beyond the initially compromised authority. No public exploit identified at time of analysis, and EPSS is low at 0.29% (22nd percentile), but SSVC rates technical impact as total and automatable as yes.
Privilege elevation in Microsoft Power Automate (Power Platform cloud service) lets an authenticated, low-privileged attacker abuse a server-side request forgery flaw (CWE-918) to make the service issue requests to internal/backend endpoints, resulting in a scope-changing escalation with total confidentiality, integrity, and availability impact. The CVSS 3.1 base score is 9.9 with a changed scope, reflecting that the SSRF crosses a trust boundary into resources beyond the vulnerable component. No public exploit identified at time of analysis, and EPSS is low (0.33%, 26th percentile), consistent with CISA SSVC marking exploitation as 'none'.
Privilege escalation in Microsoft Entra ID (formerly Azure Active Directory) lets a remote, unauthenticated attacker bypass authentication through an alternate path or channel and gain elevated privileges over the network. The flaw affects Microsoft's cloud identity-and-access-management service, which underpins sign-in and authorization for Microsoft 365, Azure, and countless federated third-party applications. No public exploit identified at time of analysis and SSVC records exploitation status as none, but the CISA SSVC framework rates the attack as automatable with total technical impact.
PHP Object Injection in the eyecix JobSearch (wp-jobsearch) WordPress plugin allows remote attackers to inject crafted serialized PHP objects that are deserialized by the plugin, affecting all versions up to and including 3.2.0. Because the vector is unauthenticated (PR:N), any visitor can supply malicious input; if a suitable POP gadget chain is present in the plugin, WordPress core, or another installed plugin, this can escalate to arbitrary file operations, SQL injection, or remote code execution. No public exploit identified at time of analysis, and the flaw is not listed in CISA KEV.
Unauthenticated PHP Object Injection affects the Mail Mint email-marketing plugin for WordPress (by WPFunnels) in all versions up to and including 1.31.0, allowing remote attackers to inject a crafted serialized PHP object that is deserialized by the plugin. If a suitable POP gadget chain is present in the plugin, WordPress core, or another installed plugin, this can escalate to arbitrary file operations, SQL injection, or remote code execution. Reported by Patchstack and rated CVSS 9.8; no public exploit is identified at time of analysis and it is not listed in CISA KEV.
Missing authorization in the YITH Request a Quote for WooCommerce Premium plugin (all versions before 4.46.0) lets unauthenticated attackers reach functionality that should be access-controlled, per a Patchstack advisory. The flaw is a broken-access-control / missing-authorization issue (CWE-862) rated CVSS 9.8; no public exploit identified at time of analysis, though the advisory does not detail the exact vulnerable action.
Privilege escalation in the Bricksforge WordPress plugin (versions <= 3.1.8.8) lets a low-privileged user elevate their account to higher-privileged roles, per a Patchstack advisory. The flaw (CWE-266, Incorrect Privilege Assignment) carries a CVSS of 9.8 with a network/no-auth vector, though the 'Subscriber Privilege Escalation' label implies a logged-in subscriber account is the realistic starting point. No public exploit code, KEV listing, or EPSS score was provided at time of analysis.
Sandbox-escape remote code execution affects Google Chrome on iOS prior to 152.0.7977.82, where improper input validation (CWE-20) in the browser's Transactions Platform component lets a remote attacker potentially run arbitrary code outside the renderer sandbox when a victim loads a crafted HTML page. Google shipped a fix in the stable channel and Chromium rated the underlying issue Medium severity, though the supplied CVSS vector scores it 9.6. There is no public exploit identified and CISA's SSVC framework records exploitation status as none.
Remote code execution in Google Chrome's DevTools component before 152.0.7977.82 lets a remote attacker escape the renderer sandbox and run arbitrary code by luring a victim to a crafted HTML page. The flaw is a use-after-free (CWE-416) rated High by Chromium and carries a CVSS 9.6 with scope change, reflecting sandbox escape. Google has shipped a fix; per CISA's SSVC assessment there is no evidence of active exploitation and no public exploit identified at time of analysis.
Remote code execution in Google Chrome for Android before 152.0.7977.82 stems from an out-of-bounds write in the WebGL implementation, letting a remote attacker escape the browser sandbox and run arbitrary code simply by luring a victim to a crafted HTML page. Rated Chromium severity High and CVSS 9.6, the flaw is notable because exploitation breaks out of the renderer sandbox rather than being contained by it. There is no public exploit identified at time of analysis, and CISA SSVC lists exploitation status as none.
Code injection in SeaCMS's Locoy Collector module (versions up to 13.6) allows remote unauthenticated attackers to execute arbitrary PHP code by manipulating the `pwd` argument to the `parseIf` function in `seacms_locoy_news.php`. A publicly available proof-of-concept exploit exists, documented in a GitHub security advisory, elevating practical risk above the conservative 6.9 base score. The provided CVSS 4.0 impact metrics (VC:L/VI:L/VA:L) conflict with the 'RCE' tag - PHP code injection in a CMS context typically yields full server-side code execution, suggesting the vendor scoring may significantly understate actual impact.
Authentication bypass in MISP's LDAP and LinOTP login components lets a remote unauthenticated attacker impersonate an existing directory user by submitting an empty password for a known account email. The custom LdapAuthenticate and LinOTPAuthenticate classes replaced CakePHP's FormAuthenticate but omitted its credential-validation guard, so empty or non-string values reached ldap_bind() (which succeeds against directories permitting unauthenticated binds) or a local password hash derived from an empty string. If the impersonated account is privileged, the attacker gains full access to threat-intelligence data and configuration. No public exploit identified at time of analysis; a vendor patch (commit 0ee058548) is available.
Unrestricted file upload in itsourcecode Online Medicine Delivery System 1.0 allows unauthenticated remote attackers to upload arbitrary files - including PHP webshells - through the image parameter of the Order Management Controller endpoint. The vulnerable function doInsert in /rider/orders/controller.php?action=add performs no validation of uploaded file types, enabling direct server-side code execution. A public exploit demonstrating RCE via this file upload path has been released on GitHub and is actively circulating.
Unauthenticated SQL injection in code-projects Doctor Appointment System 1.0 allows remote attackers to enumerate and extract database contents by exploiting the email parameter in the patient login endpoint (/patient_login.php) via time-based blind techniques. A public GitHub proof-of-concept documents the exact method, lowering the exploitation bar to script-kiddie level. No patch has been released by the vendor; the product appears to be an educational PHP demo with limited production presence.
SQL injection in itsourcecode Online Medicine Delivery System 1.0 allows remote attackers to manipulate the ID argument passed to Order::pupdate in the rider order-confirmation endpoint, enabling arbitrary database queries. The vulnerable parameter is processed without sanitization at /rider/orders/controller.php?action=edit&actions=confirm. A public proof-of-concept has been disclosed on GitHub; no KEV listing and no vendor patch are available at time of analysis.
SQL injection in SeaCMS's WeChat integration module allows remote unauthenticated attackers to manipulate database queries through the `Content` parameter processed in `weixin/index.php`. Versions up to and including 13.6 are confirmed affected, and a public proof-of-concept exploit has been published on GitHub. The root cause is reliance on PHP's `addslashes()` for SQL sanitization - a known-insufficient defense that fails to prevent injection in many charset and connector configurations.
Authentication bypass in Eclipse Arrowhead 5.0.0 through 5.2.1 lets an unauthenticated attacker who can publish to the MQTT broker impersonate the cloud's system operator. When the MQTT API runs with the certificate authentication policy, CertificateMqttFilter reads an X.509 certificate straight from the MQTT message payload and trusts its Subject DN without ever verifying the signature or issuer chain, reducing authorization to two string comparisons on public, attacker-controlled values. By minting a self-signed certificate with CN=Sysop.<cloud>.<org>.arrowhead.eu and dnQualifier=op, the attacker gains isSysOp==true and full management access. No public exploit is identified at time of analysis, but the technique is described in full detail in the advisory.
Missing authorization in J2Store, the J2Commerce e-commerce extension for Joomla, lets remote attackers reach the `J2StoreControllerApps` `appTask` delegation path - which instantiates app-plugin controllers with no ACL check - and drive `applocalizationdata::getInstallerTool()` with a caller-influenced, non-allow-listed table name to truncate `#__j2store_*` tables and construct a path-traversal-capable path to SQL files it then executes. This yields a file-read/execute primitive affecting J2Store 1.0.0-3.3.21, 4.0.0-4.0.21, and 4.1.0-4.1.6. There is no public exploit identified at time of analysis, and access is currently blocked only as an accidental side effect of an `fof.xml` wildcard-deny rather than a deliberate control.
Remote code execution in OCS Inventory NG's Ocsreports web console (admin_info CSV upload endpoint) allows an authenticated administrator to upload a PHP webshell that, once processed, runs arbitrary code as the web-service account. The upload routine trusts the client-supplied filename and never validates file content or securely restricts extensions (CWE-434), so a benign-looking CSV import becomes a code-execution primitive. Disclosed via INCIBE as part of a multi-vulnerability advisory for Ocsreports; no public exploit identified at time of analysis, and no EPSS or KEV signal is present in the input.
Remote code execution in MOOS-IvP's iSay module (through version 24.8.1) lets any actor on the MOOS message bus run arbitrary shell commands as the iSay process user. The SAY_MOOS variable handler in Sayer.cpp builds a speech command string and passes it straight to system(), so a published message containing backticks or $() command-substitution syntax is executed by the shell. Reported by VulnCheck with a vendor patch available; no public exploit is identified at time of analysis, though the source-level root cause is fully disclosed in the upstream fix commit.
Remote code execution in MOOS-IvP through 24.8.1 arises from multiple heap and stack buffer overflows in the IvP function string decoders (FunctionEncoder.cpp / FunctionEncoderMK.cpp), which copy attacker-controlled encoded strings into fixed buffers while trusting declared length fields and scanning for delimiters without any bounds or end-of-string checks. Any actor able to publish a crafted value to a MOOS variable (via the typically unauthenticated MOOSDB) or supply a malicious .alog file can overflow these buffers, potentially achieving code execution on the autonomy stack of a marine vehicle. Publicly available exploit code exists per the VulnCheck advisory; there is no public exploit identified in CISA KEV, so it is not confirmed as actively exploited.
Remote OS command injection in MOOS-IvP's uMemWatch utility (through version 24.8.1) lets attackers who can connect to the MOOSDB as a client execute arbitrary shell commands as the uMemWatch process user. The uMemWatch memory-monitoring tool builds a shell command string that embeds the attacker-controlled MOOS client name as an unquoted stdout-redirection target, so shell metacharacters in the name are interpreted by the shell. Publicly available upstream fix code exists (PR #121); no public exploit was identified at time of analysis, and the flaw is not in CISA KEV.
Remote code execution risk in MOOS core-moos through 10.4.0 arises from a pre-authentication heap overflow in MOOSCommPkt packet handling, where a remote attacker declares a negative packet length to write arbitrary data into a four-byte heap buffer during the connection HandShake, before any authentication occurs. Any exposed MOOSDB robotics-middleware instance is affected, and because the flaw is triggered by an attacker-controlled length read straight off the wire, it can be reached with a single crafted packet. No public exploit identified at time of analysis, though the issue was reported and detailed by VulnCheck and a fix is available.
Unauthenticated variable write in MOOS core-moos through 10.4.0 lets any client that can reach the optional MOOSDB HTTP server port set arbitrary MOOS variables - including actuator and override commands - because the web server enforces no credential of any kind. In vulnerable builds the HTTP 'poke' path is always live, so a single crafted GET/POST can alter the shared runtime blackboard that drives autonomous-vehicle behavior. Reported by VulnCheck with a vendor patch available (PR #77 / commit 7e3aecd); no public exploit identified at time of analysis, and it is not listed in CISA KEV.
Unauthenticated full compromise of the MOOSDB message bus in MOOS core-moos through 10.4.0, where the wire protocol performs no client authentication. Any attacker who can reach the MOOSDB TCP port can bypass the compile-time protocol-string check, connect under an arbitrary client name, and gain unrestricted publish, subscribe, and administrative privileges - including the DB_CLEAR operation that wipes all variables and client mail queues. VulnCheck reported the flaw and an upstream fix (shared-key handshake) exists in PR #84; no public exploit has been identified at time of analysis, though the attack is trivial to script.
Out-of-bounds write in MOOS-IvP through 24.8.1 allows remote attackers to corrupt memory and potentially execute code by supplying a crafted encoded BHV_IPF payload. The StringToIvPFunction() decoder reads dimension, piece, and degree counts directly from the payload and uses them as allocation sizes and loop bounds without any ceiling check, so mismatched dimension values let an attacker write attacker-controlled doubles past the end of the IvPBox weight array. A vendor patch exists (PR #126); no public exploit and no CISA KEV listing have been identified at time of analysis.
Unauthenticated session-token forgery in Peppermint (an open-source self-hosted helpdesk/ticketing platform) versions through 0.5.5 lets any remote attacker impersonate arbitrary users. The application's docker-compose.yml ships a hardcoded JWT signing secret that is public in the project repository, so an attacker who knows the secret can mint valid tokens for any user ID - including administrators - and reach protected API endpoints without credentials. Reported by VulnCheck; no public exploit identified at time of analysis, though the 'exploit' is trivially the published secret itself.
Full account takeover in WWBN AVideo arises because the video_id_hash acts as a non-expiring, non-revocable bearer token that authenticates the holder as the video owner with complete administrator privileges. Any attacker who obtains a valid video_id_hash can replay it indefinitely to gain full admin session access, and the credential keeps working even after the victim rotates their password - eliminating the primary recovery mechanism. Reported by VulnCheck with a fix in the vendor GitHub Security Advisory; no public exploit identified at time of analysis, and no EPSS or KEV data was provided.
Unauthorized runtime route reconfiguration in MOOS essential-moos pShare through 10.0.1 lets any client of the MOOS database issue PSHARE_CMD messages to open new listeners and redirect or duplicate inter-process bus traffic. Because pre-patch builds unconditionally subscribed to PSHARE_CMD, a remote unauthenticated attacker able to publish to the MOOSDB could reroute or mirror sensor/control traffic to attacker-controlled destinations without any credentials. The vendor patch (PR #20) is available and a source-level fix is confirmed, but no public exploit or active exploitation is identified at time of analysis.
SQL injection in the GeoDirectory WordPress plugin (versions 2.8.174 and earlier) lets unauthenticated remote attackers inject SQL into backend database queries, per a Patchstack advisory. The flaw carries a CVSS of 9.3 driven largely by a scope-change assumption, and enables extraction of sensitive database contents (user credentials, secrets, PII). No public exploit code or active-exploitation evidence is identified at time of analysis.
Token forgery in python-jose through 3.5.0 lets an attacker who possesses the service's asymmetric public key mint valid HS256 (HMAC) JWTs, because the library's HMAC key initialization accepts DER-encoded public keys that lack PEM armor or SSH prefixes and never rejects them as asymmetric material. This is a classic JWT algorithm-confusion (RSA/EC-to-HMAC) attack that succeeds whenever the verifying application does not explicitly restrict the accepted algorithms, and it represents an incomplete fix for CVE-2024-33663. There is no public exploit identified at time of analysis, though the technique is well-documented and the same class of flaw has prior public tooling.
Local privilege escalation / host memory corruption in the Linux kernel's KVM x86 shadow-MMU allows a malicious or buggy guest to trigger a slab use-after-free on the KVM host. When KVM derives a child shadow page's role from an invalid/obsolete parent root, it fails to clear role.invalid, violating the invariant that invalid pages stay off the active MMU list; __kvm_mmu_prepare_zap_page() then uses list_add() instead of list_move(), corrupting the list and freeing a shadow page that is still referenced, producing a KASAN slab-use-after-free in __kvm_mmu_get_shadow_page. There is no public exploit identified at time of analysis and EPSS is low (0.21%), but the fix is a hardening/defense-in-depth patch that also adds a WARN when an invalid parent is encountered.