Path traversal in rclone v1.51.0-v1.74.4 allows an attacker who controls a remote source (confirmed with S3) to create or overwrite files outside the configured local destination directory when the victim uses a non-default local encoding that omits Dot (such as --local-encoding Slash, None, or Raw). The localPath() function in backend/local/local.go failed to validate that the constructed filesystem path remained within the configured root after encoding conversion, enabling crafted remote object names containing .. components to resolve to arbitrary filesystem locations with the permissions of the rclone process. A detailed proof of concept is publicly available in GHSA-7p4m-qxvv-g567; no CISA KEV listing was present at time of analysis, and a Windows-specific backslash traversal variant is additionally confirmed.
Native code execution outside the Chromium sandbox is achievable in Electron prior to 39.8.9, 40.9.2, 41.2.1, and 42.0.0-beta.3 via the DevTools 'reveal in file manager' handler, which incorrectly forwarded attacker-supplied paths to the OS shell-open primitive rather than a safe folder-reveal call. Exploitation requires an attacker to already control JavaScript execution within the DevTools frontend - most plausibly through a malicious DevTools extension - while DevTools is open against a window loading untrusted content. No public exploit code exists and the vulnerability is not listed in CISA KEV; patched releases are available across all active Electron stable and beta branches.
Path traversal in the PocketFlow pocketflow-coding-agent cookbook example exposes arbitrary filesystem reads and writes to any caller who can influence the file-tool arguments supplied to an agent invocation. The vulnerable `_path(workdir, p)` helper wraps `os.path.join` without canonicalization, meaning Python's own documented behavior - returning an absolute `p` unchanged and not resolving `../` sequences - silently discards the intended working-directory containment. Affected file tools include ReadFile, ListFiles, PatchRead, and PatchApply. A publicly available proof-of-concept exists; this is not confirmed in CISA KEV, but the trivial nature of the bypass (standard Python behavior) makes exploitation straightforward wherever the pattern has been copied into production.
Information disclosure in the GeoDirectory WordPress plugin (before 2.8.168) exposes the email addresses of all registered users - including site administrators - to any authenticated Contributor-level or higher user. The root cause is an unrestricted user-search handler that performs no authorization check against WordPress's capability system, meaning any low-privilege authenticated user can invoke it freely. Publicly available exploit code exists per WPScan, though EPSS at 0.14% (4th percentile) and absence from CISA KEV suggest opportunistic exploitation remains limited at time of analysis.
FTP CRLF injection in rclone before 1.75.0 allows an attacker who can place crafted filenames in a source namespace to inject arbitrary authenticated FTP commands when a victim syncs to a more-privileged FTP destination using a non-default encoding that exposes raw CR/LF. The dependency `github.com/jlaffaye/ftp` passes command arguments directly onto the line-oriented FTP control channel via `textproto.Conn.Cmd` without stripping newlines, and the GHSA advisory confirms a real FTP server executed the injected `DELE` command during researcher testing. No public exploit code and no CISA KEV listing are identified at time of analysis; the vendor-released fix is v1.75.0.
Reflected XSS in the TranslatePress WordPress plugin (versions ≤ 3.2.5) allows unauthenticated attackers to inject and execute arbitrary JavaScript in victim browsers by abusing the plugin's internal `#!trpst#`/`#!trpen#` token-to-angle-bracket substitution, which runs after WordPress has already sanitized and escaped the search query parameter. Exploitation requires tricking an authenticated user into clicking a crafted search URL - no server-side authentication is required from the attacker (PR:N per CVSS vector). No confirmed active exploitation (not in CISA KEV) and no public POC have been identified at time of analysis, though the unauthenticated, low-complexity path and large WordPress plugin install base make this a meaningful exposure for unpatched sites.
Reflected Cross-Site Scripting in the Seraphinite Accelerator WordPress plugin (versions ≤ 2.29.15) allows unauthenticated remote attackers to inject arbitrary JavaScript into victim browsers by exploiting a PHP type-juggling flaw that completely bypasses the plugin's HMAC signature verification. The root cause is a two-part chain: the `CacheExtractPreparePageParams()` function uses PHP's loose `!=` operator to validate the nonce, which allows a JSON-decoded boolean `true` to compare as equal to any non-empty HMAC string, and the `_CbContentFinishSkip()` function then concatenates the attacker-controlled `selfTest` field from that unverified payload directly into the HTML response with no escaping. No public exploit or CISA KEV listing has been identified at time of analysis, but a patched version (2.29.18) is available and the Wordfence changeset confirms the vulnerable code paths.
Stored XSS in the Orbit Fox WordPress plugin (versions before 3.0.8) allows authenticated users holding at least the Author role to upload malicious SVG files containing arbitrary JavaScript, which then executes in the browser context of any visitor who views the file - including administrators. The vulnerability is gated on the plugin's optional SVG upload feature being enabled. A public proof-of-concept is available via WPScan; CISA KEV listing is not confirmed, and EPSS sits at a low 0.17% (7th percentile), indicating limited automated campaign targeting at time of analysis. Vendor-released patch version 3.0.8 is available.
Memory exhaustion in rclone's shared HTTP CONNECT proxy helper (`lib/proxy/http.go`) allows a malicious or compromised proxy to crash the rclone process by returning arbitrarily large CONNECT response headers. Versions up to and including 1.74.0 are affected; the fix is confirmed in v1.75.0. No active exploitation has been identified (not in CISA KEV), but the advisory includes a detailed proof-of-concept demonstrating that a 2 MiB header is accepted without error across repeated test runs, and the impact is process-wide OOM affecting all FTP, SFTP, and other rclone mounts concurrently.
Unauthenticated SQL injection in Rongzhitong Visual Integrated Command and Dispatch Platform (all versions through build 20260617) exposes the `/dm/dispatch/user/findAll` endpoint to remote database manipulation via the unsanitized `Name` parameter. A publicly available exploit has been published, and the vendor has not responded to responsible disclosure, meaning no patch exists. With CVSS 4.0 AV:N/PR:N and a live exploit, any internet-exposed deployment is at immediate risk of data extraction or modification.
SQL injection in ESAFENET CDG's USB key login endpoint allows remote unauthenticated attackers to manipulate backend database queries through the unvalidated `keyid` parameter at `/CDGServer3/ukey/usbkey;logindojojs`. All CDG versions up to build 20260615 are affected per CPE data, with impacts spanning limited database read and write access. A public exploit is available (E:P per CVSS 4.0 vector), the vendor has not responded to disclosure, and no patch has been released - leaving all deployed instances exposed with no vendor-confirmed remediation path.
SQL injection in Shandong Hoteam PDM Product Data Management System (versions up to 8.3.10) allows unauthenticated remote attackers to inject arbitrary SQL commands via the `FilterString` parameter of the `GetStoredClassByFilter` function exposed through the `/Base/BaseService.asmx/DataService` ASMX web service endpoint. A public exploit has been disclosed via a Feishu document, elevating real-world risk despite the moderate CVSS 4.0 score of 5.5. The vendor did not respond to responsible disclosure, meaning no patch is available and no remediation timeline exists.
Prototype pollution via Electron's contextBridge allows untrusted renderer-side web content to smuggle a malicious prototype across the isolation boundary into preload script context, bypassing context isolation in versions prior to 39.8.9, 40.9.2, 41.2.2, and 42.0.0-beta.4. Exploitation is conditional on preload scripts accepting object arguments from untrusted content and reading inherited properties without own-property guards. No public exploit has been identified at time of analysis, and the flaw is not listed in CISA KEV; however, the scope-change (S:C) CVSS metric reflects that a successful attack crosses the renderer-to-preload privilege boundary, which can have amplified consequences in apps that expose sensitive Node.js APIs through the bridge.
External protocol handler bypass in Electron allows sandboxed iframes to launch OS-registered external applications, circumventing iframe sandbox enforcement in all Electron versions below 39.8.8, 40.9.0, 41.2.1, and 42.0.0-beta.3. The root cause is that Electron's HandleExternalProtocolInUI function in electron_browser_client.cc failed to inspect WebSandboxFlags before processing external protocol navigation requests, and critically did not forward the frame's sandbox state to the app's permission handler - so even a custom handler could not make an informed allow/deny decision. No active exploitation is confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, but the attack is network-deliverable with no authentication required against apps relying on Electron's default permission configuration.
Stored XSS in the WP Custom HTML Page WordPress plugin (≤0.6.2) enables users with the Author role to persist arbitrary JavaScript via an unsanitized custom page handler, which then executes for every visitor - including administrators - at a publicly accessible URL. The plugin fails both to sanitize HTML input and to enforce WordPress's native unfiltered_html capability restriction, effectively granting Author-level users a privilege they should not have. A publicly available exploit is documented by WPScan; EPSS (0.15%, 5th percentile) indicates no observed widespread opportunistic exploitation, though the public-URL delivery mechanism means admin-targeted attacks require no active phishing.
Electron's window.open() features string parsing forwards untrusted BrowserWindowConstructorOptions directly to child BrowserWindows without an allowlist, allowing renderer-side web content to supply privileged options - such as icon - that cause the trusted main process to access attacker-chosen file or network paths. All Electron apps serving untrusted web content without a setWindowOpenHandler guard are affected across the 39.x, 40.x, 41.x, and 42.x beta series. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog; the practical attack surface is narrowed to apps that load third-party or user-controlled content and omit the recommended setWindowOpenHandler override.
Unauthenticated IDOR in the DHL Shipping Germany for WooCommerce WordPress plugin (versions before 4.0.1) exposes every generated shipping label to any internet visitor. The plugin's label-download endpoint performs no authorization check whatsoever - no capability check, nonce, login requirement, or order-ownership verification - and labels are indexed by predictable sequential IDs, enabling trivial full enumeration. A publicly available exploit exists; successful exploitation leaks customer full names, complete postal addresses, and order references at scale, carrying significant GDPR implications for any German e-commerce operator running the affected plugin.
Unauthorized component instantiation in Nuxt server islands (versions >=3.1.0 <3.21.10 and >=4.0.0 <4.5.1) allows remote unauthenticated attackers to render arbitrary globally-registered Vue components or native HTML elements - including constructs like `<iframe>` - by supplying a crafted string prop to the `/__nuxt_island/` endpoint. The attack exploits Vue's attribute fallthrough behavior: props an island does not declare pass through to its root element, so if that root is a polymorphic component (such as reka-ui or @nuxt/ui elements using an `as` prop), the attacker's string silently reaches dynamic component resolution without any explicit forwarding in the island author's code. Unlike the related RCE vector GHSA-9473-5f9j-94wq, this does not require `vue.runtimeCompiler`, making it reachable in substantially more configurations; however, no public exploit has been identified at time of analysis and real-world exploitation is constrained by application-specific island configuration requirements.
Cross-site request forgery in the GDPR Cookie Compliance WordPress plugin before 5.1.0 allows an unauthenticated attacker to forcibly expire and delete any visitor's session cookies by luring them to a crafted link. The plugin exposes a cookie-expiration action that performs no nonce or request-origin validation, meaning a single malicious URL can silently trigger it in any logged-in user's browser context. Exploitation logs the targeted user out of the WordPress site. A publicly available proof-of-concept exists per WPScan, though EPSS at 0.12% (2nd percentile) indicates exploitation remains rare in the wild; this is not in CISA KEV.
Unauthorized information disclosure in the MLSImport: IDX Plugin & MLS Plugin for Real Estate Listings WordPress plugin (all versions before 7.0.4) exposes import log files and import-related post metadata to any authenticated user, including low-privilege subscribers. The flaw stems from a missing authorization and CSRF check on an AJAX action, meaning any logged-in WordPress user on an affected site can invoke the endpoint and read sensitive operational data. A publicly available proof-of-concept exists (reported by WPScan), though EPSS places exploitation probability at 0.10% and SSVC confirms no known active exploitation at time of analysis.
M-Files Server before version 26.5.16015.3 can be crashed and permanently halted by an authenticated administrator, requiring manual intervention to restore document management services. The vulnerability stems from improper validation of syntactic input correctness (CWE-1286), allowing a privileged user to trigger a process crash from which the server cannot automatically recover. No public exploit code exists and this vulnerability is not listed in CISA KEV, positioning it primarily as an insider-threat or compromised-admin-account risk.
Out-of-bounds heap read in HDF5's N-Bit filter decompression affects all versions through 2.3.0, allowing an attacker who can deliver a crafted HDF5 file to a user or automated pipeline to trigger application crashes and, in constrained cases, leak adjacent heap memory contents into decompressed dataset values. The three affected functions - H5Z__nbit_decompress_one_byte, H5Z__nbit_decompress_one_nooptype, and H5Z__nbit_decompress_one_atomic - advance a buffer read index without bounding it against the actual compressed chunk size, exploitable whenever H5Dread is invoked, including via common tools like h5ls and h5repack. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
Session hijacking via OAuth CSRF in Livebook's Livebook Teams identity provider allows an organization-member attacker to bind a victim's browser session to the attacker's own Teams identity. Livebook versions 0.15.0 through 0.18.6 and 0.19.0 through 0.19.8 are affected when the Livebook Teams ZTA provider is configured, as the OAuth callback handler accepts any valid authorization code without verifying it was issued for the current browser session. The attacker cannot authenticate as the victim, but the victim unknowingly operates under the attacker's identity, exposing notebooks, secrets, and uploaded data to the attacker's account. No public exploit code has been identified and active exploitation has not been confirmed by CISA KEV.
Integer underflow in HDF5 through 2.3.0 allows denial of service when processing Fletcher32-filtered datasets with chunk sizes smaller than 4 bytes. The `H5Z__filter_fletcher32` function in `H5Zfletcher32.c` subtracts the 4-byte checksum length from the input buffer size using an unsigned `size_t` without first verifying the buffer meets the minimum size, causing the result to wrap near `SIZE_MAX` and triggering a massively out-of-bounds read inside `H5_checksum_fletcher32`. Any application or pipeline calling `H5Dread` on a crafted HDF5 file - including the standard `h5ls` and `h5dump` utilities - can be crashed; no public exploit code has been identified and this vulnerability is not in CISA KEV.
Null pointer dereference in HDF5 through 2.3.0 allows denial of service when a user opens a crafted file containing a malformed N-Bit filter pipeline message with zero client-data values. The function H5Z__filter_nbit unconditionally reads cd_values[0] through cd_values[4] before checking whether the array is non-NULL or contains at least 5 elements, crashing any application - including the bundled h5ls and h5repack tools - that calls H5Dread on such a dataset. No active exploitation has been confirmed (not listed in CISA KEV) and no EPSS score was available, but the fix diff publicly exposes the exact crash path, lowering the barrier for proof-of-concept development.
HDF5 library through version 2.3.0 crashes with a divide-by-zero when a process opens a crafted file containing mismatched chunk-layout and dataspace dimensionality. The missing rank validation in H5O__layout_decode allows the corrupt metadata to propagate unchecked to H5S__hyper_iter_get_seq_list, where the invalid value causes integer division by zero and application termination. Tools that automatically consume externally-supplied HDF5 files - such as the bundled h5repack utility - are the primary exposure surface; no public exploit code or confirmed active exploitation has been identified at time of analysis.
Denial of service in GitHub Enterprise Server allows unauthenticated remote attackers to render an instance fully unresponsive by submitting a crafted form-encoded HTTP POST request containing deeply nested parameters, triggering uncontrolled recursive parsing that exhausts both CPU and the pool of request-handling worker processes. Because parameter parsing occurs before routing and authentication checks, every POST endpoint on the instance serves as a viable attack surface, requiring no foothold or prior knowledge of application structure. No public exploit code has been identified and the vulnerability is not listed in CISA KEV; the CVSS 4.0 E:U modifier confirms no known active exploitation at the time of scoring. GitHub has released patches across four supported release trains.
Local root escalation on the ZTE Nubia Red Magic 11 Air (NX799J) gaming smartphone stems from a built-in PostgreSQL service that runs as root, listens on a device port, and is guarded only by weak credentials. Because PostgreSQL's COPY FROM PROGRAM syntax executes OS commands with the server's privileges, any local app that reaches the database can break out of the Android application sandbox and run commands as root. No public exploit identified at time of analysis, though the technique (weak-cred Postgres plus COPY FROM PROGRAM) is well understood and trivially reproducible.
Session isolation bypass in Electron allows a malicious or compromised Chrome extension loaded into one session to cross session boundaries and access, navigate, and script windows belonging to a completely separate session. Affected are Electron applications prior to versions 39.8.8, 40.9.0, 41.2.1, and 42.0.0-beta.3 that invoke session.loadExtension and rely on multi-session architecture as a security boundary - a narrowly scoped but architecturally significant trust boundary violation. No public exploit code or CISA KEV listing exists at time of analysis; exploitation requires attacker control of an extension the application has explicitly loaded.
Insecure Direct Object Reference in the Groundhogg WordPress plugin (all versions through 4.5.2) allows authenticated users holding the view_contacts capability - most notably the built-in Sales Rep role - to enumerate and retrieve any contact record site-wide via the REST API, bypassing the intended ownership restriction that should limit them to their own assigned contacts. The GET /wp-json/gh/v4/contacts/<id> endpoint performs only a role-level capability check and accepts sequential integer IDs, meaning a Sales Rep can trivially iterate through all contact IDs and extract PII, contact metadata, owner identifiers, admin edit URLs, and - for contacts linked to a WordPress account - that user's full capability set. No public exploit code or active exploitation has been identified at time of analysis, but the attack is low-complexity for any attacker who can register or obtain a Sales Rep account.
Cost Calculator Builder for WordPress exposes live payment gateway credentials to any authenticated site user through a missing authorization check on its calculator export AJAX endpoint. All plugin versions through 3.6.17 are affected; attackers holding a Subscriber-level WordPress account - the lowest authenticated role - can invoke the `cost-calculator-custom-export-run` AJAX action to receive a full configuration export containing Stripe secret keys, PayPal client secrets, Razorpay secret keys, webhook secret keys, and reCAPTCHA secret keys. No public proof-of-concept exploit or CISA KEV listing has been identified at time of analysis, but the attack requires only a valid site account and basic HTTP knowledge, and an upstream fix has been committed to the plugin's trunk repository.
Path traversal in IBM Langflow OSS 1.0.0-1.10.3 allows authenticated low-privilege network attackers to inject directory traversal sequences into the username field, bypassing containment checks. Successful exploitation enables arbitrary directory deletion, cross-tenant data destruction, and deletion of JWT signing keys - the last of which forces platform-wide session invalidation for all users. No public exploit or CISA KEV listing has been identified at time of analysis, though the operational impact in multi-tenant deployments is severe despite the moderate CVSS score of 6.5.
Privilege escalation via command injection in Cisco Integrated Management Controller (IMC) allows authenticated Admin-level attackers to execute arbitrary OS commands and elevate to root on affected Cisco UCS Standalone and E-Series systems. Exploitation requires Admin credentials to the web-based management interface but results in full OS root access, which Cisco rates as High SIR despite a CVSS 6.5 (Medium) score - explicitly noting that root attainment carries security implications beyond what the base score reflects. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.
Second-order SQL injection in the User Access Manager WordPress plugin (versions ≤ 2.3.12) enables authenticated attackers with subscriber-level access to exfiltrate arbitrary data from the WordPress database. The vulnerability is rooted in a stored objectId value that bypasses validation at write time but is later imploded directly into a SQL NOT IN() clause without integer casting or prepared statements, exploiting a classic second-order injection pattern across two distinct code paths. No public exploit code or CISA KEV listing has been identified at time of analysis; however, the low privilege requirement (subscriber-level) and high confidentiality impact make this a meaningful priority on sites with open user registration or untrusted authenticated users.
SQL injection in the WP ERP WordPress plugin (all versions through 1.17.4) allows authenticated CRM Agent-role users to extract arbitrary data from the WordPress database by supplying a crafted 'erpadvancefilter' parameter to the CRM AJAX handler. The root flaw is a sanitization gap: sanitize_text_field strips HTML but preserves single quotes, which are then interpolated verbatim into a single-quoted SQL WHERE clause inside erp_crm_contact_advance_filter() before execution via $wpdb->get_results(), bypassing WordPress's parameterized query protections entirely. No public exploit has been identified at time of analysis, but the vulnerable code paths are fully documented in WordPress plugin trac source references provided by Wordfence.
Prometheus metric label cardinality exhaustion in Red Hat Build of Keycloak allows any authenticated user to crash the service by flooding its metric store with unique entries. When the Keycloak metrics subsystem is active, failed account operations (such as login attempts referencing nonexistent client IDs) cause raw, unsanitized error strings to be registered as Prometheus label values; because Prometheus stores each unique label combination as a distinct time series, a low-privileged attacker can generate an unbounded number of distinct metric entries, consuming JVM heap until the process crashes or becomes unresponsive. No public exploit code and no CISA KEV listing exist at time of analysis, but the low attack complexity and broad authenticated-user surface make this a realistic denial-of-service risk in any deployment where metrics are enabled.
Path traversal in IBM Langflow OSS 1.0.0-1.10.3 exposes arbitrary server filesystem files via a crafted MCP `resources/read` request using URL-encoded traversal sequences. Authenticated low-privilege users can read other users' uploaded documents, the JWT signing secret, the SQLite database, and process environment variables - leaking the JWT secret effectively enables token forgery and full account takeover beyond what the CVSS 6.5 score implies. No public exploit identified at time of analysis; vendor patch is available per IBM advisory.
Unauthenticated SSRF-adjacent resource abuse in Layouts for WPBakery (all versions ≤ 1.1.3) allows any remote attacker to force the WordPress host to issue unlimited outbound HTTP requests to the plugin vendor's external REST API and write the decoded JSON responses directly into the site's wp_options database table. The missing capability check on the wp_ajax_nopriv_handle_sync action (CWE-862) exposes this endpoint to every unauthenticated client with no nonce verification or rate limiting in place. This vulnerability is not listed in CISA KEV and no public exploit code has been identified, but the trivially low attack complexity - unauthenticated, network-reachable, zero prerequisites - makes availability abuse a realistic and automatable threat.
SQL injection in the WP Post Author WordPress plugin (all versions through 3.9.1) enables authenticated attackers with author-level access to extract arbitrary data from the WordPress database. Exploitation follows a deliberate two-step chain: the attacker stores a malicious payload in the `wpma_metabox_authors_list` parameter during post creation or editing, and the injection fires when any administrator loads the post list screen at `/wp-admin/edit.php`, rendering injected SQL results in the Authors column. No public exploit or CISA KEV listing has been identified at time of analysis; however, Wordfence has published a threat-intelligence record and the vulnerable source lines are publicly browsable in the plugin SVN repository.
SQL injection in Relevanssi's Admin Search AJAX handler (both free and Premium editions) allows authenticated WordPress contributors to perform time-based blind SQL injection against the site's database, exposing all stored data including user password hashes and private content. The taxonomy query argument passed through the `args` parameter is sanitized against XSS but never parameterized before SQL interpolation, violating the principle that sanitization and parameterization are distinct concerns. No public exploit has been identified at time of analysis, but the low privilege bar - contributor-level access, attainable on any site with open registration - meaningfully widens the realistic attack surface beyond what the 6.5 CVSS score alone conveys.
Unauthorized configuration takeover in the Udimi Tools WordPress plugin (≤ 3.2) is possible for any subscriber-level authenticated user due to missing capability checks on both the `ajax_disconnect()` and `ajax_connect()` AJAX handlers. An attacker with a valid low-privilege WordPress account can wipe the site's Udimi API key and connected account settings, then replace them with attacker-controlled credentials - effectively hijacking the site's Udimi solo-ad integration and redirecting lead tracking data. No public exploit code or CISA KEV listing exists at time of analysis; EPSS data was not provided.
IV reuse in libkcapi's one-shot symmetric cipher operations allows a remote attacker to weaken data confidentiality for applications processing inputs larger than 64 KiB under stateful modes (CTR or CBC). Affected deployments include Red Hat Enterprise Linux 8, 9, and 10, Red Hat Hardened Images, and OpenShift Container Platform 4. No public exploit or active exploitation has been identified; the AV:N vector reflects an indirect attack path where an adversary induces a vulnerable application to process specially crafted oversized inputs, enabling ciphertext analysis to expose plaintext relationships or recover data.
SQL injection in ChirpStack's SQLite-backend device tag filtering exposes the full database contents to any authenticated user with device-list access. The flaw lives in `chirpstack/src/storage/device.rs` within both `get_count()` and `list()`, where the tag KEY is concatenated into raw SQL via Rust's `format!()` macro while only the tag VALUE receives safe parameterization through Diesel's `.bind()`. Only deployments using the `chirpstack-sqlite` package are affected - the PostgreSQL backend uses Diesel's native JSONB containment operator and is architecturally immune. No public exploit code or CISA KEV listing has been identified at time of analysis.
Authenticated users in IBM Langflow OSS 1.0.0 through 1.10.3 can exploit a privileged built-in component to read arbitrary server-side environment variables, bypassing security controls designed to restrict custom component execution. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H) confirms this is a low-complexity, network-accessible flaw requiring only standard user credentials, with high confidentiality impact. No active exploitation confirmed via CISA KEV, and no public exploit code has been identified at time of analysis; IBM has released a patch via its support portal.
Server-Side Request Forgery in KubeSphere's multi-cluster controller allows any low-privileged user with Cluster CRD create or update permissions to weaponize the controller-manager and apiserver pods as HTTP proxies against arbitrary internal addresses, RFC1918 networks, and cloud instance metadata services including AWS IMDS at 169.254.169.254. The flaw resides in `pkg/utils/clusterclient/clusterclient.go` (addCluster), where the CRD-specified Kubernetes API endpoint undergoes only Go `url.Parse()` syntax validation before `Discovery().ServerVersion()` is called - no loopback, private-range, link-local, or metadata-address filtering is applied. A public researcher write-up demonstrating the attack path exists; no active exploitation has been confirmed in CISA KEV at time of analysis.
ESPHome's built-in web server unconditionally leaks plaintext passwords stored in password-mode text entities to any unauthenticated attacker on the local network. The web_server component on port 80 - which carries no authentication by default - serializes text entities with a dual-field JSON structure where the 'state' field is correctly redacted to '********' but the 'value' field is always populated with the raw secret via set_json_icon_state_value()/set_json_value(), exposing WiFi credentials, API tokens, and similar secrets through a trivial GET request or the /events EventSource stream. No public exploit code or CISA KEV listing has been identified at time of analysis, but exploitation requires only standard HTTP tooling against any reachable device with the web_server component enabled.
Host header injection in SonicWall SonicOS enables remote unauthenticated attackers to manipulate the HTTP Host header on the firewall management interface, causing redirect responses that send management users to attacker-controlled web domains. Affected version branches span the SonicOS 6.5, 7.0, 7.3, and 8.2 lines, covering a wide installed base of SonicWall firewalls. No public exploit code exists and this vulnerability has not been added to CISA KEV at time of analysis, but the unauthenticated network-accessible attack surface and management-user targeting make it a meaningful phishing risk in environments where the management interface is internet-exposed.
Server-side request forgery in IBM Langflow OSS 1.0.0 through 1.10.3 allows low-privileged authenticated users to force the server to make arbitrary outbound HTTP requests to internal or restricted network destinations due to incomplete enforcement of the platform's built-in SSRF protections. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) confirms network-reachable exploitation at low complexity with high confidentiality impact, making cloud metadata endpoints and internal services realistic targets. No public exploit has been identified at time of analysis, and no active exploitation has been confirmed by CISA KEV.
Insecure Direct Object Reference in Akaunting's multi-tenant file download route exposes uploaded media records across company boundaries to any authenticated portal customer. The `uploads/{id}/download` endpoint in `app/Http/Controllers/Common/Uploads.php` applies only generic authentication middleware and fetches Media records by raw integer ID without verifying tenant ownership, enabling sequential ID enumeration to exfiltrate invoices, financial statements, and other uploaded documents belonging to unrelated companies on the same instance. No public exploit has been identified and it is not listed in CISA KEV, but the attack is trivially executable by any portal customer given the low complexity of sequential integer enumeration.
Credential exfiltration via SSRF in Paperless-ngx's mail account test endpoint allows an authenticated user holding only object-level change_mailaccount permission to redirect IMAP test connections to an attacker-controlled host, causing the application to transmit stored plaintext passwords or OAuth tokens to that host. The MailAccountViewSet.test() action accepts caller-supplied imap_server, imap_port, and imap_security parameters while silently reusing the real stored credentials when a masked password placeholder is submitted - a design flaw that converts a benign connectivity test into an unanticipated credential-forwarding primitive. No public exploit code has been identified and this CVE is not currently listed in the CISA KEV catalog.