Concurrent transcript writes and hourly retention cleanup in the VoiceSentinel Processor's opt-in report buffer (versions 2.2.1 through 3.3.0) can lose, duplicate or corrupt transcript records and silently defeat retention pruning, so the buffer stops shrinking and grows until the processor host's disk fills and the machine or co-located services crash. The flaw is a check-then-act race: cleanup reads and rewrites transcripts.jsonl in place while appends land from a separate thread, and multiple _processing_worker tasks make the collision reachable during normal operation, especially with processing.worker_count of 2 or more or a shared public-pool deployment using one server_key. Exploitation is gated behind report_buffer.enabled being set to true (off by default), the outcome is timing- and load-dependent, and no public exploit code or active exploitation was identified at time of analysis; the vendor-released patch is 3.3.1.
OpenLiteSpeed through 1.9.4 allows unauthenticated remote attackers to bypass virtual-host client-certificate (mTLS) enforcement on HTTP/3/QUIC listeners when one instance hosts both an mTLS-protected virtual host and a non-mTLS virtual host. QuicStream inherits a verifyContext() implementation that always returns true, so a crafted QUIC request can present the non-mTLS host's SNI alongside a protected Host header and reach content that should require a client certificate. The CVSS 4.0 score is 8.2 with confidentiality-only impact, the priority label is this_week, no CISA KEV entry is provided, and a public research write-up is referenced but working exploit code is not confirmed.
Unauthenticated path traversal in n8n's Databricks node (2.14.0 through 2.46.3) lets an attacker who can feed a webhook, chat, or form field into a workflow's spaceId, indexName, or filePath parameter redirect an otherwise authenticated Databricks API call to another endpoint and read secrets with the workflow's stored credential. Exploitation requires that expression binding and a valid stored Databricks credential, and reach stays within what that credential is authorized to access; the CVSS 4.0 score is 8.2 (High) with confidentiality-only impact. No CISA KEV entry and no public exploit identified at time of analysis.
Unauthenticated webhook forgery in Juspay Hyperswitch before 1.128.0 allows an attacker who knows a merchant_id and the matching Worldpay orderCode to POST unsigned XML into the worldpayxml webhook endpoint and drive payment state transitions - most damagingly a lastEvent value of SETTLED that marks an unpaid order as charged, with refund, dispute and payout events reachable by the same path. Only deployments that have the Worldpayxml connector enabled are exposed, and the connector's verify_webhook_source returned true unconditionally, so no signature check or mTLS stood between the request and the state machine. No CISA KEV entry has been recorded for this issue and there is no confirmation of active exploitation; a public research writeup describing the unsigned-webhook technique exists but is not verified as working exploit code, and the vendor has released fixes in v1.128.0 and 2026.10.01.0.
Unauthenticated attackers who hold a merchant's publishable key and a valid payout identifier can confirm payouts in Juspay Hyperswitch through 1.128.0 and in builds before 2026.10.19.0, because the confirmation handler does not compare the supplied client_secret with the payout's stored secret. A successful call can overwrite amount, currency, connector and routing fields and trigger unauthorized merchant payouts. The vendor has released a fix, the issue is prioritized for remediation this week rather than as an emergency, and a public research write-up is referenced but working exploit code is not confirmed in the supplied data.
ZTNET through 0.7.18 allows any authenticated low-privilege user to deactivate another account, including an administrator, by submitting a victim's userId together with a deviceId that has no matching UserDevice row to POST /api/auth/user/invalidateUser; the handler then sets isActive=false and the victim's login is refused with account-expired. The root cause is a missing authorization check (CWE-862) in a Next.js API route, so impact is confined to account availability and administrative disruption, with no confidentiality exposure or code execution. A public proof-of-concept procedure confirmed against v0.7.18 is published in the vendor advisory, and the issue is fixed in 0.8.0; no CISA KEV entry is associated with this CVE.
Permanent deletion of product variants in Shopper's admin panel is possible for any authenticated staff member who holds edit_products but not delete_product_variants in versions before 2.10.0, because the Variants Livewire component's single and bulk Filament delete actions perform no server-side authorization check (CWE-285/CWE-862). The parent product edit page gates only on edit_products, so a user can load /shopper/products/{id}/edit, obtain the signed component state, and invoke callTableAction('delete', ...) or callTableBulkAction('delete', ...) against the Livewire endpoint; impact is greatest on ProductType::Variant products, where the sellable catalogue and the storefront product pages, cart and checkout can break. Shopper 2.10.0 adds ->authorize('delete_product_variants') to both actions; a public proof-of-concept test is referenced in the advisory but is not verified as working exploit code, and no CISA KEV entry or confirmed active exploitation is reported.
XML signature wrapping in LightSAML (4.x before 4.7.1 and 5.x before 5.0.1) lets an attacker who already holds one genuinely IdP-signed SAML assertion redirect signature validation to a buried copy of that genuine assertion while LightSAML consumes attacker-authored claims from a forged direct-child assertion, yielding authentication bypass and privilege escalation up to full impersonation of arbitrary NameID, Conditions and role attributes. The flaw requires only a low-privilege position (PR:L) - a captured earlier login response or the attacker's own legitimate assertion - and works even when the Service Provider enforces requireSignature=true, since the copied genuine ds:Signature still validates. Fixed in 4.7.1 and 5.0.1; the vendor advisory and a working PoC script are public, and no confirmed active exploitation (CISA KEV) or EPSS signal was provided at time of analysis.
Arbitrary file deletion in AdminNeo's SQLite driver allows an authenticated SQLite-mode user to remove any file writable by the PHP process by submitting a non-database path in the database-list drop parameter (db[]). Versions before 5.5.1 are affected: create and rename operations are guarded by the .db/.sdb/.sqlite extension check, but the drop path passes submitted values straight to unlink(). Exploitation requires an authenticated AdminNeo session in SQLite mode plus a live CSRF token, and impact is confined to files the PHP process can delete; the GitHub advisory publishes reproduction steps that were validated against a Docker/Nginx deployment. This is a genuine but conditional priority rather than a drop-everything emergency, and the fix is only complete by updating to 5.5.1.
Arbitrary file upload in the Avada theme for WordPress and WooCommerce, versions up to and including 7.16.2, can lead to remote code execution because convert_palette_images_to_truecolor() processes uploaded files without sufficient file type validation. The issue has a CVSS score of 8.1 with AC:H, meaning an additional attacker-uncontrolled or configuration-dependent precondition must hold; the sources do not describe that trigger, so the prerequisite is unverified. No public exploit identified at time of analysis and no KEV status is present in the supplied data; the vendor has published a 7.16.4 security update, and vuln.today assigns this_week priority - a credible priority but not an all-hands emergency.
Stored cross-site scripting in myTinyWMS allows any authenticated user who can create or edit products (Artikel) or categories to persist JavaScript in the `name` field, which then executes in the browser of every worker or administrator who opens the affected product sheet, category listing or dashboard. The value is written to the database without back-end sanitization and rendered back through unescaped Blade output in dynamic table cells, so a single saved entry becomes a cross-user execution vector that can support session theft and administrative takeover when the victim holds higher privileges. Exploitation requires an authenticated foothold with product/category write permission and a victim who loads an affected view (UI:R), which keeps this at CVSS 8.1 rather than an unauthenticated compromise; the issue is fixed in version 1.6.4, and a working PoC payload with step-by-step reproduction is published in the vendor's GitHub security advisory.
The embedded browser in JetBrains desktop IDEs - IntelliJ IDEA, PyCharm, PhpStorm, RubyMine, WebStorm, GoLand, Rider, CLion, DataGrip, RustRover and DataSpell - continues to trust revoked intermediate certificates, so an attacker holding a man-in-the-middle position on an HTTPS connection opened from that browser can present a chain anchored in a revoked eMudhra intermediate and have it accepted, exposing or altering data the user believes is protected by TLS. Reachability is narrow: the victim must actually load an HTTPS resource in the embedded browser, the attacker must be able to intercept that specific TLS session, and a revoked-but-previously-issued eMudhra intermediate must be available, so ordinary coding activity that never touches the embedded browser is not affected. No public exploit identified at time of analysis, exploitation has not been confirmed, and the issue is prioritized for remediation this week rather than as an emergency; JetBrains has published fixed builds for every affected product line.
Arbitrary command execution on hosts running the @zuke/core MCP server in registry mode is possible because command-form registry descriptors were exempted from the ZUKE_REGISTRY_LAUNCH_HOSTS authorization applied to remote module descriptors. Affected are @zuke/core versions prior to 1.51.0 where an operator runs 'zuke mcp --registry --allow-run' against a registry writable by another party (a hosted HTTP registry sharing one token, or a shared .zuke/builds directory) and a run-capable caller invokes the affected tool; the registry writer then chooses the program and arguments executed with the operator's environment and workspace access. The vendor addressed it in 1.51.0, and no public exploit code has been identified at time of analysis. The local default registry populated only through 'zuke register' is not affected because that command writes module-form descriptors.
Improper input validation in Dell OpenManage Enterprise versions prior to 4.8.0 allows an attacker who holds a low-privileged account and sits on an adjacent network to the appliance console to achieve code execution with high confidentiality and integrity impact. The CVSS vector (AV:A/AC:L/PR:L/UI:N) means the attacker must already be on the same management segment and authenticated at a low privilege level, but needs no user interaction and faces low attack complexity once those prerequisites are met. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, but Dell has released a fixed build (4.8.0 and later), so the practical risk is concentrated in unpatched management VLANs that permit low-privileged logins.
Out-of-bounds reads in libriscv's ELF parser, affecting versions through 1.17, let a crafted RISC-V ELF crash the host emulator (rvlinux) and, under favourable heap layout, may map out-of-buffer host heap memory into the guest. The flaw sits in section-header handling: sh_offset/sh_size for .text and .symtab are trusted and used to index the binary buffer without a range check, bypassing the PT_LOAD validation performed during loading. The GitHub advisory publishes a PoC script that overwrites the .text/.symtab offsets with 0x7FFFFFFFF0000000 and reproduces a host SIGSEGV; host memory disclosure is described as possible through grooming or integer overflow rather than demonstrated. Assessed CVSS is 7.9 (AV:L/AC:L/PR:N/UI:N/S:C/C:L/I:N/A:H) - no privileges required on the CVSS vector, but the attack requires getting a binary into the emulator, and there is no KEV listing or confirmed in-the-wild exploitation.
Cluster identity spoofing in SUSE Rancher Fleet's registration flow allows an actor who already holds a valid registration token for a Fleet workspace to bind a crafted registration request to a different managed cluster in that same workspace, simply by claiming that cluster's client identifier. The actor gains credentials scoped to the victim cluster's Fleet management namespace, exposing Secrets and ConfigMaps synced there, permitting limited modification of bundle deployment and cluster status data, and disrupting Fleet's management of the cluster because the legitimate agent's registration and credentials are replaced. Exploitation requires a workspace registration token plus knowledge of a stable, non-secret client identifier, so it is a conditional identity/privilege issue concentrated in shared single-workspace deployments rather than a broadly unauthenticated remote compromise; no public exploit code has been identified at time of analysis, and deployment content itself cannot be altered through this flaw.
ManageEngine SharePoint Manager Plus build 4506 and earlier fails to enforce authorization on its MFA configuration functions, so any authenticated low-privileged user can read or change MFA settings, enable or disable MFA application-wide, enumerate MFA-enrolled users, and delete MFA enrollments. This can weaken authentication protections or lock legitimate users out of the application; the vendor fixed the issue in build 4507. It is a moderate-priority issue (vuln.today Decision label: this_week) rather than an emergency, and no public exploit was identified at time of analysis.
Local privilege escalation in Pi-hole Core 6.4.2 through 6.4.3 lets code running as the unprivileged 'pihole' service account abuse the root-run updatechecker cron to truncate, create, or expose arbitrary root-owned files - including /etc/shadow, sudoers or SSH private keys - because the script rewrites /etc/pihole/versions with truncate -s 0 and chmod 644 while following symbolic links in a directory that account owns. The truncate and create primitives are deterministic, while the non-destructive disclosure variant (chmod 644 landing on the real target while truncate hits a decoy) is a fork/exec race the reporter states is won reliably. Access is local and gated by prior code execution as the specific pihole account, obtained via a compromised pihole account or the separately reported config-to-exec bugs, and no Linux capability is required. A public proof-of-concept is published in the upstream advisory; it has not been independently verified as working exploit code and no confirmed in-the-wild exploitation is reported.
Local privilege escalation in Pi-hole (versions through 6.4.3, fixed in 6.5) lets an attacker who already holds code execution as the pihole service account gain root. The account owns /run/pihole-FTL.pid, and the getFTLPID() content check only rejects values whose first character is a non-digit, so a payload such as '1+a[$(...)]' survives and is later evaluated arithmetically by a root-run pihole subcommand (reloaddns, updateGravity, repair, debug and others), executing the embedded command substitution as root. This is a bypass of the content-validation half of the CVE-2026-41489 fix; the vulnerability requires a prior pihole-user foothold and an administrator subsequently running a need_root subcommand, and the advisory includes a proof-of-concept verified end-to-end in the official container. No KEV listing or confirmed active exploitation is reported, and the vendor classifies this as a prioritize-this-week issue rather than an emergency.
Malformed H.266/VVC media processed by GStreamer's gst-plugins-bad parser can trigger an integer overflow in profile, tier, and level parsing that overflows a stack buffer, crashing the application and potentially allowing code execution in its context. The flaw is rated CVSS 7.8 High (AV:L/AC:L/PR:N/UI:R) and affects Red Hat Enterprise Linux 7 through 10 deployments that ship the vulnerable plugin; a victim must open the crafted media, so it is not remotely triggerable without user action. No CISA KEV entry or public exploit is identified in the available data, and an upstream fix is referenced in a GStreamer merge request.
Arbitrary code execution on Windows in draw.io Desktop 31.4.5 and earlier stems from the Electron shell launching `powershell` and `attrib` by bare executable name, letting Windows resolve a same-named file from the diagram's own folder instead of System32. Exploitation requires the victim to extract an attacker-supplied archive and cold-open its legitimate `.drawio` file from that directory (the app must not already be running), with the powershell path firing when Local Fonts are enabled and the attrib path firing when draft or backup attributes are updated. The advisory publishes manual reproduction steps, so a public PoC reference exists; it is not verified as working exploit code, and there is no KEV entry or active-exploitation signal. Version 31.5.2 fixes the issue by invoking system binaries via absolute System32 paths, switching to `execFile`, and setting `NoDefaultCurrentDirectoryInExePath`; CVSS is 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H).
Stack-based buffer overflow in GIMP's PSD plug-in image-resource header loader lets a crafted PSD file crash GIMP and potentially execute arbitrary code with the privileges of the user opening the file. The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R) confirms local access and user interaction are required, with no privileges needed, so this is not remote unauthenticated exploitation. No public exploit identified at time of analysis; the 7.8 HIGH score reflects high confidentiality, integrity, and availability impact rather than ease of exploitation.
Privilege escalation in Dell OpenManage Enterprise versions prior to 4.8.0 is a genuine but not emergency-level priority: a low-privileged attacker who already has local access and an authenticated account on the OME host can raise their privileges to high confidentiality, integrity, and availability impact. The flaw is rated CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and requires local access plus a pre-existing low-privileged account, not remote or unauthenticated access. No public exploit identified at time of analysis, and the vendor has released a fix in version 4.8.0.
Authenticated users of pgAdmin 4 in server (multi-user web) mode can achieve arbitrary code execution as the operating-system account running pgAdmin by uploading an executable into a shared-storage directory and then pointing their own utility binary-path preference at it. The flaw affects releases before 9.19: the preference validator refused paths under the per-user STORAGE_DIR but never checked the SHARED_STORAGE directories that ordinary users can write to, so pg_dump, pg_restore, pg_dumpall or psql were launched from an attacker-controlled file. Practical exploitation is gated: the attacker needs a valid pgAdmin account and at least one non-restricted shared storage directory, and it is decisive on Windows server mode, where a file with an executable name runs, whereas on POSIX files created through pgAdmin are not executable - no public exploit was identified at time of analysis, and the CVSS 4.0 base of 7.7 (assessed as CVSS 3.1 AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects those prerequisites rather than a network-wide, unauthenticated attack.
Cross-site request forgery in phpMyAdmin through 5.2.3 allows a remote, unauthenticated attacker (CVSS PR:N) to bypass CSRF token validation on non-AJAX POST requests and have arbitrary SQL executed with the database privileges of a logged-in victim. The attacker must lure an authenticated phpMyAdmin user into submitting a cross-site POST carrying a sql_query parameter to /sql or /database/sql, and the instance must be running http or config authentication - the prerequisite configuration plus mandatory victim interaction (UI:P) is what gates the otherwise high-impact confidentiality, integrity and availability ratings. Exploitation status: no CISA KEV entry and no confirmed public exploit code at time of analysis, though a public research write-up of the flaw exists; the issue carries a this_week priority and the underlying bypass is fixed upstream.
Encoded passwords held by Płatnik, the Polish Social Insurance Institution (ZUS) client for submitting declarations and insurance documents, can be reversed back to plaintext because the software protects them with a weak, reversible encoding scheme rather than a proper one-way password hash (CWE-261). Płatnik installations up to and including version 10.02.002 are affected per the EUVD version range, and the attacker must first obtain the encoded credential - for example from a local configuration file or database, or by intercepting it in transit - before decoding it, so this flaw does not by itself provide initial access. The independent assessment maps the impact to confidentiality loss only (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), which is materially narrower than the supplied CVSS 4.0 base score of 7.7 (AV:A/AC:H/AT:N/PR:N/UI:N with high confidentiality, integrity and availability impact). No public exploit code has been identified at time of analysis, and ZUS fixed the issue in version 10.02.002 (metric 242).
PHP object injection in the Enable Media Replace WordPress plugin (versions 4.1.4 through 4.2.3) lets unauthenticated users plant a serialized object in stored metadata that is deserialized when a user with upload access runs the plugin's replace-media-and-update-links routine, yielding object injection and local file inclusion of existing PHP/HTML files and potential escalation to remote code execution when an attacker-influenced PHP or HTML file is already present on the server. The flaw is a regression of CVE-2023-4643 (fixed in 4.1.3, reintroduced in 4.1.4); a vendor patch is available in 4.2.3. EPSS is 0.82% (57th percentile), SSVC records Exploitation: none and Automatable: no, and no public exploit has been identified at time of analysis.
WebAuthn-based two-factor authentication can be bypassed in phpMyAdmin through 5.2.3, letting an attacker who already holds a victim's valid MySQL username and password complete login to the database interface without ever satisfying the second factor. The defect is in CustomServer::parseAndValidateAssertionResponse(), which checks the challenge, origin and rpIdHash of a submitted webauthn_request_response but never verifies the assertion signature against the stored public key, so a forged response with matching metadata is accepted. Only accounts that have opted into WebAuthn/FIDO2 as their phpMyAdmin second factor are affected, and the attacker must be authenticated with first-factor credentials (PR:L) and able to reach the phpMyAdmin interface; no public exploit code is confirmed at time of analysis, though a public research writeup of the flaw exists and priority is rated this_week.
ArcadeDB versions up to and including 26.10.1 keep already-open Postgres, Bolt, MongoDB and Redis wire-protocol connections fully functional after an administrator deletes the user, removes the user's database grant, or rotates the password and narrows the group, so a revoked account can continue reading and writing data for as long as that connection stays open. The exposure is limited to connections opened before the revocation (new logins with the same credentials are refused and the HTTP API returns 403 immediately), and an attacker must already be an authenticated ArcadeDB user with a live wire connection, matching the assessed attack vector of PR:L; it is fixed in 26.10.2. No exploitation in the wild is confirmed by CISA KEV, but a public proof-of-concept description exists in the vendor advisory, and it is not verified as working exploit code; the trigger and prerequisites make this a targeted, moderate-priority risk rather than a mass-exploitation emergency.
Remote denial of service in the Aedes MQTT broker through version 1.1.0 lets any client able to open an MQTT session crash the broker process with a single over-deep PUBLISH or SUBSCRIBE topic, or by registering a Will message with such a topic that fires on ungraceful disconnect. The crash comes from a synchronous 'too many words' throw inside the qlobber topic matcher that Aedes does not catch, so it reaches the Node.js event loop and terminates the process, disconnecting every connected client and blocking reconnection until restart. The vendor advisory includes a public proof-of-concept script that reliably kills the official moscajs/aedes Docker image on the first packet; the fix ships in 1.1.1 as a topic-level guard defaulting to 100 levels.
Uncontrolled memory allocation in ag-psd's readPsd() lets a remote attacker crash any Node service that parses untrusted Photoshop files: the reader sizes off-heap typed-array buffers from attacker-declared header geometry (width, height, channels, depth and per-layer rectangles) before validating those declarations against the bytes actually present, so a 52-byte PSD can commit roughly 3.17 GB of peak RSS in about 0.45 seconds before a RangeError is raised. All npm releases up to and including 30.2.0 are affected, CVSS 3.1 scores this 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CWE-789), and no authentication, interaction or special configuration is needed - only exposure to attacker-supplied PSD input with default read options. The flaw is not listed in CISA KEV, but the vendor advisory publishes a working 52-byte proof-of-concept input (sha256 a1146a6f…) together with reproduction steps; this is a real, actionable denial-of-service issue rather than a critical emergency, and remediation should be scheduled this week for any service that accepts user-uploaded PSDs.
Regular-expression denial of service in Ring's nested-params middleware lets unauthenticated remote attackers stall request handling by supplying a crafted parameter name in the query string or request body. Ring 1.15.4 and below are affected, and Ring-Defaults deployments are exposed out of the box because the nested-params middleware is enabled by default; applications that do not install the middleware never reach the vulnerable parsing path. The base 7.5 CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects availability-only impact, and no public exploit has been identified at time of analysis.
Unbounded memory growth in the glib-networking TLS 1.3 client-side session cache allows a malicious or compromised server to exhaust client memory by sending excessive session ticket messages, resulting in denial of service. The issue affects glib-networking as tracked in Red Hat Enterprise Linux 6 through 10 when a client negotiates TLS 1.3 and connects to an attacker-controlled or attacker-influenced endpoint. No public exploit code was identified at time of analysis; an upstream fix is available via glib-networking merge request 288, but a released patched version is not independently confirmed.
Unauthenticated attackers can register an OAuth client with an attacker-controlled redirect URI against the AI Engine WordPress plugin's MCP OAuth 2.1 Dynamic Client Registration endpoint in all versions through 3.8.6, then obtain an administrator-bound MCP access token once an administrator approves the client on the OAuth consent screen - approval that can be obtained via clickjacking because the consent page lacks X-Frame-Options and CSP frame-ancestors. The flaw is CWE-862 missing authorization, caused by the register endpoint being exposed with a permission_callback of __return_true, and it is fixed in 3.8.7. Exploitation requires the opt-in MCP labs module to be active and administrator interaction (UI:R); no public exploit code and no CISA KEV entry are identified in the available data, and this is a high-severity, approval-gated issue rather than a drop-everything emergency.
Path traversal in astro-notion-blog 0.13.0 allows remote attackers to escape the intended directory and read or overwrite files on the server by supplying a crafted URL that the FeaturedImage component uses to resolve an image location. The vulnerability is network-reachable and unauthenticated per the CVSS vector (AV:N/AC:L/PR:N/UI:N), and the independent assessment rates confidentiality and integrity impact as high while availability is unaffected. No public exploit is confirmed as working, though a public PoC reference exists (a GitHub repository referencing the CVE); EPSS is low at 0.24% (16th percentile) and there is no CISA KEV listing, so the priority label is this_week rather than an emergency.
Authentication bypass in the WordPress Security Plugin, Firewall & Malware Scanner with Auto Removal (versions before 2.191) allows anyone holding a user's current authenticator-app code to log in as that user, including an administrator, without supplying the account password. Exploitation is conditional: the site must run an affected version and the target account must use authenticator-app (TOTP) two-factor authentication, and the attacker must obtain a valid, time-limited code. No public exploit identified at time of analysis; SSVC lists exploitation as none, EPSS is 0.13% (3rd percentile), and the vendor has released version 2.191 as the fix.
Remote denial of service in ESPAsyncWebServer (all versions prior to 3.11.2, i.e. up to and including 3.11.1) lets an unauthenticated remote attacker reboot an affected ESP32 device by sending a single malformed multipart/form-data request to a route that has a non-trivial body handler, such as a file-upload or web-OTA endpoint. The multipart parser frees and NULLs the file-item buffer the instant it matches the closing '--<boundary>' but leaves the file flag set, so when the next byte is neither the final '--' nor a clean CRLF the rewind logic writes through the NULL pointer, triggering a StoreProhibited exception, panic and device reboot. The flaw is fixed in 3.11.2; there is no CISA KEV entry and no confirmed working exploit code, although the vendor advisory publishes a public curl reproducer that is not verified as weaponized exploit code.
AdminNeo's unauthenticated `?script=version` endpoint accepts POST data with no origin, CSRF or parameter-type validation, so a remote client can submit `version[]=...` and have PHP turn the expected string into an array. From 4.6.2 up to but not including 5.5.0, that array is serialized into the shared `adminneo.version` cache and later fed to `cookie()` and `rawurlencode()`, which throws a `TypeError` and returns HTTP 500 to every user of the instance. No credentials or user interaction are required, but exploitation depends on the web server being able to write the cache file and on version verification being enabled; the outage self-clears after the cache's 24-hour lifetime or immediately when the poisoned file is deleted. No confirmed public exploit code or active exploitation is identified at time of analysis, though the advisory does publish step-by-step reproduction commands.
Unauthenticated broken access control in WP REST Cache 2026.3.1 and earlier lets remote attackers read data from affected WordPress sites without logging in, because a plugin-exposed REST function lacks an authorization check (CWE-862). The assessed impact is confidentiality-only (CVSS 7.5, PR:N/UI:N), and exploitation requires the plugin to be installed at an affected version; the exact endpoint and any configuration prerequisite are not described in the available sources. No public exploit was identified at time of analysis, and the priority is this_week rather than emergency.
Unauthenticated sensitive data exposure in the WordPress plugin Flexible Chat 1.1.0 and earlier allows network-reachable attackers to retrieve information the plugin should not expose, with a CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N). The affected footprint is limited to WordPress sites running the wpdesk plugin at or below version 1.1.0; the available sources do not specify the endpoint, parameter, or exact data returned, and no public exploit was identified at time of analysis. The priority signals are modest and internally consistent, so this should not be treated as an emergency despite the High base score.
Broken access control in the Husky Products Filter for WooCommerce plugin (realmag777) at version 1.4.6 and earlier allows remote, unauthenticated attackers to reach functionality that performs no authorization check, resulting in high-impact exposure of confidential data while integrity and availability remain unaffected. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, base 7.5) shows that no credentials or user interaction are required, and the CWE-862 classification confirms the root cause is a missing authorization check rather than a memory-safety or injection defect; the available sources do not identify the specific endpoint, action or feature that lacks the check. There is no CISA KEV listing and no public exploit identified at time of analysis, and the vuln.today priority decision is 'this_week'; no EPSS score was supplied with the intelligence.
WP EasyPay 4.5.4 and earlier exposes an unauthenticated path traversal that can allow remote attackers to read files from the WordPress host, with confidentiality as the only impacted property and no integrity or availability effect. The CVSS 7.5 vector confirms a network-reachable, no-authentication issue requiring no user interaction. No public exploit code or confirmed active exploitation is identified in the supplied intelligence.
Remote code execution in the WordPress plugin NextGEN Gallery, affecting all versions up to and including 4.4.1, requires an authenticated attacker holding a custom-level role or above who is also the stored author of at least one existing NextGEN gallery - gallery ownership is the only authorization check standing between that account and the vulnerable upload path. Abuse of the Lightroom gallery_edit endpoint lets that author mass-assign the gallery path and upload a file into a registered template directory, which the legacy_render function then executes. The attack is gated rather than open: it is not unauthenticated and it is not exploitable on default configurations that do not hand untrusted users custom+ roles or gallery authorship, which is why CVSS rates attack complexity high despite the full confidentiality, integrity and availability impact; no public exploit was identified at time of analysis and there is no CISA KEV confirmation of active exploitation.
Unauthenticated attackers can delete other users' saved drafts and seize their draft identifiers by abusing the 'previous_draft_id' parameter in the Forminator Forms WordPress plugin through version 1.57.3.1, letting them overwrite a victim's draft with attacker-controlled submission content. The nonce that nominally guards the request provides no barrier because any visitor can obtain it by loading a public form page; the real limiting factor is that the attacker must already know the victim's draft_id, which the advisory says may be harvested from a shared 'continue later' resume link, so this is not blind or arbitrary exploitation against every installation. No CISA KEV entry or confirmed public exploit code is available at time of analysis, though the issue is prioritized this_week and affects integrity only, with no confidentiality or availability impact under the assessed vector.
Unauthenticated attackers can read every WooCommerce customer's billing data through the Email Templates Customizer and Designer plugin (all versions up to and including 1.5.14) because its preview handler never checks whether the requester is authorized. Two unauthenticated requests suffice: one harvests a reusable nonce from the 302 Location header of an unguarded admin_init handler, and the second passes that nonce with an arbitrary order ID to the preview_order endpoint, returning billing name, address, phone and email; sites with many stored orders expose proportionally more PII. The issue is rated CVSS 7.5 (AV:N/AC:L/PR:N/UI:N/C:H/I:N/A:N, CWE-862) and is a priority for this week; no public exploit code or CISA KEV entry was reported in the available data.
Sensitive information exposure in the Advanced Custom Fields: Extended WordPress plugin (all versions up to and including 0.9.2.7) lets an unauthenticated remote attacker read the WordPress password hash of any user by submitting a {get_user} template tag through a form field that the plugin resolves and stores as a publicly readable term name. The flaw is only reachable on sites where an administrator has deliberately published a page containing an [acfe_form] shortcode with a Term action that maps a field to the term name via a save.name field mapping - a supported but non-default configuration; sites without such a public form are not exposed. Severity is rated 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) with high confidentiality impact only; it is not listed in CISA KEV and no public exploit has been identified at time of analysis, and the vendor has released 0.9.2.8 with the fix.
Zuke's @zuke/core package before 1.51.0 writes rendered reportSummary(...) notes straight into the GitHub Actions job summary file without passing them through the run's secret redactor, so a note built from a resolved secret() value is published in cleartext. Anyone who can view the workflow run can read it - on a public repository that means unauthenticated viewers - and the summary artifact persists on the run until it is deleted. Exposure requires a build running under GitHub Actions that deliberately places secret-derived text in a summary note; builds that never summarize secrets, and runs outside GitHub Actions, are unaffected, and no public exploit has been identified at time of analysis (the issue is a disclosure defect rather than something an attacker triggers remotely).
Unauthenticated attackers can install detection-suppression rules in SOCFortress CoPilot deployments before 0.1.77 because the Velociraptor Sigma exclusion endpoints never actually validate the bearer token they receive: an arbitrary, expired or forged value is decoded into a sentinel string ('Invalid token' / 'Expired signature') that is stored as the rule's creator instead of rejecting the request. A rule created with a null customer_code applies to every tenant, so matching Sigma alerts are silently dropped by process_sigma_alert before an incident is ever created, and any authenticated user down to the lowest-privilege customer_user role can additionally list, read, update, toggle and delete every exclusion because those routes carry no scope or tenant check. Version 0.1.77 fixes both paths. No confirmed active exploitation (not in CISA KEV) is reported, but the vendor advisory publishes a detailed two-step proof-of-concept reference for the unauthenticated create path that has not been independently validated here as working exploit code.
PHP object injection in Chamilo LMS 2.0.0 can escalate to remote code execution: two code paths (career.lib.php line 495 and cron/import_csv.php line 2768) call PHP's native unserialize() on the user_career.extra_data database column without restricting allowed classes, so an attacker who can write crafted serialized data into that column can instantiate arbitrary objects and drive POP gadget chains in the bundled Symfony, Doctrine and Monolog libraries. The prerequisite write primitive is not available in a single request - the advisory names a separate SQL injection, a compromised admin CSV import, or a lower-privilege admin panel - and a usable gadget chain must also be present, which is why the assessed severity is High (7.5) but with AC:H and PR:L and the current priority is 'this week' rather than emergency. No public exploit code and no confirmed active exploitation were identified at time of analysis; vendor-released patch: Chamilo LMS 2.0.1.
Cross-tenant account takeover in ROOST Coop before 1.0.2 stems from the SAML verify callback resolving the authenticated user by email only, without binding that lookup to the organization named in the /saml/login/:orgId/callback path. An attacker who administers any organization on the instance and controls its SAML IdP signing key can post an assertion for a victim's email to a different organization's callback when the target organization has registered the same signing certificate, and receive a session as that victim. The attack is authenticated (PR:H in the vendor vector, since registering a SAML IdP requires organization administrator rights) and is only exploitable in the unusual shared-certificate configuration; there is no KEV listing and no public exploit identified at time of analysis, and the decision signal places remediation in the this-week window.