Authenticated code execution in Plex Media Server before 1.43.3.10861 is a genuine but privilege-gated code-execution flaw: an attacker who first obtains admin-level access to the server's management interface can leverage the TranscoderH264Options preference, which is appended verbatim to x264's option string on every transcode, or write a malicious .so file that is loaded and executed at startup without signature, execute-bit, or symbol checks. This affects servers running versions prior to 1.43.3.10861; no public exploit was identified at time of analysis, and the supplied CVSS 4.0 score is 8.6 with PR:H, consistent with our independent CVSS 3.1 assessment requiring high privileges (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). Because Plex admin is often the single server-owner account, the realistic attack path is credential compromise or exposure of the admin interface to untrusted networks; execution then occurs on the next transcode or after a server restart.
OS command injection in the frictionless-py framework through 5.20.0rc1 lets unauthenticated remote attackers execute arbitrary operating system commands in the victim's security context when the victim runs the `frictionless explore` console command against an attacker-supplied Data Package. The flaw is reachable because resource path values from an untrusted datapackage.json are concatenated unsanitized into a shell invocation (`vd {paths}` via os.system), so shell metacharacters placed in a path are interpreted by the shell rather than treated as a filename. Exploitation requires victim interaction (CVSS UI:A) - the user must deliberately explore the malicious package - and publicly available exploit code exists, including a proof-of-concept repository; there is no data provided indicating confirmed active exploitation, and the assessed CVSS:3.1 vector is AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (vendor CVSS:4.0 8.6, PR:N/UI:A), so impact is high on confidentiality, integrity and availability of the user's environment but gate-controlled by the social-engineering step.
Unauthenticated blind SQL injection in ClipBucket v5 (before 5.5.3-#182) allows remote attackers to extract sensitive database contents-including user credentials, email addresses, and administrator password hashes-via the photo search endpoint's unsanitized query parameter. Publicly available exploit code exists (HackMD writeup), and the vendor has released a patch (PR #874 / commit 7fd0af6f) that applies mysql_clean() to the vulnerable input. Because the vulnerability requires no authentication or user interaction and the assessed CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) confirms high confidentiality impact, this is a genuine priority for immediate remediation; successful exploitation can lead to account takeover after offline cracking of admin hashes.
SQL injection in the Rule Management Search Reports feature of ManageEngine OpManager and Firewall Analyzer 12.8.669 and earlier allows a remote, authenticated low-privilege user to inject arbitrary SQL through a search parameter, giving them database read and write capability with high confidentiality, integrity, and availability impact (CVSS 3.1: 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is rated CVSS 8.8 and affects on-premises ITOM deployments exposing the web console; exploitation requires prior possession of valid credentials at any privilege tier, so it is not a pre-authentication flaw. At time of analysis there is no public exploit identified and no confirmed active exploitation, but the vendor has released a patch in version 12.8.670, making upgrade the decisive remediation step.
Account takeover in Klever-Go's KleverUpdateAccountPermission built-in (all versions prior to 1.7.20) allows an attacker-controlled smart contract to replace a victim account's entire permission set without any victim key or signature. The handler authorizes updates using the attacker-supplied vmInput.RecipientAddr instead of the authenticated vmInput.CallerAddr, and because the default self-signer created by createDefaultOwnerPermission satisfies the contractHasValidPermission check, a contract can name any permissioned victim as recipient and install attacker-supplied Owner permissions - enabling asset theft or permanent lockout of the victim. The CVSS 4.0 score is 8.7 with a low-privilege vector (PR:L), reflecting that the attacker must be able to deploy or control a contract that can issue an indirect built-in call; accounts without stored permissions and the native transaction path are not affected. Exploitation requires no user interaction, and no public exploit code or confirmed active exploitation was identified at time of analysis; this is nevertheless a genuine high-priority vulnerability given its unauthenticated-from-the-victim's-perspective account takeover impact on a production blockchain.
Maliciously crafted on-chain account names processed by Klever-Go prior to 1.7.20 are spliced into Elasticsearch _bulk request bodies without JSON escaping, allowing an attacker who can submit a SetAccountName transaction to inject forged bulk actions that create, overwrite, or delete documents in any index the indexer can write to. Because the name is stored in consensus account state, the poisoned value is replayed by new and historical indexers, and no access to the indexing host or the Elasticsearch port is required. Severity is rated 8.4 (CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:H/SC:N/SI:H/SA:L; our independent assessment CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:H/A:H), exploitation requires an authenticated low-privilege on-chain account plus a deployment that actually runs the Elasticsearch indexer, and the issue is fixed in 1.7.20; no public exploit identified at time of analysis, though the upstream fix ships a regression test that reproduces the advisory's injection construction.
Tauri's automatic CSP nonce injection - a hardening feature meant to restrict script execution inside the app webview - is rendered completely ineffective when the application's own script-src directive lists the data: or blob: scheme sources, because CSP Level 3 keeps scheme sources active regardless of a nonce being present. An attacker who can place markup or script into webview content in such an application can therefore execute arbitrary script without ever knowing the nonce, enabling script execution, data theft, or privilege abuse through the embedded webview; Tauri applications that retain the default hardened CSP without data: or blob: in script-src are not affected. The issue is rated CVSS 8.3 (AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H) but is gated by a non-default developer configuration choice plus a separate injection vector within the app, and no public exploit was identified at time of analysis.
Path traversal in ABB Mint Workbench I through version 5876 allows any local user to reach files outside the intended restricted directory, giving high confidentiality impact on the vulnerable host and on a subsequent system while leaving integrity and availability untouched. Exploitation is gated by local access - the CVSS vector specifies AV:L with PR:N and UI:N - so exposure is confined to engineering workstations and commissioning laptops running the affected build rather than servers or internet-facing systems. No public exploit code and no confirmed active exploitation have been identified at time of analysis; ABB has published vendor advisory 9AKK108473A3188.
An authentication bypass in the EthPress - Web3 Login WordPress plugin, affecting all versions up to and including 2.3.5, allows unauthenticated remote attackers to log in as any WordPress user with a linked Ethereum wallet address - including administrators - simply by supplying that user's public wallet address together with an arbitrary, well-formed (but invalid) signature, resulting in full site takeover. The root cause is a missing return statement in verify_login() that lets execution fall through to the cookie-setting login routine even when signature verification fails; no public exploit code has been identified at time of analysis, and the assessment rates it 8.1 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H), with the 'high' attack complexity reflecting the need to discover a valid linked wallet address rather than any authentication barrier. Because exploitation is unauthenticated and requires no user interaction, any site where at least one account (especially an administrator) has linked a wallet should be treated as exposed until patched or the plugin is disabled.
Use-after-free in librsvg during rendering of crafted SVG documents with nested XInclude directives and duplicate entity declarations allows unauthenticated local attackers to crash or potentially execute code in applications that use the library. Tracked as CVE-2026-96889 and reported by Red Hat, the flaw affects librsvg as shipped in Red Hat Enterprise Linux 6, 7, 8, 9, and 10. Exploitation requires user interaction (UI:R) because a victim must open, preview, or thumbnail a malicious SVG; the CVSS 3.1 score is 7.8. No public exploit code was identified at time of analysis, and independent assessment indicates that arbitrary code execution is unproven-only denial of service or crash is reliably reachable.
Denial of service in Wire's Swift runtime (the SPM/CocoaPods 'Wire' product, implemented by wire-runtime-swift) lets an unauthenticated remote attacker abort a decoding process with a single 10-byte protobuf payload; all released Swift runtime versions through 6.4.0 and Wire 7 alphas through 7.0.0-alpha03 are affected. An unknown START_GROUP field wrapping a LENGTH_DELIMITED field whose varint decodes to a negative Int32 (for example -128) slips past a bounds check in ReadBuffer.readData(count:) that only validates the upper bound, and the negative count reaches Foundation's Data(bytes:count:), which traps with SIGTRAP instead of throwing the documented, catchable ProtoDecoder.Error. Publicly available exploit code exists (the vendor advisory ships a complete proof of concept), but there is no indication of active exploitation; the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5) reflects a low-complexity remote availability impact confined to Swift applications that actually feed untrusted protobuf bytes to Wire's decoder.
Denial of service in JLine3's built-in grep command (org.jline:jline-builtins) lets anyone who can supply a search pattern hang a worker thread indefinitely via catastrophic regular-expression backtracking. The builtin - reachable in applications that embed JLine3 and expose the shell to remote or interactive users - rewrites non-line-regexp patterns as .*pattern.* before compiling them with Java's backtracking regex engine, so a short input such as (a+)+b tested against non-matching text causes exponential CPU consumption (CWE-1333; CVSS 3.1 base 7.5 upstream, while the assessed vector requires low privileges, PR:L). Impact is availability-only (C:N/I:N/A:H) with no confidentiality or integrity loss; publicly available exploit code exists in the form of the advisory's two-line PoC, but the issue is not listed in CISA KEV and no confirmed active exploitation has been reported. Vendor-fixed releases are available: 3.30.15 on the 3.x line and 4.3.1 on the 4.x line.
Unauthenticated remote denial of service in Klever-Go (all versions before 1.7.20) allows any client that can reach the node's REST/WebSocket API to exhaust its memory and goroutines through the default-open /subscribe endpoint, and because that API runs in-process with the node, the resulting OOM-kill also takes down P2P and consensus participation. No API key, account, stake, or funds are required (vector PR:N), and publicly available exploit code exists: the vendor advisory ships working PoCs against unmodified production code showing a single 8 MiB WebSocket frame expanding server heap by roughly 32 MiB, 300 concurrent connections accepted despite a configured global cap of 100, and 200,000 attacker-supplied address strings growing the hub's subscription map 1:1 with no cap. The assessed severity is CVSS 3.1 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), and real-world priority is bounded mainly by Klever-Go's limited node footprint rather than by any weakness in the finding itself.
Improper enforcement of the marketplace settlement workflow in Klever-Go prior to 1.7.20 lets an authenticated seller settle a resting-bid NFT auction through the Claim seller-accept branch while leaving the claimed order loadable with a future EndTime and stale CurrentBid/CurrentBidder values. A later bidder can then submit a higher bid, be debited, and trigger a refund to the previous bidder even though the NFT has already been delivered, while Claim and CancelOrder both reject that bidder because IsClaimed is true - leaving them unable to obtain the NFT or recover their funds. The flaw is purely an integrity/business-logic issue (CWE-841, assessed CVSS:3.1 7.1, AV:N/AC:L/PR:L/UI:N with no confidentiality or availability impact, matching the vendor's 7.1 CVSS 4.0 rating); no public exploit code or confirmed active exploitation was identified at time of analysis, and a vendor fix is available in 1.7.20.
Unauthenticated OS command injection in Changing CGServiSign enables a remote attacker to run arbitrary operating-system commands on a victim's machine when that victim is lured into visiting a malicious web page while CGServiSign's local service interface is running. The attacker needs no credentials and no access to the host (CVSS 4.0 8.6, PR:N, AC:L), but exploitation depends on user interaction (UI:A) plus the presence of this specific Taiwanese e-signature client with its local listener active, which meaningfully narrows the realistic target set. No public exploit code and no confirmed active exploitation were identified at time of analysis, and because the CPE is a wildcard over all versions, every deployment must be considered affected until a fixed build is published.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 (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.
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.
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).
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).