Privilege escalation in Rancher Manager before 2.15.1 allows any user with delegated GlobalRole create or update permission to permanently destroy cluster-wide Kubernetes RBAC policies by hijacking arbitrary ClusterRoles. The GlobalRole controller resolved its target ClusterRole by reading the user-settable `authz.management.cattle.io/cr-name` annotation rather than deriving the name from the GlobalRole's own identity, enabling an authenticated attacker to redirect the controller at any ClusterRole - including `cluster-admin` - and overwrite its rules. The corrupted permissions persist in the Kubernetes object store even after the malicious GlobalRole is deleted, making this a durable, stealthy integrity attack. No public exploit has been identified at time of analysis.
Irrecoverable SuperToken drain in Gardens v2's StreamingEscrow contract allows any caller to invoke the permissionless syncOutflow() function during an active governance dispute, transferring escrowed funds to the proposal beneficiary before dispute resolution completes. Unlike StreamingEscrow.claim(), which correctly enforces a disputed-state gate, syncOutflow() performs the same excess-balance transfer without checking the disputed flag, creating an exploitable asymmetry in the contract's state machine. If the dispute is subsequently resolved against the proposal, drainToStrategy() cannot recover the already-transferred tokens, resulting in permanent loss of community treasury assets with no on-chain recovery path.
RSA PKCS#1 v1.5 signature forgery in node-forge through v1.4.0 enables unauthenticated network attackers to craft signatures that pass verification against arbitrary messages when the verifying party uses low-exponent RSA keys (e=3). The root cause is missing element-count validation inside nested DigestAlgorithm ASN.1 sequences: forge's `_parseAllDigestBytes` mode confirms all bytes are consumed but does not enforce the canonical minimal DigestInfo shape required by RFC 8017, allowing garbage bytes inside the DigestAlgorithm container to survive verification while OpenSSL rejects the same structure. This is explicitly described as an incomplete fix for CVE-2026-33894; a working proof-of-concept is documented in the linked GHSA advisory; no public exploit identified in CISA KEV at time of analysis.
TLS private key disclosure in SiYuan <=3.8.1 allows any authenticated user - or any network client on default no-auth-code deployments - to exfiltrate the server's TLS private key (conf/key.pem) and CA private key (conf/ca.key) via a simple POST to /api/file/getFile. The root cause is a dual flaw: the IsForbiddenAbsPath() blocklist covers only conf/conf.json by exact match while leaving sibling key material unprotected, and the getFile handler unconditionally skips the blocklist for RoleAdministrator - a role granted to every authenticated user in v3.8.1. On TLS-enabled, network-exposed instances this enables retrospective decryption of captured HTTPS sessions and forgery of certificates already trusted by clients that imported SiYuan's CA. No public exploit identified at time of analysis; vendor-confirmed fix is available in v3.8.2.
Node identity spoofing in MOOS-IvP uFldNodeComms through 24.8.1 allows any network-reachable attacker to impersonate legitimate autonomous vehicle nodes and inject arbitrary MOOS variable notifications into the mission coordination fabric. The uFldNodeComms module (FldNodeComms.cpp) accepts the source node identity declared in the NODE_MESSAGE body payload without cross-checking it against the MOOSDB community from which the connection actually originated, a classic CWE-345 insufficient authenticity verification. An attacker reaching the MOOSDB communication bus can craft packets claiming to originate from any trusted node (e.g., a fleet commander or mission-critical sensor node), silently manipulating inter-vehicle state. No public exploit code and no CISA KEV listing have been identified at time of analysis.
Arbitrary OS command execution in SEPPmail Secure Email Gateway before 15.0.6 is possible via CWE-502 deserialization in the privileged REST API import workflow. An attacker who holds a privileged API token can submit a crafted serialized payload to the import endpoint and trigger command execution under the 'nobody' system account. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified at time of analysis, but the attack pattern for deserialization vulnerabilities is well understood.
Buffer overflow in TOTOLINK CP450 4.1.0's web CGI handler allows low-privileged remote attackers to corrupt memory and likely execute arbitrary code by supplying an oversized value to the `topicurl` argument in `/cgi-bin/cstecgi.cgi`. The CVSS 4.0 threat metric E:P confirms proof-of-concept exploit code exists, elevating this beyond a theoretical concern. No vendor patch or advisory has been published, leaving affected devices exposed with only compensating controls available.
OS command injection in the Amazon Web Services codecatalyst-blueprints npm package (before 0.3.156) allows a repository contributor with commit access to execute arbitrary commands inside the blueprint resynthesis environment by embedding shell metacharacters in the `owner` field of a `[local]` merge strategy entry within a crafted `.ownership-file`. The attack requires both commit access to a project repository and a resynthesis trigger event, making automated mass exploitation infeasible. No public exploit has been identified and SSVC rates exploitation as none and non-automatable; users of the managed Amazon CodeCatalyst service require no action because AWS applies independent server-side allowlist enforcement and per-project environment isolation.
Arbitrary file read and write in DbGate through version 7.2.6 allows authenticated low-privilege users to escape the application's data directory by supplying file:// scheme URIs in the jslid parameter of the jsldata controller. The root function getJslFileName() performs no directory containment validation, exposing the full server filesystem to the DbGate process's OS-level permissions. The most critical consequence is exfiltration of encrypted database credentials from the connections configuration, enabling lateral movement to every database managed through the tool; the write primitive adds configuration tampering and potential code-plant risk.
Unauthenticated PayPal IPN callback forgery in J2Store (Joomla e-commerce extension) versions 1.0.0-3.3.21, 4.0.0-4.0.21, and 4.1.0-4.1.6 allows any anonymous attacker to confirm orders without payment or force other customers' orders to FAILED status. The vulnerability stems from three compounding flaws: a signature verification function that treated UNVERIFIED as acceptable, disabled TLS peer verification on the outbound PayPal check, and amount validation that could be entirely bypassed by omitting the mc_gross field - making the IPN endpoint trivially forgeable with a plain unauthenticated HTTP POST. No public exploit has been identified at time of analysis, but the attack is trivially constructable from the description alone given enumerable order IDs and a merchant receiver_email that is typically public.
SQL injection in OCSReports (OCS Inventory NG) at the admin_double function endpoint allows authenticated operator-level users to manipulate the `selected_grp_dupli[]` array parameter to alter backend SQL queries and extract or modify data from the application database. All versions are affected per CPE, with the attack requiring only a valid operator account over the network. No active exploitation has been identified at time of analysis, but the low privilege bar and high data impact make this a meaningful insider or credential-compromise risk.
SQL injection in OCSReports (OCS Inventory NG) allows authenticated users holding operator privileges to extract or manipulate the full application database via the unsanitized `del_check` parameter at the `/ocsreports/?function=save_query_list` endpoint. The CVSS 4.0 score of 8.6 reflects a network-accessible, low-complexity attack path with high confidentiality and integrity impact against the underlying database. No public exploit code and no active exploitation have been identified at time of analysis; however, the standard SQLi technique and low privilege bar make this straightforward for any operator-level insider or compromised account holder.
Unlimited OTP brute-force against MISP's email-based two-factor authentication allows an attacker holding valid primary credentials to bypass the second factor and fully compromise a target account. The email_otp() endpoint applied no rate limiting or lockout, and the OTP is scoped to the user rather than the login session - enabling multiple concurrent sessions to hammer the same valid OTP simultaneously. Patch available via commit 8658062ea; no public exploit identified at time of analysis.
Blind SQL injection in Worklenz through version 3.0.0 exposes cross-tenant password hashes and other sensitive database content to any authenticated user by injecting arbitrary PostgreSQL expressions into ORDER BY clauses via the sort-field query parameter in pagination helper functions. This is explicitly an incomplete remediation of the prior CVE-2026-25947, indicating the original fix was insufficient and the root-cause injection sink remains open. No confirmed active exploitation is present in CISA KEV, but a public GitHub security advisory (GHSA-f2f8-2ppj-85pf) provides sufficient technical disclosure to guide reproduction.
Out-of-bounds memory read in DASYLab's .DSB file parser (all versions before 2026.0.0) allows an attacker to read beyond the bounds of an allocated data structure, potentially disclosing adjacent memory contents and crashing the application. Exploitation requires convincing a user - typically an engineer, lab technician, or researcher - to open a specially crafted DASYLab worksheet file. No public exploit code or active exploitation has been identified at time of analysis; vendor measX has released version 2026.0.0 as the fix.
Remote code execution in MOOS-IvP through 24.8.1 arises from unsanitized shell metacharacters passed to a `system("mkdir ...")` call inside `SplitHandler::handlePreCheckSplitDir()`, reachable via the `alogsplit` log-processing utility. An attacker who controls either a log file's pathname - including its filename - or the `--dir` command-line parameter can embed shell syntax (e.g., backtick substitution or `$(...)` sequences) that executes arbitrary commands with the privileges of the operator invoking `alogsplit`. No public exploit or CISA KEV listing has been identified at time of analysis; the fix is confirmed in upstream GitHub PR #127, replacing the dangerous `system()` call with a direct `mkdir(2)` syscall.
Privilege escalation in util-linux through versions 2.41.5 and 2.42.2 allows local low-privilege users to execute privileged post-mount hook operations on pre-existing filesystems by exploiting libmount's failure to validate mount helper exit status before dispatching the MOUNT_POST stage. The root cause - captured by CWE-390 - lies in context_mount.c functions mnt_context_do_mount() and mnt_context_mount(), which gate post-mount hook execution solely on a zero result code without verifying whether the underlying mount helper or kernel syscall actually succeeded. No public exploit code has been identified at time of analysis, but the public GHSA advisory and three upstream patch commits provide sufficient technical detail to support independent exploit development.
Untrusted search path (CWE-426) in OpenVPN's Windows tapctl utility allows a local low-privileged attacker to substitute a malicious netsh.exe executable when tapctl invokes it without a fully-qualified path. Affected versions span OpenVPN 2.5.0-2.6.22 and 2.7_alpha1-2.7.6 on Windows; the fix was released in v2.7.7. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis.
Privilege escalation in Hitachi Energy MicroSCADA SYS600 allows any user with access to the engineering tools to elevate their privileges to Windows administrator on the underlying host machine, achieving full operating-system control. The flaw resides in the RBAC enforcement layer (CWE-303 - incorrect implementation of the authentication/authorization algorithm), meaning the mechanism that is supposed to constrain engineering-tool users to scoped permissions fails to enforce those boundaries against the Windows OS layer. Exploitation yields complete control of the host, directly threatening the availability, integrity, and confidentiality of the SCADA environment. No public exploit or CISA KEV listing has been identified at time of analysis.
Broken application-layer authentication in Hitachi Energy MicroSCADA SYS600 allows any user with an operating system account on the hosting server to read and modify SYS600 application objects without possessing SYS600 credentials. Because the application relies on OS-level authentication rather than enforcing its own access controls (CWE-303), the SYS600 authentication boundary is effectively bypassed for all local OS users. In a SCADA environment managing electrical distribution infrastructure, this means OS-resident users - such as IT staff, contractors, or service accounts - can tamper with power system application objects without SCADA authorization, carrying high real-world consequences.
Out-of-bounds heap read in DASYLab's .DSB file parser allows memory disclosure and potentially code execution when a victim opens a specially crafted workspace file. All DASYLab versions prior to 2026.0.0 are affected. The CVSS 4.0 vector assigns high confidentiality, integrity, and availability impact to the vulnerable system, indicating the flaw may be exploitable beyond simple information leakage - a heap OOB read during string conversion can sometimes be chained into controlled code execution depending on heap layout. No public exploit or CISA KEV listing is identified at this time.
Out-of-bounds heap read during .DSB file parsing in DASYLab (all versions prior to 2026.0.0) allows an attacker who can persuade a user to open a specially crafted data file to potentially disclose heap memory contents and crash the application. The root cause is CWE-125: insufficient validation of user-supplied length or offset fields during file-handling routines, causing reads a few bytes past an allocated heap buffer boundary. No public exploit code or active exploitation has been identified at time of analysis; vendor-released patch is version 2026.0.0.
Out-of-bounds write in DASYLab (all versions before 2026.0.0) enables arbitrary code execution when a victim opens a specially crafted .DSB worksheet file. The flaw, CWE-787, stems from improper validation of user-supplied data within the .DSB file parser, permitting writes past the end of an allocated data structure and corrupting adjacent memory. No public exploit or active exploitation has been identified at time of analysis; successful exploitation requires social-engineering the target into opening a malicious file.
Out-of-bounds heap write in DASYLab before version 2026.0.0 enables arbitrary code execution on the victim's system when a user opens a maliciously crafted .DSB worksheet file. The flaw stems from insufficient validation of user-supplied data during .DSB file parsing, allowing an attacker to write past the end of an allocated heap buffer (CWE-787). All versions of DASYLab prior to 2026.0.0 are affected, and exploitation relies entirely on convincing a user to open a weaponized file; no public exploit or active exploitation has been identified at time of analysis.
Out-of-bounds write in DASYLab's .DSB worksheet file parser allows an attacker to achieve code execution with full confidentiality, integrity, and availability impact by convincing a user to open a crafted file. All versions of DASYLab prior to 2026.0.0, as published by MeasX (formerly National Instruments), are affected. No public exploit code exists and no active exploitation has been confirmed at time of analysis.
Server-side request forgery in Label Studio through 1.23.0 allows authenticated users to route outbound webhook requests to RFC 1918 private addresses and cloud instance metadata endpoints (e.g., 169.254.169.254), bypassing network segmentation controls. By creating a webhook that targets an internal service and enabling payload transmission, an attacker can probe internal infrastructure topology and exfiltrate annotation data to attacker-controlled destinations in the same operation. No public exploit exists at time of analysis, but the patch commit confirms the affected code path in label_studio/webhooks/utils.py and the fix extends SSRF controls to S3 endpoint validation as well.
OS command injection (CWE-78) in WSO2's shared Carbon Console administrative interface allows an authenticated administrator with adjacent network access to execute arbitrary operating system commands, leading to complete compromise of the affected system. The vulnerability spans at least eight WSO2 middleware products - including API Manager, Identity Server, Open Banking components, Traffic Manager, Universal Gateway, and API Control Plane - all of which share the Carbon Console administrative layer. The CVSS scope-change flag (S:C) indicates that successful exploitation extends impact beyond the WSO2 application boundary to the underlying host and potentially adjacent systems.
NULL pointer dereference in the Linux kernel's psxpad-spi driver crashes the kernel when system suspend is triggered on hardware using SPI-connected PlayStation controllers. The probe() function in drivers/input/joystick/psxpad-spi.c omits the spi_set_drvdata() call that stores per-device state, so psxpad_spi_suspend() unconditionally dereferences a NULL pointer on suspend entry, causing a kernel panic. Patches are available across all active stable kernel branches (5.10 through 7.2); EPSS is 0.21% and no active exploitation has been identified.
Race condition in the Linux kernel's ovpn (kernel-native OpenVPN) module allows a workqueue callback to continue executing within module text after that text has been freed during module teardown, creating a use-after-free condition in kernel space. The flaw exists because ovpn queues work items on the global system workqueue rather than a module-owned queue, leaving no driver-controlled drain point to guarantee all callbacks have exited before the module's code segment is released. Systems actively using the kernel-native ovpn module are at risk of kernel memory corruption or crash during module unload; no public exploit has been identified at time of analysis and EPSS is 0.20%.
Use-after-free in the Linux kernel's MediaTek power domain driver exposes kernel memory to potential corruption via a dangling device-tree node pointer. In scpsys_get_bus_protection_legacy(), two error paths call of_node_put() to release infracfg and SMI device-tree node references before those nodes are passed to dev_err_probe() with the %pOF format specifier; if the put drops the last reference, the formatter dereferences freed memory. Vendor patches are available for Linux 6.18.46, 7.1.10, and 7.2, and EPSS exploitation probability sits at 0.20% (10th percentile) with no confirmed active exploitation.
Out-of-bounds table access in the Linux kernel fp9931 regulator driver exposes kernel memory to corruption via a malformed VPOS/VNEG voltage selector lookup table. The fp9931 driver's VPOSNEG_table[] contains two defects: a duplicate 7.04V entry that shifts all subsequent selector mappings by one, and a truncated table of only 41 entries instead of the required 64, meaning any selector value above 0x28 triggers an out-of-bounds access in kernel memory. Devices incorporating the FP9931 PMIC (a display-panel power regulator) running affected kernel versions are vulnerable; exploitation probability is very low (EPSS 0.20%, 10th percentile) with no public exploit and no confirmed active exploitation.
Use-after-free in Chrome's Compositing component (versions prior to 152.0.7977.82) enables a sandbox escape when chained with a renderer-process compromise - an attacker who has already gained control of the renderer can corrupt memory in the Compositing layer and execute arbitrary code outside Chrome's sandbox boundary on the host operating system. The CVSS S:C (scope changed) metric confirms this is a privilege-escalation-across-boundary primitive, delivering full C:H/I:H/A:H impact against the underlying OS. A vendor patch is available in Chrome 152.0.7977.82, and no public exploit has been identified at time of analysis.
Cross-tenant cloud storage object access in Label Studio through 1.23.0 allows an authenticated low-privilege user to read other organizations' cloud storage contents by supplying arbitrary file URIs to the proxy_api.py presign and stream endpoints. The root cause is the absence of organization-scoped filters during URI resolution, enabling a tenant in a shared deployment to enumerate and exfiltrate training data, annotations, or source media belonging to other organizations. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis, but the attack is low-complexity and fully automatable once an account is obtained.
TLS certificate validation is disabled by default in the Federator component of Eclipse aeriOS, enabling man-in-the-middle interception of all outbound HTTPS connections made by the component. Any attacker who can position themselves on the network path between the Federator and external services - including OAuth authorization servers - can impersonate those services and harvest OAuth client credentials and bearer tokens. This affects only the current pre-release development codebase; a source-level fix is confirmed in commit 9c63b60, but no official tagged release exists. No public exploit or CISA KEV listing has been identified at time of analysis.
Cross-tenant vault key disclosure in Helicone's AI proxy and observability platform exposes plaintext upstream provider credentials - including OpenAI, Anthropic, and AWS Bedrock API keys - to any authenticated admin or owner of a separate tenant organization. The vulnerability exists in VaultManager.getDecryptedProviderKeyById(), invoked via GET /v1/vault/key/{providerKeyId}, which decrypts and returns vault secrets without verifying that the requesting user's organization matches the organization that owns the target key. A vendor patch commit is available; no active exploitation or public proof-of-concept has been identified at time of analysis.
Unauthenticated exposure of OAuth client_secret credentials via the /oauth2/register endpoint affects Medplum versions 4.1.10 through 5.1.6, a healthcare developer platform widely used to build FHIR-compliant apps. When a caller submits a redirect_uri that matches a pre-configured entry in the server's defaultOAuthClients configuration block, the registration endpoint reflects the stored client_secret back in the response - effectively handing an attacker the credential needed to impersonate that OAuth client. The vendor patched this in version 5.1.7 (PR #8837); no public exploit has been identified at time of analysis.
Unauthenticated settings modification in the WP Compress WordPress plugin (versions <= 7.21.28) allows any remote attacker without credentials to alter plugin configuration, potentially redirecting CDN endpoints, disabling image optimization, or manipulating performance settings site-wide. The flaw stems from missing authorization checks (CWE-862) on settings-update endpoints, meaning any internet-reachable WordPress installation running the affected plugin is exposed. No public exploit code or CISA KEV listing has been identified at time of analysis, but the unauthenticated, low-complexity attack vector makes this trivially exploitable by automated scanners.
Double-free memory corruption in the MongoDB C Driver's OpenSSL-based TLS certificate revocation checking path allows a trusted TLS endpoint to crash the connecting client application. During the TLS handshake, a server already trusted by the client can present specially crafted certificate data that triggers a heap object being freed twice (CWE-415), causing the client process to terminate unexpectedly. The impact is a client-side denial of service; no code execution has been claimed, and the CVSS 4.0 vector (VA:H, VC:N, VI:N) corroborates an availability-only outcome with no public exploit identified at time of analysis.
Incorrect authorization (CWE-863) in Elastic Kibana allows authenticated users holding only low-privilege accounts to modify configurations that should be restricted to higher-privilege roles, bypassing Kibana's access control enforcement. The CVSS vector (AV:N/AC:L/PR:L/UI:N, C:H/I:H/A:N) confirms the flaw is network-exploitable with minimal complexity and yields high confidentiality and integrity impact against Kibana's configuration plane. Elastic has released patched versions across the 8.x and 9.x release trains under advisory ESA-2026-178; no public exploit has been identified and the vulnerability is not listed in CISA KEV.
Privilege escalation in Kibana's Fleet management component allows any user holding Fleet management privileges to mint arbitrarily elevated Elasticsearch cluster credentials - up to full cluster administration - for every Elastic Agent enrolled in a targeted policy. Elasticsearch cluster privilege declarations sourced from integration packages were not validated before being used to generate agent credentials (CWE-863: Incorrect Authorization), enabling an attacker to inject overprivileged credentials across an entire agent fleet. No public exploit has been identified at time of analysis, and CISA KEV status is not confirmed, but the impact is laterally broad: a single privileged user can compromise all agents and the Elasticsearch cluster they authenticate to.
Broken access control in the Agentimus AI SEO, llms.txt & MCP for AI Agents WordPress plugin (versions <= 1.51.0) allows any subscriber-level authenticated user to perform privileged administrative actions. The plugin fails to enforce capability checks on one or more endpoints, enabling low-privilege users to read or modify sensitive plugin data - including AI SEO configuration, llms.txt content, and MCP agent settings. No public exploit is identified at time of analysis, but the low authentication bar (subscriber registration is typically open on WordPress sites) makes this broadly exploitable wherever the plugin is installed.
Out-of-bounds memory reads in the Linux kernel's drm/amdkfd CRAT table parser allow a local attacker to leak kernel memory and potentially crash the system on AMD GPU/APU-equipped hosts. The CRAT (Component Resource Affinity Table) subtype parser validates that a subtype header fits within the image buffer but fails to verify that the advertised subtype length field also stays within bounds, enabling kfd_parse_subtype() to cast the header pointer beyond valid memory when a malformed CRAT table is supplied. No public exploit has been identified at time of analysis; EPSS is 0.19%, placing this in the 9th percentile.
Out-of-bounds write in the Linux kernel's `dev_validate_header()` network function allows a local process holding `CAP_SYS_RAWIO` to corrupt kernel memory by sending a raw packet with a short link-layer header while the target network device is concurrently reconfigured to increase `hard_header_len`. The `memset` zero-padding operation writes past the skb headroom reserved at allocation time, producing a silent memory corruption that is worse than the pre-existing `skb_under_panic()` it masks. Patches are available across multiple stable kernel branches; EPSS stands at 0.24% with no public exploit or CISA KEV listing.
Out-of-bounds buffer access in the Linux kernel's synaptics-rmi4 driver exposes systems with Synaptics RMI4 touchpad hardware to kernel memory corruption triggered by a copy-paste typo in F55 electrode initialization. On affected hardware where the receiver (RX) electrode count exceeds the transmitter (TX) count, the incorrectly propagated TX value causes F54 diagnostic routines to calculate an inflated report buffer size, enabling potential OOB reads or writes in kernel space. Patched stable releases are available across all maintained kernel branches; no public exploit code or active exploitation (CISA KEV) has been identified, and EPSS remains at 0.21%.
Use-after-free and race condition in the Linux kernel's amba-pl011 ARM UART serial driver during DMA teardown allows a local attacker to corrupt kernel memory, potentially gaining arbitrary code execution or causing a denial of service. The flaw exists because dmaengine_terminate_all() returns without waiting for in-flight callbacks to complete, enabling the TX DMA callback to dereference already-freed TX buffer memory; a parallel race exists in the RX path where the poll timer accesses RX buffers without holding the port lock. Patches are available across multiple stable kernel branches; no public exploit code or active exploitation (KEV) has been identified at time of analysis.
Use-after-free in the Linux kernel's pata_sl82c105 PATA bridge driver allows a local low-privileged user to potentially achieve kernel memory corruption leading to privilege escalation on systems equipped with the SL82C105 PCI bridge chip. The defect was introduced by commit 44c10138fd4b, which replaced a PCI configuration-space read with direct access to the cached revision field of a PCI device struct - but left that access after the reference was dropped via pci_dev_put(), creating a window where the bridge struct may be freed before the read occurs. Patches have been backported across multiple long-term stable kernel branches; no public exploit code or active exploitation has been identified at time of analysis.
Out-of-bounds array access in the Linux kernel's Thunderbolt driver exposes local low-privileged users to potential kernel memory corruption and privilege escalation. The flaw in tb_consumed_dp_bandwidth() sizes the group_reserved[] array at MAX_GROUPS entries (indices 0 through MAX_GROUPS-1) but uses Group IDs directly as indices, where valid IDs run from 1 through MAX_GROUPS - causing an off-by-one that reads and writes one element past the array boundary when the highest bandwidth group is processed. Patches are available across multiple stable kernel branches (6.12.x, 6.18.x, 7.1.x, 7.2), and no public exploit code has been identified at time of analysis.
Out-of-bounds memory access in the Linux kernel's Loongson2 MMC driver allows a local authenticated user to corrupt kernel memory through incorrect scatterlist indexing in the mmc: loongson2 subsystem. The functions `ls2k0500_mmc_reorder_cmd_data()` and `ls2k2000_mmc_reorder_cmd_data()` use `for_each_sg()` to iterate a scatterlist but then incorrectly re-index the current `sg` pointer as if it were an array base (using `&sg[i]`), causing access to wrong or out-of-bounds scatterlist entries. This memory corruption can lead to full kernel compromise - confidentiality, integrity, and availability loss - on systems using Loongson LS2K0500 or LS2K2000 SoCs equipped with MMC storage. No public exploit has been identified at time of analysis.
Uninitialized pointer dereference in the Linux kernel's MediaTek GPU power-domain driver (`pmdomain/mediatek/mfg`) can trigger a kernel fault or incorrect OPP (Operating Performance Point) configuration on first device attachment. The `prev_o` variable in `mtk_mfg_attach_dev()` is read in a conditional branch on the first loop iteration before ever being assigned, meaning it holds an indeterminate stack value; if that value is non-NULL, the kernel dereferences a stale or garbage pointer. Affected versions span stable kernel trees from commit f08e7a4e8d6a through the fixed points in 7.1.10, 7.2, and 6.19. No public exploit code and no CISA KEV listing are present; EPSS at 0.19% (9th percentile) reflects minimal real-world exploitation interest.
Stack buffer overflow (CWE-121) in the file-level restore agent of Dell PowerProtect Data Manager versions 20.2.0.0 and below enables attackers to potentially achieve full system compromise, including code execution. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, score 7.8) indicates local access with low privileges, while the vendor description separately references a 'high privileged remote attacker' - a direct conflict in both attack vector and privilege level requiring vendor clarification. No public exploit or CISA KEV listing exists at time of analysis.