Information disclosure in the Passwords component of Google Chrome desktop builds prior to 155.0.8059.39 lets a remote, unauthenticated attacker obtain sensitive data when a victim renders a crafted HTML page. The vendor rates the issue Chromium security severity Low, and the independent assessment converges on a limited-confidentiality impact (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N) rather than the 8.8 figure carried in some feeds, so the mandatory user interaction and the low-confidentiality scope are the real risk drivers. There is no public exploit identified at time of analysis, and a vendor patch is already shipping in the stable channel as 155.0.8059.39.
Google Chrome builds prior to 155.0.8059.39 contain a missing authorization check in the Autofill component that allows a remote attacker to read sensitive information in the browser's stored autofill data. Exploitation is not silent: it requires the victim to be socially engineered into opening an attacker-crafted HTML page (CVSS UI:R, PR:N), and the SSVC assessment records Exploitation=none and Automatable=no, meaning this cannot be triggered at scale or without user action. Our independent assessment rates the impact as confidentiality-only (C:H/I:N/A:N), so real-world risk is MODERATE and meaningfully lower than the headline CVSS 8.8 suggests; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV, though a vendor patch is available.
Use-after-free in Google Chrome's CSS handling affects builds prior to 155.0.8059.39 and allows a remote, unauthenticated attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. The flaw scores CVSS 3.1 base 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), yet Google assigned it Chromium severity Low because the resulting code execution is confined to the browser sandbox and requires user interaction - full host compromise would require chaining a separate sandbox-escape bug. No public exploit identified at time of analysis, and a vendor patch is available.
Arbitrary code execution confined to Chrome's renderer sandbox is possible in Google Chrome versions prior to 155.0.8059.39, where an incorrect comparison in the font rendering pipeline can be triggered by a crafted HTML page. This is an unauthenticated remote attack (AV:N/PR:N) that requires the victim to load attacker-controlled web content (UI:R); the resulting code execution stays inside the renderer sandbox (S:U), and escaping to the host operating system requires a separate, unrelated sandbox-escape vulnerability - which is why Chromium assigned a Low security severity despite the CVSS 8.8 base score. No public exploit code was identified at time of analysis, and a vendor-released patch (155.0.8059.39) is available.
Race condition in the V8 JavaScript engine allows remote code execution inside the browser sandbox in Google Chrome builds prior to 155.0.8059.39. A remote, unauthenticated attacker can trigger the flaw by getting a victim to open attacker-supplied HTML that drives V8 into the timing window (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) - the required user interaction is the only precondition, and code execution is confined to the renderer/V8 sandbox, so host compromise would require a second, separate sandbox-escape bug. Google has shipped a fixed stable-channel build, and no public exploit code or confirmed active exploitation was identified at time of analysis (CISA SSVC records Exploitation: none; no KEV listing or PoC in the available sources).
Use-after-free in Google Chrome's garbage-collection code before 155.0.8059.39 allows an unauthenticated remote attacker to corrupt memory and execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. Exploitation requires user interaction (PR:N, UI:R) and the code execution stays contained in the browser sandbox, so OS-level compromise would require chaining a separate sandbox-escape flaw; no public exploit identified at time of analysis, and CISA's SSVC assessment records exploitation as 'none' and automatable as 'no', which tempers the high 8.8 CVSS base score. Vendor-released patch: 155.0.8059.39, distributed through Chrome's stable channel.
Use-after-free in the Streaming component of Google Chrome prior to 155.0.8059.39 allows unauthenticated remote attackers to execute arbitrary code inside the renderer sandbox when a victim is socially engineered into loading a crafted HTML page, consistent with the CVSS vector AV:N/AC:L/PR:N/UI:R. Google rates the issue Medium severity (Chromium) while the CVSS base score is 8.8, reflecting high confidentiality, integrity, and availability impact on the renderer process rather than the host. There is no CISA KEV listing and no public exploit identified at time of analysis, and the SSVC assessment records exploitation as none; the primary containment is Chrome's process sandbox, so full host compromise would require chaining a separate sandbox-escape flaw.
Use-after-free in Google Chrome allows unauthenticated remote attackers to execute arbitrary code within the renderer sandbox by convincing a victim to load a crafted HTML page, affecting all versions prior to 155.0.8059.39. The attack requires user interaction (UI:R) but no authentication or special configuration, and while code execution is confined to the sandbox, the CVSS 3.1 score is 8.8. No public exploit or active exploitation has been identified, and a vendor patch is available.
Google Chrome builds prior to 155.0.8059.39 contain a use-after-free in PDF handling that allows a remote, unauthenticated attacker to execute arbitrary code inside the browser's renderer sandbox when a victim loads a crafted HTML page that embeds a malicious PDF. Exploitation requires the user to open attacker-controlled web content processed by Chrome's built-in PDF (PDFium) viewer - a mandatory interaction step (CVSS UI:R) with no zero-click vector, and any code execution is confined to the sandboxed renderer unless chained with a separate sandbox escape. There is no public exploit identified at time of analysis, SSVC records no observed exploitation and rates the issue not automatable, but technical impact is rated total given high confidentiality, integrity, and availability impact; a vendor patch exists in 155.0.8059.39.
Use-after-free in Google Chrome's Media component allows a remote attacker to execute arbitrary code inside the browser's renderer sandbox by luring a victim into loading a crafted HTML page in any Chrome build prior to 155.0.8059.39. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), consistent with Google's own 'High' Chromium security severity, and requires no authentication or privileges on the victim host beyond the user visiting the malicious content (UI:R). Exploitation is confirmed to be constrained by user interaction and by the renderer sandbox - CISA SSVC scores it Exploitation: none, Automatable: no, Technical Impact: total - and there is no public exploit identified at time of analysis, though a vendor-released patch is available.
Use-after-free in Google Chrome's parser allows remote, unauthenticated attackers to execute arbitrary code inside the renderer sandbox by convincing a victim to load a crafted HTML page, affecting all Chrome versions prior to 155.0.8059.39. Exploitation requires user interaction (the victim must visit or open the malicious page), and the resulting code execution is contained by Chrome's renderer sandbox, so full host compromise would require chaining with a separate sandbox-escape vulnerability. A vendor patch is available in 155.0.8059.39, and no public exploit identified at time of analysis, with CISA's SSVC assessment recording exploitation as none.
Remote code execution inside the renderer sandbox is possible in Google Chrome builds prior to 155.0.8059.39, where a use-after-free in the Media component can be triggered by a crafted HTML page. Exploitation requires the victim to load attacker-controlled web content (UI:R) but no authentication or special privileges (PR:N), so default desktop installs are affected; resulting code execution is contained within the renderer sandbox rather than the host operating system. At time of analysis there is no public exploit identified at time of analysis per available intelligence (SSVC exploitation: none, automatable: no), and a vendor patch is available from Google. Rated CVSS 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and Chromium security severity High, this is a genuine high-priority patching item, though the signals are mixed on urgency.
Use-after-free in Google Chrome's Select component before version 155.0.8059.39 allows unauthenticated remote attackers to execute arbitrary code inside the browser's renderer sandbox, but only after socially engineering a victim into opening a crafted HTML page (CVSS 3.1 8.8, AV:N/AC:L/PR:N/UI:R). The impact is confined to the sandbox, so compromise of the host operating system would require chaining a separate sandbox-escape vulnerability. No public exploit code or confirmed active exploitation was identified at time of analysis, and Google - the reporting party - has released a fixed build.
Remote code execution inside the Chrome renderer sandbox is possible in Google Chrome builds prior to 155.0.8059.39, where a use-after-free defect in the HTML handling path can be triggered by a crafted HTML page. Any user running an unpatched desktop Chrome who loads attacker-controlled web content (CVSS 3.1: AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8) can be targeted; no credentials or elevated privileges are required, but mandatory user interaction (UI:R) and the renderer sandbox confinement limit the direct blast radius, since escaping the sandbox to the host OS would require a separate, distinct vulnerability not covered by this CVE. Google has shipped a vendor patch (155.0.8059.39) and the issue was reported through the Chrome vulnerability program with a Chromium severity rating of High; no public exploit code and no confirmed active exploitation have been identified, and the affected-code flaw is consistent across the CPE wildcard for google:chrome.
Remote code execution confined to Chrome's renderer sandbox is possible in Google Chrome prior to 155.0.8059.39, where a use-after-free in the browser's Bindings layer can be triggered when a victim opens a crafted HTML page. The attack is unauthenticated (PR:N) but depends on user interaction (UI:R), and because the assessed scope is unchanged (S:U), code execution is contained inside the renderer sandbox - reaching the host would require a separate sandbox-escape vulnerability. No public exploit code or confirmed active exploitation has been identified at time of analysis, and Chrome's automatic update mechanism narrows the realistic exposure window, making this a high-priority patch item rather than an emergency.
Arbitrary code execution in Backstage TechDocs documentation builds allows an authenticated user with write access to a repository registered in the Backstage catalog to run commands on the build host by embedding malicious keys in the repository's mkdocs.yml. Both TechDocs build modes configured locally or in a container (techdocs.generator.runIn set to 'local' or 'docker') are vulnerable because the affected @backstage/plugin-techdocs-node package (prior to 1.14.6, and 1.15.0 through 1.15.3) failed to sanitize nested markdown_extensions and theme configuration values before invoking MkDocs. Exploitation is access-gated rather than anonymous: CVSS 3.1 scores this 8.8 with a PR:L vector, EPSS is low at 0.26% (16th percentile), CISA SSVC rates exploitation as none and automatable as no, and no public exploit code has been identified at time of analysis.
The signals here conflict sharply and must be reconciled before prioritization: the supplied CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and the 'Authentication Bypass' tag imply full compromise, while the authoritative assessed vector AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N describes only a confidentiality impact with mandatory user interaction. As assessed, an unauthenticated remote attacker can obtain sensitive information from Google Chrome desktop builds prior to 155.0.8059.39 when a victim opens a crafted HTML page, with no integrity or availability impact and no authenticated-session or special-configuration prerequisite in the product itself. There is no CISA KEV listing and no public exploit code identified at time of analysis, Chromium rates the underlying issue Low severity, and the vendor-released patch is Chrome 155.0.8059.39.
Privilege escalation in the WordPress plugin Tourfic Pro (the paid extension of the Tourfic travel and hotel booking plugin) at version 1.17.3 and earlier allows an attacker to elevate to a higher-privileged WordPress role, with a CVSS v3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflecting full loss of confidentiality, integrity and availability within the affected site. The CVSS vector's PR:L indicates the attacker must first hold a low-privilege authenticated account (for example a self-registered subscriber) and that no user interaction is required, but the vendor's own description labels the flaw 'Unauthenticated' - a material conflict that determines whether only registered users or any site visitor can trigger it, and defenders should verify which precondition actually applies. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV; the plugin's comparatively small installed base further limits real-world exposure, so this is best treated as a credible priority for sites running the plugin rather than a broadly exploited campaign.
A low-severity information disclosure exists in the Payments component of Google Chrome, where a remote attacker using a crafted HTML page and social-engineering lures could cause the browser to leak sensitive information handled by the payments/autofill feature in builds prior to 155.0.8059.39. Exploitation is not automatic: the victim must be convinced to open the attacker's page while running a vulnerable build, and the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N) confines realistic impact to confidentiality loss with no integrity or availability effect. There is no confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis; a vendor patch is available in Chrome 155.0.8059.39. Note that the supplied CVSS base score of 8.8 (C:H/I:H/A:H) is inconsistent with both the Chromium severity rating of Low and the independent assessment, and should not be used for prioritization without reconciliation.
Information disclosure in Google Chrome's Autofill component lets a remote, unauthenticated attacker read sensitive data by luring a victim to a crafted HTML page on any Chrome build prior to 155.0.8059.39. Exploitation requires user interaction (UI:R) - the victim must actually navigate to the attacker's page - which is the primary limiting factor, and no non-default configuration or privileges are needed since Autofill is enabled by default. The independent assessment scopes impact to confidentiality only (C:H/I:N/A:N), while the supplied vector additionally claims high integrity and availability impact; no public exploit code and no confirmed active exploitation have been identified at time of analysis, and vendor-patched builds are available.
Incorrect reference resolution in Google Chrome on macOS before 155.0.8059.39 can disclose sensitive information to a remote attacker who uses social engineering to make the victim load a crafted HTML page. Exploitation requires a macOS user running an affected Chrome build who actively opens attacker-supplied content (UI:R), with no authentication required (PR:N) and network-delivered payloads (AV:N); there is no confirmed active exploitation and no public exploit code identified at time of analysis, and the only data supplied is a vendor patch and a Chromium issue. The signals conflict sharply: the headline CVSS of 8.8 (C:H/I:H/A:H) is not supported by the available evidence, and the assessed vector is confidentiality-only (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N, roughly 6.5 Medium), matching Chromium's own 'Medium' severity label, so real-world priority is lower than the 8.8 figure implies.
Google Chrome on Android releases before 155.0.8059.39 mishandle Autofill reference resolution, allowing a remote attacker who socially engineers a victim into opening a crafted HTML page to read sensitive information held in the browser's Autofill store. The CVSS vector PR:N means no authentication is needed, but the required user interaction (UI:R) and social-engineering dependency are the main practical barriers; no public exploit code has been identified at time of analysis. Our independent assessment scores this as confidentiality-only (CWE-706, use of incorrectly-resolved name or reference), so it should be treated as an information-disclosure issue rather than code execution or data tampering.
Information disclosure in Google Chrome for Android lets a remote attacker who successfully socially engineers a victim into opening a crafted HTML page expose sensitive data handled by the browser's Passwords component; builds prior to 155.0.8059.39 are affected, and no authentication or non-default configuration is required. The vendor classifies the issue as Low severity (CWE-200) and no public exploit code was identified at time of analysis. Note that the supplied CVSS base score of 8.8 (C:H/I:H/A:H) is inconsistent with the information-disclosure description and the vendor's Low rating; our independent assessment scores it AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N, i.e. a confidentiality leak that strictly depends on user interaction.
Google Chrome for Android prior to 155.0.8059.39 contains an incorrect-authorization flaw in its Transactions Platform component that lets an unauthenticated remote attacker read sensitive information from the browser by luring the victim into opening a crafted HTML page. No public exploit code has been identified at time of analysis and the issue is not reported as actively exploited, though the attack is fully remote (AV:N/PR:N) and requires only that a user on a vulnerable Android build load the attacker's page (UI:R). Note that public severity signals conflict: the vendor rates this Chromium security severity 'Low' and limits impact to information disclosure, while a widely replicated CVSS 3.1 base score of 8.8 lists high integrity and availability impact that is not supported by the description - our independent assessment scores it 8.8-adjacent only on confidentiality (C:H/I:N/A:N).
Information disclosure in Google Chrome for Android (versions prior to 155.0.8059.39) allows remote, unauthenticated attackers to reach sensitive data held by the browser's Autofill feature via a crafted HTML page, with the flaw rooted in incorrect authorization (CWE-863) in the Autofill path. Per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N), exploitation requires the victim to actively navigate to the attacker's page and the impact is confined to confidentiality, with no integrity or availability effect; the vendor-supplied 8.8 score (C:H/I:H/A:H) and the 'Low' Chromium severity conflict with this assessment and should be reconciled before prioritization. Chrome on Android is the affected build, no public exploit was identified at time of analysis, and a vendor-released patch (155.0.8059.39) is available.
Incorrect authorization in the Selection component of Google Chrome for iOS lets a remote, unauthenticated attacker obtain sensitive information when a victim opens a crafted HTML page, and the issue is resolved in Chrome 155.0.8059.39. Only the iOS build of Chrome below that version is in scope; desktop and Android builds are not named as affected, and exploitation requires the user to actively visit the attacker-controlled page (UI:R per the assessed vector). No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, so the practical risk is bounded by mandatory user interaction, the narrow iOS-only affected population, and the fact that a vendor fix already ships; note that the supplied base score of 8.8 (C:H/I:H/A:H) is inconsistent with both the Chromium 'Low' severity label and the assessed vector, which rates impact as confidentiality-only.
Sensitive information disclosure in Google Chrome builds prior to 155.0.8059.39 lets an unauthenticated remote attacker obtain data through the browser's Bluetooth handling by convincing a victim to open a crafted HTML page (CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N per the independent assessment). The root cause is an incorrect authorization check (CWE-863) in the Web Bluetooth code path, so exploitation is limited to an information leak rather than code execution; the mandatory UI:R requirement means this is not a no-interaction drive-by, and the victim must be running a vulnerable Chrome version that reaches the affected Bluetooth logic. No public exploit identified at time of analysis, and the issue is not confirmed actively exploited (no CISA KEV entry), although the vendor-rated 8.8 score conflicts with the assessed confidentiality-only vector and should be weighed as a severity signal rather than proof of integrity or availability impact. Vendor-released patch: 155.0.8059.39.
Use-after-free and out-of-bounds pointer handling in the Linux kernel CIFS/SMB client (cifs.ko) lets a malicious or man-in-the-middle SMB server corrupt kernel memory on a connecting client by returning crafted encrypted compound PDUs. The defect sits in receive_encrypted_standard(), where a stale next_buffer pointer retained on error paths and unvalidated NextCommand/next_cmd offsets taken from pre-decryption length can lead to use-after-free and reads beyond the reassembly buffer, affecting confidentiality, integrity and availability of the host. Exploitation requires the victim to act as an SMB client and mount or connect to an attacker-controlled share, with SMB3 encryption/sealing negotiated and attacker-controlled server responses; no public exploit has been identified at time of analysis, EPSS is low at 0.21% (11th percentile), and vendor-released patches exist for the affected stable trees.
Remote code execution inside the Chrome renderer sandbox is possible in Google Chrome versions prior to 155.0.8059.39 through a race condition in the V8 JavaScript engine, triggered when a victim loads a crafted HTML page. The flaw requires no authentication (PR:N) but does require user interaction (UI:R) and depends on winning a non-deterministic timing window, which is reflected in the assessed AC:H and makes reliable exploitation harder. Resulting code execution stays within the renderer sandbox, so escaping to the host OS would require chaining a separate sandbox-escape vulnerability; no public exploit code has been identified at time of analysis, and vendor patches are available.
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.