Horizontal privilege escalation in Leantime through 3.6.2 allows any authenticated user to read live TOTP secrets or strip two-factor authentication from arbitrary accounts via unenforced JSON-RPC endpoints, fully defeating per-account 2FA protection. The four affected methods - getSetupData, saveSecret, verifyAndEnable, and disable2FA - accept a caller-supplied userId with no ownership check, session pinning, or permission gate, unlike other methods in the same RPC dispatcher. No public exploit has been identified at time of analysis and the flaw is not listed in CISA KEV, but the low exploitation complexity (authenticated, network-accessible, no user interaction) makes it a credible lateral-escalation risk in any multi-user Leantime deployment.
URI normalization bypass in Keycloak's Authorization Services PathMatcher allows authenticated low-privilege users to reach administrative or restricted endpoints by appending trailing slashes or matrix parameters to request URIs. Affected deployments include Red Hat Build of Keycloak, Red Hat Single Sign-On 7, Red Hat Data Grid 8, and Red Hat JBoss EAP Expansion Pack. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog, though the high CVSS confidentiality and integrity impact scores reflect meaningful privilege escalation risk in production environments.
MailChimp Forms by MailMunch (WordPress plugin) versions up to and including 3.2.7 allows any authenticated subscriber-level user to silently hijack the site's MailMunch account integration, redirecting all captured lead data to an attacker-controlled account. The missing capability check on the `sign_in()` and `sign_up()` AJAX handlers (CWE-862) means a low-privilege WordPress account is sufficient to relink the plugin to an attacker's own MailMunch account - after which every form submission is delivered to the attacker and the site's forms and landing pages are served from the attacker's MailMunch workspace. No public exploit code has been identified at time of analysis, but the attack surface is trivially accessible to any authenticated user.
Privilege escalation in Keycloak's Dynamic Client Registration (DCR) component allows attackers with standard user accounts and limited Initial Access Tokens to forge administrative roles directly into their own access tokens. The underlying flaw is a missing claim-path validation in the default DCR policy for User Property mappers, which permits writing attacker-controlled values into sensitive internal claim locations that normally carry role and privilege assertions. Successful exploitation enables takeover of other registered OAuth clients, exfiltration of confidential client secrets, and full administrative control over the affected Keycloak realm. No confirmed active exploitation or public exploit code is identified at time of analysis.
Server-side template injection in DjangoCRM's massmail module allows authenticated users with mass-mail edit rights to execute arbitrary Django Template Language expressions by injecting syntax into EmlMessage subject and content fields, which are passed unsanitized to Django's Template() constructor across three separate code locations. Successful exploitation can disclose other users' account data and password hashes from Django request context variables, exfiltrate CSRF tokens enabling cross-site request forgery, and include arbitrary registered templates. No KEV listing or public exploit code has been identified at time of analysis, but the low attack complexity and high-confidence CVSS 8.1 rating indicate meaningful risk for deployments where mass-mail edit rights are granted to non-administrator users.
Privilege escalation in Progress MarkLogic Server's REST API document processing pipeline allows an authenticated user holding an administrative REST role to elevate their access to a higher privilege level, resulting in unauthorized disclosure of sensitive server-side data. Affected versions span both the 11.x and 12.x release trains, patched in 11.3.6 and 12.0.3 respectively per the vendor's August 2026 critical security bulletin. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog, though the scope change (S:C) and high confidentiality and integrity impact in the CVSS vector underscore meaningful post-exploitation consequence within the MarkLogic environment.
Stored cross-site scripting in Uptime Kuma's Matomo analytics integration allows an admin or editor-level user to inject arbitrary JavaScript into every public status page by saving a crafted `siteId` value. The escaping pipeline in `server/analytics/matomo-analytics.js` - combining `jsesc` with `isScriptContext:true` and `html-escaper.escape()` - fails to neutralize JavaScript syntax characters (`]`, `)`, `;`, `(`), which are sufficient to break out of the `_paq.push(['setSiteId', ...])` expression context. Every unauthenticated visitor of any `/status/<slug>` page subsequently executes the attacker-controlled JavaScript, enabling session cookie theft and full page takeover. No public exploit has been independently confirmed, though the disclosure includes a functional proof-of-concept payload; no KEV listing exists at time of analysis.
Broken access control in IBM Langflow OSS 1.0.0-1.10.3 allows any authenticated user to inject arbitrary graph data into the shared execution cache for flows they do not own, via the deprecated POST /api/v1/build/{flow_id}/vertices endpoint. The endpoint performs no ownership validation, enabling cross-user cache pollution that can corrupt other users' workflow state, trigger unauthorized execution of foreign flows, or produce denial of service across a shared platform instance. No public exploit code exists and CISA KEV does not list this vulnerability; EPSS (0.20%, 10th percentile) and SSVC (exploitation: none, automatable: no) collectively indicate low immediate exploitation risk despite the high CVSS score.
Cross-site request forgery in the Search Analytics for WP WordPress plugin (all versions through 1.4.16) allows an unauthenticated remote attacker to permanently delete all search-term records and associated search-history rows by tricking an authenticated Administrator into clicking a crafted link. The root cause is a complete absence of nonce validation in the `process_bulk_action()` function of the `MWTSA_Stats_Table` class, meaning any forged HTTP request that reaches the endpoint during a valid admin session will execute destructive bulk-delete operations unchallenged. No public exploit code or CISA KEV listing is identified at time of analysis, but the low attack complexity and irreversible data-loss impact elevate practical risk for any WordPress deployment relying on this plugin's analytics data.
Unauthorized access to other users' personal data in SirenGPS Android Application 2.19.44 stems from the backend API failing to verify that a requesting user is authorized to act on the target user identifier supplied in API parameters. An authenticated attacker exploiting this horizontal privilege escalation can read and overwrite arbitrary users' personal information with only low-privilege access. No public exploit identified at time of analysis and EPSS is extremely low (0.15%, 5th percentile), but a detailed researcher advisory is publicly available on GitHub, lowering the bar for replication.
Remote code execution and arbitrary file deletion in Zigbee2MQTT stem from an unsanitized path.join() call in ExternalJSExtension.getFilePath() (lib/extension/externalJS.ts), allowing any MQTT client with publish access to escape the extensions directory via traversal sequences and write arbitrary files to the host filesystem. Once the malicious .js file is written, Zigbee2MQTT immediately imports it via Node.js import(), executing attacker-controlled code in the application process context. The same vulnerable code path also backs the extension-removal handler, yielding a second primitive for arbitrary file deletion. No public exploit or KEV listing was identified at time of analysis, but the exploitation path is mechanically straightforward given the detailed description.
OS command injection in @oblique/cli 15.4.0 allows arbitrary shell command execution on the local system when a developer invokes the project-creation feature with a crafted project name. The CLI passes user-supplied input directly into shell commands via string concatenation before calling Node.js execSync(), meaning shell metacharacters (semicolons, backticks, pipes) in the project-name argument are interpreted by the OS shell. The attack is limited to local execution contexts - an attacker must either control the project name passed to the CLI or socially engineer a developer into supplying a malicious string. No public exploit or CISA KEV listing has been identified at time of analysis, and a vendor patch (>=15.4.2) is available.
Incorrect buffer size calculation (CWE-131) in an unidentified Linux distribution package tracked by both Ubuntu and Red Hat enables local, user-interaction-triggered exploitation with high confidentiality, integrity, and availability impact, yielding a CVSS base score of 7.8. The local attack vector combined with a user-interaction requirement (AV:L/UI:R/PR:N) is consistent with a malicious file parsing scenario, where a user opens a crafted input triggering the buffer miscalculation. No public exploit has been identified at time of analysis, and no KEV listing is present; however, the full C:H/I:H/A:H impact triad indicates potential for memory corruption leading to arbitrary code execution.
Double-free memory corruption in the Linux kernel's mac80211 WiFi subsystem exposes systems running in WiFi 6 AP mode with FILS discovery configured to potential kernel heap corruption and privilege escalation. The flaw in ieee80211_set_fils_discovery() prematurely queues the old template for deferred freeing before confirming the new allocation succeeds; when kzalloc() fails, a stale pointer is retained and freed a second time upon AP teardown or reconfiguration. No public exploit identified at time of analysis; EPSS is 0.19% (8th percentile), consistent with the constrained exploitation prerequisites.
Use-after-free race condition in the Linux kernel's RDMA/rxe (SoftRoCE) subsystem allows a local unprivileged user to trigger a kernel crash or achieve page-level memory corruption. The race occurs between rxe_mmap() - which releases pending_lock while a rxe_mmap_info kref is still live - and a concurrent DESTROY_CQ ioctl that drops the kref to zero, causing vfree() to clear vmalloc PTEs mid-walk in remap_vmalloc_range_partial(). No CISA KEV listing exists and EPSS is 0.16% (5th percentile), reflecting the race's very narrow exploitation window; however, the C:H/I:H/A:H impact and confirmed upstream patch make this a priority update for any environment with RDMA/rxe loaded.
Double reference-count release (double netdev_put()) in the Linux kernel's IPv6 XFRM/IPsec policy subsystem allows a local low-privileged user to underflow a net_device refcount, producing kernel ref_tracker warnings and 'unregister_netdevice: waiting for <dev> to become free' hangs that can destabilize or crash the system and potentially enable privilege escalation through kernel memory corruption. The flaw exists in xfrm6_fill_dst() at net/ipv6/xfrm6_policy.c: on the error path where in6_dev_get(dev) returns NULL, netdev_put() is called but xdst->u.dst.dev is not cleared, so dst_destroy() later releases the same reference a second time. No public exploit and no CISA KEV listing have been identified at time of analysis; EPSS is 0.16% (5th percentile), indicating currently low automated exploitation probability.
Use-after-free in the Linux kernel mac80211 MLO (Multi-Link Operation) subsystem allows a local attacker with low privileges to corrupt kernel memory by reading stale debugfs entries after a failed ieee80211_vif_update_links() operation. Systems running kernel 6.4 or later with WiFi 7 (IEEE 802.11be) MLO-capable hardware are within the affected code path; patched releases are available across all active stable branches. No public exploit or CISA KEV listing exists and EPSS is 0.16%, but CVSS impact metrics of C:H/I:H/A:H indicate full kernel compromise potential if the vulnerability is successfully triggered, as confirmed by a KASAN slab-use-after-free trace referencing a task named 'exploit/145'.
Double-free memory corruption in the Linux kernel's mac80211 WiFi subsystem allows a local attacker with low privileges to corrupt kernel heap memory, potentially leading to privilege escalation or denial of service. The flaw exists in ieee80211_set_unsol_bcast_probe_resp(), where kfree_rcu() is invoked on the old unsolicited broadcast probe response template before a new one is successfully allocated - if kzalloc() then fails, the stale pointer is re-queued for freeing during AP teardown or subsequent configuration updates, triggering a KASAN-detected double-free in softirq context. No public exploit exists and EPSS is extremely low (0.16%, 5th percentile), but the local PR:L CVSS vector and high C/I/A impact scores make this a meaningful kernel hardening target for multi-tenant or shared Linux environments.
Slab-out-of-bounds read in the Linux kernel btrfs free space cache loader allows a local attacker to trigger kernel memory corruption by supplying a crafted btrfs filesystem with an inflated num_entries value in the on-disk btrfs_free_space_header. All Linux kernel versions from commit 5b0e95bf607d through the patched stable releases across the 6.6, 6.12, 6.18, 7.1, and 7.2 series are affected. An attacker who can mount or cause the kernel to process such a crafted volume causes the io_ctl->index pointer to walk past the pages[] array boundary, with the overrun slot treated as a struct page and passed to crc32c(), culminating in a general protection fault with kernel code execution or information disclosure potential. No public exploit has been identified and this vulnerability is not in CISA KEV; EPSS places exploitation probability at the 5th percentile.
Double-release memory corruption in the Linux kernel's BPF TCP iterator (bpf_iter_tcp_batch) allows a local low-privileged user with BPF iterator access to trigger a kernel panic. When batch reallocation fails, the first bpf_iter_tcp_put_batch() call frees socket references and overwrites batch slots with socket cookies; if realloc then fails, the iterator's stop routine executes a second put_batch() and dereferences those cookie integer values as struct sock pointers, causing a KASAN-detected null-pointer dereference and kernel panic. No public exploit identified at time of analysis; EPSS is 0.15% (5th percentile), indicating low current automated exploitation probability.
Double-free use-after-free in the Linux kernel's xfrm (IPsec) subsystem allows a low-privileged local user to corrupt kernel heap memory, potentially achieving privilege escalation. The race condition in xfrm_user_policy() between a non-atomic sk_dst_cache reset via setsockopt and the UDP fast-path's atomic xchg() reset causes both code paths to observe the same dst pointer and call dst_release() twice, freeing the xfrm_dst bundle while still in use. Critically, the description confirms this is reachable by an unprivileged user via user and network namespaces, making it exploitable on most modern Linux distributions where user namespaces are enabled by default. No public exploit exists and no KEV listing, but the KASAN-confirmed write-to-freed-memory primitive is a classic kernel privilege escalation vector.
Heap buffer overflow in dr_libs dr_wav.h enables arbitrary code execution in 32-bit applications that parse untrusted W64 WAV files containing CUE chunk metadata. The flaw stems from a two-stage allocation mismatch: stage-1 capacity estimation silently truncates a 64-bit W64 chunk size to 32-bit size_t, under-allocating heap space, while stage-2 writes using the full attacker-controlled cuePointCount field without validating against that flawed estimate. The sole runtime guard (DRWAV_ASSERT) is compiled out under -DNDEBUG, the default for release builds, making exploitation silent in production. No active exploitation is confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis.
Privilege escalation in CCleaner's Uninstaller component on Windows allows a local low-privileged attacker to gain SYSTEM-level access by planting an NTFS symlink or directory junction before or during application uninstallation. The uninstaller executes file deletion with elevated (SYSTEM) integrity and follows the attacker-controlled link without validation, redirecting destructive operations to arbitrary system paths. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis; Gen Digital has released a fix in CCleaner 7.10.1464.
Stack-based buffer overflow in tinyobjloader-c's MTL material file parser allows an attacker who can supply a crafted 3D asset to corrupt the call stack of any application that loads it, potentially achieving arbitrary code execution. All versions of syoyo/tinyobjloader-c are affected because the only bounds guard in tinyobj_parse_and_index_mtl_file() is an assert() call that compiles to a no-op under -DNDEBUG - the standard flag for release builds - leaving memcpy(linebuf, p, p_len) completely unchecked. The identical vulnerable pattern is duplicated in a second function in the same header file, and no vendor-released patch has been identified at time of analysis. No public exploit code and no CISA KEV listing have been identified.
Full unauthenticated access to Livebook 0.19.7-0.19.9 is possible when a Livebook Agent or App Server's deployment group is deleted from Livebook Teams while the agent is temporarily disconnected. A logic error in `Livebook.Hubs.TeamClient.handle_call/3` causes the zero-trust authentication layer to treat an unresolvable cached deployment group identifier identically to one with identity enforcement deliberately disabled, allowing any network-reachable client to read notebooks and secrets, execute code on the server runtime, and disrupt operations without authentication. No public exploit has been identified at time of analysis, and no CISA KEV listing is present, but the high confidentiality, integrity, and availability impact (CVSS 4.0: 7.7) warrants prompt patching for all Teams-connected deployments.
Path traversal in IBM Langflow OSS versions 1.0.0 through 1.10.3 enables authenticated remote attackers to read arbitrary files on the underlying system by submitting URLs containing dot-dot sequences (/../). The CVSS scope change metric (S:C) confirms that exploitation reaches beyond the application's own directory boundary, exposing system-level files such as credentials, configuration, or private keys to any low-privileged account holder. No public exploit code has been identified at time of analysis, though IBM has released a patch via advisory node/7282647.
Denial of service in Cisco IOS XE Software's SNMP subsystem allows an authenticated remote attacker to force an affected device to reload by sending a malformed SNMP request, disrupting all traffic transiting the device. The vulnerability spans all three SNMP protocol versions (1, 2c, and 3) and affects an exceptionally broad version range across both the 3.x, 16.x, and 17.x release trains. No public exploit or CISA KEV listing has been identified at time of analysis, but the scope-change rating (S:C) reflects that a device reload cascades into a network outage for all downstream systems dependent on the affected device.
Remote availability disruption in Cisco Catalyst SD-WAN Manager and Controller allows a low-privileged authenticated attacker over the network to cause high-availability impact with scope change - affecting resources beyond the directly targeted component. Discovered internally by Cisco's SD-WAN engineering team during a proactive security review and addressed in software hardening releases, this vulnerability is not confirmed as actively exploited (not in CISA KEV) and no public exploit code is known at time of analysis. The CVSS 7.7 (High) score reflects the combination of network accessibility, low authentication bar, no user interaction required, and high availability consequence with scope change.
OS command injection in the Backup Migration WordPress plugin (all versions through 2.1.5.1) allows authenticated attackers holding Administrator-level access - or any user granted the plugin's custom `do_backups` capability - to execute arbitrary operating-system commands as the web-server user. The flaw stems from misuse of `esc_attr()`, an HTML sanitizer, as a shell sanitizer in the `restoreBackup()` AJAX handler, enabling shell metacharacter injection into an `exec()` call. This represents an incomplete remediation of CVE-2023-7002; the equivalent fix applied to `handleQuickMigration()` was never ported to the `$backupName` variable path. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Session persistence after password change in Flarum before 1.8.16 allows an attacker who already holds a valid session token to maintain full account access indefinitely, even after the victim resets their password. The `TokensClearer::clearPasswordTokens()` function clears only the `password_tokens` table and never touches the `access_tokens` table, so all active session cookies, API bearer tokens, and long-lived RememberAccessToken entries survive both user-initiated and administrator-forced password resets. No public exploit has been identified at time of analysis; vendor-released patch v1.8.16 resolves the issue.
PHP Object Injection in Cotonti CMS's Comments plugin grants any authenticated member a deserialization primitive reachable via two default-accessible sinks, with a working POP chain already demonstrated by the researcher. The `ci` POST parameter in CreateAction.php and the `cb` parameter in EditAction.php are both base64-decoded and passed to `unserialize()` without an `allowed_classes` restriction, allowing instantiation of any class loaded in the PHP runtime. A proof-of-concept using Cotonti's built-in MySQL_cache class was confirmed to trigger attacker-controlled SQL INSERT operations via `__destruct()->flush()`; further impact including RCE is contingent on additional gadget chains available in a given installation. No public exploit code has been released and no CISA KEV listing exists at time of analysis.
Sensitive information exposure in the Page and Post Restriction WordPress plugin (versions ≤ 1.4.0) allows unauthenticated attackers to read the full rendered content of every published page and post on sites relying on the plugin's global privacy toggles. The plugin's REST API guards - `papr_restrict_page_post_rest_api()` and the `the_posts` filter in `papr_filter_posts()` - consult only per-post/page metabox settings and completely ignore the 'Make all Pages Private' and 'Make all Posts Private' global options, leaving the `/wp-json/wp/v2/pages` and `/wp-json/wp/v2/posts` endpoints unguarded. No public exploit is identified at time of analysis, but the attack is trivially executable with a single unauthenticated HTTP GET request.
Denial-of-service via buffer overflow in open62541 v1.5.5 allows a remote, unauthenticated attacker to crash an OPC UA server by sending a crafted Service_Call request with malformed input arguments. The flaw resides in the method-call service handler (ua_services_method.c), where input arguments are validated against runtime-resolved InputArguments metadata without proper bounds enforcement. No active exploitation or CISA KEV listing has been identified at time of analysis, but the network-accessible attack surface and zero-privilege requirement make this a meaningful availability risk for any OPC UA server deployment based on this library version.
Unauthenticated arbitrary file read in Eclipse Theia browser-mode deployments (versions ≤1.73.1) allows any network client to exfiltrate files accessible to the backend process, including paths outside the opened workspace such as SSH keys, cloud credential tokens, and system configuration files. The vulnerability combines two compounding flaws: the `@theia/filesystem` HTTP endpoints perform no workspace confinement when resolving client-supplied URIs to filesystem paths, and a middleware defect in `@theia/core` re-issues the session cookie and calls `next()` without validating the connection token on HTTP requests - token enforcement applies only to WebSocket upgrades, leaving all HTTP file endpoints fully exposed. Electron deployments are explicitly not affected via this path. No public exploit is identified at time of analysis.
Missing authorization on Penpot's ::import-binfile RPC command allows any authenticated user to overwrite arbitrary files across team boundaries and subscribe to WebSocket events for any file on the instance, enabling cross-tenant data exfiltration and data poisoning. All Penpot deployments on versions up to and including 2.17.0 are affected per EUVD intelligence, with a proof-of-concept publicly documented by vokecyber.com. The provided CVSS vector critically understates impact: it omits confidentiality and integrity loss despite the described full data exfiltration and file overwrite capability, and marks the vulnerability as unauthenticated (PR:N) contrary to the description's explicit 'authenticated user' requirement - defenders should not rely on the published vector for risk prioritization.
Unbounded memory allocation in Rancher Manager's API audit logging middleware enables unauthenticated remote attackers to crash the Rancher management plane via memory exhaustion. When API audit logging is enabled, the audit copyReqBody middleware - positioned ahead of Rancher's APIBodyLimitingHandler in the handler chain - reads entire HTTP request bodies into memory on public login endpoints with no size cap, bypassing the default 1 MiB limit. An attacker sending a small number of concurrent oversized requests to these endpoints can exhaust server memory and terminate the Rancher Manager process, rendering the Rancher API and UI unavailable and severing management control of all downstream Kubernetes clusters. No public exploit has been identified at time of analysis.
Path traversal in Eclipse Theia's plugin-hosting HTTP endpoint (versions 1.66.0 through 1.73.1) enables unauthenticated remote attackers to exfiltrate arbitrary files readable by the Theia backend process by injecting percent-encoded directory traversal sequences. The `/hostedPlugin/:pluginId/:path(*)` endpoint passes user-supplied path data directly into `path.resolve()` without subsequently verifying the resolved path stays within the plugin directory boundary. Critically, because plugin IDs are deterministically derived from publisher and plugin name, an attacker can use well-known built-in plugins as traversal anchors without any prior reconnaissance of the target system. No public exploit code or CISA KEV listing has been identified at time of analysis.
Server-side use-after-free in open62541 1.5.5 allows a remote attacker to crash an OPC UA server process, causing denial of service. The flaw arises in the local MonitoredItem subscription path where UA_Subscription_localPublish continues dereferencing a UA_Notification object after a callback has already freed it by calling UA_Server_deleteMonitoredItem on the active item. No public exploit or CISA KEV listing has been identified; impact is limited to availability with no confidentiality or integrity exposure.
Unauthenticated SQL injection in the VikAppointments Service Booking Calendar WordPress plugin allows remote, unauthenticated attackers to read arbitrary data from the site's database - including WordPress user credential hashes - by manipulating the sort-order parameter on the public reviews list endpoint. The vulnerability stems from unsanitized user-controlled input passed directly into a database ORDER BY clause in lib.vikappointments.php (lines 5907 and 6011), reachable through both the servicesearch and employeesearch public views. No public exploit has been identified at time of analysis, though the unauthenticated network vector and high confidentiality impact make this a credible priority for WordPress sites running this plugin.
Hardcoded RTSP credentials in Zosi C519M IP camera firmware V4.2.8.823C01450BA expose live video feeds to any network-reachable attacker. The built-in credentials embedded in the RTSP authentication mechanism cannot be changed by the device owner, making every affected unit permanently vulnerable to unauthorized stream access. A public proof-of-concept exists on GitHub, and CISA's SSVC framework rates the attack as automatable with no exploitation preconditions beyond network reachability - no public exploit identified as actively exploited in CISA KEV at time of analysis.
Blind SQL injection in the TableOn - WordPress Posts Table Filterable plugin (versions ≤ 1.0.5.1) exposes WordPress user credentials to unauthenticated remote attackers via a public AJAX endpoint. The `filter_data[comment_count]` parameter is split on a colon delimiter and both halves are interpolated directly into a `posts_where` SQL clause without `intval()` casting or `$wpdb->prepare()` sanitization, enabling blind query appending. A researcher confirmed extraction of database metadata, all WordPress usernames, and password hashes; the fix is available in version 1.0.6, and no public exploit code has been identified at time of analysis.
Arbitrary file read in art-template's sub-template resolution logic exposes any file accessible to the Node.js process when application code passes externally-controlled input into include() or extend() template directives. The flaw exists in src/compile/adapter/resolve-filename.js, where path.resolve(root, filename) is called without any subsequent validation that the resolved path remains within the root directory - absolute paths silently discard root entirely, and relative traversal sequences (../) are not blocked. With a CVSS base score of 7.5 (AV:N/AC:L/PR:N/UI:N), exploitation is network-accessible and requires no authentication against vulnerable applications; however, no confirmed active exploitation (CISA KEV) or public proof-of-concept has been identified at time of analysis.
Unauthenticated sensitive information exposure in the AI Copilot - Content Generator plugin for WordPress (versions up to and including 1.4.6) allows any remote attacker to retrieve plaintext OpenAI API keys and full AI model configurations. The `getCurrentTaskResults()` method is exposed via `wp_ajax_nopriv_` AJAX hooks with no nonce validation, no authorization checks, and no permission guard - making task results freely accessible to unauthenticated callers. Attackers who enumerate sequential integer task IDs can exfiltrate every stored API key, prompt configuration, and keyword set from the site's database. No active exploitation is confirmed in CISA KEV, and no public exploit code has been identified at time of analysis, though the vulnerability is trivially exploitable given the low attack complexity.
Uncontrolled memory allocation in imagecli's `scale` pipeline operation allows remote unauthenticated denial-of-service against any application embedding the library with user-controlled pipeline input. Supplying a large ratio value (e.g., `scale 100000`) causes Scale::apply() in src/image_ops.rs to compute output dimensions that trigger an attempted allocation of hundreds of terabytes, aborting the host process immediately. No active exploitation (CISA KEV) has been identified, but the attack is self-describing from the public GitHub issue and requires no authentication per the CVSS vector (PR:N, AC:L).
Five Flask API endpoints in Book-Management-System (/student, /record, /books, /find_stu_book, /find_not_return_book) are missing authentication controls, exposing student PII and borrowing history to any unauthenticated remote caller. Because the card_id parameter is a sequential integer, a trivial enumeration loop can drain the entire student database without credentials. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack requires no sophistication and is fully network-accessible.
Unauthenticated REST API access in the wiseCampaign - WooCommerce Conversions Made Easy WordPress plugin (all versions through 1.1.16) allows any network attacker to read and overwrite the plugin's banner, stockbar, and core settings, and to upload arbitrary background image files via wp_handle_upload(), with zero authentication or nonce validation. Every REST endpoint the plugin registers uses the blanket permission callback '__return_true', which bypasses WordPress's built-in capability and nonce checks entirely. No public exploit code or CISA KEV listing has been identified at time of analysis, but the unauthenticated, low-complexity attack surface makes this straightforward to exploit opportunistically.
Remote file inclusion and path traversal in Eclipse Mojarra 2.3 through 5.0 allows unauthenticated network attackers to force server-side Facelet resolution of attacker-controlled URLs via the `DefaultFaceletFactory` component, exposing restricted files with the privileges of the application server. The attack targets the JSF template resolution pipeline and can leak sensitive configuration data from `WEB-INF/web.xml` (which typically contains database credentials and security settings) or OS-level files such as `/etc/passwd`. SSVC rates the attack as automatable with no confirmed active exploitation at time of analysis, but the CVSS:3.1 AV:N/AC:L/PR:N/UI:N vector means no barriers exist between a remote attacker and a vulnerable endpoint.
Unauthenticated attachment download in Documize Community exposes all organization files to any remote attacker via a trivially bypassable token check. The Download handler in domain/attachment/endpoint.go, registered via AddPublic without auth middleware, validates the `secure` query parameter only by checking that it is non-empty (len(secureToken) > 0) rather than comparing it to a server-stored secret - meaning any request with `?secure=x` succeeds. Notably, sibling handlers in the same file (togglePublish, delete) enforce proper session-based authorization, confirming this is an implementation inconsistency rather than deliberate design. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis, but the attack requires no authentication, no special tools, and trivial construction.
SQL injection in Directus before 12.1.0 enables an authenticated administrator to execute arbitrary SQL against the underlying PostgreSQL database during collection creation by embedding attacker-controlled SQL syntax within a geometry field type value. The attack is gated behind two non-default prerequisites - administrator-level credentials and a PostgreSQL backend with the PostGIS extension installed - which together constrain the realistic threat surface to insider risk or compromised admin accounts. A vendor patch is confirmed available in v12.1.0; no public exploit code or CISA KEV listing has been identified at time of analysis.
Authentication bypass in IBM Langflow OSS 1.0.0 through 1.10.3 exposes the Model Context Protocol (MCP) composer endpoint to unauthenticated remote access when projects are configured with auth_type=oauth and MCP composer is enabled - which is the default deployment state. An unauthenticated network attacker can reach the MCP composer endpoint and read confidential project data (C:H) without supplying valid credentials, entirely bypassing the OAuth authentication gate. No public exploit code or CISA KEV listing has been identified at time of analysis, but the vendor (IBM) has confirmed the issue and released a patch.