Memory corruption in Google Chrome's Navigation component - a use-after-free (CWE-416) - allows a remote attacker to execute arbitrary code outside the browser sandbox on any Chrome installation prior to 155.0.8059.39 by getting a user to load a crafted HTML page. The flaw is rated Critical by Chromium with a CVSS 3.1 base score of 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H): no authentication is required and delivery is network-based, but exploitation still depends on the victim rendering attacker-controlled content, and the scope change (S:C) reflects that successful exploitation escapes the renderer sandbox to affect the host system. No public exploit has been identified at time of analysis (CISA SSVC Exploitation: none, Automatable: no), and this is a genuine high-priority issue rather than an inflated high-CVSS score.
Server-side template injection in Dell Container Storage Modules (CSM) releases prior to 1.18.0 allows a low-privileged authenticated remote user to escalate privileges within and beyond the affected component, with a CVSS 3.1 base score of 9.6 (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N). The flaw is rated Scope:Changed with high confidentiality and integrity impact and no availability impact, meaning a compromise of the template-evaluating component can cross a security boundary and affect resources the attacker would not normally control. At time of analysis there is no evidence of confirmed active exploitation (not in CISA KEV) and no public exploit identified; the practical barrier is that a valid low-privilege account with network access to CSM is required before the injection can be delivered.
Out-of-sandbox code execution is achievable in Google Chrome desktop builds prior to 155.0.8059.39 by exploiting a use-after-free in the browser-process TabStrip component, reached when a victim is socially engineered into opening an attacker-crafted HTML page. The flaw carries a 9.6 CVSS (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) because the corrupted component sits outside the renderer sandbox, so a successful exploit escapes Chrome's primary containment boundary; however, it is not a zero-click bug and no public exploit identified at time of analysis, and CISA's SSVC assessment rates exploitation as 'none' with Automatable 'no'. A vendor-released patch (155.0.8059.39) is available, making this a high-priority but currently non-weaponized patch-now item rather than an active incident.
Use-after-free in the browser-process component of Google Chrome before 155.0.8059.39 lets a remote attacker execute arbitrary code outside the sandbox when a victim opens a crafted HTML page. Exploitation is unauthenticated (CVSS:3.1/AV:N/AC:L/PR:N) but requires the user to navigate to attacker-controlled content (UI:R); the scope change and high confidentiality, integrity, and availability ratings reflect that a successful page load escapes the renderer sandbox to reach host-level code execution, which pushes the base score to 9.6 and earns a Chromium security severity of Critical. There is no public exploit identified at time of analysis and the flaw is not listed in CISA KEV, so the practical near-term risk comes from the low complexity of the trigger (phishing, malvertising, or a compromised site) rather than from observed attacks. Vendor-released patch: Chrome 155.0.8059.39.
Incorrect authorization (CWE-863) in Google Chrome's SiteIsolation component allows an unauthenticated remote attacker to execute arbitrary code in the browser when a victim loads a crafted HTML page, a flaw Google rates High and that carries a CVSS base score of 9.6. Exploitation is limited by the required user interaction (UI:R) - the victim must visit attacker-controlled or compromised web content on a build older than 155.0.8059.39 - so delivery hinges on drive-by browsing or social engineering rather than unattended compromise, consistent with CISA's SSVC rating of non-automatable. No public exploit code has been identified at time of analysis, and a vendor-released patch is available in Chrome 155.0.8059.39.
Remote code execution outside the browser sandbox in Google Chrome prior to 155.0.8059.39 allows a remote attacker to execute arbitrary code on a victim's system via a crafted HTML page. The flaw is a use-after-free in the browser's Core component, and exploitation requires the victim to open attacker-controlled web content (UI:R) while no authentication or special privileges are needed (PR:N); the CVSS score is 9.6 with scope change (S:C) reflecting sandbox escape. Despite the high impact, there are no exploitation signals: no public exploit identified at time of analysis and the SSVC assessment lists exploitation as none, though the total technical impact and wide deployment make timely patching a priority.
An integer overflow in the WebGL implementation of Google Chrome on Android lets a remote attacker potentially execute arbitrary code outside the browser sandbox on devices running any build prior to 155.0.8059.39. The CVSS 3.1 base score is 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), meaning exploitation is unauthenticated but requires the victim to open an attacker-controlled HTML page that exercises the vulnerable WebGL code path; the scope change (S:C) reflects the potential escape from Chrome's renderer sandbox rather than a mere renderer crash. At time of analysis there is no public exploit identified, CISA's SSVC assessment records Exploitation: none and Automatable: no, and a vendor patch exists, so the issue is high priority on impact and patch urgency rather than on observed exploitation. Because WebGL is enabled by default on Android Chrome, no special configuration is needed on the victim side beyond navigation to the malicious page.
Incomplete cleanup in Dawn, Chrome's WebGPU implementation, allows a crafted HTML page to potentially corrupt GPU-process state and achieve code execution outside the browser sandbox in Google Chrome builds prior to 155.0.8059.39. Exploitation requires the victim to render attacker-controlled content that reaches the affected WebGPU/Dawn code path (CVSS UI:R with PR:N - unauthenticated remote attackers, but user interaction required), and the outcome is probabilistic rather than a guaranteed silent drive-by; the published base score is 9.6 while Google rates the issue Medium, and our assessed vector raises attack complexity to AC:H to reflect the difficulty of chaining a cleanup flaw into a reliable sandbox escape. No public exploit code has been identified at time of analysis, and Google has released Chrome 155.0.8059.39 as the fix.
Remote code execution outside the browser sandbox is possible in Google Chrome builds prior to 155.0.8059.39 through a use-after-free flaw in the built-in Chromecast (Cast) component: an attacker who gets a victim to render a crafted HTML page can corrupt freed memory and run arbitrary code with the browser's privileges (CVSS 9.6, Chromium severity Critical). The sole hard prerequisite is user interaction - no credentials or elevated privileges are required per the CVSS vector (AV:N/AC:L/PR:N/UI:R/S:C) - and because Cast ships with standard desktop Chrome rather than as an optional extension, the exposed population is essentially every unpatched Chrome installation. No public exploit code or confirmed active exploitation was identified at time of analysis, and Google has released a fixed build.
Incorrect authorization in the Google Chrome user-interface layer allows a crafted HTML page to escape the renderer sandbox and execute arbitrary code outside it on all Chrome builds prior to 155.0.8059.39. Exploitation requires the victim to open an attacker-supplied page (UI:R in the assessed vector) and, while no authentication is required (PR:N) and no unusual configuration is needed, the attack is not fully remote - it depends on that user action, which is the main limiting factor. Severity signals are mixed: the assessed CVSS vector scores 9.6 with scope change (S:C) and high confidentiality, integrity and availability impact, yet Google rates the underlying Chromium issue as Medium, and no public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Incorrect authorization in Google Chrome's FileSystem component allows a remote attacker to break out of the browser sandbox and potentially execute arbitrary code at the operating system level on desktop builds prior to 155.0.8059.39. Per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6), no authentication or prior privileges are required, but exploitation is not automatic: the attacker must use social engineering to convince the victim to open a crafted HTML page, which aligns with CISA's SSVC rating of "not automatable" and a technical impact of "total" given the scope change across the sandbox boundary. There is no CISA KEV listing and no public exploit code identified at time of analysis, and a vendor patch is available, so this should be treated as a high-severity, patch-now issue rather than an actively exploited emergency.
Integer overflow in the Media component of Google Chrome (all versions prior to 155.0.8059.39) allows a remote, unauthenticated attacker to corrupt memory via a crafted HTML page containing specially formed media content, with the potential to execute arbitrary code outside the browser sandbox. Exploitation is not automatic: the CVSS vector (UI:R) confirms the victim must actively load the attacker-controlled or compromised page, and Google rated this a Chromium severity of 'Low', indicating the sandbox-escape outcome is not reliably achievable and probably depends on specific memory conditions or combining this primitive with others. No public exploit code and no CISA KEV entry were identified at time of analysis; the 9.6 score reflects the scope-change metric (S:C) and high C/I/A impact rather than proven real-world exploitation, so the practical risk is lower than the headline score suggests.
An out-of-bounds write in the Media component of Google Chrome before 155.0.8059.39 lets a remote attacker corrupt memory and potentially achieve arbitrary code execution outside the browser sandbox when a victim opens an attacker-crafted HTML page containing malicious media content. The attack is fully remote and requires no authentication (CVSS:3.1/AV:N/AC:L/PR:N), but it is gated by user interaction (UI:R) - the victim must visit the malicious or compromised page - and the 'outside the sandbox' outcome implies defeating Chrome's process sandbox, which is materially harder in practice than the 9.6 base score suggests. No public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor has released a fixed build.
Improper input validation in the Mobile component of Google Chrome on iOS allows a remote attacker to potentially execute arbitrary code outside the browser sandbox when a victim is socially engineered into opening a crafted HTML page, fixed in Chrome 155.0.8059.39. Successful exploitation requires user interaction (CVSS vector PR:N/UI:R with S:C), meaning the attack hinges on phishing or a malicious link rather than a zero-click path, and the scope change reflects the assessed ability to escape the sandbox boundary. No public exploit code has been identified at time of analysis and the issue is not a confirmed actively exploited (CISA KEV) vulnerability, but the 9.6 CVSS score and the RCE tag make prompt patching of older mobile Chrome installations the priority.
A use-after-free in the Chrome Tabs component of Google Chrome on macOS allows a remote attacker to potentially execute arbitrary code outside the sandbox when a victim loads a crafted HTML page, affecting all builds prior to 155.0.8059.39. Exploitation is unauthenticated (CVSS PR:N) but requires user interaction (UI:R) - the victim must navigate to or open attacker-controlled web content, with no zero-click vector indicated, and reliable code execution additionally depends on successful heap grooming of the freed object. The issue is assessed as a genuine high-priority problem rather than a high-CVSS-but-low-real-risk case (CVSS 9.6, scope-changed), and no public exploit was identified at time of analysis; a vendor patch is available in Chrome 155.0.8059.39.
Use-after-free in Chrome's Tint shader compiler lets a remote attacker achieve code execution outside the browser sandbox when a victim opens a crafted HTML page - the page drives Chrome's WebGPU pipeline so that Tint compiles a malicious WGSL shader that triggers the memory-safety flaw. The flaw affects Google Chrome builds prior to 155.0.8059.39 and is rated 9.6 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), with the scope-change sub-score reflecting that successful exploitation escapes the renderer sandbox and yields host-level impact; no authentication is needed, but the attacker must convince the user to visit the page (UI:R). No public exploit code has been identified at time of analysis and CISA's SSVC assessment records no exploitation, so this is currently a high-priority patch-now issue rather than an actively exploited one; a vendor patch is available in the 155.0.8059.39 stable release.
Use-after-free in the ANGLE graphics layer of Google Chrome allows a remote, unauthenticated attacker to execute arbitrary code outside the browser sandbox when a victim opens a crafted HTML page; the vulnerable code path is present in Chrome builds prior to 155.0.8059.39. Exploitation is not automatic - the attacker must lure the user into rendering the malicious page (UI:R), but no credentials are required and the assessed CVSS:3.1 vector scores 9.6 with a scope change (S:C) because successful exploitation escapes Chrome's primary containment boundary rather than staying inside the renderer sandbox. Only publicly available exploit code would normally elevate this beyond an urgent patch-now item: at the time of analysis there is no indication of confirmed active exploitation (no CISA KEV listing) and no public exploit identified, while a vendor patch is available. Note that the description scopes the flaw to Chrome on Android, whereas the only vendor reference is the Desktop stable-channel release notes - the affected platform should be verified against the vendor advisory before relying on a platform-specific assumption.
Incorrect authorization in the Search component of Google Chrome for Android before 155.0.8059.39 can allow a remote, unauthenticated attacker to execute arbitrary code outside the browser sandbox when a victim is socially engineered into opening a crafted HTML page. The vendor-rated Chromium severity is Medium, yet the assessed CVSS is 9.6 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) because the flaw crosses a security boundary (scope changed) with high confidentiality, integrity and availability impact. The risk signals conflict and must be weighed carefully: the impact score is severe, but exploitation requires a click of user interaction, is confined to Android builds (desktop Chrome is unaffected), and no public exploit code or confirmed active exploitation has been identified at the time of analysis. Vendor patches are available.
Code execution outside the Chrome sandbox is possible in Google Chrome desktop builds prior to 155.0.8059.39, where a use-after-free in the network component (CVE-2026-106234, CWE-416) can be triggered by a crafted Chrome extension that a remote, unauthenticated attacker convinces a victim to install. The UI:R prerequisite - social engineering the user into installing the extension - is the primary limiting factor, which is why the vendor assigned a Chromium security severity of Low even though the assessed CVSS is 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) and technical impact is rated total in the CISA SSVC framework; the high CVSS and the Low vendor severity are sharply conflicting signals. No public exploit identified at time of analysis (SSVC exploitation: none), and a vendor patch is available.
Information disclosure in the Permissions component of Google Chrome before 155.0.8059.39 allows a remote, unauthenticated attacker to bypass the browser's site-isolation boundary by luring a victim into loading a crafted HTML page. Exploitation requires user interaction (UI:R) - the target must visit attacker-controlled content - and the resulting impact is limited to leaking information across origins rather than code execution, data modification, or denial of service. A vendor fix is already available in 155.0.8059.39, there is no confirmed active exploitation (no CISA KEV listing) and no public exploit code identified at time of analysis, and EPSS is 0.18% (7th percentile), indicating a low near-term exploitation likelihood.
Out-of-sandbox code execution in Google Chrome for iOS (versions prior to 155.0.8059.39) stems from a missing authorization check that lets a remote, unauthenticated attacker who socially engineers a victim into opening a crafted HTML page run arbitrary code outside the browser sandbox (CVSS 3.1 base 9.6, AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, CWE-862). Exploitation is not possible without user interaction - the victim must navigate to or open attacker-controlled content on a vulnerable iOS Chrome build - and no public exploit code was identified at time of analysis, with no KEV confirmation of active exploitation. The combination of a scope-changing sandbox escape with high confidentiality, integrity, and availability impact makes this a high-priority browser flaw, but the mandatory user interaction and the narrow affected population (only unpatched iOS Chrome builds) keep it short of an emergency-patch situation.
OS command injection in Progress Software's Autonomous REST Connector GenAI Agents ARCGenAI-Generator 2.0 allows attacker-controlled shell metacharacters embedded in a Swagger/OpenAPI schema name to run as arbitrary OS commands on a developer's workstation, because the derived {fileName} value is interpolated unquoted into the agent's shell-based temporary-file cleanup commands (rm -f / del /Q / rmdir). Exploitation is unauthenticated from a network perspective (CVSS:3.1/AV:N/AC:L/PR:N) but requires user interaction: a developer must load the attacker-supplied API specification into the generator, which is reflected in the UI:R metric and the 9.6 score with Scope:Changed. No public exploit code has been identified at time of analysis and the flaw is not in CISA KEV, but a vendor patch (upstream commit 7ede6d96eb033d647ffdcabf8d8069c098293575 plus the Progress DataDirect Critical Security Alert Bulletin, September 2026) is available.
Unauthenticated remote code execution in the SPIP Crayons plugin before 3.5.0 allows any remote attacker to take over a SPIP site by reaching crayons_store.php without the secu_ anti-forgery parameter, which causes the authorization dispatcher to select an unconditionally-true handler instead of the legitimate modification check. With authorization bypassed, the attacker can write an arbitrary .html skeleton file, read configuration files that expose the site secret, and forge a signed AJAX context that executes the planted skeleton as PHP under the web-server user. The assessed impact is high across confidentiality, integrity, and availability (CVSS:3.1 AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H; vendor-scored 9.3), exploitation requires only that the Crayons plugin be installed and enabled below 3.5.0, and no public exploit code was identified at time of analysis though the flaw is trivially reachable and unauthenticated.
Unauthenticated, network-adjacent attackers can crash - and potentially execute arbitrary code on - Arista Wi-Fi access points by sending a crafted packet to the wireless gateway service, provided the captive portal or application firewall feature is enabled on at least one SSID. The flaw is a stack-based buffer overflow (CWE-121) rated 9.4 under CVSS 4.0 (AV:A/AC:L/PR:N/UI:N with all impact metrics High and scope change), and because the wireless gateway service restarts automatically after a crash, an attacker can retry indefinitely. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (not listed in CISA KEV); exposure is limited to devices where a vulnerable feature is actually enabled and to attackers within wireless range or on an adjacent network segment.
Unauthenticated SQL injection in the Booknetic WordPress plugin (versions 4.8.5 and earlier) lets any remote attacker inject arbitrary SQL into database queries handled by the plugin, yielding direct read access to the underlying WordPress database. Per the assessed vector (AV:N/AC:L/PR:N/UI:N), the injection is reachable before authentication against a default plugin installation, so any internet-reachable WordPress site with Booknetic active and a publicly accessible booking page is a viable target - no account, no user interaction, and no non-default configuration required. The practical ceiling on impact is set by product presence: only sites actually running the affected plugin are exposed, and the value of exploitation scales with how much sensitive data the WordPress database holds; no public exploit code has been identified at time of analysis, and no EPSS score was supplied in the available intelligence, though the reported 9.3 CVSS score and confidentiality-heavy impact justify treating this as a high-priority patch.
Unauthenticated SQL injection in the WooCommerce Appointments WordPress plugin (versions up to and including 5.3.2) lets any remote attacker without credentials or user interaction inject arbitrary SQL through the plugin's request handling, giving high confidentiality impact with limited integrity impact and no availability impact (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N per independent assessment; the CVE record publishes a 9.3 score with a scope-changed vector). Because WooCommerce Appointments is a commercial paid booking add-on that must be licensed and activated on top of WooCommerce, exposure is confined to that subset of WooCommerce stores running a vulnerable version rather than the WordPress install base at large, which is the main factor keeping this a priority fix rather than an emergency. No public exploit identified at time of analysis.
Extraction of hardcoded credentials and cryptographic keys from the Schmooze dating mobile application lets unauthenticated remote attackers bypass authentication and act as legitimate clients against the vendor's backend and cloud services, with the CPE entry indicating no version is excluded from the flaw. Because the secrets ship inside a publicly distributed client package, any party who obtains the app and decompiles it can recover them without privileges, user interaction, or special server-side conditions (CVSS 4.0 base 9.3, PR:N/UI:N), yielding high confidentiality impact on the client and high confidentiality plus integrity impact on downstream backend/cloud systems. No public exploit code has been identified at time of analysis and the issue has not been added to CISA KEV, but the low barrier to reproduction and the structural nature of CWE-321 keep the practical risk high; the independent assessment notes that impact is bounded to the resources those specific embedded secrets authorize, and that key rotation plus app re-release invalidates previously extracted material.
Unauthenticated attackers who can reach the Murr Elektronik AAS Edge Client (all versions) REST API can read every data set exposed by its GET endpoints and alter Asset Administration Shell submodel data through PATCH requests, because those endpoints were deployed without any authentication (CWE-306). The issue is scored 9.3 under CVSS 4.0 and 9.1 under our CVSS 3.1 assessment (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), reflecting trivial network-only reachability, no credential requirement, and high confidentiality and integrity impact; availability is not affected in our assessment. No public exploit code and no CISA KEV listing were identified at time of analysis, so actual risk is driven almost entirely by exposure: high where the Edge Client API sits on an untrusted or flat OT network, substantially lower where it is segmented behind firewalls or confined to isolated industrial networks.
Unauthenticated SQL injection in ARMember Premium versions 7.8 and earlier allows remote attackers to execute arbitrary SQL queries against the underlying WordPress database, potentially exposing sensitive information. The flaw requires no authentication (PR:N) or user interaction (UI:N), and its scope change (S:C) indicates the database is a security authority distinct from the web application. No public exploit identified at time of analysis, but the CVSS score of 9.3 reflects the high confidentiality impact.
Unauthenticated SQL injection in the SendPress Newsletters WordPress plugin (all versions up to and including 1.26.1.20) allows a remote attacker who can reach an affected site to inject arbitrary SQL and read data from the site's database - including WordPress user credential hashes, secret keys and plugin/configuration tables - with no login and no user interaction. Our independent assessment recalibrates the reported CVSS 9.3 (vector AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:L) to CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N (7.5): a genuine high-priority issue rather than a CVSS-inflated one, with confidentiality-only impact and unchanged scope. The practical limiting factor is deployment - only sites actively running this plugin at or below the vulnerable version are exposed, and the exact injectable endpoint/parameter is not disclosed - and no public exploit code or confirmed active exploitation (CISA KEV) is identified at time of analysis.
Unauthenticated SQL injection in the WordPress plugin Radius Booking - Booking Calendar for Appointments & Services through 1.0.19 allows remote attackers to read arbitrary database data through crafted input, with the independent assessment limiting confirmed impact to confidentiality (C:H/I:N/A:N). Affected sites are only those with this specific plugin installed and active at a vulnerable version; no authentication, user interaction, or non-default configuration is required. No public exploit or CISA KEV entry is identified at time of analysis, and deployment scope is the primary limiting factor.
Unauthenticated SQL injection in the Porto Theme Functionality WordPress plugin affects versions up to and including 3.9.3, allowing remote attackers to inject arbitrary SQL into the plugin's database queries without any prior authentication (CVSS vector PR:N, no user interaction). Successful exploitation can expose sensitive data stored in the site's WordPress database - the independent assessment rates confidentiality impact as High and integrity impact as Low, while the vendor/feed score of 9.3 assumes scope change and a different impact mix; both agree the issue is trivially network-reachable. There is no CISA KEV listing and no public exploit code identified at time of analysis, so this is a high-severity, easily reachable flaw rather than a confirmed actively exploited campaign, and no fixed plugin version is specified in the supplied advisory data.
Unauthenticated SQL injection in the Weblizar WordPress plugin 'Newsletter Subscription Form - User Subscriptions Form, Capture Email' (versions up to and including 1.5.9) lets an attacker who can reach the plugin's public subscription/capture-email form endpoint inject SQL through user-supplied input. Per the CVSS vector (PR:N/UI:N), no authentication or victim interaction is required, so any site running this plugin with a publicly reachable form is exposed; the primary limit on real-world exposure is simply whether this relatively uncommon plugin is installed. The feed score is 9.3, while our independent assessment scores it 8.1 (scope unchanged, confidentiality high, integrity low, availability none) because the demonstrated impact is primarily database read-out rather than full compromise. No public exploit code and no confirmed active exploitation (no CISA KEV entry) were identified at time of analysis, so this is a high-severity but not yet corroborated-as-exploited issue.
Unauthenticated SQL injection in the WordPress plugin Gmedia Photo Gallery (versions 1.25.1 and earlier) allows remote attackers to inject arbitrary SQL into database queries and read data the application can access, which the assessment rates as high confidentiality impact with no integrity or availability impact. Any WordPress site with the plugin installed and active is potentially exposed because exploitation requires no account, no privileges, and no victim interaction (AV:N/AC:L/PR:N/UI:N); the practical gate is deployment - the site must run an unpatched version and expose the vulnerable endpoint to the network. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, but the reporter's 9.3 score and the zero-prerequisite vector make it a high-priority item for inventory and patching rather than a CVSS-inflated finding.
Unauthenticated network attackers can reach backend functionality in Arista CV-CUE that is intended only for internal services, giving them access to sensitive location information and the ability to disrupt affected services. The root cause is a missing authentication check (CWE-306) on internal-service endpoints, rated 9.3 under CVSS 4.0 with a vector of AV:N/AC:L/AT:N/PR:N/UI:N and high confidentiality, integrity and availability impact within the vulnerable component; an independent assessment agrees the flaw is remotely reachable and requires no credentials, configuration change or user interaction, but stresses that the real-world exploitability depends on network exposure. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the practical limiting factor is whether the internal endpoints are exposed to untrusted networks or are segmented behind a trusted management network.
Stored cross-site scripting in the Arista CloudVision Fileserver upload API lets an attacker who holds a valid CloudVision account with file-upload privileges persist a malicious payload that executes in another user's browser session. Because the missing input validation allows unsanitized content to be stored and later rendered, a successful hijack of an administrator's web session can yield full account and administrative access, which is why the issue carries a 9.3 CVSS 4.0 base score; the independent assessment concurs (CVSS 3.1 8.0-class impact with S:C). Exploitation is not anonymous - it requires authenticated upload privileges (PR:L) and, critically, active interaction from a victim who must view the stored content (UI:A), so the highest-impact outcome depends on an administrator rendering the payload. No public exploit code or confirmed active exploitation was identified at time of analysis, and the headline 9.3 should be read with that nuance rather than as an unauthenticated remote compromise.
Stored cross-site scripting in Arista networking software (documented in Arista Security Advisory 0192) lets an unauthenticated attacker who can reach the affected interface from an adjacent network plant malicious content that later executes in the browser of an authenticated user who views it. Exploitation requires the one-two punch of adjacent-network reachability (CVSS AV:A) plus a logged-in victim rendering the stored payload (UI:A), so the attacker gains no privileges at injection time but can hijack the victim's authenticated session, read sensitive data, alter system state, or disrupt the service once the payload fires. Arista PSIRT rates this Critical at CVSS 4.0 base 9.3, and there is no public exploit code and no indication of active exploitation (not listed in CISA KEV) at the time of analysis.
The Mooncake Store REST service through version 0.3.13.post1 binds to 0.0.0.0 and enforces no authentication on any route, so any host that can reach the service port can read cached KV data (including user prompts), inject or delete objects via /api/put and /api/remove_all, and mount attacker-described segments via /api/mount - all without credentials or user interaction (CVSS:4.0 9.3; independent assessment: CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Exposure is the shipped default in affected versions, making risk highest where the listener is reachable from a flat internal network or accidentally exposed to the internet; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV). This is a missing-authentication class defect (CWE-306), not a memory-safety or injection bug.
Server-side remote code execution affects Handlebars versions 4.0.0 through releases prior to 4.7.10, where a flaw in the lookupProperty prototype-access check lets a rendered template reach Function.prototype.constructor and obtain the JavaScript Function constructor, executing attacker-supplied code with the server application's privileges. Exploitation is conditional: an unauthenticated remote attacker must be able to render a template whose source they control, the runtime must have allowProtoMethodsByDefault enabled (not the default configuration), and the template context must expose an accessible function value that can be traversed via __proto__. No public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (no CISA KEV listing); vendor-released patch: 4.7.10.
Authentication claim injection in Payload CMS affects versions after 3.0.0 and before 3.90.0, where a collection field configured with the saveToJWT option set to a Payload-reserved claim name (id, collection, email, sid, iat, or exp) can place attacker-influenced values into the authentication token issued at login, allowing spoofing of identity, email, collection, or session claims. Exploitation is gated on a non-default configuration plus attacker control over the aliased field value and a subsequent login, which is why the vendor's CVSS 4.0 score of 9.2 carries Attack Requirements Present (AT:P) and the independent assessment resolves to CVSS:3.1/AV:N/AC:H/PR:L/UI:N (high complexity, authenticated); default installations and collections that only map saveToJWT to non-reserved keys are not reachable. No public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is fixed in version 3.90.0.
PHP code injection in the Smarty templating engine allows remote code execution in applications running Smarty 4.x before 4.5.8 or 5.x before 5.8.5 that render templates through the extends:/multi-component inheritance path with caching enabled. When such a template is compiled, the top-level unifunc never restores its nocache_hash, so the value is null; combined with an empty regex alternative in the cache-split logic, attacker-controlled assigned data containing a forged /*%%SmartyNocache:%%*/ marker is copied verbatim (bypassing PHP-tag neutralization) into the regenerated PHP cache file and executed on the next include. Exploitation is unauthenticated per the vendor CVSS vector (PR:N) but is gated by strict preconditions - inheritance-path templates, active caching, unescaped attacker-controlled output, and a fresh PHP process that reloads the compiled file after the cache entry is evicted (TTL expiry or cache clear) while compiled files persist - making it conditional rather than reliably on-demand; no public exploit code or confirmed in-the-wild exploitation was identified at time of analysis.
Two-factor authentication bypass through brute force affects PLANKA 2.2.0 through 2.2.1: the POST /api/access-tokens/verify-totp endpoint imposes no limit on incorrect TOTP submissions, so an attacker who already holds a user's password can replay the same ten-minute pending token and guess six-digit codes until one is accepted, receiving a full access token. Exploitation is gated on possessing the victim's password (first factor) and the account having TOTP enabled, and the assessed CVSS 3.1 vector is AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N - materially lower real-world risk than the headline 9.1 (CVSS 4.0) score, which assumes PR:N. There is no public exploit identified at time of analysis and no confirmed active exploitation; the vendor fix is an upstream commit that destroys the pending session after repeated failures and adds per-IP and per-identifier rate limiting.
SQL injection in the web-based management interface of HPE Aruba ClearPass Policy Manager allows an authenticated attacker with high-privilege (PR:H) management-interface access to inject SQL into backend queries and run arbitrary database commands, with a vendor-assigned CVSS of 9.1 (AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H). The impact is severe - confidentiality, integrity and availability of the appliance database are all rated high, and the scope change (S:C) indicates the compromise can escape the vulnerable component - but the precondition of valid administrative credentials plus network reachability to the management UI substantially narrows the practical attack surface, and no public exploit code has been identified at time of analysis. No evidence of active exploitation (CISA KEV) is present in the provided intelligence; this is a genuinely high-severity issue that warrants prompt patching but is not an untriaged emergency.
Authorization bypass in the Chromoting (Chrome Remote Desktop) host component of Google Chrome on macOS prior to 155.0.8059.39 lets remote attackers circumvent macOS system access restrictions by sending crafted network traffic to the remoting service; the provided CVSS vector is AV:N/PR:N/UI:N so the flaw is treated as network-reachable and unauthenticated. Exploitation is conditional rather than opportunistic: it requires Chrome Remote Desktop (Chromoting) to be installed, enabled and network-reachable on a macOS host, and Google's Chromium team rated the underlying defect only 'Low' severity, which is why our independent assessment reduces impact to C:L/I:L/A:N with AC:H instead of the vendor's 9.1. No public exploit code or confirmed active exploitation has been identified at time of analysis, and EPSS is low at 0.21% (10th percentile), so this should not be triaged as a 9.1-equivalent emergency even though the vendor score is high.
Incomplete cleanup in the Chromoting (Chrome Remote Desktop) component of Google Chrome on macOS before 155.0.8059.39 lets a remote, unauthenticated attacker bypass system access restrictions using crafted network traffic, per the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N vector. Impact is materially constrained: only macOS hosts on an affected build with Chromoting enabled and reachable are in scope, and the realistic outcome is limited information exposure rather than full compromise, which is consistent with the vendor's 'Low' Chromium severity rating. Risk signals conflict sharply - the supplied CVSS score of 9.1 (C:H/I:N/A:H) and the authoritative assessed vector of C:L/I:N/A:N disagree - and must be reconciled before prioritization; EPSS is negligible at 0.17% (6th percentile), there is no KEV listing, and no public exploit identified at time of analysis. Vendor-released patch: Chrome 155.0.8059.39.
OAuth2 token-endpoint misuse in Gitea 28.0.0 and earlier allows anyone holding a valid, unexpired OAuth2 access token to submit it under the refresh_token grant and receive a brand-new access token plus refresh token, effectively extending access past the credential's original expiry. Exploitation requires a pre-existing valid access token issued for the same OAuth2 application and grant, so this is a persistence/escalation-of-lifetime flaw rather than an entry point for an unauthenticated outsider; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N (NVD rates it 9.1 with PR:N). Multi-source signals conflict: NVD's score and CISA's SSVC rating of total technical impact are severe, while EPSS is only 0.17% (6th percentile) and SSVC lists exploitation as none - no public exploit code has been identified at time of analysis and the issue is not in CISA KEV.
Duplicate-name tree entries pushed to Gitea ≤1.27.3 are stored and served inconsistently: the web diff and file views resolve such a path to the first entry, while `git checkout`, Gitea Actions and generated release archives resolve it to the last, so a contributor can open a pull request that looks benign to reviewers but runs or delivers attacker-controlled content at the same commit. Exploitation requires the ability to push a branch or open a pull request (contributor access, or a public instance allowing registration and fork-based PRs) and is only consequential where a consumer resolves the commit differently - CI auto-running on the PR, a developer checking it out, or a release tarball being built; there is no confirmed active exploitation and no public exploit code identified at time of analysis, with EPSS at 0.16% (4th percentile). Critically, upgrading fixes only new incoming objects - existing repositories are not rescanned, so a malicious tree already stored stays exploitable after the patch.
Authentication bypass in Gitea's built-in SSH server (affected releases up to and including 1.27.3) lets a remote attacker authenticate as another user by presenting a case-variant of that user's registered RSA public key. Three conditions must all hold: the built-in SSH server must be enabled via START_SSH_SERVER = true (non-default on many deployments), the backing database must perform case-insensitive text comparison (the default SQLite qualifies), and the attacker must possess or derive a working RSA private key whose public key differs from the victim's only by letter case, which is cryptographically very hard and is why the effort is assessed as high complexity rather than the low complexity of the published vendor vector. No public exploit code identified at time of analysis; EPSS is 0.16% (4th percentile) and the CISA SSVC assessment records exploitation: none. The flaw is fixed in v28.0.0 by matching keys on their SHA256 fingerprint instead of encoded content.
Man-in-the-middle server impersonation affects Microsoft MsQuic client applications built against the OpenSSL or QuicTLS TLS backend at versions prior to 2.4.20, 2.5.11, and 2.6.1, because the client fails to verify that the server certificate matches the intended target hostname. An attacker who already holds an on-path position can present a mismatched certificate and terminate the QUIC connection as the spoofed server, enabling interception and modification of application data; the CVSS 4.0 vector (9.1) and the independent assessment (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N) agree that the attack is unauthenticated, requires no user interaction, and is gated by the on-path positional prerequisite rather than by any credential. Deployments using the Schannel backend (including default Windows configurations) are not affected, and no public exploit code or confirmed active exploitation was identified at time of analysis.
Authenticated command injection in Microsoft UFO's Mobile MCP server (versions prior to 3.0.9) lets a caller who holds a valid UFO_MCP_API_KEY pass shell metacharacters through the press_key tool's free-form key_code parameter and have them executed as the Android shell user on an already-authorized, connected device. Exploitation is remote and requires adb on the UFO host plus a reachable paired device, so it is not a host OS compromise, nor does it grant Android root - impact is bounded to Android shell-user privileges on the target handset. No public exploit code or confirmed in-the-wild activity has been identified at time of analysis; the vendor has released a fix in version 3.0.9, and although the assigned CVSS is 9.1 (Critical), that score is driven largely by the scope change and network vector while the practical blast radius remains capped.