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.
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.
CPU exhaustion in MongoDB's Mongoid Ruby ODM allows an unauthenticated remote party to render an embedding application unresponsive by supplying crafted text that lands inside a pattern-matching query condition Mongoid evaluates in memory against an embedded association, triggering catastrophic regex backtracking (CWE-1333, ReDoS). The impact is availability-only: the affected Ruby application process burns CPU and stops responding, with no confidentiality or integrity effect. No public exploit code has been identified at time of analysis, and reachability depends on a specific application coding pattern, which is why the independent assessment applies AC:H and treats deployments that never route untrusted input into regex conditions on embedded documents as out of scope (the CNA's CVSS 4.0 vector rates it 8.7 with AC:L, a more aggressive reading than the assessed CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H).
hickory-resolver releases before 0.26.2 fail to propagate a 'bogus' DNSSEC proof state out of the high-level Resolver::lookup() and Resolver::lookup_ip() APIs, so records that fail DNSSEC signature validation are handed back to the caller as successful, apparently validated answers. This is an integrity-only bypass affecting unauthenticated remote attackers (CVSS:4.0 8.7 / assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N) who either control the authoritative zone answering the query or sit on the network path to inject forged records with invalid RRSIGs; applications that do not compile the crate's __dnssec feature are unaffected because they never expected validation in the first place. A vendor fix is available in 0.26.2 (commit 30720f4, PR 3871), and no public exploit code or confirmed active exploitation was observed at time of analysis. This is a genuine, high-priority integrity flaw despite the absence of exploitation telemetry.
Hardcoded MQTT credentials shipped inside Bransys ELD grant unauthenticated read access to real-time telemetry for every active device belonging to a subset of carriers connected to the affected MQTT broker. Because the static credential is embedded in the product, remote attackers who recover it - for example by reverse-engineering the shipped binary or firmware - can subscribe to the broker with any standard MQTT client, and no user interaction or per-victim authentication is required (PR:N/UI:N). The exposure is confidentiality-only against live fleet data (C:H/I:N/A:N in our assessed CVSS 3.1 vector) and no public exploit code or confirmed active exploitation was identified at time of analysis; the reported CVSS 4.0 score of 8.7 reflects the broad device population reachable with a single shared credential, and CISA ICS advisory ICSA-26-260-01 documents the issue.
Unauthenticated relative path traversal in HGiga OAKlouds Bulletin V3 (2.0 and 3.0 product lines, module builds below 107) lets remote attackers read arbitrary files from the underlying host, potentially exposing configuration files, stored credentials, and other sensitive system data. Both the published CVSS 4.0 score of 8.7 and our independent CVSS 3.1 assessment (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) agree that no authentication, no user interaction, and no non-default configuration are required - the only prerequisites are network reachability of the Bulletin web interface and a vulnerable build. No public exploit identified at time of analysis, and the vendor has released a fix in build 107, so residual risk hinges on whether internet-facing or partner-exposed deployments have actually been upgraded. This is a genuinely high-priority issue given the unauthenticated, confidentiality-only but high-impact nature of the flaw and the often sensitive content of Taiwanese bulletin/portal deployments.
An authentication downgrade in NASA CryptoLib 1.5.0 lets a remote, unauthenticated attacker defeat Space Data Link Security (SDLS) authentication on the Telecommand receive path by crafting a frame whose Security Parameter Index (SPI) names a weaker Security Association (SA) than the one legitimately authorized for that frame's Global Virtual Channel ID (GVCID). Because the receiver never checks that the selected SA is permitted for the frame's GVCID, the command is processed under the attacker-chosen SA, giving high integrity impact (VI:H, C:N, A:N) against spacecraft or ground-segment command handling. Exploitation is constrained rather than trivially remote: the attacker must be able to inject frames into the TC uplink/command channel (typically an RF ground link or internal command network, not the public internet) and a misconfigured or weaker SA must already exist for the targeted GVCID. No public exploit code was identified at time of analysis, and the flaw is an authorization/downgrade weakness rather than a confidentiality exposure.
Stored cross-site scripting in SiYuan through 3.8.4 lets an attacker inject malicious style values into heading attributes that the outline and bookmark docks render without escaping, so the payload executes as JavaScript inside SiYuan's Electron renderer - which runs with full system access, making this effectively an XSS-to-code-execution condition on the host rather than ordinary script execution in a sandboxed browser context. Delivery is either a crafted notebook that the victim imports or opens, or abuse of SiYuan's administrative endpoints (the latter implying authenticated access); the payload only fires when the victim surfaces the affected heading in the outline or bookmark dock, so user interaction is required (UI:A) and exploitation is not purely passive. No public exploit identified at time of analysis; the CVE carries a CVSS 4.0 base score of 8.6 and was independently assessed as CVSS 3.1 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), reflecting the notebook-import path being unauthenticated while the administrative-endpoint path requires credentials.
Unauthenticated SQL injection in IBM Platform RTM (the real-time monitoring component of Spectrum LSF) lets a remote attacker who can reach the product's web/reporting interface inject crafted SQL into a back-end database, reading, adding, modifying, or deleting data. The vendor rates it CVSS 3.1 8.6 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:L), and our independent assessment agrees on severity while noting that in typical HPC/LSF deployments the component sits on a trusted cluster-management network rather than the public internet, which is the main real-world brake on exploitation; the assessed vector also raises the integrity impact to H (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L) because successful SQL injection against a writable application account commonly yields full row-level manipulation, not just partial. No public exploit code was identified at time of analysis and the flaw is not in CISA KEV, though the PR:N/UI:N profile means no credentials or user interaction are needed once the endpoint is reachable. Vendor patch availability is listed as available, giving administrators a direct fix path; the specific vulnerable parameter and page are not named in available data, so pre-auth reachability should be verified against the IBM advisory.
Unauthenticated SQL injection in the Load Balancer Groups component of IBM Guardium Data Protection 12.2 allows remote attackers to reach the Load Balancer Servlet endpoint and inject arbitrary SQL statements, potentially exposing managed data and degrading the confidentiality, integrity, and availability of the appliance (CVSS 8.6, with confidentiality impact rated high and integrity/availability impact limited). Per the CVSS vector PR:N/UI:N, no credentials or user interaction are required to attempt the attack, but practical risk depends on network exposure: Guardium appliances are normally deployed on internal management or security networks rather than the public internet, so reachability to the servlet is the principal gating condition. No public exploit code has been identified at time of analysis, and IBM has published remediation through its support advisory rather than confirmed in-the-wild activity.
Stored cross-site scripting in the Concrete CMS Community Store package before 2.7.8 lets an unauthenticated shopper plant script payloads in customer-supplied checkout fields - billing first/last name, email, and phone - which the storefront renders without HTML escaping in default order-slip, cart, and checkout templates. The injected script lies dormant until an authenticated store manager or administrator opens the affected order in the order slip or admin order views, at which point it executes in their privileged session and can create rogue accounts or exfiltrate store and customer data. Exploitation requires privileged-user interaction (no public exploit code identified at time of analysis), but because the vulnerable rendering lives in default templates and no non-default configuration is needed, any shop accepting guest orders is exposed - an attacker gains no access unless a manager views the poisoned order, and patch version 2.7.8 is available.
Authenticated low-privilege users can read and insert TimeSeries samples in ArcadeDB deployments running versions before 26.9.1 even when security-group ACL deny rules explicitly forbid it, because the permission resolver builds its grants from record bucket IDs while TimeSeries types own no normal record buckets, causing the access check to fail open. The flaw is a genuine authorization bypass (CWE-863) with high confidentiality and integrity impact but no availability impact, and it only manifests on instances that actually use TimeSeries types and rely on ACLs to segregate them. No public exploit code has been identified at time of analysis, but the vendor has released the fix in ArcadeDB 26.9.1.
Insecure direct object reference in Mongoid's nested-attributes handling lets an authenticated user with basic application privileges supply another user's record identifier, causing Mongoid to look up that record outside ownership or tenant scoping and then update and link it to the requester's own record-resulting in unintended disclosure and unauthorized modification of data. Exploitation is limited to applications that use accept_nested_attributes_for on ownership- or tenant-scoped associations and rely on Mongoid to enforce scoping; no public exploit identified at time of analysis, and no confirmed affected or fixed versions because the only reference is an unbounded MongoDB Jira advisory with a wildcard CPE.
Command injection within Acode on Android lets any locally installed application execute arbitrary shell commands inside Acode's own sandboxed UID, exposing private app data, stored remote credentials, Storage Access Framework grants and granted runtime permissions. The flaw affects builds from 1.11.6 up to but not including 1.12.7, where the terminal plugin exports com.foxdebug.acode.rk.exec.terminal.TerminalService without a binding permission and TerminalService.java performs no caller verification, so a zero-permission hostile app can bind the service and pass an attacker-controlled cmd value via MSG_EXEC. Exploitation is strictly local and requires the victim to already have run a malicious app alongside a vulnerable Acode release; no public exploit code has been identified at time of analysis and there is no CISA KEV listing or EPSS signal reported.
SQL injection in pg_partman before 5.5.0 allows an authenticated low-privileged partman_user to escalate to PostgreSQL superuser and execute operating-system commands as the PostgreSQL service account. The flaw only fires when pg_jobmon is installed, part_config.jobmon is true for the target partition set, and an affected exception handler in a pg_partman function actually runs; the injected SQL then executes with the privileges of pg_partman_bgw.role, which defaulted to a PostgreSQL superuser prior to 5.5.0. The malicious parent-table name is stored persistently in part_config, so the escalation can re-trigger on later background-worker maintenance ticks; exploitation is conditional and most dangerous in multi-tenant clusters that use jobmon with a superuser background worker, and no public exploit code was identified at time of analysis. Fixed in 5.5.0.
SQL injection in pg_partman before 5.5.0 allows an authenticated partman_user who owns a template table to escape the generated ALTER TABLE ADD PRIMARY KEY statement by placing a double-quote character in a column name, causing the background worker to run attacker-supplied SQL under the worker's role. Because pre-5.5.0 deployments effectively default pg_partman_bgw.role to a PostgreSQL superuser, successful exploitation yields database-wide compromise and operating-system command execution as the PostgreSQL service account, with the crafted catalog identifier persisting and re-triggering during later child-partition creation. Exploitation is gated on the background worker actually applying the primary key to a child partition (hence AC:H) and is neutralized entirely if the worker runs as a non-superuser role; no public exploit identified at time of analysis, and the flaw is fixed in 5.5.0 (CVSS 3.1 score 8.5).
SQL injection in pg_partman prior to 5.5.0 allows an authenticated PostgreSQL role holding the documented partman_user privileges to plant arbitrary SQL in the writable part_config.time_dncoder column and have it executed when routine maintenance or partition-inspection functions later interpolate that value into dynamic SQL. Because the injected statement runs with the privileges of the invoking operation, deployments whose pg_partman_bgw.role GUC is still pointed at a superuser role (the historical default before 5.5.0) can be escalated to database-wide compromise and operating-system command execution as the PostgreSQL service account, and the poisoned configuration row can re-establish elevated access on subsequent background-worker ticks. Exploitation requires write access to part_config and is most realistic in multi-tenant instances where several roles share pg_partman, and no public exploit code was identified at time of analysis; version 5.5.0 fixes the issue. The assessed CVSS is 8.5 (AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), reflecting authenticated access and a high-complexity, scope-changing path rather than a remotely unauthenticated attack.
SQL injection in pg_partman prior to 5.5.0 lets a role with partman_user access store arbitrary SQL - rather than a legitimate function name - in the part_config.time_encoder column, which undo_partition() interpolates into a dynamically executed SELECT without identifier quoting and runs with the privileges of whichever caller invokes that function. Exploitation is a two-step confused-deputy chain: an authenticated writer plants the payload, and a separate more-privileged role must later call undo_partition() on the same partition set, which is why the assessed vector is AV:N/AC:H/PR:L with impact bounded by the invoking caller rather than the attacker, and it does not carry the automatic superuser escalation of the background-worker create-partition flaw. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the issue is resolved in pg_partman 5.5.0.
Unauthorized relocation of retained partition child tables in pg_partman before 5.5.0 lets an authenticated database role holding partman_user access move another tenant's child tables into a schema it does not own. The cause is that drop_partition_id() and drop_partition_time() pass part_config.retention_schema straight into ALTER TABLE SET SCHEMA, and the background worker executes the move under pg_partman_bgw.role - a PostgreSQL superuser by default before this release - so the privilege check that normally guards SET SCHEMA is never enforced. The realistic impact is bounded to multi-tenant deployments where several roles own partition sets on the same instance, no public exploit code was identified at time of analysis, and the escalation is fully neutralized by pointing pg_partman_bgw.role at a non-superuser role, which the vendor confirms can be done even before upgrading.
Privileged users of PLANET IGS-5225-8P2T4S industrial managed switches running V1 firmware before 1.2412b260707 or V2 firmware before 2.2412b260519 can activate undocumented debug functionality that ships enabled in the embedded software, reaching an OS command execution path that grants root-level access to the device. Exploitation requires high-privilege administrative/management access and local access to the device management plane (CVSS:4.0 AV:L/PR:H), so the realistic threat is a malicious insider or an attacker who has already obtained management credentials rather than an unauthenticated remote compromise. No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor-released patched firmware is available.
Unsafe reflection (CWE-470) in Mongoid's document persistence layer allows a crafted key to be reflected into an internal method invocation instead of the intended array-field update, which can delete stored records and render the embedding application unresponsive. The affected component is Mongoid, MongoDB's Ruby object-document mapper; the CPE record (cpe:2.3:a:mongodb_inc.:mongoid:*:*:*:*:*:*:*) carries no version bounds, so the vendor has not published a bounded version range, and exposure applies to any embedding application that forwards unauthenticated, attacker-controlled keys directly into an array-field update. The CVSS 4.0 vector marks this dependency as AT:P (Attack Requirements: Present), meaning Mongoid is not exploitable in isolation, but where that non-default coding pattern exists there is no authentication or user-interaction barrier (PR:N, UI:N/A:H). Impact is integrity and availability only (VI:H/VA:H, VC:N), and no public exploit code has been identified at time of analysis.
Unauthenticated, remote query-operator injection in Mongoid - the official MongoDB object-document mapper for Ruby - allows an attacker to shape how MongoDB evaluates a query whenever an application forwards externally supplied filter parameters straight into Mongoid query-building methods without whitelisting allowed operators. Successful abuse can disclose stored field values (for example through $ne, $gt or $regex-style filter logic used for blind extraction) and, because operators such as $regex or $where can force expensive scans, can degrade database performance. The impact is conditional: the vendor's CVSS 4.0 vector carries AT:P (attack requirements present) and our assessment uses AC:H, because exploitation depends entirely on the downstream application's query-construction pattern rather than on a Mongoid setting. No public exploit code was identified at time of analysis, and the issue is not listed in CISA KEV; EPSS data was not provided. CVSS 4.0 base is 8.3 (AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:N/VA:L) and our independent CVSS 3.1 assessment is AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:L, i.e. high confidentiality impact with a limited availability effect and no integrity impact.
Heap out-of-bounds write in OpenImageIO's Cineon image reader (cineon.imageio) allows memory corruption when the library decodes a crafted .cin file that declares an unsupported per-channel bit depth, such as 26. Affected deployments are those running OpenImageIO versions prior to 3.0.21.0, 3.1.16.0, or 3.2.0.3-beta1, and exploitation requires that a victim or an automated pipeline actually open and parse the attacker-supplied Cineon file (CVSS vector PR:N with UI:R). The flaw is rated High (CVSS 3.1 base 8.3, AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H) and no public exploit code has been identified at time of analysis; vendor-released fixes are available in 3.0.21.0, 3.1.16.0, and 3.2.0.3-beta1.
Memory-exhaustion denial of service in SGLang through 0.5.20 allows anyone who can reach the decode engine's internal ZMQ rank port to terminate the serving process by sending a single STAGING_REQ frame carrying an extremely large chunk_idx value. The flaw applies only to deployments running prefill/decode disaggregation - a non-default, multi-engine serving topology - and requires network reachability to the inter-rank ZMQ port that normally carries unauthenticated traffic on a trusted cluster network; when that port is bound to loopback or an isolated back-end network, the issue is not reachably exploitable. No public exploit identified at time of analysis, and the impact is confined to availability: the scheduler allocates memory until the system runs out and the process is killed, with no data exposure or code execution.
Mismatched handling of the HTTP/1 absolute-form request authority in Red Hat build of Quarkus and other affected Red Hat middleware lets a remote, unauthenticated attacker smuggle requests across the HTTP/1-to-HTTP/2 protocol boundary, overriding the :authority pseudo-header that downstream services use for routing and authorization. The vendor CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N = 8.2 High) rates integrity as the dominant impact (I:H) with limited confidentiality exposure (C:L) and no availability effect, consistent with a CWE-444 request-smuggling class defect. Exploitation is not confirmed actively exploited (no CISA KEV listing) and no public exploit identified at time of analysis, although real-world exploitation requires a deployment that actually translates HTTP/1 requests into HTTP/2 and a downstream component that trusts :authority for routing or authorization decisions.
Cross-client information disclosure in http-cache-semantics through 4.2.0 allows remote, unauthenticated attackers to receive cached responses that were generated for other users. The library's _varyMatches() function performs byte-for-byte comparison of Vary header values and therefore fails to treat a wildcard 'Vary: *' directive as a prohibition on shared-cache reuse, so a request for a URL previously fetched by someone else can be satisfied from cache with that other client's sensitive per-user data. Exploitation is conditional and non-deterministic - it requires a shared, multi-user cache deployment and an origin that emits wildcard Vary on cacheable responses - which is consistent with the vendor CVSS 4.0 score of 8.2 with AC:H and AT:P; no public exploit code has been identified at time of analysis.
Privileged users inside a QEMU guest running on the Q35 machine type with the KVM accelerator can abuse the VAPIC setup hypercall (hw/i386/vapic.c) to break SMM isolation, because the code fails to verify that a writable RAM alias stays inside the option ROM window. By repositioning that alias over chipset-locked SMRAM, an attacker with root-equivalent guest access defeats D_LCK protection and injects code into System Management Mode memory, which QEMU scores as a scope-changing, total-impact compromise (CVSS 8.2). Exploitation is local to the guest with high privileges required (AV:L, PR:H, S:C), publicly available exploit code exists according to the CISA SSVC assessment, but there is no confirmed active exploitation and EPSS is low at 0.20% (10th percentile).