OS command injection in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows a remote authenticated attacker holding only a low-privilege account to execute arbitrary operating-system commands on the underlying host, fully compromising the confidentiality, integrity and availability of the affected deployment. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) confirms network reachability, low attack complexity, mandatory authentication at the low privilege level and no user interaction, matching the independent assessment that this is a genuine high-priority vulnerability rather than a high-CVSS-but-low-risk artifact. No public exploit code was identified at time of analysis, and a vendor patch is available through IBM support node 7288649; accordingly, real-world risk is concentrated in reachable, unpatched 5.4.0.0 deployments rather than in broad opportunistic exploitation.
OS command injection in IBM DataStage on Cloud Pak for Data 5.4.0.0 lets an authenticated remote attacker with only low-privilege credentials run arbitrary commands on the underlying host, yielding full confidentiality, integrity, and availability impact. The flaw requires network reachability to the DataStage service but no user interaction and no non-default configuration, so any valid low-privilege account is sufficient to attempt exploitation; the platform is a specialized enterprise deployment typically placed behind organizational access controls rather than exposed to the internet. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV), but a vendor patch is available per IBM's advisory, and the low attack complexity and high impact make prompt patching advisable.
OS command injection in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows an authenticated remote attacker holding low-privilege credentials to execute arbitrary commands on the underlying system, with high impact to confidentiality, integrity, and availability. The flaw stems from improper neutralization of special elements used in OS commands (CWE-78), and exploitation requires a valid authenticated session plus reachability of the specific DataStage feature that passes user-supplied input into a shell command; no user interaction is needed. No public exploit code has been identified and there is no evidence of active exploitation (not listed in CISA KEV), but a vendor patch is available and the issue should be treated as a genuine high-priority fix rather than a high-CVSS-but-low-risk artifact.
Remote authenticated code execution in IBM DataStage on Cloud Pak for Data 5.4.0.0 is possible because connector property values are not properly escaped when OSH scripts are generated, allowing an attacker with a valid account and the ability to define or edit connector properties to inject commands that execute with DataStage privileges. The flaw is network-reachable, low-complexity, and requires no victim interaction, but it requires authentication (CVSS 3.1 PR:L) and is rated 8.8 HIGH (C:H/I:H/A:H). No public exploit code or confirmed active exploitation was identified in the provided intelligence, and a vendor patch is available via IBM support.
Remote code execution in Microsoft Outlook affects Microsoft 365 Apps for Enterprise, Office LTSC 2021, and Office LTSC 2024 when a targeted user opens or previews a specially crafted email message. The CVSS vector (AV:N/AC:L/PR:N/UI:R) indicates an unauthenticated remote attacker can trigger the flaw with no credentials, but success depends on the victim interacting with the malicious message - Outlook's Preview Pane is a plausible trigger surface for message-borne code execution. No public exploit code has been identified at time of analysis (E:U) and Microsoft has released an update, so this is a high-priority patching candidate given the enormous installed base of Outlook, but not an emergency requiring emergency change control.
Remote code execution in MLflow's statsmodel flavor (versions 2.1.0 through 3.14.0) occurs because _load_model() omits the MLFLOW_ALLOW_PICKLE_DESERIALIZATION=False safeguard, allowing a crafted MLmodel artifact to trigger unsafe pickle deserialization (CWE-502). An authenticated low-privileged attacker (PR:L) who can register or supply a malicious artifact to the model registry or artifact store can achieve arbitrary code execution when a victim's pipeline or serving process loads it, although the victim must load the untrusted artifact (UI:R). The independent assessment notes that no public exploit was identified at time of analysis (SSVC Exploitation: none), and exposure is limited to environments that load untrusted statsmodel artifacts; those using only trusted internal models are not realistically exposed.
Durable MQTT sessions in Moquette 0.18.0 and earlier can corrupt each other's persisted queues when a client connects with an identifier ending in '_meta', allowing cross-session message loss, misdelivery, or exposure of queued content. The flaw only exists when the broker is configured with H2 MVStore-backed durable/persistent sessions, and the attacker must use a client ID shaped like '<victim_client_id>_meta', so some knowledge or predictability of a target client ID is required; Moquette accepts anonymous clients by default, so authentication is not necessarily a barrier (assessed CVSS 3.1 AV:N/AC:H/PR:N/UI:N/C:L/I:H/A:L). The impact is integrity-dominant with limited confidentiality loss - this is a JVM memory-safe broker and no RCE is involved; the upstream advisory that covers this bug also ships source-only PoC code for a companion pattern-ACL bypass, but no public exploit identified at time of analysis and no CISA KEV listing. The issue is fixed in Moquette 0.18.1.
Type confusion in Google Chrome builds prior to 154.0.8037.57 lets a remote attacker who convinces a victim to load attacker-controlled web content corrupt memory inside the renderer and potentially achieve code execution in that process. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-843), meaning no authentication or privileges are required but exploitation is not zero-click: the victim must render a malicious page, and because scope is unchanged the initial compromise is confined to the renderer sandbox unless chained with a separate sandbox escape. No public exploit code has been identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV); a vendor-released patch is available in Chrome 154.0.8037.57.
Arbitrary code execution in MLflow (versions 2.0 and later) via the dspy flavor, where an attacker-crafted MLflow model artifact causes remote code execution when loaded by a victim. The vulnerability arises because the MLFLOW_ALLOW_PICKLE_DESERIALIZATION=False safety control is enforced only when the model_path ends in '.pkl'; any other path (or extension) silently skips the check and unpickles attacker-controlled data. Per the CVSS vector (AV:N/AC:L/PR:N/UI:R) an unauthenticated remote attacker can exploit this, but success depends on user interaction: a person or automated pipeline must fetch and load the malicious model. Exploitation has not been confirmed as active (not in CISA KEV) and no public exploit code was identified at time of analysis, and CISA SSVC rates exploitation as 'none' with automatable 'no', though technical impact is total (full confidentiality, integrity, and availability loss on the host that loads the model). The CVSS 8.8 score is well-justified by the technical impact rather than inflated.
Use-after-free memory corruption in Google Chrome desktop builds earlier than 154.0.8037.57 (CWE-416) allows remote attackers to corrupt memory and potentially achieve code execution inside the renderer process when a victim opens a malicious or compromised web page. The flaw is remotely reachable with low attack complexity and no privileges required (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 8.8), but it hinges on user interaction and, because scope is unchanged, exploitation is contained to the sandboxed renderer; full host compromise realistically requires chaining a separate sandbox-escape bug. There is no confirmed active exploitation and no public exploit identified at time of analysis, so the elevated priority is driven by Chrome's ubiquity and the reliability of memory-safety bugs in this class rather than by observed attacks; vendor patches are already available.
Arbitrary host filesystem writes are possible in Flatpak through the extra-data fetch path, and on system-wide installs those writes are performed as root, allowing a malicious or compromised remote to plant attacker-controlled files outside the application sandbox. Exploitation is unauthenticated on the attacker's side (PR:N) but requires user interaction (UI:R): the victim must install or update an application whose manifest uses the xa.extra-data-sources mechanism from a malicious or attacker-controlled repository, and full root-level impact additionally depends on a system install rather than a per-user install. Two defects combine - the files/extra directory is resolved through symlink-following path operations, and blob names taken from xa.extra-data-sources are not sanitized against '..' traversal. There is no public exploit identified at time of analysis and no CISA KEV entry; tracking is available through the upstream advisory GHSA-fqx6-vh4p-42cg and Red Hat's CVE/Bugzilla records.
Privilege escalation in the WordPress plugin Import and Export Users and Customers (versions up to and including 2.4.17) allows any authenticated user at Subscriber level or above to become an Administrator. The attacker stores crafted values in their own display_name and nickname profile fields and then waits for a site administrator to run the plugin's documented export-then-reimport migration with both 'Update existing users' and 'Update roles for existing users' set to 'yes'; a CSV quoting/escape mismatch between exporter and importer causes the crafted display_name to be consumed as the role field, yielding 'administrator' at the importer's add_role call. Exploitation is not self-contained - it requires the operator to enable those two non-default migration settings - and no public exploit identified at time of analysis. The vendor risk score is 8.8 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), while our independent assessment re-rates it as AV:N/AC:H/PR:L/UI:R because the admin-driven, non-default migration workflow materially constrains real-world exploitation.
Unauthenticated remote code execution in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows an attacker positioned on an adjacent network segment to send a crafted Java-serialized payload to the PayDir Business Rules Manager RMI SSL endpoint and execute arbitrary code on the target host. Because the vulnerable service is exposed with no authentication and no user interaction required (CVSS 8.8, AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), successful exploitation exposes all PayDir credentials and enables manipulation of payment business rules, producing high confidentiality and integrity impact. The adjacency requirement is the primary limiting factor, and no public exploit identified at time of analysis; a vendor patch is available per the IBM advisory.
Message-filtering bypass in xdg-dbus-proxy before 0.1.9 lets a malicious or already-compromised sandboxed application - most notably a Flatpak app, but also deployments under frameworks such as Firejail - escape its confinement and execute arbitrary code on the host by attaching a forged reply serial number to non-reply D-Bus messages. The flaw carries a CVSS 4.0 base score of 8.7 (AV:N/AC:L/PR:N/UI:P, with high confidentiality, integrity and availability impact scoped to the sandbox-escape boundary) and is rated a genuine high-priority sandbox-escape issue rather than a CVSS-inflated paper risk; the practical precondition is that an attacker must first get code running inside a sandbox that routes its session bus through the vulnerable proxy, typically by tricking a user into installing or launching a hostile or trojanized app. No confirmed active exploitation (CISA KEV) and no public exploit code were identified at time of analysis; vendor-released patch: 0.1.9.
Stored cross-site scripting in REDAXO CMS 5.21.1 and earlier allows an attacker who can place a file with HTML metacharacters in its filename into the /media directory to inject JavaScript that runs in the browser of any backend user who opens Mediapool → Sync, enabling session-cookie theft and potential CMS takeover. The flaw lives in the mediapool addon's sync.php, which renders unregistered filesystem filenames into HTML without rex_escape(); exploitation requires high privilege (admin-level backup restore or direct server/filesystem access) plus a victim holding the media[sync] permission who loads the page, so it is not reachable by an unauthenticated remote attacker on a default install. It is correctly rated LOW at CVSS 4.8, with no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV), although the vendor advisory documents a step-by-step proof-of-concept reproduction path; a vendor patch is available in REDAXO 5.21.2.
Stored cross-site scripting in REDAXO CMS 5.x (affecting versions up to and including 5.21.1) lets an authenticated backend administrator plant HTML/JavaScript in a Media Manager effect type's name field, which is later rendered unescaped inside the 'media is in use' warning shown when another administrator tries to delete a referenced media file. Successful exploitation requires a second, victim administrator to click the Delete button on a specifically referenced media item, after which the payload runs in the victim's backend session and can be used for session hijacking, credential harvesting, or CSRF-token theft leading to full backend account takeover. Rated CVSS 3.1 4.8 (AV:N/AC:L/PR:H/UI:R/S:C/C:L/I:L/A:N), this is a low-priority issue: it is not listed in CISA KEV and there is no evidence of active exploitation, though the vendor advisory publishes a full step-by-step proof-of-concept reproduction (publicly available exploit code exists). No EPSS score or in-the-wild telemetry was provided with this report.
Local privilege escalation in Foxit PDF Editor for macOS allows an attacker with a low-privilege foothold to execute arbitrary commands as root by tampering with a user-modifiable configuration value that the installer trusts during high-privilege upgrades. Exploitation requires local access, write access to the configuration value, and a privileged upgrade operation to be triggered, but no user interaction (UI:N) is needed. No public exploit code or active exploitation has been identified at time of analysis (no KEV, no POC).
A local privilege escalation vulnerability in the auto-update daemon shipped with Foxit PDF Editor and Foxit PDF Reader (CVE-2026-91798, CVSS 3.1 8.8) lets an already-authenticated, low-privileged local user abuse an insecurely permitted configuration file (CWE-732) to have the elevated daemon execute arbitrary script content with SYSTEM/root-level rights. Because the attacker must already hold a session on the host and the impact crosses a privilege boundary, the vector is AV:L/PR:L/UI:N/S:C with full confidentiality, integrity, and availability impact; no remote attack path exists, and no public exploit code was identified at time of analysis. Any host running a vulnerable Foxit build with the update daemon installed and the loosely permissioned configuration file present is exposed, making this most relevant to multi-user workstations, VDI, and terminal-server environments where unprivileged users share a machine with a privileged updater.
Authenticated OS command injection in OpenC3 COSMOS 5.12.0 through 7.2.1 allows a user with a valid session to run arbitrary operating-system commands as the openc3 service user by writing shell metacharacters into the pypi_url setting and then installing a plugin that carries Python dependency metadata. The injected value is interpolated into a shell backtick inside PluginModel.install_phase2, so commands execute with access to the service's Redis and bucket storage credentials; in the open-source edition any authenticated user can reach both the setting-write and plugin-install operations, whereas the Enterprise edition requires the administrator role, and the vendor has fixed the issue in 7.3.0. There is no CISA KEV listing or confirmed in-the-wild exploitation, but the public vendor advisory GHSA-vp3w-52v9-q57f includes confirmed end-to-end proof-of-concept steps, and the independent assessment rates this as a genuine high-priority issue rather than CVSS inflation.
Privilege escalation in ZohoCorp ManageEngine Applications Manager 182000 and earlier allows a holder of an authenticated low-privileged account to read an administrator's API key and then replay that key to carry out administrator-level actions over the network. Exploitation requires a valid low-privilege login (CVSS vector PR:L) on a vulnerable instance, but needs no user interaction and no special configuration, and successful abuse grants full high-integrity, high-confidentiality control of the application. No public exploit code or confirmed active exploitation was identified at time of analysis; the primary limiting factor is the mandatory pre-existing low-privilege account, which is why this rates as a genuine high-priority flaw rather than a benign high-CVSS artifact.
SQL injection in ManageEngine Applications Manager (builds 182000 and below) allows an authenticated low-privileged user to run arbitrary SQL commands against the application's database, enabling escalation to administrator privileges and, from there, remote code execution on the underlying host. The flaw carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and is rated high priority because the only meaningful barrier is possession of any valid low-privileged account - no user interaction or special configuration is required, and once credentials exist the attack complexity is low. Exploitation status: no public exploit identified at time of analysis; the issue was reported by the vendor (Zohocorp), and no CISA KEV listing or public proof-of-concept code has been observed in the supplied intelligence.
Authentication bypass in Zoho ManageEngine OpManager 12.8.710 and earlier allows an attacker reaching the web console to skip an authentication control when the optional Application Manager Plugin is enabled, with high impact to confidentiality, integrity, and availability (CVSS 8.8). Only instances with that specific non-default add-on are exposed; deployments without the plugin are not affected. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV, but the CVSS vector (AV:N/AC:L/PR:L/UI:N) combined with the CWE-306 missing-authentication root cause means the precondition is worth treating as near-unauthenticated until the vendor advisory clarifies it.
Command injection in the Diagnose Settings feature of ZohoCorp ManageEngine OpManager and Firewall Analyzer 12.8.709 and earlier allows an authenticated low-privilege user to run arbitrary operating system commands on the host through the web management interface, resulting in complete loss of confidentiality, integrity, and availability (CVSS 8.8, PR:L, UI:N). Exploitation requires a valid low-privileged account and network reachability to the console, but no user interaction and no non-default configuration, so the management interface is the primary gating factor. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, meaning the practical risk is concentrated on internet- or partner-facing ManageEngine consoles where any account holder can reach the vulnerable feature.
Server-side shortcode execution can be triggered through the GTranslate WordPress plugin before 5.0.1, which fails to strip shortcodes from outgoing email content before expanding them. Unauthenticated remote attackers can exploit this only when the plugin is configured in a non-default way that places user-influenced content into email bodies passed through WordPress shortcode expansion, and only if a useful shortcode is already registered on the site; both prerequisites keep the practical impact bounded and are reflected in the assessed CVSS score of 4.8 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N). Publicly available exploit code exists via the WPScan advisory, and there is no indication of confirmed active exploitation (CISA KEV); this is a real but low-priority issue.
Unauthenticated code installation on the Reachy Mini robot daemon (Pollen Robotics) allows any host on the same LAN to execute arbitrary Python code on the robot by posting an attacker-controlled Hugging Face Space to POST /apps/install. The endpoint is reachable without credentials because the wireless variant of the daemon binds to 0.0.0.0, and the handler's dependency chain (Depends(get_app_manager)) never performs an authorization check; the chosen Space's build/setup code is then executed by the daemon via uv or pip. Affected are all Reachy Mini units before the vendor's v1.11.0 patched release (CPE cpe:2.3:a:pollen_robotics:reachy_mini:*); there is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV), though the attacker prerequisites are trivial for anyone sharing the robot's Wi-Fi network. Scoring is AV:A/AC:L/PR:N/UI:N with high confidentiality, integrity and availability impact, consistent with full compromise of the robot host.
Google Chrome for desktop is affected by a security defect that Google addressed in a stable-channel update published on its Chrome Releases blog; the CVE record itself carries no description, no CVSS vector, and no CWE identifier, so the precise impact, attack vector, and required privilege level cannot be determined from available data. Because the affected component is a desktop browser, exploitation would most plausibly require the victim to browse attacker-controlled or compromised web content, but that is an inference from product type rather than from the CVE record. There is no public exploit identified at time of analysis, and authentication requirements are not confirmed from available data.
Type confusion in Google Chrome's core rendering code allows remote attackers to corrupt memory and execute arbitrary code inside the browser renderer, affecting Chrome builds prior to 154.0.8037.57 on all platforms. Exploitation requires the victim to load attacker-controlled web content (a malicious or compromised page), matching the CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H profile - no credentials are needed, and default configurations are exposed because the flaw sits in normal rendering rather than an optional feature. At the time of analysis there is no CISA KEV listing and no public exploit identified at time of analysis; the impact is contained to the sandboxed renderer (S:U), so full host compromise would require a separate sandbox escape not described in this record, but the integrity and confidentiality impact within the renderer is high and the issue is rated 8.8.
Type confusion (CWE-843) in Google Chrome before 154.0.8037.57 lets remote attackers corrupt memory and potentially disclose information or execute code inside the renderer by having a victim load attacker-controlled web content. The bug is unauthenticated and network-delivered (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base score 8.8 High), but requires the user to visit or render a malicious page, and the assessed scope is unchanged (S:U), so renderer-scoped compromise would need a separate sandbox escape to reach full system impact; no public exploit identified at time of analysis, and no CISA KEV entry is associated with this CVE. Chrome ships on an aggressive release cadence, so the fix is already available in the stable channel and risk is concentrated in unpatched or auto-update-disabled fleets.
Use-after-free memory corruption in Google Chrome builds earlier than 154.0.8037.57 allows a remote, unauthenticated attacker to corrupt memory in the browser by having a victim load attacker-controlled web content, yielding code execution with high confidentiality, integrity, and availability impact (CVSS 3.1 base 8.8, CWE-416). Exploitation is network-reachable with low complexity and requires no credentials, but is gated on user interaction (UI:R) - the victim must visit a malicious page or view attacker-controlled content such as a malicious ad or iframe. Because scope is unchanged (S:U), the primitive is contained within the renderer process, so full host compromise realistically requires chaining an additional sandbox-escape vulnerability; a fixed build is already available and there is no public exploit identified at time of analysis (no CISA KEV listing, no confirmed in-the-wild activity reported in the supplied intelligence).
No technical details are available for CVE-2026-95338: the description field is empty and no CVSS score, CVSS vector, CWE classification, CPE string, or affected package name was supplied alongside the record. The only identifying signal is that the issue was reported under the vendor:ubuntu source, indicating it is tracked as a vulnerability in a package distributed through Ubuntu's repositories and handled via the Ubuntu Security Notice process. Risk cannot be meaningfully assessed from the available data, and there is no public exploit identified at time of analysis; exploitation prerequisites, impact, and affected versions must be obtained from the Ubuntu Security Notice for this CVE before any triage decision is made.
Out-of-bounds memory write in Google Chrome (desktop builds) lets remote, unauthenticated attackers corrupt browser memory when a victim loads attacker-controlled web content. The vendor CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:R/S:U with C:H/I:H/A:H (base 8.8), so the only prerequisite is that a user navigates to or renders a malicious page, and because the vector is scope-unchanged the memory corruption is expected to remain within the renderer/browser process rather than granting an inherent sandbox escape. The underlying flaw is an out-of-bounds write (CWE-787) in Chrome builds predating the vendor's September 2026 stable channel fix; patched builds are not affected, and no public exploit code or confirmed active exploitation was identified at time of analysis.
Cross-site request forgery in Google Chrome on desktop lets a remote, unauthenticated attacker achieve high confidentiality, integrity and availability impact against a victim who is persuaded to visit or interact with an attacker-controlled page (CVSS 3.1 vector AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8). Only Chrome installations older than 154.0.8037.57 are affected, and Google has shipped a stable channel fix in that build, with the issue tracked upstream as Chromium issue 511791538 and Ubuntu listed among the reporters. No public exploit code has been identified and the flaw is not in CISA KEV, but note that the official description is empty and the CWE-352 label is hard to reconcile with the full C/I/A impact claimed, so the exact triggering feature remains unconfirmed.
Memory corruption via use-after-free in Google Chrome allows remote code execution or sensitive data disclosure in the renderer when a victim loads attacker-controlled web content in any version earlier than 154.0.8037.57. The flaw is network-reachable, low-complexity and requires no authentication (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8 High), but it does require the user to open a malicious page, ad or iframe, and because the scope is Unchanged the immediate impact stays inside the sandboxed renderer, so full host compromise realistically needs a second, chained sandbox-escape bug. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); a vendor patch is available in Chrome 154.0.8037.57.
Use-after-free in Google Chrome builds prior to 154.0.8037.57 allows remote, unauthenticated attackers to corrupt memory when a victim loads attacker-controlled web content, with potential for information disclosure and code execution. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8) indicates low-complexity, network-reachable exploitation that is gated only by user interaction, and because scope is unchanged (S:U) any initial code execution is confined to the renderer sandbox, so full host compromise would require chaining a separate sandbox escape. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and a vendor patch in Chrome 154.0.8037.57 is available.
Use-after-free memory corruption in Google Chrome builds prior to 154.0.8037.57 allows a remote, unauthenticated attacker to corrupt memory and potentially execute code within the browser renderer by persuading a victim to load attacker-controlled web content (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV. Exploitation requires the victim to open a malicious page or attacker-embedded content in a trusted site, and because the assessed scope is unchanged (S:U) the impact is initially confined to the renderer sandbox, so full host takeover would require a separate sandbox escape; Google has shipped a fixed build that is distributed through Chrome auto-update, shrinking the exposure window on kept-current fleets.
Type confusion in Google Chrome's renderer allows remote attackers to corrupt memory and potentially achieve code execution inside the browser by convincing a victim to open a crafted web page; the attack is network-delivered, requires no authentication (PR:N), and has low complexity, with the only meaningful barrier being that the user must interact with attacker-controlled content (UI:R). A vendor patch is available per the September 2026 stable-channel update, and no public exploit code or confirmed active exploitation was identified at time of analysis, so the high priority here is driven mainly by Chrome's ubiquity rather than observed attacks. Because the CVSS scope is unchanged (S:U), full-system compromise as scored would likely require chaining this bug with a separate sandbox-escape vulnerability, while on its own the flaw is expected to yield renderer-level memory corruption, information disclosure, and potential arbitrary code within the sandboxed process.
Unauthenticated SQL injection in Photoview through 2.4.0 lets remote attackers read arbitrary data from the application database by manipulating the album_id path segment of the album download route. Because the pre-patch handler used the raw path value directly in a GORM lookup before any authentication or authorization check ran, any internet- or LAN-reachable instance is exploitable without credentials or user interaction, with impact limited to confidentiality (CVSS 4.0 base 8.7; assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N). A vendor fix has been merged upstream via pull request 1453; no public exploit code was identified at time of analysis, and the issue is not confirmed as actively exploited (CISA KEV).
Remote, pre-authentication denial of service in the Moquette MQTT broker (moquette-io moquette-broker) through 0.18.0 allows any client able to reach the MQTT listener to wedge the broker's session event loop by sending a malformed shared-subscription filter such as '$share/grp' that omits the '/{topicFilter}' portion. Because the exception is thrown while building the subscription and the SessionEventLoop only catches InterruptedException and is never restarted, command handling on that loop stops and every other client session assigned to the same loop is denied service; the network vector is unauthenticated (CVSS 4.0 AV:N/AC:L/PR:N/UI:N with VA:H, score 8.7; vendor-assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). Moquette accepts anonymous MQTT clients by default and the target does not need shared subscriptions pre-configured for the crash to occur, so exploitation requires only network reachability; publicly available exploit code exists in the form of source-level proof-of-concept tests published with the advisory, but there is no indication of active exploitation (not in CISA KEV).
Denial of service in the Moquette lightweight Java MQTT broker prior to 0.18.1: a single remote, unauthenticated MQTT client can terminate a shared SessionEventLoop with a command that raises an uncaught exception, and because SessionEventLoopGroup never restarts a dead loop, every other client session pinned to that loop stops processing PUBLISH, SUBSCRIBE, PUBACK and related commands. Because Moquette accepts anonymous MQTT clients by default and the CVSS vector (PR:N) confirms no authentication is required, an attacker who chooses client IDs that distribute across the broker's available loops can progressively disable session processing broker-wide; impact is availability-only (C:N/I:N/A:H, no code execution or data exposure), and the upstream advisory documents concrete trigger inputs such as a malformed $share/grp SUBSCRIBE, a deeply nested topic, and an ACL NPE. No public exploit tooling was identified at time of analysis, and the issue is fixed in 0.18.1.
Arbitrary code execution as root is achievable on affected Plesk servers by any authenticated panel user who can influence a directory on the untrusted search path used by the Plesk RESTful API extension. Exploitation requires Plesk core 18.0.34 through 18.0.80.7 or 18.0.81 (i.e., below 18.0.80.8 / 18.0.81.1 respectively) together with the 'Plesk RESTful API' extension at versions 2.4.2 through 2.4.6; the vector is network-reachable, needs only low-privilege credentials (PR:L per the CVSS 4.0 vector) and no user interaction, making a full root compromise of the hosting panel feasible from an ordinary subscription account. Independent assessment rates this a genuinely high-priority flaw despite thin external signal, since successful exploitation yields complete loss of confidentiality, integrity and availability on the panel host (CVSS 4.0 base 8.7; assessed CVSS 3.1 8.7 with S:U/C:H/I:H/A:H). No public exploit code identified at time of analysis, and no EPSS or CISA KEV data corroborates active exploitation; vendor fixes are available in Plesk 18.0.80.8 / 18.0.81.1 and extension 2.4.7.
Unbounded per-session message queuing in Moquette MQTT Broker before 0.18.1 permits remote unauthenticated clients to exhaust broker memory or persistent storage by sustaining a fast publisher against a slow subscriber, causing denial of service. The CVSS 4.0 base score is 8.7 (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N), consistent with a high-availability-only impact under CWE-770; the independent assessment CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H confirms no confidentiality or integrity impact. Default Moquette configurations permit anonymous clients, broadening exposure, and no public exploit identified at time of analysis; no CISA KEV entry, EPSS score, or public exploit specific to this queue-exhaustion issue is provided in the input.
Remote unauthenticated clients can crash a Moquette MQTT broker running 0.18.0 or earlier by publishing or subscribing with a topic name or filter that is nested to an extreme depth, triggering uncontrolled recursion in the broker's CTrie subscription structure and an uncaught StackOverflowError. Because Moquette accepts anonymous MQTT clients by default, network reachability is the only precondition, and the resulting crash lands on a SessionEventLoop that catches only InterruptedException and is never restarted, so the failure wedges every session co-located on that loop rather than just the attacker's connection - a broker-wide denial of service with high availability impact (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H; vendor-published CVSS 4.0 base 8.7). The issue is not in CISA KEV and no public exploit identified at time of analysis; it is fixed in Moquette 0.18.1, which introduces a MAX_TOPIC_DEPTH of 1024 enforced on both PUBLISH and SUBSCRIBE paths.
Unauthorized message injection in the Moquette lightweight Java MQTT broker affects all releases prior to 0.18.1: PostOffice.publishWill publishes a client's Last-Will Testament without running the canWrite authorization and reserved-topic checks that gate a normal PUBLISH, so remote unauthenticated attackers (CVSS vector PR:N) can register a Will on a topic they are not allowed to write and have the broker deliver that message to subscribers when the connection is abruptly dropped. This is an integrity-only flaw (C:N/I:H/A:N) whose real-world severity depends on how sensitive the restricted topic is - for example device command-and-control channels - and exploitation requires that an ACL or IAuthorizatorPolicy actually restricts writes to the targeted topic; vendors score it 8.7 (CVSS 4.0). Publicly available exploit code exists (the upstream advisory ships source-level PoCs, including a wildcard-ACL injection proof), but there is no indication in the supplied data of confirmed active exploitation (CISA KEV), and no patch is available other than upgrading to vendor-released version 0.18.1.
Stored cross-site scripting in the automation-controller component of Red Hat Ansible Automation Platform 2 lets an authenticated low-privileged user embed a javascript: hyperlink into job, ad hoc command, project update, or inventory update standard output, which is then rendered as a text/html link in the controller's stdout view. Because the HTML conversion escapes HTML metacharacters but never strips ANSI terminal escape sequences, an OSC 8 hyperlink becomes an unfiltered HTML anchor, and the response carries no Content-Security-Policy; a higher-privileged user (for example an administrator) who views that output page and clicks the link executes attacker-controlled JavaScript in their authenticated session, allowing actions up to full platform takeover. The vector is network-reachable with low privileges (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N, 8.7), but exploitation hinges on a privileged victim actively clicking the crafted link; no public exploit code and no confirmed active exploitation were identified at time of analysis.
Brocade SANnav deployments running versions before 3.0.1a expose backend management service ports without adequate access controls, so a local, non-administrative user on the SANnav host can talk directly to those services and relay commands to interconnected Fabric OS switches under the SANnav management user's identity. Exploitation is access-gated: it requires an authenticated low-privileged account on the host (PR:L, consistent across both the vendor CVSS 4.0 vector and our assessed CVSS:3.1 vector AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) plus a SANnav instance that is actively managing switches, but where those conditions hold, impact is high across confidentiality, integrity and availability with a changed scope because the attacker's authority crosses from the host user into the managed switch fabric. No public exploit code or confirmed active exploitation was identified at time of analysis.
An authenticated automation-controller administrator in Red Hat Ansible Automation Platform 2 can turn the administrator-controlled format template for API 4XX log messages into a secret-reading primitive, using Python string-format traversal to walk from the interpolated user object into Django settings and pull out the SECRET_KEY and the database password. Because the log destination (external aggregator) is also administrator-controlled, the formatted message - and therefore the secrets - can be shipped off the host, giving the administrator the master key protecting all stored credentials, the ability to forge signed user sessions, and direct database access; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:N (8.7) with high confidentiality and integrity impact and scope change, since secrets leave the controller's security boundary. No public exploit code has been identified at time of analysis and there is no CISA KEV entry, so this is a high-priority hardening issue rather than an actively exploited one: the practical risk is driven by the very high value of the assets reachable once a privileged administrator account or the log pipeline is compromised.
Command injection in the Brocade SANnav CLI scripting component lets an authenticated user who already holds command-execution/scripting permissions break out of the restricted allow-list execution context and run unauthorized shell commands across managed fabric switches, escalating to full administrative switch access. Exploitation requires a valid SANnav account with scripting rights and adjacency to the SAN management plane (AV:A, PR:L) - the product is not internet-reachable by default - and no user interaction is needed once that foothold exists. Every SANnav release before 3.0.1a is in scope per the CPE (cpe:2.3:a:brocade:sannav:*:*:*:*:*:*:*:*), and no public exploit code has been identified at time of analysis; this is a genuine mid-to-high priority for SANnav operators, not an emergency-tier internet-facing issue.
Cross-tenant account takeover in InvoiceShelf before 2.4.1 allows an authenticated Owner of one company to read and overwrite any user account in another company on the same multi-company installation by abusing the /api/v1/users/{user} endpoints. The flaw is an authorization bypass through user-controlled key (CWE-639): the API resolves the target by global primary key while UserPolicy validates only the requester's own header-company, enabling cross-tenant disclosure and full account takeover via email/password overwrite plus company re-assignment. No public exploit identified at time of analysis; exploitation requires Owner-level privileges (PR:H) and a multi-company deployment, but is remote, low-complexity, and high-impact when those conditions are met.
PII harvesting in JoomShaper EasyStore 1.0.0-3.0.0 allows unauthenticated attackers to enumerate guest checkout records via the checkout.searchGuestUser endpoint, which returns full shipping details (name, phone, address) for any supplied email address. Despite vendor labeling as an authenticated SQL injection, the endpoint requires no authentication or session validation and enables bulk collection of customer PII. No public exploit code has been identified at time of analysis; the vendor has resolved the issue by removing the server-side endpoint and migrating autofill to client-side localStorage.
Authenticated SQL injection in the Easy Store extension for Joomla (versions 1.0.0 through 3.0.0) allows a Joomla administrator to inject arbitrary SQL through the coupon bulk update task at administrator/index.php?option=com_easystore&task=coupon.couponBulkUpdate. The flaw is a genuine injection (reported as CWE-74, functionally classic CWE-89 SQLi) where coupon IDs are concatenated straight into raw SQL IN (...) clauses instead of being cast to integers or parameterized. Exploitation is confirmed to require high privilege (PR:H in the assessed CVSS:3.1 vector), and there is no public exploit identified at time of analysis and no CISA KEV listing; EPSS is low at 0.25% (14th percentile), so despite the 8.6 headline score the practical priority is moderate-to-low because Joomla administrators already hold broad database-level trust.