An out-of-bounds memory write in Google Chrome allows an unauthenticated, remote attacker to corrupt memory and potentially execute arbitrary code or crash the browser when a victim opens a crafted web page, as reflected by the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H (9.6, scope-changed). The flaw is classified as CWE-787 (out-of-bounds write) and is addressed by the vendor's stable channel update for desktop, with the fix credits originating from the Ubuntu vendor reporting channel, meaning downstream Chromium packages are also in scope. At time of analysis there is no public exploit identified, no CISA KEV listing, and no EPSS data provided; however, because browser memory-corruption bugs of this class are historically attractive to exploit developers, this remains a high-priority patching item despite the absence of exploitation telemetry.
Unspecified security defects in Google Chrome desktop builds are addressed by a September 2026 stable-channel update, meaning only users running outdated installations remain exposed. The exact vulnerability class, attack vector, and privilege requirements are not disclosed in the available data, so the primary applicability condition is simply that the victim runs an unpatched Chrome desktop build and loads attacker-influenced web content, which implies user interaction (browsing) as a limiting factor. There is no CVSS score or vector, no CWE mapping, no EPSS probability, no CISA KEV listing, and no public exploit code identified at time of analysis, so no quantitative severity or exploitation-probability framework can be applied to this record.
The affected product and the nature of the security impact for CVE-2026-95325 cannot be established from the intelligence available at time of analysis. The only signal present is that the entry was reported by the vendor source 'ubuntu', with no description, CVSS score or vector, CWE mapping, CPE identifiers, references, EPSS score, or KEV status supplied; the independent assessment accordingly classifies this as a data-void entry with no analyzable signals. No public exploit identified at time of analysis, and there is no basis to characterize the attack vector, authentication requirements, or affected versions.
Google Chrome on the desktop stable channel carries a vendor-patched security defect tracked as CVE-2026-95347, disclosed through Google's Chrome Releases stable-channel update in September 2026. The actual impact is currently undetermined: no description, CVSS score or vector, CWE classification, or affected version range has been published, so the vulnerability class, whether attackers must be authenticated, and whether user interaction (such as visiting a crafted page) is required cannot be confirmed from available data. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and no EPSS probability or SSVC decision data exists to refine the risk; this should be treated as a patch-priority item pending the details in the vendor advisory.
Risk cannot be meaningfully assessed for CVE-2026-95299 because the vulnerability record contains no description, no CVSS score or vector, no CWE mapping, and no CPE/product identifiers; the only attributable data point is that the issue was reported by the vendor Ubuntu. Consequently the affected component, the attack surface, and any prerequisite conditions remain unknown, and no public exploit has been identified at time of analysis. Analysts should treat this identifier as unresolved rather than low-risk: an empty record frequently reflects a placeholder or embargoed entry that is populated later, so the absence of detail is not evidence of low severity.
OS command injection in Plesk allows any authenticated low-privilege panel account - customer, reseller, or subscription level - to run arbitrary operating-system commands with root privileges, turning what is normally a tightly scoped hosting login into full control of the managed server. The flaw is remotely reachable over the network at low complexity with no user interaction (CVSS 4.0 base 9.4; independently assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), and the scope change plus high confidentiality, integrity, and availability impact reflect a complete host compromise rather than a single-tenant breach. No public exploit code has been identified at time of analysis and the CVE is not listed as confirmed actively exploited (CISA KEV), but the low bar of a single valid non-admin session keeps the practical risk high; the specific vulnerable panel function and the exact affected Plesk versions are not stated in the available data and must be confirmed against the vendor advisory.
SQL injection in SourceCodester Online Reviewer Management System 1.0 allows attackers to manipulate the test_id parameter in /reviewer_0/admins/assessments/pretest/exam-delete.php, potentially reading or altering database contents. Publicly available exploit code exists, but practical exploitation requires reaching the administrative interface and likely a valid admin session despite the CVSS 4.0 vector indicating no privileges; the product's rare deployment footprint further limits real-world risk. This is a classic high-nominal/low-real-risk finding with limited confidentiality, integrity, and availability impact.
SQL injection in SourceCodester Online Reviewer Management System 1.0 lets an attacker who can reach the administrative assessment endpoint inject arbitrary SQL through the test_id parameter of /reviewer_0/admins/assessments/pretest/btn_functions.php?action=update, exposing and potentially altering stored review and assessment data. Publicly available exploit code exists (a proof-of-concept is published in the GitHub issue referenced by VulDB), and the vendor has not shipped a fixed version. Because the vulnerable path sits under /admins/, exploitation in practice most likely requires a valid administrative session, making reachability of the admin area and credential strength the primary limiting factors; the CVSS 4.0 score of 6.9 treats it as PR:N, our own assessment rates it CVSS:3.1 AV:N/AC:L/PR:L/UI:N with high confidentiality and low integrity impact.
SQL injection in SourceCodester Online Reviewer Management System 1.0 lets remote attackers inject arbitrary SQL through the difficulty_id parameter on the /reviewer_0/admins/assessments/databank/btn_functions.php endpoint when action=add, allowing partial read, modification, and disruption of the underlying database. The vendor-supplied CVSS 4.0 score is 6.9 with a vector claiming no privileges or user interaction required (PR:N/UI:N), but the vulnerable path sits inside the /admins/ administrative area, which in typical deployments is only reachable behind an authenticated administrator session - an independent assessment re-rates it as CVSS 3.1 AV:N/AC:L/PR:L/UI:N with low confidentiality, integrity, and availability impact. Publicly available exploit code exists and has been published alongside the disclosure, and there is no indication of confirmed active exploitation (no CISA KEV listing), while exploitation is further constrained by how few instances of this obscure PHP application are deployed and internet-reachable.
Missing authorization in the Abdurrab5 Online Makeup Store PHP application allows unauthenticated remote attackers to reach admin-only functionality by supplying a crafted adminid argument to the confirm_logged_in/confirm_user functions in functions.php, enabling low-impact confidentiality, integrity, and availability effects. Publicly available exploit code exists-including a GitHub write-up-but no CISA KEV confirmation or EPSS data is provided, so active exploitation is not confirmed. The vendor uses a rolling release with no version metadata, meaning all deployments of this codebase should be considered potentially affected, though the project's niche, single-developer nature limits its real-world attack surface.
Unauthenticated account creation in Neethuharii CafeManagement lets any remote attacker who can reach the AddCashierCode.php endpoint provision a new cashier account with attacker-chosen uname, pass, role and status values, because the addcashier function performs no authorization check (CWE-285). Publicly available exploit code exists - a third-party GitHub writeup demonstrates the missing-authentication account-creation path - but there is no sign of active exploitation and the CVE is not in CISA KEV. The vendor was contacted early and never responded, so no fixed release is available; the practical impact is bounded to Low confidentiality, integrity and availability effects (cashier-level account creation rather than administrative takeover) and should be weighed against the project's limited real-world production footprint, meaning the headline CVSS 4.0 score of 6.9 overstates real-world priority.
SQL injection in DataLife Engine 18.0 allows remote, unauthenticated attackers to manipulate the 'story' parameter in the Search Module's strip_data function, potentially leading to partial data disclosure or modification. Publicly available exploit code exists, and the vendor did not respond to disclosure, so no vendor-released patch is identified at time of analysis. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms network reachability without privileges or user interaction, though impact is limited to low confidentiality and integrity loss per the assessed CVSS 3.1 vector.
Remote unauthenticated SQL injection in the Abdurrab5 'online-makeup-store' customer login handler (customerSignin.php) allows attackers to inject arbitrary SQL via the username or password arguments, potentially leading to full database compromise with high confidentiality and integrity impact. The flaw is confirmed by a publicly available exploit write-up on GitHub, and the CVSS 4.0 vector carries the E:P proof-of-concept maturity flag, though exploitation in production is expected to be rare due to the niche deployment footprint of this individual-developer application. No vendor patch is available at time of analysis, and the project uses a rolling release model, so no fixed version can be identified.
Unauthenticated SQL injection in the Online Makeup Store PHP application lets remote attackers manipulate the 'id' and 'password' parameters of index.php's Admin Login Handler. Because the injectable parameters sit on the public login endpoint, no credentials, user interaction, or special configuration are required, and publicly available exploit code exists (no CISA KEV listing). Practical risk is dominated by deployment scarcity: this is an individual developer's project with no versioned releases and negligible production footprint, so few real targets are likely to exist even though any reachable instance is exploitable.
A crafted HISTORY_IGNORE value can hang a JLine reader session (org.jline:jline-reader) via catastrophic regular-expression backtracking, pinning the reader thread at high CPU each time a command line is written to history. Applications that embed JLine 3.x (>= 3.0.0, < 3.30.15) or 4.x (>= 4.0.0, < 4.3.1) and let HISTORY_IGNORE be set from user configuration or application settings are affected; the impact is limited to denial of service with no confidentiality or integrity effect. The attacker must already be able to control configuration (CVSS vector PR:L, AV:L), so this is a low-to-moderate real-world priority; no public exploit code was identified at time of analysis, although the vendor advisory documents deterministic reproduction steps, and vendor patches shipping the fix are available in 3.30.15 and 4.3.1.
Argument injection in WP Toolkit for cPanel 6.11.2-10794 and earlier allows a remote authenticated (low-privileged, PR:L per the CVSS vector) customer account to read arbitrary files and execute arbitrary code, with the impact extending beyond the attacker's own account into other tenants hosted on the same cPanel server. Any standard shared-hosting customer login - including a self-registered or compromised account - is sufficient, requiring no user interaction and no elevated privileges, though the extension must be installed, enabled, and reachable on a version at or below 6.11.2-10794. There is no public exploit identified at time of analysis and the issue does not appear on CISA KEV; the defining risk amplifier is the multi-tenant scope change (S:C) rather than mass internet-wide exploitation.
Remote stack-based buffer overflow in the Device Discovery Service of FAST FAC1203R Gigabit Edition 2.0.4 routers allows unauthenticated attackers to execute arbitrary code via a crafted message processed by the copy_msg_element function. A public proof-of-concept exploit has been published, and the vendor has not released a patch. While the CVSS vector indicates network exploitable (AV:N), the discovery service is typically limited to the LAN broadcast domain, so attackers most likely need adjacent network access rather than internet routing.
Any holder of a valid low-privileged cPanel account can escalate to root and execute arbitrary code on the underlying host, because a privileged cPanel operation is executed with unnecessary root privileges (CWE-250). The flaw is remotely reachable over the network with low attack complexity and no user interaction, but it does require an authenticated account (CVSS 4.0 vector PR:L) - a trivial barrier on shared hosting where accounts are commonly sold or self-provisioned, and a meaningful one on locked-down single-tenant deployments. It carries a 9.4 CVSS 4.0 score and is rated a genuine high-priority issue rather than a high-score/low-real-risk case, though no public exploit code and no confirmed active exploitation were identified at time of analysis; no EPSS estimate was available in the supplied intelligence.
Unauthenticated SQL injection in CafeManagement's CafePortalLogin.php login handler allows remote attackers to bypass authentication and potentially read or modify backend data. Publicly available exploit code exists, including a Medium writeup, and the vendor did not respond, leaving a rolling-release product without an official patched version; severity signals conflict, with the supplied CVSS 4.0 score of 5.5 understating the independently assessed high confidentiality and integrity impact.
Unrestricted file upload in the AddProductCode.php endpoint of Neethuharii CafeManagement lets unauthenticated remote attackers upload arbitrary files, including PHP scripts, by manipulating the 'image' parameter - a public proof-of-concept writeup by researcher 'mr.yk404' describes achieving remote code execution through this path, and exploitation requires no authentication, privileges, or user interaction (CVSS 4.0 AV:N/AC:L/PR:N/UI:N, E:P). The vendor was contacted but did not respond, and because CafeManagement uses a rolling release model, no affected or fixed version numbers are published; the CPE entry (cpe:2.3:a:neethuharii:cafemanagement:*:*:*:*:*:*:*:*) treats all versions as potentially vulnerable. Vendor scoring places this at CVSS 4.0 6.9, while our independent assessment rates it CVSS 3.1 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) because successful upload of executable content to a web-reachable directory yields full confidentiality, integrity, and availability impact; the practical limiter is deployment scarcity, as this is a niche hobbyist application rarely exposed in production.
Unauthenticated file upload in Laravel-Mediable 7.0.0 and 7.0.1 lets a remote attacker upload a .pht file that passes MediaUploader::verifyExtension() and File::sanitizeFileName(), which is then written to disk and executed as PHP when requested on Apache servers configured with the Debian/Ubuntu default FilesMatch handler, resulting in remote code execution as the web server process. The flaw is an incomplete fix for CVE-2026-49972: the forbidden_extensions list added in config/mediable.php blocks phpt but omits pht, an Apache-recognized PHP extension. Vendor-released patch 7.0.2 closes the gap; no public exploit code was identified at time of analysis, but exploitation is trivial where the upload endpoint is reachable and unauthenticated, so the issue warrants high priority despite the platform-specific precondition.
Moquette MQTT brokers prior to 0.18.1 can start up with authentication and authorization silently disabled whenever a configured authenticator_class or authorizator_class fails to load, so any remote client - including anonymous MQTT clients, since the broker is anonymous by default - can read and write every topic the broker handles while the operator believes access controls are active. The flaw is not directly attacker-triggered: it requires a deployment that both intends to enforce auth and has a broken class-load (misspelled class name, missing dependency, constructor failure, or classpath problem), which is why the independent assessment rates it CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N even though the end-state is a full confidentiality and integrity break; the vendor's CVSS 4.0 vector is 9.3. No public exploit for this fail-open condition was identified at time of analysis, and no CISA KEV entry is present; version 0.18.1 fixes the issue by aborting startup instead of falling back to permissive defaults.
Improper authorization in the WPGraphQL WordPress plugin's updatePost GraphQL mutation allows an authenticated Contributor to publish their own draft posts without the publish_posts capability and to edit their own already-published posts without edit_published_posts, bypassing the site's editorial approval workflow. Confirmed in WPGraphQL 2.19.0 under default settings; the equivalent requests against the WordPress REST API are correctly rejected with rest_cannot_publish and rest_cannot_edit. Impact is bounded - the attacker must already hold a valid Contributor account (unauthenticated exploitation is not possible), can only touch posts they own, and cannot escalate privileges, modify other authors' content, or execute code; no public exploit code was identified at time of analysis, and the issue is rated MEDIUM (CVSS 5.4, AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L).
Code injection in orval's opt-in @orval/hono generator (all versions before 8.29.0) lets an attacker who controls an OpenAPI document plant an apostrophe in a static path segment and break out of the single-quoted route literal, injecting arbitrary JavaScript that runs whenever the generated TypeScript module is imported or built. This is a build-time supply-chain style flaw rather than a runtime flaw in a network service: the affected party must run orval code generation against an untrusted spec and then import the generated output, and the CVSS v4.0 score of 9.3 reflects high confidentiality, integrity and availability impact on the build/developer environment. Exploitation is not confirmed in the wild (no CISA KEV entry) and no public exploit code was identified at time of analysis, though the upstream patch and the exact vulnerable code path are publicly documented.
Code generation in orval before 8.29.0 writes the raw OpenAPI operationId into a single-quoted object literal inside generated TanStack Query mutator metadata, so a crafted operationId can break out of the string and inject arbitrary JavaScript that executes when the generated query or mutation hooks are called. Practical exploitation requires a developer or CI pipeline to run orval codegen against an OpenAPI document whose operationId is attacker-controlled and then to execute the generated hooks - a conditional path that hinges on the trust boundary of the ingested spec, even though PR:N appears in the vector; the independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) reflects this required victim interaction, while the headline CVSS 4.0 score of 9.3 (UI:N) overstates how freely the flaw triggers. No public exploit code and no CISA KEV entry were identified at time of analysis, and no EPSS score was provided; a vendor patch is available (orval 8.29.0).
Unauthenticated ANSI/VT100 escape-sequence injection in the Mesop web framework's /__csp__ CSP-reporting endpoint (pip package mesop <= 1.3.3) allows remote attackers to embed terminal control sequences in JSON report fields such as blocked-uri and document-uri, which are passed straight to print() and written to stdout unsanitized. A public proof-of-concept payload is documented in the vendor advisory; when an operator later views the raw application stdout in an ANSI-capable terminal, the injected sequences can clear the screen, move the cursor, hide text, or render forged messages such as a fake 'SECURITY OK - No CSP violations found' banner, corrupting the integrity of operator-facing logs. The assessed risk is low-to-moderate and is purely a log-integrity issue: there is no confidentiality, availability, or server-side integrity impact, the attack requires a human to view rendered logs (UI:R), and logs consumed by JSON aggregators, SIEMs, or other non-rendering pipelines neutralize the sequences. Vendor-released patch: 1.3.4.
Unauthenticated remote attackers can bypass client-certificate trust in Temporal's s2s-proxy 0.1.16 through 0.2.2 by presenting a self-signed certificate and key to a mux or TCP TLS server listener, because the proxy runs Go's RequireAnyClientCert mode whenever skipCAVerification is false and therefore never validates the presented chain against the configured CA. A successful handshake yields a yamux-multiplexed, peer-authenticated channel on which the attacker can call every RPC the proxy's aclPolicy allows, exercising the proxy's own Temporal credentials against the cross-cluster replication API without supplying any trusted certificate, private key, or Temporal credential. No CISA KEV active-exploitation signal is present and no public exploit identified at time of analysis, but the defect carries a 9.3 CVSS 4.0 score and the vendor has published an upstream fix (PR #296 plus associated commits).
Stored cross-site scripting in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows an attacker with adjacent-network positioning to plant script inside stored network acknowledgement data, which then executes in the browsers of authenticated FTM operators and can lead to session hijacking and unauthorised operator-level payment actions. The flaw sits in the NetworkAcknowledgement React component (NetworkAcknowledgement.jsx:42), which renders stored acknowledgement content without adequate output encoding. The vendor rates it 9.3, while the assessed vector is CVSS:3.1/AV:A/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:N, where the requirement that a legitimate operator open the affected view is the practical limiting factor; no public exploit code and no confirmed active exploitation were identified at time of analysis, but the payments context and scope change keep the impact ceiling high.
Unauthenticated remote attackers can mark pending WooCommerce orders as paid without completing payment by abusing the SUMIT Payment Gateway for WooCommerce plugin before version 4.0.0, which accepts payment notifications without validating them against the SUMIT payment provider. The vulnerability is network-reachable with no authentication or user interaction required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, score 5.3) and is confined to falsifying order payment status, i.e. financial fraud rather than site compromise; publicly available exploit code exists, though there is no confirmation of active exploitation (not in CISA KEV). Risk is bounded mainly by the niche adoption of this specific gateway and by the fact that the integrity impact is limited to order state.
Content spoofing in Foxit PDF Editor and Foxit PDF Reader allows remote attackers to alter visible content in incrementally updated PDFs without invalidating an existing digital signature, so the document continues to appear validly signed. Publicly available exploit code exists for this CWE-347 signature verification flaw, but no active exploitation has been confirmed. The attack requires user interaction (opening the document) and is high complexity (AC:H) but unauthenticated (PR:N), yielding high integrity impact without confidentiality or availability loss.
Unauthenticated SQL injection in the WordPress/WooCommerce plugin Product Filter by WBW (versions 3.1.7 and earlier) lets any remote visitor inject SQL through the plugin's public-facing product-filter functionality and read arbitrary data from the site's database, with no login and no victim interaction required. The reporting source (Patchstack) and ENISA EUVD both classify this as a high-severity SQLi, while the assessed vector constrains the impact to confidentiality only (C:H/I:N/A:N) rather than the scope-change-plus-availability model that produces the 9.3 headline score, so the practical effect is large-scale data disclosure rather than remote code execution or denial of service. No public exploit code has been identified and there is no evidence of active exploitation at time of analysis; exploitation depends solely on whether the affected plugin is installed, active, and reachable on a standard WordPress deployment.
Code injection in the Orval OpenAPI client generator (@orval/core before 8.28.0) lets an attacker who controls a multipart schema property name in a supplied OpenAPI document smuggle a `${...}` template-literal expression into the generated client, which then executes as live JavaScript with the privileges of the process that builds or runs that client. The vendor rates this CVSS 4.0 9.3 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H), while our independent assessment scores it CVSS 3.1 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) because exploitation is not reachable over a network service directly - it requires a developer to generate and then execute a client from an attacker-influenced spec, which is meaningful user interaction. This is a build-time/tooling supply-chain flaw: only organizations that feed untrusted, third-party, or externally sourced OpenAPI documents into Orval and then run the generated code are exposed. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV, though a vendor patch and the upstream fix commits are public, so weaponization of the technique is plausible for anyone who reads the advisory.
Code injection in orval before 8.29.0 lets an attacker who controls or influences the OpenAPI specification being processed smuggle executable JavaScript into the generated client: media-type (Content-Type) keys are written into single-quoted string literals without escaping, so punctuation in a crafted key terminates the literal and injects arbitrary statements into the emitted code. The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) makes this an unauthenticated remote code-injection flaw at 9.3, but exploitation in practice is gated by the victim actually running orval over the malicious spec and then invoking the generated fetch operation or mock resolver - our independent assessment therefore applies UI:R (CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), and teams that only generate clients from their own trusted specifications are not realistically exposed. No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has released a fix in orval 8.29.0.
Code injection in the Orval OpenAPI client generator's @orval/effect package (versions 8.14.0 through 8.28.1) lets an attacker who can influence an OpenAPI schema embed arbitrary JavaScript expressions in the generated validation module, which execute at module scope as soon as that generated code is built or imported. The injection point is the schema `default` value, which the effect generator rewrites into a template literal so that `${...}` syntax (or a literal backtick) re-arms interpolation, with numeric constraints such as minimum/maximum/multipleOf similarly emitted as unquoted expressions; exploitation is remote and does not require prior credentials per the vendor vector (PR:N), but it does require the victim to run the generator against an untrusted or third-party spec and then build or import the output, giving injected code the developer's build-time privileges. No public exploit code has been identified at time of analysis and the issue is patched upstream, so real-world urgency is lower than the vendor's CVSS 4.0 score of 9.3 suggests - this is a build-time/developer-tooling flaw rather than a network-facing service exposure (independent assessment: CVSS 3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, reflecting the victim interaction the vendor rating understates).
Server-side Twig template injection in Solspace Freeform 5.0.0 through 5.10.13 for Craft CMS 5.x lets unauthenticated attackers submit Twig expressions through public forms that are evaluated by Freeform's isolated Twig renderer when field values are rendered back into HTML attributes (the vendor fix excludes the value, name, and id attributes from rendering). Confirmed impact is limited to disclosure of PHP/core and Craft bootstrap constants such as PHP_VERSION, PHP_OS, CRAFT_BASE_PATH, and CRAFT_VENDOR_PATH, plus possible form rendering errors from malformed Twig; no access to Craft globals, getenv(), alias(), database or mailer credentials, security/license keys, arbitrary files, or code execution was demonstrated in testing. Publicly available exploit code exists in the form of one-line payloads published in the vendor's GitHub security advisory (e.g. {{ constant('PHP_VERSION') }}@example.com), but there is no evidence of confirmed active exploitation (not listed in CISA KEV); CVSS 5.3 and the advisory's isolated-sandbox findings indicate low severity.
Remote code execution affects LightLLM deployments through version 1.2.0 that run the KV-transfer worker with the non-default '--pd_trans_mode nccl' option, which exposes an unauthenticated RPyC ThreadedServer control channel on the network. An attacker with network reachability can send a malicious pickled object to that channel, triggering unsafe deserialization and executing arbitrary code with the privileges of the LightLLM service account (CVSS 9.3; PR:N/UI:N). The vulnerability is not known to be actively exploited and no public exploit code has been identified at time of analysis, though the non-default configuration limits exposure to deployments that explicitly enable NCCL-based prefill/decode disaggregation.
Missing reCAPTCHA verification in the Paid Membership Subscriptions WordPress plugin before version 3.1.0 lets unauthenticated attackers create user accounts without solving the CAPTCHA the site has enabled, by simply omitting the reCAPTCHA form field from the registration request. Publicly available exploit code exists (documented by WPScan), though there is no confirmed active exploitation per CISA KEV. The impact is a protection-mechanism bypass rather than data exposure or code execution - the assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N - and it only affects sites that run an affected version and have reCAPTCHA enabled on the registration form.
Unauthenticated attackers can forge payment webhook requests to mark arbitrary WooCommerce orders as paid without any money changing hands in the Paymob for WooCommerce WordPress plugin before version 4.1.14. The weakness is confined to one branch of the plugin's payment webhook handling that omits request-signature verification, so no credentials and no user interaction are required - only that the store runs the vulnerable plugin with its webhook endpoint network-reachable. Publicly available exploit code exists, and the assessed CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, 5.3 MEDIUM) reflects a remote, unauthenticated business-logic integrity impact rather than data theft or code execution.
Unauthenticated metadata injection in the Forminator Forms WordPress plugin before 1.57.2.1 allows any visitor who submits a public form to attach arbitrary metadata keys - including keys WordPress reserves for its own use - to the post that submission creates. The issue is confined to forms explicitly configured with Forminator's post-creation feature (forms that collect post content and publish a post per submission); ordinary contact, lead, or newsletter forms that never create posts are not exposed, which keeps real-world reach narrow and impact low (integrity-only). Publicly available exploit code exists per the WPScan reference, exploitation status is not confirmed actively exploited (CISA KEV) and no EPSS value was supplied; the assessed vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N yields a 5.3 base score, consistent with a low-to-moderate priority finding.
Unauthenticated attackers can bypass the per-visitor voting limit and falsify the submitter address recorded for form entries in the Forminator Forms WordPress plugin before 1.57.2.1. The plugin prefers client-supplied forwarding headers such as X-Forwarded-For over the actual connecting address without first confirming the request originated from a trusted proxy, so every attacker-controlled request appears to come from a different, self-chosen IP - breaking both the vote-throttling logic and the integrity of stored submission metadata (rated CVSS 5.3, integrity-only impact, no code execution, data disclosure, or availability loss). Publicly available exploit code exists per the WPScan advisory, making this trivially reproducible; it is not reported as confirmed actively exploited (no CISA KEV entry), and exploitation of the voting bypass requires the site to actually host a Forminator poll.
RabbitMQ brokers that use the OAuth2 plugin can silently fall back to disabled TLS certificate verification when no CA bundle can be located, allowing an attacker already positioned as a network man-in-the-middle to forge the JWKS response and inject arbitrary JWTs that the broker will accept as authentic. The flaw affects RabbitMQ server versions prior to 3.13.15, 4.0.20, 4.1.11, 4.2.6, and 4.3.0, and exploitation requires four conditions to align: the OAuth2 plugin must be in use, no cacertfile may be configured, the host or container's OS CA bundle must be empty or unreadable, and the attacker must hold a MitM position on the path to the identity provider's JWKS endpoint. Unauthenticated remote attackers are the relevant threat actor per the CVSS vector (PR:N), but the precondition stack and the required network position make this a heavily gated authentication-bypass rather than a blanket internet-exploitable critical; no public exploit code and no confirmed active exploitation were identified at time of analysis.
Code injection in the Orval OpenAPI-to-TypeScript client generator (@orval/core) before 8.30.0 lets an attacker who controls the default value of a date or date-time field in an OpenAPI schema splice arbitrary JavaScript into generated factory code, which then executes with the privileges of whatever process consumes the generated client. Exploitation is not remote against a deployed service: it requires the non-default factoryMethods and useDates options to be enabled, a developer running codegen against a spec the attacker can influence, and the resulting factory client being executed, giving an assessed CVSS 3.1 vector of AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (the advisory lists 9.2 under CVSS 4.0). No public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); the vendor has shipped a fix in 8.30.0.
Privilege escalation in Red Hat Ansible Automation Platform 2 (built on the AWX upstream project) lets an authenticated AAP platform administrator escape the container-group sandbox and obtain OpenShift namespace-level access, including the ability to read and exfiltrate namespace secrets. The flaw is reachable over the network (AV:N) with no user interaction (UI:N) and changes scope across the container/namespace boundary (S:C), but it is gated on the highest AAP privilege tier (PR:H), so it is an insider or compromised-admin scenario rather than an unauthenticated attack; only deployments that use container groups backed by OpenShift/Kubernetes are exposed. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV); no vendor-released patch has been identified at time of analysis, so mitigation depends on restricting the vulnerable field or the administrators who can reach it.
TLS client-authentication bypass in the RabbitMQ trust-store plugin lets a remote unauthenticated attacker whose forged self-signed certificate carries the issuer DN and serial number of any whitelisted certificate pass mutual-TLS authentication. Only deployments that have the rabbitmq_trust_store plugin enabled and wired in as the TLS verify_fun for a client-certificate listener are affected, and an attacker must first learn or guess at least one whitelisted certificate's {Issuer, Serial} pair, which is non-secret and is exposed by the plugin's list command, logs, or any copy of the certificate. All RabbitMQ server releases prior to 3.13.15, 4.0.20, 4.1.11, 4.2.6, and 4.3.0 are vulnerable; vendor-released patches exist in those versions, and no public exploit identified at time of analysis.
FileMaker Server deployments that expose the Web Publishing Engine can be driven into serving the XML Web Publishing interface even when an administrator has explicitly disabled the Custom Web Publishing with XML option, because a request-supplied extended privilege header is trusted without validating it against the configured publishing state. The bypass carries a CVSS 3.1 base score of 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), so unauthenticated remote attackers reach high confidentiality and integrity impact with no user interaction, but only against servers where the Web Publishing Engine is actually deployed and network-reachable; installations that do not run Web Publishing are unaffected. No public exploit code and no confirmed active exploitation have been identified at time of analysis (EPSS 0.15%, 3rd percentile; CISA SSVC exploitation: none), and Claris remediated the issue in FileMaker Server 26.0.3.
Server-side thumbnail generation in FileMaker Server for Linux can be forced to over-read process memory when an attacker uploads a specially crafted image into a container field reachable through FileMaker WebDirect, leaking contents of the server's process memory and potentially crashing the worker process. Only the Linux server variant is affected; exploitation requires WebDirect to be enabled and a hosted solution that exposes a writable container field, which in most deployments implies a WebDirect guest or low-privilege authenticated session (the assessed vector is PR:L, while NVD's published vector claims PR:N - a discrepancy worth noting when scoring). No public exploit code has been identified at time of analysis, the issue is not in CISA KEV, and EPSS is a low 0.14% (3rd percentile); Claris has released a fix in FileMaker Server 26.0.3, so this is a genuine but not urgent priority - patch on a normal cycle rather than under emergency change.
HTTP/2 request smuggling in Apache Tomcat can mix up request headers between concurrent streams, allowing unauthenticated remote attackers to potentially read or alter other users' request data when the connector has HTTP/2 explicitly enabled. The flaw is a regression from the fix for CVE-2026-41293 and affects only Tomcat 11.0.22 through 11.0.25, 10.1.55 through 10.1.59, and 9.0.118 through 9.0.121; exploitation is rated high complexity (AC:H) with limited confidentiality and integrity impact (C:L/I:L). No public exploit code has been identified at time of analysis, and the independent assessment rates this as a moderate-priority, genuine protocol-layer flaw rather than a critical emergency.
Unauthenticated remote code execution in the YAHMAN Add-ons WordPress plugin affects all versions before 0.9.31 when the plugin's remote-file caching feature is explicitly enabled. The plugin stores remotely fetched files in a publicly accessible cache directory without validating their type, so an attacker can plant arbitrary PHP content there and have the web server execute it, yielding code execution with full confidentiality, integrity, and availability impact (CVSS 9.0, CRITICAL; AV:N/AC:H/PR:N/UI:N). Exploitation is unauthenticated and requires no user interaction, but it is gated by the non-default cache feature and rated high complexity (AC:H), and no public exploit code was identified at time of analysis. There is no confirmed active exploitation (no CISA KEV listing).
Identity-assertion confusion in the WP OAuth Server (Login with WordPress) plugin before 6.4.0 allows a user holding a Subscriber-level account or above to obtain a validly signed OpenID Connect identity assertion belonging to another user - including an administrator - and use it to authenticate as that victim at any relying application that trusts the WordPress site as an SSO identity provider. The plugin fails to bind the assertion it issues to the authorization grant being exchanged, instead returning the assertion of whichever user authenticated most recently, so exploitation depends on a race/interaction window (assessed vector AC:H, UI:R) in which the targeted higher-privileged user is the most recently authenticated identity. No public exploit code was identified at time of analysis, and there is no CISA KEV entry indicating active exploitation.
Unauthenticated OS command injection in Changing CGServiSign enables a remote attacker to run arbitrary operating-system commands on a victim's machine when that victim is lured into visiting a malicious web page while CGServiSign's local service interface is running. The attacker needs no credentials and no access to the host (CVSS 4.0 8.6, PR:N, AC:L), but exploitation depends on user interaction (UI:A) plus the presence of this specific Taiwanese e-signature client with its local listener active, which meaningfully narrows the realistic target set. No public exploit code and no confirmed active exploitation were identified at time of analysis, and because the CPE is a wildcard over all versions, every deployment must be considered affected until a fixed build is published.