Local privilege escalation in Oracle Commerce Guided Search / Oracle Commerce Experience Manager 11.4.0 (Endeca Application Controller component) allows an attacker who already holds a low-privileged logon on the host to fully compromise the application, affecting confidentiality, integrity, and availability. Oracle rates it 7.0 with CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, meaning the attack requires local access and high complexity rather than remote reachability. No public exploit code has been identified, the CVE is not listed in CISA KEV, and no EPSS score was provided in the source data.
Local privilege escalation in Oracle Hyperion Financial Management 11.2.26.0.000 lets an authenticated attacker who already holds a low-privileged logon on the host running the application seize full control of the HFM instance, with high confidentiality, integrity and availability impact. Oracle rates the attack as difficult (AC:H) and the vector is strictly local (AV:L) with no user interaction, so the exposure is limited to operators of the affected server rather than the network at large. No public exploit code has been identified at time of analysis, and the only supplied reference is Oracle's Critical Security Patch Update advisory.
Let me synthesize this. CVE-2026-76159: Duplicati for Windows before v2.4.0.0, incorrect permission assignment (CWE-732) in configuration loader, allows local low-priv attacker to escalate to SYSTEM via attacker-controlled preload.json. Product name: Duplicati. Tags include "Microsoft" which is likely a mislabeled tag — Duplicati is an independent open-source project (duplicati.com), not Microsoft. Though it runs on Windows... The tag "Microsoft" as vendor is wrong. Emit mislabeled_tag with target "Microsoft". Confidence high? Duplicati is an independent open-source backup tool, not Microsoft. Yes, high confidence. Missing tags? Maybe "windows" — since it's Windows-specific. Hmm, missing_tag target "Windows", suggested "windows". That's unambiguously implied ("Duplicati for Windows", MSI installers). Could emit. But careful — is "windows" a valid tag slug in their taxonomy? They said emit only when unambiguously implied. I'll include it with high confidence... Actually risk: their taxonomy may be "Microsoft Windows". Hmm. I'll include it maybe. Let's be a bit conservative but it seems clearly applicable. I'll include "windows" for missing_tag. Hmm, but if the slug doesn't exist it might attach a bad tag. The instructions say suggested is "lowercase hyphenated slug (e.g. target "WordPress", suggested "wordpress")". So "windows" is fine. Also "privilege-escalation" technique tag is already present as "Privilege Escalation". Fine. CVSS given is 4.0 base with E:X etc. Score 7.0. PR:L, AV:L, UI:P. Hmm, why UI:P? Probably because attacker needs to force the app to load the config... The preload.json is attacker-controlled — likely attacker with write access to a directory that gets loaded. Local low-priv attacker writes preload.json, then triggers service restart (UI:P passive — waiting for service restart/admin action). Anyway. My assessed CVSS 3.1: AV:L/AC:L/PR:L/UI:P? Hmm, UI:P isn't valid in 3.1. UI options: N, R. If user interaction required (someone must rest
An out-of-bounds write reachable through a race condition in google_mba_recv_msg() in google_mba_poll.c allows a locally installed low-privilege application on an affected Android device to corrupt kernel memory and escalate to system/kernel privileges. Rated CVSS 7.0 (AV:L/AC:H/PR:L/UI:N), the flaw requires no user interaction but does need the attacker to already run code on the device and to win a timing window, which keeps it materially below a remote, unauthenticated severity. No public exploit code has been identified and the issue is not listed in CISA KEV at time of analysis; no EPSS score was supplied in the source data.
Memory corruption in the ARM64 TLB-invalidation path of the Android kernel allows a local attacker holding low privileges to win a race condition and escalate to kernel/root privileges, with no user interaction and no additional execution privileges required. Affected builds are Google Android (CPE cpe:2.3:a:google:android:*:*:*:*:*:*:*:*), specifically ARM64 devices; Google's September 2026 Pixel security bulletin is the vendor reference for the fix. No EPSS score, CISA KEV listing, or public proof-of-concept was present in the supplied intelligence, so active exploitation is unconfirmed and no public exploit code has been identified at time of analysis.
Let me build the JSON. CVE-2026-58724: Android kernel use-after-free due to race condition, local EoP requiring System execution privileges, no UI. CVSS 7.0 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H. Reported by Google Devices. CPE: google:android. Tags: Privilege Escalation, Google, Race Condition. Reference: Android security bulletin September 2026 Pixel. Note: "System execution privileges needed" — this is Android bulletin phrasing meaning the attacker needs System-level privileges already... Actually in Android bulletins, "System execution privileges needed" means the vulnerability requires the attacker to already have System privileges? Hmm, actually Android bulletin says "This could lead to local escalation of privilege with System execution privileges needed" — meaning the attacker needs System execution privileges? Historically it means exploitation requires the attacker to run code with System privileges already... Actually it means the vulnerability can lead to local escalation of privilege with System execution privileges needed — i.e., it requires System-level privileges to exploit. That means privilege escalation from System to... hmm, in Android, "System" is a UID (system uid 1000). So it escalates to kernel. Actually "with System execution privileges needed" means the attacker must already have System privileges. CVSS PR:L is consistent-ish. Actually PR:L. Hmm but if System privileges needed, PR:H might be more apt. Given CVSS says PR:L, I'll assess PR:L... Hmm. My own assessment: AV:L/AC:H/PR:H? Let me think. The Android phrasing "System execution privileges needed" — needed to exploit — implies significant privileges already (system UID, not just any app). That's PR:H arguably. But CVSS gives PR:L. I'll go with PR:H? Let's be careful — I should ground my assessment in the description. The description says "with System execution privileges needed" — this means the exploit requires system-level privileges. So PR:H is honest. But the vendor's own CVSS says
A race condition in the trusty_dputc() debug output path of generic-arm64-smcall.c in the Android kernel allows an out-of-bounds write that can be leveraged for local privilege escalation. The flaw is only reachable by a process already running with System execution privileges, and exploitation requires winning a timing window (AC:H, PR:L), with no user interaction. Impact is high across confidentiality, integrity and availability because the corrupted memory is kernel/secure-monitor adjacent, but no public exploit code or in-the-wild exploitation is known from the available intelligence.
Denial of service through catastrophic regular-expression backtracking affects the A2UI web_core and React renderer packages through version 0.10.6, where the Basic Catalog 'regex' function and TextField validation compile and execute attacker-supplied patterns without any safety check. An application that renders attacker-influenced A2UI schemas or expressions can have its JavaScript event loop pinned, freezing the UI or a headless renderer for an attacker-chosen duration at negligible cost to the attacker. Exploitation is remote and unauthenticated per the supplied CVSS 4.0 vector, the upstream fix is visible in pull request #2366, and no public exploit code or CISA KEV entry was reported at time of analysis.
A command injection flaw in the WSO2 Integrator MI extension for Visual Studio Code lets a crafted Micro Integrator project run arbitrary operating system commands when its unit test execution flow is triggered. Exploitation is not remote or silent: the developer must open the untrusted project, explicitly grant it workspace trust, and then run the project's unit tests, after which injected commands execute with the privileges of the VS Code user (CVSS 3.1 base 7.0, AV:L/AC:H/PR:N/UI:R). Impact is therefore bounded by the developer workstation's account privileges, and no public exploit code or active exploitation is indicated in the available intelligence.
Unauthenticated server-side request forgery in AVideo through version 29.0 lets remote attackers drive the server's own HTTP client to arbitrary destinations by supplying crafted Host headers to submitIndex.php or ajax.php. Because the check_site_availability function follows redirects without validating the host, an attacker can map internal hosts and open ports from the outside. No public exploit code or CISA KEV entry was provided in the intelligence feed, so exploitation status is unconfirmed, but the flaw requires no credentials and is trivially automatable.
An authenticated administrator of a Netcore NR255-V router running firmware 1.5.130703 can crash the device by sending a crafted HTTP request to the route_policy_add.cgi handler that omits the required exit_port parameter, triggering a null pointer dereference (CWE-476) and a denial-of-service condition. The flaw is remotely reachable over the network but sits behind the management interface's high-privilege authentication requirement (CVSS 4.0 PR:H), and it affects availability only — there is no confidentiality or integrity impact. No public exploit code is confirmed in the provided intelligence, the issue is not listed in CISA KEV, and no EPSS score was supplied; the assigned CVSS 4.0 base score is 6.9.
Crafted
Arista EOS devices with password-based authentication enabled can accumulate orphan authentication sessions when a specially crafted password string is submitted to the management login path. Repeatedly sending such passwords exhausts the device's authentication resources, so legitimate administrators are locked out of the switch. Arista discovered the flaw internally and states it has no evidence of malicious exploitation in customer networks; no public exploit code or CISA KEV listing was identified in the supplied intelligence. The vendor-rated CVSS 4.0 score is 6.9 with availability-only impact.
Heap buffer overflow in the NGINX HTTP/3 module (ngx_http_v3_module) can crash NGINX worker processes or corrupt a limited amount of heap data when NGINX Plus or NGINX Open Source serves QUIC traffic while linked against OpenSSL 3.5.0 or earlier under certain configurations. The overflow occurs while processing a TLS handshake and is non-deterministic — triggering it is largely outside the attacker's control — so the realistic outcome is opportunistic denial of service (worker restart) plus limited data corruption rather than reliable remote code execution. There is no control plane exposure (data plane only), no public exploit identified at time of analysis, and no CISA KEV listing; EPSS data was not provided.
Opening a crafted .rdp connection file in the FreeRDP xfreerdp X11 client (versions 3.11.0 through 3.30.0) can trigger out-of-bounds heap reads and writes because the client fails to validate MonitorIds array values in xf_detect_monitors. This local, user-interaction-gated flaw requires a victim to open the malicious file and does not affect the RDP server side; publicly available exploit code exists, but there is no confirmation of active exploitation (not in CISA KEV). The vendor has released a patch in FreeRDP 3.31.0, and the CVSS 6.9 rating reflects limited confidentiality and integrity impact with a high availability impact.
The MCPVault npm package (a lightweight Model Context Protocol server that gives AI agents access to an Obsidian vault) anchored its restricted-directory deny-list to the vault root in versions before 0.11.5, so nested .git, .obsidian and node_modules directories silently pass both isAllowed() and isAllowedForListing(). An attacker who influences which path an AI agent reads — typically through prompt injection in content the agent ingests — can cause nested .git/config files (remote URLs, embedded tokens) or nested Obsidian metadata to be read, and can pollute the listAllTags index with nested node_modules content. No public exploit code or CISA KEV entry was identified at the time of analysis; the vendor shipped the fix in 0.11.5.
CSRF protection bypass in MISP ≤2.5.45 allows a network-adjacent attacker to forge authenticated state-changing requests against any MISP action that reads parameters from the URL. The bypass exploits CakePHP's method-override processing: submitting `_method=GET` (or an equivalent non-write verb via `X-HTTP-Method-Override`) causes CakePHP to empty the parsed request body before MISP's `BetterSecurityComponent` evaluates whether to run `_validatePost()` and `_validateCsrf()`. Because `hasData` is false after body-clearing, both protections are silently skipped entirely. No public exploit has been identified at time of analysis, but the mechanism is straightforward to weaponize by anyone who can lure an authenticated MISP user to a crafted page.
Authentication downgrade in the miniOrange JWT Authentication for WP REST APIs WordPress plugin (versions before 4.8.0) lets unauthenticated remote attackers force the plugin to fall back to Basic HTTP authentication by supplying a crafted GET parameter, overriding whatever JWT or API token configuration the site administrator set. Because the vulnerable code path performs no capability check or nonce verification, and the plugin returns distinguishable error codes without rate limiting, attackers can chain the bypass into unthrottled username enumeration and credential guessing against WordPress REST endpoints. Exploitation yields only low confidentiality and integrity impact (CVSS 4.0 base 6.9), and no public exploit code or active exploitation was identified in the supplied intelligence at time of analysis.
MISP 2.5.45 and earlier fails to apply its authentication-failure logging throttle on two API auth paths — requests presenting no API key and requests presenting a key of incorrect length — allowing an unauthenticated remote caller to write an unbounded number of durable auth_fail entries into the database. Repeated requests can exhaust storage and degrade or deny availability of the platform (CWE-770). No public exploit code and no CISA KEV entry were present in the supplied intelligence; an upstream fix commit (2bf887433) is available from the vendor.
Oracle HR Intelligence, a component of Oracle E-Business Suite (versions 12.2.3 through 12.2.15), contains a difficult-to-exploit vulnerability in its Internal Operations component that lets a low-privileged, network-positioned attacker with an authenticated HTTP session tamper with or destroy critical HR data and repeatedly crash the service. Integrity and availability are both fully impacted while confidentiality is not, giving a CVSS 3.1 base score of 6.8 (AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:H). No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV, so the current exposure is driven by unpatched enterprise ERP deployments rather than active exploitation.
Oracle Product Hub, the product master-data component of Oracle E-Business Suite (versions 12.2.3 through 12.2.15), is exposed to a difficult-to-exploit flaw in its Internal Operations component that lets a low-privileged, network-positioned attacker read and tamper with critical product data via HTTP. The CVSS 3.1 base score is 6.8 (AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N), reflecting high confidentiality and integrity impact but no availability impact, with the high attack-complexity metric indicating exploitation depends on conditions outside the attacker's direct control. There is no public exploit identified at time of analysis and the flaw has not been listed in CISA KEV; Oracle's own advisory at cspusep2026.html is the authoritative remediation source.
Oracle Siebel CRM Deployment (Cloud Gateway component) versions 17.0 through 26.7 contains a hard-to-exploit flaw that lets a low-privileged attacker with HTTP network access read and modify critical CRM data, with Oracle rating both confidentiality and integrity impact as High. The vendor advisory does not disclose the root cause, and no public exploit code, EPSS score, or CISA KEV entry was supplied with this record, so real-world exploitation is unconfirmed. The associated 'Authentication Bypass' tag is not corroborated by the Oracle text, which describes unauthorized data creation, deletion, and modification rather than an explicit credential-check bypass.
Oracle iRecruitment, the recruitment module of Oracle E-Business Suite, exposes an access-control weakness in its Internal Operations component across versions 12.2.3 through 12.2.15 that lets an attacker on the same physical network segment read, create, modify, or delete recruitment data without authenticating. The flaw is rated difficult to exploit (CVSS 6.8, AV:A/AC:H/PR:N/UI:N) because it demands layer-2 adjacency to the application host and a race-prone or otherwise unreliable attack path, but it delivers high confidentiality and integrity impact with no availability loss. No public exploit code or CISA KEV entry was present in the supplied intelligence, so exploitation is not confirmed in the wild.
Unauthenticated attackers positioned on the adjacent network segment of a host running Oracle Helidon can read and modify critical application data through a flaw in the helidon-integrations-neo4j component. Affected releases are Helidon 3.0.0 through 3.2.20 and 4.0.0 through 4.5.4; Oracle rates this CVSS 3.1 6.8 with an AV:A/AC:H profile, meaning the attacker needs layer-2 proximity and must satisfy non-trivial conditions, but needs no credentials and no user interaction. No public exploit code and no CISA KEV entry were identified at the time of analysis, and no EPSS score was supplied with the intelligence.
Adjacent-network attackers can bypass authentication in Oracle Agile PLM 9.3.6 (Application Server component), gaining the ability to read, create, delete, or modify any data the PLM application can reach. The flaw is unauthenticated per its CVSS vector (PR:N) but only reachable from the physical communication segment attached to the host running Agile PLM, and Oracle rates it as difficult to exploit (AC:H) with a 6.8 base score affecting confidentiality and integrity only. No public exploit code or CISA KEV listing was present in the available intelligence, so active exploitation is unconfirmed.
Local attackers who already hold high privileges and a valid logon to the host running Oracle Hyperion Financial Management 11.2.26.0.000 can exploit a flaw in the product's Security component to seize full control of the application, with complete loss of confidentiality, integrity and availability. The issue is rated CVSS 6.7 (AV:L/AC:L/PR:H/UI:N) and no public exploit code, EPSS score or CISA KEV entry was present in the supplied intelligence. Because it requires pre-existing privileged local access, this is primarily a post-compromise escalation and insider-abuse concern rather than an internet-facing remote attack.
Missing authorization and visibility checks in a WP Directory Kit shortcode (WordPress plugin versions up to and including 1.5.7) allow any logged-in user with a role as low as Contributor to read non-public listing content — including password-protected entries and hidden fields — that belongs to other users. The flaw is an information-disclosure issue (CWE-200) publicly documented by WPScan with exploit detail available, though the EPSS score of 0.14% (4th percentile) and the absence of any CISA KEV entry indicate no confirmed active exploitation and low predicted mass-exploitation risk. Impact is confidentiality-only and limited in scope: no data modification, no denial of service, and no privilege escalation beyond the reading of restricted listing data.
Permission bypass logic errors in Google Android allow a local actor who already holds System-level execution privileges to gain further privileges on affected devices, including Pixel handsets addressed by the September 2026 Android Security Bulletin. The flaw stems from a protection-mechanism failure in which permission checks in unspecified locations are skipped, requiring only local access and no user interaction; an attacker cannot use it for initial compromise or to escalate from an ordinary unprivileged app, since System privileges are a hard prerequisite. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, and EPSS is low at 0.13% (3rd percentile), consistent with an assessment that this is a genuine but low-priority issue.
Local privilege escalation in the Android kernel lets an attacker who already holds System-level execution privileges bypass a permission check and extend that access further on affected Pixel devices covered by the September 2026 Android Security Bulletin. The flaw is a logic error in permission handling (CWE-693) that requires no user interaction but is gated behind the high precondition of pre-existing System execution context (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, base 6.7), making it a privilege-boundary bypass chained after an initial compromise rather than a standalone entry point. No public exploit code has been identified at time of analysis, there is no CISA KEV listing, and EPSS is low at 0.13% (3rd percentile), consistent with an assessment of a genuinely low-priority, locally-scoped issue.
Local privilege escalation in Google Android/Pixel arises from a permission bypass in the DreamPickerReceiver.kt component (the Daydream/screensaver picker), where a confused-deputy flaw lets a locally installed application reach privileged operations that execute with System privileges. Affected are Android/Pixel builds at security patch levels prior to the 2026-09-01 bulletin; exploitation requires the attacker to already have local code execution via a malicious or compromised app, and no user interaction is needed once that app is present. The issue is fully local (AV:L) with no remote or network reach, no public exploit code has been identified at time of analysis, and devices carrying the 2026-09-01 patch level are not exposed.
Permission bypass in the Android kernel, caused by an integer overflow in multiple code locations, allows an actor who already holds Android System execution privileges on a Pixel device to escalate privileges locally with no user interaction required. The vendor scores it 6.7 (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), and the PR:H prerequisite is the decisive constraint: the high confidentiality, integrity and availability metrics describe what a System-context actor can reach, not what an ordinary installed app or remote attacker can achieve. EPSS is 0.12% (2nd percentile) and there is no public exploit code or CISA KEV entry identified at time of analysis, so the defect functions as a secondary privilege-boundary escape usable only after an initial System-level compromise, not as a standalone entry point.
Local privilege escalation in the Android Bootloader lets an attacker who already holds System-level execution privileges (PR:H) bypass a missing permission check on an exposed bootloader interface and escalate to higher integrity, confidentiality, and availability impact on the device. Exploitation is local only (AV:L), requires no user interaction (UI:N), and is confined to post-compromise escalation of a privilege boundary on affected Pixel/Android firmware, which is why the assessed severity is moderate (CVSS 6.7) despite high C/I/A ratings. EPSS is very low at 0.12% (2nd percentile), no public exploit code exists, and there is no confirmed active exploitation (not in CISA KEV) at time of analysis; Google's September 2026 Pixel security bulletin covers the fix.
Local privilege escalation in the Android kernel affects Google Pixel devices and is addressed by the September 2026 Pixel security bulletin; an attacker who already holds System-level execution privileges on the device can exploit a logic error in the code to gain further elevated access. The flaw is a logic error rather than a memory-safety bug, requires no user interaction, and is not remotely reachable - the CVSS vector (AV:L/PR:H/UI:N) confirms it is only usable as a secondary escalation step after an initial high-privilege local compromise. There is no public exploit identified at time of analysis, no CISA KEV listing, and the EPSS score of roughly 0.12% (2nd percentile) reflects the low likelihood of exploitation, making this a low real-world priority despite the 6.7 'Medium' base score.
Local privilege escalation in the Android kernel's address remapping code (addr_remap_address_map in remap.c) allows an attacker who already holds System-level execution privileges to further elevate their access on the device. The flaw is a logic error in mapping validation that constitutes a protection-mechanism failure (CWE-693); successful exploitation requires local access and high privileges (CVSS:3.1/AV:L/AC:L/PR:H/UI:N), with no user interaction, and yields high confidentiality, integrity, and availability impact. There is no public exploit identified at time of analysis and no confirmed actively exploited (CISA KEV) status; EPSS is negligible at 0.12% (2nd percentile), and fixes are bundled into Google's 2026-09-01 Android/Pixel security bulletin, making this a genuine but bounded issue rather than a top-tier emergency.
Local privilege escalation in Google Android's image authentication service (image-auth-srv.c) allows a component that already holds System execution privileges to abuse a logic error in the gsa_sw_pk_hash_compare public-key hash-comparison routine, achieving escalation into a more trusted execution context. The flaw is reachable only locally (AV:L) and requires high privileges (PR:H) with no user interaction (UI:N), so it is not an initial-access or remote vector. Exploitability signals are weak: EPSS is 0.12% (2nd percentile), there is no CISA KEV listing, and no public exploit identified at time of analysis; the practical risk is a defense-in-depth weakness affecting Pixel/Android builds that ship the affected image authentication service.
Local privilege escalation in the Android kernel's ac_init_one_sswrp() initialization routine (init.c) allows an attacker who already holds System execution privileges on an affected Android/Pixel device to escalate further by abusing a logic error in the code, with no user interaction required. Because the assessed vector is AV:L/PR:H, this is a post-compromise escalation primitive rather than a remote or unauthenticated entry point - the pre-existing System-level foothold is the primary limiting factor, which sharply narrows realistic exploitation to attackers who have already breached a highly privileged process. No public exploit code or CISA KEV listing was identified at time of analysis, EPSS is very low (0.12%, roughly the 2nd percentile), and Google has shipped a fix in the September 2026 Pixel bulletin (2026-09-01) - consistent with a genuine but low-priority issue.
Memory corruption in the Android Trusted Execution Environment (TEE) allows a local attacker who already holds System execution privileges to escalate privileges within the secure world by supplying improperly validated input to an affected secure-world interface. The flaw is local-only (AV:L), requires high pre-existing privileges (PR:H), and needs no user interaction (UI:N), yielding high confidentiality, integrity, and availability impact if the corrupted trusted application is reached; Google rates it 6.7 (Medium). Risk is tempered by the significant foothold required, the local-only attack surface, and the low EPSS score (0.11%, 2nd percentile); no public exploit code has been identified and the flaw is not listed in CISA KEV, with fixes delivered in the Pixel security bulletin dated 2026-09-01.
Local privilege escalation in Google Android's Video Processing Unit (VPU) component lets an attacker who already holds System-level execution privileges supply improperly validated input that overwrites shared memory, yielding high confidentiality, integrity, and availability impact with no user interaction required. The flaw (CWE-20) affects Android/Pixel builds that predate the 2026-09-01 security patch level and is only reachable locally, not over a network. Exploitation is constrained by the PR:H prerequisite - an ordinary unprivileged app cannot reach the vulnerable path - and no public exploit code or confirmed active exploitation has been identified at time of analysis; EPSS is correspondingly low at 0.11% (2nd percentile).
Local privilege escalation in the Android bootloader lets a caller that already holds System execution privileges bypass a missing permission check and reach higher-privileged bootloader operations on affected Android devices. The CVSS vector (AV:L/PR:H/UI:N) makes clear this is a second-stage escalation that requires both local access and an existing high-privileged foothold, not a remote or unprivileged-app vector, and it needs no user interaction. Google resolves it through the September 2026 Android/Pixel security bulletin; EPSS is very low (0.11%, 2nd percentile) and no public exploit has been identified at time of analysis.
Local privilege escalation in the arm-smmu-v3 driver of Google's Android kernel lets code already running with System privileges bypass the ARM SMMUv3 protection mechanism and reach higher-level (kernel/root) execution on affected ARM-based devices, including Pixel. The root cause is a logic error classified as CWE-693 (Protection Mechanism Failure), reachable without any user interaction but only from a local, already-privileged context (CVSS PR:H). No public exploit code and no active exploitation have been identified at time of analysis, so this is a monthly-bulletin hardening fix rather than an emergency patch.
A missing permission check in the FSM key-release routine (FsmReleaseKey in fsm.c) of the Android kernel allows a locally positioned attacker to bypass an access-control verification and escalate privileges on affected devices. The flaw is rated CVSS 6.7 (AV:L/AC:L/PR:H/UI:N) and is classified as CWE-693, Protection Mechanism Failure, because the intended permission gate is simply not enforced on that code path. Exploitation requires the attacker to already hold System-level execution privileges on the device, and no public exploit code or CISA KEV entry has been identified at time of analysis.
Local privilege escalation in the Android kernel's arm-smmu-v3 driver (smmu_install_nested_ste) lets a process that already runs with System execution privileges turn a logic error in SMMU stream-table-entry handling into full kernel-level compromise of confidentiality, integrity, and availability. Only devices whose kernel exposes the ARM SMMUv3 driver in a nested-translation configuration are affected, and Google rates it Moderate with a CVSS base of 6.7 (AV:L/PR:H), meaning exploitation presupposes a highly privileged local foothold rather than remote or unauthenticated access. There is no indication of public exploit code and the issue is not listed in CISA KEV; Google's Pixel bulletin of 2026-09-01 ships the fix.
A use-after-free in the ARM SMMU v3 driver (arm-smmu-v3.c) of the Android kernel lets a local attacker who already holds System-level execution privileges corrupt kernel memory and escalate to full kernel/System privilege. The flaw is a logic error in one of several driver functions that leaves a freed object reachable, and no user interaction is needed once the attacker has code running at that privilege level. It is ranked CVSS 6.7 (AV:L/PR:H), there is no indication of active exploitation or public exploit code, and Google published a fix in the September 2026 Pixel security bulletin.
Local privilege escalation in Google Android's GPU driver component allows a process that already runs with System execution privileges to bypass a permission check through a logic error, gaining full read/write/execute impact at a higher privilege level. Only Android devices carrying the affected GPU component are exposed, and exploitation is strictly local with no user interaction, so it cannot be triggered by a remote attacker or a normal unprivileged app on its own. There is no public exploit code and no CISA KEV listing identified at time of analysis; remediation is delivered through the September 2026 Android/Pixel security bulletin.
A logic error in the ARM SMMU v3 driver's smmu_detach_dev path allows a caller who already holds System-level privileges on an Android device to bypass SMMU/IOMU memory-permission checks and escalate to kernel (EL1) execution, achieving full compromise of the device. Affected are Google Pixel/Android builds using the arm-smmu-v3 driver prior to the September 2026 Android Security Bulletin patch level. Exploitation is local, requires no user interaction, and no public exploit code or CISA KEV listing was identified at time of analysis, so the practical risk is concentrated on devices that already run privileged or partially compromised code.
Local privilege escalation in the Android kernel's PMIC inter-process-communication driver (ap_pmic_ipc.c) lets a caller that already holds System execution privileges bypass permission checks via a confused-deputy flaw in ap_pmic_poll_msg_handler and gain kernel-level code execution. Only Android devices that carry the affected PMIC IPC driver — the Google Pixel bulletin of 2026-09-01 is the vendor reference, and the CPE scopes this to google:android — are exposed, and the attacker must already be running with elevated (System) privileges on the device. No public exploit code or CISA KEV entry was identified at time of analysis, and no EPSS score was supplied, so this reads as a post-compromise escalation primitive rather than a remotely reachable entry point.
A permission bypass in multiple Google Android system components allows an attacker who already holds System-level code execution to escalate privileges via a confused-deputy flaw. Google addressed it in the September 2026 Pixel security bulletin (patch level 2026-09-01); exploitation is local, requires no user interaction, and demands a pre-existing privileged foothold (CVSS PR:H), so it functions as a privilege-escalation link in a chain rather than a standalone remote compromise. No CISA KEV listing, no public exploit code, and no EPSS score were provided at time of analysis.
A permission bypass in Android's CPM component allows a local attacker already running code with System execution privileges to leverage a confused-deputy weakness and escalate further, gaining full read/write/execute impact on the device. Exploitation requires local access and high (System-level) privileges per the CVSS vector but no user interaction, making it a post-compromise escalation primitive rather than a remote entry point. No public exploit code or CISA KEV listing was provided in the intelligence feed, and EPSS data was absent; the fix ships through the September 2026 Android/Pixel security bulletin.
Local escalation of privilege in the Android kernel's ARM SMMU v3 driver lets a process that already runs with System privileges reach kernel-level code execution by passing malformed input to the nested device-detach path (smmu_detach_dev_nested in arm-smmu-v3.c). Because the CVSS vector requires PR:H, this is not a boundary an ordinary unprivileged app can cross — it is a second-stage escalation for code that already holds highly privileged, kernel-adjacent access on the device. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV, so risk is driven by the monthly Android/Pixel kernel patch cycle rather than by observed attacks; no EPSS score was supplied in the input data.
An out-of-bounds write in the Android kernel, caused by a missing bounds check, allows an attacker who already holds System-level execution privileges on a device to corrupt kernel memory and escalate to full kernel/root privileges. The flaw is reachable only with local access (AV:L, PR:H) and requires no user interaction, and the associated CVSS score of 6.7 reflects high integrity, confidentiality and availability impact rather than ease of reach. No public exploit code or CISA KEV active-exploitation listing was provided in the available intelligence, so this is currently assessed as a patch-priority local privilege-escalation bug rather than a known exploited threat.