Vulnerabilities

The Paid Downloads plugin for WordPress, in all versions up to and including 3.15, exposes an arbitrary file upload flaw in its admin_request_handler function, which performs no authorization check and no file-type validation and is reachable by unauthenticated users because is_admin() returns true for requests to /wp-admin/admin-post.php. An unauthenticated attacker can therefore upload files directly to the site, including files the web server may execute, which makes remote code execution possible. Exploitability depends on the server stack: on Apache with AllowOverride enabled, an .htaccess file placed in the upload directory can block direct HTTP retrieval of uploaded files, so sites on nginx, LiteSpeed, or Apache with AllowOverride None are the most exposed. Any WordPress site running the plugin at version 3.15 or earlier is affected. As of this analysis the flaw is not on CISA's KEV list, no public proof-of-concept is known, and no in-the-wild exploitation has been confirmed.

Do: Update the Paid Downloads plugin to a version newer than 3.15 as soon as a patched release is available; if no fix is published, deactivate and remove the plugin. Sites that must keep running it should block PHP execution and direct HTTP access to uploaded files at the web-server layer (an .htaccess deny rule is effective on Apache with AllowOverride enabled, while nginx and LiteSpeed sites need an equivalent server-level rule) and should review the uploads directory and admin-post.php access logs for suspicious .php uploads or .htaccess modifications.

The Multi Uploader for Gravity Forms WordPress plugin is vulnerable to unauthenticated arbitrary file upload (CWE-434) in all versions up to and including 1.1.9, caused by insufficient file type validation in the move_file function during chunked upload handling. An attacker with no account or privileges can send crafted chunked upload requests to the plugin's endpoint and place arbitrary files, such as malicious PHP scripts, on the affected server. Successfully uploaded web-executable files may enable complete remote code execution, giving the attacker full control of the site and its data. Any WordPress site running the plugin at version 1.1.9 or older is affected, and the vulnerability is rated critical (CVSS 9.8). As of this analysis there is no evidence of in-the-wild exploitation and no known public proof-of-concept.

Do: Update Multi Uploader for Gravity Forms to the first patched release after 1.1.9 as soon as one is available; if no patch is published yet, deactivate or remove the plugin until a fixed version ships. Check the wp-content uploads directory for unexpected PHP or other executable files and review web-server logs for unauthenticated POST requests to the plugin's upload endpoints. Given the unauthenticated RCE potential, treat any site running version 1.1.9 or older as at risk and verify integrity of the WordPress installation if compromise is suspected.

CVE-2026-25294 is a buffer over-read (CWE-126) in a Qualcomm WLAN component that occurs while parsing a frame during channel usage. An attacker positioned in adjacent radio range (e.g., a nearby Wi-Fi peer) can send a specially crafted frame that triggers the over-read with no privileges or user interaction required. The result is high availability impact only: a transient denial of service of the wireless component, with no confidentiality or integrity loss and no evidence of code execution. Devices containing the affected Qualcomm WLAN component are exposed; the source data does not identify specific chipsets or firmware versions. Exploitation status is currently clean: the flaw is not in CISA KEV and no public proof-of-concept is known.

Do: No fixed versions are listed in the source data; check Qualcomm's product security bulletin and your device OEM's/Android security bulletin for the fix mapped to CVE-2026-25294 and apply firmware updates when released. Because the attack vector is adjacent (nearby radio range), risk concentrates on Wi-Fi clients and access points within attacker proximity; the DoS is transient, so repeated exposure rather than a single frame is the practical concern. Monitor Qualcomm advisories for the affected chipset identifiers to confirm whether your fleet is in scope.

An integer overflow (CWE-190) in a Qualcomm product component corrupts memory when very large data buffers from external sources are validated: because the length check is performed using addition, the computed size can wrap around and incorrectly pass validation. A local, low-privileged attacker (CVSS:3.1 AV:L/AC:L/PR:L/UI:N) could trigger the flaw by supplying a crafted oversized buffer, with high potential impact on confidentiality, integrity, and availability, typically enabling memory corruption that may lead to code execution or a crash in the affected component. The advisory was assigned by Qualcomm's product security team, but the specific affected chipsets, components, and firmware versions are not identified in the available data. Exploitation is not currently known: the issue is absent from CISA's KEV catalog and no public proof-of-concept exists.

Do: Monitor Qualcomm's security bulletin for the advisory covering CVE-2026-25290 and apply OEM firmware/Android security updates as soon as fixed versions are published, since the specific patched versions are not yet identified in the available data. Because exploitation requires local access with low privileges, prioritize patching devices that run untrusted applications and restrict installation of untrusted local software on Qualcomm-based devices in the interim.

CVE-2026-25284 is an information disclosure flaw caused by a use-after-free condition: a pointer to freed memory is reused, and the resulting out-of-bounds read (CWE-126, buffer over-read) returns memory contents to the caller. A local attacker who already holds low privileges on the device can trigger the dangling-pointer reuse without any user interaction, and the CVSS scope change (S:C) indicates the leaked data crosses a security boundary, potentially exposing memory belonging to a more privileged component. The attacker gains read access to sensitive memory contents (high confidentiality impact) but cannot modify data and causes only minor availability impact. Affected devices are those running the impacted Qualcomm software or firmware; the specific chipset or component name and the version ranges were not included in the source data. The flaw is not listed in CISA's Known Exploited Vulnerabilities catalog and no public proof-of-concept is known, so exploitation has not been confirmed.

Do: Watch the Qualcomm security bulletin for CVE-2026-25284 and apply firmware/OS updates from your device or OEM vendor as they roll out, since Qualcomm typically ships fixes through OEM builds. Because exploitation requires local access with low privileges, limit untrusted apps and local accounts on potentially affected devices. Inventory which products run Qualcomm components and verify whether your specific chipset or firmware version is named in the advisory once published.

CVE-2026-25283 is a memory-corruption flaw (CWE-121, stack-based buffer overflow) in which copying unverified data from an external source into an allocated buffer exceeds the buffer's size. The CVSS vector (AV:L/AC:L/PR:L/UI:N/S:C) indicates it is triggered by a local attacker with low privileges, such as a malicious app or local process supplying oversized external data to the affected component, with no user interaction required, and that the corruption crosses a security boundary into a more privileged context. A successful attacker gains high confidentiality, integrity, and availability impact in that escaped scope, consistent with privileged code execution, data disclosure, or a crash of the affected subsystem. The CVE was assigned by Qualcomm's product security team, so affected products are Qualcomm chipset/firmware components deployed across Android smartphones and other connected hardware, but the provided data does not name the specific component or version range. No exploitation is currently known: the flaw is not on CISA's KEV list and no public proof-of-concept exists.

Do: Monitor Qualcomm's security bulletin for CVE-2026-25283 and apply the corresponding firmware/driver fix as it is distributed through your device or OEM's security updates. Until patched, reduce risk by restricting untrusted app installs on potentially affected Qualcomm-based devices, since exploitation requires local low-privileged code execution. Once the advisory is published, verify your device model and chipset against Qualcomm's list to confirm whether your hardware is in scope.

CVE-2026-25282 is an out-of-bounds memory read (CWE-125) in a Qualcomm platform component that occurs when the component processes unverified data originating from a neighboring system. Per the CVSS vector, a local attacker with low privileges and no user interaction required can feed such data to the affected component and trigger the flaw, causing a transient denial of service with high availability impact and low confidentiality/integrity impact. The scope-changed metric suggests the vulnerable code runs in a protected or isolated subsystem, a pattern typical of Qualcomm modem/baseband and similar components. Devices built on affected Qualcomm silicon — which spans a large share of Android smartphones and many IoT and automotive products — are potentially affected, although the specific component, chipset list, and fixed firmware versions are not included in the available data. The issue is not listed in CISA's KEV, and no public proof-of-concept or in-the-wild exploitation is known.

Do: Check Qualcomm's security bulletin for CVE-2026-25282 to identify the affected chipset(s)/component and the fixing firmware, then apply the corresponding OEM or Android monthly security update as it reaches your devices. Because triggering requires local access to feed unverified data to the affected component, prompt patching and limiting untrusted local applications materially reduce risk. No workaround is documented; monitor vendor advisories for the definitive list of affected parts.

CVE-2026-25281 is a resource-allocation flaw (CWE-770) in a Qualcomm component that processes request buffers, where incoming large or numerous buffers are accepted without sufficient memory-allocation validation. An unprivileged attacker with adjacent-network access (CVSS AV:A, e.g., on the same LAN or within Wi-Fi/Wireless proximity) can trigger excessive memory consumption, causing a transient denial of service; availability impact is rated high (A:H) with no confidentiality or integrity impact. Because the scope is changed (S:C), the exhaustion affects resources beyond the vulnerable component's own security scope, such as a shared subsystem crashing or hanging, with the condition typically recovering after restart. Devices running the affected Qualcomm component are exposed, although the source data does not enumerate the specific chipsets or versions, so defenders should consult Qualcomm's security bulletin for the definitive affected-product list. No public proof-of-concept, CISA KEV listing, or confirmed in-the-wild exploitation is known at this time.

Do: Watch the Qualcomm security bulletin assigned by [email protected] for the definitive list of affected chipsets, then apply the corresponding OEM/device firmware update as soon as it is offered. Until patched, reduce adjacent-network exposure for likely affected Qualcomm-based devices (restrict access to shared LANs and Wi-Fi, and review which unauthenticated clients can reach them). Check with your device vendor for updates addressing CVE-2026-25281, since Qualcomm fixes of this type typically ship through OEM builds rather than as standalone patches.

CVE-2026-25280 is a memory corruption flaw (CWE-787, out-of-bounds write) in a Qualcomm component, occurring when the escape handling flow processes data into user-supplied buffers whose sizes were not sufficiently validated. It is triggered by a local, low-privileged process that submits data or undersized buffers along this code path, causing memory to be written past the intended bounds. An attacker who already has a foothold on a device (e.g., a malicious app or compromised process) could leverage it for local privilege escalation with high impact on confidentiality, integrity, and availability, per the CVSS 7.8 local-attack vector. Affected parties are users of devices running vulnerable Qualcomm silicon or firmware such as Snapdragon-based smartphones and other Qualcomm-powered products; the specific affected chipsets and version ranges are not enumerated in the available data. The flaw is not listed in CISA's Known Exploited Vulnerabilities catalog and no public proof-of-concept is known, so no exploitation is currently confirmed.

Do: Watch for CVE-2026-25280 in Qualcomm's security bulletin and apply the corresponding OEM/Android monthly security update as soon as your device vendor ships it, since fixes for Qualcomm issues typically arrive via device firmware rather than generic patches. Until patched, limit installation of untrusted apps on affected devices, as the flaw requires local low-privileged access to exploit. Verify the Qualcomm component/firmware version of your devices against the bulletin's affected list once published.

CVE-2026-25278 is a memory corruption flaw in Qualcomm's kernel code that processes I2C transfer requests, caused by a time-of-check/time-of-use race condition (CWE-367) between memory allocation and the subsequent data copy. A local attacker with low privileges can trigger the race, for example by issuing I2C transfer requests in a way that wins the race window, corrupting kernel memory. The impact is local privilege escalation or arbitrary kernel-level read/write/execute effects, reflected in the high confidentiality, integrity, and availability scores in CVSS 3.1 (7.8, local vector, low privileges, no user interaction). It affects devices built on Qualcomm chipsets whose kernels include the affected I2C driver code — a population spanning Android smartphones and other Qualcomm-based products — with the authoritative chipset list published in Qualcomm's security bulletin. There is currently no public proof-of-concept, no CISA KEV listing, and no known exploitation in the wild.

Do: Monitor Qualcomm's security bulletin for this CVE and apply the fixed kernel/driver through your device vendor's firmware or Android security updates as soon as published. On embedded or Linux products using Qualcomm platforms, update kernel packages and restrict unprivileged access to I2C device nodes (e.g., /dev/i2c-*) as an interim mitigation. Because exploitation requires local low-privileged access, prioritize patching devices that run untrusted third-party apps or local users.

CVE-2026-25275 is an out-of-bounds read (CWE-126) in the Qualcomm WLAN component's processing of IEEE 802.11 authentication frames that carry a FILS (Fast Initial Link Setup, 802.11ai) information element. An attacker within Wi-Fi radio range can trigger it by sending an unauthenticated authentication frame whose FILS information element header length fields are invalid, causing the parser to read past the frame data. The result is a transient denial of service (typically a Wi-Fi subsystem crash and re-initialization); there is no confidentiality or integrity impact and no code execution, reflected in the CVSS 3.1 vector (C:N/I:N/A:H, score 7.5 high). Devices using the affected Qualcomm WLAN software, such as Snapdragon-based and other Qualcomm-chipset Wi-Fi products, are exposed, though the specific affected SoC/version list was not included in the available data. No exploitation is known: the flaw is not in CISA KEV, no public proof-of-concept exists, and no in-the-wild abuse has been reported.

Do: Apply the WLAN firmware/host driver fix from Qualcomm's security bulletin as distributed through your device vendor (e.g., Android or Windows OEM security updates), and check your device or chipset model against Qualcomm's advisory for confirmation. Because the attack is over the air and requires no credentials, patching is the only practical fix; organizations with wireless IDS/WIPS can watch for anomalous FILS authentication frames. Impact is transient, so affected devices recover after the Wi-Fi subsystem restarts or reconnects.

A buffer over-read (CWE-126) in the Bluetooth channel-map handling of Qualcomm chipsets causes a transient denial of service when a channel map containing an insufficient number of used channels is processed while adaptive frequency hopping (AFH) is fully enabled. An attacker in adjacent wireless range, requiring no privileges or user interaction, can trigger the flaw by sending a crafted channel map to the vulnerable Bluetooth component. The impact is availability-only (CVSS availability: high; confidentiality/integrity: none), meaning the affected device's Bluetooth functionality transiently fails, with no code execution or data compromise. Any device running the affected Qualcomm Bluetooth firmware is potentially exposed, although the provided data does not enumerate specific chipset models or versions. No public proof-of-concept is known, the issue is not in CISA's KEV catalog, and exploitation has not been observed.

Do: Monitor Qualcomm's security bulletin for CVE-2026-24081 and apply device firmware/OS updates from your OEM for affected Qualcomm Bluetooth components as they are released. Until patched, disable Bluetooth when not needed in environments with nearby untrusted devices, since the attack vector is adjacent (Bluetooth range). Inventory hardware for Qualcomm-based Bluetooth chipsets now so affected devices can be prioritized once the affected product list is published.

A Qualcomm device control handler contains a memory-corruption flaw (buffer over-read, CWE-126) caused by improper synchronization when multiple threads issue concurrent IOCTL requests to the driver. A local, low-privileged attacker could trigger the race condition by sending simultaneous IOCTL requests, corrupting memory in the driver. Because the CVSS vector grants high confidentiality, integrity, and availability impact from a local attack with low privileges, successful exploitation likely yields local privilege escalation to kernel-level compromise of the host. Any system running the affected Qualcomm driver component is exposed; the specific product names and version ranges are not enumerated in the available data. Exploitation status: no public proof-of-concept is known and the flaw is not listed in CISA KEV.

Do: Check Qualcomm's security bulletin for CVE-2026-24075 and apply the updated driver package provided by Qualcomm or your device OEM (e.g., via Windows Update or the OEM support portal) as soon as a fixed version is published. Until patched, restrict untrusted local code execution on systems running the affected driver, since exploitation requires a low-privileged local attacker. Verify installed driver versions against the bulletin once Qualcomm confirms affected and fixed ranges.

CVE-2026-24074 is a memory corruption flaw (CWE-787, out-of-bounds write) in Qualcomm chipset software, disclosed through Qualcomm's product security team. When processing data whose offset and length values are unusually large, a data copy operation exceeds buffer limits and writes past the end of the intended buffer. A local attacker who already has low privileges on a device (for example, via a malicious app) can trigger the condition to corrupt memory, potentially escalating privileges or gaining code execution in the affected component's context, with high impact on confidentiality, integrity and availability per the CVSS 7.8 score. The vulnerability affects devices running Qualcomm chipset firmware — a population that spans a large share of the world's Android smartphones and connected devices — though the specific affected components and version ranges are not listed in the available data. Exploitation status: the flaw is not on CISA's Known Exploited Vulnerabilities catalog and no public proof-of-concept is known.

Do: Watch for the Qualcomm security bulletin entry covering CVE-2026-24074 and install OEM firmware/Android monthly security updates as soon as they deliver the fix; do not downgrade or defer device patch levels. Because the attack vector is local with low privileges required, limit risk in the interim by discouraging sideloading of untrusted apps and reviewing high-privilege app installs on managed fleets. Enterprises should check device patch levels and OEM advisories for affected model lists, then prioritize fleet-wide updates.

CVE-2026-24073 is a memory corruption flaw (CWE-787, out-of-bounds write) in software assigned by Qualcomm's product-security CNA that processes decode statistics, caused by insufficient validation of an offset against the size of the structure it indexes into. A local attacker with low privileges can trigger the flaw by getting the affected component to process malformed decode statistics data, with no user interaction required. Successful exploitation corrupts adjacent memory and carries high impact to confidentiality, integrity, and availability (CVSS 3.1 score of 7.8, AV:L/AC:L/PR:L/UI:N), consistent with local code execution or privilege escalation in the context of the affected component. Any device running the affected Qualcomm component is exposed; the specific chipset, driver, or component name is not detailed in the available data. No exploitation is currently known: the flaw is not listed in CISA KEV and no public proof-of-concept exists.

Do: Monitor Qualcomm's security bulletin (qualcomm.com/security) for CVE-2026-24073 to identify the exact affected chipsets/components and fixed versions, then apply the corresponding OEM firmware or Android security update when released. Until patched, limit local attack surface on affected devices by avoiding installation of untrusted apps, since exploitation requires local access with low privileges. Confirm your device's chipset and update status with the handset or device OEM's support pages.

CVE-2025-59607 is a memory corruption flaw (untrusted pointer dereference, CWE-822) in a Qualcomm component, triggered when copying input data that exceeds normal allocation limits. A local attacker who already has low privileges on a device can supply oversized input to the affected component with no user interaction required, causing the corruption. The high ratings for confidentiality, integrity, and availability in the CVSS score indicate the flaw can likely lead to privileged code execution or a system-level crash. The advisory was issued by Qualcomm Product Security, but the specific affected chipset, component, and version range are not stated in the available data, so affected devices cannot be precisely enumerated. No public proof-of-concept exists and the flaw is not in CISA's Known Exploited Vulnerabilities catalog, so exploitation is not currently known to be occurring.

Do: Monitor Qualcomm security bulletins and your device OEM's Android security patch releases, and apply the firmware/driver fix for the affected component as soon as it is identified. Because the attack vector is local and requires only low privileges, avoid installing untrusted apps or granting local access on Qualcomm-based devices until patched.

GeoVision's GV-Remote E-Map desktop application loads one or more dynamic-link libraries from an unsafe search path (CWE-427), so Windows resolves a DLL name to a directory an attacker controls before the legitimate library location. A local attacker with low privileges who can write a malicious DLL into such a directory gets it loaded by the application, with the CVSS vector indicating no user interaction is required beyond the application's normal startup/loading behavior. Successful exploitation yields arbitrary code execution in the security context of the GV-Remote E-Map process, giving the attacker the privileges of the user running the surveillance client. Only organizations running GeoVision's GV-Remote E-Map client on Windows workstations are affected; the flaw is local (AV:L) and cannot be exploited remotely by itself. There is no evidence of exploitation in the wild, the flaw is not in CISA KEV, and no public proof-of-concept is known.

Do: Check GeoVision's support/download portal for an updated GV-Remote E-Map release and upgrade as soon as a fixed version is published, since no fixed version is identified in the current data. Until then, restrict write permissions on the application's installation folder and any directories on its DLL search path to administrators, run the client as a standard (non-elevated) user, and avoid installing it on shared or multi-tenant workstations. Inventory Windows hosts running GV-Remote E-Map and monitor for a vendor advisory or KEV listing.

CVE-2026-81546 is a stack-based buffer overflow (CWE-121) in the Affinity by Canva application, caused by inadequate bounds checking when parsing Affinity document files. An attacker triggers it by crafting a malicious Affinity document and convincing a user to open it in the app, consistent with the CVSS vector (AV:L/PR:N/UI:R/AC:H), which requires local delivery and user interaction. Successful exploitation could result in arbitrary code execution in the context of the user running Affinity, with high impact to confidentiality, integrity, and availability. All users running Affinity before version 3.3.0 are affected. There are no known public proof-of-concepts, no reports of in-the-wild exploitation, and the flaw is not listed in CISA KEV.

Do: Upgrade Affinity to version 3.3.0 (the September 2026 release) or later, and verify the installed version via the app's About/settings screen. Until patched, avoid opening Affinity document files from untrusted or unknown sources, since no workaround for the parser flaw is documented. Monitor vendor advisories for any updates on exploitation status.

The Python/Django live-view library djust (CVE-2026-61594) fails to enforce standard Django authorization on its WebSocket (live) transport: views are mounted via check_view_auth instead of Django's View.dispatch() chain, so protections such as LoginRequiredMixin, PermissionRequiredMixin, UserPassesTestMixin, login_required decorators, custom dispatch() guards, and the djust admin staff gate apply only to the initial HTTP GET and are silently bypassed over WebSocket. Any anonymous or under-privileged client can open a WebSocket connection and mount such a view, causing its handlers to run. Because all events and state flow over WebSocket, an attacker can reach full read and write handlers — including the djust admin extension's list/create/change/delete operations — yielding high confidentiality and integrity impact (CVSS 3.1: 9.1 critical). All djust deployments that protect WebSocket-mounted views or admin routes with Django mixins, decorators, or overridden dispatch() are affected. No public proof-of-concept is known, the issue is not in CISA KEV, and there are no reports of exploitation in the wild.

Do: Upgrade to djust 1.0.7 or later, where check_view_auth honors the Django AccessMixin family on every transport, system check S004 flags unsafe auth patterns at startup, and the admin mixin enforces login plus active-staff permissions. As an interim workaround, gate WebSocket-mounted views using djust's own login_required, permission_required, or check_permissions attributes instead of HTTP-only Django mixins or decorators. Audit all WebSocket-mounted views (especially admin routes) and review access logs for anonymous WebSocket connections that mounted privileged views.

The joi npm package (the hapi.js schema validation library) is vulnerable to regular expression denial of service (ReDoS, CWE-1333) in the Joi.string().isoDate() validation rule, because one of the regular expressions applied to input is unanchored. A remote attacker who can supply a string that reaches an isoDate() check can trigger quadratic backtracking by sending a valid ISO date followed by a long run of fractional-second digits, taking roughly 1.4 seconds per 64 KB of digits and about 22 seconds per 256 KB. With a single crafted request the attacker can stall the event loop or a request handler, degrading or denying service to the application. Any Node.js service using joi versions 17.2.0 up to (but not including) 18.2.6 that validates attacker-controlled strings with isoDate() is affected. Exploitation is not currently known in the wild, there is no public proof-of-concept, and the flaw is not on the CISA KEV list.

Do: Upgrade joi to 17.13.7 if you are pinned to the 17.x line, or to 18.2.6 or later on the 18.x line. As a workaround, cap the length of any string (e.g., request-body or field-size limits) before it reaches joi's isoDate() validation. Search your codebase for Joi.string().isoDate() and confirm whether the validated input can be attacker-controlled.

Nodemailer before 9.1.0 fails to apply UTS-46 normalization when encoding internationalized domain names, causing its domain resolver to compute a Punycode A-label that differs from what standards-compliant parsers compute for the same address. An attacker can craft recipient email addresses containing invisible characters or Unicode compatibility mappings that pass the application's domain allow-list check, while SMTP delivery resolves to a different, attacker-controlled domain. Successful exploitation redirects mail to attacker domains, potentially leaking message contents and confidential data (high confidentiality impact per the CVSS score). Any Node.js application using a vulnerable Nodemailer version with allow-lists that restrict recipient domains to trusted domains is affected. No public proof-of-concept is known and the issue is not listed in CISA KEV, so exploitation has not been confirmed in the wild.

Do: Upgrade to Nodemailer 9.1.0 or later, which applies UTS-46 normalization before Punycode encoding. As an interim mitigation, normalize recipient domains (UTS-46, then convert to A-labels) with a standards-compliant library before evaluating them against allow-lists, or restrict recipients to ASCII-only domains. Review mail logs for recipient domains containing 'xn--' punycode labels or unexpected domains that differ from the allow-listed values.

Nodemailer versions 6.9.16 through 9.0.x contain a flaw in lib/addressparser where a comment closed immediately before a non-break character is not treated as folding whitespace that terminates the domain; instead, the tokenizer concatenates the atoms around the comment into a single domain. An attacker who submits an address such as [email protected](x)evil.com gets Nodemailer to read the recipient domain as good-corp.comevil.com (registrable domain comevil.com, which the attacker can register) and use it for both the SMTP envelope and the To:/From: headers, while a conformant RFC 5322 validator reads good-corp.com. Applications that allow-list recipient domains with a strict parser or naive prefix/substring check and then hand the raw address string to Nodemailer can therefore be tricked into sending mail to an attacker-controlled domain, potentially leaking message contents or enabling interception via the attacker's mail server. Any application or service in the affected version range that performs domain validation with a parser other than Nodemailer's own is affected; exploitation requires no privileges or user interaction. There is currently no CISA KEV listing and no known public proof-of-concept or reported in-the-wild exploitation.

Do: Upgrade to Nodemailer 9.1.0 or later, which correctly terminates the domain at comments. Until upgraded, reject or strip addresses containing parenthesized comments before validation, or perform your domain allow-list check on the address as parsed by Nodemailer itself rather than with a separate strict parser or substring match, and audit outbound mail flows that accept user-supplied recipient addresses.

Nodemailer before 9.1.0 contains an uncontrolled resource consumption flaw (CWE-400): a quadratic time-complexity algorithm in its addressparser component. A remote attacker can trigger it by supplying a crafted comma-separated address list — for example, sending a single email with a very large number of addresses that the application parses. The parsing stalls the Node.js event loop for extended periods, driving the process to 100% CPU and effectively freezing the entire application, yielding a denial of service with no confidentiality or integrity impact. Any Node.js service running a vulnerable Nodemailer version that parses attacker-controlled address lists (such as inbound email headers or user-supplied recipient lists) is affected. Exploitation has not been observed: the issue is not in CISA KEV and no public proof-of-concept is known.

Do: Upgrade to Nodemailer 9.1.0 or later. Until patched, cap the number and length of addresses accepted per message, avoid passing untrusted email headers or user-supplied recipient lists into address parsing, and rate-limit or isolate email-parsing workloads (e.g., worker processes with hang detection/restart) so a stall cannot freeze the main service. Audit your codebase and dependencies to determine whether attacker-controlled input reaches Nodemailer's address parser.

Craft CMS 5.0.0-RC1 through versions before 5.11.0 gate the GraphQL draftCreator and revisionCreator fields with only the elements.drafts:read or elements.revisions:read scopes instead of the user-data scope (usergroups.*:read) enforced by Gql::canQueryUsers(), and the resolver returns a raw User element with no per-field authorization. Any client holding just the drafts or revisions scope — or an unauthenticated client, if the operator has enabled the public GraphQL schema with those scopes — can query these fields and harvest the email addresses, usernames, full names, and postal addresses of all draft and revision creators, typically site editors and administrators. No privilege escalation or code execution is involved; the impact is confidentiality of user PII (CWE-200), consistent with the 8.7 high CVSS 4.0 score. All sites running the affected Craft CMS 5.x range are vulnerable in principle, with actual exposure depending on whether a GraphQL schema (public or token-based) grants the drafts or revisions scopes. No public proof-of-concept is known, the flaw is not in CISA's KEV catalog, and no exploitation has been reported; a fix is available in Craft CMS 5.11.0.

Do: Upgrade to Craft CMS 5.11.0, which fixes the field-level authorization. Until then, remove the elements.drafts:read and elements.revisions:read scopes from the public GraphQL schema and from any API tokens that don't need them, and audit existing GraphQL schemas/tokens for those grants. Check GraphQL access logs for queries requesting draftCreator or revisionCreator fields to detect past PII harvesting.

Craft CMS 5.10.0 through 5.10.12 contain an incomplete fix for CVE-2026-55794: the control-panel redirect handler (Controller::getPostedRedirectUrl()) still feeds attacker-influenced input into the unsandboxed View::renderObjectTemplate() sink. Because Craft/Yii HMAC tokens are not bound to a parameter name, and the same fix commit introduced a self-signing oracle in Cp::elementLabelHtml(), an authenticated low-privilege control-panel user with edit rights on just a single element type can mint a valid token over attacker-controlled Twig for the returnUrl parameter and replay it as the redirect POST parameter. Reaching the unsandboxed sink yields server-side template injection that executes arbitrary PHP code, resulting in full server compromise. Any Craft CMS deployment running 5.10.0-5.10.12 is affected, including sites where untrusted users hold edit permission on any one element type. No public proof-of-concept is known and the flaw is not in CISA's KEV, so exploitation has not been confirmed.

Do: Upgrade to Craft CMS 5.10.13 or later immediately. Until patched, restrict control-panel access to trusted users and review accounts with element edit permissions, since edit rights on a single element type are sufficient to exploit. Check logs for unusual returnUrl/redirect token replay and inspect the host for signs of unexpected PHP execution or webshells.

CVE-2026-92592 is a signature-purpose-confusion flaw in Craft CMS 4.8.0 through 4.18.5 and 5.0.0 through 5.10.12: the license-shun cookie and signed redirect parameters are validated with the same HMAC key and format (Yii's cookieValidationKey derived from the shared Craft securityKey), so a signature minted for one purpose is accepted for the other. An authenticated non-administrator user (Control Panel access is not required) can obtain a signed cookie via the license-shun endpoint and transplant that signed envelope into a redirect parameter; on a subsequent successful login, Craft validates the signature and renders the authenticated bytes as an unsandboxed Twig template, where Twig's map filter accepts a string callback that permits calling PHP system(). A successful attacker thereby executes arbitrary operating-system commands as the web-server user on the CMS host. Exploitation requires an account using password authentication without active 2FA, the default request configuration, and availability of PHP system(). No public proof-of-concept is known, the flaw is not in CISA's KEV, and there is no confirmed in-the-wild exploitation.

Do: Upgrade to Craft CMS 4.18.6 or 5.10.13 (or later) on all affected 4.x and 5.x installations. As interim mitigation, enforce 2FA on every account (active 2FA blocks this path), consider removing system() and similar functions via PHP's disable_functions, and audit for unexpected accounts plus review login and redirect activity for signs of license-shun cookie tampering.

Craft CMS 5.0.0 through 5.10.12 treats a database connection failure as meaning Craft is not installed, which makes anonymous installer actions — including install/validate-site — reachable on already-installed production sites whenever PHP is still serving requests but the configured MySQL endpoint is unreachable. The installer accepts a site name that is serialized through Site::getName() and expanded via App::env(), so an unauthenticated attacker can submit a predictable variable name such as CRAFT_SECURITY_KEY and receive its value. A successful attempt discloses Craft secrets, process environment variables, $_SERVER entries, or PHP constants, potentially including the application security key, database credentials, or API keys. Exploitation requires an independently occurring database outage plus a guest session cookie and matching CSRF token obtained beforehand and still valid during the outage, so every Craft 5.x site running 5.0.0–5.10.12 carries the flaw but only those hit by an outage in such a window are concretely exposed. There is no public proof-of-concept, no known in-the-wild exploitation, and the issue is not listed in CISA KEV; it is fixed in 5.10.13.

Do: Upgrade to Craft CMS 5.10.13 or later. Where immediate upgrade is not possible, treat any database outage as a security window: invalidate guest sessions and rotate CSRF state after outages, and block unauthenticated access to installer actions such as install/validate-site at the web server or application firewall. After any outage, review access logs for requests to installer endpoints and rotate the security key and any database or API credentials that could have been exposed.

WWBN AVideo through 29.0 (commit e01e41ecc) is vulnerable to cross-site request forgery in objects/videoAddNew.json.php, which disables the platform's automatic CSRF guard and its untrusted/same-domain request check whenever 'user' and 'pass' parameters are present in the request, without ever validating them. An attacker can host a crafted page that, when visited by an authenticated user, submits cross-origin requests with these dummy parameters to modify video records. The attacker can transfer video ownership, delete user-group access restrictions on private content, and alter settings such as can_download, can_share, only_for_paid, video_password, status, rating, creation date, and view counts; if the victim has administrator or canAdminVideos() rights, any video on the site can be manipulated. Any site running an affected AVideo version whose authenticated users with upload rights can be lured to an attacker-controlled page is exposed. No public proof-of-concept, KEV listing, or patched release was available at the time of the advisory.

Do: No fixed version exists yet, so monitor the WWBN/AVideo repository for an updated release and patch as soon as one is published. In the interim, mitigate at the web server or WAF by rejecting cross-site requests (Origin/Referer allow-listing) to objects/videoAddNew.json.php, or patch the code to remove the skipAutoCSRFCheck/bypassSameDomainCheck bypass for user/pass parameters. Review logs for videoAddNew.json.php requests containing user/pass query-string parameters, and audit recent changes to video ownership, group restrictions, and privacy settings (can_download, can_share, only_for_paid, video_password) for signs of tampering.

AVideo through 29.0 contains a stored OS command injection (CWE-78) in the CloneSite plugin: cloneClient.json.php builds the command 'sshpass -p <password> rsync ...' with a plain str_replace and no shell escaping, so a single quote in the stored SSH password breaks out of the quoted argument and injects arbitrary shell commands. The password is saved through the admin-only objects/pluginAddDataObject.json.php endpoint, whose only CSRF defense is a no-op when requests appear to originate from loopback (e.g., behind a same-host TLS-terminating reverse proxy with $global['trustedProxies'] unset) or when an attacker-controlled application is co-hosted on the same hostname; on HTTPS the session cookie is SameSite=None, so a cross-site POST carries the admin's session. An unauthenticated attacker who lures a logged-in administrator into saving a malicious SSH password (and an attacker-controlled cloneSiteURL) gains arbitrary command execution when the plugin's documented crontab entry runs, with the privileges of the crontab owner (commonly root or www-data). Only deployments with the CloneSite plugin enabled and its crontab installed are exploitable, and default single-process Apache deployments are reported as not CSRF-exploitable. The flaw is confirmed at master HEAD (commit 8963b6a1); no public PoC is known, it is not in CISA KEV, and no patched version is available.

Do: No patched release exists yet, so disable the CloneSite plugin and remove its crontab entry unless strictly required. Otherwise restrict access to objects/pluginAddDataObject.json.php and plugin/CloneSite/cloneClient.json.php, set $global['trustedProxies'] correctly so the loopback CSRF bypass does not trigger, and reject single quotes or shell metacharacters in the stored SSH password. Because the injected command runs as the crontab owner (often root or www-data), monitor those accounts and audit recent crontab-driven CloneSite activity for tampering.

WWBN AVideo, a self-hosted open-source video streaming platform, accepts the stored users.password hash value itself as a valid login credential. Because two independent code paths — loginFromRequest() and encryptPasswordVerify() — verify a submitted credential by comparing it against the stored hash rather than the original password, an attacker who submits the hash directly to login endpoints authenticates as any user. Practical exploitation therefore requires the attacker to first obtain a user's stored hash, typically through a secondary flaw such as SQL injection, file exposure, or log leakage, which the CVSS 4.0 'AT:P' (attack requirements present) score component reflects. Any AVideo deployment running version 29.0 or earlier is affected, with internet-facing instances most at risk. No public proof-of-concept, inclusion in CISA KEV, or confirmed in-the-wild exploitation is currently known.

Do: Upgrade AVideo to a release newer than 29.0 as soon as the vendor publishes a fix, and monitor the vendor's repository for the patched version. Until patched, prevent hash disclosure — remediate any SQL injection or file/log exposure issues, restrict access to login endpoints, and rotate passwords for accounts whose hashes may have leaked. Because the hash itself acts as a credential, treat any confirmed hash exposure as a full account compromise and review authentication logs for logins submitted with hash-like strings.

AVideo through version 29.0 contains a broken access control flaw (CWE-639) in the get_api_video API endpoint, specifically in its clean_title branch. An unauthenticated attacker can look up any video by its publicly visible slug, causing the endpoint to skip user-group authorization checks and return videos that should be restricted to members of specific groups. The response also leaks sensitive fields about the video owner, including email address, phone number, physical address, birth date, and whether the account is an administrator. Any AVideo deployment running version 29.0 or earlier with the API reachable (the default configuration) is affected, and the confidentiality-only impact makes it useful for reconnaissance and PII harvesting. No public proof-of-concept is known, the issue is not in CISA's KEV catalog, and there are no confirmed reports of exploitation so far.

Do: Upgrade AVideo to the latest release from the vendor (anything newer than 29.0) as soon as a patched build is available. Until then, restrict unauthenticated access to the get_api_video API endpoint (e.g., via a WAF or reverse-proxy rule) and review server logs for anonymous requests to get_api_video referencing video slugs, which would indicate probing. Audit which videos are restricted to user groups and assume owner account details may have been exposed if such requests are found.

HKUDS nanobot before 0.3.0 contains a server-side request forgery (CWE-918) in its WebFetchTool component: the _validate_url() function fails to block internal IP ranges, private (RFC 1918) addresses, and loopback targets. An attacker who can send messages to the bot simply instructs it to fetch URLs such as the cloud metadata endpoint (169.254.169.254), localhost services, or internal network addresses, and the tool performs the requests and returns the responses. This lets the attacker harvest IAM/cloud credentials from the metadata service and read data from internal services reachable from the host running the bot, with no privileges or user interaction required (CVSS 4.0 9.2 critical). Anyone running an affected version of nanobot with WebFetchTool enabled and reachable by untrusted message input is affected. There is currently no evidence of in-the-wild exploitation and no public proof-of-concept is known.

Do: Upgrade nanobot to version 0.3.0 or later, which fixes the URL validation in WebFetchTool. If upgrading is not immediately possible, restrict who can send messages that trigger web fetches and apply network-level controls so hosts running nanobot cannot reach 169.254.169.254, localhost, or RFC 1918 ranges (e.g., metadata endpoint firewalling and egress filtering). Review cloud and proxy logs for unexpected requests to metadata or internal addresses originating from hosts running nanobot.

The TCH QRing smart ring model R20_B006 running firmware RT09R20_1.00.00_250318 exposes a Nordic UART Service over Bluetooth Low Energy that enforces no client authentication or command authorization (CWE-306, missing authentication for critical function). Any attacker within BLE range can connect directly to the ring without pairing, authentication, or user approval, bypassing the official companion app and cloud authentication entirely. Once connected, the attacker can read the battery level, activate live heart rate monitoring, and retrieve stored historical heart rate and blood oxygen records, yielding a high confidentiality/privacy impact with no integrity or availability impact. All wearers of this model on the affected firmware are exposed whenever the ring is powered and within Bluetooth range; there is no known public proof-of-concept, no CISA KEV listing, and no confirmed exploitation.

Do: Check the firmware version in the companion app and apply a patched firmware from TCH when one becomes available (no fixed version was identified in this disclosure). Until then, power the ring off when not in use and be aware that any Bluetooth device within roughly 10 meters can silently read its health data without consent. This is a local, proximity-based privacy exposure, so remote detection and network-level mitigations do not apply.

CVE-2026-85469 is a CI/CD supply-chain weakness (CWE-1357) in the release workflow for quay-builder-qemu, the QEMU-based build image used by Red Hat Quay / Project Quay's container build feature. The workflow invokes the third-party GitHub Action Noelware/docker-manifest-action pinned to a mutable branch instead of an immutable commit, so an attacker who compromises that upstream action can inject arbitrary code into the release workflow. With code execution in the workflow, the attacker can exfiltrate the registry credentials used to publish quay-builder-qemu images, publish trojanized images to downstream users, and abuse the exposed default GITHUB_TOKEN to further tamper with the repository. Affected parties are organizations that pull or run quay-builder-qemu images as part of Quay's builder feature; the CVSS vector (AV:N/AC:H/PR:H/S:C) reflects that exploitation requires first compromising the upstream action but then crosses trust boundaries. No public proof-of-concept, CISA KEV listing, or confirmed in-the-wild exploitation is known.

Do: Pin Noelware/docker-manifest-action (and all workflow actions) to a full-length immutable commit SHA, set GITHUB_TOKEN permissions to the minimum required, and rotate any registry credentials accessible to the release workflow. Verify the digests/signatures of quay-builder-qemu images currently in use and monitor Red Hat / Project Quay security advisories for updated builder images, as no fixed version is identified in the available data.

ComfyUI before 0.30.0 fails to sanitize the folder_name parameter in its dataset save nodes, allowing path traversal (CWE-22) so that files can be written to arbitrary locations outside the intended output directory. An attacker triggers the flaw by crafting a malicious workflow that the victim loads, which requires user interaction but no privileges. By writing attacker-controlled content to sensitive locations, the attacker can achieve code execution through modified startup files or package initializers. Anyone running an affected ComfyUI version who loads workflows from untrusted sources is at risk, which is significant given ComfyUI's large community of shared workflows. No public proof-of-concept is known, the issue is not in CISA KEV, and exploitation has not been observed in the wild.

Do: Upgrade ComfyUI to 0.30.0 or later. Treat workflow files from untrusted or community sources as untrusted input, and audit systems for unexpected files written outside the output directory as well as tampered startup scripts or package __init__ files. Where immediate patching is not possible, avoid loading third-party workflows on affected versions.

changedetection.io through version 0.60.6 contains a server-side request forgery flaw (CWE-918) because the Goto URL action in browser steps is not validated. An unauthenticated remote attacker can supply an arbitrary internal URL in the optional_value parameter of a browser step, causing the application's headless browser to fetch that location and return the response. This allows the attacker to read content from restricted network locations reachable by the server, such as cloud metadata endpoints or internal-only services, with high confidentiality impact and no integrity or availability impact per the CVSS 4.0 score of 8.7. Anyone running a self-hosted changedetection.io instance at version 0.60.6 or earlier is affected, especially instances reachable from untrusted networks. No public proof-of-concept or confirmed in-the-wild exploitation is known, and the issue is not listed in CISA KEV.

Do: Upgrade to the latest changedetection.io release as soon as a patched build beyond 0.60.6 that validates the browser-step Goto URL action is available. In the interim, restrict access to the instance (require authentication via reverse proxy or firewall rules) and block browser-step egress to link-local and RFC1918 ranges, including 169.254.169.254. Check instance logs for requests carrying internal URLs in the optional_value parameter as an indicator of probing.

decap-server, the npm-based local backend proxy used with Decap CMS (formerly Netlify CMS) local development workflows, enforces its repository-root containment with a plain string prefix comparison that does not validate path separators. As a result, paths pointing to sibling directories whose names merely begin with the repository directory's name (for example, 'myrepo' versus 'myrepo-backup') pass the containment guard and are treated as in-bounds. An attacker who can reach the proxy and satisfies the required conditions can read, write, or delete files in those sibling directories, with high confidentiality and integrity impact but no availability impact per the CVSS 4.0 vector (7.6, High; network vector, high complexity, no privileges). Anyone running decap-server is affected — typically developers or teams using the Decap CMS local_backend feature — with risk highest where the server is reachable beyond strict localhost or where sensitive directories share the repository's name prefix. No public proof-of-concept is known and the issue is not in CISA KEV, so no exploitation has been reported.

Do: Upgrade decap-server as soon as a patched release is published, since no fixed version is identified in the advisory data. Until then, avoid running it on hosts containing sensitive sibling directories, keep it bound to localhost or behind a firewall/VPN, and audit for directories whose names share the repository name's prefix (e.g., 'myrepo' and 'myrepo-archive') adjacent to the served repository.

browserless versions 1.44.0 through 2.56.7 fail to enforce file protocol restrictions in their Playwright websocket endpoints, allowing any authenticated token holder to read arbitrary files from the server. An attacker who possesses a valid connection token connects to the Playwright websocket and instructs the headless browser to navigate to file:// URLs, exfiltrating the contents of files accessible to the container process. This works even though the ALLOW_FILE_PROTOCOL setting defaults to false, meaning the security control is not actually enforced on the vulnerable endpoints. Any deployment of the affected versions that issues tokens to third parties, partners, or shared automation users is affected, which is a common pattern for browserless-style scraping and PDF-generation services. No public proof-of-concept, in-the-wild exploitation, or KEV listing is known.

Do: Upgrade browserless to a release newer than 2.56.7 that enforces the file protocol restriction. Until patched, avoid issuing websocket tokens to untrusted clients, restrict network access to the Playwright websocket endpoints, and run the container with minimal filesystem read permissions. Review service logs for browser navigations to file:// URLs, which would indicate attempted abuse.

phpList versions before 3.6.17 contain a cross-site request forgery (CSRF) flaw (CWE-352) in the mass subscriber removal form handler, which fails to validate anti-CSRF tokens. An attacker can host a crafted web page and, when a logged-in phpList administrator visits it, silently trigger requests that delete and blacklist arbitrary subscriber addresses using the admin's authenticated session. The impact is loss of mailing-list integrity: victims' subscribers can be removed en masse and blacklisted, damaging list deliverability and requiring manual restoration. Any self-hosted phpList deployment running a version prior to 3.6.17 whose administrator browses other sites while logged in is affected. No public proof-of-concept is known and the flaw is not listed in CISA's KEV, so exploitation has not been confirmed.

Do: Upgrade phpList to version 3.6.17 or later, which restores CSRF token validation on the mass subscriber removal handler. Until upgraded, administrators should avoid browsing untrusted websites while logged into the phpList admin interface, and log out when idle. Review the subscriber list and blacklist for unexplained removals or blacklisted addresses that could indicate abuse.

UVdesk Community Skeleton through version 1.1.8 does not authenticate requests or verify that installation has already been completed on wizard endpoints exposed by the ConfigureHelpdesk controller (CWE-306, missing authentication for critical function). An unauthenticated remote attacker can submit crafted requests to these endpoints to repoint the application's database connection and create a new super administrator account. With a super admin account (and possibly control of the datastore), the attacker gains full control of the helpdesk instance, including tickets, customer data, and further access into the hosting environment. Any organization running a self-hosted UVdesk Community Skeleton instance at version 1.1.8 or earlier is affected, particularly instances reachable from the internet. As of this analysis there is no public proof-of-concept, no CISA KEV listing, and no confirmed exploitation in the wild, but the flaw is trivially exploitable with simple HTTP requests, so attackers could weaponize it quickly once disclosed.

Do: Upgrade UVdesk Community Skeleton to a version newer than 1.1.8 as soon as a patched release is available, and until then block or require authentication for the installer/wizard routes (ConfigureHelpdesk controller endpoints) at the web server or reverse proxy. Review application logs for unauthenticated POST requests to wizard/installer paths, check the configuration for unexpected database host changes, and audit member/admin accounts for super administrators you did not create. If a rogue super admin or altered database configuration is found, rotate all credentials and treat tickets and stored data as compromised.

Nango through version 0.70.4 fails to validate caller-supplied connection configuration values that are interpolated into provider token endpoints and proxy URL templates, resulting in server-side request forgery (CWE-918). An authenticated attacker with low-privileged access can submit crafted configuration values that cause the Nango server to send requests to attacker-chosen internal addresses or cloud metadata endpoints. Successful abuse can leak internal service responses and potentially exfiltrate stored provider credentials such as OAuth tokens. Any deployment running Nango version 0.70.4 or earlier is affected, with self-hosted instances bearing the greatest risk. No public proof-of-concept is known, the flaw is not in CISA KEV, and exploitation has not been observed.

Do: Upgrade Nango to a release newer than 0.70.4 once a patched version is available, and audit existing connection configurations for unexpected hostnames or URLs. Restrict which API credentials can create or modify connections and apply egress filtering on the Nango server, particularly blocking link-local cloud metadata addresses such as 169.254.169.254. Rotate stored provider credentials if suspicious connection configs or unexplained outbound requests are found.

cc-connect through version 1.5.0 fails to apply per-user allowlist filtering in the onCardAction handler that processes Feishu (Lark) interactive card callbacks, even though the plain text message handler does enforce these access controls. An attacker who can trigger card actions inside a chat where the bot has been admitted can dispatch agent commands that the bot executes, bypassing the per-user access controls entirely. Because the dispatched commands run through the connected agent, the flaw carries high confidentiality, integrity, and availability impact (CVSS 4.0 score 8.7) while requiring only low privileges and no user interaction. Anyone running cc-connect 1.5.0 or earlier as a Feishu bot with interactive card callbacks enabled is affected. No public proof-of-concept is known and the flaw is not listed in CISA KEV, so exploitation is not currently known to be occurring.

Do: Upgrade cc-connect to a release newer than 1.5.0 that enforces the per-user allowlist in the onCardAction handler as soon as a fixed version is available. As an interim mitigation, restrict or disable interactive card actions in admitted Feishu chats, and audit bot logs for agent commands triggered via card callbacks from users who are not on the allowlist.

Docs before 5.4.1 fails to terminate established WebSocket collaboration sessions when a user's access is revoked at the parent document level (CWE-613, improper session expiration). The flaw is triggered when an administrator revokes a user's access to a parent document while that user still holds open WebSocket connections to its sub-documents; those connections are never disconnected. Because the CVSS 4.0 vector rates attack complexity high with present attack requirements (AC:H/AT:P) and low privileges required, the revoked user must generally have an active session at the moment access is cut, but once that condition holds they retain real-time read and write access to the sub-documents indefinitely. Any deployment running an affected version that uses WebSocket-based collaboration with hierarchical parent/sub-document permissions is exposed. No public proof-of-concept, CISA KEV listing, or in-the-wild exploitation is currently known.

Do: Upgrade to Docs 5.4.1 or later. As an interim mitigation, restart the WebSocket/collaboration service after revoking a user's parent-document access to force stale sessions to close, and audit logs for reads or edits performed by recently de-provisioned users. When revoking access, verify that the user's sub-document sessions are actually terminated rather than left open.

Manticore Search versions 27.0.0 before 28.4.4 contain an incorrect authorization flaw (CWE-863): permission checks are only applied to the first statement of a multi-statement SQL request, so any additional statements are executed without validation. A user holding only read-only privileges can trigger the flaw by appending extra SELECT statements to a single multi-statement request and reading data the account is not authorized to see. By chaining this bypass against credential tables, the attacker obtains administrator password hashes that Manticore accepts directly for authentication, yielding admin-level access without ever recovering a plaintext password. Any Manticore Search deployment in the affected range that exposes its SQL interface to low-privileged users is impacted. No public proof-of-concept is known, the flaw is not in CISA's KEV, and there are no confirmed reports of in-the-wild exploitation.

Do: Upgrade to Manticore Search 28.4.4 or later. Until patched, restrict the SQL and HTTP interfaces to trusted networks, minimize the number of read-only accounts, and review logs for multi-statement requests containing extra SELECTs against credential tables; rotate administrator credentials if unauthorized queries are found.

Coze Studio through 0.5.1 fails to restrict the server URL supplied when registering plugin tools, an SSRF flaw (CWE-918). Any authenticated user can register a plugin tool pointing at an arbitrary URL, causing the backend server to fetch it and return the response to the attacker. Because the request originates from the trusted backend network, an attacker can reach cloud metadata endpoints (e.g., instance metadata services) and internal-only services, harvesting potentially sensitive data such as credentials. Any self-hosted Coze Studio deployment at version 0.5.1 or earlier that permits untrusted users to register plugins is affected. No public proof-of-concept or in-the-wild exploitation is known, and the issue is not listed in CISA KEV.

Do: Upgrade Coze Studio to a release newer than 0.5.1 that validates or allowlists plugin server URLs as soon as one is available. Interim mitigations: restrict which authenticated users can register plugin tools, and block backend egress to cloud metadata endpoints (e.g., 169.254.169.254) and internal network ranges. Review existing plugin registrations and backend access logs for requests to metadata or internal services.

OpenSign through 2.41.3 contains a missing-authorization flaw (CWE-862) in its getDocument cloud function, which fails to validate the caller's identity when one-time-password verification is disabled. An unauthenticated attacker who obtains a document identifier, for example from a shared guest signing link, can invoke the function and retrieve complete document details including all signers' information, the sender's identity, and valid download tokens. Because the tokens are valid for download, the attacker can likely retrieve the document contents themselves, though there is no integrity or availability impact. Any OpenSign deployment, self-hosted or cloud, that uses guest signing links with one-time-password verification disabled is affected. No public proof-of-concept or in-the-wild exploitation is currently known, and the flaw is not listed in CISA KEV.

Do: Upgrade OpenSign to a release newer than 2.41.3 as soon as a patched version is published, and until then enable one-time-password verification for guest signing so the getDocument function enforces caller identity. Restrict direct access to the underlying cloud-function API, treat guest signing links and document identifiers as sensitive, and rotate or revoke download tokens for confidential documents if exposure is suspected.