Unauthenticated denial of service in Milvus through 2.6.22 and 3.0.0 allows any remote attacker with network access to port 9091 to immediately terminate core service components - proxy, datanode, or querynode - by issuing a single crafted HTTP GET request. The management server's /management/stop endpoint is not protected by the REST API authentication middleware, making exploitation trivial with a publicly available proof-of-concept. No CISA KEV listing exists at time of analysis, but the combination of zero-prerequisite exploitation, public PoC, and CVSS 4.0 score of 8.7 represents a high real-world availability risk for any Milvus deployment with port 9091 reachable beyond localhost.
Path traversal in rclone's `serve restic` REST API allows any attacker with network access to the endpoint to read, create, overwrite, or delete objects outside the operator-configured backend directory. The flaw spans rclone v1.40 through v1.74.4 and affects WebDAV, FTP, SFTP, HTTP, and Memory backends - but not S3-compatible or local filesystem backends, which encode `..` as literal filename characters. A fully functional, step-by-step proof of concept has been publicly released; no CISA KEV listing exists at time of analysis.
Newline injection in boringproxy 0.10.0 and earlier allows authenticated low-privileged users with tunnel-creation permission to write arbitrary entries into the server's SSH authorized_keys file, achieving persistent shell access to the host. By supplying a percent-encoded newline (%0a) in the domain parameter of the tunnel creation API endpoint, an attacker inserts an unrestricted public key, then SSHs directly into the server and reads plaintext credentials - including all user tokens, tunnel private keys, and TLS certificates - from the application's database file. A public proof-of-concept exploit is available via GitHub, and no patched release has been identified at time of analysis.
Authorization gate bypass in Nuxt (npm package, versions 3.21.7-<3.21.10 and 4.4.7-<4.5.1) allows unauthenticated network access to routes protected by appMiddleware auth rules whenever those route-rule keys contain uppercase characters. This is an incomplete fix for CVE-2026-53721: the prior patch case-folded the lookup path before matching route rules, but left the compiled rule keys verbatim, producing a permanent symmetric mismatch that silently drops all app-level protections for any mixed-case route. No public exploit has been identified at time of analysis; however, the vulnerable condition arises automatically in any Nuxt application deriving route rules from PascalCase page files (e.g., pages/Admin.vue) or writing mixed-case routeRules keys explicitly.
Server-side remote code execution in Nuxt's server island feature (nuxt >=3.4.0 <3.21.10 and >=4.0.0 <4.5.1) allows unauthenticated network attackers to execute arbitrary code in the Nitro server process by injecting a `template` key into island props delivered to the `/__nuxt_island/` endpoint. Exploitation requires two simultaneous preconditions: `vue.runtimeCompiler: true` must be explicitly enabled (it is off by default), and the application must expose a server island whose rendered output routes attacker-controlled prop values into Vue's dynamic component resolution - a condition that can arise implicitly via Vue's attribute-fallthrough mechanism when the island's root is a polymorphic component such as @nuxt/ui's UButton. No public exploit code or CISA KEV listing has been identified at time of analysis, and the non-default configuration requirement substantially limits the real-world attack surface.
Remote code execution in the zportals WordPress plugin (all versions before 6.3.4) is achievable by any authenticated user holding a Subscriber role or above, exploiting a server-side file upload validation failure that trusts the client-supplied Content-Type header and preserves the original file extension. By uploading a PHP webshell disguised with a benign MIME type, an attacker can plant executable server-side code and gain full control of the WordPress application layer. A publicly available proof-of-concept exploit exists; no confirmed active exploitation (CISA KEV) has been observed, but the low authentication barrier makes this a genuine risk for sites with open registration.
Missing capability checks across multiple REST API routes in the YayPricing WordPress plugin (all versions before 3.5.7) allow any subscriber-level authenticated user to overwrite a WooCommerce store's complete pricing configuration and extract private coupon codes. The plugin incorrectly relies on a shared nonce as its sole authorization gate rather than WordPress capability checks, a fundamental access control failure classified under CWE-284. A publicly available exploit exists per WPScan (EUVD-2026-53116), though EPSS sits at 0.14% (4th percentile), indicating low automated exploitation activity; CISA KEV listing is absent, so active exploitation in the wild is not confirmed.
PowerShell smart-quote filename injection in rclone's SFTP backend allows an attacker who controls remote filenames to execute arbitrary PowerShell commands as the victim's SSH account on the server. All rclone versions prior to v1.75.0 are affected when the SFTP remote uses PowerShell as the SSH command shell and server-side hashing is invoked. A proof-of-concept was confirmed by the GHSA advisory author; no CISA KEV listing was present at time of analysis, but the specific attack conditions meaningfully constrain real-world exposure to Windows-hosted or PowerShell-shelled SFTP deployments.
Arbitrary Python code execution in PraisonAI's workflow include feature allows an attacker who controls a local recipe directory to execute arbitrary code as the PraisonAI process user. Affected are praisonai 3.9.26-4.6.57 and praisonaiagents 0.12.12-1.6.57. This is a hardening bypass: the vulnerable sink in Workflow._execute_include() skips the PRAISONAI_ALLOW_TEMPLATE_TOOLS/PRAISONAI_ALLOW_LOCAL_TOOLS opt-in gates and the centralized safe loader that protect all other tools.py autoload paths, making it a distinct variant within an established advisory family. No public exploit or CISA KEV listing has been identified at time of analysis.
Command injection in H3C NX15 V100R017 allows authenticated remote attackers to execute arbitrary OS commands via the unsanitized `my2P4key` argument processed by the `esps.wan.repeater.set/repeaterproc` handler at the `/api/esps` endpoint. The CVSS 4.0 vector confirms high-privilege authentication is required (PR:H), yet successful exploitation yields full host compromise with confidentiality, integrity, and availability all rated High. A public Python proof-of-concept exploit script is available on GitHub, materially raising urgency for administrators of internet-exposed devices or those using default credentials.
OS command injection in H3C NX15 firmware V100R017 enables authenticated remote attackers to execute arbitrary operating system commands by manipulating the File argument in the file.exec function exposed via the /api/esps Backend RPC endpoint. A public Python proof-of-concept exploit script is available on GitHub, substantially lowering the barrier to exploitation for less-skilled actors. No vendor-released patch has been identified at time of analysis, leaving affected deployments dependent on compensating controls.
Server-side request forgery in PraisonAI's web_crawl() function (versions 1.5.128-1.6.57) allows an attacker who can influence URLs processed by agent or tool workflows to exfiltrate responses from internal services, private network hosts, and cloud metadata endpoints such as AWS IAM credential URLs. This is a confirmed patch bypass of the previously disclosed SSRF class in CVE-2026-40160 and GHSA-8f4v-xfm9-3244, exploiting the fact that the httpx fallback client uses follow_redirects=True without revalidating redirect destinations against the original host blocklist. No public exploit code and no CISA KEV active exploitation designation have been identified at time of analysis.
Unauthenticated arbitrary file read in audiobookshelf exploits a URL-encoding normalization gap between the Express authentication-exemption regex (which reads raw percent-encoded req.path) and Express's route parameter decoder (which decodes %2F sequences before handler execution), allowing any remote attacker to traverse the filesystem via crafted cover art requests. This directly bypasses the prior fix for CVE-2025-25205, which had anchored the auth-exemption regex to req.path - meaning the root cause was incompletely remediated. No CISA KEV listing or confirmed public exploit exists at time of analysis, but the AV:N/AC:L/PR:N/UI:N profile and bypass-of-prior-patch nature make this high priority for all internet-facing audiobookshelf deployments.
Unauthenticated CPU exhaustion in Nuxt's island renderer endpoint allows remote attackers to degrade or stall server availability without any credentials or valid hash. Nuxt versions 3.1.0-3.21.9 and 4.0.0-4.5.0 are affected: the `/__nuxt_island/` handler fully buffers, destr-parses, and ohash-hashes attacker-supplied POST bodies before checking the URL-embedded hash token, meaning expensive computation runs on doomed requests. Because Nitro's runtime executes on a single Node.js event loop, a sustained low-rate flood of ~4.6 MB JSON bodies is sufficient to stall all concurrent legitimate requests. No public exploit code or CISA KEV listing exists, but the attack is trivially reproducible from the published advisory description alone.
Unauthenticated remote denial-of-service in Nuxt's island/server-component SSR engine allows any attacker to crash a worker process with a single ~130-byte HTTP request. The island URL hash is a non-secret digest computed from public request parameters, so an attacker can forge valid island requests and supply an arbitrarily large integer as a v-for iteration prop - causing the SSR engine to allocate memory proportional to that integer. Reporter-confirmed measurements show count=40000000 or items=4000000 produces an out-of-memory worker crash; no public exploit code has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the attack is self-evident and trivially reproducible from the advisory description.
Server-Side Request Forgery (SSRF) bypass in PraisonAI's web_crawl tool prior to version 1.6.58 enables unauthenticated network attackers to reach internal network resources, loopback interfaces, and cloud metadata endpoints (such as AWS IMDS) from the PraisonAI host. The protection bypass exploits a validate-here/fetch-there gap (CWE-367 TOCTOU): the hostname is validated once with socket.gethostbyname but then re-resolved at connect time by httpx or urllib with redirect-following enabled, allowing HTTP redirect chains or DNS rebinding to steer the final connection to attacker-chosen internal destinations. No public exploit code or active exploitation has been identified at time of analysis; a fix is available in version 1.6.58.
Contest Gallery WordPress plugin before version 30.0.7 implements a custom front-end login mechanism that issues authentication cookies directly after password validation, entirely bypassing WordPress's standard authentication pipeline. This architectural shortcut renders all brute-force protection plugins and two-factor authentication plugins completely ineffective, allowing unlimited, unthrottled password guessing against any WordPress account - including administrators - up to full account takeover. A publicly available proof-of-concept exists per WPScan reporting, though CISA has not listed this in KEV and SSVC indicates no confirmed active exploitation at time of analysis.
Two-factor authentication bypass in the WP 2FA WordPress plugin before 4.1.0 allows an attacker who possesses a valid user password to completely skip the second authentication factor and gain full account access, including administrator-level accounts. The plugin presents the 2FA challenge but fails to server-side validate the submitted factor for any of its supported methods, rendering 2FA protections entirely ineffective. A publicly available exploit exists (sourced from WPScan), though EPSS sits at 0.19% (9th percentile), indicating limited observed exploitation activity at time of analysis despite the public proof-of-concept.
Stored Cross-Site Scripting in the Bit Form WordPress plugin before 3.2.0 enables unauthenticated attackers to upload crafted SVG files containing embedded JavaScript as signature images, which execute in a victim's browser upon viewing the submission. Any authenticated user - most critically a WordPress administrator - who reviews form submissions containing the malicious SVG is at risk of session hijacking or unauthorized administrative action. A public proof-of-concept is available per WPScan; however, EPSS stands at 0.18% (8th percentile) and CISA KEV does not list active exploitation, indicating real-world opportunistic exploitation has not been widely observed.
Password-protected block content in the Passster WordPress plugin (all versions before 4.3.6) is rendered into the public HTTP response body before the server evaluates the password check, making the gate purely cosmetic. Unauthenticated remote users can retrieve protected content by inspecting the raw response - no password required. A public proof-of-concept exploit is available via WPScan, and the CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N) confirms trivial remote exploitation with full confidentiality impact, though EPSS at 0.16% (5th percentile) and no CISA KEV listing indicate exploitation has not yet become widespread or automated.
Category-locked content in the Passster WordPress plugin (all versions before 4.3.6) is fully exposed through the native WordPress REST API, bypassing the plugin's access controls entirely. Unauthenticated remote users can retrieve the title, full body, and excerpt of any post that site owners intended to restrict using Passster's category-based protection. A publicly available exploit exists per WPScan; no CISA KEV listing and a low EPSS of 0.16% (5th percentile) indicate limited observed in-the-wild exploitation so far, but the trivial exploitation conditions make this an immediate upgrade priority for any site relying on Passster to gate sensitive content.
Unauthenticated content disclosure in the Passster WordPress plugin (versions before 4.3.6) allows any remote user to retrieve the full content of draft, private, and pending posts via a REST API endpoint that skips post-status validation. The flaw is conditional on the target site having a captcha provider configured, which is the typical deployment mode for Passster installations. Publicly available exploit code exists per WPScan reporting, though EPSS sits at only 0.16% (5th percentile), suggesting exploitation remains targeted rather than widespread. No CISA KEV listing has been issued.
Registration enforcement bypass in the User Registration & Membership WordPress plugin (all versions before 5.2.6) allows unauthenticated users to create accounts on sites where the administrator has explicitly disabled open registration. The plugin processes registration form submissions without validating the site-level registration-disabled setting, effectively nullifying an administrative security control. A publicly available exploit exists per WPScan, though EPSS sits at a low 0.15% (4th percentile), indicating limited observed exploitation despite the accessible POC.
Unauthenticated information disclosure in the Sunshine Photo Cart WordPress plugin (all versions before 3.6.12) allows any internet-connected user to retrieve image comments from private, password-protected, or otherwise access-restricted galleries by exploiting a missing authorization check on an AJAX endpoint. The flaw is classified as CWE-862 (Missing Authorization) and carries a CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N). A publicly available proof-of-concept exists via WPScan, though EPSS at 0.15% (4th percentile) and no CISA KEV listing indicate no confirmed widespread exploitation at time of analysis.
Account takeover in the miniOrange 2FA WordPress plugin before 6.2.7 is enabled when an attacker already possesses a target user's password - the plugin fails to bind a newly configured second factor to the target account's existing registered factor during the pre-login two-factor challenge, allowing the attacker to redirect 2FA enrollment to an attacker-controlled device, complete the challenge, and authenticate as the victim including as site administrators. A publicly available proof-of-concept exists per WPScan, though EPSS sits at 0.14% (4th percentile), indicating exploitation has not yet become widespread. Critically, the published CVSS vector (C:N/I:N/A:H) severely misrepresents the actual impact - this is a full account-takeover flaw with high confidentiality and integrity consequences, not a denial-of-service; analysts should not use the published vector for risk calibration.
Stack-based buffer overflow in the UTT HiPER 1250GW firmware (all versions up to v3.2.7-210907-180535) allows authenticated remote attackers to corrupt stack memory via the tempName argument of the /goform/getOneApConfTempEntry endpoint, with potential for arbitrary code execution on the device. A public proof-of-concept exploit is available on GitHub, and the vendor did not respond to coordinated disclosure, leaving no patch path available. No CISA KEV listing exists, but the PoC availability combined with an unpatched network device significantly elevates practical risk for any exposed management interface.
Stack-based buffer overflow in UTT HiPER 1250GW firmware (all versions through 3.2.7-210907-180535) enables low-privileged remote attackers to corrupt stack memory and achieve arbitrary code execution by submitting an oversized value to the cipher parameter of the /goform/APSecurity_5g endpoint. A public proof-of-concept exploit is available on GitHub, materially increasing opportunistic abuse risk. No vendor patch exists - the vendor failed to respond to responsible disclosure - leaving no fix-based remediation path at time of analysis.
Stack-based buffer overflow in UTT HiPER 1200GW firmware up to v2.5.3-170306 enables network-reachable authenticated attackers to corrupt stack memory and achieve arbitrary code execution on the device. The vulnerable C runtime function strcpy in the web management endpoint /goform/ConfigAdvideo performs no bounds validation on the timestart HTTP parameter, allowing oversized input to overwrite return addresses and redirect execution flow. A public proof-of-concept exploit is available on GitHub; no vendor patch exists as UTT did not respond to the coordinated disclosure.
Cross-origin read bypass in Electron's custom protocol handler exposes sensitive application data to remote pages via fetch() and XMLHttpRequest. Electron apps on any branch prior to 39.8.10, 40.9.3, 41.4.0, or 42.0.0 that register a custom scheme with supportFetchAPI: true but omit corsEnabled: true fail to enforce CORS, allowing a malicious remote page loaded in the renderer to read the full response body of privileged custom-scheme requests. No public exploit code is identified at time of analysis and the vulnerability is not in CISA KEV, but the confidentiality impact is rated high by the vendor given the potential to exfiltrate internal application data.
Remote code execution as root is achievable against H3C NX15 firmware V100R017 via the `/api/esps` Web API endpoint, which exposes the `service.add` function without adequate access controls (CWE-749). Exploitation requires high-privilege authentication, but a post-authentication proof-of-concept script (`postauth_service_add_rce.py`) is publicly available on GitHub, demonstrating a complete root RCE chain. No vendor patch has been identified at time of analysis; no active exploitation is confirmed in CISA KEV.
Broken object-level authorization in the MultiVendorX WordPress plugin before 5.0.11 allows any authenticated vendor (Store Owner role or above) to perform unauthorized cross-tenant operations against other vendors' stores via the REST API. The plugin fails to verify that the target store in a REST API request belongs to the authenticated vendor, enabling confidentiality breaches, store takeovers, permanent deletion, and arbitrary modification of competitor or co-platform stores. A publicly available exploit exists; EPSS probability is low (0.14%, 4th percentile) suggesting opportunistic or targeted exploitation rather than mass scanning, and this CVE is not currently listed in the CISA KEV catalog.
Integrity tampering in Thermo Fisher Applied Biosystems Genetic Analyzers allows any user with local file system access to silently modify .fsa and .hid output files - the raw DNA sequence and fragment analysis data produced by these instruments - because no cryptographic integrity check (CWE-353) is applied to these files. Affected products span eight distinct data collection and analysis software lines, including the forensic-grade GeneMapper ID-X platform, meaning tampered files could propagate falsified DNA profiles into criminal proceedings or clinical diagnostics without detection. No public exploit code has been identified at time of analysis, and exploitation is covered by CISA ICS Medical Advisory ICSMA-26-216-01.
Hardcoded shared Bluetooth authentication key in KARR BT and DR-100 dealer-installed automotive anti-theft systems allows any attacker within Bluetooth range to issue unauthorized commands to affected vehicles without credentials. Exploitation requires only physical proximity and basic Bluetooth tooling, enabling door unlocking and engine immobilization on any unit sharing the static key. No public exploit or CISA KEV listing has been identified at time of analysis, but the hardcoded key class of vulnerability (CWE-321) is well-understood and trivially reversible once discovered.
OS command injection in HashBrown CMS through version 1.4.6 enables any authenticated user holding media resource scope to execute arbitrary shell commands on the server by exploiting a discrepancy between two filename-parsing functions. The MIME-type filter in getMIMEType() truncates filenames at the first '?' character - accepting 'x.jpg?$(command)' as a valid image - while Node.js Path.extname() does not truncate at '?', allowing the full malicious suffix to flow unescaped into a shell exec() call inside the thumbnail generation routine. No public exploit code or CISA KEV listing has been identified at time of analysis, but the technique is well-understood and requires only low-privilege access, making it a meaningful risk for any internet-accessible deployment.
Arbitrary OS command execution in IBM Langflow OSS 1.0.0 through 1.10.3 is reachable by any authenticated low-privileged user who can modify MCP server configurations. Improper validation of the command field in those configurations allows injected shell commands to be executed with the application's process privileges, yielding full confidentiality, integrity, and availability impact. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low-complexity, network-accessible attack path against a growing AI-tooling platform warrants prompt patching.
Command injection in Cisco Integrated Management Controller (IMC) allows a remotely authenticated low-privileged attacker to execute arbitrary OS commands and escalate privileges to root on affected Cisco UCS Standalone servers. Exploitation requires only low-level credentials to the IMC web-based management interface - no local access, no user interaction. No public exploit has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog, but the low attack complexity and full system impact make it a meaningful priority for any environment with IMC exposed to internal or management networks.
OS command injection in IBM Langflow OSS 1.0.0 through 1.10.3 enables remote authenticated attackers to execute arbitrary system commands on the underlying server. The flaw stems from insufficient sanitization of user-supplied input passed to OS-level command execution routines (CWE-78), granting full system-level access with a single authenticated request. No public exploit code has been identified at time of analysis, and CISA does not list this in KEV, though CVSS-assessed technical impact is total across confidentiality, integrity, and availability.
Arbitrary file upload in LightSync Pro WordPress plugin (all versions through 2.1.6) enables authenticated attackers with Author-level access to upload executable files - including PHP webshells - via the unvalidated `rest_replace_media()` REST API function, with remote code execution as a realistic outcome. The root cause is CWE-434: missing file type validation on the server side, allowing any file extension to be accepted. No public exploit code has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the CVSS score of 8.8 reflects the high post-exploitation impact given the minimal privilege bar (Author role).
OS command injection in HashBrown CMS through version 1.4.6 allows any authenticated user with project configuration access to execute arbitrary OS commands on the server by embedding shell metacharacters in the Git deployer's branch field - an attack surface left exposed by the incomplete remediation of CVE-2020-6948, which fixed single-quote injection in git clone fields but not the branch parameter in the git checkout invocation. GitDeployer.validate() blocks only single-quote characters, leaving semicolons, pipes, ampersands, backticks, and command substitution syntax freely injectable; once planted, the malicious branch value fires automatically on every subsequent deployer operation (media upload, content save) without further attacker interaction. No public exploit code or confirmed active exploitation has been identified at time of analysis, but the attack is mechanistically trivial given the complete absence of metacharacter filtering.
Unsandboxed Twig template rendering in Bolt CMS allows any user holding an editor-level CMS role to inject arbitrary OS commands via Server-Side Template Injection (SSTI), achieving remote code execution as the web server process. The root cause is that Bolt's Twig environment never registers a SandboxExtension, so the full Twig filter chain - including dangerous filters like `passthru` - is available to content authors. The default out-of-the-box configuration of the 'pages' content type ships with `allow_twig: true`, meaning this is exploitable in a standard Bolt installation without any additional misconfiguration. No public exploit has been independently confirmed, though the CVE description includes a working payload demonstrating command execution.
Unauthenticated arbitrary file and directory deletion in GitHub Enterprise Server allows any network-reachable attacker to recursively destroy critical instance data - including Git LFS objects, release assets, issue attachments, and user avatars - by injecting a path traversal sequence into the X-GitHub-Request-Id HTTP request header. The vulnerability stems from using this header value unsanitized as a filesystem path component for an upload buffer directory; a deferred cleanup routine then recursively deletes whatever directory the traversal resolves to, including the entire user storage root. No public exploit has been identified at time of analysis and the CVE is not in the CISA KEV catalog, but the near-zero exploitation bar - no authentication, no user interaction, effective even with private mode enabled - makes this a critical priority for any organization running on-premises GitHub Enterprise Server.
Remote code execution in IBM Langflow OSS 1.0.0-1.10.3 allows authenticated remote attackers to inject and execute arbitrary Python code by crafting payloads that evade the platform's AST-based security scanning mechanism. The flaw (CWE-94, Code Injection) is particularly insidious because the defensive AST validation layer gives a false sense of protection while silently passing malicious constructs to the Python runtime. No public exploit or CISA KEV listing exists at time of analysis, but the low-complexity, fully network-accessible attack path with complete confidentiality, integrity, and availability impact warrants urgent patching - especially for any internet-exposed or multi-tenant deployments.
Remote code execution in IBM Langflow OSS 1.0.0 through 1.10.3 allows authenticated remote attackers to run arbitrary commands by supplying crafted configuration parameters that bypass the application's incomplete input denylist (CWE-184). The flaw carries a CVSS 8.8 score with full confidentiality, integrity, and availability impact, and SSVC rates the technical impact as total. No active exploitation is confirmed - EPSS sits at 0.42% (35th percentile) and the vulnerability is absent from CISA KEV - though the low attack complexity makes it a genuine priority for any internet-exposed Langflow deployment with untrusted authenticated users.
OS command injection in the backmeup npm package allows any attacker who can supply input to the package's name, source, destination, or filter options to execute arbitrary shell commands on the backup host or, when SSH mode is configured, on the remote SSH target. The flaw stems from direct string concatenation of option values into shell command strings executed via child_process or ssh2-exec, with no neutralization of metacharacters beyond path.normalize() and path.join(). No public exploit has been identified at time of analysis, but the CVSS vector (PR:L, AV:N, AC:L) indicates this is straightforwardly exploitable by any low-privilege application user whose input reaches the vulnerable call sites.
Remote code execution in IBM Langflow OSS 1.0.0 through 1.10.3 allows any internet-reachable attacker to execute arbitrary server-side code using only two HTTP requests. The vulnerability is rooted in CWE-94 (Code Injection), enabling full server compromise with no user interaction. A vendor patch is available via IBM advisory, and no public exploit has been identified at time of analysis - however the trivially low attack complexity makes any internet-exposed instance an immediate remediation priority.
Unsandboxed Groovy script execution in Jenkins Multijob Plugin 669.v9d96a_d9c71b_0 and earlier allows any attacker holding Item/Create or Item/Configure permission to run arbitrary code directly on the Jenkins controller JVM. The plugin exposes Groovy scripting capabilities that intentionally bypass the Script Security Plugin - the standard Jenkins mechanism for confining script execution to a restricted sandbox - meaning scripts execute with the full privileges of the Jenkins service account. The fix is available in Multijob Plugin 677.v7ffc23d6a_4c2; no public exploit has been identified at time of analysis and this CVE is not listed in the CISA KEV catalog.
Privilege escalation in Dokan (WordPress multivendor marketplace plugin) versions up to and including 5.0.1 enables any authenticated vendor or seller to read, modify, or delete any WordPress user account - including site administrators - via REST API calls to `/wp-json/dokan/v1/customers/{id}`. The plugin's `CustomersController` re-registers WooCommerce's customer CRUD routes but replaces the native `manage_woocommerce` capability gate with a flawed check that inspects only the requesting user's role and never validates authorization against the target user. Setting the `password` parameter on an administrator's record via a PUT request yields full site takeover. No public exploit identified at time of analysis, though the attack is mechanically trivial for any Vendor-role account holder.
Remote code execution in IBM Langflow OSS 1.0.0 through 1.10.3 is achievable by remote attackers holding low-privilege credentials via server-side code injection (CWE-94). The CVSS score of 8.8 reflects full confidentiality, integrity, and availability impact with a low-complexity network attack path requiring only valid user authentication. No public exploitation has been confirmed - EPSS places the exploitation probability at 0.36% (29th percentile) and SSVC rates exploitation status as none and the attack as non-automatable, though SSVC's technical impact rating is total, consistent with arbitrary code execution.
Remote code injection in IBM Langflow OSS 1.0.0 through 1.10.3 allows an authenticated remote attacker to execute arbitrary code on the underlying server by supplying malicious input through user-controlled code fields within the platform. The CVSS vector (AV:N/AC:L/PR:L) confirms the attack is network-reachable at low complexity, requiring only low-privilege credentials, with full confidentiality, integrity, and availability impact on the host. A vendor patch is available; no public exploit or CISA KEV listing has been identified at time of analysis.
Privilege escalation in Red Hat Build of Keycloak's Dynamic Client Registration (DCR) grants an attacker with low-privilege client registration credentials full realm administrator access by exploiting a validation bypass in the 'Allowed Protocol Mapper Types' security policy. The policy correctly validates mapper types at initial registration but fails to re-validate the mapper type during a client update when the mapper's surrounding configuration is unchanged, allowing a type-swap from a permitted mapper to a restricted high-privilege mapper (such as a HardcodedRoleMapper that injects realm-admin roles into tokens). No public exploit code has been identified and no CISA KEV listing is present, but the attack is low-complexity, fully network-exploitable, and results in complete confidentiality, integrity, and availability compromise of the Keycloak realm.