Remote code execution in IBM Langflow OSS 1.0.0 through 1.10.3 is achievable by any authenticated attacker due to improper validation of module imports, classified under CWE-94 (Code Injection). The CVSS 8.8 score reflects full confidentiality, integrity, and availability impact with no user interaction required beyond low-privilege authentication. No public exploit code has been identified at time of analysis, EPSS sits at 0.34% (27th percentile), and SSVC designates exploitation as 'none' currently - though the SSVC technical impact is rated 'total', confirming the severity of successful exploitation.
Unsafe pickle deserialization in Hugging Face PEFT's LoRA-GA and CorDA initialization modules allows arbitrary code execution when a victim loads a malicious cache or covariance file. The affected code paths in corda.py (lines ~102 and ~163) and loraga.py (line ~101) call torch.load() without weights_only=True, bypassing the safe-loading wrapper that PEFT enforces elsewhere in the codebase. An attacker who can supply or substitute a pre-computed LoRA-GA or CorDA cache file - for example via a shared model repository or poisoned download - achieves full code execution in the victim's ML environment upon initialization. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.
Privilege escalation in the Smart Popup by Supsystic WordPress plugin (all versions through 1.12.0) enables unauthenticated remote attackers to create persistent WordPress Administrator accounts with attacker-controlled credentials. Three compounding flaws are chained: a PHP `array_merge()` collision silently removes the `save` action from the popup module's permission blocklist, the subscription confirmation email leaks a reusable `pps_nonce` that the `wp_ajax_nopriv_save` endpoint accepts, and `createWpSubscriber()` applies no server-side role allowlist - allowing an attacker to freely set `params[tpl][sub_wp_create_user_role]=administrator`. No public exploit or CISA KEV listing is confirmed at time of analysis, but the attack chain is fully described in the CVE and the low complexity makes independent weaponization likely.
Unauthenticated arbitrary file write in Eclipse Theia 1.73.1 and earlier (browser-mode deployments) allows any cross-origin web page to overwrite files at any absolute path the backend process can access, with a realistic escalation to remote code execution. The `POST /file-upload` handler in `@theia/filesystem` accepts attacker-controlled absolute paths with no workspace boundary check, while a distinct HTTP middleware flaw in `@theia/core` lets the connection token check pass without rejection for tokenless HTTP requests. Because `multipart/form-data` is a CORS-safelisted request type, browsers send the exploit request cross-origin with no preflight and no credentials. No public exploit has been identified at time of analysis, and no CISA KEV listing appears in the provided data, but the attack mechanism is straightforward and requires only that a victim visit an attacker-controlled page.
Arbitrary server-side code execution in Magistrala's Rules Engine exposes any authenticated low-privileged user to full file system access, environment variable exfiltration, database manipulation, and SSRF against internal microservices. The platform's two script runtimes - Go via Yaegi and Lua - both fail to sandbox dangerous capabilities: the Go engine exposes the complete standard library behind a trivially insufficient regex filter, while the Lua engine performs no validation whatsoever and explicitly preloads file I/O, HTTP client, and database libraries. No public exploit code has been identified at time of analysis, but the attack requires only a valid account and the ability to create rules, making exploitation straightforward for any tenant or internal user.
Host filesystem read and write access in IBM Langflow OSS 1.0.0 through 1.10.3 is achievable by any authenticated low-privilege user via insufficient filtering of Docker volume-mount and device-mapping arguments passed to Docker-based MCP servers. By injecting unsanitized flags such as --volume into MCP server configuration, an attacker can bind-mount arbitrary host directories into a spawned container, exposing or tampering with sensitive files outside the intended Docker isolation boundary. No public exploit code has been identified at time of analysis and no CISA KEV listing exists, but the network-exploitable, low-complexity attack path and full CIA impact score (CVSS 8.8) make this a high-priority patch target for any organization running Langflow in Docker environments with externally accessible or multi-tenant access.
SQL injection in Koha's guided report builder (`reports/guided_reports.pl`) allows any authenticated staff member holding the low-privilege `create_reports` or `execute_reports` permission to perform time-based blind SQL injection against the Koha database, which stores patron PII, borrowing history, and staff/LDAP credentials. The `order_by` and dynamically-named `{order}_ovalue` CGI parameters are concatenated verbatim into an ORDER BY clause by `C4::Reports::Guided` with no allowlist, escaping, or prepared-statement binding - a structural defect, since SQL placeholders cannot parameterize column names. No public exploit or CISA KEV listing has been identified at time of analysis, but the attack technique is well-understood and the affected permission is routinely granted to non-admin library staff.
Time-based blind SQL injection in Cacti's ORDER BY handling allows any authenticated user - regardless of privilege level - to extract, modify, or destroy the Cacti database by supplying a crafted `sort_column` GET parameter to at least four administrative endpoints. The root cause is a regex-based sanitization allowlist in `sanitize_sql_column()` (lib/functions.php) that explicitly permits parentheses to support SQL expressions like `COUNT(id)`, inadvertently passing payloads such as `SLEEP(5)` through unmodified before they are concatenated into unparameterized ORDER BY clauses. No public exploit code or KEV listing has been identified at time of analysis, but the low privilege bar and network accessibility make this a credible priority for any organization running Cacti.
Remote code execution in IBM Langflow OSS (versions 1.0.0 through 1.10.3) allows authenticated attackers to execute arbitrary Python code by exploiting a cryptographic weakness (CWE-326) in the custom component validation mechanism. When the optional hardening mode is enabled - the feature intended to restrict execution to trusted component templates - the application validates submitted component code against a truncated SHA-256 digest, making it computationally feasible for an attacker to craft a malicious Python file that collides with a trusted template's hash and bypasses the validation gate entirely. No public exploit code has been identified at time of analysis; a vendor patch is available per IBM advisory, though the exact fixed version is not stated in available data.
Remote code execution in IBM Langflow OSS 1.0.0-1.10.3 allows authenticated low-privilege users to trigger arbitrary Python execution on the backend server by submitting crafted Agentic Assistant workflows containing malicious LLM-generated components that are evaluated server-side during validation before user approval is granted. The flaw (CWE-94, Code Injection) arises because the validation pipeline eagerly executes model-generated Python without sandboxing or deferral, giving attackers backend process-level privileges to exfiltrate data, interact with the file system, or initiate outbound network connections. No public exploit code or CISA KEV listing has been identified at time of analysis; EPSS places exploitation probability at 0.22% (13th percentile), but SSVC rates technical impact as total, making this a high-priority patch target for multi-user or internet-exposed deployments.
Command injection in IBM QRadar SIEM allows an authenticated privileged user to execute arbitrary OS commands at normal user privilege level due to insufficient input validation (CWE-78). Affected versions span QRadar 7.5.0 through 7.5.0 UP 15 Interim Fix 005 and 7.6.0.0 through 7.6.0.1, placing enterprise security operations centers at risk if SIEM operator accounts are compromised or misused by insiders. No public exploit code exists and no active exploitation is confirmed; EPSS places this at the 13th percentile (0.22%), indicating minimal near-term mass-exploitation probability.
Remote code execution via CSRF in Jenkins Multijob Plugin 669.v9d96a_d9c71b_0 and earlier allows a network attacker to execute arbitrary code within the Jenkins controller JVM by inducing a low-privileged authenticated user to trigger a forged request. The Jenkins security advisory published 2026-08-05 formally discloses this as SECURITY-3823(2), with EUVD-2026-53526 corroborating the affected version range. No public exploit code or CISA KEV listing has been identified at time of analysis, though the network reachability and low attack complexity make this a meaningful risk wherever Jenkins is accessible and users browse untrusted sites within the same browser session.
Cleartext storage of sensitive information in Cisco Catalyst SD-WAN Controller and Manager exposes credentials or other security-critical data to authenticated network-accessible attackers, with CVSS 8.8 reflecting the high potential for full system compromise via stolen credentials. Affecting an extraordinarily wide version range spanning 17.2.x through 20.14.x across both the Controller and Manager components, this vulnerability was discovered internally by Cisco's engineering team - a positive signal indicating no known prior adversarial exploitation. No public exploit code exists and the vulnerability is not listed in CISA KEV; however, the SD-WAN control plane sensitivity means exposed credentials could enable broad network infrastructure takeover.
Cross-site request forgery in the Progress MarkLogic Server Admin UI allows a remote attacker to perform privileged administrative actions on behalf of a logged-in administrator by luring them to a crafted malicious webpage. Affected versions span the 11.x line prior to 11.3.6 and the 12.x line prior to 12.0.3, covering deployments across both active release trains. No public exploit code or active exploitation has been identified; Progress Software has issued patches for both branches.
Cleartext registration token exposure in Rancher allows a low-privileged user to obtain perpetually valid cluster join tokens and enlist rogue nodes into downstream Kubernetes clusters. The tokens - used to authenticate nodes and agents during cluster bootstrapping - are stored without encryption or expiration and are reachable through at least four distinct channels: the Rancher API, etcd, stored automation artifacts, and direct filesystem access on enrolled nodes. The CVSS scope-change flag (S:C) accurately reflects that successful exploitation extends attacker influence beyond the Rancher management plane into downstream cluster workloads, secrets, and compute. No public exploit has been identified at time of analysis, and no CISA KEV listing exists.
Remote unauthenticated denial of service in OpenStack Swift through 2.38.0 allows any network-reachable attacker to exhaust all proxy worker threads with a trivially crafted HTTP Accept header. The proxy server's Accept header parser employs a qdtext regex pattern susceptible to catastrophic backtracking (CWE-1333), where a payload of just 32 backslash-character pairs stalls a single worker for over 30 seconds. Repeated concurrent requests consume all available proxy workers, causing complete and sustained service unavailability — no authentication, session, or account is required. No public exploit or CISA KEV listing has been identified at time of analysis, though the description itself constitutes a functional attack recipe.
Stack-based buffer overflow in OpenSIPS versions prior to 3.6.6 and 4.0.0-rc1 allows a remote unauthenticated attacker to crash worker processes by exploiting the watcherinfo XML generation path in the presence module. The attacker sends a SIP SUBSCRIBE with a From URI exceeding 200 characters, establishing an oversized watcher entry, then triggers presence.winfo generation to overflow a fixed-size stack buffer in create_winfo_xml() within notify.c. No public exploit has been identified at time of analysis, but the unauthenticated network vector and straightforward two-step attack path make this a credible denial-of-service risk for any SIP infrastructure exposing presence services.
Stored XSS in Grocy's API layer allows authenticated users to permanently inject arbitrary script tags into shared application data, executing in the browsers of any user who views affected records. The vulnerability spans all API-writable resource types - products, recipes, stock entries, user records, and chores - making it broadly exploitable across the application. The CVSS score of 8.7 with Scope:Changed reflects the cross-user impact characteristic of stored XSS: a single low-privileged write yields high confidentiality and integrity impact against other users' sessions. No public exploit code or CISA KEV listing is identified at time of analysis.
Stored XSS in InvoiceNinja v5-stable allows an authenticated user with invoice creation access to inject arbitrary JavaScript into the invoice terms field, which executes in a business client's browser when they view the invoice in the client portal. The attack leverages Laravel Blade's raw unescaped output directive in `resources/views/portal/ninja2020/invoices/includes/terms.blade.php`, with no HTML sanitization performed in `StoreInvoiceRequest.php`, enabling session cookie theft and full client account takeover. This is a distinct code path from the previously published CVE-2026-33628 (line-item description XSS), and no public exploit has been identified at time of analysis.
Denial-of-service via malformed XMCP packets forces unexpected reloads of Cisco IOS and IOS XE devices, exploitable by any remote unauthenticated attacker. The CVSS scope change (S:C) reflects that the reload impacts the entire device, not just the XMCP subsystem, bringing down all services simultaneously. No public exploit or CISA KEV listing exists at time of analysis, but the zero-authentication, low-complexity attack vector - combined with Cisco's ubiquitous enterprise footprint - makes this a high-priority patching target for network operations teams.
Denial-of-service in Cisco IOS XE Software's Blocks Extensible Exchange Protocol (BEEP) feature allows an unauthenticated remote attacker to force an unexpected device reload by sending a specially crafted BEEP SOAP request. The CVSS 8.6 score with Changed scope (S:C) reflects that a device reload disrupts all network services downstream of the affected device, amplifying impact beyond the immediate target. No public exploit or CISA KEV listing has been identified at time of analysis, though the low-complexity, no-authentication attack vector makes this a credible automated threat against any internet- or network-exposed IOS XE device running the BEEP feature.
Server-side request forgery in Stirling-PDF's POST /api/v1/convert/url/pdf endpoint allows unauthenticated remote attackers to exfiltrate cloud metadata and internal network resources by supplying a URL to an attacker-controlled page containing embedded resource references (e.g., img tags targeting 169.254.169.254). The endpoint was deliberately excluded from the SSRF protections applied to three sibling conversion endpoints, creating an uneven security boundary; WeasyPrint, the underlying rendering subprocess, fetches all embedded resources with no per-resource SSRF filtering, causing internal HTTP responses to be embedded verbatim into the returned PDF. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack requires no authentication and no special configuration, making any network-exposed Stirling-PDF instance a viable target.
Unauthenticated remote denial-of-service affecting Cisco IOS XE Software across a wide version range results from multiple improper input validation flaws (CWE-20) discovered during Cisco's internal security hardening review. The CVSS vector (AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:H) indicates that network-adjacent or internet-facing IOS XE devices can be crashed or rendered unavailable without any credentials or user interaction, with the changed scope (S:C) suggesting impact can extend beyond the directly targeted device to dependent network services. No public exploit code has been identified and this is not listed in CISA KEV, consistent with the internally discovered origin.
Unauthenticated remote denial-of-service in Cisco IOS XE Software allows network-accessible attackers to crash IOS processes or force full device reloads by exploiting insufficient control flow management flaws (CWE-691), with a scope-changing availability impact rated CVSS 8.6. The vulnerabilities were discovered internally by Cisco's own engineering team as part of a proactive security review and addressed through software hardening releases - no active exploitation or public proof-of-concept has been identified at time of analysis. The affected version range is exceptionally broad, spanning IOS XE 16.6.x through 26.1.x, meaning virtually every Cisco IOS XE device on networks that has not been recently patched is likely running a vulnerable version.
Denial-of-service conditions in Cisco IOS XE Software stem from multiple incorrect calculation flaws (CWE-682) discoverable over the network without authentication, capable of crashing the affected device and disrupting all traffic transiting it. The CVSS scope change (S:C) indicates impact extends beyond the vulnerable component itself, consistent with a network appliance crash affecting downstream routing and switching functions across an enterprise. Internally discovered and disclosed by Cisco as part of a proactive software hardening initiative, no public exploit identified at time of analysis and CISA KEV status is absent.
Unauthenticated remote attackers can cause high availability impact with scope change on Cisco IOS XE Software through improper control of resources across their lifetime (CWE-664), affecting an exceptionally broad version range from 16.6.x through 26.1.x. The vulnerabilities were discovered proactively by Cisco's internal security engineering team and grouped as a software hardening release, meaning patches were prepared before external threat actor awareness. No public exploit exists and the CVE is absent from CISA KEV, but the AV:N/AC:L/PR:N/UI:N CVSS profile means exploitation requires no authentication or special conditions against any network-accessible IOS XE device.
Remote unauthenticated exploitation of improper memory buffer boundary handling in Cisco IOS XE Software can cause a complete denial of service with Changed scope (S:C), potentially cascading disruption to downstream network segments that depend on the affected routing or switching infrastructure. Affecting an extremely broad range of IOS XE release trains from 16.6.x through 26.1.x across hundreds of specific builds, this vulnerability was discovered and self-reported by Cisco's own engineering team during a proactive internal security hardening review - not in response to observed attacks. No public exploit code or CISA KEV listing has been identified at time of analysis, which moderates near-term opportunistic exploitation risk despite the high CVSS score of 8.6.
Missing authorization on the group DM recipient endpoint in Spacebar Server allows any authenticated user to add themselves or arbitrary third parties to private group DM channels without being a member. Versions prior to commit dcfd91035e3da42abf5f32d8d86a35219225b3d4 expose the unguarded PUT /channels/{channel_id}/recipients/{user_id} handler, granting attackers full read and write access to private conversation history. No public exploit code or active exploitation has been identified at time of analysis, but the commit diff and GHSA advisory are publicly available, lowering the bar for exploitation.
Memory corruption in nanoMODBUS through v1.23.0 allows a malicious or compromised Modbus server to crash or potentially execute arbitrary code on connecting clients by sending a crafted Read Device Identification response (FC 0x2B/MEI 0x0E) that triggers an out-of-bounds NUL byte write in recv_read_device_identification_res(). Any application embedding this library and invoking the Device Identification client function is exposed when connecting to an attacker-controlled server. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, though the off-by-one NUL write primitive into adjacent heap or stack memory represents a realistic path to both denial of service and, depending on allocator layout, code execution.
Untrusted JavaScript rendered in Livebook notebook outputs can escape the sandboxed cross-origin iframe and trigger session-wide keyboard shortcuts, causing forced execution of all notebook cells without user consent. Livebook versions 0.5.0-0.18.6 and 0.19.0-0.19.8 are affected; a user who merely opens a third-party or documentation-linked notebook can have its Elixir code automatically evaluated on their runtime. Because cell outputs are mirrored to every connected client, a single malicious notebook load can trigger the exploit simultaneously across all collaborators in the session. No public exploit or CISA KEV listing is identified at time of analysis, but the low-friction attack path - open a notebook, get code executed - represents a meaningful social-engineering risk.
Remote code execution in ESPHome through 2026.7.0-dev allows any attacker who can supply a crafted YAML configuration to execute arbitrary Python code on the machine that processes it. The vulnerability is an operator-precedence bug in the cv.url() validator: Python's 'and' binding tighter than 'or' causes any file:// URI to unconditionally pass validation, bypassing the intended network-URI-only restriction on the external_components git source URL field. ESPHome then invokes git clone against the attacker-supplied local path and loads the resulting repository into Python's import machinery, yielding full code execution with the privileges of the esphome process; no public exploit has been identified at time of analysis.
Remote code execution in Mistral Vibe before 2.23.3 allows any attacker who can deliver a crafted repository to a victim to execute arbitrary commands with the victim's full OS privileges. The mechanism is git's core.fsmonitor hook: Mistral Vibe calls git status --porcelain without suppressing hook execution, so a malicious fsmonitor entry embedded in a repository's .git/config is executed whenever any vibe command runs inside that repository. No public exploit or CISA KEV listing has been identified at time of analysis; however, the attack pattern is straightforward and the fix is confirmed at v2.23.3.
Remote authenticated attackers can bypass localhost-only access restrictions in IBM Langflow OSS 1.0.0 through 1.10.3 to write arbitrary MCP (Model Context Protocol) server configurations to IDE configuration files on the underlying host system. The CVSS scope change (S:C) confirms this escapes the Langflow application boundary, enabling persistent manipulation of developer IDE environments on the host. No public exploit code or CISA KEV listing has been identified at time of analysis; a vendor-released patch is available.
Webhook URL validation bypass in Memos allows authenticated users to trigger Server-Side Request Forgery via the 0.0.0.0 address notation, causing the server to make outbound HTTP requests to its own loopback interface and exposing internal-only services, with a CVSS 8.5 score reflecting Changed Scope and High Confidentiality impact. The root cause is a code-divergence defect: isReservedIP() in internal/webhook/validate.go omits the 0.0.0.0/8 CIDR block and never calls ip.IsUnspecified(), while the correctly implemented sibling function isInternalIP() in internal/httpgetter/html_meta.go does both. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low attack complexity and standard SSRF-to-loopback technique make this a realistic risk on any Linux-hosted Memos instance with multi-user access.
Server-side request forgery in Progress MarkLogic Server before 11.3.6 and 12.0.3 enables authenticated low-privileged users to bypass existing IMDS protection filters, causing the server to fetch cloud instance metadata endpoints (e.g., AWS IMDSv1 at 169.254.169.254). Successful exploitation yields temporary cloud IAM credentials, extending attacker reach to all cloud resources accessible by the host instance's IAM role. No public exploit code or CISA KEV listing has been identified at time of analysis; however, the Scope:Changed CVSS metric and credential-theft impact elevate operational priority significantly for cloud-hosted deployments.
Stored XSS in OpenBK7231T firmware allows an adjacent-network attacker with MQTT broker access - commonly unauthenticated in real IoT deployments - to inject persistent JavaScript payloads into device channel labels via the SetChannelLabel MQTT command. The malicious label survives device reboots in memory and executes in the browser of every user who subsequently views the device's built-in web management panel, with high confidentiality and integrity impact in a changed scope. No public exploit has been identified at time of analysis, but the unauthenticated MQTT broker pattern common in home automation environments effectively lowers the practical exploitation barrier below what the AV:A vector alone implies.
Server-Side Request Forgery in Shiori's bookmark download function allows any authenticated user to force the server to issue HTTP requests to loopback addresses (127.0.0.1) and 0.0.0.0 - which Linux routes to the loopback interface - reaching cloud metadata endpoints, co-located databases, and internal-only APIs. The root cause is `DownloadBookmark()` in `internal/core/download.go` using a plain `http.Client` with no custom `DialContext` and no post-resolution IP validation (no `IsLoopback()`, `IsPrivate()`, `IsUnspecified()`, or `IsLinkLocalUnicast()` checks). No public exploit has been identified at time of analysis, but the attack path is trivially constructable given the well-documented SSRF pattern against Go's standard HTTP client.
DNS rebinding bypass of SSRF protection in Memos' webhook dispatcher allows a low-privileged authenticated attacker to reach internal network resources by exploiting a time-of-check/time-of-use race in hostname resolution. The `safeDialContext()` function in `internal/webhook/webhook.go` validates the resolved IP against reserved ranges but then re-dials using the original hostname, allowing the underlying `net.Dialer.DialContext()` to perform a second, independent DNS lookup that the attacker controls. By setting a short TTL on an attacker-controlled domain and swapping the DNS response between validation and dial, an attacker can cause Memos to connect to arbitrary internal addresses. No public exploit or CISA KEV listing has been identified at time of analysis, but the scope change (S:C) and high confidentiality impact reflect the risk of internal service enumeration and data exfiltration.
Local privilege escalation in the NI-PAL kernel driver allows a low-privileged authenticated Windows user to escalate to SYSTEM-level and execute arbitrary code, as confirmed by the NI vendor advisory. Affected deployments include NI-PAL versions 26.3.1 and all prior releases running exclusively on Microsoft Windows. No public exploit code exists and the vulnerability is not listed in the CISA KEV catalog, but the low access complexity (AC:L, AT:N in CVSS 4.0) means exploitation requires no special conditions beyond a local user session.
Privilege escalation to SYSTEM in NetKids iMark (all versions through V5.2.5.0) is achievable by authenticated local attackers exploiting an unquoted Windows service executable path. Because the service path contains spaces but lacks surrounding quotation marks, Windows' path resolution logic will execute an attacker-placed binary at an intermediate path before reaching the legitimate service binary. JPCERT/CC has issued an advisory (JVN#28045338) and the vendor has published remediation PDF guidance; no public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
SSRF protection bypass in Gitea prior to 1.27.0 exposes internal services, cloud instance-metadata endpoints (e.g., AWS IMDSv1 at 169.254.169.254), and local files - including the application configuration containing database credentials and signing secrets - to authenticated attackers. Three HTTP fetch code paths in the migration and OAuth avatar subsystems use Go's raw http.Get() rather than the hardened hostmatcher.NewDialContext() transport used elsewhere, completely circumventing Gitea's built-in SSRF defenses. A publicly available proof-of-concept is included in the GHSA advisory; no confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Cross-company customer record access in Crater 6.0.6 exposes a multi-tenant authorization flaw where any authenticated tenant user can read, modify, or permanently delete customer records owned by other companies. The CustomerPolicy authorization class omits the company_id ownership check that all other resource policies (Invoice, Estimate, Payment, Expense) correctly enforce, and route-model-bound customer lookups use unscoped queries (self::find($id)) that return records regardless of company ownership. No public exploit has been identified at time of analysis; the CVSS 8.3 (High) score reflects straightforward network-reachable exploitation by any low-privilege authenticated user, with cascading destruction of financial records as the worst-case availability impact.
Cross-company note access in the Crater open-source invoice platform allows any authenticated user to read, modify, or delete notes belonging to an entirely different company by supplying a foreign note ID in the API. NotePolicy omits the company-ownership verification (hasCompany) that sibling policies such as InvoicePolicy correctly enforce, and NotesController's show(), update(), and destroy() actions call authorize() without passing the target Note model instance, meaning no per-resource ownership check ever executes. No public exploit has been identified at time of analysis, but the CVSS 8.3 rating reflects that the technique requires only sequential ID enumeration against a standard multi-tenant deployment - a low-effort, high-impact path to cross-tenant data exfiltration and tampering.
Privilege persistence in Shiori, the self-hosted bookmarks manager (go-shiori/shiori), allows a deleted or demoted owner to continue authenticating with full owner-level privileges for up to 30 days after account revocation. The root cause is that CheckToken in internal/domains/auth.go validates only the JWT HMAC signature and trusts the embedded claims without re-querying the database, and no token revocation or session store mechanism exists anywhere in the codebase. An attacker who previously held an owner-level account - such as a terminated employee - retains full read/write access to all bookmarks and administrative functions until the token's natural expiry. No active exploitation confirmed (no CISA KEV listing); no public exploit code identified at time of analysis.
Unauthenticated payment hijacking in WPFormify - Stripe Payments with Form and Checkout (all versions ≤ 1.1.1) allows any remote attacker to overwrite or delete the site's Stripe API credentials with zero authentication. Two plugin functions registered on WordPress's `admin_init` hook are reachable via the publicly accessible `admin-post.php` endpoint because they perform no capability check and no nonce verification. An attacker exploiting this can silently redirect all customer payments to an attacker-controlled Stripe account, or disable payment processing entirely by erasing the stored credentials - with no public exploit identified at time of analysis but trivially low exploitation complexity.
Unauthenticated remote write access in the toner-management PHP application allowed any attacker to invoke admin-tier database operations - INSERT, UPDATE, and DELETE - across inventory entities including toners, printers, consumers, tickets, and staff records. The CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms no credentials, session token, or user interaction are required; the admin write handlers (add.php, edit.php, delete.php) were directly reachable over HTTP and processed SQL operations unconditionally. A fix has been merged via GitHub PR #1 adding session-based admin role validation to all affected handlers, but no formally tagged release version has been confirmed. No public exploit code and no CISA KEV listing are identified at time of analysis.
Arbitrary file deletion via path traversal in the Content Egg WordPress plugin (versions up to and including 11.3.0) enables authenticated attackers holding author-level access or higher to delete any file accessible to the PHP process on the server's filesystem. The root cause is that the `img_file` field within `cegg_data` post metadata is sanitized only with `wp_strip_all_tags()` - which removes HTML tags but leaves path traversal sequences intact - stored verbatim in post meta, then concatenated without normalization into a filesystem path inside `getFullImgPath()` (ImageHelper.php:L149) before being passed to PHP's `unlink()`. Deletion of critical WordPress files such as `wp-config.php` can cascade into remote code execution by triggering the WordPress reinstallation flow; no public exploit or CISA KEV listing identified at time of analysis.
Unauthenticated network access to WLED's GET /json/cfg endpoint exposes full device configuration - including network credentials, hardware layout, and LED setup - to any client on the same network, while a separate global-state authentication flaw in wled.h allows any attacker who submits the correct 4-digit PIN via POST /json to instantly grant full write access to all subsequent unauthenticated clients until the device reboots. The write-access window enables critical operations including OTA firmware flashing, WiFi reconfiguration, and factory reset. No public exploit code or CISA KEV listing has been identified at time of analysis, but the 10,000-combination PIN space with no described rate-limiting makes the authentication bypass trivially automatable against any network-reachable WLED instance.
Slab-out-of-bounds read in the Linux kernel's ksmbd SMB2 server allows remote unauthenticated attackers to crash the kernel or leak one byte of adjacent slab memory by sending a crafted compound SMB2 request. The vulnerable path in ksmbd_smb2_check_message() reads the 2-byte StructureSize2 field at offset 64 from each compound element without first confirming the element is at least 66 bytes, so a trailing element of exactly 64 bytes causes a one-byte overread beyond the receive buffer. No exploitation has been publicly confirmed (EPSS 0.16%, 5th percentile, not in CISA KEV), but the unauthenticated network attack vector (CVSS 8.2) makes any ksmbd-exposed host a realistic DoS target. Vendor-released patches are available across all maintained stable kernel series.
NULL pointer dereference in HDF5's H5Pget_fill_value function (all versions before 2.1.1) enables denial of service by processing a specially crafted HDF5 dataset file. The flaw arises when a fill value message (format version 1 or 2) carries the 'defined' flag alongside a negative size field - a malformed state the library fails to normalize to its internal 'undefined' sentinel - allowing a NULL datatype pointer to reach H5T_path_find and crash the process. No public exploit identified at time of analysis; the CVSS 4.0 score of 8.2 reflects high availability impact, but the local file-parsing vector and user interaction requirement meaningfully constrain real-world exposure.