Unauthenticated attackers who can reach the Murr Elektronik AAS Edge Client (all versions) REST API can read every data set exposed by its GET endpoints and alter Asset Administration Shell submodel data through PATCH requests, because those endpoints were deployed without any authentication (CWE-306). The issue is scored 9.3 under CVSS 4.0 and 9.1 under our CVSS 3.1 assessment (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N), reflecting trivial network-only reachability, no credential requirement, and high confidentiality and integrity impact; availability is not affected in our assessment. No public exploit code and no CISA KEV listing were identified at time of analysis, so actual risk is driven almost entirely by exposure: high where the Edge Client API sits on an untrusted or flat OT network, substantially lower where it is segmented behind firewalls or confined to isolated industrial networks.
Unauthenticated SQL injection in ARMember Premium versions 7.8 and earlier allows remote attackers to execute arbitrary SQL queries against the underlying WordPress database, potentially exposing sensitive information. The flaw requires no authentication (PR:N) or user interaction (UI:N), and its scope change (S:C) indicates the database is a security authority distinct from the web application. No public exploit identified at time of analysis, but the CVSS score of 9.3 reflects the high confidentiality impact.
Unauthenticated SQL injection in the SendPress Newsletters WordPress plugin (all versions up to and including 1.26.1.20) allows a remote attacker who can reach an affected site to inject arbitrary SQL and read data from the site's database - including WordPress user credential hashes, secret keys and plugin/configuration tables - with no login and no user interaction. Our independent assessment recalibrates the reported CVSS 9.3 (vector AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:L) to CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N (7.5): a genuine high-priority issue rather than a CVSS-inflated one, with confidentiality-only impact and unchanged scope. The practical limiting factor is deployment - only sites actively running this plugin at or below the vulnerable version are exposed, and the exact injectable endpoint/parameter is not disclosed - and no public exploit code or confirmed active exploitation (CISA KEV) is identified at time of analysis.
Unauthenticated SQL injection in the WordPress plugin Radius Booking - Booking Calendar for Appointments & Services through 1.0.19 allows remote attackers to read arbitrary database data through crafted input, with the independent assessment limiting confirmed impact to confidentiality (C:H/I:N/A:N). Affected sites are only those with this specific plugin installed and active at a vulnerable version; no authentication, user interaction, or non-default configuration is required. No public exploit or CISA KEV entry is identified at time of analysis, and deployment scope is the primary limiting factor.
Unauthenticated SQL injection in the Porto Theme Functionality WordPress plugin affects versions up to and including 3.9.3, allowing remote attackers to inject arbitrary SQL into the plugin's database queries without any prior authentication (CVSS vector PR:N, no user interaction). Successful exploitation can expose sensitive data stored in the site's WordPress database - the independent assessment rates confidentiality impact as High and integrity impact as Low, while the vendor/feed score of 9.3 assumes scope change and a different impact mix; both agree the issue is trivially network-reachable. There is no CISA KEV listing and no public exploit code identified at time of analysis, so this is a high-severity, easily reachable flaw rather than a confirmed actively exploited campaign, and no fixed plugin version is specified in the supplied advisory data.
Unauthenticated SQL injection in the Weblizar WordPress plugin 'Newsletter Subscription Form - User Subscriptions Form, Capture Email' (versions up to and including 1.5.9) lets an attacker who can reach the plugin's public subscription/capture-email form endpoint inject SQL through user-supplied input. Per the CVSS vector (PR:N/UI:N), no authentication or victim interaction is required, so any site running this plugin with a publicly reachable form is exposed; the primary limit on real-world exposure is simply whether this relatively uncommon plugin is installed. The feed score is 9.3, while our independent assessment scores it 8.1 (scope unchanged, confidentiality high, integrity low, availability none) because the demonstrated impact is primarily database read-out rather than full compromise. No public exploit code and no confirmed active exploitation (no CISA KEV entry) were identified at time of analysis, so this is a high-severity but not yet corroborated-as-exploited issue.
Unauthenticated SQL injection in the WordPress plugin Gmedia Photo Gallery (versions 1.25.1 and earlier) allows remote attackers to inject arbitrary SQL into database queries and read data the application can access, which the assessment rates as high confidentiality impact with no integrity or availability impact. Any WordPress site with the plugin installed and active is potentially exposed because exploitation requires no account, no privileges, and no victim interaction (AV:N/AC:L/PR:N/UI:N); the practical gate is deployment - the site must run an unpatched version and expose the vulnerable endpoint to the network. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, but the reporter's 9.3 score and the zero-prerequisite vector make it a high-priority item for inventory and patching rather than a CVSS-inflated finding.
Unauthenticated information disclosure in the Slider Pro WordPress plugin (versions 0 through 1.0.0) allows any remote visitor to call an AJAX action that performs no capability or authorisation check, returning the titles, excerpts, permalinks and media metadata of non-public posts such as drafts, pending, scheduled, private and trashed items, plus post revisions. The exposure is confined to metadata rather than full post bodies, which keeps the confidentiality impact limited (CVSS 3.1 base 5.3, Medium, AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) with no integrity or availability effect. Publicly available exploit code exists, but CISA's SSVC assessment records no active exploitation and no KEV listing applies.
Order tampering in the Fast Courier WordPress plugin (versions through 5.2.3) lets unauthenticated attackers overwrite the courier status and customer-facing tracking details of any WooCommerce order by supplying the target order's ID to an unprotected REST route. The underlying defect is a missing authorization check (CWE-862) on the plugin's order-fulfillment endpoint, so remote attackers need no credentials and no user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, score 5.3); the practical prerequisite is knowing or enumerating a valid WooCommerce order ID. Publicly available exploit code exists, as documented in the WPScan advisory, but there is no confirmed active exploitation according to available intelligence (no CISA KEV entry; SSVC exploitation: none), and impact is limited to the integrity of courier and tracking fields with no data disclosure, code execution, or availability loss.
Unauthenticated attackers can manipulate order states in the Deema Payment Gateway WordPress plugin (versions through 1.1.2) by exploiting a missing payment verification step in the hosted-checkout return handler, causing orders to be marked as paid without any actual payment. The plugin fails to confirm transaction status or amount with the payment provider, and publicly available exploit code exists. With a CVSS score of 5.3 (MEDIUM), the impact is limited to integrity of order data, with no confidentiality or availability effects.
Unauthenticated attackers can mark unpaid orders as paid or cancel/refund existing orders on WordPress sites running the Deema Payment Gateway plugin through version 1.1.2, because the plugin fails to verify the authenticity of incoming payment provider notifications and ships with that verification disabled by default. The flaw is remotely exploitable without authentication (CVSS 5.3, CWE-287) and affects order integrity only, with no server compromise or data disclosure. Publicly available exploit code exists, but CISA SSVC indicates no observed exploitation; this is a genuine but moderate-priority issue rather than a critical emergency, and it should be patched or mitigated promptly.
Unauthenticated network attackers can reach backend functionality in Arista CV-CUE that is intended only for internal services, giving them access to sensitive location information and the ability to disrupt affected services. The root cause is a missing authentication check (CWE-306) on internal-service endpoints, rated 9.3 under CVSS 4.0 with a vector of AV:N/AC:L/AT:N/PR:N/UI:N and high confidentiality, integrity and availability impact within the vulnerable component; an independent assessment agrees the flaw is remotely reachable and requires no credentials, configuration change or user interaction, but stresses that the real-world exploitability depends on network exposure. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the practical limiting factor is whether the internal endpoints are exposed to untrusted networks or are segmented behind a trusted management network.
Stored cross-site scripting in the Arista CloudVision Fileserver upload API lets an attacker who holds a valid CloudVision account with file-upload privileges persist a malicious payload that executes in another user's browser session. Because the missing input validation allows unsanitized content to be stored and later rendered, a successful hijack of an administrator's web session can yield full account and administrative access, which is why the issue carries a 9.3 CVSS 4.0 base score; the independent assessment concurs (CVSS 3.1 8.0-class impact with S:C). Exploitation is not anonymous - it requires authenticated upload privileges (PR:L) and, critically, active interaction from a victim who must view the stored content (UI:A), so the highest-impact outcome depends on an administrator rendering the payload. No public exploit code or confirmed active exploitation was identified at time of analysis, and the headline 9.3 should be read with that nuance rather than as an unauthenticated remote compromise.
Stored cross-site scripting in Arista networking software (documented in Arista Security Advisory 0192) lets an unauthenticated attacker who can reach the affected interface from an adjacent network plant malicious content that later executes in the browser of an authenticated user who views it. Exploitation requires the one-two punch of adjacent-network reachability (CVSS AV:A) plus a logged-in victim rendering the stored payload (UI:A), so the attacker gains no privileges at injection time but can hijack the victim's authenticated session, read sensitive data, alter system state, or disrupt the service once the payload fires. Arista PSIRT rates this Critical at CVSS 4.0 base 9.3, and there is no public exploit code and no indication of active exploitation (not listed in CISA KEV) at the time of analysis.
The Mooncake Store REST service through version 0.3.13.post1 binds to 0.0.0.0 and enforces no authentication on any route, so any host that can reach the service port can read cached KV data (including user prompts), inject or delete objects via /api/put and /api/remove_all, and mount attacker-described segments via /api/mount - all without credentials or user interaction (CVSS:4.0 9.3; independent assessment: CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Exposure is the shipped default in affected versions, making risk highest where the listener is reachable from a flat internal network or accidentally exposed to the internet; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV). This is a missing-authentication class defect (CWE-306), not a memory-safety or injection bug.
Server-side remote code execution affects Handlebars versions 4.0.0 through releases prior to 4.7.10, where a flaw in the lookupProperty prototype-access check lets a rendered template reach Function.prototype.constructor and obtain the JavaScript Function constructor, executing attacker-supplied code with the server application's privileges. Exploitation is conditional: an unauthenticated remote attacker must be able to render a template whose source they control, the runtime must have allowProtoMethodsByDefault enabled (not the default configuration), and the template context must expose an accessible function value that can be traversed via __proto__. No public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (no CISA KEV listing); vendor-released patch: 4.7.10.
Authentication claim injection in Payload CMS affects versions after 3.0.0 and before 3.90.0, where a collection field configured with the saveToJWT option set to a Payload-reserved claim name (id, collection, email, sid, iat, or exp) can place attacker-influenced values into the authentication token issued at login, allowing spoofing of identity, email, collection, or session claims. Exploitation is gated on a non-default configuration plus attacker control over the aliased field value and a subsequent login, which is why the vendor's CVSS 4.0 score of 9.2 carries Attack Requirements Present (AT:P) and the independent assessment resolves to CVSS:3.1/AV:N/AC:H/PR:L/UI:N (high complexity, authenticated); default installations and collections that only map saveToJWT to non-reserved keys are not reachable. No public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is fixed in version 3.90.0.
PHP code injection in the Smarty templating engine allows remote code execution in applications running Smarty 4.x before 4.5.8 or 5.x before 5.8.5 that render templates through the extends:/multi-component inheritance path with caching enabled. When such a template is compiled, the top-level unifunc never restores its nocache_hash, so the value is null; combined with an empty regex alternative in the cache-split logic, attacker-controlled assigned data containing a forged /*%%SmartyNocache:%%*/ marker is copied verbatim (bypassing PHP-tag neutralization) into the regenerated PHP cache file and executed on the next include. Exploitation is unauthenticated per the vendor CVSS vector (PR:N) but is gated by strict preconditions - inheritance-path templates, active caching, unescaped attacker-controlled output, and a fresh PHP process that reloads the compiled file after the cache entry is evicted (TTL expiry or cache clear) while compiled files persist - making it conditional rather than reliably on-demand; no public exploit code or confirmed in-the-wild exploitation was identified at time of analysis.
Two-factor authentication bypass through brute force affects PLANKA 2.2.0 through 2.2.1: the POST /api/access-tokens/verify-totp endpoint imposes no limit on incorrect TOTP submissions, so an attacker who already holds a user's password can replay the same ten-minute pending token and guess six-digit codes until one is accepted, receiving a full access token. Exploitation is gated on possessing the victim's password (first factor) and the account having TOTP enabled, and the assessed CVSS 3.1 vector is AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N - materially lower real-world risk than the headline 9.1 (CVSS 4.0) score, which assumes PR:N. There is no public exploit identified at time of analysis and no confirmed active exploitation; the vendor fix is an upstream commit that destroys the pending session after repeated failures and adds per-IP and per-identifier rate limiting.
SQL injection in the web-based management interface of HPE Aruba ClearPass Policy Manager allows an authenticated attacker with high-privilege (PR:H) management-interface access to inject SQL into backend queries and run arbitrary database commands, with a vendor-assigned CVSS of 9.1 (AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H). The impact is severe - confidentiality, integrity and availability of the appliance database are all rated high, and the scope change (S:C) indicates the compromise can escape the vulnerable component - but the precondition of valid administrative credentials plus network reachability to the management UI substantially narrows the practical attack surface, and no public exploit code has been identified at time of analysis. No evidence of active exploitation (CISA KEV) is present in the provided intelligence; this is a genuinely high-severity issue that warrants prompt patching but is not an untriaged emergency.
Authorization bypass in the Chromoting (Chrome Remote Desktop) host component of Google Chrome on macOS prior to 155.0.8059.39 lets remote attackers circumvent macOS system access restrictions by sending crafted network traffic to the remoting service; the provided CVSS vector is AV:N/PR:N/UI:N so the flaw is treated as network-reachable and unauthenticated. Exploitation is conditional rather than opportunistic: it requires Chrome Remote Desktop (Chromoting) to be installed, enabled and network-reachable on a macOS host, and Google's Chromium team rated the underlying defect only 'Low' severity, which is why our independent assessment reduces impact to C:L/I:L/A:N with AC:H instead of the vendor's 9.1. No public exploit code or confirmed active exploitation has been identified at time of analysis, and EPSS is low at 0.21% (10th percentile), so this should not be triaged as a 9.1-equivalent emergency even though the vendor score is high.
Incomplete cleanup in the Chromoting (Chrome Remote Desktop) component of Google Chrome on macOS before 155.0.8059.39 lets a remote, unauthenticated attacker bypass system access restrictions using crafted network traffic, per the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N vector. Impact is materially constrained: only macOS hosts on an affected build with Chromoting enabled and reachable are in scope, and the realistic outcome is limited information exposure rather than full compromise, which is consistent with the vendor's 'Low' Chromium severity rating. Risk signals conflict sharply - the supplied CVSS score of 9.1 (C:H/I:N/A:H) and the authoritative assessed vector of C:L/I:N/A:N disagree - and must be reconciled before prioritization; EPSS is negligible at 0.17% (6th percentile), there is no KEV listing, and no public exploit identified at time of analysis. Vendor-released patch: Chrome 155.0.8059.39.
OAuth2 token-endpoint misuse in Gitea 28.0.0 and earlier allows anyone holding a valid, unexpired OAuth2 access token to submit it under the refresh_token grant and receive a brand-new access token plus refresh token, effectively extending access past the credential's original expiry. Exploitation requires a pre-existing valid access token issued for the same OAuth2 application and grant, so this is a persistence/escalation-of-lifetime flaw rather than an entry point for an unauthenticated outsider; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N (NVD rates it 9.1 with PR:N). Multi-source signals conflict: NVD's score and CISA's SSVC rating of total technical impact are severe, while EPSS is only 0.17% (6th percentile) and SSVC lists exploitation as none - no public exploit code has been identified at time of analysis and the issue is not in CISA KEV.
Duplicate-name tree entries pushed to Gitea ≤1.27.3 are stored and served inconsistently: the web diff and file views resolve such a path to the first entry, while `git checkout`, Gitea Actions and generated release archives resolve it to the last, so a contributor can open a pull request that looks benign to reviewers but runs or delivers attacker-controlled content at the same commit. Exploitation requires the ability to push a branch or open a pull request (contributor access, or a public instance allowing registration and fork-based PRs) and is only consequential where a consumer resolves the commit differently - CI auto-running on the PR, a developer checking it out, or a release tarball being built; there is no confirmed active exploitation and no public exploit code identified at time of analysis, with EPSS at 0.16% (4th percentile). Critically, upgrading fixes only new incoming objects - existing repositories are not rescanned, so a malicious tree already stored stays exploitable after the patch.
Authentication bypass in Gitea's built-in SSH server (affected releases up to and including 1.27.3) lets a remote attacker authenticate as another user by presenting a case-variant of that user's registered RSA public key. Three conditions must all hold: the built-in SSH server must be enabled via START_SSH_SERVER = true (non-default on many deployments), the backing database must perform case-insensitive text comparison (the default SQLite qualifies), and the attacker must possess or derive a working RSA private key whose public key differs from the victim's only by letter case, which is cryptographically very hard and is why the effort is assessed as high complexity rather than the low complexity of the published vendor vector. No public exploit code identified at time of analysis; EPSS is 0.16% (4th percentile) and the CISA SSVC assessment records exploitation: none. The flaw is fixed in v28.0.0 by matching keys on their SHA256 fingerprint instead of encoded content.
Man-in-the-middle server impersonation affects Microsoft MsQuic client applications built against the OpenSSL or QuicTLS TLS backend at versions prior to 2.4.20, 2.5.11, and 2.6.1, because the client fails to verify that the server certificate matches the intended target hostname. An attacker who already holds an on-path position can present a mismatched certificate and terminate the QUIC connection as the spoofed server, enabling interception and modification of application data; the CVSS 4.0 vector (9.1) and the independent assessment (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N) agree that the attack is unauthenticated, requires no user interaction, and is gated by the on-path positional prerequisite rather than by any credential. Deployments using the Schannel backend (including default Windows configurations) are not affected, and no public exploit code or confirmed active exploitation was identified at time of analysis.
Authenticated command injection in Microsoft UFO's Mobile MCP server (versions prior to 3.0.9) lets a caller who holds a valid UFO_MCP_API_KEY pass shell metacharacters through the press_key tool's free-form key_code parameter and have them executed as the Android shell user on an already-authorized, connected device. Exploitation is remote and requires adb on the UFO host plus a reachable paired device, so it is not a host OS compromise, nor does it grant Android root - impact is bounded to Android shell-user privileges on the target handset. No public exploit code or confirmed in-the-wild activity has been identified at time of analysis; the vendor has released a fix in version 3.0.9, and although the assigned CVSS is 9.1 (Critical), that score is driven largely by the scope change and network vector while the practical blast radius remains capped.
An out-of-bounds write in Oracle VM VirtualBox before 7.2.8 lets a user with a foothold inside a guest VM corrupt memory in the host-side hypervisor process through the emulated PCNet (Am79C970A) network adapter. The flaw sits in pcnetReceiveNoSync in DevPCNet.cpp, and because the write crosses the guest-to-host boundary it can lead to host memory corruption and potential code execution in the VirtualBox process, though integrity and availability impacts are the primary outcomes. Exposure is materially narrower than the vendor-supplied 9.1 network-vector score implies: the vulnerable code path is only reachable when the VM is explicitly configured with the legacy PCNet NIC rather than VirtualBox's modern Intel PRO/1000 or virtio-net defaults, and the attacker must already have local user-level access in the guest. No public exploit has been identified at time of analysis, SSVC records exploitation as none, and there is no CISA KEV listing.
Command injection in the client software component of HPE Aruba ClearPass Policy Manager allows an attacker to execute arbitrary commands with elevated privileges on an affected host, provided they can get crafted input into the client's processing path. The flaw is rated 8.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H): it is network-reachable, low complexity, and requires no authentication, but exploitation depends on a user or operator of the client interacting with attacker-supplied input (UI:R), which is the principal limiting factor - the appliance/server is not compromised by an unsolicited remote request alone. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; no EPSS score was provided in the source data, so exploitation likelihood should be judged primarily on the user-interaction prerequisite and the elevated-privilege impact if triggered.
Memory corruption in the wired-uplink network endpoints of Arista Wi-Fi access points lets an unauthenticated attacker who already sits on the same Layer-2 segment as the AP's wired uplink crash the sensor service and, under specific preconditions, potentially achieve remote code execution. No authentication or user interaction is required, but the vulnerability is scored adjacent-network (AV:A) with an explicit attack precondition (AT:P in the CVSS 4.0 vector), so the dependable outcome is a denial-of-service crash of the sensor service while full code execution is condition-dependent; no public exploit code has been identified at time of analysis. Because exploitation demands Layer-2 adjacency to the uplink segment, segmentation of management/uplink VLANs is the single most effective exposure reducer.
Prototype pollution in the npm package @stablelib/cbor (versions before 2.0.4) allows an attacker who supplies a CBOR payload to make decoder output inherit attacker-chosen properties, because a map key named "__proto__" is written via bracket assignment and reaches the JavaScript prototype setter instead of creating a normal data property. Applications that pass untrusted CBOR to decode() and then read properties through normal prototype lookup, or merge the decoded object into configuration, authorization or feature-flag state, can act on inherited attacker values - the upstream GHSA includes a working proof-of-concept, so publicly available exploit code exists, but there is no KEV listing and no confirmed active exploitation. Impact is conditional and integrity-only (no confidentiality or availability loss), and the independently assessed CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:H/A:N rates it below the vendor-supplied 8.9 CVSS 4.0 score because exploitation depends on that specific downstream consumption pattern.
Code injection in Microsoft Kiota 0.5.0 through pre-1.35.0 allows attacker-controlled text embedded in an OpenAPI description to break out of the generated Java or PHP documentation comment and execute in the consuming application or build environment once that generated source is compiled and loaded (Java) or loaded (PHP). The flaw is reachable unauthenticated (CVSS:3.1/AV:N/AC:L/PR:N/UI:R) but requires user interaction: a developer or CI pipeline must generate client code from an untrusted or tampered spec and then build or load the output, making this a build-time/supply-chain path rather than an attack on already-deployed runtime services. There is no public exploit identified at time of analysis and the CVE is not listed in CISA KEV; CVSS 3.1 base score is 8.8, and the issue is fixed in 1.35.0.
Command injection in the ClearPass Policy Manager API allows an authenticated remote attacker holding only low-privilege credentials to execute arbitrary commands and escalate to administrative control of the affected appliance, with high impact to confidentiality, integrity, and availability (CVSS 8.8). The vulnerability is network-reachable and requires no user interaction, but it is not exploitable by a fully unauthenticated attacker - valid low-privilege API access is a hard precondition. At time of analysis there is no public exploit identified, and no evidence of active exploitation (no CISA KEV listing); the risk is rated high-priority for organizations running the product but not an emergency absent exploitation signals.
Authenticated path traversal in the ClearPass Policy Manager command line interface allows a low-privileged remote user to escape the intended file path context and execute arbitrary code with elevated privileges on the underlying operating system. The flaw is rated CVSS 3.1 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning it is network-reachable, low complexity, requires only valid low-privilege CLI credentials and no user interaction, and yields full confidentiality, integrity, and availability impact. Exploitation prerequisites are non-trivial: the attacker must already hold valid authenticated access to the ClearPass CLI, so exposure is bounded by how broadly low-privilege appliance accounts are provisioned and by how tightly management-plane access is restricted; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (CISA KEV).
Remote code execution in the ACPT (Premium) WordPress plugin affects all versions up to and including 2.0.66, allowing an authenticated attacker with only subscriber-level access to run arbitrary code on the server. The chain works by abusing a REST API form-creation endpoint that performs no capability check, planting a malicious email_settings payload, and then triggering a form submission so the plugin's unsandboxed Twig environment renders attacker-controlled template expressions during email generation. No user interaction is required and no public exploit code has been identified at time of analysis, though the low authentication bar (subscriber) makes it considerably more dangerous on sites with open registration; exploitation is not confirmed actively exploited (no CISA KEV listing), and the vendor changelog points to a fixed release.
Authenticated remote code execution affects IBM Langflow OSS versions 1.0.0 through 1.12.2, where an incomplete blocklist in the built-in code security scanner can be bypassed to execute arbitrary code on the server. Exploitation requires a valid low-privilege account (CVSS PR:L) and the ability to submit code evaluated by the scanner; unauthenticated attackers are not sufficient. No public exploit code has been identified at time of analysis and there is no CISA KEV listing, though the high CVSS base score of 8.8 and the multi-tenant exposure of typical Langflow deployments make the risk significant where untrusted users can register or be provisioned.
Remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets an authenticated attacker escape the application's code execution sandbox and run arbitrary commands on the host. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N) confirms network reachability and a low-privileged authenticated session as the only precondition, with no user interaction required. No public exploit code has been identified at time of analysis and there is no CISA KEV entry, but the low complexity and high impact make this a genuine prioritization concern for internet-exposed or multi-tenant deployments.
Unauthenticated remote attackers can force-delete arbitrary objects in Mooncake Store master through 0.3.13.post1 by sending forged Remove, RemoveByRegex, RemoveAll, or BatchRemove RPCs to the coro_rpc port with the force flag set, bypassing lease checks. This CWE-306 missing-authentication flaw is availability-scoped (CVSS 3.1: C:N/I:L/A:H) and requires only network reachability to the coro_rpc port, enabling cache loss and request failures. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.
Google Chrome versions prior to 155.0.8059.39 contain a use-after-free in the WebRTC component that a remote, unauthenticated attacker can trigger by convincing a victim to visit a crafted HTML page, resulting in arbitrary code execution within the renderer sandbox (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). Exploitation is not automatable and requires user interaction, and the resulting code execution is confined to Chrome's renderer sandbox per the vendor description, so full host compromise would additionally require chaining a separate sandbox-escape flaw. No public exploit code has been identified at time of analysis, and CISA's SSVC assessment records no known exploitation; Chrome's built-in auto-update is the primary exposure-reduction control, as patched versions 155.0.8059.39 and later are not vulnerable.
Remote code execution in IBM Langflow OSS versions 1.0.0 through 1.12.2 allows an authenticated attacker to run arbitrary operating-system commands by supplying crafted input to a component that fails to neutralize special elements before passing them to an OS command or code-evaluation path (CWE-94). Per the assessed CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), exploitation requires a valid low-privilege authenticated session on the Langflow instance, needs no victim interaction, and yields full confidentiality, integrity, and availability impact on the affected host. No public exploit code was identified at time of analysis, and the issue is not confirmed as actively exploited (CISA KEV); the practical risk is concentrated on network-exposed Langflow servers that use weak, shared, or default credentials, since a compromised or low-privilege account is the only prerequisite.
Broken authentication in the Simple JWT Login WordPress plugin 4.0.0 allows a remote authenticated attacker with subscriber-level privileges to bypass intended JWT authentication controls, resulting in high confidentiality, integrity, and availability impact (CVSS 8.8, CWE-288). The vulnerability is network-exploitable, requires low complexity, and needs no user interaction, but an attacker must first obtain a low-privileged account-often self-registerable when open registration is enabled. No public exploit code or confirmed active exploitation has been identified at time of analysis.
Authenticated remote code execution in IBM Langflow OSS 1.0.0 through 1.12.2 lets any user who can log in to the instance run arbitrary code on the host, because the platform fails to properly constrain attacker-supplied input before it reaches a code-execution path. The flaw carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning low-complexity, network-reachable exploitation that requires only a low-privileged account but yields full confidentiality, integrity, and availability impact - no user interaction and no elevated privileges are needed. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation, but IBM has published a vendor advisory with a fix, so the practical exposure is greatest for organizations that expose Langflow to untrusted networks or provision accounts broadly.
Type confusion in the V8 JavaScript engine of Google Chrome prior to 155.0.8059.39 lets a remote, unauthenticated attacker execute arbitrary code inside the browser's renderer sandbox when a victim loads a crafted HTML page; the CVSS vector is AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, so the sole prerequisite is that the victim renders attacker-controlled content in an unpatched desktop build. No public exploit code or active exploitation was identified at time of analysis, and CISA KEV does not list this CVE. The vendor-released patch is Chrome 155.0.8059.39, and installations already updated past that version are not affected. Because the impact is scoped to the sandbox (S:U) per the description, full host compromise would require chaining a separate sandbox-escape vulnerability.
Authorization bypass in Kibana's Fleet package installation process lets an authenticated user who holds delegated Fleet package-management privileges - but no direct Elasticsearch administrative rights - claim a data stream identifier already in use by another tenant sharing the same deployment. Because Fleet does not verify ownership of that identifier before applying the uploaded package's generated index and ingest-pipeline settings to pre-existing infrastructure, an attacker can redirect a victim tenant's subsequent data through infrastructure they control, achieving unauthorized disclosure and modification of that data and preventing it from reaching its intended destination (CVSS 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Exploitation requires a multi-tenant Kibana deployment with delegated Fleet privileges and valid authenticated access; it is impossible in single-tenant setups, and no public exploit identified at time of analysis.
Arbitrary code execution inside the renderer sandbox is achievable in Google Chrome builds prior to 155.0.8059.39, where a use-after-free in the browser's Media component can be triggered when a victim loads a crafted HTML page. Scoring 8.8 under CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, the bug requires no authentication but does require the user to visit attacker-controlled content, and because the resulting code execution is confined to the renderer sandbox, full host compromise would require chaining a separate sandbox-escape flaw. A vendor patch is available in the Chrome Stable channel update, and no public exploit has been identified at time of analysis - this is a high-priority patching item rather than an emergency.
Remote code execution inside the Chrome renderer sandbox is possible on Chrome builds prior to 155.0.8059.39, where a use-after-free in the WebRTC component can be triggered by a crafted HTML page. The flaw is rated 8.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and assigned Chromium severity High; no authentication or prior privileges are required, but the victim must open or be redirected to the attacker's page (UI:R). Impact is confined to the renderer sandbox - reaching the host OS would require chaining a separate sandbox-escape vulnerability - and no public exploit was identified at time of analysis; the primary exposure window is the short period before Chrome's auto-update moves users to the fixed build.
Use-after-free in Google Chrome's Web Audio implementation affects versions prior to 155.0.8059.39, where a remote attacker can achieve arbitrary code execution inside the browser's renderer sandbox by getting a victim to open a crafted HTML page that exercises the Web Audio API. The flaw carries an assessed CVSS of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), meaning no authentication or non-default configuration is required, but the attack does depend on user interaction (loading the page) and the resulting code execution is confined to the renderer sandbox, so full host compromise would require chaining a separate sandbox escape. Chromium rates the issue High severity, the vendor has published a fix in 155.0.8059.39, and no public exploit code has been identified at time of analysis; there is no CISA KEV confirmation of active exploitation.
Broken access control in the Progress Planner WordPress plugin through version 1.10.0 allows any authenticated user holding the low-privileged Subscriber role (or higher) to reach plugin functionality they are not authorized to invoke, yielding high impact to confidentiality, integrity, and availability at a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is network-reachable, requires no user interaction and no elevated privileges beyond a valid low-privilege session, and is classified as CWE-862 (Missing Authorization); risk is greatest on sites that permit open or self-service registration and materially lower where account creation is locked down. No public exploit code has been identified at time of analysis, and there is no indication of confirmed active exploitation in CISA KEV; the report originates from Patchstack. Authentication requirements are confirmed from the assessed vector, which carries PR:L, so exploitation is authenticated but does not require administrative access.
Subscriber-level privilege escalation in the JobZilla - Job Board WordPress theme through version 2.2 allows an authenticated low-privilege user to elevate their permissions, with high impact to confidentiality, integrity, and availability (CVSS 8.8). The attack is network-reachable, low-complexity, and requires no user interaction; because the CVSS vector includes PR:L, the attacker must be authenticated, and in typical job-board deployments with open self-registration obtaining a Subscriber account is trivial, while sites with registration disabled still require a valid low-privilege credential first. No public exploit identified at time of analysis, so this is an actionable priority for affected sites but not an unauthenticated emergency.
Use-after-free in Google Chrome's Track component before 155.0.8059.39 allows an unauthenticated remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. The CVSS 3.1 base score is 8.8 (High) with UI:R, meaning exploitation requires user interaction but no authentication; successful code execution remains confined to Chrome's renderer sandbox and would require a separate sandbox-escape bug to affect the host OS. No public exploit identified at time of analysis, and SSVC records Exploitation: none; CISA KEV does not list this CVE.