Internal redirection URL validation in LiteSpeed Web Server before 6.3.7 build 1 can be bypassed in a narrow 'corner case', allowing an authenticated remote user with low privileges (PR:L per the vendor vector) to have a crafted URL resolve to a resource other than the one the validation logic approved. Because the flaw stems from the URL normalization path decoding the same value more than once (CWE-174), the malformed request passes the check in its first-decoded form but takes on different meaning after a second decode; the assessed impact is high confidentiality loss with only limited integrity impact and no availability loss, with scope crossing into the underlying system. The vendor's CVSS 4.0 vector rates this 9.4 with low attack complexity and all impacts High, whereas our independent assessment (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N) treats exploitation as high complexity because only an undocumented, highly specific corner case triggers it; no public exploit code exists and the issue is not confirmed as actively exploited (CISA KEV), so exposure is limited in practice to attackers who can reach the redirect path and reproduce the exact crafted input.
Command injection in the AiSOC actions service (AiSOC 7.2.0 up to, but excluding, 12.0.0) allows a low-privileged authenticated user to break out of quoted arguments in the file_path, path, script_name, or script_args parameters and execute arbitrary commands with SYSTEM/root privileges on CrowdStrike-managed endpoints. Exploitation requires that the deployment expose the actions service, that at least one CrowdStrike-managed endpoint is enrolled so a Real Time Response (RTR) session can be established, and that a mutating endpoint action (quarantine_file/rm, the automatic post-quarantine path_exists/ls probe, or a runscript path) is reachable with attacker-controlled input. No public exploit identified at time of analysis, and the practical weight of this flaw is tempered mainly by the small footprint of AiSOC deployments rather than by technical severity; note that the vendor's own fix commit documents that on default installs the dedicated actions-service token was never generated and its guard exempted itself while AISOC_DEV_MODE was enabled, so mutating routes could respond to anyone able to reach the port - materially lowering the authentication barrier described by the CVSS PR:L metric.
Stored cross-site scripting in Kiteworks Core (all versions prior to 9.5.0) enables unauthenticated attackers to persist malicious JavaScript that executes in an administrator's browser session when the poisoned page is viewed. Successful exploitation could grant the attacker full administrative control, including creating new admin accounts, as reflected by the CVSS 9.3 score (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:N). The primary limiting factor is the required user interaction-an administrator must actively view the affected page-and no public exploit identified at time of analysis.
Remote, unauthenticated attackers who can reach an explicitly enabled OpenBSD ldapd instance can complete an LDAP Bind as another identity because delegated BSD authentication results are correlated only by the LDAP child process's client file descriptor and LDAP message ID. When a connection closes and a later connection reuses the same file descriptor and message ID, the earlier successful authentication result is delivered to the new connection, granting the attacker the other user's identity (CWE-863, incorrect authorization); the same code path also dereferences a missing connection and crashes the daemon for denial of service. Exploitation is gated by two prerequisites: ldapd must be manually enabled (it is not on by default) and configured to use delegated BSD authentication, and the identity takeover additionally requires winning a timing/resource-reuse race to land on the exact fd+message-ID pair, which is why both the CVSS 4.0 vector (AC:H/AT:P) and the independent CVSS 3.1 assessment (AC:H) rate the attack complexity as high despite PR:N. The defect is confirmed by an upstream OpenBSD source fix and errata 7.8/057 and 7.9/021; no public exploit code and no CISA KEV active-exploitation entry were identified at time of analysis.
Prototype-pollution gadget in the Piscina Node.js worker-pool library allows an attacker who already controls a separate prototype-pollution primitive in the host application to escalate that primitive into worker-thread code preload and execution: an inherited execArgv value is passed straight to the Node.js Worker constructor, an inherited loadBalancer function runs during task scheduling, and inherited env values reshape worker environments. The flaw affects Piscina releases before 4.9.4 (4.x), before 5.3.2 (5.x), and before 6.0.0-rc.5 (6.x RC); exploitation is unauthenticated from Piscina's perspective and needs no user interaction, but the assessed vector (AV:N/AC:H, CVSS 4.0 AT:P) confirms it is not standalone-exploitable without a pre-existing prototype-pollution bug in the consuming application. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing).
A use-after-free in CPython's ssl module lets a remote, unauthenticated TLS client crash a Python TLS server process - or make it call through a freed pointer - when the server's SSLContext.sni_callback reassigns a different SSLContext to SSLSocket.context and nothing else keeps the original callback-bearing context alive. Only this non-default coding pattern is exploitable (typically per-connection SSLContext creation or context replacement while connections are open), and triggering generally requires a second ClientHello on the connection - e.g. a TLS 1.3 HelloRetryRequest induced by offering a rejected key share - or a callback that raises after switching context; servers that wrap their listening socket with the SSLContext and pure TLS clients are unaffected. No public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor-reported CVSS 4.0 score of 9.2 conflicts with an independent CVSS 3.1 assessment of 6.9 (AV:N/AC:H/PR:N/UI:N/C:L/I:L/A:H), which reflects the restrictive, non-default prerequisites rather than unqualified remote code execution.
Unauthenticated remote attackers who can reach a yii2-starter-kit deployment (through version 4.2.0) running with its default development configuration can read sensitive runtime data and write arbitrary PHP files. The dev profile sets the Yii debug and Gii modules' allowedIPs to ['*'] in common/config/web.php, so the debug endpoint leaks session cookies and executed database queries (C:H) while the Gii code generator can be abused to create attacker-controlled PHP in the application directory (I:H), a practical path to remote code execution. Exploitation requires the application to be network-exposed while still running the development/staging configuration; a properly hardened production deployment restricts allowedIPs (typically to localhost). No public exploit identified at time of analysis, and the issue is not in CISA KEV; EPSS data was not supplied.
Privilege escalation in Internet2 Grouper before 7.5.1 allows authenticated users with delegated rule creation or editing permissions in the User Interface to elevate their privileges, but only in certain configurations. This flaw (CWE-266) requires a non-default configuration and pre-existing authorization, moderating the headline critical severity; the attack is of high complexity per our independent assessment, and no public exploit identified at time of analysis. Upgrading to version 7.5.1 resolves the issue.
Improper output escaping in Satori (an HTML/CSS-to-SVG rendering library) allows crafted values to be interpreted as SVG markup, and when those values are routed through the Node.js ImageResponse implementation from Next.js's next/og, the same flaw escalates to remote code execution. Affected are Satori versions 0.0.27 through 0.33.4 and Next.js versions 16.2.0 through 16.3.5 that pass attacker-controlled data into SVG content, attributes, or styles; the Edge ImageResponse path and applications that never feed untrusted values into SVG are not affected. Exploitation is unauthenticated per the CVSS vector (PR:N) but hinges on that deployment prerequisite, and no public exploit identified at time of analysis. Vendor-released patches exist in Satori 0.33.5 and Next.js 16.3.6.
Unauthenticated remote code execution affects LightLLM through 1.2.0 when it is deployed in visual_only (multimodal/vision) mode, which exposes an RPyC inference service that performs no authentication and unpickles the arguments passed to its remote_infer_images method. Any attacker who can reach that visual RPyC port can send a crafted object whose __reduce__ method runs on the server, achieving code execution with the privileges of the LightLLM service account and resulting in high confidentiality, integrity, and availability impact (CVSS 4.0 base 9.3; independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N with high C/I/A). Text-only LightLLM deployments do not expose the affected service, no public exploit code has been identified at time of analysis, and real-world exposure hinges on whether the visual RPyC port is bound to an untrusted-reachable interface rather than to localhost or an isolated network.
Unauthenticated SQL injection in the WordPress Books Gallery plugin (wp-books-gallery) 4.8.3 and earlier lets a remote attacker read arbitrary data from the site's WordPress database over plain HTTP, with no credentials and no user interaction required. Exposure is limited to sites that actually have this low-adoption plugin installed and activated, and no public exploit code was identified at time of analysis; there is no CISA KEV entry for this issue. Because the assessed impact is high confidentiality with only a low availability effect, the realistic worst case is full database disclosure - user password hashes, private content and configuration secrets - rather than code execution or data tampering.
Authentication bypass in the YunoHost sogo_yhn package lets any remote client impersonate an arbitrary SOGo user - including a privileged administrator - by simply sending an HTTP header, with no password required. The package configures SOGo to treat the 'x-webobjects-remote-user' header as a verified identity, and the bundled Nginx reverse proxy does not strip that inbound header, so it reaches the backend untouched; both the vendor CVSS 4.0 score (9.3) and our independent CVSS 3.1 assessment (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) confirm unauthenticated, network-reachable, high-impact compromise without user interaction. The flaw is fixed in version 5.8.0~ynh9; no CISA KEV listing is associated with this CVE and no public exploit code was identified at time of analysis, but the trivial attack primitive (single header) and the exposed default configuration make prompt patching or proxy-level header stripping essential.
Unauthenticated remote attackers can retrieve other users' plaintext passwords from Digiwin EasyFlow .NET via a specific API endpoint. This missing authentication vulnerability (CWE-306) affects all versions per the CPE and requires only network reachability to the vulnerable API, as confirmed by the assessed CVSS vector (AV:N/AC:L/PR:N/UI:N). No public exploit code or active exploitation in the wild has been identified at the time of analysis.
Unauthenticated remote code execution affects Digiwin EasyFlow .NET, which deserializes attacker-supplied serialized content on the server without validating the incoming type information (CWE-502). Any network-reachable instance can be compromised by a remote attacker with no credentials and no user interaction, per the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) and the independent assessment (CVSS 3.1 9.8, S:U/C:H/I:H/A:H), yielding full confidentiality, integrity, and availability impact. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV; practical exposure is instead bounded by whether the EasyFlow .NET service is internet-facing and by the product's predominantly regional (Taiwan) install base, though the attacker must first know or discover the endpoint that accepts the serialized payload.
Remote unauthenticated heap use-after-free in iperf3 3.21 can let an attacker crash or potentially execute code on an exposed iperf3 server. The flaw occurs in server mode when the per-test watchdog frees an iperf_stream without joining the worker thread, and a blocked worker then dereferences the freed memory; exploitation requires winning a timing race (AT:P), so success is not guaranteed on a single attempt. No public exploit identified at time of analysis; the vendor fix is iperf3 3.22.
Heap-based buffer overflow in iperf3 3.20 and 3.21 allows an unauthenticated remote client to overrun a 256-byte RSA buffer inside decrypt_rsa_message() by sending an oversized authtoken, corrupting heap memory on the server and potentially achieving remote code execution or a crash (CWE-122). The flaw is only reachable when an operator has explicitly started the iperf3 server in RSA-authentication mode with --rsa-private-key-path and --authorized-users-path; default iperf3 servers run without authentication and never enter the vulnerable code path, which is reflected in the upstream CVSS 4.0 vector's AT:P (attack requirements present) and in our independent assessment of CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. No public exploit identified at time of analysis, no CISA KEV listing, and no EPSS score was supplied; a vendor fix is released as iperf3 3.22.
Authentication bypass in Kiteworks Email Protection Gateway (versions before 9.5.0) lets unauthenticated remote attackers reach administrative functions simply by citing a valid administrator account identifier, without supplying the corresponding password or any token. Exploitation allows creation, modification, or deletion of internal users and managed domains and changes to security-feature configuration; deleting a managed domain also removes its user accounts and can lock legitimate administrators out of the gateway, consistent with the assessed vector's high integrity and availability impact and no confidentiality impact. The vendor has released fixed version 9.5.0, no public exploit code has been identified, and the vulnerability is not listed in CISA KEV at time of analysis; the main gating factor is that the attacker must know or guess an existing administrative account reference and be able to reach the administrative service over the network.
Server-side request forgery in Kiteworks Email Protection Gateway (versions before 9.5.0) lets a remote, unauthenticated attacker make the gateway issue crafted requests to internal or otherwise unintended network destinations by simply delivering a message whose content references external resources - no credentials and no victim interaction are required. The vendor rates this 9.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N); our independent assessment concurs on the low exploitation barrier but bounds confidentiality impact to whatever internal endpoints are reachable from the gateway's server-side position and lowers integrity impact accordingly. No public exploit code has been identified at time of analysis and the flaw is not confirmed as actively exploited (CISA KEV); a vendor patch is available in 9.5.0.
Authentication bypass in the YunoHost-packaged SOGo application (sogo_yhn) allows unauthenticated remote attackers to log in to any existing user account by supplying only that user's username together with an arbitrary password, rated CVSS 9.2. The root cause is the package's default configuration of SOGoTrustProxyAuthentication=YES, which causes SOGo to skip password verification during HTTP Basic authentication; every package version prior to 5.8.0~ynh9 is vulnerable by default, so exposed instances are broadly at risk. No public exploit code or exploitation telemetry has been identified at time of analysis, but the bypass requires no specialized tooling beyond knowing a valid username (typically derivable from email addresses), and the vendor has released a fixed version.
Man-in-the-middle attackers can impersonate the OPC UA server to Apache PLC4X (PLC4J) client applications and read, forge or modify secure-channel traffic - including the user credentials the client sends - affecting versions 0.9.0 through 0.13.1, with the fix landing in 1.0.0. Unauthenticated network attackers holding an on-path position (the AT:P requirement) benefit from insecure defaults: the security policy defaults to None in every affected release, 0.9.0-0.11.0 only log failed message-signature checks and never verify the server certificate taken from the unauthenticated GetEndpoints response, while 0.12.0-0.13.1 invert the signature check (rejecting valid signatures and accepting invalid ones) and accept server certificates with no trust anchor; from 0.12.0 the driver also silently continues at a weaker policy than configured, and from 0.13.0 endpoint selection prefers the weakest matching endpoint. Rated 9.2 (Critical) under CVSS 4.0 and high-severity under the independent CVSS 3.1 assessment (AV:N/AC:H/PR:N/UI:N/C:H/I:H/A:H); no public exploit code identified at time of analysis.
Path traversal in the skill_upload API handler of DB-GPT 0.8.0 (packages/dbgpt-app/src/dbgpt_app/openapi/api_v1/agentic_data_api.py:40) lets a remote attacker supply a crafted upload path and write files outside the intended workspace or storage directory. The provider-assigned CVSS is 9.1 and the supplied vector indicates no authentication prerequisite (PR:N), but our independent assessment scores it AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L - integrity is the dominant impact, with limited availability effects and no confirmed confidentiality loss, and the practical attack surface depends heavily on whether the skill_upload endpoint is reachable without authentication in a given deployment. Exploitation status is unconfirmed: the CVE is not in CISA KEV, no public exploit code has been confirmed (EPSS 0.47%, 38th percentile), and no vendor-released patch was identified at time of analysis.
Path traversal in DB-GPT 0.7.5 and 0.8.0 lets remote attackers write arbitrary files outside the intended upload workspace through the OpenAPI python_file_upload endpoint at packages/dbgpt-app/src/dbgpt_app/openapi/api_v1/python_upload_api.py:42. The affected service is the DB-GPT web API and the vector is rated critical (CVSS 9.1, AV:N/AC:L/PR:N/UI:N), so exploitation hinges on network reachability of the instance rather than on any attacker-held credentials - DB-GPT ships its API without enforced authentication by default, which is why the score is PR:N. There is no confirmed active exploitation (not listed in CISA KEV) and no public exploit identified at time of analysis; EPSS is low at 0.47% (38th percentile), so this is a genuine but not yet mass-exploited issue. Note a scoring divergence: NVD rates confidentiality and integrity high with no availability impact, while our independent assessment rates integrity and availability high and confidentiality none.
Server-side request forgery in Kiteworks Email Protection Gateway before 9.5.0 allows a remote, unauthenticated sender to embed URLs in message content that the gateway then fetches server-side and reflects back, exposing internal services and cloud instance metadata to the attacker. Because the gateway processes inbound mail from untrusted senders as its normal operating mode, no credentials or user interaction are required beyond delivering a crafted message to a protected recipient, and the confidentiality impact is high whenever the appliance runs on a cloud instance with an attached IAM role. No public exploit code has been identified at time of analysis; the issue is nevertheless high priority given the unauthenticated network vector, with our independent assessment scoring integrity impact as Low (reflecting that state changes depend on which internal endpoint is reachable) rather than the published vector's High.
Unauthenticated server-side request forgery in Kiteworks Email Protection Gateway before version 9.5.0 lets a remote attacker cause the gateway itself to send crafted requests to internal or otherwise unintended network destinations by simply sending an inbound message that triggers an online certificate status check. Because the request originates from the gateway's own network position, an attacker can potentially reach internal services that are not directly exposed, leading to sensitive information disclosure and, depending on reachable targets, disruption of gateway availability. No public exploit code has been identified at time of analysis and the vulnerability is not confirmed as actively exploited (no CISA KEV listing); exploitation is nevertheless trivially reachable since it requires no authentication and no user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H, score 9.1), with realized impact bounded by the gateway's internal network position and egress restrictions.
Server-side request forgery in Kiteworks Email Protection Gateway before 9.5.0 allows a remote, unauthenticated attacker (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H, 9.1) to make the gateway fetch attacker-chosen URLs by embedding a crafted certificate revocation list reference in an inbound message. Successful exploitation yields disclosure of information reachable from the gateway's network position or disruption of gateway availability, but no write access or code execution (I:N), so practical severity is bounded by what internal or cloud-metadata endpoints the appliance can actually reach - landing it in the medium operational-priority band despite the critical base score. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV).
Server-side request forgery in Kiteworks Email Protection Gateway (all versions before 9.5.0) lets a remote, unauthenticated attacker who can deliver an inbound message cause the gateway to issue crafted HTTP requests to internal or otherwise unintended network destinations, with the trigger occurring during the gateway's issuer-certificate retrieval step. With CVSS 3.1 base score 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H), a successful attack can disclose sensitive internal information reachable from the gateway's network position and/or disrupt gateway operation, but the practical impact is bounded by which internal services and metadata endpoints the gateway can reach and by whether any response data is reflected back to the attacker rather than being blind. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV), though the combination of network reachability, no authentication, and no user interaction makes this a genuine priority within the email security gateway niche.
Directory traversal in Bisheng 2.3.0, 2.4.0, and 2.4.0-beta1 lets a remote attacker use crafted filename/path input to break out of the intended download/cache directory through the save_download_file routine (src/backend/bisheng/core/cache/utils.py:290), yielding arbitrary file read and write with a CVSS 3.1 base score of 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N). The vector indicates an unauthenticated, network-reachable attack with no user interaction, though the practical limiting factor is whether the API route that reaches save_download_file is exposed without a login - defenders should verify that against their own deployment before assuming unauthenticated reachability. Exploitation status: no public exploit identified at time of analysis, and there is no CISA KEV entry; EPSS is 0.33% (24th percentile), so mass exploitation is not currently expected, but the impact per successful attack is severe given the high confidentiality and integrity ratings and the absence of any availability impact.
WS-Security policy bypass in Apache WSS4J (4.0.0 <4.0.2, 3.0.0 <3.0.6, and 0 <2.4.4) allows an unauthenticated remote attacker to exploit EncryptedHeader child confusion so that an attacker-controlled plaintext element is promoted as the decrypted header, undermining confidentiality coverage and enabling WS-SecurityPolicy bypass. Per the CVSS 3.1 vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N (9.1), the flaw is network-reachable with low complexity, requires no authentication and no user interaction, and can affect both confidentiality and integrity - typically through Apache CXF-based SOAP services that decrypt EncryptedHeader elements and enforce WS-SecurityPolicy. Exposure is limited to deployments that actually rely on encrypted SOAP headers and policy enforcement; services not using WS-Security header confidentiality are not meaningfully exposed, and no public exploit code was identified at time of analysis.
Meta Horizon OS versions prior to v74.0.0.878.1682 allow a locally installed malicious application that has been granted notification-access to impersonate the privileged com.oculus.vrshell package - and any other package signed with the same signing key - against OS endpoints that authenticate callers via CallerIdentity, producing high confidentiality and integrity impact. The root cause is an improper communication-channel restriction (CWE-923) in MediaSyncJobReceiver, which can be induced to send a privileged PendingIntent carrying a com.oculus.vrshell CallerIdentity to any application registered as a NotificationListenerService. Although the supplied NVD score is 9.1 with an AV:N vector, the realistic attack path is a local, on-device app-to-app attack that requires an attacker-controlled listener already resident on the device; EPSS is low (0.23%, 13th percentile) and no confirmed active exploitation (CISA KEV) or public exploit code was identified at time of analysis.
Authenticated server-side request forgery in Tugtainer before version 1.30.6 allows any logged-in user with access to notification settings to make the backend send outbound HTTP requests to attacker-chosen URLs through the /settings/test_notification endpoint, reaching localhost, RFC1918 ranges, and cloud metadata addresses such as 169.254.169.254. The urls field is passed directly to the Apprise notification library with no scheme, hostname, private-IP, or metadata filtering in the default configuration, and because responses are not returned to the caller the attack is blind, which limits it to internal port scanning, service probing, and indirect information inference rather than straightforward data exfiltration. Our independent assessment agrees with the SSRF class and the authentication prerequisite (PR:L) but rates the CIA impact lower (C:L/I:L/A:L) than the vendor's 9.1 scoring, so the practical severity sits below the headline score; vendor-released patch: 1.30.6, and no public exploit identified at time of analysis, with no CISA KEV listing.
Unauthenticated firmware replacement on PTZOptics PTZ cameras and the vendor's Firmware Upgrade Tool lets anyone who can reach the device's update endpoint flash a modified firmware image onto the hardware, handing the attacker persistent control of the camera without ever supplying administrator credentials. Rated CVSS 9.1 (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N with full confidentiality, integrity and availability impact), the missing-authentication flaw (CWE-306) covers the Move/Link/Studio 4K and SE families below their respective fix builds, every Generation-2 camera (PT12X/PT20X/PT30X SDI/NDI/USB, ZCAM variants, Studio Pro) at all versions, and all versions of the Upgrade Tool. No public exploit code has been identified and the issue is not confirmed actively exploited (no CISA KEV listing) at time of analysis, but because exploitation is unauthenticated and needs no user interaction the only real gating factor is network reachability - these cameras normally sit on AV/production VLANs rather than the public internet, so an attacker must first gain a foothold on the same segment and then craft a firmware image the device accepts.
Authentication bypass in the GiveWP WordPress donation plugin (all versions through 4.16.9) allows remote, unauthenticated attackers to satisfy the plugin's credential/equivalence check with crafted input and reach privileged plugin functionality on any affected site. Scoring CVSS 3.1 base 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), exploitation requires only that the plugin be installed and reachable - no account, no privileges, and no victim interaction - with high confidentiality and integrity impact, which makes automated scanning of WordPress installs a realistic attack model. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and no EPSS score was supplied, so priority should be driven by the severity and trivial preconditions rather than observed exploitation.
Cross-workspace authentication bypass in Soft Machine 0.2.247 and earlier lets an authenticated paying tenant read, modify, and destructively restore another tenant's workspace through its HTTP API. Two helper functions in /app/server.js, verifyContainerAuth() and authenticateWorkspaceHttp(), accept the app-wide CONTAINER_SHARED_SECRET as a bearer token without validating which workspace the caller owns, bypassing the per-workspace workspaceTokenMatches check; because that secret is identical on every container and readable from the tenant's own process environment, the multi-tenancy isolation boundary collapses. Exploitation requires a valid paid account, adjacency to the target workspace API (AV:A), and no user interaction; no public exploit has been identified at time of analysis and no vendor-released patch is available, so this is assessed at CVSS 9.0 as a genuine high-priority multi-tenancy isolation failure.
Unauthenticated remote code execution in the AcyMailing SMTP Newsletter WordPress plugin (versions 11.0.5 and earlier) allows a remote attacker to execute arbitrary code on the underlying server, leading to full site compromise. The CVSS 3.1 base score is 9.0 (AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H), indicating no authentication or user interaction is required, though the high attack complexity (AC:H) signals that reliable exploitation likely depends on a specific precondition, application state, or configuration that the attacker must arrange or wait for. No public exploit code is currently identified, and the vulnerability is not listed in CISA KEV.
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.