Plane's InstanceAdminSignUpEndpoint in versions 0.13 through pre-1.4.0 allows unauthenticated remote attackers to exploit a time-of-check time-of-use race during first-run setup and create a second instance administrator with full instance-admin authority alongside the legitimate operator. Exploitation requires that no instance administrator exists yet and that the attacker wins a concurrent-request race before the legitimate first admin is committed; after setup completes, the endpoint rejects new admins and the flaw is unreachable. No public exploit identified at time of analysis, and the risk is situational because the vulnerable window is brief and requires network reachability to the admin signup path.
Deactivated user accounts in Plane prior to 1.4.0 can still authenticate with existing credentials because the login flow does not reject inactive users and save_user_data() silently sets is_active back to True, reactivating the account without notifying administrators. This is an authenticated (CVSS PR:L) improper access control issue (CWE-284) requiring the attacker to possess valid, un-rotated credentials for an account that was deactivated via is_active=False rather than deleted; impact scales with the account's prior role, up to full workspace control if it was an Admin. No public exploit identified at time of analysis, no CISA KEV listing and no EPSS score were present in the provided intelligence; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N (8.1 High).
A malicious web page visited on a machine running Joplin Desktop with the opt-in Web Clipper server enabled can pair itself as a trusted client and obtain the permanent API token, yielding ongoing read and write access to the victim's notes, notebooks, tags, resources and master keys. The root cause (CWE-346) is that the pairing endpoints POST /auth and GET /auth/check respond with Access-Control-Allow-Origin: * and accept any http/https origin, while the desktop approval dialog fails to display the requesting origin, so a victim who approves a generic-looking prompt unknowingly authorizes the attacking page. Exploitation requires the Web Clipper server to be explicitly enabled (off by default), a browser context on the same machine, and the victim to approve the prompt; no public exploit identified at time of analysis. Vendor-released patch: 3.7.13.
Privilege escalation in Progress Telerik Fiddler Classic for Windows (versions prior to v6.0.20262.10021) lets a local low-privileged attacker replace one of the application's external helper executables with a different, validly signed binary that passes the product's weak publisher-name allow-list check, causing Fiddler to launch attacker-chosen code - including elevated (Administrator) execution for the helper tools that request elevation. Exploitation is local and authenticated (CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N, 7.9), requires write access to the installed helper binaries, and is gated on a user launching the affected tool and approving the elevation prompt without noticing the executable name changed; it is not remotely or unauthenticated exploitable, and there is no public exploit identified at time of analysis. The authoritative assessment rates this a moderate, locally-exploitable privilege-escalation flaw rather than a drop-everything priority, with the UI:R requirement and the need for a pre-existing local foothold being the main limits on real-world abuse.
Plaintext storage of sensitive data on the Mercusys AC12 V2 router, compounded by the absence of any secure boot mechanism, allows an attacker with hands-on access to read stored secrets and reflash or modify the firmware to run arbitrary code. The vendor-derived base score of 7.8 reflects a local, low-privilege vector (AV:L/AC:L/PR:L/UI:N), but independent analysis re-scores the realistic attack path as physical access with no authentication required (AV:P/AC:L/PR:N/UI:N) because reading the flash contents or writing a modified image presupposes possession of the device. Real-world priority is low: EPSS is 0.16% (5th percentile), no publicly available exploit code has been identified, and there is no CISA KEV entry - exploitation is confined to supply-chain, resale, repair-shop, theft, or evil-maid scenarios rather than mass remote compromise.
A permission bypass logic error in Android's DeviceAdminAppsPreferenceController.updateState allows a locally installed, running app to escalate privileges, granting it high confidentiality and integrity impact on affected devices (Android 14, 15, and 16-qpr2). Exploitation requires a local foothold consistent with the assessed CVSS vector (AV:L/PR:L) - the attacker must already have a malicious app executing on the device and be able to reach the device-admin apps preference code path - but no user interaction is needed, so the escalation can occur silently once that app is present. There is no remote attack vector, CISA SSVC records exploitation as 'none' and the flaw as non-automatable (cannot be reliably mass-exploited), and no public exploit code has been identified at time of analysis. This is a credible but not emergency-tier issue.
Local privilege escalation in the Android Settings application (the ApplicationActionButtonsPreferenceController handling app-uninstall controls) allows an attacker who already holds a low-privileged local foothold - such as a malicious or compromised app running in the standard app sandbox - to bypass a permission check and perform actions that should require elevated privileges, with no user interaction required. Affected versions are Android 14, 15, and 16-qpr2, as addressed by the October 2026 Android (Automotive OS) security bulletin; the exploit is only reachable locally (AV:L, PR:L, UI:N) and no public exploit code or active exploitation has been identified at time of analysis. The issue is a logic error in the shouldDisableUninstallButton routine rather than a memory-safety defect, and CISA SSVC rates exploitation as 'none' with 'no' automatable and total technical impact if successfully triggered.
Local privilege escalation in Android 14, 15, 16, 16-qpr2, and 17 allows an attacker with low-level local code execution - such as a pre-installed malicious or compromised app - to bypass permission checks and gain elevated privileges without user interaction, rated CVSS 7.8 (AV:L/PR:L/UI:N). The flaw is a logic error in permission management (CWE-269) tracked as CVE-2026-28625; no public exploit or active exploitation is identified at time of analysis. The only vendor reference is the Android Automotive OS security bulletin, so applicability to general Android handsets should be confirmed.
Local privilege escalation in the Android Settings component lets an attacker-controlled application that is already running on the device with low privileges (CVSS PR:L, AV:L) abuse a confused-deputy permission check and cause the more-privileged Settings process to perform operations on the caller's behalf, delivering high confidentiality and integrity impact with no user interaction required. Confirmed-affected builds are Android 14, Android 15, Android 16, and Android 16-qpr2, and the only vendor reference provided is the Android Automotive OS security bulletin for 2026-10-01, so the breadth of exposure across Android form factors should be confirmed with Google. There is no public exploit identified at time of analysis, and CISA's SSVC evaluation records exploitation as none, so this is a genuine but second-tier, local-only escalation path rather than a remotely reachable or actively exploited issue.
Local privilege escalation in Android 14, 15, and 16 allows a malicious or already-compromised app running on the device to bypass the caller-identity validation performed by checkCallerIsCertInstallerOrSelfInProfile in CredentialStorageActivity, yielding high confidentiality and integrity impact against protected credential storage. The flaw is a CWE-20 improper input validation defect that requires only low local privileges (CVSS PR:L) and no user interaction, but it cannot be triggered remotely or from a zero-privilege starting point. No public exploit code was identified at time of analysis and CISA SSVC records exploitation as 'none', so despite the 7.8 base score the practical urgency is driven by patch adoption on affected devices rather than by observed attacks.
An out-of-bounds write in Android's NFC Execution Environment (NFCEE) action handling code (nfa_nfcee_act.cc) lets a locally installed low-privilege application corrupt memory in the NFC stack and escalate to system-level privileges. Per the assessed CVSS:3.1 vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, the attacker must already be able to run code on the device as a low-privilege app (PR:L) and the flaw is not reachable over the network (AV:L), with no user interaction required; devices running unpatched Android 16, 16-qpr2, or 17 builds are affected, while those with the October 2026 security patch are not. Exploitation is not observed in the field - SSVC records Exploitation:none and there is no KEV listing or public exploit code identified at time of analysis - and EPSS is low at 0.11% (1st percentile), so this presents as a genuine but non-urgent local privilege-escalation issue rather than a remotely exploitable emergency.
Zephyr RTOS builds that enable CONFIG_USERSPACE and include an I3C controller driver allow an unprivileged user-mode thread with a grant on the I3C controller device object to escalate to supervisor privilege. The syscall verifier z_vrfy_i3c_do_ccc() checked the outer i3c_ccc_payload, the broadcast data buffer and the targets.payloads[] array but never validated the per-target data pointers carried inside each struct i3c_ccc_target_payload, and it validated the caller's live structure rather than a snapshot, so the driver dereferences an attacker-chosen kernel address; a read CCC turns this into an arbitrary-length out-of-bounds kernel write and a write CCC into a kernel memory disclosure (CVSS 3.1 base 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, CWE-822). No public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is strictly local - there is no remote or network attack path. An upstream fix commit exists that snapshots the payload, copies the target array into kernel memory and validates every per-target buffer with K_SYSCALL_MEMORY(), but no tagged release version containing it was independently confirmed from the provided data.
Import-time code execution in Docling 2.27.0 through 2.131.0 lets any distribution already present in the same Python environment that registers an entry point in the 'docling' group run arbitrary code as soon as Docling's plugin factories initialize - even when allow_external_plugins is set to false, because the plugin manager imports every registered module before the namespace allow-list is applied and then misleadingly logs that the plugin was skipped. The assessed vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) confirms this is a local, supply-chain-style prerequisite: an attacker must first get a third-party or compromised package installed and registered, and Docling must then be started by a user, so there is no remote network exploitation path. No public exploit code or active exploitation is known at time of analysis (EPSS 0.11%, percentile 1%; CISA SSVC exploitation: none), and the vendor has shipped a fix in 2.131.0.
Local privilege escalation in Google Android (versions 14, 15, 16, 16-qpr2, and 17) allows an attacker who already holds a local foothold to write outside intended memory bounds and elevate privileges to a higher-privileged context. The flaw is an incorrect bounds check producing an out-of-bounds write (CWE-119) in multiple locations, rated CVSS 7.8 with vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H - exploitable by an unprivileged app on the device, with high complexity of preconditions but low attack complexity once a foothold exists, and no user interaction required. Exploitation is not automatable per the CISA SSVC assessment, no public exploit code has been identified at time of analysis, and the issue is not confirmed actively exploited (no CISA KEV listing).
Local privilege escalation in Google Android 17 arises from an out-of-bounds write in the stpropnci_process function of stpropnci.cc, where an incorrect bounds check lets a low-privileged local process corrupt memory, with high impact to confidentiality, integrity, and availability (CVSS 3.1 base 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Exploitation requires the attacker to already have local code execution on the device - an ordinary low-privileged app able to reach the vulnerable function and supply triggering input - after which no additional execution privileges and no user interaction are needed; there is no network-facing or remote trigger, so a foothold must first be obtained or the flaw chained behind a separate remote bug. No public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (not in CISA KEV), making this a genuine but second-tier priority relative to remotely reachable Android flaws.
Local privilege escalation in Google Android 16, 16-qpr2, and 17 arises from improper input validation in the Bluetooth snoop logger's FilterCapturedPacket routine (snoop_logger.cc), which can corrupt memory when malformed packet data is processed. Exploitation requires a low-privileged local app or process already running on the device (CVSS vector shows AV:L/PR:L/UI:N), meaning an attacker must first obtain a foothold but needs no user interaction and no additional execution privileges to escalate to full confidentiality, integrity, and availability impact. There is no public exploit code and no confirmed active exploitation (CISA SSVC exploitation value: none; not in KEV, no POC identified), but a fix is available through the Android Security Bulletin dated 2026-10-01, so this should be treated as a genuine, second-tier patch-priority issue rather than an emergency.
Local privilege escalation in Google Android 14, 15, 16, 16 QPR2 and 17 is possible through an out-of-bounds write in the qsort routine of libufdt_sysdeps_vendor.c, which occurs when the device-tree (ufdt) parsing path is driven into resource exhaustion with attacker-influenced input. An attacker who already holds a local, low-privileged foothold on the device - for example a malicious installed app or a process that can feed data into the ufdt parsing path (PR:L) - can trigger the flaw with no user interaction and no additional execution privileges, achieving high confidentiality, integrity and availability impact within the platform (CVSS 7.8). No public exploit identified at time of analysis, and the issue is addressed through the October 2026 Android Security Bulletin.
Local privilege escalation on Android 14, 15, 16, 16-qpr2, and 17 stems from an out-of-bounds read in MessageQueueBase.h caused by an incorrect bounds check, allowing an attacker with low-privilege local code execution to gain elevated privileges with high impact to confidentiality, integrity, and availability (CVSS 7.8). Exploitation requires a locally installed malicious or compromised app and no user interaction, and no public exploit has been identified at the time of analysis.
Local privilege escalation in Android's Bluetooth stack lets an app running with ordinary privileges corrupt control flow in the privileged Bluetooth process and inherit its elevated rights. The root cause is an uninitialized-pointer dereference (CWE-824) in handle_le_monitor_device_event of msft.cc, the Microsoft HCI vendor-extension handler, affecting Android 16, Android 16-qpr2 and Android 17 per EUVD. This is a second-stage escalation rather than a remote entry point: the attacker must already have local code execution and be able to reach the Bluetooth LE monitoring path (CVSS AV:L, PR:L, UI:N), and no public exploit code has been identified at time of analysis; Google addresses the issue in its October 2026 Android Security Bulletin.
Local privilege escalation in Google Android 14 through 17 (including 16 QPR2) lets a low-privilege local actor trigger an integer overflow inside the NFC Type 4 Tag read/write path (rw_t4t_update_file in rw_t4t.cc) that produces an out-of-bounds write, yielding code execution in a higher-privileged context. Per the assessed vector (AV:L/AC:L/PR:L/UI:N), the attacker must already have local code execution or app presence on the device but needs no user interaction, and exploitation requires attacker-controlled NFC Type 4 Tag data to reach the reader/writer code path on an unpatched build. There is no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV); the CVSS score is 7.8 and the practical constraint is the local-only attack vector, making this a genuine fleet-patching priority rather than an emergency.
Local privilege escalation in Google Android 14, 15, 16, 16-qpr2, and 17 lets a low-privilege app bypass permission checks through a confused-deputy flaw in the dialInternal code path, allowing the app to perform permission-protected actions it should not be able to perform. Exploitation requires a local foothold - the attacker must already be running code as a low-privilege app (PR:L) - but needs no user interaction (UI:N) and offers no remote attack surface (AV:L), making this a credible but not emergency-priority risk. There is no CISA KEV entry and no public exploit identified at time of analysis; patched builds from the October 2026 Android Security Bulletin are not vulnerable.
Local privilege escalation in Google Android 14 through 17 (including 16-QPR2) allows a low-privileged app already running on the device to bypass permission checks enforced inside VirtualAudioControllerTest.java and reach elevated functionality, yielding high confidentiality, integrity, and availability impact (CVSS 3.1 base 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The attack is strictly local: it requires an existing low-privileged execution context on the device, needs no user interaction, and is not remote. No public exploit code has been identified and there is no confirmed active exploitation (CISA KEV) at time of analysis, and CISA's SSVC evaluation rates exploitation as none with the issue judged not automatable.
Local privilege escalation in Google Android 17 (with a denial-of-service component) allows code running on the device with low-level privileges to trigger an uncaught exception in affected components, yielding high confidentiality, integrity, and availability impact. Per the assessed CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8), exploitation requires a prior local foothold - typically a malicious or compromised third-party application already installed - and needs no user interaction and no additional execution privileges, but cannot be reached remotely over the network; the flaw is scoped to the Android 17 version named in the EUVD data. No public exploit identified at time of analysis.
Local privilege escalation in Google Android 14 through 17 (including 16-qpr2) arises from type-confusion memory corruption in multiple platform locations, letting a process that already has a low-privilege foothold on the device gain high-privilege code execution with confidentiality, integrity, and availability impact. Based on the CVSS vector (AV:L/AC:L/PR:L/UI:N), exploitation requires the attacker to already run code locally in a low-privileged context - a malicious or compromised app in its sandbox - and needs no user interaction and no special configuration; the flaw is reachable in default builds of the affected versions. There is no public exploit identified at time of analysis, CISA SSVC rates exploitation as none and the issue as not automatable, and a vendor-released fix is available through the October 2026 Android Security Bulletin (patch level 2026-10-01), so this is a genuine but not emergency-grade priority - the key limiting factor is the need for an existing on-device foothold rather than remote reachability.
Remote code execution in Immich before 3.2.4 lets any authenticated non-admin user with upload permission run arbitrary code inside the immich-server container. The exploit chains two crafted SVG assets: a stored reference asset and a second 'delayed-marker' SVG whose attacker-controlled <image href> value reaches ImageMagick's unrestricted MSL and VIDEO coders after the file bypasses libvips' native SVG loader, with execution occurring when the server generates a thumbnail. The attack is high-complexity and depends on the ImageMagick fallback path being reachable with those coders enabled; version 3.2.4 contains the fix, and no public exploit code was identified at time of analysis.
Local code execution on the Mercusys AC12 V2 router is possible because a 512-bit RSA private key is hardcoded in the firmware image and shared across every unit of that model, so anyone who obtains the key - from the firmware binary or through an on-device shell, serial or UART foothold - can bypass the trust operation it protects and run arbitrary code on the device. Exploitation requires local access only, with no authentication and no user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, 7.7 High), while confidentiality and integrity impacts are rated High and availability is unaffected. There is no confirmed active exploitation (not in CISA KEV) and the SSVC assessment marks the issue non-automatable, but a public advisory/exploit exists and EPSS is low at 0.17% (6th percentile), placing this as a bounded, physical/adjacency-level risk rather than a mass-exploitation emergency.
Insecure automatic update handling in GitAhead 2.5.0 through 2.7.1 allows a network-positioned attacker to deliver and execute an attacker-supplied update binary with the privileges of the victim user. The updater installs downloaded updates without integrity or signature verification (Updater.cpp:176-279), and the application permanently suppresses TLS certificate validation after the user accepts a single SSL error dialog (Application.cpp:284-309), so an attacker who presents an invalid certificate once can intercept later automatic update checks, offer a fake version, and achieve code execution when installation is approved. The CVSS 4.0 vector rates this 7.7 (AV:N/AC:H/AT:P/PR:N/UI:P) and the parallel CVSS 3.1 assessment is AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H; unauthenticated remote attackers are in scope, but exploitation is conditional on a man-in-the-middle position and mandatory user interaction at both the certificate dialog and the install prompt, and no public exploit code has been identified at time of analysis.
Server-side request forgery in the Plane project-management platform (makeplane/plane) prior to 1.4.0 allows any authenticated project member to make the server fetch attacker-chosen internal URLs during work-item link unfurling and read the response body back as the link title or favicon, producing a readable rather than blind SSRF. The vulnerable behaviour is a regression-style gap: the fix shipped in v1.2.2 for CVE-2026-27706 / GHSA-jcc6-f9v6-f7jw (also an SSRF in link unfurling) remains incomplete in the v1.3.1 GA release, so the v1.2.2 mitigation alone is not sufficient on that line. Rated CVSS 7.7 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N), exploitation requires a low-privileged authenticated account, and no public exploit code has been identified at time of analysis; the highest-value outcome is theft of cloud IAM credentials by targeting the instance metadata endpoint at 169.254.169.254 on cloud-hosted deployments, where the link fetcher can reach internal metadata or internal-only services.
Blind SQL injection in the Groundhogg WordPress plugin (versions through 4.8.3) allows an authenticated high-privilege user - an administrator, or any account granted Groundhogg admin capabilities - to inject SQL into a plugin query and extract data from the underlying WordPress database. The flaw is network-reachable with low attack complexity and requires no victim interaction, but the PR:H metric means an attacker must already hold elevated credentials, which sharply limits who can exploit it; there is no indication of active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis. The reporting source scored this 7.6, whereas independent assessment rates it lower (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:N/A:N, ~4.9) because the injection is blind, read-only in effect, and gated behind admin-level access - a genuine but conditional risk rather than a drop-everything emergency.
Server-side request forgery in self-hosted Plane (makeplane/plane) versions prior to 1.4.0 lets an authenticated workspace administrator who can create or edit webhooks point a webhook at an attacker-controlled hostname and then rebind that hostname to an internal IP address, causing the background delivery worker to issue requests against internal services, cloud metadata endpoints, or other hosts reachable from the API/worker containers. The flaw is a bypass of the earlier SSRF fix for CVE-2026-30242: creation-time IP validation is performed in apps/api/plane/app/serializers/webhook.py, but apps/api/plane/bgtasks/webhook_task.py independently re-resolves the hostname at send time without validating the result, leaving a DNS-rebinding TOCTOU gap. Per the assessed CVSS 3.1 vector AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:L/A:N (base 7.6), exploitation demands high administrative privilege and a successfully won DNS race, but yields high confidentiality impact and scope change; no public exploit code has been identified at time of analysis and the issue is fixed in Plane 1.4.0.
Missing authorization checks in the WordPress plugin 'Scratch & Win - Giveaways and Contests' (all versions through 3.0.2, vendor Apps Mav) allow an authenticated low-privilege user - for example a subscriber on a site that permits open or self-service registration - to reach plugin functionality that should be gated behind higher-privilege capabilities, resulting in high confidentiality exposure plus limited integrity and availability impact (CVSS 3.1 base 7.6, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L). Exploitation is network-reachable and requires no user interaction, but it is constrained by the need for a valid low-privileged account, so purely anonymous abuse is not confirmed. No public exploit code and no confirmed active exploitation were identified at time of analysis, and no vendor-released fixed version appears in the available data.
Arbitrary file write in Perforce P4 Search versions prior to 2026.4.2 allows an attacker who already holds a valid P4 Search service authentication token to dictate the file path used by the logging configuration interface and thereby write files anywhere on the host, which can escalate to code execution under the P4 Search service account. The flaw is a credentialed, privileged operation rather than an unauthenticated internet-facing attack: exploitation requires the service token, network reachability of the configuration interface, and a version older than the fixed 2026.4.2 release. No public exploit code and no confirmed active exploitation were identified at time of analysis; the practical risk is concentrated in environments where the service token is weakly protected or the interface is broadly exposed.
Server-side request forgery in Plane (makeplane/plane) before 1.4.0 lets an authenticated user abuse the OAuth avatar synchronization flow to make the Plane server fetch internal-only resources and then retrieve the fetched bytes through the public /api/assets/v2/static/{asset_id}/ asset endpoint. The avatar_url value taken from the attacker's OAuth provider profile is fetched server-side without internal-IP validation and with redirects followed by default, so a public URL can be used to bounce the request to a cloud metadata service (169.254.169.254) or an internal admin API reachable from the Plane host. Vendor-released patch: 1.4.0 (advisory GHSA-cv9p-325g-wmv5); no public exploit identified at time of analysis. The exploitation conditions are real but conditional - OAuth-based authentication with avatar sync must be enabled and the server must be able to reach something sensitive internally - so cloud-hosted deployments are the most exposed, and this is a legitimate but conditional risk rather than a drop-everything emergency.
Privilege escalation in Ghost CMS (versions 4.39.0 through 6.63.x) lets a staff user holding the 'view staff invites' permission read the secret tokens stored in pending invitations, including invitations issued for roles more privileged than their own, and then accept such an invite to elevate their account. Exploitation requires an authenticated staff session against the Admin API plus at least one pending higher-privilege invite at the time of attack, which is why the vendor rates attack complexity as high and the real-world priority is moderate rather than urgent. No public exploit has been identified at time of analysis, and the flaw is fixed in Ghost 6.64.0.
Denial of service in Scrapy 1.4.0 through 2.14.1 allows any web server the crawler visits to terminate the crawler process by returning a crafted Referrer-Policy response header, such as 'sys.exit', which the built-in RefererMiddleware treats as a Python import path and invokes. The flaw is reachable over the network without authentication or user interaction (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U, base 7.5 High), and its impact is limited to availability because only importable, zero-argument callables can be triggered, making realistic effect process termination rather than general arbitrary code execution. Any crawler left in its default configuration (RefererMiddleware enabled via REFERER_ENABLED=True) that fetches attacker-controlled pages is exposed; no public exploit identified at time of analysis, and the vendor-released patch is Scrapy 2.14.2.
Unauthenticated requests carrying attacker-chosen HTTP method tokens can drive unbounded Prometheus label growth in vLLM's Rust frontend prior to 0.30.0, exhausting process memory and inflating the /metrics response until the service or its monitoring path becomes unusable (CWE-400, CVSS 7.5 availability-only). The vulnerability applies to deployments where the track_http_metrics middleware is active and an 'unguarded' route such as /tokenize or /detokenize is reachable; the advisory and fix tests confirm those routes accept the request and record the raw method token as a metrics label. Publicly available exploit code exists, but CISA KEV does not list this CVE as actively exploited and EPSS is low (0.33%, ~24th percentile); the CISA SSVC assessment rates technical impact as partial and automation as 'no', since meaningful exhaustion requires a sustained stream of many unique method tokens rather than a single request. The issue is fixed in vLLM 0.30.0.
Unauthenticated information disclosure in Five Star Restaurant Reservations (plugin versions through 2.7.24) allows remote attackers to extract embedded sensitive data from WordPress sites. The vulnerability, tracked as CWE-201, has a CVSS 3.1 base score of 7.5 (AV:N/AC:L/PR:N/UI:N/C:H/I:N/A:N), indicating high confidentiality impact with no integrity or availability impact. No public exploit identified at time of analysis.
An authentication bypass in the npm packages @insumermodel/mppx-condition-gate (before 3.0.0) and @insumermodel/mppx-token-gate (1.0.0 through 1.0.3) lets unauthenticated remote attackers obtain content that should require payment by simply naming any wallet address that satisfies the configured on-chain condition. The gates trusted the client-supplied credential.source as proof of payer identity instead of verifying wallet control, so since qualifying wallets are public blockchain state, no secret or wallet ownership is needed; cached free-access grants can also be reused for the configured cache lifetime. No public exploit code was identified at time of analysis, and practical risk is bounded by the small deployment footprint of these packages; the vendor-released fixes are @insumermodel/mppx-condition-gate 3.0.0 and @insumermodel/mppx-token-gate 1.0.4.
Resource exhaustion in Apache Struts 2.5.14 through 2.5.33, 6.0.0 through 6.11.0, and 7.0.0 through 7.3.0 allows an unauthenticated remote attacker to amplify a small request into a far larger response, consuming server CPU and outbound network capacity. The issue is conditional: the target application must bind a request parameter to a java.math.BigDecimal property and then render that property through the Struts tag library; applications missing either behavior are not affected per the advisory and independent assessment. No public exploit has been identified at time of analysis, EPSS is low at 0.28% (19th percentile), and the impact is availability-only (CVSS 7.5 with C:N/I:N/A:H).
Remote unauthenticated attackers can make ViewSonic vCast fetch and install an attacker-supplied APK by abusing the vCast APK delivery mechanism's unauthenticated download endpoint to point the device at a malicious APK URL. Affected versions are vCast v0.0.0 through v3.2.715 inclusive on ViewSonic ViewBoard devices; the endpoint is network-reachable with no privileges and no user interaction, but the resulting installation is unprivileged, so the planted app runs as a normal application rather than with system/root rights. The supplied CVSS 3.1 base vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N (7.5), while our independent assessment treats the practical impact as C:N/I:L/A:N because the outcome is unprivileged app installation; no public exploit identified at time of analysis and no CISA KEV active exploitation is indicated.
Authorization bypass in the Plane project-management platform (Makeplane) prior to 1.4.0 lets callers retrieve FileAsset records - issue-description and comment-description attachments - from private or unpublished projects without being a member of the project those assets belong to. Two authenticated workspace-scoped endpoints (WorkspaceFileAssetEndpoint and WorkspaceAssetDownloadEndpoint) resolve assets by workspace only, so any active workspace member who knows an asset UUID can pull files from any project in that workspace, while the public-anchor EntityAssetEndpoint grants AllowAny access and scopes lookups to the anchor's workspace rather than its published entity or project, so an unauthenticated remote caller with a valid published anchor and a valid asset UUID can read assets from unpublished or private projects in that workspace; the CVSS vector (PR:N, no user interaction) reflects that unauthenticated path. Exploitation is constrained by CWE-639-style IDOR prerequisites: asset UUIDs are random and non-enumerable, so the attacker must first leak or otherwise obtain them, and no public exploit code and no confirmed active exploitation were identified at time of analysis. The issue is fixed in 1.4.0, and the practical priority is moderate rather than urgent given the UUID-guessing barrier.
Path traversal in Unimall v4's FileUploadController.local() enables remote attackers to read arbitrary files outside the intended upload directory; the supplied CVSS vector (PR:N/UI:N) indicates no authentication or user interaction is required, though that remains unconfirmed against the vendor's actual routing. Although the description claims arbitrary code execution, the same vector shows only high confidentiality impact (C:H/I:N/A:N), so RCE would require an unconfirmed write-into-webroot capability; our independent assessment notes that if such a write is possible, integrity and availability impacts could follow. No public exploit or CISA KEV listing was identified, and EPSS is low at 0.24% (13th percentile).
An out-of-bounds write in MediaTek modem (baseband) firmware allows an attacker operating a rogue base station to escalate privileges on a wide range of MediaTek chipsets (e.g., MT6853, MT6980, MT6991, MT8798, MT6895) once the victim's device connects to that base station; no authentication is required, but exploitation is high-complexity and requires user interaction per the assessed vector. No public exploit code or confirmed active exploitation has been identified at time of analysis, and the risk is bounded by the need for RF proximity to a malicious base station rather than being a mass-exploitable remote flaw.
Memory corruption in the MediaTek cellular modem baseband (an out-of-bounds write from a missing bounds check) allows an attacker who operates a rogue base station within radio range to escalate privileges on the target device without authentication and without any user interaction. Exploitation is not reachable over the internet: the CVSS vector AV:A/AC:H/PR:N/UI:N with C:H/I:H/A:H reflects that the attacker must be in adjacent radio proximity and must successfully induce the victim's UE to attach to the malicious base station, and CISA's SSVC assessment records Exploitation: none and Automatable: no, so this is a conditionally gated baseband flaw rather than a mass-exploitation emergency. No public exploit code has been identified at time of analysis; MediaTek has released a fix under Patch ID MOLY01778988 (Issue ID MSV-8897) in its October 2026 product security bulletin.
An out-of-bounds write in MediaTek modem firmware (CWE-787) allows a nearby attacker operating a rogue base station to escalate privileges on affected devices once the user equipment attaches to the attacker-controlled cell. The flaw has a CVSS 3.1 base score of 7.5 (AV:A/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) and affects dozens of MediaTek chipsets, including MT6833, MT6877, MT6983, MT6985, and MT6989, when they run unpatched modem firmware. No public exploit code has been identified at time of analysis, CISA's SSVC assessment records no observed exploitation and marks the issue as not automatable, and MediaTek has published a fix under Patch ID MOLY01778993 in its October 2026 product security bulletin.
Remote denial of service in Google Android 14, 15, 16, 16 QPR2, and 17 allows an unauthenticated attacker to crash the device's message-parsing path and cause persistent disruption by sending a crafted MMS/WAP PDU that PduParser.java decodes without an adequate bounds check. Because MMS PDUs are parsed automatically upon receipt, no user interaction or credentials are required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5); the only practical precondition is that the attacker can route an MMS to the victim's handset, which normally implies knowing the phone number and having carrier MMS reachability. CISA's SSVC evaluation records exploitation as none with no public exploit identified at time of analysis, although the flaw is classified as automatable, and impact is confined to availability (crash / persistent denial of service) with no confidentiality, integrity, or privilege gain.
Directory traversal in WookTeam 1.6.6 and earlier lets a remote attacker read arbitrary files from the server through the /api/project/task/export endpoint by supplying the data parameter with a crafted JSON payload whose file value contains ../ sequences, which are concatenated into storage_path() and streamed back via response()->download(). The assessed CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N (7.5), so the flaw is treated as unauthenticated and read-only, though the independent assessment flags that real-world deployments of this team-collaboration app may require a session to reach the export route and defenders should confirm whether their instance exposes it pre-authentication. Exploitation pressure currently looks low - EPSS is only 0.21% (11th percentile), there is no CISA KEV entry, and no public exploit identified at time of analysis, even though a public technical write-up of the file-read behavior is linked from the CVE record; the practical risk is limited to files readable by the web-server process user.
Cache poisoning in BuildKit lets a malicious image advertise DiffIDs that do not match its actual layer contents, so a daemon with a shared or persistent cache can adopt attacker-controlled layers as the base for a victim image and execute attacker code inside the victim build - for example by replacing a commonly executed path such as /bin/sh, reading build secrets mounted into the build, altering output artifacts, or hanging the build. Exploitation is unauthenticated but conditional: the attacker's image must be processed before the victim build on a daemon with a shared or persistent cache (multi-tenant or long-lived CI/build farms), and a victim build must then reference the targeted base image; ephemeral, non-shared caches are unaffected. No public exploit code identified at time of analysis; the vendor patch is BuildKit v0.33.1, and the issue carries a CVSS 7.5 (CVSS 4.0) rating with our independent assessment at CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:L.
Server-side request forgery in Feehi CMS 2.1.1 allows remote attackers to coerce the server into issuing HTTP requests to attacker-chosen URLs via the bundled UEditor 'catchimage' image-fetch endpoint, because the private-IP validation routine fails to block loopback (e.g. 127.0.0.1) and link-local (e.g. 169.254.169.254) destinations. The SSRF is semi-blind - the attacker infers internal service state through observable response differences rather than receiving full response bodies - so practical impact is limited to internal service probing and information disclosure, with no confirmed integrity or write effect; the supplied vector rates it 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N), while the independent assessment downgrades confidentiality to Low (C:L) and notes that PR:N is unverified because catchimage may sit behind an authenticated CMS session. Publicly available exploit code exists (SSVC Exploitation: poc) and the issue is automatable, but there is no confirmed active exploitation (not in CISA KEV), and the EPSS score is low at 0.14% (3rd percentile), indicating limited near-term exploitation likelihood at scale.
Unauthorized code execution during the boot process is possible on AMD Zynq UltraScale+ MPSoC, Zynq UltraScale+ RFSoC, and Kria SOM devices when an attacker with physical or local USB access can drive oversized Device Firmware Upgrade (DFU) download requests while the device is held in USB boot mode. The flaw is an out-of-bounds write (CWE-787) in the USB boot-mode DFU path: missing boundary validation allows the download to overflow the DDR receive buffer and corrupt adjacent First Stage Boot Loader (FSBL) memory before the FSBL hands off to later boot stages. AMD rates this 7.5 (CVSS 4.0 AV:L/AC:L/AT:P/PR:N/UI:N with High confidentiality, integrity, and availability impact to the device); no public exploit code and no confirmed active exploitation were identified at time of analysis, and practical exposure is limited to devices whose boot configuration actually permits USB boot rather than QSPI/eMMC/SD.