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.
Sandbox escape in Google Chrome before 155.0.8059.39 via a heap-based buffer overflow (CWE-122) in ANGLE, Chrome's graphics translation layer: a remote attacker who has already compromised a sandboxed renderer process can use a crafted HTML page to execute arbitrary code outside the sandbox. It is a second-stage primitive rather than an initial-access bug - the assessed vector CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H (8.3) reflects high attack complexity, a required pre-existing renderer exploit chain, and active user interaction (UI:R), with the scope change S:C capturing the crossing of the sandbox boundary, even though Chromium rates the underlying bug Low severity. No public exploit code was identified at time of analysis and CISA's SSVC data records no observed exploitation, so the headline 8.3 should be weighed against the significant preconditions.
Heap-based buffer overflow in Google Chrome's font-handling code (CWE-122) lets an attacker who has already compromised the renderer process execute arbitrary code outside the sandbox when a victim renders a crafted HTML page containing malicious font data. All Chrome builds prior to 155.0.8059.39 on default configurations are affected; exploitation is unauthenticated (PR:N) but requires user interaction (UI:R) and a pre-existing renderer compromise, so it functions as a sandbox-escape chain component rather than a standalone drive-by, and is rated high complexity (AC:H) despite a CVSS base of 8.3 (S:C). No public exploit code has been identified at time of analysis and CISA's SSVC assessment records no exploitation, but the vendor has shipped a fix in 155.0.8059.39.
Sandbox escape in Google Chrome on macOS, affecting releases prior to 155.0.8059.39, allows an attacker who has already compromised the browser's renderer process to execute arbitrary code outside the sandbox when the victim views a crafted HTML page. The CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, base 8.3) confirms a network-reachable, scope-changing escape that requires user interaction and carries high confidentiality, integrity and availability impact once triggered, but the AC:H rating and CISA SSVC 'Automatable: no' reflect that it cannot be used standalone - a prior renderer compromise is a hard prerequisite. Per the authoritative assessment this is a chained second-stage exploit limited to macOS; no public exploit code and no confirmed active exploitation were identified at time of analysis.
Type confusion in ANGLE, Chrome's OpenGL ES abstraction layer, lets a remote attacker who has already compromised the renderer process execute arbitrary code outside the browser sandbox in Google Chrome versions prior to 155.0.8059.39. The victim must load attacker-controlled graphics content (crafted HTML invoking WebGL/ANGLE paths), so user interaction is required, and the bug cannot be triggered by merely visiting a page without a separate renderer exploit first - it is a second-stage sandbox-escape primitive in a multi-bug chain rather than an initial-access vector. No public exploit identified at time of analysis; CISA's SSVC assessment rates exploitation as none and automatable as no, but technical impact as total, consistent with the CVSS scope change (S:C), high confidentiality and integrity impact, and the High Chromium security severity rating.
A sandbox escape in Google Chrome before 155.0.8059.39 lets an attacker who has already compromised the browser's renderer process trigger a race condition in Chrome's font handling and execute arbitrary code outside the sandbox, via a crafted HTML page the victim must load (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, score 8.3). The prerequisite is significant: a separate, prior renderer compromise is required, and AC:H reflects the non-deterministic nature of winning the race, so this is a chained post-exploitation primitive rather than a standalone drive-by. Unauthenticated from a network perspective, with UI:R meaning the target must open attacker-controlled content; no CISA KEV entry, no public exploit code identified at time of analysis, and CISA's SSVC assessment rates exploitation as none and automatable as no, though technical impact is total once the race is won. Vendor-released patch: 155.0.8059.39.
Use-after-free in Google Chrome's Storage component (all versions prior to 155.0.8059.39) allows a remote attacker to execute arbitrary code outside the sandbox, but only after the attacker has already compromised the renderer process - typically by chaining a separate renderer bug - and only when a victim loads a crafted HTML page (CVSS 8.3, AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H). Because a prior renderer compromise, user interaction, and non-trivial heap grooming are all required, this is a second-stage sandbox-escape primitive rather than standalone initial access. No public exploit code has been identified at time of analysis, CISA SSVC records exploitation as none, and Google has shipped a vendor patch in Chrome 155.0.8059.39.
Improper access control in the vertex result caching subsystem of IBM Langflow OSS 1.0.0 through 1.12.2 lets a remote authenticated attacker read sensitive cached data or inject malicious content into vertex results that other users then consume. The issue carries a CVSS 3.1 base score of 8.3 (High) under the vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L, meaning it is network-reachable with low complexity and requires only a low-privileged account, while yielding high confidentiality and integrity impact and low availability impact. No public exploit code has been identified at time of analysis and the flaw does not appear in CISA KEV; IBM has published a patch advisory (node/7290694), so exposure is limited to unpatched deployments and to attackers who already hold valid credentials on the instance.
Arbitrary code execution outside the browser sandbox is possible in Google Chrome on macOS prior to 155.0.8059.39, where incorrect reference resolution in the WebAppInstalls component allows crafted network traffic to cross a process trust boundary. Exploitation is not standalone: the attacker must already have compromised the Chrome renderer process, which makes this a second-stage sandbox-escape primitive in a larger exploit chain rather than a directly reachable remote compromise, and the assessed vector (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H) reflects that non-trivial precondition. A vendor-released patch (Chrome 155.0.8059.39) is available, and no public exploit code was identified at the time of analysis.
A race condition in Google Chrome's Fonts component prior to version 155.0.8059.39 lets a remote attacker escape the browser sandbox and execute arbitrary code at the browser's privilege level, but only after the attacker has already compromised a sandboxed renderer process through some separate, unrelated vulnerability. The exploit additionally requires the victim to load a crafted HTML page (UI:R) and the attacker to win a timing-dependent race (AC:H), so this is best understood as a sandbox-escape primitive rather than a standalone initial-access vector. There is no public exploit identified at time of analysis - CISA's SSVC assessment rates exploitation as 'none' and the flaw as not automatable - and a vendor-released patch (155.0.8059.39) is available, making this a high-priority defense-in-depth fix rather than a catastrophic unpatched bug.
Origin policy bypass in Google Chrome for Android prior to 155.0.8059.39 lets a remote attacker acting through a confused deputy have actions carried out under a different web origin's authority, so a victim who is socially engineered into opening a crafted HTML page can have that page reach resources or capabilities it should never hold for its own origin. Only Chrome on Android is affected, exploitation is not silent (it requires the user to open attacker-supplied content, CVSS PR:N/UI:R), and no public exploit code or active exploitation has been identified at time of analysis; EPSS is 0.22% (12th percentile), and Google rates the underlying Chromium bug as Low severity. Note the sharp signal conflict that must be reconciled before prioritization: the nominal vendor CVSS is 8.3 while EPSS, vendor severity, and our independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:L/A:N) all point to materially lower real-world risk.
System access restriction bypass in Google Chrome versions prior to 155.0.8059.39 allows a remote attacker to break out of the browser's security boundary through the FullScreen component, but only after having already compromised the Chrome renderer process and only with successful social engineering to make the victim interact with a crafted HTML page. Because it is a chain component rather than a standalone bug, exploitation requires a pre-existing renderer foothold plus mandatory user interaction (UI:R) and carries high attack complexity (AC:H), so it is not exploitable against a fully patched default browser on its own. No KEV listing and no publicly available exploit code have been identified at time of analysis, and EPSS is low at 0.22% (12th percentile), consistent with the conditional nature of the flaw despite the 8.3 CVSS base score and a Chromium security severity rating of Medium.
Sandbox escape in Google Chrome versions prior to 155.0.8059.39: a race condition (CWE-362) in the browser's font handling can be triggered when a victim renders a crafted HTML page, potentially allowing a remote, unauthenticated attacker to execute arbitrary code outside the browser sandbox. Exploitation requires the target to load or view the attacker-controlled page (UI:R) and depends on winning a timing-sensitive race (AC:H), which typically demands repeated attempts and precise memory grooming, making this a credible high-priority browser flaw rather than a confirmed emergency. No publicly available exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and a vendor patch is available from Google.
Arbitrary code execution outside the browser sandbox is possible in Google Chrome on macOS prior to 155.0.8059.39, where a timing-dependent race condition (CWE-367) in the Core component can be won to break out of the renderer's sandbox. Exploitation is conditional rather than a single remote shot: the attacker must already have compromised the renderer process, must socially engineer the victim into opening and interacting with a crafted HTML page (UI:R), and must win a non-deterministic race that the AC:H rating and CISA's SSVC assessment (Exploitation: none, Automatable: no) indicate is unreliable and not readily scriptable. No public exploit code has been identified at time of analysis, and Google has shipped a fixed build, 155.0.8059.39; because the mandatory pre-existing renderer compromise is a high bar, this is best treated as a conditional priority to be handled through normal patching cadence rather than an emergency.
Cross-site scripting in @quasar/app-vite (Quasar Framework) SSR and SSG rendering paths prior to 3.3.0 allows HTML attribute and markup injection when an application derives or overrides ssrContext.nonce from attacker-controllable data instead of relying on Quasar's default cryptographically generated base64/base64url nonce. The flaw is exploitable remotely and unauthenticated in the sense that no privileges are required on the server side (CVSS PR:N), but it is inert under default configuration: a quote character must survive into the nonce value, and the poisoned server-rendered page must then be loaded by a victim, so exploitability is contingent on the application's own nonce handling (independent assessment rates it AV:N/AC:H and requires user interaction). There is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; the issue is fixed in version 3.3.0.
Apache Commons BCEL before 6.13.0 caches attacker-supplied class files under the symbolic name declared inside the class file itself rather than validating that name against the name it was requested under, so a class loaded via AbstractClassPathRepository or ClassLoaderRepository can poison a repository entry keyed to a different, colliding name. Applications that load class files from an attacker-influenceable classpath or input stream and later rely on the repository's name-keyed lookups or verification results can be induced to operate on the wrong class, producing an integrity-only impact (no confidentiality or availability effect). The independent assessment rates this CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N - network-reachable and unauthenticated, but requiring a specific name-collision and subsequent lookup sequence (AT:P), so it is not a fully automatable drive-in exploit; no public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor's elevated 8.2 CVSS 4.0 score reflects the integrity impact alone.
Cross-origin data disclosure in Google Chrome (all versions prior to 155.0.8059.39) stems from a missing authorization check in the browser's FileSystem component, allowing a crafted HTML page to breach the web origin boundary and read data it should not reach. Exploitation is strictly a second-stage condition: an attacker must first have already compromised Chrome's renderer process through a separate flaw, and the victim must load attacker-controlled content (UI:R), so a default, fully patched Chrome with an intact renderer sandbox is not directly exploitable - a limitation that makes real-world risk moderate despite the 8.2 base score, and is reflected in the low EPSS of 0.22% (12th percentile). Google has shipped a fix in Chrome 155.0.8059.39, there is no confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis.
Site isolation bypass in Google Chrome for Android (versions prior to 155.0.8059.39) lets an attacker who has already compromised the renderer process cross the per-site process boundary and reach data that should remain isolated to other origins, triggered when the victim loads a crafted HTML page. It is a second-stage flaw rather than an initial-access vector: exploitation is gated on a separate, pre-existing renderer compromise plus required user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:L/A:N), which is why the vendor assigned a Chromium severity of Low even though the base score is 8.2. No public exploit identified at time of analysis, no CISA KEV listing, and EPSS is only 0.21% (11th percentile); a vendor patch is available, so the residual risk is concentrated in unpatched Android clients that are simultaneously exposed to a first-stage renderer exploit.
Privilege escalation in Dell System Update versions prior to 2.3.0.0 lets a low-privileged local attacker abuse an incorrectly secured critical resource to gain higher privileges (CVSS 8.2, CWE-732). Exploitation requires local access, a valid low-privileged account, and user interaction-most plausibly an administrator running the updater after malicious content has been staged in a writable location-so remote or unauthenticated attack is not possible. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.
Elevation of privilege in Dell System Update (DSU) versions prior to 2.3.0.0 allows an authenticated, low-privileged local attacker to reach a privileged code path and operate at higher integrity than intended, stemming from an improper access control weakness (CWE-284, tagged by the reporter as an authentication bypass). Exploitation is conditional rather than drive-by: the attacker must already hold a local account on the endpoint (AV:L, PR:L) and a separate user interaction step (UI:R) is required to trigger the vulnerable path, so this is a post-foothold escalation scenario with no remote or network-reachable vector. CVSS 3.1 scores it 8.2 with a changed scope and high confidentiality, integrity and availability impact, but no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV.
Ciphertext tampering in the Cloak Elixir encryption library (danielberkompas/cloak, all versions from 0.1.0-pre onward) lets anyone with write access to the encrypted store silently flip bits in stored ciphertext so that decryption returns an attacker-chosen plaintext of the same length. The affected code paths, Cloak.Ciphers.AES.CTR and Cloak.Ciphers.Deprecated.AES.CTR, encrypt with AES-256 in CTR mode and store the key tag, IV, and ciphertext with no MAC, and decrypt/2 validates only the key tag and a minimum length - so tampered data is returned as valid with no error. Exploitation requires write access to the ciphertext (the description cites SQL injection into the Ecto-backed database or a compromised replica) plus knowledge or a correct guess of the existing plaintext at the tampered offset, and the replacement value must be exactly the same length as the original; impact is integrity-only (VC:N/VA:N), with no public exploit identified at time of analysis. Note the vendor CVSS 4.0 score of 8.2 is driven entirely by VI:H, while an independent assessment applying CVSS 3.1 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N) rates the realistic risk considerably lower because an attacker must already control writes to the encrypted store and have plaintext knowledge.
Remote code execution in Payload CMS before 3.90.0 (and canary builds before 4.0.0-canary.34) lets a remote, unauthenticated attacker execute arbitrary code by sending a crafted request to the public first-register operation. The flaw only applies to instances that have local authentication enabled and have not yet had their first admin user created, i.e. a freshly deployed, re-provisioned, or ephemeral instance still inside its initial setup window; once an admin exists the attack surface disappears. No public exploit identified at time of analysis, and no evidence of active exploitation (not in CISA KEV), though the CVSS 8.1 score with full confidentiality, integrity and availability impact makes this a high-priority fix for anyone running uninitialized deployments.