Command injection in Glances prior to 4.5.6 allows a local unprivileged user to execute arbitrary shell commands when administrator-configured action templates use adjacent unescaped Mustache variables. The per-field sanitizer in _sanitize_mustache_dict() strips multi-character shell operators from individual template field values but cannot prevent their reconstruction across variable boundaries after Chevron rendering, enabling '&&' to be assembled from two separate '&' characters that each pass the filter individually and are then executed by secure_popen(). No public exploit has been identified at time of analysis, though GHSA-qcpp-8x79-hhp3 provides sufficient technical detail to reproduce the attack technique.
Denial-of-service in vm2 (Node.js sandbox library) versions 3.11.0-3.11.5 allows sandbox code to bypass the `bufferAllocLimit` DoS mitigation via two unwrapped allocation paths - `Buffer.concat(list, totalLength)` and `Buffer.from({length: N})` - committing unbounded host external memory in a single synchronous C++ call that V8's timeout mechanism cannot interrupt. A publicly available PoC confirms that a 200-byte sandbox payload inflates host RSS by hundreds of megabytes per invocation, making a single crafted request sufficient to OOM-kill a host process running inside a Docker container, Kubernetes pod, or AWS Lambda function. No public exploit identified in CISA KEV at time of analysis, though functional exploit code is embedded in the GHSA advisory itself.
Server-Side Request Forgery (SSRF) in 9Router 0.5.4 and earlier allows unauthenticated remote attackers to probe internal network services by supplying an arbitrary issuerUrl to the /api/auth/oidc/test endpoint, which the application fetches without validating against private or loopback address ranges. The reflected OIDC discovery fields - including token_endpoint and jwks_uri - expose internal service metadata, enabling internal network enumeration. No public exploit code or CISA KEV listing has been identified at time of analysis, though the unauthenticated, low-complexity attack surface makes opportunistic scanning plausible.
Stack exhaustion denial-of-service in deepmerge-ts crashes Node.js processes when attacker-controlled recursive object graphs are passed to `deepmerge()`, `deepmergeInto()`, `deepmergeCustom()()`, or `deepmergeIntoCustom()()`. All versions prior to 8.0.0 lack cycle detection in the recursive record-merge routine, allowing two self-referencing objects sharing a key path to drive the process into infinite recursion until the Node.js runtime throws `RangeError: Maximum call stack size exceeded`. A public proof-of-concept is included in the GitHub security advisory; no CISA KEV listing exists at time of analysis.
Memory exhaustion in Netty's SctpMessageCompletionHandler (netty-transport-sctp) allows unauthenticated remote peers to drive a JVM into OutOfMemoryError by sending oversized, incomplete SCTP message fragments. The handler enforces limits on concurrent incomplete messages and per-message fragment counts - introduced as a fix for the prior CVE-2026-46340 - but omits a corresponding cap on total buffered bytes. With default settings of 128 messages and 128 fragments, an attacker can buffer approximately 1GB per connection; a small number of concurrent connections suffices to exhaust server heap. Vendor-released patches exist in versions 4.1.137.Final and 4.2.17.Final; no active exploitation or public POC has been identified at time of analysis.
GraphQL multiplex query handling in GitLab CE/EE improperly validates request methods, permitting unauthenticated attackers to trigger state-changing mutations via HTTP GET requests, effectively bypassing CSRF protections. All GitLab CE/EE deployments running versions 18.2 through the affected ranges across the 18.x, 19.0, 19.1, and 19.2 release lines are exposed. A publicly available exploit exists via HackerOne disclosure, and successful exploitation allows an attacker to perform arbitrary data-modifying operations on behalf of any authenticated GitLab user who can be lured to a malicious page.
MLflow's `CreateModelVersion` endpoint prior to version 3.15.0 permits authenticated users to anchor a model version to another user's run or logged-model artifact directory, then retrieve those artifacts through `GET /model-versions/get-artifact` without holding the required READ permission on the source resource. This confused-deputy pattern arises because `_validate_source_run()` and `_validate_source_model()` in `mlflow/server/handlers.py` enforce only path containment - not cross-user authorization - allowing the registered model's artifact-read gate to be used as a proxy to exfiltrate a victim's ML artifacts. No active exploitation has been confirmed (not in CISA KEV), and the vendor-released fix is available in MLflow 3.15.0 alongside a public security advisory and PR diff that fully document the exploit technique.
Stack buffer overflow in COVESA Open1722 through version 0.9.2 enables unauthenticated remote attackers to corrupt stack memory and achieve arbitrary code execution or denial of service by sending a single crafted UDP datagram containing more than 15 ACF-CAN messages. The root cause is an unbounded write index in the avtp_to_can() function, which increments unconditionally past the end of a fixed 15-slot stack array without comparing against the caller-supplied size. Exploitation requires no authentication because the ACF-CAN listener accepts packets from any sender matching a hardcoded stream identifier transmitted in plaintext; no public exploit code or active exploitation confirmed by CISA KEV has been identified at time of analysis.
Remote code execution in WordPress exposes sites to full server compromise when an Author-level (or higher) authenticated user uploads a specially crafted PostScript file that is subsequently processed by Imagick and Ghostscript. The vulnerability, classified as CWE-434 (Unrestricted Upload of File with Dangerous Type), leverages Ghostscript's Turing-complete PostScript interpreter to execute arbitrary OS-level commands under the web server's process identity. No public exploit has been identified at time of analysis, but the low privilege bar - requiring only an Author account - and WordPress's massive global deployment footprint make this a high-priority remediation item for any self-hosted installation running Imagick with Ghostscript.
Arbitrary file read and write in HP Web Jetadmin (WJA) is achievable by unauthenticated remote actors via a DLL hijacking mechanism, carrying a CVSS 4.0 score of 8.9. The flaw exposes full confidentiality, integrity, and availability of the WJA host - an attacker can exfiltrate sensitive configuration and credential files or overwrite system files to achieve persistent access. Proof-of-concept exploit code exists (CVSS 4.0 E:P), elevating real-world risk, though active exploitation has not been confirmed by CISA KEV at time of analysis.
Remote code execution in Roundcube Webmail (before 1.6.18 and 1.7.x before 1.7.3) is achievable by authenticated remote attackers through the cmd_learn driver of the markasjunk plugin, which passes unsanitized placeholder replacement values derived from user-controlled email content directly to OS command invocations (CWE-78). Exploitation is strictly limited to instances where the markasjunk plugin is installed and configured with the cmd_learn driver - a non-default, operator-configured setup - meaning the broader Roundcube population is unaffected. Vendor-released patches exist for both the 1.6.x and 1.7.x branches; no public exploit has been identified at time of analysis, and the CVE is not listed in the CISA KEV catalog.
Remote code execution is achievable in T-Systems International GmbH ImageMaster version 9.14.2.8.1 through an unrestricted file upload flaw in the 'add attachments' feature of the document creation workflow. A remote attacker can upload a malicious executable file (e.g., a webshell) and subsequently trigger its server-side execution, achieving full system compromise. A proof-of-concept exploit is publicly available per SSVC data and a GitHub repository linked in references; however, no CISA KEV listing has been recorded and EPSS exploitation probability is notably low at 0.59% (45th percentile), indicating limited observed in-the-wild activity at time of analysis.
Arbitrary file upload in 2100 Technology's Official Document Management System (all versions before 5.0.105) enables authenticated remote attackers to upload and execute web shell backdoors, achieving full arbitrary code execution on the underlying server. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L) confirms network-accessible exploitation requiring only a low-privileged account, with total impact across confidentiality, integrity, and availability. No public exploit code or active exploitation has been identified at time of analysis, and a vendor patch is available.
LDAP filter injection in Roundcube Webmail arises from unescaped substitution variables (`%u`, `%fu`, `%d`) embedded directly into LDAP `search_filter` configuration strings, affecting all 1.6.x releases before 1.6.18 and 1.7.x releases before 1.7.3. An authenticated user whose login credentials contain crafted LDAP metacharacters can manipulate server-side directory queries, potentially disclosing LDAP directory contents or escalating privileges by subverting group membership lookups. No active exploitation has been identified at time of analysis (SSVC: Exploitation none), though the low attack complexity and network accessibility warrant prompt patching for any LDAP-backed deployment.
Integer overflow in Apple's image processing subsystem across iOS, iPadOS, and macOS Tahoe allows arbitrary code execution when a user processes a maliciously crafted image. Affected platforms include iOS and iPadOS prior to 26.6.1 and macOS Tahoe prior to 26.6.2, with Apple releasing out-of-band point releases indicating urgency. No public exploit has been identified at time of analysis, but the CVSS 8.8 score and SSVC total technical impact rating place this among high-priority patching targets given Apple's massive consumer and enterprise device footprint.
Memory corruption in Apple's web content rendering engine affects iOS, iPadOS, and macOS Tahoe, enabling high-impact device compromise when a user processes maliciously crafted web content. All iOS and iPadOS versions prior to 18.7.10 and 26.6.1, and macOS Tahoe versions prior to 26.6.2, are confirmed affected per Apple security advisories and EUVD-2026-60510. Apple has released patched builds across all affected branches; no public exploit code or CISA KEV listing has been identified at time of analysis.
Local privilege escalation in Zephyr RTOS (versions 4.0.0-4.4.1 with CONFIG_USERSPACE enabled) allows an unprivileged user-mode thread to execute arbitrary code in kernel supervisor mode by supplying forged struct device pointers with attacker-controlled API function tables to the flash_copy() system call. The syscall verifier z_vrfy_flash_copy() validated the output buffer but omitted the K_SYSCALL_DRIVER_FLASH object validation for src_dev and dst_dev that every sibling flash syscall enforces - a unique gap in the trust boundary that the kernel implementation blindly dereferences in supervisor context. No public exploit or active exploitation has been identified at time of analysis; a vendor-released patch is confirmed in commit 1b1ecdc4 and available in Zephyr 4.4.2.
Privilege escalation in Red Hat Advanced Cluster Management for Kubernetes 2 allows any attacker with local pod execution under the `search-serviceaccount` service account to impersonate `system:masters` and gain full cluster-admin control. The `search-serviceaccount` RBAC bindings grant cluster-wide `impersonate` permissions on users and groups - a grossly over-privileged configuration that collapses the entire cluster's security boundary if any pod running under this account is compromised. No public exploit has been identified at time of analysis and this CVE is not in CISA KEV, but the CVSS scope change (S:C) and full CIA triad impact (C:H/I:H/A:H) accurately reflect the catastrophic blast radius of successful exploitation.
Command injection in Glances system monitoring (versions 4.5.2 through 4.5.5) allows a local attacker with process-execution rights to bypass the action-template sanitizer by embedding pipe characters in process argv, which is exposed as a Python list that the incomplete `_sanitize_mustache_dict()` function passes to the Mustache renderer without sanitization. This is a confirmed incomplete fix of CVE-2026-32608: the original sanitizer checked only top-level string values in the render dictionary, leaving nested containers unchecked, and the Chevron renderer does not escape `|`, so the character reaches `secure_popen` and spawns an attacker-controlled subprocess. Vendor-released patch v4.5.6 introduces recursive sanitization; no public exploit has been identified at time of analysis.
Path traversal in Evidently UI's dataset materialization endpoint exposes arbitrary host filesystem files to unauthenticated remote attackers. The filename parameter in the materialization API is unsanitized, enabling directory traversal sequences or absolute paths to escape the workspace directory; the materialized file is then retrievable via the download endpoint. No active exploitation has been confirmed (not listed in CISA KEV), and no patched version has been identified at time of analysis - all known versions remain vulnerable per the wildcard CPE.
Unauthorized file download in Typemill before 2.26.0 is achievable by unauthenticated remote attackers through a path-equivalence authorization bypass in the media file download controller. The role-based restriction map is consulted using the raw, unnormalized URL-supplied filename, while the PHP filesystem layer transparently resolves path-equivalent forms - dot-slash prefixes, double slashes, and percent-encoded separators - to the actual protected file, producing an authorization mismatch that allows restricted media to be served without credentials. No public exploit code has been identified at time of analysis, but the attack requires no authentication, no user interaction, and no special client capabilities beyond a standard HTTP request.
Out-of-bounds heap read in TIER IV Nebula's Vlp32Decoder::unpack() function through version 1.2.0 enables unauthenticated remote attackers to inject fabricated LiDAR point data into autonomous vehicle perception pipelines by sending short malformed UDP datagrams to the Velodyne sensor port. Unlike other Nebula sensor drivers, the VLP-32 UDP listener enforces no sender-address restrictions, making any network-reachable host a valid attacker origin without spoofing. Fabricated points derived from adjacent heap memory contents are silently published into downstream PointCloud2 messages consumed by Autoware nodes, creating a sensor-integrity risk with direct safety implications; no public exploit code and no CISA KEV listing are identified at time of analysis.
Unthrottled brute-force against SiYuan's Publish Service Basic Auth allows remote unauthenticated attackers to enumerate passwords against named publish-viewer accounts and gain read access to published notes and notebooks. All SiYuan releases before 3.7.4 are affected wherever the Publish Service is enabled and network-accessible on its default TCP port 6808. No public exploit code has been identified at time of analysis, but the attack is trivially automatable using any standard HTTP client given the complete absence of rate limiting, per-account lockout, or exponential backoff in the vulnerable code path.
Unauthenticated access to JimuReport's report folder template listing endpoint exposes all report definitions, share tokens, embedded SQL statements, and live query data to any remote attacker. The CWE-306 root cause - missing authentication for a critical function - means the disclosure requires no credentials, no user interaction, and no special tooling. With a CVSS 4.0 score of 8.7 and a network-accessible, zero-complexity attack path, this represents a high-priority information disclosure risk for any JimuReport deployment reachable from an untrusted network. No public exploit or CISA KEV listing has been identified at time of analysis, though the vulnerability is fully disclosed via VulnCheck advisory and a public GitHub issue.
Broken object-level authorization on Crawlab's password-change endpoint allows any authenticated user to overwrite the credentials of any platform account, including administrators, without ownership or role verification. The attack is a two-step IDOR chain: enumerate user IDs through an unrestricted user-listing endpoint, then submit a password-change request targeting the administrator account ID. Once administrator access is seized, full platform control enables deployment of malicious crawler scripts, achieving arbitrary code execution across all distributed worker nodes. No public exploit has been identified at time of analysis, though the IDOR pattern is trivially reproducible by any holder of a valid session.
Authentication bypass in the jahlives/openssl_encrypt PHP library (all versions before 1.4.0) exposes deployments running the standalone telemetry server to full API authentication compromise via hardcoded credentials. The static default secret key embedded in the telemetry server configuration is used for API key hashing; any attacker who obtains this now-public value can reconstruct valid API key hashes and authenticate to the telemetry API without possessing legitimate credentials. The vendor has released a fix in version 1.4.0, confirmed via GHSA-p926-6hjp-w9jw; no public exploit code or CISA KEV listing has been identified at the time of analysis.
Hardcoded PostgreSQL credentials embedded in openssl_encrypt standalone server configuration files expose backend databases to unauthorized access in all versions before 1.4.0. Network-adjacent attackers who obtain the well-known static credentials - trivially available from the distributed software package or public advisory - can authenticate directly to the PostgreSQL instance and retrieve sensitive stored data without any legitimate account. No public exploit code has been identified and this CVE is not listed in the CISA KEV catalog, but the CWE-798 root cause makes exploitation mechanically trivial for any attacker within network reach of the database port.
Service account role escalation in SkyPilot grants any authenticated user full administrative control by exploiting missing authorization enforcement on the permission update API. The server-side handler in sky/users/server.py accepted admin role assignments from any valid user without verifying the caller held admin privileges - a direct CWE-269 (Improper Privilege Management) failure. All versions are affected per wildcard CPE; a patch commit is available upstream but no formally tagged release has been confirmed. No active exploitation is confirmed at time of analysis.
Insecure Direct Object Reference (IDOR) in phpIPAM through 1.8.1 allows any holder of a valid temporary share URL to enumerate every IP address record stored across all subnets and sections - far beyond the single subnet the share was issued for. The flaw exists because the temporary share handler in app/temp_share/index.php passes the attacker-controlled subnetId GET parameter directly to a database fetch without confirming the returned address belongs to the authorized subnet. Exposed records include hostnames, DNS names, MAC addresses, owner and contact fields, and free-text notes that frequently contain credentials and configuration details. No public exploit or CISA KEV listing has been identified at time of analysis; a vendor-released patch is available in v1.8.2.
Path traversal in the jahlives openssl_encrypt plugin (versions before 1.4.0) permits unauthenticated remote attackers to escape the intended plugin configuration directory by supplying crafted plugin_id values containing sequences such as '../'. The _is_safe_path method fails to sanitize the plugin_id parameter before using it to construct filesystem paths, exposing arbitrary server-side files readable by the application process. No active exploitation is confirmed (not in CISA KEV) and no public POC has been identified at time of analysis, though the network-accessible, zero-authentication attack profile makes this straightforward to exploit from the vulnerability description alone.
Hardcoded JWT signing secrets embedded in config.py of openssl_encrypt versions before 1.4.0 allow any party with access to the library's publicly hosted source code to forge cryptographically valid JWT tokens for arbitrary client IDs, bypassing authentication on keyserver and telemetry APIs. The static secrets pass all validation checks, making exploitation a matter of reading the source and generating a token with standard JWT tooling-no brute-force or cryptographic attack is required. No CISA KEV listing or public proof-of-concept exploit has been identified at time of analysis, but the trivially low exploitation complexity makes this a high-priority remediation for any network-exposed deployment running an unpatched version.
Quadratic CPU consumption in sqlparse's group_comments function (grouping.py) allows remote unauthenticated denial of service against any Python application that passes attacker-controlled input to sqlparse.parse() or sqlparse.format(sql, strip_comments=True). A comment-only payload of roughly 250 KB forces minutes of CPU burn regardless of the MAX_GROUPING_TOKENS guard, because group_comments executes before that cap is checked. A public proof-of-concept with benchmark data confirms O(n²) scaling: n=4000 comments takes ~1600 ms versus ~106 ms at n=1000; no public exploit identified at time of analysis beyond the researcher's PoC, and the vulnerability is not listed in CISA KEV.
Insecure Direct Object Reference (IDOR) in the openssl_encrypt Python pip package (versions before 1.4.0) allows any authenticated client to revoke another client's cryptographic key without owning it. The keyserver's revoke_key method at lines 195-270 of service.py validates the requester's ML-DSA post-quantum signature but never checks whether the requesting client_id matches the key's owner_client_id - meaning an attacker with valid credentials can target any key in the server by presenting their own legitimate signature against a victim's key ID. No public exploit is identified at time of analysis, though the low attack complexity and the availability of a detailed GHSA advisory make exploitation straightforward for authenticated clients.
Information disclosure in the openssl-encrypt Python pip package (jahlives/openssl_encrypt, all versions before 1.4.0) allows any unauthenticated network caller to extract sensitive database infrastructure details by hitting the /ready health-check endpoint. The endpoint returns raw Python exception strings - including database hostnames, IP addresses, port numbers, driver version, and potentially credentials embedded in connection strings - whenever a database error is triggered. No public exploit code has been identified at time of analysis, but the attack requires only a standard HTTP client and no special conditions against default deployments.
Sandbox bypass in the openssl_encrypt Python plugin (jahlives, all versions before 1.4.0) allows attackers to completely circumvent the restricted_open file access control layer by importing Python's standard pathlib or io modules within the sandbox context, enabling arbitrary file read and write on the host filesystem. The vulnerability is exploitable over the network with no privileges required but requires passive user interaction (UI:P per CVSS 4.0), scoring 8.7 on the CVSS 4.0 scale. No public exploit has been identified at time of analysis, and a vendor-released patch is available in version 1.4.0.
Cryptographically weak PRNG use in openssl_encrypt before 1.4.0 exposes steganographic pixel selection to full state-recovery attacks. The library's steganography module seeds Python's Mersenne Twister with only 64 bits of SHA-256 hash material derived from the user password, then uses it to select pixel positions for hidden data - a design flaw captured by CWE-338. Any attacker who knows or can brute-force the steganography password can deterministically reconstruct the PRNG sequence and enumerate every pixel carrying concealed data, breaking steganographic confidentiality entirely. No public exploit has been identified at time of analysis and no CISA KEV listing exists, but the MT state-recovery technique is well-documented and requires no novel research.
Password exposure in openssl_encrypt before version 1.4.0 allows any local system user to capture plaintext encryption and keystore passwords by reading process argument listings. When operators pass credentials via the --password or -p CLI flags, those values appear verbatim in /proc/[pid]/cmdline and ps aux output on Linux/Unix multi-user systems. No public exploit is identified at time of analysis, though exploitation requires only standard POSIX utilities universally available on Linux; the CVSS 4.0 vector's AV:N designation appears miscalibrated - actual attack surface is local, meaningfully limiting real-world risk.
openssl_encrypt (pip, versions <= 1.4.7) unconditionally prints a derived hardware pepper as a hex string to stdout/stderr when the 'hsm fido2-test' or 'hsm onlykey-test' diagnostic commands are invoked, with output potentially persisting in CI build logs, terminal scrollback buffers, or session recordings. A secondary exposure exists where a related plugin component logged raw prf_data values outside the library's secret-redaction pathway. No public exploit has been identified and no CISA KEV listing exists; critically, the vendor description explicitly states the leaked pepper is derived from a random per-invocation test salt and is salt-bound, meaning it cannot be used to decrypt real files, substantially constraining actual impact despite the elevated CVSS 4.0 score of 8.7.
Weak key derivation in openssl_encrypt versions prior to 1.4.0 enables accelerated offline password cracking against files encrypted by the library. The jahlives/openssl_encrypt PHP library implements PBKDF2 in a non-standard construction - using iterations=1 per inner call within an outer application loop - a design whose formal security properties have not been analyzed and whose brute-force resistance is materially lower than a correctly parameterized PBKDF2 implementation. No public exploit code has been identified at time of analysis, and the library has not been listed in CISA KEV; exploitation is bounded to attackers who have already obtained the encrypted artifacts.
openssl_encrypt (jahlives, versions before 1.4.0) ships with an insecure default trusted_proxies configuration that grants implicit trust to all RFC 1918 private address space in IntegrityProxyConfig, enabling mutual TLS authentication bypass via forged client certificate headers. Any attacker with access to a co-located private network segment can inject a crafted header that the library accepts as a legitimate certificate identity, effectively impersonating an authenticated mTLS principal. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV; however, the authentication bypass class is operationally severe for any deployment relying on mTLS for access control.
Path traversal in SWE-agent's trajectory inspector component (sweagent inspector, confirmed v1.1.0) allows unauthenticated remote clients to read arbitrary JSON-formatted files from the host by injecting parent-directory sequences into the /trajectory/ HTTP endpoint. The inspector server binds to all network interfaces (0.0.0.0) with wildcard CORS and no authentication, meaning any network-reachable client or a malicious web page visited in a browser on the same host can exploit this directly without any credentials or special tooling. Disclosure is architecturally constrained to files parseable as trajectory JSON, but those files routinely capture repository contents, shell command output, and secrets or API keys recorded during prior agent sessions, making the practical impact significant despite the format restriction.
Stack memory disclosure in COVESA Open1722 through version 0.9.2 exposes approximately 18 KB of live process stack memory onto the CAN bus, reachable by any node on that bus. An unauthenticated remote attacker sends a crafted UDP datagram bearing a matching AVTP stream ID; integer truncation in acf-can-listener.c converts avtp_to_can()'s -1 error return to 255 in a uint8_t variable, driving the write loop 255 times over a 15-slot stack array and emitting roughly 240 CAN frames of raw stack contents. No public exploit identified at time of analysis and no CISA KEV listing is present, but the vulnerability mechanism is fully described in the VulnCheck advisory, lowering the barrier to reproduction.
Out-of-bounds heap read in Belledonne Communications bcg729 through 1.1.2 allows unauthenticated network-adjacent attackers to crash the media process or silently corrupt G.729 comfort-noise generation by delivering a single zero-length SID RTP payload. The root cause is an integer underflow in uint8_t arithmetic inside decodeSIDframe() that causes the function to unconditionally attempt reading 11 bytes from a zero-byte heap buffer, resulting in media process termination or consumption of adjacent heap memory as LP filter reflection coefficients. No public exploit identified at time of analysis, but the trigger condition - one malformed RTP packet - represents a trivially low technical barrier for any attacker already on the RTP session path.
Quadratic CPU consumption in sqlparse versions prior to 0.6.0 allows unauthenticated remote denial-of-service via crafted deeply-nested SQL payloads submitted to any application calling sqlparse.parse(), sqlparse.format(), or sqlparse.split(). A ~2KB malicious input with 500-2000 nesting levels can consume approximately 10 seconds of CPU per request - a ~5000x amplification ratio - before depth or token limits raise a SQLParseError. No active exploitation is confirmed in CISA KEV, though the GHSA advisory includes a detailed proof-of-concept demonstrating the attack; CVSS 4.0 rates availability impact as High (8.7) with no authentication required.
Remote unauthenticated denial-of-service in INDI indiserver through 2.2.4.2 allows any attacker with TCP access to port 7624 to crash the daemon with a single malformed packet. The vulnerability stems from an unbounded sprintf() call writing XML error messages into a fixed 1024-byte stack buffer in MsgQueue.cpp - sending mismatched XML tags whose names exceed that boundary overflows the stack frame and terminates the process, immediately disconnecting all active astronomical instrument drivers and client sessions. No public exploit code has been identified at time of analysis and the vulnerability is not listed in the CISA KEV catalog, though the attack primitive is trivially constructible given the deterministic overflow path confirmed in the patch diff.
Local privilege escalation in SiYuan before 3.7.4 allows a low-privileged local attacker to execute arbitrary commands with administrator privileges by crafting a workspace directory whose path contains OS command metacharacters. When the victim triggers the Microsoft Defender exclusion workflow within SiYuan and approves the resulting UAC prompt, the application passes the unsanitized path to the elevated elevator.exe helper process, enabling command injection at administrator level. No public exploit code has been identified at time of analysis, but the CVSS 4.0 score of 8.6 reflects the full-system compromise potential once the attack preconditions are met.
Privilege escalation in Stirling-PDF before 2.9.0 allows any authenticated ROLE_USER to obtain the privileged STIRLING-PDF-BACKEND-API-USER internal service account API key through the pipeline subrequest mechanism, then impersonate that account to bypass rate limits and query sensitive monitoring endpoints such as /api/v1/info/requests/all and /api/v1/info/load/all. The root cause is PipelineProcessor.java injecting the static internal service account key into pipeline subrequests rather than the requesting user's own key, making it retrievable via /api/v1/user/get-api-key. No public exploit or CISA KEV listing exists at time of analysis; vendor-released patch v2.9.0 resolves the issue.
SSRF via DNS rebinding in Budibase's REST datasource integration (versions prior to 3.40.0) lets an authenticated builder or tenant bypass the outbound-fetch IP blacklist by exploiting a TOCTOU gap between hostname validation and undici's independent DNS re-resolution at connection time. Because the REST integration overrides the transport with undici's fetch, the validated Node.js agent pin established by the prior CVE-2026-54353 fix is silently ignored, leaving the single most-used outbound path in Budibase unprotected. An attacker who can configure a REST datasource can reach cloud instance-metadata endpoints to steal IAM credentials, or read from and write to internal services such as CouchDB, Redis, and MinIO with full HTTP method and response access. No public exploit has been identified at time of analysis.
Local privilege escalation in Acer's Planet9 software allows an authenticated local user to achieve arbitrary code execution with SYSTEM privileges by exploiting overly permissive file ACLs on the Planet9 background service executable. The service runs as SYSTEM but the executable it invokes grants write access to non-administrative users, enabling binary replacement. When the service restarts or the host reboots, the attacker-controlled payload executes with full SYSTEM authority. No public exploit has been identified at time of analysis, and this is not listed in the CISA KEV catalog.
SQL injection in Budibase's PostgreSQL datasource connector allows an authenticated administrator to execute arbitrary DDL and DML statements against the connected PostgreSQL database by supplying a crafted schema name containing embedded double quotes. The vulnerable code in packages/server/src/integrations/postgres.ts interpolates the schema field directly into a SET search_path statement using the simple query protocol, which permits semicolon-delimited multi-statement execution. Impact includes full database read and write access - including extraction of pg_shadow password hashes and potential OS-level file reads via pg_read_file(). No public exploit or CISA KEV listing identified at time of analysis; however, the GHSA advisory provides a complete, step-by-step reproduction procedure making this trivially reproducible. Fixed in version 3.39.19.