Unauthenticated attackers can create WordPress user accounts on sites running the Easy Form Builder by WhiteStudio plugin in versions 4.0.0 through before 4.2.0, even when the site owner has deliberately disabled user registration. The plugin fails to validate a submitted value against its stored configuration for certain form types (CWE-284, improper access control), so the registration-disabled setting is bypassed via a remote, unauthenticated request requiring no user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, 5.3). Publicly available exploit code exists for this issue, but it is not confirmed as actively exploited (not in CISA KEV); the realistic impact is bounded by the site's default new-user role, typically Subscriber, and updating to 4.2.0 fully removes the flaw.
Unauthenticated remote code execution affects HGiga's OAKlouds Custom Page module in the 2.0, 3.0 and 4.0 lines at builds below 26, where an attacker who can reach the Custom Page endpoint can submit malicious serialized content and have it deserialized into arbitrary code running with the web service's privileges. The CVSS 4.0 score of 9.3 reflects the worst case for an unauthenticated network attacker (PR:N, UI:N, AT:N, high confidentiality, integrity and availability impact on the vulnerable system), and the practical limiter is exposure - whether the affected instance is reachable from untrusted networks - rather than any technical precondition. No public exploit code has been identified at time of analysis and the flaw is not currently listed as confirmed actively exploited (CISA KEV), but the low attack complexity, unauthenticated access and full-system impact make this a genuinely high-priority issue for any organization running the affected builds, and a vendor fix is available.
Data disclosure and permanent record deletion in Mongoid can be triggered by an unauthenticated remote attacker when an application passes an externally supplied field name to certain in-memory query methods for embedded documents, exploiting an unsafe reflection weakness (CWE-470). The vendor CVSS 4.0 base score of 9.2 reflects the network vector and high impact across confidentiality, integrity, and availability, though the attack requires a developer-dependent data flow (AT:P) where untrusted input reaches a field name parameter. No public exploit code or active exploitation has been identified at time of analysis, and affected/fixed versions remain unconfirmed due to an unbounded CPE (mongoid:*).
Authentication bypass in IBM Sterling File Gateway lets a remote, unauthenticated attacker forge or inject an unvalidated SSO header and obtain a fully authenticated session on the gateway's web interface. The flaw is rated CVSS 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N) because no credentials, privileges, or user interaction are required, and a successful bypass yields high confidentiality and integrity impact over file-transfer workflows. No public exploit identified at time of analysis, but exploitation is trivial for anyone who can reach an SSO-header-enabled deployment, so internet-exposed instances should be treated as high priority; IBM has published a fix advisory.
SQL injection in IBM Guardium Data Protection 12.2 allows a remote attacker who already holds a valid low-privilege session to execute arbitrary SQL commands against the appliance's backend database by supplying crafted input to a request parameter that is not properly neutralized before being used in a SQL statement. IBM rates this CVSS 9.1, driven by a high confidentiality impact on a platform whose core function is monitoring and protecting sensitive databases, though exploitation prerequisites are meaningful: the attacker must be authenticated (CVSS vector PR:L), needs network reach to the management interface, and only version 12.2 is named as affected. There is no CISA KEV listing and no public exploit code identified at time of analysis, so risk is concentrated in environments where low-privilege credentials can be obtained or are broadly distributed, and a vendor patch is available.
Ultraviolet CoCoS through version 0.8.2 contains a session-misbinding flaw in the intra-handshake attested TLS (aTLS) verification path for Intel TDX: the verifier fails to copy the expected current-session freshness value into the TDX quote-body policy before quote validation, so any structurally valid TDX QuoteV4 Evidence is accepted without checking that its REPORT_DATA field matches the reportData expected for that session. An unauthenticated remote counterparty (CVSS vector AV:N/PR:N) that can supply or relay such a quote - acting as the attesting party or replaying a previously captured or foreign quote - can therefore cause a relying party to release application data bound to an unintended attestation context, giving high confidentiality and integrity impact. No public exploit code and no confirmed in-the-wild exploitation were identified at time of analysis, and the vendor's 9.1 score (AV:N/AC:L) slightly overstates ease of exploitation versus our assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N, since a valid TDX quote and use of the affected TDX aTLS branch are prerequisites. The issue is fixed in version 0.9.0.
Process Compose before 1.120.0 exposes its MCP SSE listener on loopback without validating the Host or Origin header or authenticating the caller, allowing a malicious website to reach that listener through DNS rebinding and issue MCP requests. Unauthenticated remote attackers (CVSS 4.0 PR:N, UI:P) can, when expose_control_tools is enabled, enumerate process state, read, search or truncate logs, and start, stop, restart or scale local processes; user-defined tools may expose further commands and output. Publicly available exploit code exists (SSVC Exploitation: poc), no active exploitation is confirmed (no CISA KEV listing), and the issue is fixed in 1.120.0.
An attestation-freshness and origin-validation failure in the aTLS AMD SEV-SNP verification path of Cocos AI (Ultraviolet) affects versions up to and including 0.8.2: when a relying party invokes the intra-handshake verification path with no expected reportData value (nil, empty, or omitted), the SEV-SNP policy ReportData is left unset and the verifier will accept unrelated or stale Evidence that is not bound to the current TLS connection. An attacker who possesses a valid but foreign or replayed SEV-SNP attestation blob can therefore induce a trusting party to accept an unintended attestation context, undermining the core trust guarantee of the confidential-computing platform and potentially enabling both integrity and confidentiality compromise in any workflow where aTLS output drives a trust or authorization decision. Exploitation is unauthenticated at the network layer (CVSS PR:N) but constrained by high attack complexity and specific prerequisites - the caller must omit the expected reportData, and only SEV-SNP aTLS deployments up to 0.8.2 are exposed; no public exploit code or confirmed active exploitation has been identified at time of analysis. The issue is fixed in version 0.9.0.
An attacker-supplied Truevision TGA image can force the Perl Imager module (versions before 1.036) to kill the entire hosting process: a colour map length of 32768 or more is read into a signed short, becomes negative, is cast to size_t, and turned into a near-SIZE_MAX allocation request that fails and makes Imager's allocator call exit(3). Exploitation requires only that the application pass untrusted image bytes to Imager->read() with TGA handling (explicit type 'tga' or auto-detection) - the CVSS vector is PR:N, so no authentication is needed, and the exit(3) is uncatchable, meaning Perl eval and Try::Tiny handlers cannot trap it and a single malicious file terminates the worker, request handler, or CLI process. Publicly available exploit code exists per the SSVC assessment (exploitation: poc), but the input does not record confirmed active exploitation (CISA KEV); the vendor CVSS of 9.1 (C:H/I:N/A:H) is overstated, since the independently assessed vector is C:N/I:N/A:H - this is a pure denial-of-service condition with no code execution, memory corruption, or data disclosure.
OS command injection in the web management server of PLANET IGS-5225-8P2T4S industrial managed switches lets a remote, low-privilege authenticated attacker run arbitrary operating-system commands and obtain root on the device. Only switches running V1 firmware before 1.2412b260707 or V2 firmware before 2.2412b260519 are affected; patched builds from the vendor address the flaw. Exploitation requires network reachability to the switch's web interface plus valid credentials (PR:L), so exposure is limited to segmented OT/industrial networks where the management UI is reachable; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV, though the high EPSS-relevant characteristics of authenticated command injection in edge/OT devices make prompt patching advisable.
Script injection in IBM Guardium Data Protection 12.2 allows a remote authenticated attacker with low-privileged web credentials to inject unsanitized input into web-generated pages, which then executes as JavaScript when another user views the affected page. The independent assessment treats this as a client-side cross-site scripting issue requiring victim interaction, with low confidentiality and integrity impact in the browser/session context and no availability impact, rather than host operating system code execution despite the vendor description's 'arbitrary code' phrasing. No public exploit was identified at time of analysis, and a vendor patch is available from IBM.
Physical-access arbitrary code execution on Carecam HMT.CM2507 IP cameras, where firmware automatically runs a predetermined script from attached removable media without verifying its authenticity or integrity. An attacker who can reach the camera's SD/USB interface and insert crafted media can execute code in the device's security context, achieving high confidentiality, integrity and availability impact; the assessed CVSS 3.1 vector (AV:P/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) reflects that no credentials or user interaction are needed once physical access is obtained, and that this is the primary limiting factor since there is no network-facing path to the flaw. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV - exploitation requires an attacker with hands-on access to the hardware.
Command injection in NUUO Network Video Recorder 2.0.0 lets remote, unauthenticated attackers (PR:N per the CVSS vector) execute arbitrary OS commands through the handle_import_privilege.php endpoint, although the CVSS UI:R metric indicates that some user interaction is required to trigger the flaw. The vendor software passes unsanitized input to an OS command (CWE-77), and SSVC rates the issue as automatable with total technical impact; publicly available exploit code exists via a referenced public gist, but there is no evidence of confirmed active exploitation (CISA KEV). Because NVRs are frequently internet-exposed, this is a genuine high-priority issue for any deployment of version 2.0.0.
Cross-site scripting in IBM Guardium Data Protection 12.2 lets an authenticated user with access to the management interface inject script that executes in the browser of another logged-in user who views the poisoned page, enabling session theft or actions performed with the victim's privileges. The vendor rates this CVSS 8.9 (High) with scope change, but the CWE-79 classification and the assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N) identify it as an input-neutralization/XSS flaw rather than the remote code execution implied by some tagging; exploitation requires a valid account (PR:L, authenticated) plus victim interaction (UI:R) and does not work unauthenticated. No public exploit code and no CISA KEV listing were identified at time of analysis, and the vendor has published a patch advisory, so risk is real but constrained by the authentication and user-interaction prerequisites.
Cross-site scripting in IBM Guardium Data Protection 12.2 allows an attacker holding valid low-privilege web interface credentials to inject content that executes scripts in a second, typically higher-privileged user's browser session when that user views the improperly neutralized page. Although the vendor description and the 'RCE' tag suggest arbitrary code execution, CWE-79 (improper neutralization of input during web page generation) and the assessed vector restrict impact to the victim's browser session in the web application's security context, not native code execution on the appliance, and exploitation requires both authenticated access and victim interaction. No public exploit code and no confirmed active exploitation were identified at time of analysis, and IBM has published a patch advisory at https://www.ibm.com/support/pages/node/7288035.
Cross-site scripting (CWE-79) in IBM Guardium Data Protection 12.2 allows an authenticated remote user to supply crafted input to the web management console that is later rendered by a second, separate user's browser, executing attacker-controlled script in that victim's session. Exploitation requires two distinct conditions - a valid Guardium account to plant the payload and a privileged victim who loads the affected page - so it is not self-executing and cannot be triggered before authentication; despite the vendor description's reference to 'arbitrary code', the demonstrated impact is bounded to client-side script execution within the victim's browser session (session/token theft, forged UI actions, data exfiltration from the console), not server-side command execution. No public exploit code has been identified at time of analysis, there is no CISA KEV listing, and the vendor's 8.9 CVSS score overstates real-world risk relative to the assessed vector (PR:L/UI:R, confidentiality and integrity impact limited, no availability impact).
Authenticated command injection in IBM Cloud Pak for Data 5.1.2 lets a network-reachable, low-privileged user run arbitrary operating-system commands with elevated privileges on the underlying system. The flaw is an improper-neutralization-of-special-elements issue (CWE-78) in how user-supplied input is validated before being passed to a shell, and it rates CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning full loss of confidentiality, integrity and availability on the affected host once the attacker has any valid account. IBM has published a fix via its support advisory; no public exploit code has been identified at the time of analysis and there is no confirmation of active exploitation (CISA KEV).
Authenticated OS command injection in IBM Guardium Data Protection 12.2 lets a user holding only low-privilege console credentials execute arbitrary operating-system commands on the affected appliance through the exportCertificate functionality, resulting in full loss of confidentiality, integrity, and availability (CVSS 3.1 base score 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Because the attack requires valid credentials and network reachability to the Guardium management interface, it is not usable by unauthenticated outsiders; CISA's SSVC assessment records Exploitation as 'none' and Automatable as 'no', and no public exploit code has been identified at time of analysis. EPSS is 0.63 percent (49th percentile), consistent with a targeted, credentialed issue rather than a broadly exploited one, and IBM has published a vendor patch.
IBM MQ queue managers that process XA (X/Open distributed) transactions are vulnerable to a memory-corruption buffer overflow triggered when a malformed XA transaction identifier (XID) is parsed, allowing an authenticated attacker with network access to crash the queue manager and potentially execute arbitrary code in its context. Exploitation requires valid credentials and the ability to drive XA transaction operations over an MQ channel (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, vendor score 8.8), so the reliably achievable outcome is denial of service while code execution remains a potential, not guaranteed, consequence. There is no public exploit identified at time of analysis and no confirmed active exploitation, but a vendor patch is available and the low attack complexity combined with the complete loss of confidentiality, integrity and availability impact makes prompt remediation important.
Integer overflow (CWE-190) in IBM MQ distribution list processing lets an authenticated user with PUT authority to a distribution list send a crafted MQPUT message that corrupts memory handling, reliably crashing the queue manager and potentially enabling arbitrary code execution. The flaw is network reachable with low complexity and no user interaction (CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8 High), but requires a valid MQ session plus put/queue authority on a reachable queue manager, so it is not exploitable by unauthenticated attackers. No public exploit code or confirmed active exploitation has been identified at time of analysis; an RCE outcome is not confirmed and the reliably achievable impact against affected versions is denial of service, while IBM has published a vendor fix.
Arbitrary file upload in WP Cloud Plugins (Use-your-Drive, Out-of-the-Box/Dropbox, Share-one-Drive/OneDrive-SharePoint, and Lets-Box/Box) versions 2.0 through 3.8.3 lets attackers with subscriber-level access write executable files to the WordPress uploads directory, enabling remote code execution (CVSS 8.8). The vulnerable download_file_to_uploads function is reachable through an import AJAX action that is also registered via wp_ajax_nopriv_ and lacks a capability check in can_import(), so the effective authentication prerequisite may be lower than the CVSS PR:L rating suggests, though exploitation still requires one of the four plugins installed and active and depends on the host allowing PHP execution inside wp-content/uploads. No public exploit code identified at time of analysis and the issue is not listed in CISA KEV.
Heap-based buffer overflow in IBM MQ allows an authenticated, low-privilege attacker who can reach a queue manager to cause a denial of service or potentially escalate privileges by issuing an MQPUT operation that carries a malformed distribution header (the MQDH distribution-list header). The flaw is network-reachable, low complexity, and requires no user interaction (CVSS 3.1 base 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), with the assessed impact spanning confidentiality, integrity, and availability, although reliable privilege escalation beyond a crash remains unconfirmed. No public exploit identified at time of analysis, and the vendor has published a patch advisory at IBM support node 7287778.
Authenticated attackers holding only Subscriber-level access on a WordPress site can overwrite arbitrary user metadata through the Mapster WP Maps plugin (all versions up to and including 1.23.0), because the my_profile_update() handler forwards an attacker-controlled acf-photo-gallery-groups POST meta key and value directly into update_user_meta() with no nonce verification, no capability check, and no allowlist of permitted keys. Independent assessment rates the practical impact as integrity-only: the vendor description explicitly states privilege escalation is not possible, so Wordfence's CVSS 8.8 vector (C:H/I:H/A:H) is materially overstated and should be read as an arbitrary user-meta write primitive rather than a confidentiality or availability compromise or an admin-takeover path. Exploitation requires the site to permit low-privilege registration (or the attacker to otherwise obtain a Subscriber account), and no public exploit code was identified at time of analysis; no KEV or EPSS data was supplied.
Authenticated OS command injection in IBM Guardium Data Protection 12.2 allows a remote attacker holding a valid low-privilege session to execute arbitrary operating-system commands on the affected appliance, with high impact to confidentiality, integrity, and availability (CVSS 3.1 base 8.8). The flaw is rated AV:N/AC:L/PR:L/UI:N/S:U, so exploitation requires credentials - authentication requirements are confirmed as authenticated (PR:L) by the assessed vector - but no user interaction and no non-default configuration; the specific vulnerable feature and input parameter are not disclosed in the advisory, and no public exploit code has been identified at time of analysis (not listed in CISA KEV). Realistic risk therefore centers on malicious insiders, compromised or reused operator accounts, and attackers who have already established a foothold on the management network, and IBM states a vendor patch is available.
An integer overflow in IBM MQ's MQINQ (inquire object attributes) request processing lets an authenticated remote user crash the queue manager and, per the vendor, potentially execute arbitrary code, giving the issue a CVSS 3.1 base score of 8.8 with high confidentiality, integrity and availability impact. Exploitation is network-based against the queue manager listener (default 1414/tcp), requires valid MQ credentials or connection authority (PR:L) and no user interaction; the vendor describes reliable code execution as a potential rather than confirmed outcome, so denial of service is the more assured impact. No public exploit identified at time of analysis, and a vendor fix is available per the IBM advisory.
Authenticated users of SysReptor Professional can turn a crafted image upload into arbitrary code execution: image formats that cause the platform's processing pipeline to invoke Ghostscript allow embedded PostScript to run inside a shared temporary directory, and a race against GnuPG configuration files created in temporary subdirectories makes GnuPG copy attacker-controlled Python into the application code directory, where it executes with the SysReptor process's privileges after the next worker restart. The Community edition is not affected, and exploitation requires a valid authenticated account plus a timing-sensitive race. Version 2026.58 provides only a partial mitigation and the issue is fully fixed in 2026.61; no public exploit code or confirmed active exploitation was identified at time of analysis, although the vendor rates this High at CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) while an independent assessment treats the race as AC:H.
IBM MQ queue managers running affected releases can be crashed - and, per IBM, potentially have arbitrary code executed on them - by an authenticated participant in an MQ cluster that sends cluster command messages with malformed length fields. The flaw affects MQ 9.1.0.0 through 9.1.0.37 LTS, 9.2.0.0 through 9.2.0.43 LTS, 9.3.0.0 through 9.3.0.41 LTS and 9.3.0.0 through 9.3.5.1 CD, 9.4.0.0 through 9.4.0.25 LTS and 9.4.0.0 through 9.4.5.1 CD, and 10.0.0.0; it is network-reachable (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8 HIGH) but requires a valid cluster identity, and IBM frames code execution only as a possibility while denial of service is the more certain outcome. No public exploit code exists and no public exploit was identified at time of analysis - CISA SSVC records Exploitation: none and Automatable: no - while EPSS estimates exploitation likelihood at roughly 0.36% (29th percentile), so priority should be driven by exposure of clustered queue managers rather than by observed attack activity.
SQL injection in the Analytic Grid Service Handler of IBM Guardium Data Protection 12.2 allows a low-privileged authenticated user to reach the analytic cases grid endpoint and inject arbitrary SQL statements, giving unauthorized access to sensitive data and putting the confidentiality, integrity, and availability of the platform at high risk (CVSS 3.1 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Exploitation is constrained: it is not possible unauthenticated, since a valid web console account with at least low privilege is mandatory, and the attack surface is limited to the analytic cases grid feature rather than the whole product. No public exploit code has been identified at time of analysis, and IBM has published a vendor patch through support bulletin 7288040.
SQL injection in the New Query Builder REST Processor of IBM Guardium Data Protection 12.2 allows a low-privileged authenticated user to inject arbitrary SQL through the newQueryBuilder REST endpoint, enabling unauthorized read and modification of data held by the appliance and degrading system availability. 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), reflecting remote reachability and high confidentiality, integrity and availability impact, but it is not pre-authentication: an attacker must already hold a valid low-privilege Guardium account and reach the appliance's REST interface. No public exploit code or confirmed active exploitation was identified at time of analysis, and IBM has published a vendor patch; because the entry point is standard Query Builder functionality rather than an optional component, the absence of an exploit is the only thing currently limiting real-world risk.
Missing authorization checks in the REST API of IBM Guardium Data Protection 12.2 allow a remote, low-privileged authenticated attacker to perform actions beyond their assigned role and gain elevated privileges over the Guardium platform. Exploitation requires valid credentials for a low-privileged account (CVSS vector PR:L, AV:N, no user interaction), so this is not a pre-authentication flaw; reachability is further limited in most deployments because Guardium REST APIs normally sit on internal or management network segments. No public exploit code has been identified at time of analysis and the vulnerability is not listed as confirmed actively exploited (CISA KEV); the vendor has published a fix, and exploitability is constrained by the need for valid credentials and management-plane access.
IBM Guardium Data Protection 12.2 allows an authenticated low-privileged user to execute arbitrary operating system commands through an unspecified input validation flaw. The vulnerability, requiring a valid account but no user interaction and reachable over the network, executes commands with the low privileges of the compromised user, limiting direct system takeover but enabling data access or lateral movement. With EPSS at 0.26% and no public exploit or KEV listing, the immediate threat is limited, but the CVSS score of 8.8 and potential for abuse warrant prompt patching.
Low-privileged authenticated users of IBM Guardium Data Protection 12.2 can extract hardcoded product master secrets embedded in the hardware_assess and obstore binaries, then use those secrets to reach the product's internal database and read sensitive system information. Exploitation is gated by an existing authenticated account on the appliance plus the ability to access the affected on-box binaries, so the realized attack surface is local/CLI-oriented rather than purely remote, and there is no public exploit identified at time of analysis. The vendor's 8.8 score (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) overstates exposure for a hardcoded-credentials weakness; an independent assessment of AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N is more consistent with a locally reachable, confidentiality-dominant issue that is brute-force gated by pre-existing authenticated access.
Code injection in Mongoid allows unauthenticated attackers who can influence a query argument to execute arbitrary JavaScript in the MongoDB server via a string-typed query criterion, leading to disclosure of stored field values, unintended document selection for writes, and reduced database performance. The vulnerability affects Mongoid versions 8.0.0 through 8.0.12, 8.1.0 through 8.1.12, 9.0.0 through 9.0.11, and 9.1.0, but exploitation requires the application to pass externally influenced string criteria to the query builder and the MongoDB deployment to permit server-side JavaScript evaluation. No public exploit identified at time of analysis.
Cross-site request forgery in IBM Guardium Data Protection 12.2 lets a remote attacker with no credentials (CVSS vector PR:N) induce a currently authenticated user's browser into sending forged requests that bypass security restrictions and perform privileged actions in that user's context. Exploitation is not automatic: it requires the victim to be logged into the Guardium web interface (ideally as an administrator) and to be lured into loading attacker-controlled content while that session is live (UI:R), so it is best modeled as an attacker-assisted integrity abuse of an existing session rather than a self-contained compromise. IBM has acknowledged the flaw (CWE-352) and shipped a vendor fix, but no public exploit code has been identified at time of analysis and the issue does not appear on CISA KEV, so exploitation is not confirmed in the wild; successful attacks can alter configuration or security settings through the victim's own authorized privileges, but the attacker cannot read responses returned to that session.
Stack exhaustion in go-openapi/swag's jsonutils package before 0.27.1 allows unauthenticated remote attackers to crash any Go service that parses or serializes ordered JSON from untrusted input - most notably endpoints that accept OpenAPI specification documents or otherwise route attacker-controlled JSON through the ordered marshal/unmarshal path - by submitting a deeply nested document that recurses without any depth limit. The result is a fatal Go stack overflow that terminates the process and drops all in-flight requests; there is no data exposure or modification, so impact is confined to availability (CVSS 8.7, CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VA:H). No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV, but exploitation requires only a single crafted request, so exposure should be treated as high for internet-facing services built on this library. The underlying defect is CWE-674 (uncontrolled recursion).
Remote code execution in ClipBucket v5 (all releases before 5.5.3-#182) allows an authenticated low-privileged user to upload a PHP file that is stored and later executed by PHP-FPM, yielding full server compromise. The photo upload endpoint validates only the file's MIME type/magic bytes but never rewrites the extension, so a payload beginning with valid image magic bytes retains its .php extension on disk (CWE-434, CVSS 4.0 base 8.7 / independently assessed CVSS 3.1 as AV:N/AC:L/PR:L/UI:N/C:H/I:H/A:H). Exploitation requires only a standard account - readily self-registered on default deployments with open registration - plus a web-executable upload directory served by PHP-FPM; there is no unauthenticated path and no public exploit code identified at time of analysis, and the issue is not confirmed actively exploited (not in CISA KEV).
Heap-based memory corruption in the IBM MQ for HPE NonStop queue manager lets an attacker who already holds a valid, low-privileged authenticated channel connection (PR:L) crash or potentially take over the broker by sending a message carrying a malformed distribution list structure, yielding the full confidentiality, integrity and availability impact reflected in the CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is a heap buffer overflow (CWE-122) arising from improper validation of the multi-recipient list records embedded in an MQ message, so exploitation is network-reachable and requires no user interaction, but it is not reachable pre-authentication or against a default queue manager configuration. IBM has published a vendor patch and no public exploit code or evidence of active exploitation was identified at time of analysis.
Authenticated remote attackers holding low-privileged credentials can exploit an incorrect permission assignment in the LDAP API of Synology DiskStation Manager to read or write arbitrary files and to trigger denial-of-service conditions, giving full loss of confidentiality, integrity, and availability on affected systems per the assessed vector (CVSS 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The vulnerability affects DSM builds before 7.2.1-69057-12, 7.2.2-72806-9, 7.3.2-86009-4, and 7.4-90075, with realistic exposure concentrated in NAS deployments that expose the management interface and run directory-services/LDAP functionality. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and the authentication requirement plus the need for a network-reachable DSM instance are the primary factors limiting real-world abuse.
Unauthenticated attackers can cancel or confirm arbitrary appointments in the Easy Appointments WordPress plugin before 4.0.2.2 because the mail-link action token is derived from a hardcoded, source-embedded salt combined with the appointment's creation timestamp instead of an unguessable secret. Exploitation hinges on knowing or guessing the target appointment timestamp, which keeps reliability limited (reflected as AC:H in CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L, base 4.8); impact is confined to integrity and availability of existing appointment records with no data disclosure. Publicly available exploit code exists, and a vendor-released patch (4.0.2.2) is available.
Memory corruption in snappy-java through 1.1.10.8 lets an attacker terminate the JVM hosting the library: the Snappy.compress(ByteBuffer, ByteBuffer) overload writes past the end of the destination buffer when incompressible input exceeds its remaining capacity, corrupting off-heap memory. Exposure is limited to Java applications that call that specific ByteBuffer overload with attacker-influenceable, low-compressibility data and a destination buffer that was not sized using Snappy.maxCompressedLength(); code using the byte[]-based compress API or compressing only trusted data is not exposed. The flaw is reachable by unauthenticated remote attackers (CVSS 4.0 vector reports PR:N, and the independent assessment agrees with AV:N/PR:N/UI:N), but the impact is availability-only - no confidentiality or integrity loss and no code execution - and no public exploit code or confirmed active exploitation was identified at time of analysis.
Denial of service in the CSSOM JavaScript library through 0.5.0 allows unauthenticated remote attackers to terminate a parsing process by supplying a stylesheet declaration named 'length', a reserved property name that is not validated and therefore overwrites the internal declaration counter; the corrupted counter then drives an oversized memory allocation when cssText is serialized, crashing the process. Exploitation is conditional rather than automatic: the host application must feed attacker-controlled CSS into CSSStyleDeclaration.setProperty() or stylesheet parsing and must later serialize that declaration via cssText, so deployments that only parse trusted first-party CSS, or that never serialize untrusted input, are not exposed. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; the provided CVSS 4.0 score of 8.7 (assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects a high availability-only impact with no confidentiality or integrity effect, and the library itself is not network-exposed.
Denial of service in uri-js through 4.4.1 lets remote, unauthenticated attackers stall a Node.js process indefinitely: the removeDotSegments routine enters an infinite loop when a path segment begins with a Unicode line separator (U+2028) or paragraph separator (U+2029), blocking the event loop until heap exhaustion. The package is an unmaintained, widely pulled-in dependency (commonly transitively, e.g. via ajv), so the risk is driven by prevalence: no public exploit identified at time of analysis and no confirmed actively exploited (CISA KEV) status. Exposure is limited to applications that actually route untrusted input into removeDotSegments directly, or into normalize()/resolve() with IRI handling enabled; code paths handling only trusted or internal URIs are not reachable by this bug.
Cross-user information disclosure in the http-cache-semantics npm library (through 4.2.0) allows unauthenticated attackers to retrieve cached HTTP responses belonging to other users from a shared cache. By re-requesting an identical URL with a large client-supplied Cache-Control: max-stale directive, an attacker can cause the library to serve cache entries that were deliberately security-zeroed - such as responses carrying Set-Cookie session credentials - instead of suppressing them. The vendor CVSS 4.0 score is 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H), while the independent assessment rates it CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N, reflecting that real-world exploitation depends on a downstream shared-cache configuration that stores authenticated responses; the vendor advisory is available from VulnCheck. No public exploit code and no confirmed active exploitation were identified at time of analysis.
Unauthenticated memory exhaustion in SGLang through 0.5.19 lets remote attackers force out-of-memory termination of the prefill process by submitting arbitrary bootstrap_room values to the decode engine's POST /generate endpoint. The flaw only manifests in a non-default deployment: prefill/decode disaggregation mode with the Mooncake KV transfer backend enabled, which is not the standard monolithic serving configuration, and the endpoint must be network-reachable. No public exploit code was identified at time of analysis, and the vulnerability is not confirmed actively exploited (CISA KEV); impact is confined to availability (CVSS 4.0 base 8.7; independent assessment scores the same issue 7.5 under CVSS 3.1), with no data exposure or code execution.
Denial of service in vLLM before 0.28.0 allows an unauthenticated remote attacker to poison the process's GPU context by sending a single request containing a negative token ID to the /v1/embeddings or /pooling endpoints, after which all subsequent inference requests fail until the server is restarted. The vulnerable endpoints are part of vLLM's OpenAI-compatible HTTP server and ship enabled in default configurations, and because vLLM provides no built-in authentication, the practical risk is governed entirely by whether the API is reachable by untrusted clients over a public or shared network. Impact is availability-only (assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H; vendor CVSS 8.7), no public exploit code was identified at time of analysis, and no KEV-listed active exploitation is reported.
Prototype pollution in the deepmerge JavaScript library (all versions through 4.3.1) allows an attacker who controls a source object passed into a merge operation to inject properties such as '__proto__', 'constructor', or 'prototype' into the resulting object's prototype chain. The impact is latency-dependent: applications that merge untrusted data (for example, a JSON request body) and then read properties without own-property checks will silently inherit attacker-chosen values, which can corrupt application logic, bypass authorization checks, or influence downstream behaviour. The flaw is a library primitive rather than a standalone exploit, and no public exploit code was identified at time of analysis; the vendor CVSS 4.0 score of 8.7 reflects integrity impact only (VC:N/VA:N), and an independent assessment rates it considerably lower (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) because exploitation requires the consuming application to both pass attacker-controlled source objects and perform unchecked inherited-property reads.
Denial of service in source-map-js up to and including 1.2.1 allows an attacker who can supply an indexed source map to hang the Node.js process: the library reads the per-section offset.line value without bounds checking, so an arbitrarily large integer forces a long synchronous loop that blocks the event loop and starves all other requests. The flaw (CWE-1284, improper validation of a specified quantity) is reachable only where a service actually parses attacker-controlled maps - for example an online transpiler, upload-accepting bundler service, or error/stack-trace resolver - since source maps are normally trusted build-time artifacts; the assessed CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects that data-flow prerequisite, and no public exploit was identified at time of analysis. Impact is availability only; despite the 'Information Disclosure' tag in some feeds, there is no confidentiality or integrity loss in the assessed vector.
Denial of service in rustls-webpki through 0.103.12 and in 0.104.0-alpha.1 through 0.104.0-alpha.6: a crafted certificate revocation list carrying an issuingDistributionPoint extension whose onlySomeReasons BIT STRING content is exactly [0x00] triggers an integer underflow in bit_string_flags() and panics the parsing process. Unauthenticated remote attackers can reach this only where an application has explicitly opted into CRL revocation checking by passing RevocationOptions to verify_for_usage() and parses CRL bytes from a source the attacker can influence (for example an attacker-supplied or MITM'd CRL distribution point); the default rustls configuration that omits RevocationOptions is unaffected. Publicly available exploit code exists - the GHSA-82j2-j2ch-gfr8 advisory ships a complete PoC CRL that reproduces the crash - but there is no confirmation of active exploitation, and the impact is purely availability (no confidentiality or integrity effect).
Password-reset token interception in SOGo before 5.12.11 lets unauthenticated remote attackers redirect account-recovery links to attacker-controlled domains by submitting a forged Origin HTTP header to the password-recovery endpoint, so that valid reset tokens are emailed to the victim inside URLs pointing at attacker infrastructure - enabling full account takeover once the victim clicks the link. The flaw only affects deployments where the optional Password Recovery feature is enabled, and exploitation requires victim interaction (UI:P / UI:R). No public exploit code or confirmed active exploitation has been identified at time of analysis, but the issue is disclosed with source-diff evidence and fixed in SOGo 5.12.11, which introduces a mandatory base-URL allowlist.
Command injection in btrbk's ssh_filter_btrbk.sh helper (versions 0.29.0 through 0.32.6) lets a user who already holds an SSH key restricted by that script append a trailing pipe command to an otherwise permitted btrbk invocation, executing arbitrary commands with the privileges of the backup-target SSH account. The root cause is a missing end-of-string anchor in the allow_stream_match regular expression, so the filter validates only a command prefix and ignores everything after it. Exploitation is gated: it requires that the deployment actually use ssh_filter_btrbk.sh as an authorized_keys forced command (deployments that do not are explicitly unaffected), and an attacker must already control a key subject to that restriction (PR:L); no public exploit has been identified at time of analysis. The issue is fixed in btrbk 0.32.7 via upstream commit 29ca3c0.