Kernel instability in the Linux wireless stack (cfg80211) lets an attacker-controlled rogue AP or Wi-Fi device within radio range drive a client into an assertion failure inside the BSS rbtree handling, resulting in a WARN_ON that becomes a full system crash when panic_on_warn is enabled. Only systems running the in-tree cfg80211/mac80211 code are affected, and exploitation requires an adjacent attacker plus a victim client actively associated to the malicious device; the malformed BSS type change does not occur in normal operation, so real-world exposure is limited to deliberate rogue-device scenarios. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV); EPSS is low at 0.18% (7th percentile), and our independent assessment scores this 5.3 (CVSS:3.1/AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) rather than the inflated 8.8 base score, reflecting availability-only impact with high attack complexity and adjacent access requirements.
Memory corruption and scope-changing host impact in the Linux kernel's PowerPC IOMMU TCE handling affect ppc64 systems where a local low-privileged actor can invoke multi-page TCE hypercalls such as H_STUFF_TCE or H_PUT_TCE_INDIRECT with npages greater than 1. The flaw is in iommu_tce_check_ioba(), which used a hardcoded page count of 1 instead of the caller-supplied npages, so the intended bounds check can be bypassed and the TCE table capacity may be exceeded, yielding the assessed full confidentiality, integrity, and availability impact on the host under a scope-changing vector. No public exploit identified at time of analysis, no CISA KEV entry was provided, and EPSS is low at 0.18% (7th percentile); vendor patches are available.
Use-after-free in the Linux kernel's KVM PowerPC Book3S HV nested-virtualization path (kvmhv_emulate_tlbie_all_lpid) lets a local attacker who controls an L1 guest corrupt host kernel memory by racing a tlbie-driven nested-guest free against a vCPU iterating the nested-guest IDR, yielding high confidentiality and integrity impact on the host (assessed CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H; the vendor/NVD vector lists the same impacts with AC:L for 8.8). Exploitation is timing-dependent and limited to PowerPC Book3S HV hosts running KVM with nested virtualization enabled and exercised; there is no public exploit code identified at time of analysis and EPSS is low (0.18%, 7th percentile), so risk is serious but narrow. Vendor fixes are released in Linux 6.1.189, 6.6.158, 6.12.112, 6.18.54, 7.2.8 and 7.3-rc4 (EUVD-2026-93211).
Gitea Actions in versions up to and including 1.27.3 can execute workflow code from an untrusted fork pull request head on the repository's runners without the maintainer approval that the first-time-contributor gate is supposed to require. An authenticated user holding Actions write permission can cancel a run that is still awaiting approval and then re-run it; the rerun path recreated the attempt's jobs as waiting instead of blocked while the run still recorded that approval was required, so the jobs were released without an approval decision. Signals point to a genuine but not emergency-grade issue: exploitation requires Actions enabled, a registered matching runner, a fork pull request from a first-time contributor, and Actions write access (CVSS PR:L), no public exploit code was identified at time of analysis, and EPSS is low at 0.16% (4th percentile).
Fork-controlled workflow code execution is possible in Gitea (through 1.27.3) when Actions is enabled and a repository runs a shared run-level concurrency group: an attacker who can open a fork pull request plants workflow content in an approval-gated run, a sibling run in the same concurrency group cancels the blocked job and drives the run terminal while it still carries the approval flag, and a later maintainer approval re-queues the already-cancelled job so a matching runner claims and executes it. The independent assessment rates this CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:U/C:H/I:H/A:H - lower than the 8.8 base figure because the decisive step is a human maintainer approval plus a race against a sibling run and an available accepting runner - and no public exploit code has been identified at time of analysis. No public exploit identified at time of analysis; EPSS is 0.16% (4th percentile) and CISA SSVC records Exploitation: none, Automatable: no, Technical Impact: total.
WeasyPrint releases prior to 70.0 hand attacker-controlled bytes - from HTML img URLs, CSS image values, SVG image references, and data URIs - to Pillow's generic image dispatcher, which does not exclude Encapsulated PostScript, so on any host with Ghostscript installed Pillow's EpsImagePlugin shells out to that interpreter and runs the attacker's PostScript. This produces interpreter-permitted effects, demonstrated by the fix commit's dangerous.eps sample writing /tmp/test-marker.txt, and escalates to remote code execution when the installed Ghostscript has a usable -dSAFER sandbox bypass; hosts without Ghostscript never reach the rasterization path and are not exploitable. No public exploit code and no CISA KEV entry were identified at time of analysis, and the vendor-released patch is WeasyPrint 70.0; the published CVSS is 8.8 while our own assessment rates attack complexity as High with no privileges and no user interaction required.
OS command injection in Dell OpenManage Integration for Microsoft Windows Admin Center (versions prior to 3.7.0) allows an authenticated low-privileged remote attacker to execute arbitrary commands on the management host, compromising confidentiality, integrity, and availability. The vulnerability requires network access (AV:N) and low privileges (PR:L) but no user interaction (UI:N), and it is only reachable where the Dell OpenManage Integration extension is installed. No public exploit code or active exploitation is currently identified; the vendor has released a security advisory (DSA-2026-442) with a fix in version 3.7.0.
Authenticated low-privileged users of Microsoft SimpleChat can achieve operating-system command execution under the application service identity by exploiting an authorization-ordering flaw in POST /api/user/plugins (CVE-2026-105797, CVSS 8.8). Affected releases are 0.261.003 and 0.261.027; an attacker with a valid low-privilege session can omit the top-level MCP type field so that the _reject_non_admin_mcp_stdio check skips inspection, after which the type is restored from metadata and a stdio MCP action is persisted - the process then spawns when that action tool is invoked. Exploitation additionally requires two non-default deployment prerequisites (personal plugins enabled and governance permitting MCP actions), and there is no public exploit identified at time of analysis; vendor-released patch: 0.261.031.
OS command injection in SambaBox appliances running versions before 5.4.1 allows an attacker who holds a valid but low-privileged account to execute arbitrary operating system commands on the underlying host by supplying shell metacharacters to a command-handling function. The flaw is network-reachable, low-complexity, and requires no user interaction, but the need for an authenticated session (CVSS PR:L) is the key limiting factor that separates it from a fully unauthenticated remote code execution scenario. No public exploit code or confirmed active exploitation was identified at time of analysis, so risk is concentrated in organizations that actually expose SambaBox interfaces to users beyond a trusted management network.
Mooncake Store master through 0.3.13.post1 performs no authorization check on the EvictDiskReplica and BatchEvictDiskReplica RPCs, so any unauthenticated remote attacker who can reach the master's coro_rpc port can force the deletion of DISK replicas belonging to any object across all tenants. Where a targeted object's only surviving replica lives on disk, the eviction causes permanent, unrecoverable data loss; objects with in-memory or redundant replicas instead suffer availability degradation rather than total loss. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (no CISA KEV listing), but the independently assessed CVSS:3.1 score of 8.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H) reflects high availability impact for any master RPC endpoint that is network-reachable.
Authenticated command injection in Microsoft UFO's Mobile MCP server (ufo/client/mcp/http_servers/mobile_mcp_server.py) lets a caller holding a valid Mobile MCP API key smuggle shell metacharacters through the type_text text parameter and the launch_app package_name parameter; the adb client concatenates those values into a remote command string that the connected Android device re-parses, executing extra commands as the Android shell user. The issue affects UFO releases prior to 3.0.10 and, per the CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H vector (8.8), requires authentication (PR:L) plus a reachable, already ADB-authorized device, while confining impact to Android shell-user privileges rather than host OS or root execution. No public exploit identified at time of analysis. Vendor-released patch: 3.0.10.
Server-side request forgery in GitHub Enterprise Server 3.20, 3.21, and 3.22 lets an authenticated repository contributor with push permission cause the appliance to issue requests to attacker-controlled internal hosts, which can be chained to remote code execution on the appliance. The flaw sits in the secret scanning validator for GCP service account credentials, which trusts the token endpoint embedded in a committed credential and sends a request to it without restricting the destination, and it additionally requires GitHub Advanced Security with secret scanning validity checks enabled, a non-default configuration. No public exploit identified at time of analysis; vendor-released patches are 3.20.9, 3.21.7, and 3.22.2, and the issue was reported through the GitHub Bug Bounty program.
Denial of service in the @stablelib/cbor decoder before version 2.0.4 (the GitHub advisory records the fix as 2.0.3) allows remote, unauthenticated attackers to exhaust the JavaScript call stack by submitting a CBOR payload composed of deeply nested arrays, maps, or tagged values, producing a RangeError during decoding that can terminate the worker or process handling the request. Because the pre-patch decoder imposed no nesting limit and had no iterative fallback, no non-default configuration, credentials, or user interaction are required - only that the application decode attacker-controlled CBOR. Public proof-of-concept code is included in the vendor advisory (a 12,000-level nested-array payload), and the flaw is scored HIGH (CVSS 4.0 base 8.7, assessed independently as CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) with impact confined entirely to availability, since confidentiality and integrity are explicitly unaffected. Exploitation escalates to a real outage only where the thrown exception is left uncaught and allowed to kill the request worker or process; services that wrap decode() in try/catch degrade to a single failed request. There is no indication of confirmed active exploitation (not in CISA KEV).
Unauthenticated remote attackers can stall server-side rendering in Quasar Framework versions prior to 2.23.3 by sending a crafted User-Agent header that triggers catastrophic regex backtracking in Platform.parseSSR(). Because Platform is an auto-installed plugin, the header is parsed before routing on every SSR request, so a single malformed request keeps the Node.js event loop busy and delays or blocks all other SSR traffic - an availability-only impact (CVSS 4.0 base 8.7; our assessment CVSS 3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). Only SSR targets are exposed; SPA, PWA, Electron, Cordova, Capacitor, browser-extension, and static-site-generation builds never feed an attacker-controlled header into this path. No public exploit identified at time of analysis, and no CISA KEV listing or EPSS score was provided in the source data.
Stored cross-site scripting in Payload CMS before 3.90.0 (and canary builds before 4.0.0-canary.34) lets an authenticated user with upload privileges plant a crafted SVG in any collection configured to accept downloadable SVG uploads; the file survives sanitization and executes attacker-controlled JavaScript when a victim downloads and opens it. The vendor rates it 8.7 High (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N), reflecting the need for a valid upload account plus victim interaction, with scope change because the payload is delivered through the application's own storage and origin. No public exploit identified at time of analysis; the issue is fixed in 3.90.0 and 4.0.0-canary.34.
Authenticated high-privilege users on Arista EOS can exploit a path traversal (CWE-22) in the Network Provisioning Image Repository to read or write files anywhere on the platform filesystem, escaping the intended storage scope via crafted requests or malicious file uploads. The issue requires valid credentials with image-repository permissions (CVSS PR:H), so the exploit population is limited to insiders or attackers who have already compromised a privileged account. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but the high confidentiality and integrity impact makes this a mid-to-high priority for affected deployments.
Unauthenticated attackers within radio-frequency (RF) proximity can crash the WIPS sensor service on affected Arista access points or potentially achieve remote code execution by sending a crafted frame. The vulnerability, an out-of-bounds write (CWE-787), affects APs with Wireless Intrusion Prevention System (WIPS) enabled and requires no wireless association, authentication, or user interaction. No public exploit has been identified at time of analysis; the CVSS 4.0 score is 8.7, and while not a mass-internet-exploitation emergency, it is an operational-priority issue for Arista wireless environments because successful exploitation disables WIPS monitoring and may allow code execution on the AP.
In Arista CV-CUE, an unauthenticated attacker can forge their apparent source IP address and obtain administrative session privileges on the CV-CUE backend, effectively bypassing authentication (CWE-290). The attacker must either be positioned on an adjacent private network segment reachable by the backend, or route requests through a reverse proxy or load balancer that forwards client-supplied headers such as X-Forwarded-For without sanitising them; no credentials and no user interaction are required. Rated CVSS 4.0 8.7 (and scored 8.7-equivalent high impact under the independent CVSS 3.1 assessment with AV:A/AC:L/PR:N/UI:N/C:H/I:H/A:H), this is a credible high-priority authentication-bypass issue. There is no public exploit identified at time of analysis, and exploitation is bounded by network reachability and header-handling configuration in front of the backend. Patch availability is not confirmed in the provided data; consult the Arista security advisory 0190.
Stored cross-site scripting in Microsoft SimpleChat versions prior to 0.261.029 allows an authenticated group Owner, Admin, or DocumentManager to persist arbitrary JavaScript through a crafted document filename uploaded via POST /api/group_documents/upload; the payload executes in the SimpleChat origin when another group member clicks the Share control on the affected document. Scored CVSS 8.7 (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N), the flaw yields high confidentiality and integrity impact with scope change because the injected script runs with the victim's session, exposing victim-visible data and actions. Exploitation requires a privileged authenticated group member to plant the payload and a second group member to trigger it (Share click, or hover via a tooltip-attribute variant that can also reach ordinary Users); no public exploit code was identified at time of analysis, and the issue is remediated in 0.261.029.
Authenticated remote code execution in Craft CMS 5.10.13.2 allows any low-privilege Control Panel user to run operating-system commands as the PHP/web-server process by injecting Twig through the app/render-components action. The attack requires only basic CP access; a non-admin Team user with no optional permissions was shown to override an EntryType uiLabelFormat and trigger an Entry render that evaluates attacker-controlled Twig via renderObjectTemplate(). No public exploit identified at time of analysis, but the impact is severe because the render path is unsandboxed and can reach PHP functions such as system().
Unauthenticated arbitrary file deletion in the WordPress plugin Simple File List (versions through 6.3.11) lets remote attackers remove files from a vulnerable site without authenticating, without user interaction, and without any non-default configuration. The issue is rated 8.6 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:L/A:H), with the limited integrity sub-score reflecting that the real damage depends on which files the web server user can delete - deleting wp-config.php or core files is far more severe than deleting an uploaded asset. No public exploit identified at time of analysis and the plugin is not listed in CISA KEV; this is nonetheless a genuine high-priority issue for WordPress sites running the affected plugin.
Authenticated SQL injection in Payload CMS allows a user holding read plus create or update permission on a collection that contains a json field - or a blocks field with blocksAsJSON enabled - to inject arbitrary SQL through crafted field paths and query operators when the site runs on the Postgres or SQLite database adapters. Only collections carrying those specific field types are reachable; collections built purely from text and richText fields are explicitly not affected, and richText fields themselves are not exploitable. The flaw requires an authenticated principal (CVSS PR:L) with write access, which materially narrows the attack surface, and no public exploit code or confirmed in-the-wild exploitation has been identified at time of analysis; Payload has shipped fixes in 3.90.0 (SQLite adapters), 3.73.0 (Postgres adapters) and 4.0.0-canary.34.
Stored cross-site scripting / unrestricted file upload in Payload CMS lets an authenticated user with upload permission to an XML-accepting collection store an XML document (plus stylesheet) that executes JavaScript in the Payload origin when another logged-in user opens the file. Affected are all 3.x releases before 3.90.0 and canary/4.x builds before 4.0.0-canary.34, which the vendor fixed in the corresponding 3.90.0 and 4.0.0-canary.34 releases. Exploitation is conditional: it requires a non-default local upload configuration that permits XML/XML-family MIME types (for example via allowRestrictedFileTypes), a valid authenticated upload account, and a second user to open the stored file - there is no public exploit identified at time of analysis and the issue is not in CISA KEV, so this is a credible-but-conditional threat rather than a drop-everything emergency, though the CVSS 4.0 base score of 8.6 reflects high confidentiality/integrity/availability impact on the Payload origin.
Code execution outside the Chrome sandbox on Windows is possible through CVE-2026-106186, an uncontrolled search path flaw in Chrome's CredentialProvider component affecting Chrome builds prior to 155.0.8059.39. The issue is local-only (CVSS:3.1/AV:L) and requires both a pre-existing local foothold with write access to a directory the component searches and user interaction to load the affected program, yet because the credential provider loads in a more privileged Windows context the scope changes (S:C) and confidentiality, integrity, and availability impacts are all High, yielding a base score of 8.6 with no privileges required (PR:N). No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; SSVC rates exploitation as 'none' and automatable as 'no', and Chromium's own internal severity rating is 'Low', which sharply tempers the headline CVSS figure. A vendor patch is available as Chrome 155.0.8059.39.
OS command injection in Arista CloudVision CUE backup management allows an authenticated Super User to execute arbitrary commands with the privileges of the affected service by submitting a crafted backup request. Exploitation is access-gated: it requires the highest application privilege level (PR:H), so anonymous or low-privileged remote users cannot trigger it; the issue functions as an application-admin-to-OS escalation. No public exploit identified at time of analysis, and no EPSS score or KEV status was provided; the independent assessment characterizes this as a genuine but access-gated vulnerability rather than a mass-exploitation threat.
Path traversal in the Software Management Studio Software Repository (CWE-22) allows an authenticated remote user with repository-level privileges to read and write files anywhere on the underlying platform filesystem, far outside the repository's intended storage scope, by sending specially crafted requests or crafted file uploads. Successful exploitation results in complete loss of confidentiality, integrity and availability for the affected system (CVSS 4.0 base 8.6; independently assessed as CVSS 3.1 8.6 with AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). The decisive limiting factor is the high-privilege prerequisite (PR:H) combined with the absence of any public exploit identified at time of analysis, so realistic risk is concentrated in insider misuse or reuse of already-compromised privileged repository credentials rather than opportunistic external attack; this is a conditional priority, not a drive-by threat.
Improper access control in the npm package @payloadcms/plugin-mcp (versions 3.61.0 up to but excluding 3.88.0) lets any authenticated user of the configured user collection create, read, update, and delete MCP API keys belonging to other accounts; because an MCP key authenticates as the user it is bound to, an attacker can mint or rebind a key to a higher-privileged account and take it over. The flaw is network-reachable and requires only a low-privileged account (CVSS 4.0 score 8.6 and the independent assessment's CVSS 3.1 vector both carry PR:L with high confidentiality and integrity impact), and it is only exploitable when the application actually exposes the MCP API Key collection - installations that do not use @payloadcms/plugin-mcp are entirely unaffected. The vendor fixed the issue in 3.88.0; no public exploit code and no confirmed active exploitation were identified at time of analysis.
HortusFox versions before 6.2 expose an authenticated remote code execution path through the theme import feature (ThemeModule::startImport): an uploaded ZIP archive is extracted into the public web root before file names, extensions, or content are validated, so an attacker with an administrator account can bundle a PHP payload and an .htaccess file that re-enables PHP execution and then execute arbitrary OS commands as the web-server user by requesting the dropped file under the themes directory. Exploitation is gated by administrator privileges (CVSS PR:H), so practical risk depends on obtaining or compromising an admin account; no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV). The vendor addressed the flaw in the 6.2 release, and the issue is tracked under CWE-434 (unrestricted upload of a file with a dangerous type).
Authenticated SQL injection in the Woffice WordPress theme at versions 5.4.35 and earlier lets any Subscriber-level account supply crafted input through an as-yet-unidentified theme endpoint and read arbitrary data from the site's database, including wp_users credential material and any other records the database account can reach. Exploitation is remote (AV:N) and requires no user interaction (UI:N), but does require a valid low-privilege account (PR:L) - a barrier that is minimal on the intranet, membership and community sites Woffice targets, where open self-registration is common. Patchstack reports an 8.5 score, while our independent assessment rates it 6.5 (scope-unchanged, confidentiality-only, no integrity or availability impact); there is no CISA KEV listing and no public exploit identified at time of analysis, and the exact vulnerable parameter must be confirmed from the Patchstack advisory.
Authenticated SQL injection in WP2LEADS plugin versions 3.5.7 and earlier allows any Subscriber-level user to execute arbitrary SQL queries, resulting in high confidentiality impact and low integrity/availability impact. The vulnerability is network-reachable (AV:N) with low attack complexity (AC:L) and requires only low-privilege authentication (PR:L), making sites with open user registration particularly at risk. No public exploit identified at time of analysis.
Improper task-state validation in the @backstage/plugin-scaffolder-backend plugin (Backstage versions prior to 3.3.1, 3.4.1, 4.0.3 and 4.1.0) allows an authenticated user who holds permission to create and access Scaffolder tasks to race the task-retry path and, under specific timing and deployment conditions, influence files reachable by the Backstage backend process. Where the backend's application files are writable by the service - a non-default configuration - this can compromise the confidentiality, integrity and availability of the backend, which is why the advisory carries a high 8.5 CVSS score with scope change; no public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV) for this issue. Real-world impact is gated by three conditions: the attacker must be authenticated with the Scaffolder permission (PR:L, not anonymous), must win a non-deterministic timing window (AC:H), and must target a deployment whose backend files are writable, so hardened environments with read-only application files are substantially less exposed than the headline score suggests.
SQL injection in UDesign Core WordPress plugin versions 4.15.0 and earlier allows an authenticated attacker with Subscriber-level access or higher to read sensitive data from the underlying database. Our independent assessment rates this as high confidentiality impact (C:H) with no integrity or availability impact (I:N/A:N) and unchanged scope, differing from the provider CVSS vector which claims scope change and low availability impact. Exploitation requires an account on the target site; many WordPress sites enable open registration, lowering the barrier, but no public exploit identified at time of analysis.
SQL injection in the ListingPro WordPress plugin through version 2.9.12 allows an authenticated Subscriber-level attacker to inject arbitrary SQL through a plugin code path, exposing database contents such as user credentials hashes, listing records, and site configuration. Exploitation requires a valid Subscriber account, which is easy to obtain on sites with self-registration enabled, and only WordPress installations where the plugin is installed and activated are exposed; sites upgraded past 2.9.12 are not affected. No public exploit identified at time of analysis, and there is no confirmed active exploitation (not in CISA KEV); the issue is genuinely actionable but below top-tier urgency, with the practical risk concentrated on open-registration membership and directory sites.
SQL injection in the BuddyBoss Platform WordPress plugin (versions 3.1.0 and earlier) lets an authenticated low-privilege user - specifically a subscriber-level account - inject SQL through a plugin input that is not safely parameterized, exposing data stored in the site's database. Because BuddyBoss powers community and social-networking sites that very often leave open user self-registration enabled, the Subscriber role required by the vector (PR:L) is usually trivial to obtain, and no user interaction or non-default configuration is needed beyond a valid account. The vendor CVSS base score is 8.5 (High) with scope change, high confidentiality impact and low availability impact; no public exploit code or confirmed in-the-wild exploitation was identified at time of analysis.
SQL injection in the Paid Member Subscriptions WordPress plugin through version 3.1.1 allows authenticated subscriber-level users to execute crafted SQL queries and read sensitive data from the site's database. The independent assessment gives a vector of CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L (reported base 8.5), meaning confidentiality is high while integrity and availability impact are low and scope is unchanged. Exploitation requires only any valid subscriber account, which is typically easy to obtain on sites using this plugin for open self-service registration; no public exploit identified at time of analysis.
Arbitrary code execution on the TechDocs backend host is achievable through a sanitizer bypass in the @backstage/plugin-techdocs-node package prior to versions 1.14.6 and 1.15.4, where crafted MkDocs configuration keys (notably extra_templates) evade the allowlist filter originally added to fix CVE-2026-25153. Exploitation is not anonymous: an attacker must hold write/commit access to a repository onboarded into a TechDocs-enabled Backstage instance (PR:L, authenticated), and must defeat an existing hardened sanitizer (AC:H), after which the malicious configuration executes automatically during documentation generation with no further user interaction (UI:N) and can compromise confidentiality, integrity, and availability of the backend host and, per the S:C scope change, potentially beyond it. No public exploit code has been identified at time of analysis, CISA KEV does not list this issue, SSVC rates exploitation as none and automatable as no, and EPSS is low at 0.27% (18th percentile), making this a genuine but conditional priority rather than a drive-by critical. This is a genuine but conditional priority, not a drive-by critical.
Broken access control in the WPO365 WordPress plugin through version 44.1 lets an authenticated Subscriber-level account reach data or functionality beyond its assigned role, with the CVSS 3.1 vector indicating high confidentiality impact and a scope change. Exploitation is network-reachable and low-complexity requiring only a low-privilege account, with no user interaction needed; however, sites that disable self-registration or have no untrusted low-tier users substantially limit exposure. The CVE carries a HIGH base score of 8.5, and no public exploit identified at time of analysis, with no confirmed actively exploited (CISA KEV) status.
Improper input validation in the @backstage/plugin-scaffolder-backend-module-sentry scaffolder actions (Backstage 0.3.0 through 0.3.7) lets an authenticated internal Backstage user who is permitted to run the Sentry actions (for example sentry:project:create) supply a caller-controlled apiBaseUrl, causing the Backstage backend to send requests - including the configured Sentry Bearer token - to an attacker-chosen destination. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N, base 8.5) reflects a low-privilege, network-reachable flaw with scope change and high confidentiality impact, since the leaked integration token's usefulness depends on the token's privileges and network reachability. No public exploit code or confirmed active exploitation has been identified at time of analysis, but a vendor advisory, a fix commit, and patched releases exist.
Heap-based buffer overflow in HDF5 (The HDF Group) before 2.2.0 lets an attacker who supplies a crafted HDF5 file corrupt heap memory in any application linked against the library, causing a crash and potentially achieving arbitrary code execution. The flaw lives in H5VM_array_fill() (src/H5VM.c) and is triggered when a dataset's unallocated/unwritten chunks are read: H5D__fill_init() derives the fill-value buffer from datatype and dataspace metadata stored in the file, and when that metadata is inconsistent with the buffer's allocated size the write overruns the buffer with attacker-controlled fill-value bytes. Exploitation is not network-reachable - it requires a victim to open or automatically process the malicious file (AV:L, UI:P per CVSS 4.0; UI:R in the 3.1 assessment), so risk is highest in data-ingest, HPC and ML pipelines that parse untrusted HDF5 inputs without an interactive user; no public exploit code has been identified at time of analysis and there is no KEV listing, though the CVSS 4.0 base score of 8.5 reflects high confidentiality, integrity and availability impact.
Code execution with the hosting application's privileges is possible in Hydra 1.3.4 through versions before 1.3.7 (and before 1.4.0.dev10) when an attacker controls multiple sibling target entries in a configuration that the application passes to instantiate(). One sibling resolves hydra._internal.target_policy.UNCONTROLLED_EXECUTION_TARGETS.discard to delete a denied target from Hydra's process-global blocklist, and a later sibling - processed in insertion order against the same mutated policy - invokes the now-permitted callable; the mutation persists for the life of the process. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, 8.5) indicates no privileges are required and only passive user interaction, and no public exploit identified at time of analysis (not in CISA KEV, no POC referenced); exploitation is limited to deployments that feed untrusted configuration content to instantiate(), and a narrow execution whitelist supplied by trusted Python code is not bypassed by the reported direct mutation path.
Heap buffer overflow in libmikmod's Oktalyzer (.okt) loader lets a crafted module corrupt heap memory and potentially achieve code execution, because a 16-bit track-count field (numtrk = numpat * numchn) can be made to wrap while pattern data is still written for the full, unwrapped track count. Any application linked against libmikmod before 3.3.14 is affected, and exploitation requires the victim to open or otherwise process an attacker-supplied .okt file, matching the independently assessed CVSS 3.1 vector AV:L/AC:L/PR:N/UI:R (7.8) rather than a remotely reachable condition. No public exploit identified at time of analysis, and the 3.3.14 release rejects overflowing track counts outright.
Heap buffer overflow in libmikmod before 3.3.14 is triggered when an application linked against the library parses a crafted DSM module whose numchn and numpat header fields produce a product that overflows the 16-bit UWORD truncation in DSM_Load(), corrupting heap memory and potentially enabling code execution. The issue is local and file-based: an attacker must deliver a malicious DSM file and a victim must open or play it, so it is not a drive-by remote threat; no authentication or special privileges are required, and no public exploit has been identified at time of analysis. A vendor-released patch is available in libmikmod 3.3.14.
Stored cross-site scripting in Sachertortephp (MISP's CakePHP-derived framework) lets an authenticated user who can control an attachment filename inject CR/LF or a double quote into the Content-Disposition header generated by CakeResponse::download(). A CR/LF causes PHP to drop the entire Content-Disposition header so the response body renders inline with its own Content-Type on the application origin, while a double quote permits injection of additional Content-Disposition parameters; the payload is stored via attribute downloads, proposal downloads, or restSearch exports and executes when another authenticated user views the affected page. No public exploit code has been identified at time of analysis; an upstream fix is available via vendor commits.
Openapi-python-client before 0.29.1 fails to neutralize attacker-influenced content from an OpenAPI document when rendering string, docstring, and f-string contexts, so a malicious or untrusted specification can cause arbitrary Python to be emitted into the generated client - code that then executes when that client is imported, compromising the integrity of the importing environment and potentially its confidentiality and availability. Exposure is conditional: it requires someone to generate a client from a spec they do not fully control (a third-party, public, or otherwise untrusted API definition) and then import the generated code, which is the trigger point, so organizations generating only from trusted internal specs are effectively unaffected. The flaw is rated 8.4 under CVSS 4.0 in the source data (independent assessment maps it to CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), which is consistent with a serious but conditionally triggered supply-chain and code-generation issue rather than a remotely reachable mass-exploitation vector. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor has shipped a fix in version 0.29.1.
Arbitrary code execution outside Chrome's sandbox on Android affects Google Chrome builds prior to 155.0.8059.39, where a missing authorization check (CWE-862) can be abused by a malicious co-installed Android app. The attack is local - it requires an attacker-controlled app to already be present on the same device plus successful social engineering to get the victim to install it and trigger the action - so a default, lone Chrome installation is not directly exploitable. Google rates this Chromium security severity Medium, the vendor CVSS is 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) while our assessment substitutes UI:R, no publicly available exploit code or confirmed active exploitation has been identified at time of analysis, and EPSS is only 0.12% (2nd percentile).
Insecure file permissions in Quasar's development TLS certificate utility (@quasar/ssl-certificate before 2.1.0, shipped via @quasar/cli before 5.0.4 and @quasar/app-vite before 3.3.0) let another local, unprivileged user on the same host read the cached combined private key and certificate PEM and then impersonate the developer's localhost HTTPS endpoint in any environment that trusts that certificate. The flaw is a local, low-privilege information-disclosure and impersonation issue (CWE-732) rather than a remotely exploitable critical condition: it only matters on multi-user, non-Windows machines (shared workstations, CI/build servers, container hosts) where at least one other local account exists and the generated dev certificate is actually trusted. Additional weaknesses compound the exposure - the generated certificate was CA-capable, carried unnecessary key usages, and encoded the IPv6 loopback address as a DNS SAN - but the practical impact remains bounded by the local-attacker prerequisite; no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV) for this CVE. Vendor-released fixes are available in @quasar/ssl-certificate 2.1.0, @quasar/cli 5.0.4 and @quasar/app-vite 3.3.0.
Sandbox escape in Google Chrome's WebAppInstalls component allows a remote attacker who has already compromised the renderer process to execute arbitrary code outside the browser sandbox when a victim visits a crafted HTML page and is socially engineered into interacting with the web app installation flow. The flaw is a missing authorization check (CWE-862) affecting Chrome versions prior to 155.0.8059.39; the technical impact is total, but the vendor rates it Medium because exploitation requires a prior renderer compromise, deliberate user interaction (UI:R), and high attack complexity (AC:H) rather than a default-configuration remote hit. No public exploit code and no confirmed active exploitation have been identified at time of analysis (CISA SSVC Exploitation: none, Automatable: no).
A use-after-free in Chrome's Metrics component (CWE-416) lets an attacker who has already compromised a sandboxed renderer process execute arbitrary code outside the sandbox - a sandbox-escape primitive rather than an initial-access bug. Only users running Chrome versions below 155.0.8059.39 are affected; the flaw is unauthenticated from the network perspective (PR:N) but requires the victim to load attacker-controlled crafted HTML (UI:R) and carries High attack complexity (AC:H) because the attacker must win a use-after-free race and defeat sandbox mitigations. Google has released a fix in Chrome 155.0.8059.39, no public exploit code has been identified at time of analysis, CISA SSVC records Exploitation: none, and the overall posture is patch-promptly-but-not-emergency rather than urgent.
Missing authorization in the Actor component of Google Chrome prior to 155.0.8059.39 allows code to escape the browser sandbox, but only after the attacker has already compromised the renderer process via a separate bug and then gets the victim to load a crafted HTML page. This prerequisite, combined with required user interaction (UI:R) and high attack complexity (AC:H) from the assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H vector, means the flaw is only usable as a link in an exploit chain rather than as a standalone initial-access vector; the changed scope (S:C) and high confidentiality, integrity and availability impact reflect the potential for full code execution outside the sandbox. No public exploit code identified at time of analysis and there is no confirmed actively exploited (CISA KEV) status, so risk should be weighed against the conflicting 8.3 score versus the demanding exploitation preconditions. A vendor patch is available in Chrome 155.0.8059.39.
Sandbox escape and potential arbitrary code execution outside the browser sandbox in Google Chrome via a confused-deputy flaw in the Google Lens feature, affecting all desktop releases prior to 155.0.8059.39. Exploitation is not standalone: a remote attacker must first have compromised the Chrome renderer process (a separate renderer-stage bug), then convince the victim to load a crafted HTML page, after which the Lens component can be induced to perform a privileged operation that crosses the sandbox boundary on the renderer's behalf - consistent with the CVSS:3.1 vector AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H and high attack complexity. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV absent, SSVC exploitation: none), but the maximum technical impact rating means the issue is worth prioritizing within normal patch cycles; vendor-released patch: 155.0.8059.39.