PHP Object Injection in the User Frontend WordPress plugin (versions before 4.3.11) allows any authenticated subscriber-level user to trigger deserialization of attacker-controlled field values by reopening a previously submitted post in the plugin's frontend editing form. If a suitable PHP gadget chain is present in the WordPress installation - supplied by other installed themes or plugins - this escalates to full remote code execution. A public proof-of-concept is available via WPScan, making exploitation accessible to low-skilled attackers on vulnerable installs.
Stored cross-site scripting in the Simple Ajax Chat WordPress plugin (versions before 20260827) permits unauthenticated users to inject arbitrary HTML and JavaScript into chat messages, which execute in the browser of any viewer including site administrators. Because no authentication is required to post messages and the plugin does not sanitize or escape content before rendering, a single malicious chat post persists and fires against every subsequent visitor. A publicly available exploit demonstrates the issue, and CVSS PR:N/UI:R confirms the attacker-to-victim delivery model: the attacker posts once, then waits for an administrator to trigger code execution by viewing the chat.
Stored XSS in the FAQ Builder AYS WordPress plugin (versions before 1.8.5) permits unauthenticated remote attackers to inject persistent JavaScript payloads via visitor-submitted content that is stored without sanitization and later rendered in the WordPress admin dashboard. A double-bypass condition compounds the flaw: the plugin's own partial HTML escaping is undone by a subsequent server-side decoding step, ensuring injected scripts reach the admin browser intact. When a logged-in administrator views the affected admin panel page, the payload executes with full administrative privileges, enabling session hijacking or complete site takeover. A publicly available exploit exists per WPScan; vendor patch version 1.8.5 is available.
Unauthenticated cross-origin RCE in Windows ML CLI (winml-cli < 0.4.0) is reachable when a developer runs the `serve` command, which exposes a localhost HTTP API with a wildcard CORS policy and no authentication gate. Any malicious webpage visited by the user while the server is running can send cross-origin requests to `/v1/cli/build` or `/v1/cli/config`, inject `trust_remote_code=true`, and cause the server to call `AutoConfig.from_pretrained(trust_remote_code=True)` - downloading and executing attacker-controlled Python code from a remote model repository as the server user. The vendor has released a fix in version 0.4.0; no public exploit is identified at time of analysis.
Authenticated administrators in UnoPim before version 2.1.5 can achieve full server-side remote code execution by uploading arbitrary PHP files through the TinyMCE image upload endpoint, which performs no file extension or MIME type validation before writing files to the public storage disk. The server response discloses the uploaded file's URL, enabling direct invocation of the web shell and arbitrary OS command execution under the web server process context. A publicly available proof-of-concept and vendor-released patch (v2.1.5) both exist; no CISA KEV listing was identified at time of analysis.
Missing authorization on REST API endpoints in the Auto x LINE WordPress plugin (through version 1.0.0) allows unauthenticated remote attackers to read and modify plugin settings and erase log data. The plugin facilitates LINE messaging integration for WordPress sites, meaning exposed settings likely include LINE API credentials and channel tokens. A publicly available proof-of-concept exists per WPScan, and the unauthenticated network-accessible nature of the flaw (PR:N, AV:N) makes it trivially exploitable against any exposed instance. No actively exploited status confirmed in CISA KEV at time of analysis.
Authentication bypass in the OAuth Single Sign On WordPress plugin (versions 6.25.0 through <7.0.1) allows unauthenticated remote attackers to log in as any non-administrator WordPress user by forging the identity assertion returned during the Steam SSO flow, without possessing valid credentials. Attackers can additionally register entirely new accounts, providing persistent footholds. A publicly available proof-of-concept exploit reported by WPScan materially elevates real-world risk and makes this an immediate patching priority for affected sites.
Unauthenticated administrator account takeover in the Advanced Custom Fields: Extended WordPress plugin before 0.9.2.7 is possible when a site exposes a front-end user-update form configured to target an administrator account with a visitor-supplied password field. The plugin's Forms module skips the authorization check on who may edit the targeted account unless the submitted role is administrator or super_admin, creating a gap exploitable by any site visitor. A publicly available proof-of-concept from WPScan exists and a vendor patch is available at version 0.9.2.7.
Privilege escalation to administrator in the Advanced Custom Fields: Extended WordPress plugin before 0.9.2.7 allows unauthenticated visitors to bypass role restrictions enforced on front-end user registration forms. The plugin fails to validate that a submitted role value matches those actually offered by the configured form, and its blocklist against privileged roles is incomplete, enabling a two-stage attack: register with an elevated role, then escalate that account to full site administrator. A publicly available exploit exists per WPScan disclosure, raising the urgency of patching; no public KEV listing has been identified at time of analysis.
Stored XSS in the RegistrationMagic WordPress plugin prior to version 6.0.9.9 allows unauthenticated attackers to inject malicious scripts into registration form fields that are rendered unescaped within HTML attributes on WordPress administrative pages. When a privileged administrator subsequently views the affected backend page, the attacker's payload executes in the admin's browser context, enabling session hijacking, credential theft, or unauthorized administrative actions. A publicly available proof-of-concept exists via WPScan, and a vendor-released patch (6.0.9.9) is confirmed available.
Reflected XSS in Photo Gallery by 10Web WordPress plugin (all versions before 1.8.44) lets an unauthenticated attacker execute arbitrary JavaScript inside the authenticated browser session of an administrator or contributor by tricking them into clicking a crafted link. Two distinct injection sinks exist: the Shortcode admin page (exploitable against contributors and above) and the Galleries/Albums list page (requires the site to have more than 20 galleries, and targets administrators). Both sinks reflect unsanitized request parameters into HTML input-attribute values and weaponize an auto-firing onfocus event handler, bypassing some user-interaction defenses. A publicly available PoC via WPScan confirms the issue; vendor-patched version 1.8.44 is available.
Reflected Cross-Site Scripting in the Social Media Share Buttons & Social Sharing Icons WordPress plugin (all versions before 3.0.1) allows unauthenticated remote attackers to inject and execute arbitrary JavaScript in a victim's browser by embedding a malicious payload in a crafted URL targeting an unescaped request parameter rendered inside an inline JavaScript event handler. Exploitation is constrained to sites running a non-default icon display configuration, and requires the victim to interact with the affected share button. A public proof-of-concept is available via WPScan; no active exploitation has been confirmed by CISA KEV.
Privilege escalation in the JetBackup WordPress plugin before 3.1.23.5 allows a subscriber-level user to gain full administrator access by exploiting the plugin's failure to validate account roles during a site restore or migration. When the site owner performs a legitimate backup restore or migration, JetBackup blindly preserves and promotes accounts in the backup set without re-verifying their roles or capabilities, silently elevating an attacker's low-privilege account to administrator. A publicly available proof-of-concept exists per WPScan, though no confirmed mass exploitation (CISA KEV) is on record; the CVSS 7.1 score (AC:H/UI:R) reflects real-world complexity imposed by the site-owner trigger.
Incomplete patch for OS command injection in the Nuclio serverless dashboard (local/Docker platform, all versions prior to 1.17.4) leaves the list-all resource code path exploitable by unauthenticated remote attackers. Shell metacharacters injected via the X-Nuclio-Function-Namespace, X-Nuclio-Project-Namespace, or X-Nuclio-Function-Event-Namespace HTTP headers bypass the prior fix and reach a /bin/sh -c invocation in pkg/platform/local/client/store.go unescaped, enabling arbitrary command execution inside the dashboard container. No public exploit has been identified at time of analysis, but the attack surface is network-accessible and requires no authentication, lowering the bar significantly for any attacker already familiar with the previously disclosed injection class (GHSA-jx7q-cpg6-669g).
Authenticated SQL injection across Zohocorp ManageEngine Password Manager Pro, PAM360, and Access Manager Plus enables any low-privilege authenticated user to query or manipulate the backend database. Because these products serve as enterprise privileged access management vaults - centralizing credentials for critical infrastructure - a successful injection attack could expose the entire stored credential set. Zohocorp has released fixed builds for all three products and no public exploit has been identified at time of analysis.
Remote code execution in Jenkins 2.579 and earlier (LTS 2.568.2 and earlier) allows any low-privileged authenticated user to compromise the Jenkins controller by submitting a crafted `config.xml` document. The document embeds objects that Jenkins treats as independent top-level configuration types - such as job definitions or global settings - as nested field values; once bound into Jenkins' runtime object graph, Stapler (Jenkins' HTTP routing framework) begins dispatching live HTTP requests through those embedded objects, providing an attacker-controlled code execution path. Vendor-released patches (Jenkins 2.580, LTS 2.568.3) are available as of 2026-09-02; no KEV listing or public POC is confirmed at time of analysis.
Remote code execution is possible in the DevKit Pro WordPress plugin (versions ≤ 2.3.0) by any authenticated user holding Subscriber-level access or higher. The DPDEV_install_themes_func() function, registered on the wp_ajax_DPDEV_install_themes AJAX action, lacks both a WordPress capability check and nonce validation, allowing low-privileged users to upload and extract arbitrary theme ZIP packages - including PHP webshells - into the web-accessible wp-content/themes/ directory. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog, but the low privilege requirement (Subscriber) makes this a realistic risk on any WordPress site with open user registration.
Arbitrary file write to remote code execution in Jenkins File Parameter Plugin (versions ≤ 425.v3fa_801681b_5e) is achievable by any low-privilege authenticated Jenkins user through a Stapler data binding flaw. By crafting a build request with a path-traversal file parameter, an attacker can write attacker-controlled content to arbitrary locations on the Jenkins controller filesystem, enabling code execution by overwriting Groovy init scripts, SSH authorized_keys, or other sensitive files. No public exploit has been identified at time of analysis, and CISA SSVC rates current exploitation as none - but the technical impact ceiling is total controller compromise.
Unsafe type instantiation during form data binding in Jenkins Stapler allows low-privileged authenticated users to trigger instantiation of arbitrary object types unrelated to the intended field type, achieving full compromise (C:H/I:H/A:H) of the Jenkins controller. Affected are Jenkins 2.579 and earlier and LTS 2.568.2 and earlier, via Stapler 2107.v8dfcb_e8ed317 and earlier (excluding the backport 2088.2093.vd7c3e58008a_6). The root cause is CWE-502-class unsafe deserialization/type-binding: Stapler fails to constrain which Java types may be instantiated when processing attacker-controlled HTTP form submissions. No public exploit code or CISA KEV listing is identified at time of analysis, but Jenkins is pervasively deployed in CI/CD pipelines and the low privilege bar (Overall/Read) makes this a high-priority patch target.
NGINX JavaScript (njs) and QuickJS (qjs) fail open during the js_access phase when an exception is thrown inside an asynchronous request-body processing handler before an explicit access-denial is returned. The flaw (CWE-636, Not Failing Securely) allows unauthenticated remote attackers to bypass js_access controls entirely and reach protected backend resources. No public exploit code or CISA KEV listing has been identified at time of analysis; exploitation is bounded by the requirement for a specific async access-handler pattern.
Unrestricted Java deserialization in Jenkins Performance Plugin 1015.v09ca_52b_3370e and earlier enables any user holding Item/Configure permission to execute arbitrary code on the Jenkins controller. The plugin stores performance test results as serialized Java objects in the build directory and reads them back without enforcing a class allowlist, enabling classic gadget-chain exploitation (CWE-502). No public exploit has been identified at time of analysis, and SSVC rates exploitation as none with non-automatable delivery, but technical impact is rated total - full Jenkins controller compromise.
Path traversal in Jenkins Allure Plugin 2.35.2 and earlier allows any user holding Item/Read permission on a Jenkins job that publishes Allure test reports to read arbitrary files from the Jenkins controller's filesystem, including credentials, configuration files, and secrets stored on the controller. The vulnerability is reachable over the network with only low-level authenticated access - a standard privilege held by most Jenkins users in typical multi-user deployments. No public exploit code has been identified at time of analysis, and CISA SSVC classifies exploitation as none currently, though technical impact is rated total given unconstrained file read on the controller.
Unauthenticated remote access to PikiwiDB (Pika) v3.5.7's internal protobuf replication server allows attackers to exfiltrate complete database snapshots and intercept live write streams without any credentials. The replication port - exposed on a fixed, predictable offset from the client port (default 11221) - routes TrySync, DBSync, BinlogSync, and RemoveSlaveNode requests directly without requiring a prior authenticated MetaSync handshake, rendering the requirepass/masterauth configuration control entirely ineffective. No active exploitation is confirmed at time of analysis, but the remote, unauthenticated, low-complexity attack path makes this a high-priority exposure for any deployment where the replication port is reachable from untrusted networks.
Unsafe Java deserialization in Jenkins 2.579 and earlier (LTS 2.568.2 and earlier) allows authenticated users with configuration-submission permissions to control the values of transient fields during deserialization, with impact ranging up to full server compromise depending on how those fields are used internally. Transient fields in Java are normally excluded from serialization to protect derived or sensitive state; this flaw breaks that guarantee when processing externally supplied configuration data. No public exploit code or active exploitation has been confirmed at time of analysis, but given Jenkins' role as a CI/CD orchestrator with broad network access and secrets, the blast radius of exploitation is significant.
Stored XSS in Jenkins' system log viewer exposes administrators and privileged users to session hijacking and UI redress attacks, exploitable by any attacker who controls a Jenkins agent process. The vulnerability affects Jenkins 2.579 and earlier (including LTS 2.568.2 and earlier), where log record metadata - source, level, and timestamp - is rendered in the browser without HTML escaping, allowing persistent JavaScript injection via agent-controlled log channels. Patch versions 2.580 (weekly) and LTS 2.568.3 are available per the Jenkins security advisory SECURITY-3967; no public exploit code or CISA KEV listing has been identified at time of analysis.
PHP Object Injection in the Ninja Forms - Layout & Styles WordPress plugin (versions ≤ 3.0.31) exposes sites to unauthenticated remote code execution through unsafe deserialization of attacker-controlled PHP objects. Classified under CWE-502 (Deserialization of Untrusted Data), the flaw allows a crafted serialized payload to trigger property-oriented programming gadget chains already present in the WordPress plugin environment, yielding full confidentiality, integrity, and availability compromise of the affected server. No active exploitation has been confirmed in the CISA KEV catalog, but the unauthenticated network attack path and high-impact triad (C:H/I:H/A:H) demand immediate remediation across all affected WordPress deployments.
Verification bypass in prevail eBPF verifier versions before 0.2.4 allows any caller with eBPF program submission access - including unprivileged users on BPF-enabled kernels - to load programs that incorrectly pass safety checks but destroy the upper 32 bits of kernel pointer registers at runtime via ALU32 ADD and SUB instructions. The runtime effect is either a program fault (availability impact) or exposure of the lower 32 bits of a kernel pointer as a leakable scalar, partially defeating kernel ASLR. A vendor patch is available at v0.2.4; no active exploitation or public exploit code has been identified at time of analysis.
Stored cross-site scripting in Jenkins Customizable Header Plugin 295.v2544b_ca_19b_97 and earlier allows authenticated attackers with permission to modify plugin appearance settings to inject persistent JavaScript payloads via a crafted SVG icon, executing in the browser context of any Jenkins user who loads the affected header. Because the header renders on every Jenkins page, a single write operation by a low-privileged attacker broadly affects all platform users, including administrators. No public exploit code has been identified at time of analysis, and SSVC categorizes exploitation as none, though technical impact is rated total.
Privilege escalation in the LiquidThemes Booking Hub WordPress plugin (≤1.3.1) allows authenticated low-privileged users to incorrectly assign themselves or others elevated WordPress roles, up to and including administrator. The flaw stems from CWE-266 (Incorrect Privilege Assignment) - the plugin fails to enforce proper capability checks before processing role or privilege assignment operations. CVSS 8.8 (PR:L) confirms exploitation requires an existing low-privilege account; no public exploit code or CISA KEV listing identified at time of analysis.
Improper neutralization flaws (CWE-707) in Cisco IOS XR Software allow an authenticated remote attacker with low privileges to achieve full confidentiality, integrity, and availability impact against affected devices. The vulnerabilities were identified internally by Cisco's security engineering team and addressed in a batch hardening release, reference advisory cisco-sa-hardening-iosxr-qg64NcM. No public exploit code has been identified at time of analysis, though the CVSS 8.8 score and complete C/I/A triad reflect significant potential impact in carrier and enterprise routing infrastructure.
Remote code execution inside Chrome's sandbox is achievable via a use-after-free in WebRTC, triggered when a victim visits a specially crafted HTML page. Affected versions are all Chrome releases prior to 152.0.7977.75 across desktop platforms. No public exploit code or CISA KEV listing has been identified at time of analysis, though the sandboxed execution boundary limits the practical impact compared to the raw CVSS 8.8 score - Google's own Chromium severity rating of 'Medium' reflects this containment.
Improper handling of exceptional conditions (CWE-703) in Cisco IOS XR Software allows an authenticated, remote attacker with low-privilege credentials to achieve high-impact compromise of confidentiality, integrity, and availability. The vulnerabilities were discovered internally by Cisco's security engineering team during a proactive review and are addressed in a software hardening release. No public exploit or active exploitation has been identified at time of analysis, but the CVSS 8.8 score and full C:H/I:H/A:H impact profile make this a significant risk for service-provider and enterprise core-network operators running affected IOS XR releases.
Authentication bypass in the Jenkins SAML Plugin (all versions through 4.618.v441a_27fa_46d2) allows any authenticated low-privilege user to overwrite the SAML identity provider metadata file via unrestricted Stapler data binding, replacing it with attacker-controlled content. Once the IdP metadata is replaced, the attacker operates their own SAML authority and can issue assertions claiming any Jenkins user identity - including administrator - granting full platform compromise. No active exploitation is confirmed (not in CISA KEV), and no public POC has been identified at time of analysis.
Privilege escalation in Jenkins Microsoft Entra ID Plugin (≤710.v0b_ff8e9cc2d2) allows any Entra tenant member with group-creation rights to inherit Jenkins permissions configured for a privileged group by creating a new Entra group whose display name collides with a privileged group's display name. The plugin incorrectly resolves group identity using both the immutable object ID and the mutable, user-controllable display name, so the collision satisfies the authorization check without the attacker belonging to the legitimate privileged group. No public exploit has been identified and CISA has not listed this in KEV, but exploitation requires only a valid Entra account, making it a meaningful insider or tenant-level escalation path into CI/CD infrastructure.
Remote code execution within the browser sandbox is possible in Google Chrome versions prior to 152.0.7977.75 due to a use-of-uninitialized-resource flaw (CWE-908) in the V8 JavaScript engine. An attacker can trigger the vulnerability by luring a user to a crafted HTML page, with no authentication or special privileges required beyond normal web browsing. Google has released the patched build 152.0.7977.75; SSVC rates exploitation status as none and no CISA KEV listing has been identified at time of analysis.
Use-after-free in Chrome's TabStrip component enables remote code execution outside the renderer sandbox in Google Chrome versions prior to 152.0.7977.75. An attacker must social-engineer a user into a specific UI interaction to trigger the memory-corruption primitive, after which arbitrary code executes at browser-process privilege - a full sandbox escape. Google has issued a stable channel patch; no public exploit or CISA KEV listing has been identified at time of analysis.
Incorrect calculation vulnerabilities (CWE-682) in Cisco IOS XR Software allow an unauthenticated attacker on an adjacent network segment to achieve full confidentiality, integrity, and availability compromise of the affected device, as reflected by the CVSS 8.8 AV:A/PR:N/C:H/I:H/A:H vector. The vulnerabilities were discovered through an internal Cisco engineering security review and addressed in a software hardening release; no external exploitation has been reported. Given that IOS XR underpins carrier-grade routers and service-provider backbone infrastructure, successful exploitation could be highly disruptive to network operations.
CSRF token leakage in Jenkins allows an attacker who controls any same-origin page on the Jenkins controller to silently steal a valid CSRF crumb from an authenticated user's session and forge privileged requests on their behalf. The vulnerability spans Jenkins 2.447-2.579 (weekly) and LTS 2.452.1-2.568.2 via the bundled Stapler web framework, which embeds the session crumb as a plaintext string literal inside dynamically generated JavaScript responses. No public exploit or CISA KEV listing is present at time of analysis, but successful exploitation yields full account-level action forgery against any authenticated victim who visits the attacker-controlled page.
Cross-site request forgery in the Simply Schedule Appointments WordPress plugin (versions ≤ 1.6.12.23) enables an unauthenticated remote attacker to perform arbitrary privileged actions on behalf of a logged-in WordPress administrator. By luring an authenticated admin into loading a malicious web page or clicking a crafted link, the attacker's forged request is executed with the victim's full session privileges - potentially manipulating appointment data, customer records, and plugin configuration. No public exploit code or active exploitation has been identified at time of analysis, and the vulnerability is reported by Patchstack.
Cross-Site Request Forgery in the Mang Board WP WordPress plugin (versions ≤ 2.3.8) allows a remote unauthenticated attacker to perform unauthorized admin-level actions by tricking an authenticated site administrator into visiting a malicious page. Because the plugin's state-changing endpoints lack WordPress nonce verification, the victim's browser automatically submits forged requests using the administrator's active session, yielding high confidentiality, integrity, and availability impact over plugin-managed board content. No public exploit code has been identified and the vulnerability is not listed in CISA KEV at the time of analysis.
PHP Object Injection in the WP User Frontend WordPress plugin (versions ≤ 4.3.10) allows any subscriber-level authenticated attacker to submit crafted serialized PHP payloads over the network, triggering unsafe deserialization. If a usable gadget chain exists among the site's installed plugins or themes - common in the broad WordPress ecosystem - this can escalate to arbitrary code execution, file write, or full site compromise. Reported by Patchstack; no public exploit code or CISA KEV listing identified at time of analysis.
Out-of-bounds read in ION-DTN's decodeSdnv() function before version 4.2.0 allows unauthenticated remote attackers to trigger reads up to nine bytes past buffer boundaries by sending a UDP datagram with a truncated SDNV to the LTP link service input port. The unbounded design of the original function - which consumed octets until finding one with a clear high-order bit - made it exploitable whenever all bytes in a truncated input retained the high-order bit set, simultaneously causing byte counter underflow. No public exploit has been identified at time of analysis; a vendor-released patch is available as ION-DTN 4.2.0.
Authenticated command injection in Coolify before 4.2.0 allows low-privileged platform users to execute arbitrary OS commands on managed server hosts by embedding shell metacharacters into Docker environment variable key names. The flaw bypasses container isolation entirely - injected payloads travel over SSH as part of Coolify-generated Docker commands and execute in the host OS context, not within any container sandbox. The upstream fix in v4.2.0, confirmed by GitHub release tag and patch commit b50839d4515b115b7ded5db609471440249995da, adds validation constraints in ValidationPatterns.php to reject malformed key names before command construction.
Path traversal in facefusion's HTTP job management API allows unauthenticated remote attackers to write files at arbitrary server locations, escaping the intended jobs directory sandbox. Versions through 3.6.1 are affected; the root cause is failure to normalize job identifiers in get_job_file_name before constructing file paths. A patched release (3.7.0) is available, and the vulnerability is corroborated by a VulnCheck advisory and an independent researcher writeup, though no active exploitation has been confirmed via CISA KEV.
Uncontrolled recursion in Amazon Ion-C before v1.1.6 allows a remote unauthenticated attacker to crash any application that parses untrusted Ion data using this library, causing a denial of service via native call stack exhaustion. The fix, released in v1.1.6 and titled 'Harden container depth,' confirms the root cause is missing or insufficient depth limiting on nested Ion container parsing. No authentication is required and no special configuration is needed beyond the application accepting Ion input from untrusted sources. No public exploit code has been identified at time of analysis.
NULL pointer dereference in NGINX JavaScript (njs) crashes NGINX worker processes when an njs script calls ngx.fetch() against a server that returns a malformed HTTP response and subsequently reads Response.statusText on the result. All versions of F5's NGINX JavaScript module are listed as affected per the wildcard CPE, and the impact is confined entirely to the data plane - worker availability - with no control-plane, confidentiality, or integrity exposure. No public exploit code exists and the CVE is not listed in CISA KEV at time of analysis, but the network-accessible path and zero-privilege requirement make this a credible service-disruption risk for any NGINX deployment using njs-based outbound HTTP fetching.
Privilege escalation in FeatherPanel before v1.3.7.10 permits any authenticated subuser to rewrite their own permission record via the `SubuserController::updateSubuser` handler, immediately gaining full server control. The root cause (CWE-862 Missing Authorization) is confirmed by the fix commit, which adds `USER_UPDATE` permission enforcement, a self-modification block, and whitelist validation of permission names - none of which existed in the vulnerable code path. No public exploit code has been independently confirmed, but the VulnCheck advisory and commit diff together provide sufficient technical detail to reconstruct the attack.
Improper authorization in Craft CMS 5.x allows any authenticated control panel user to change their own password without supplying the current credential or holding an elevated session, and allows users holding the `Edit users` permission to reset other users' passwords - including administrator accounts - enabling full account takeover. The flaw exists in the `elements/save` action, where the `UserPasswordValidator` mass-assigns the `newPassword` field outside of any scenario restriction, bypassing the dedicated `users/set-password` action that enforces elevated session checks. No active exploitation is confirmed (not in CISA KEV); vendor-released patch is available in version 5.10.8.
GraphQL mutation resolvers in Craft CMS allow a token-authenticated user scoped to Site A to create, modify, or delete content entries in any other site (Site B, Site C, etc.) within the same multi-site installation. The saveEntry and deleteEntry resolvers read siteId directly from user-controlled $arguments without invoking ArgumentManager::prepareArguments(), which performs the critical array_intersect check against the GraphQL schema's allowed-sites list. Query resolvers call prepareArguments() correctly and thus enforce site boundaries, making this a mutation-specific authorization bypass. Craft CMS 5.10.11 ships the fix via the new MutationResolver::requireAllowedSite() guard; no public exploit or CISA KEV listing has been identified at time of analysis.
Annotation injection in F5 NGINX Ingress Controller allows any authenticated Kubernetes principal with write access to Ingress resources to embed arbitrary NGINX configuration directives through unsanitized annotation fields. The configuration generator passes multiple user-controllable annotation values directly into the generated nginx.conf without sanitization, enabling an attacker to inject directives that create or delete files, disable services, or manipulate NGINX routing behavior. Impact is confined to the Kubernetes control plane; the NGINX data plane itself is not directly reachable through this vulnerability.