Unauthenticated arbitrary file read in DeepWiki-Open (all builds through commit d92819a) allows remote attackers to retrieve any file readable by the API process by sending a single GET request to /codemap/file with a non-URL repo_url value containing an absolute path. Both the CVSS v4.0 score (8.7) and the independent assessment rate it AV:N/AC:L/PR:N/UI:N with high confidentiality impact and no integrity or availability impact, so any network-reachable instance with the endpoint exposed is at risk. No public exploit code or active exploitation telemetry has been identified at time of analysis, and real-world impact is bounded by the privileges of the service account and the product's modest deployment footprint.
OS command injection in zosmaai's pi-llm-wiki through 0.11.7 lets an attacker who can invoke the wiki_capture_source MCP tool run arbitrary operating-system commands on the host by manipulating the tool's url argument, which is passed unsanitized into a shell command used for source extraction. Publicly available exploit code exists (referenced in the project's issue tracker), and the flaw is fixed in version 0.11.8; there is no indication of confirmed active exploitation in CISA KEV. The CVSS v4.0 score is 8.6 (with an assessed CVSS v3.1 equivalent of 8.8), reflecting high confidentiality, integrity, and availability impact, though the vector requires authorized tool access (PR:L) and real-world risk is bounded by the project's very small deployment footprint and whether the MCP tool endpoint is remotely reachable.
Command execution on Windows-based JetBrains TeamCity servers allows authenticated users with Pipeline Git connection configuration privileges to run arbitrary OS commands via CRLF injection in connection settings, affecting versions before 2026.2, 2026.1.4, and 2025.11.8. The flaw requires authentication (PR:L per CVSS) and only impacts Windows deployments; no public exploit code has been identified at time of analysis. With a CVSS score of 8.8, successful exploitation grants high confidentiality, integrity, and availability impact.
Remote code execution in JetBrains TeamCity (CVE-2026-100253) lets an authenticated attacker with permission to edit a project's versioned settings escape the Kotlin DSL sandbox and execute code on the TeamCity server. Affected versions are those before 2026.2, before 2026.1.4, and before 2025.11.8. No public exploit identified at time of analysis, but this is a genuine high-priority issue rather than an inflated CVSS score because it can compromise a CI/CD server; exploitation requires a low-privileged, non-anonymous account able to supply or commit malicious Kotlin DSL settings.
OpenClaw Windows Node versions before 2026.7.1 allow an authenticated caller holding a gateway/agent session to escalate to arbitrary command execution on the Windows host by abusing the system.execApprovals.set capability. The rule validator fails to reject allow rules whose executable (first whitespace-delimited token) contains a wildcard, so patterns such as '*.*', '*.exe', '*e*' or 'c*' are accepted and effectively grant blanket approval that the default-deny policy would otherwise block; subsequent system.run calls then execute arbitrary programs - including the LOLBins mshta, rundll32 and certutil - with no operator check or user prompt. Exploitation requires an existing network connection to the gateway/agent interface (CVSS 4.0 PR:L; independent assessment CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.7), no public exploit code was identified at time of analysis, and the vendor has released a fixed version.
Memory exhaustion denial of service in restbed through 5.0.0 allows remote unauthenticated attackers to crash server processes by sending WebSocket frames that declare payload lengths up to 2^63 bytes and then streaming data into an unbounded buffer. Any restbed-based service that exposes a WebSocket endpoint to an untrusted network is potentially affected, and no credentials or user interaction are required. The impact is confined to availability (process crash/OOM), with no data disclosure or code execution path; no public exploit code or confirmed active exploitation has been identified at time of analysis. The CVSS 4.0 base score is 8.7, and an independent CVSS 3.1 assessment aligns as a genuine but scope-limited denial-of-service issue.
Authenticated SQL injection in Moodle's question bank web service allows a low-privilege user to inject unsanitized input into database queries, potentially exposing, modifying, or deleting sensitive data in the underlying database. 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), meaning any valid account that can reach the question bank web-service endpoint is a potential vector - exploitation by fully anonymous users is not possible, and the requirement for credentials and for the web service to be enabled/exposed are the main limiting factors. There is no public exploit identified at time of analysis, EPSS is low at 0.25% (14th percentile), and CISA SSVC rates exploitation as none with partial technical impact; this is a credible, exploitable issue but not an emergency.
Local privilege escalation in Meta Horizon OS prior to v66.0.0.733.524 allows a malicious on-device application to register a broadcast receiver for com.oculus.systemactivities.SCREENSHOT and receive a privileged PendingIntent containing a com.oculus.horizon CallerIdentity, which can then be used to impersonate that package to OS endpoints that rely on CallerIdentity authentication. The attack requires the malicious app to already be installed and running on the same device, via sideloading or a malicious store app; there is no remote network-only path in the authoritative assessment. No public exploit was identified at time of analysis, EPSS is low at 0.23% (13th percentile), and the available fix is Meta Horizon OS v66.0.0.733.524.
Improper access control in Pexip Infinity's product-internal, inter-node API lets an attacker who already holds a foothold on one node of a multi-node deployment execute arbitrary code as an unprivileged user on another node. The affected builds are Infinity before 38.2 as well as 39.0, 39.1 and 40.0, tracked as CPE cpe:2.3:a:pexip:infinity:*:*:*:*:*:*:*:* and rooted in CWE-863 (incorrect authorization). The internal API requires no authentication (PR:N) and no user interaction (UI:N), but the attack path is adjacent-network only (AV:A) and code runs unprivileged on the target rather than as root; there is no public exploit identified at time of analysis and no CISA KEV listing, though the 8.8 CVSS and lateral-movement potential make this a high-priority fix for any clustered installation.
Command injection in Kiteworks Core's internal cluster-management function allows an attacker who already has code execution on one node of a clustered deployment to run operating system commands with elevated privileges on other nodes in the same cluster. The vulnerable function is not reachable from outside the cluster, so the attack path is confined to the internal cluster network and requires a pre-existing foothold on a cluster member; single-node deployments are not exposed. Rated CVSS 8.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) with scope change reflecting cross-node impact, and no public exploit identified at time of analysis.
Sandbox escape in Kiteworks Core's document-conversion feature (CVE-2026-102125, CVSS 8.8) allows code already executing inside the conversion sandbox to break confinement and act with the privileges of the application service account, enabling reads or modifications of application data and configuration or disruption of the service. Exploitation is conditional: the attacker must first get code running inside the sandbox, typically by submitting a crafted document for conversion, and the CVSS vector (AV:L/PR:L/UI:N/S:C) confirms a local, low-privilege prerequisite with no user interaction once that foothold exists. No public exploit code has been identified at time of analysis, making this a genuine but conditional integrity and availability risk rather than a mass-exploitation threat; a vendor-released patch is documented in Kiteworks advisory GHSA-58j2-hj9r-c258.
Memory exhaustion in pypdf versions prior to 6.19.0 allows a remote, unauthenticated attacker to make an application unavailable by supplying a crafted PDF whose page-label numbering tree uses an alphabetical style (/S /A or /S /a) with an oversized /St start value, causing the library to generate pathologically long label strings when an application requests document page labels. The impact is strictly availability-related (C:N/I:N/A:H) with no data exposure, integrity loss, or code execution, and it only triggers if the consuming application actually reads page labels rather than merely opening the file. There is confirmed actively exploited status: no public exploit identified at time of analysis, and no vendor-released patch identified at time of analysis beyond the fixed release 6.19.0; the independent assessment rates this as a genuine but bounded denial-of-service rather than an RCE despite the elevated CVSS 4.0 score of 8.7.
Denial of service in pypdf versions prior to 6.19.0 allows an unauthenticated remote attacker to pin a PDF-processing worker by supplying a document containing a large number of embedded files, because the dictionary-based attachments API re-enumerates and reparses the entire /EmbeddedFiles attachment list on every content lookup instead of indexing it once. The impact is limited to availability (CPU and wall-clock exhaustion); there is no code execution, data disclosure, or integrity impact, and the exposure is conditional on the host application actually enumerating or reading embedded-file attachments rather than merely opening the PDF. No public exploit identified at time of analysis, and the issue is fixed in the vendor's 6.19.0 release, so this should be treated as a bounded availability bug rather than a critical priority.
Denial of service in pypdf versions prior to 6.19.0 allows remote, unauthenticated attackers to exhaust application CPU by supplying a crafted PDF whose AcroForm choice field carries a large number of options and selected values; when a consuming application calls update_page_form_field_values with flatten=True, the appearance-stream generator recomputes the same invariant selection-glyph set once per line, driving runtimes up until the host process or worker becomes unavailable. The flaw is rated CVSS 4.0 8.7 (and 3.1 8.1 by independent assessment) with availability-only impact - no confidentiality or integrity loss, and no code execution. Exploitation requires the application to explicitly perform form-field updates with flattening on attacker-controlled input; merely opening, parsing, or reading the PDF does not reach the vulnerable code path. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV); the fix ships in upstream release 6.19.0.
Denial of service in pypdf before 6.18.1 lets a crafted PDF drive the library's FlateDecode recovery path into inefficient byte-by-byte decompression, consuming CPU until the consuming application becomes unavailable. Exploitation is unauthenticated and requires only that a pypdf-based service parse or extract text from an attacker-supplied PDF (CVSS v4.0 8.7, AV:N/AC:L/PR:N/UI:N, availability-only); no public exploit identified at time of analysis. The flaw is a residual case left after the earlier malformed-FlateDecode recovery fix and is resolved in 6.18.1.
Memory exhaustion in pypdf versions prior to 6.18.1 lets a crafted PDF force the library to allocate and process far more font-width data than a simple font can legitimately hold, degrading or crashing any process that extracts text or font metrics from untrusted documents. The parser fails to cap the /Widths array of a simple TrueType or Type1 font at the 256 one-byte character codes that such fonts can actually address, so an oversized array is walked entry by entry while widths are collected. The CVSS 4.0 vector (8.7, AV:N/AC:L/PR:N/UI:N, high availability-only impact) reflects unauthenticated remote triggering with no user interaction beyond supplying the file, and the availability-only profile confirms no confidentiality or integrity loss. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (not in CISA KEV), though the trigger is trivially reproducible by anyone who can hand a PDF to a pypdf-consuming service; a vendor patch in 6.18.1 is available.
Memory exhaustion in pypdf versions prior to 6.18.1 allows unauthenticated remote attackers to crash or degrade any application that parses attacker-supplied PDFs, by embedding oversized source-code or destination-string tokens inside a font /ToUnicode CMap. Processing such a file (for example during text extraction, which routes through pypdf/_cmap.py parse_bfchar) makes the library decode and retain these oversized values, driving availability-impacting memory consumption with no confidentiality or integrity effect. The vendor CVSS 4.0 vector (8.7, VA:H only, PR:N/UI:N) matches the assessed CVSS 3.1 vector of AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H; no public exploit code or KEV-listed active exploitation was identified at time of analysis, and a vendor-released patch (6.18.1) is available.
Denial of service in pypdf versions prior to 6.18.0 allows remote, unauthenticated attackers to stall PDF parsing by supplying a crafted file whose indirect-object identifier or generation-number token continues for an excessive length without a whitespace delimiter. The parser's read_until_whitespace helper in pypdf/_utils.py scans unbounded input, so the consuming process hangs or runs for an extremely long time, making any service that parses untrusted PDFs unavailable (CVSS 4.0 8.7, availability-only; assessed CVSS 3.1 8.0 AV:N/AC:L/PR:N/UI:N/A:H). Impact is confined to availability - there is no path to code execution or data disclosure - and no public exploit code or confirmed active exploitation was identified at time of analysis. A vendor-released fix is available in pypdf 6.18.0.
Memory-exhaustion denial of service in pypdf versions prior to 6.17.0 allows remote attackers to inflate application memory usage by supplying a crafted PDF whose /PageLabels /Nums dictionary declares a Roman-numeral numbering style (/S /R) with an extremely large start value (/St), causing the library to construct a numeral string proportional to that value. The CVSS:4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N, VA:H) indicates an unauthenticated, network-reachable, low-complexity attack with high availability impact and no confidentiality or integrity effect, but the practical precondition is that the consuming application must actually invoke pypdf's page-label retrieval on attacker-supplied documents - applications that never read page labels are unaffected. No public exploit code has been identified at time of analysis and there is no CISA KEV entry; the vendor released a fix in 6.17.0 that rejects Roman start values above 3,999.
PHP object injection in the Photo Gallery by 10Web WordPress plugin (versions up to and including 1.8.46) allows an authenticated user with Contributor-level privileges to pass crafted serialized data into a plugin code path that calls unserialize(), which under CVSS 3.1 scores 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Successful exploitation can corrupt or disclose data and, if a usable PHP gadget chain exists in the plugin, WordPress core, or another active plugin, can escalate to arbitrary code execution on the web server; no user interaction is required once the low-privileged account exists. At the time of analysis there is no CISA KEV listing and no public exploit code identified, and authentication as Contributor or higher is a firm prerequisite, so exposure is concentrated on sites that grant Contributor+ roles to untrusted users or leave open registration enabled.
PHP object injection in the Schema & Structured Data for WP & AMP plugin (all versions up to and including 1.66) lets an authenticated attacker with a Contributor-level WordPress account feed crafted serialized input into a plugin deserialization path, and the vendor's CVSS 3.1 vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8 High) rates that as low-complexity, network-reachable and capable of full confidentiality, integrity and availability impact once a usable POP gadget chain is available in the plugin, WordPress core or another installed component. Authentication is mandatory and there is no unauthenticated route, but no user interaction is required after the attacker holds a qualifying account; the practical exposure therefore depends on whether the site permits open registration or loosely manages Contributor roles. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, so the primary risk is post-authentication privilege escalation rather than opportunistic mass exploitation.
Authentication bypass in Trex MES allows unauthenticated attackers positioned on the same adjacent network segment to invoke a critical function without supplying credentials, delivering full confidentiality, integrity, and availability impact (CVSS 3.1 base 8.8, vector AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Exploitation is limited to attackers who can reach the MES host over the local or OT network - the flaw is not reachable from the public internet - but no privileges or user interaction are required and attack complexity is low, so any host on that segment can trigger it against affected builds through 2026-09-29. No public exploit code or confirmed active exploitation was identified at time of analysis, and no EPSS score was supplied; the practical exposure depends almost entirely on how tightly the MES network is segmented.
Cross-site request forgery in the WordPress plugin Blacklist Manager - WooCommerce Anti-Fraud, Blacklist & Checkout Verification (versions through 2.3.1) lets a remote, unauthenticated attacker forge state-changing requests that execute with the privileges of a logged-in victim who loads attacker-controlled content. Exploitation is not autonomous: it requires an authenticated user with a live session - typically an administrator or shop manager - on a site where WooCommerce and this plugin are both installed and active, and that user must be tricked into visiting a malicious page (CVSS UI:R, PR:N means the attacker needs no credentials of their own, not that the victim is anonymous). The published CVSS 3.1 base score of 8.8 (C:H/I:H/A:H) appears inflated for a CSRF issue; our independent assessment rates it AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:L, reflecting high integrity impact but limited confidentiality and availability impact. No public exploit code and no confirmed active exploitation were identified at time of analysis.
Remote code execution in the CartFlows WordPress plugin affects versions 3.2.0 and earlier, allowing an authenticated user with Contributor role or higher to execute arbitrary code on the hosting server. The flaw is a PHP include/require path-control weakness (CWE-98) with a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning exploitation requires a valid low-privileged account but no user interaction. No public exploit was identified at time of analysis, and the practical exposure depends on whether the site grants Contributor access to untrusted users.
Authenticated Contributor-level users can exploit a PHP Object Injection vulnerability in Themify Builder versions up to and including 7.8.1. The flaw, caused by unsafe deserialization (CWE-502), allows an attacker with a Contributor account to inject a serialized PHP object, potentially leading to remote code execution or full site compromise if a usable PHP gadget chain exists in the WordPress installation. The vendor-assigned CVSS score is 8.8 (High), and no public exploit code has been identified at the time of analysis.
PHP object injection in the quantumcloud Conversational Forms for ChatBot WordPress plugin (versions through 1.5.0) lets any authenticated Subscriber-level user reach full confidentiality, integrity, and availability impact, matching the High 8.8 CVSS 3.1 score (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The attack is remote, low-complexity, and requires no user interaction, but real-world severity depends on whether WordPress core or other installed plugins supply a usable PHP POP gadget chain that turns object injection into code execution or destructive file/database operations. No KEV or public-exploit signal was present in the supplied intelligence, so active exploitation is not confirmed from this data.
PHP object injection in the WordPress plugin DesignSetGo 2.8.0 and earlier allows an authenticated user with Contributor-level access to submit a crafted serialized payload, which the plugin then deserializes, potentially leading to data theft, file manipulation, or remote code execution depending on which PHP gadget chains are reachable in the site's loaded code. 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 remote, low-complexity exploitation requiring only a low-privileged authenticated account and no user interaction, and the impact is assessed as high across confidentiality, integrity, and availability - though the practical outcome depends on the presence of a usable gadget chain. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV (not confirmed actively exploited); no EPSS score was supplied, but the self-registerable nature of the Contributor role on many sites keeps the real-world risk elevated.
PHP object injection in the WordPress plugin Go Live Update Urls (Mat Lipe) version 7.0.8 and earlier allows an authenticated attacker holding at least the Contributor role to pass crafted serialized data that the plugin deserializes, potentially leading to full confidentiality, integrity, and availability impact on the affected site if a usable PHP gadget chain is present in the plugin, WordPress core, or another installed theme/plugin. The vulnerability is network-reachable with low attack complexity, requires only low-privileged authentication (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 8.8 High) and no user interaction; exploitation additionally depends on the availability of a viable POP gadget chain, a common but not universal precondition. At the time of analysis there is no public exploit identified and no confirmation of active exploitation (not listed in CISA KEV), and no vendor-released fixed version is confirmed in the available data. Risk triage should treat this as a high-priority issue for any site running the vulnerable plugin where Contributor accounts are easily obtainable (for example, open self-registration).
PHP object injection in the 10Web Booster WordPress plugin (versions up to 2.33.6) allows an authenticated Contributor to inject a malicious PHP object, potentially leading to remote code execution if a suitable gadget chain is present. The vulnerability is network-exploitable, requires no user interaction, and has a CVSS score of 8.8, but exploitation depends on the availability of a POP chain within the plugin or other installed components. No public exploit code has been identified at time of analysis.
PHP object injection in the WordPress plugin SEO Plugin by Squirrly SEO (through version 14.2.5) allows an authenticated attacker with only Contributor-level access to feed crafted serialized data into PHP's unserialize(), which can escalate to remote code execution, arbitrary file operations, or SQL injection if a usable POP gadget chain is reachable in the plugin, WordPress core, or another installed plugin. The flaw scores CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so it is a genuine high-priority issue, but the practical blast radius depends on two prerequisites: the site must permit untrusted or self-registered Contributor accounts, and a viable gadget chain must exist. No public exploit code has been identified at time of analysis and the vulnerability is not known to be actively exploited (not in CISA KEV); it is not exploitable by fully unauthenticated visitors.
Stored cross-site scripting in the Verge3D Publishing and E-Commerce WordPress plugin before 4.13.1 lets unauthenticated attackers upload a file whose contents are never validated and which the plugin then serves back with an attacker-controlled content type, so the embedded JavaScript executes in the browser of any user who opens the uploaded file's URL. Exploitation requires the target site to expose the plugin's file storage/upload feature and depends on a victim opening the attacker-supplied file link (UI:R), so it is not an automatic drive-by compromise; no public exploit code was identified at time of analysis and CISA's SSVC evaluation records exploitation as 'none'. Sites running version 4.13.1 or later are not affected, and the vendor has released a fix.
Stored cross-site scripting in the WordPress plugin All in One Files Upload (versions 2.0.3 through 2.0.16) lets unauthenticated visitors upload SVG files containing active content that executes in the site's origin when a victim opens or previews the file, potentially handing an attacker administrator-level control of the site if a privileged user is the one who opens it. Exploitation requires no authentication (CVSS vector PR:N) and no non-default configuration, since the plugin itself whitelists SVG uploads and fails to verify the authenticity of its public upload requests, but it does require victim interaction (UI:R) and is assessed as not automatable per SSVC. No public exploit code has been identified at time of analysis and CISA KEV does not list this CVE, though independent scoring disagrees with the vendor-side 8.8 rating: our assessment scores scope change with limited confidentiality and integrity impact (S:C/C:L/I:L/A:N) because the realized impact depends entirely on a privileged victim opening the stored file, which is why the urgency signals conflict.
Remote, unauthenticated requests to the WatchGuard Fireware OS authentication login interface can crash the management daemon, producing a denial of service on affected Firebox appliances. The root cause is a NULL pointer dereference (CWE-476) triggered by a specially crafted request to the login endpoint; impact is confined to availability of the management daemon, with no confidentiality or integrity loss and no code execution. Exploitation requires only network reachability to the management/authentication interface (assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), and no public exploit code or confirmed active exploitation has been identified at time of analysis (the CVE is not listed in CISA KEV). The published score of 8.7 reflects the CVSS 4.0 vector, while the independent assessment treats this as a genuine but bounded availability risk whose real-world severity hinges on how widely the login interface is exposed.
Authentication bypass in AiSOC 7.5.0 through 11.x lets unauthenticated remote attackers subscribe to realtime WebSocket/SSE channels belonging to any tenant, exposing live alerts, cases, agent events, and graph updates. The realtime edge verifies subscription tickets with a hard-coded HS256 key committed to the repository, and per the patch commit that constant was the effective key in every shipped deployment because no docker-compose or make manifest ever passed AISOC_REALTIME_JWT_SECRET to either the API or the realtime service. Version 12.0.0 removes the fallback entirely and generates a real secret, so only deployments that explicitly set the variable are unaffected; no public exploit code identified at time of analysis, and the assessed impact is confidentiality-only against a very small deployment footprint.
Stored cross-site scripting in Kiteworks Core before version 9.5.0 allows an authenticated user with only low privileges to submit content that executes arbitrary JavaScript in the browser session of any other user who later views it, potentially enabling full account takeover of higher-privileged users such as administrators. The issue scores 8.7 (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N = High) because a successful attack crosses the browser privilege boundary into the victim's session, yielding high confidentiality and integrity impact while availability is unaffected. No public exploit code or confirmed active exploitation was identified at time of analysis, and exploitation is constrained by two prerequisites: the attacker must already hold a valid low-privileged account, and a second user must subsequently render the stored payload in the web UI.
Stored cross-site scripting in Kiteworks Core allows an authenticated user to store crafted content that executes arbitrary JavaScript in another user's authenticated session when that victim previews the shared content, potentially enabling session compromise or account takeover. Affected deployments are Kiteworks Core versions before 9.5.0, and exploitation requires a valid platform account plus victim interaction with the preview rendering path. No public exploit code or CISA KEV listing has been identified at time of analysis, and the independent assessment classifies this as a moderate-priority, contingent-risk finding rather than an urgent one.
The anonymous form-rendering endpoint in Kiteworks' Advanced Forms / Secure Data Forms component returns more information than a published form needs, letting anyone who knows or can guess a published form's web address retrieve the form owner's Kiteworks account profile (including personal details) plus portions of the deployment's configuration settings. No authentication or user interaction is required against a default deployment that serves published forms, and the exposed data does not include passwords, authentication tokens, or MFA secrets. Scoring is CVSS 3.1 8.6 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N), driven entirely by confidentiality loss with a scope change since an unauthenticated viewer gains data belonging to a different security authority; no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV.
Arbitrary command execution on Windows hosts is achievable through OpenClaw Windows Node versions prior to 2026.7.1, where the system.run exec-approval policy can be evaded by an authenticated connected gateway or agent holding the PR:L role. The ExecShellWrapperParser fails to split commands on pipe operators or extract command-substitution/subexpression syntax, so a denied command placed behind an allowed prefix (for example `benign | denied` or `echo $(denied)`) is never surfaced to the allow/deny ruleset and executes anyway; the failure only yields a bypass where a restrictive exec-approval policy is actually configured, and the impact is confined to Windows targets. No public exploit code has been identified at time of analysis, and the issue is not confirmed as actively exploited (no CISA KEV listing); vendor-released patch 2026.7.1 is available.
Unauthenticated remote code execution affects Taskcluster deployments running versions prior to 100.3.0 that expose the GraphQL endpoint to an anonymous role. The vulnerable code path is the GraphQL `filter: JSON` argument on list/search queries (clients, roles, secrets, worker pools, denylist addresses, artifacts, hooks, namespaces), which was parsed with the `sift` library using improper input validation (CWE-20); a crafted filter payload can lead to code execution on the web-server, giving full confidentiality, integrity, and availability impact (assessed CVSS 3.1 9.8, raw vendor CVSS 4.0 8.7). Exploitation is network-reachable and needs no authentication or user interaction, but is conditional on the deployment granting an anonymous role access to GraphQL; no active exploitation (CISA KEV) or public exploit code has been identified at time of analysis, and the vendor-released patch is version 100.3.0.
Authenticated users holding the backend 'manager' role in yii2-starter-kit through 4.2.0 can upload PHP scripts through the backend file-storage upload action and then request them from the web-accessible storage directory, achieving remote code execution as the web server user. The defect is an unrestricted file upload (CWE-434) with a CVSS 4.0 base score of 8.7 (PR:L, fully consistent with the assessed CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H): exploitation is gated on manager-level authentication, on the backend file-storage module being enabled and reachable, and on the storage directory being served without script-execution restrictions, which is the default starter-kit layout. No public exploit code identified at time of analysis, and the practical priority is tempered by the authentication prerequisite and the niche footprint of the product, though the impact is total for any live deployment that meets those preconditions.
Unbounded HTTP request-header buffering in Corvusoft restbed 5.0.0 and earlier allows remote unauthenticated attackers to exhaust server heap memory and kill the process, producing a denial of service against any network-reachable service built on the framework. The attack requires nothing more than opening TCP connections and streaming header bytes indefinitely without ever sending the terminating blank line, so the server keeps growing its header buffer until memory is exhausted; no credentials, feature flags, or user interaction are involved (CVSS:4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VA:H, assessed as CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). Impact is confined to availability - there is no data disclosure or code execution - and no public exploit code has been identified at time of analysis, though the technique is straightforward to reproduce by hand. Exposure is materially reduced where a reverse proxy or load balancer in front of restbed enforces its own header-size and header-timeout limits.
Unauthenticated HTTP requests to LightLLM through 1.2.0 can halt and wedge inference workers on any deployment started with the --enable_rl flag, because the reinforcement-learning control routes (/pause_generation, /abort_request, /flush_cache, /init_weights_update_group) are mounted on the public API with no authentication check (CWE-306). An attacker who can merely reach the API over the network can pause generation, abort in-flight requests, repeatedly flush the cache, or disturb weight-update groups, degrading or fully interrupting service availability, with no data disclosure or modification possible through these routes. Risk is bounded by the non-default RL configuration and by network exposure of the API; no public exploit identified at time of analysis.
Decryption of sensitive diagnostics bundles in AJA HELO Plus firmware before 2.1.7 allows unauthenticated remote attackers to recover highly sensitive server information from any device they can reach. The firmware embeds a static AES passphrase in obfuscated form, so an attacker who reverse engineers the publicly available firmware image once can decrypt diagnostics exports pulled from the unauthenticated diagnostics endpoint on every affected device. Exploitation requires no authentication, no user interaction, and no non-default configuration, with network reachability to the device's management/diagnostics interface as the primary limiting factor; no public exploit code has been identified at time of analysis, and a vendor fix is available in firmware 2.1.7.
Memory exhaustion in the CODESYS Gateway Client lets an attacker-controlled gateway crash the client by supplying a crafted response whose size field is trusted without an upper bound, driving uncontrolled resource allocation (CWE-770) and a total loss of availability on the affected client. The vendor scores this 8.7 (CVSS 4.0 AV:N/AC:L/AT:N/PR:N/UI:N, driven entirely by VA:H with VC:N/VI:N), and our independent assessment is consistent: remote denial of service with no confidentiality, integrity, or code-execution impact. The real limiting factor is not credentials or user interaction but endpoint control - the attacker must be able to impersonate or redirect the gateway the client connects to; no public exploit code and no confirmed active exploitation were identified at time of analysis.
Man-in-the-middle attackers can intercept and decrypt sensitive BVMS traffic across versions 4.5 through 12.3 because the product relies on a hard-coded cryptographic key (CWE-321), allowing unauthorized access to confidential data and, per the assessed impact, tampering with protected communications. The flaw is remotely reachable and requires no credentials (PR:N) or user interaction (UI:N), and it carries a high severity rating of 8.7 with a scope change reflecting impact beyond the vulnerable component. Risk is materially gated by the high attack complexity (AC:H): the attacker must first obtain a man-in-the-middle position on the network path between BVMS components, so it is not exploitable purely remotely against an isolated, well-segmented deployment. No confirmed active exploitation (CISA KEV) and no public exploit code identified at time of analysis.
MISP before 2.5.48 lets an authenticated user holding the delegation permission (perm_delegate) retarget an existing event-delegation record to any event on the instance by injecting an 'id' or 'event_id' field into the delegation submission, because the controller authorizes only the event named in the URL but persists the entire caller-supplied record. The injected row grants the attacker's organisation read access to the targeted event and, if the target organisation accepts the delegation, transfers ownership of that event and deletes the original record - a confidentiality and integrity impact rated 8.7 (CVSS:4.0) and assessed as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L. Exploitation requires two concrete preconditions: an account with perm_delegate and the non-default, instance-wide MISP.delegation setting enabled; there is no public exploit identified at time of analysis, but a vendor fix is available in 2.5.48 (commit d1f5684f9).
Memory exhaustion and parser panics in the Go implementation of Apache PLC4X (PLC4Go) allow a malicious PLC device, or an attacker able to inject or spoof frames on the industrial network path, to crash or exhaust the client application, resulting in denial of service. The flaws affect Go module github.com/apache/plc4x/plc4go from 0.11.0 up to but not including 1.0.0 and include unbounded wire-claimed array and buffer allocations, unchecked indexing of ADS and KNXnet/IP responses, zero-length framing that breaks ADS and EIP message boundaries, unlimited recursion in recursive protocol types, and 16-bit length/position arithmetic in generated serializers that wraps and can cause payloads larger than 8 KB to be mis-framed. CVSS vector indicates no authentication is required (PR:N) and no public exploit has been identified at time of analysis; exploitation is limited to environments where a PLC4Go client talks to untrusted or attacker-reachable industrial endpoints, and impact is availability only.
Denial of service in Apache PLC4X (PLC4J Java) from 0.10.0 before 1.0.0 allows a remote, unauthenticated attacker who can impersonate an OPC UA server to exhaust the client application's memory or stack during connection setup. The defects are triggered while the secure channel and session are established, before server identity is bound, so trusting a configured server does not prevent exploitation. No public exploit identified at time of analysis; vendor CVSS 4.0 score is 8.7 and the independent CVSS 3.1 assessment confirms AV:N/AC:L/PR:N/UI:N with availability-only impact (A:H).
NULL pointer dereference in Pgpool-II allows an unauthenticated remote attacker to crash the watchdog process when the high-availability clustering feature is enabled and network-reachable. This is an availability-only impact (no confidentiality or integrity loss) and is limited to HA deployments where watchdog is configured; single-node or non-HA installations are unaffected. No public exploit identified at time of analysis, and the vendor has not yet released a patch.
Stack-based buffer overflow in Pgpool-II (versions 3.5.x through 4.7.2) allows unauthenticated remote attackers to crash the connection pooler process by sending a crafted message, causing a denial of service against Pgpool-II and the PostgreSQL databases it fronts. The vendor-assigned CVSS 4.0 score of 8.7 reflects strictly availability-only impact (VC:N/VI:N/VA:H), and no public exploit code has been identified at time of analysis. Exploitation requires only network reachability to the Pgpool-II listening socket; instances on internal or firewalled networks are at reduced risk.