Stored cross-site scripting in the WordPress plugin FV Flowplayer Video Player affects all versions up to and including 7.5.55.7212. An authenticated attacker holding a subscriber-level account or above can submit a profile video whose attribute value is rendered as raw HTML, so script executes in the browser of any user who later views the injected page. Exploitation requires an administrator to have first enabled the non-default 'Allow visitors to upload videos to their profile' (profile_videos_enable_bio) setting; a fixed commit exists upstream, and SSVC records no known exploitation and no public exploit identified at time of analysis.
Stored cross-site scripting in the Meow Gallery WordPress plugin (all versions up to and including 5.5.1) lets an authenticated author-level user inject script through attachment alt text that is emitted into an aria-label attribute. Because WordPress's sanitize_text_field() strips angle-bracketed tags but leaves double quotes intact, an attacker can break out of the aria-label context and add event-handler attributes such as onclick that fire when a visitor views the injected gallery page. The vulnerable sink is only reached when gallery items are rendered as links (a non-empty link_href), and a patch appears in the 5.5.1-to-5.5.2 changeset; no public exploit code or active exploitation was identified at time of analysis, and the priority label is this_month rather than immediate action.
Stored cross-site scripting in CP Multi View Events Calendar 1.4.43 and earlier allows any authenticated WordPress user with Subscriber-level access to inject arbitrary script through the calendar 'Subject' parameter, which is stored and executes when a victim views the affected calendar page. The adddetails endpoint is reachable by low-privileged users because the required nonce is localized on published pages carrying the calendar shortcode, and no public exploit was identified at time of analysis. This is a moderate-severity issue (CVSS 6.4) with limited confidentiality and integrity impact under a changed-scope vector.
Denial of service in the Elixir standard library's URI module lets a remote client submit a URL whose port component contains hundreds of thousands of digits, causing URI.parse/1 to construct an oversized bignum whose later conversion to text costs seconds of CPU. Exposure requires that the application parse attacker-supplied URLs with URI.parse/1 (not URI.new/1, which uses :uri_string and is capped at five digits on patched Erlang/OTP releases) and then render or echo the resulting %URI{} through URI.to_string/1, inspect/1, logging or error formatting, with the multi-second cost confined to Erlang/OTP 27, 28 and 29.0 while OTP 29.1 and later are largely immune. Authentication is not required (PR:N), but the effect is limited to availability (A:L) and sustained CPU pressure, the advisory documents a proof-of-concept reproduction rather than released exploit tooling, and no confirmed active exploitation is reported; vendor-fixed releases 1.18.6, 1.19.7 and 1.20.5 are available, placing this at moderate, this-month priority rather than an emergency.
Server-side request forgery in phpMyAdmin through 5.2.3 lets unauthenticated remote attackers drive the application into outbound MySQL-protocol connections to attacker-chosen hosts and ports via setup/validate.php, which never enforces the setup-disabled guard, so the probe path stays live even on installations where administrators believe setup mode is off. Impact is limited to semi-blind internal reconnaissance: the attacker learns whether a host/port answers the MySQL handshake by reading the differing error messages returned by Validator::testDBConnection(), with low confidentiality impact and no integrity or availability effect. Exploitation is not accidental-territory: it requires the setup directory to be network-reachable, and the high attack complexity and present attack requirements (AC:H/AT:P) mean probing is not trivially reliable; there is no CISA KEV listing and no confirmed active exploitation, though a public research writeup describing the issue exists and is not verified as working exploit code. Severity is medium and the issue is real but not urgent - the vendor has published upstream fixes in commits and a pull request, with a released patched version not independently confirmed in the supplied data.
Missing authorization checks in the LORIS imaging_browser API allow any authenticated API caller to modify imaging data without holding the edit permission that the imaging_browser frontend enforces. The flaw affects LORIS from 22.0.0 prior to 27.0.4 and from 28.0.0 prior to 28.0.2, and only matters on deployments where the API is enabled and the caller already has a valid account - the independent assessment scores it PR:L with integrity-only impact (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N) rather than the broader CNA vector. No public exploit code or active exploitation has been identified at time of analysis; the vendor has released fixes in 27.0.4 and 28.0.2, and sites that no longer use the API can disable it to eliminate the endpoint.
Kubewarden's trusted-repos-policy before 2.1.2 is a moderate-severity admission-control bypass: an authenticated user with permission to create or update admission-controlled workloads can use an uppercase or mixed-case registry hostname to evade a lowercase reject-list entry, causing the policy to admit an image that the container runtime then pulls. Allow-list configurations are not affected because they fail closed by over-denying differently cased hostnames. No public exploit identified at time of analysis.
Contributor-level users of the Cozmoslabs Profile Builder plugin for WordPress (versions up to and including 4.0.5) can escalate beyond their assigned role because the plugin mishandles privilege assignment (CWE-266). An attacker who already holds a Contributor account - plausible on sites with open registration or multi-author workflows - can leverage the flawed role-handling logic over the network without any user interaction, with low confidentiality, integrity and availability impact (CVSS 6.3, CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L). No public exploit code was identified at time of analysis and the issue is not in CISA KEV; the exact trigger path and the specific elevated capability obtained are not described in the available sources.
SUSE Rancher Manager fails to enforce its local (management) cluster shell authorization check on every API route that can reach the shell handler, so an alternative request form lets any authenticated Rancher user spawn an interactive shell pod in the cattle-system namespace on the management cluster. Affected are Rancher 2.11.x through 2.15.x branches before the fixed releases, in default configurations with no special feature flag enabled; exploitation requires a valid Rancher account (CVSS PR:L) and no permissions on the local cluster. The spawned dashboard-shell-* pod runs unprivileged and its Kubernetes API access stays scoped to the requesting user's own identity, so the bypass yields compute and in-namespace network presence on the management plane rather than additional Kubernetes privileges; no public exploit code was identified at time of analysis, and the flaw is a bypass of the protection added for CVE-2022-21953.
An authentication bypass in xiaozhi-esp32-server through 0.9.8 lets remote, unauthenticated clients open an authenticated WebSocket session against the voice-assistant backend by supplying a Device-ID header whose value mimics an allowlisted MAC address, because WebSocketServer._handle_auth lets allowlisted identifiers skip Bearer HMAC token verification entirely. A successful attacker can issue voice-assistant commands, exchange audio and read that device's conversation context, though confidentiality and integrity impact is capped by the need to know or correctly guess an allowlisted MAC-shaped value (assessed CVSS 6.3, AC:H/AT:P, PR:N/UI:N). No KEV entry or confirmed active exploitation exists at time of analysis; this is a moderate-priority, this_month item, and the vendor has published an upstream fix in pull request 3457 alongside a public issue report and a regression test script that demonstrates the bypass path.
Information disclosure in libmspack through 0.11alpha (CVSS 4.0 base 6.3) allows an attacker who supplies a crafted MS-ZIP CAB file to the library's cabd->extract() path to place up to 32 KiB of stale heap memory into the extracted output. The flaw is an uninitialized-memory (CWE-908) condition in the MS-ZIP decompressor: when a crafted first block begins with a back-reference, unchecked back-reference distances copy window/heap contents instead of initialized data. The leaked bytes are uncontrolled stale heap, not attacker-selected memory, and the attacker gains value only if the host application returns or exposes the extracted output - a deployment dependency reflected in the AT:P metric; no KEV entry or confirmed working exploit is reported, though a public technical writeup is referenced.
Out-of-bounds memory read in tcpflow through 1.6.1 allows unauthenticated remote attackers to leak process memory into reconstructed flow files or crash the tool by supplying TCP packets whose IP payload-length field is forged to disagree with the actual packet size. The flaw is reachable in two ways: injecting crafted IPv4 or IPv6 TCP packets into traffic a tcpflow instance is capturing live, or handing an operator a malicious pcap file to process; both require that someone actually runs tcpflow over the attacker-influenced input, which is the primary limiting factor (CVSS 4.0 AT:P, 6.3 medium; independently assessed as CVSS 3.1 6.3 with low confidentiality and low availability impact only). Exploitation is not confirmed in the wild and no CISA KEV entry exists; a public technical writeup describing the payload-length forgery is referenced, but it is not verified as working exploit code, and the vuln.today priority decision is this_month rather than immediate action.
Parse Server versions 9.7.0 up to 9.10.5-alpha.9 contain an IDOR-class authorization flaw (CWE-639) in _Installation updates: an update addressed by object ID is applied to the installation named in the X-Parse-Installation-Id header, and when protectedFieldsTriggerExempt is enabled a beforeSave trigger can process the addressed installation's protected fields while the write lands elsewhere. The issue is medium severity and confidentiality-only; exploitation requires a deployment that has explicitly enabled the non-default protectedFieldsTriggerExempt option and defines a beforeSave trigger on _Installation, plus knowledge of the target installation's object ID. No public exploit identified at time of analysis, and Parse Server 8 and versions before 9.7.0 are unaffected.
Prometheus through 3.15.1 can expose Azure AD or Google IAM bearer tokens when remote_write follows an HTTP 3xx redirect to a host chosen by an attacker, who can then replay the token, for example to write metrics to the victim's backend. The issue affects instances that use those bearer-token credential types for remote_write and that follow redirects, which is the default; it does not apply to remote_write setups without those credentials or where the endpoint and redirect path cannot be attacker-influenced. Severity is medium (CVSS 4.0 base 6.3; assessed CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N), with no public exploit identified at time of analysis.
Additional administrator account creation in Uptime Kuma through 2.5.8 allows unauthenticated attackers to obtain admin access to an instance that is still in its first-run setup state. Concurrent Socket.IO setup requests are timed to the bcrypt hashing window so the empty-user-table check passes more than once, after which the attacker can modify monitors and API keys and enable disableAuth. Exploitation is confined to unconfigured deployments with an empty user table and depends on a narrow timing race; no public exploit is identified at time of analysis, and the priority is this_month rather than immediate action.
Email header injection in CakePHP's SmtpTransport and MailTransport lets data that an application places into custom mail headers via Message::setHeaders() or Message::addHeaders() break out of the header line and add or alter headers such as Bcc, redirecting or modifying outgoing mail. Affected releases named in the CVE are 4.5.12, 4.6.5, 5.1.8 through 5.1.10, 5.2.14 through 5.2.15, 5.3.7, and 5.4.0 through 5.4.3; the flaw is an incomplete fix for CVE-2026-77634, which stripped only full CRLF pairs and left bare CR or LF bytes intact. Impact is confined to message integrity (no confidentiality or availability effect) and only materializes when an application itself feeds untrusted input into custom headers; no authentication or user interaction is required of the attacker, and no public exploit code was identified at time of analysis. This is a medium-severity, defensive-priority issue rather than an emergency.
Cookie domain handling in CakePHP's Http Client CookieCollection, affecting releases through 5.4.3, relies on unanchored suffix matching in both directions: outbound requests could carry cookies scoped to 'example.com' to a host such as 'notexample.com', and inbound Set-Cookie headers with a Domain belonging to an unrelated host were accepted into the jar. An attacker who controls a suffix-adjacent or otherwise unrelated server that a victim application contacts through Http\Client can therefore read leaked session cookies or plant cookies into a cookie jar shared across hosts. The flaw is client-side and exploitable only where an application uses Http\Client and reuses one CookieCollection across outbound requests; it is not in CISA KEV, and the supplied sources do not confirm working exploit code, while an upstream fix exists in commits referenced by PR 19702 and a vendor advisory is available.
CRLF injection in CakePHP's multipart/MIME handling (FormDataPart and Mailer attachment code) through 5.4.3 lets an attacker who can influence an attachment's declared MIME Content-Type or Content-ID break out of the intended header line and add arbitrary MIME part headers or content. The flaw is not exploitable in a default configuration: it only materializes when the consuming application passes unsanitized user input into Message::setAttachments()/addAttachment() or into FormDataPart type/contentId values for HTTP client multipart bodies, which is why the assessed vector carries AC:H and AT:P while remaining unauthenticated. Impact is integrity-only (no confidentiality or availability effect) and the concrete downstream outcome - email content spoofing, malformed MIME accepted by a downstream parser, or altered multipart requests - depends on the consumer; no confirmed working exploit code was identified at time of analysis, though a public research writeup of the CRLF issue exists and the vendor fix is published.
Buffer overflow in ProFTPD's mod_rewrite module, specifically the internal int:utf8trans RewriteMap, allows remote attackers to overwrite a static buffer and corrupt session memory, crashing the FTP session. Affected are ProFTPD releases before 1.3.9e and 1.3.10rc1 through 1.3.10rc4; exploitation is configuration-dependent, requiring mod_rewrite to be loaded with an int:utf8trans RewriteMap applied by a RewriteRule to FTP command arguments, and unauthenticated exploitation is possible only where pre-login commands are rewritten. Patches are available in 1.3.9e and 1.3.10rc5, and no public exploit code is identified in the available intelligence.
Denial of service in GCC's libstdc++ parallel-mode search implementation allows a local attacker who can supply crafted search data to an application built with parallel mode to drive an out-of-bounds memory access, crashing the process. Only binaries compiled with the opt-in parallel mode (__gnu_parallel / _GLIBCXX_PARALLEL) are exposed, and the flaw is rated CVSS 6.2 with availability-only impact (C:N/I:N/A:H) on a local attack vector (AV:L/PR:N/UI:N). No public exploit code has been identified at time of analysis, and the issue is tracked by Red Hat with a 'this_month' priority; the underlying root cause is an undersized internal buffer (CWE-787).
Stored cross-site scripting in BeeHome MyBeeHome releases before 2025-11-01 lets a remote attacker plant script through the Profile editing functionality and the chat messaging component, which then executes in another user's browser session when that content is viewed. The published score is CVSS 6.1 (Medium) with vector AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, so exploitation is network-reachable and low complexity but depends on victim interaction, and impact stays within the browser context (Low confidentiality and integrity, no availability effect, scope change because the script runs in the victim's session rather than against the server). EPSS is 0.21 percent (11th percentile) and there is no CISA KEV entry; a public PoC reference exists in the form of a GitHub repository (jhonny606/mybeehome-stored-xss-2025), but it is not verified as working exploit code. The vendor has not published an advisory with an exact fixed version, and the only version boundary available is the 'before 2025-11-01' cutoff in the CVE description.
Arbitrary file write outside the extraction directory in sevenz-rust2 0.21.0 and earlier allows an attacker-controlled .7z archive to overwrite files on the host when an application uses the crate's default extraction APIs such as decompress_file. The issue is a Zip-Slip path traversal (CWE-22) fixed in 0.21.1; a public PoC reference exists in the GHSA advisory but is not verified as working exploit code, and no CISA KEV entry or confirmed active exploitation is reported. NVD assigns 6.1 with AV:L/UI:R, while the independent assessment applies AV:N/UI:N to services that automatically unpack uploaded archives, so exposure is highest in upload-handling backends, malware-analysis sandboxes, CI pipelines, and mod/game installers.
Read-only mode in Bytebase DBHub before 0.22.6 can be bypassed on the MySQL and MariaDB connectors, allowing write and destructive DDL statements such as DROP TABLE to reach the database through the MCP execute-SQL tool. The root cause is an interpretation conflict: DBHub's scanner treats every '--' as a line comment, while MySQL and MariaDB only start a comment when whitespace follows, so a payload like 'SELECT 1--1;DROP TABLE victim' passes the read-only classifier and is still executed in full because the connectors run with multipleStatements enabled. Unauthenticated remote attackers must be able to influence the SQL the assistant issues - most realistically via prompt injection in content the assistant reads - and read-only mode must actually be enabled for the bypass to matter; a proof-of-concept payload is documented in the public advisory, no confirmed public exploit code or CISA KEV entry exists at time of analysis, and the issue is fixed in 0.22.6.
Configuration line injection in OPNsense core before 26.7.8 lets an authenticated account holding the wireless-edit privilege embed CR/LF characters in WPA fields - wpa.identity, wpa.passphrase, and the RADIUS auth_server_shared_secret/auth_server_shared_secret2 values - so that arbitrary wpa_supplicant or hostapd directives are appended when the generated configuration is loaded by the root-run wireless daemons. The assessed vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:H) reflects a post-authentication, role-gated issue whose trigger additionally depends on a wireless interface actually being configured for WPA and the configuration being consumed by the daemon; confidentiality is unaffected while integrity and availability of the wireless service are. This is a genuine but conditional privilege-escalation issue rather than a mass-exploitation emergency: no CISA KEV listing and no confirmed working exploit code were reported at time of analysis, although a public research writeup and the upstream fix commits describe the injection technique, and the vendor has released a patch in 26.7.8.
pgAdmin 4 before 9.19 fails to enforce the administrator-only restriction on server sharing in server mode: the server API create and update endpoints persist a 'shared' flag and shared username supplied by any authenticated user holding the stock 'User' role, and the servers.json import prunes a non-administrator's shared entries only after validation, so a file containing an invalid entry can still smuggle in a shared server. The planted server carries no stored credentials, so the direct impact is limited to its insertion into every other user's tree, named to look trustworthy and pointed at an attacker-controlled host; the damaging outcome requires a separate victim to connect and hand over their own database password. Fixes are released in 9.19 and no public exploit has been identified at time of analysis, though the exposure is confined to multi-user deployments running SERVER_MODE rather than desktop mode.
An authenticated dashboard user in Nezha 2.0.0 through 2.3.x can cause a persistent denial of service against non-TSDB deployments by deleting a service through POST /api/v1/batch-delete/service, which leaves orphaned service_histories rows behind. On the dashboard's next startup, ServiceSentinel.loadTodayStats dereferences the missing per-service status map entries for those leftover rows and panics, and the crash repeats on every restart until an operator manually removes the orphaned history. The trigger is not immediate and depends on a restart occurring, and TSDB-backed configurations appear unaffected; no public exploit code was identified at time of analysis and the issue is not in CISA KEV. Vendor-released patch: 2.4.0.
Prototype pollution in Parse Server allows any client holding write access to a Parse class to corrupt a shared JavaScript prototype by submitting a crafted field key in dot notation or an ACL entry name that matches a built-in object member such as toString, valueOf or hasOwnProperty. The most severe outcome corrupts a built-in function used throughout the server process, after which unrelated requests fail until the server is restarted, denying service to every client of that instance - and in a multi-tenant deployment, across all applications served by that process. The issue is confirmed to affect Parse Server releases before 8.6.108 and 9.0.0 through 9.10.5-alpha.9; the dot notation vector requires no special configuration, though the highest-impact keys (__proto__ and constructor) are already rejected by the default requestKeywordDenylist. Exploitation requires authenticated class write capability (PR:L) and the impact is availability-only; no public exploit code or active exploitation has been identified at time of analysis.
A privilege-escalation and site-takeover flaw in Plausible Analytics Community Edition through 3.2.1 lets an authenticated site editor read pending invitation and ownership-transfer IDs rendered on the settings/people page, then register an account under the exact invitee email bound to that ID and accept it. Successful exploitation requires an existing pending invitation or ownership transfer plus the ability to register using the invitee's email address, so the issue only applies to instances with outstanding invites and untrusted editor-level accounts. Impact is limited to integrity (assuming the invited role or taking site ownership), with no direct confidentiality or availability loss; no public exploit code is identified at time of analysis and the CVSS 4.0 score is 6.0 with the priority label this_month.
Authenticated OPNsense users holding the page-services-ntp-gps or PPS privilege can inject additional ntpd directives by submitting CR/LF characters in the fudge and refid fields of services_ntpd_gps.php or services_ntpd_pps.php, causing the generated /var/etc/ntpd.conf to be loaded by the root-run NTP daemon. OPNsense core through 26.7.8 is affected, and exploitation requires both the delegated NTP GPS/PPS privilege and an apply/restart of the NTP service, so this is a medium-severity privilege-boundary bypass rather than an unauthenticated mass-exploitable flaw. No CISA KEV entry or EPSS score was supplied, a public research write-up is referenced, working exploit code for this specific NTP vector is not confirmed in the provided data, and the vuln.today priority is this_month.
SQL injection in Moodle's External database enrolment plugin (enrol_database) lets a user with an editing-teacher role store a backslash-quote payload in a course's idnumber field that is later executed by the scheduled enrolment sync task, allowing them to read data from and manipulate enrolment results in the linked MySQL/MariaDB external database. Only sites that have enabled and configured this non-default enrolment plugin against a MySQL or MariaDB backend are exposed; the payload fires only when the scheduled sync runs, so the attacker does not control trigger timing. No KEV listing is present and no verified working exploit code was identified at time of analysis, though a third-party research writeup is referenced; the source-level links in the advisory point to the affected code in v5.3.0 rather than to a confirmed fix.
ProFTPD through 1.3.9e and 1.3.10rc1 through 1.3.10rc4 allow an authenticated FTP user to overwrite files in write-protected locations by abusing symlink handling in the contrib mod_copy module (SITE COPY and SITE CPTO). Rather than resolving the destination to its real path, mod_copy canonicalized the virtual path, so a symlink planted in a directory the user can write to is followed into a directory guarded by a Limit WRITE restriction, granting integrity impact only (no confidentiality or availability impact) against servers that load mod_copy. Severity is moderate with a high attack complexity (CVSS 4.0 6.0 / CVSS 3.1 6.0, AC:H, PR:L); no CISA KEV entry exists and no verified working exploit code is publicly documented, though a public research writeup describing the technique is referenced, and the vendor fix is available.
An integer wrap in GCC's libstdc++ std::vector<bool> element-count handling can leave the container internally inconsistent, so a later operation on it reads or writes out of bounds and crashes the process - an availability-only denial of service (CVSS 5.9, C:N/I:N/A:H). The flaw is reachable only through an application compiled against the affected libstdc++ that builds a std::vector<bool> from an attacker-influenced, excessively large element count; the library is not independently network-reachable, and the high attack complexity reflects the need to drive the count to a value that actually triggers the wrap. Affected platforms per the CPE data are Red Hat Enterprise Linux 6 through 10, OpenShift Container Platform 4 and 5, and Red Hat Hardened Images; no KEV listing or public exploit was identified at time of analysis, and Red Hat tracks the issue under this CVE and Bugzilla 2478508.
Element Call's standalone SPA build writes the shared call-encryption `password` URL query parameter verbatim into its application logs, and those logs are bundled into error reports ("rageshakes") that are sent to the application operator. The flaw affects versions 0.16.0 through 0.20.2 - deployments such as call.element.io - and is rated moderate severity because disclosure only occurs when a user actively submits a bug report and someone with access to the rageshake log store later reads it; the credentials themselves are never exposed over the network path. Version 0.20.3 adds redaction of the `password` key, and there is no public exploit code identified at time of analysis, though operators running their own rageshake servers must separately purge secrets already captured in historical reports.
Timing side-channel in secp256k1-native's native constant-time scalar multiplication (Point#mul and the native scalar_multiply_ct) lets an attacker who can measure operation timing statistically recover bits of a secret scalar such as a private key or nonce - but only when the C extension was built by GCC 14.3.0, 15.1.0, or 15.2.0 at -O2 (the level extconf.rb appends), where the compiler reconstructs the branchless uint256_select mask into a secret-dependent je/jne jump. The flaw is in the compiled binary rather than the source, so source review and ctgrind on a non-reconstructing toolchain miss it; builds with GCC 12.4.0 or earlier (pure bitwise ops) and GCC 13.3.0 (constant-time cmov) are not affected, and the pure-Ruby path is unaffected and separately makes no constant-time claim. Practical exploitation additionally requires a consuming application that multiplies a secret scalar in a timing-observable context such as an online signing oracle plus many repeated measurements; no public exploit code was identified at time of analysis, and version 0.18.0 removes the defect on all tested compilers.
i18next core versions up to and including 26.3.3 allow process-wide corruption of shared built-in objects such as Object.prototype.hasOwnProperty when an application deep-merges untrusted resource data via addResourceBundle(lng, ns, data, deep, overwrite) with both deep:true and overwrite:true. Supplying a source key that matches an inherited built-in (hasOwnProperty, toString, valueOf) makes deepExtend recurse into that shared function and, with overwrite enabled, set one of its properties to attacker-controlled data - for example making Object.prototype.hasOwnProperty.call non-callable - after which subsequent calls, including i18next's own internals, throw TypeError and the process cannot recover, yielding denial of service with limited integrity impact. The configuration is non-default and no standard i18next backend or integration uses it, so exposure is confined to custom application code that merges attacker-controlled translation content; the CVSS vector scores PR:L with AC:H, and no public exploit identified at time of analysis beyond the proof-of-concept snippet published in the vendor advisory (a public PoC reference exists; it is not verified as working exploit code).
A denial-of-service flaw in Red Hat Enterprise Linux 9.6 through 9.10 kernel builds stems from an incomplete backport of the CVE-2026-46099 fix, leaving a bottom-half imbalance in seg6_input_core() that causes softirq starvation. Only hosts with SRv6 (IPv6 Segment Routing) tunnels configured in the kernel are exposed, since that non-default networking feature is what drives traffic into the affected code path; upstream Linux and RHEL 10 are explicitly not affected. The impact is availability-only (CVSS 5.9, A:H, AC:H) with no confidentiality or integrity effect, and no public exploit code is identified at time of analysis.
Information disclosure in the Drupal ECA Helper contrib module affects all released versions (*.*), letting a remote attacker who already holds a high-privilege authenticated account on the Drupal site reach data that should not be exposed to them. The assessed severity is CVSS 5.9 (moderate) with high attack complexity (AC:H) and a privileged-account precondition (PR:H), and the impact is scoped to confidentiality only. The flaw is not in CISA KEV, EPSS is 0.14% (3rd percentile), no public exploit identified at time of analysis, and the priority decision is this_month rather than immediate action.
The Orphans Media contributed module for Drupal is affected across all versions ('*.*') by a high-complexity flaw that a highly privileged authenticated user could leverage to compromise confidentiality and integrity; the module's function, trigger, and fix are documented in Drupal advisory SA-contrib-2026-196 rather than the CVE record. EPSS is negligible (0.14%, 3rd percentile) and there is no KEV entry or public exploit reference, so this is a moderate, non-emergency issue (CVSS 5.9, decision label 'this_month') whose real exposure is limited to sites that installed this contrib module and grant administrative-level accounts. The vulnerability yields no availability impact (C:N? no - A:N), and exploitation depends on conditions outside the attacker's control (AC:H).
Uncontrolled stack recursion in Pistache's REST router path normalization lets a request path containing tens of thousands of consecutive '/' characters exhaust a thread's stack and terminate the server process with SIGSEGV. Pistache 0.0.5 through 0.4.26 and current master are affected; the reporter reproduced an end-to-end crash at roughly 24,000 consecutive slashes against a minimal server configured with maxRequestSize(200000), and also reproduced it through direct calls to SegmentTreeNode::sanitizeResource() and through a parsed HTTP request path. Impact is conditional rather than a default remote crash: the default 4096-byte request-size cap blocks the pathological path unless maxRequestSize() is raised, a front end forwards very long paths, or attacker-controlled strings reach the router API; the GitHub advisory ships a working proof-of-concept with full reproduction steps, the issue is not listed in CISA KEV, and remote exploitation requires no authentication (PR:N).
Decoding crafted SCTP segments with gopacket through v1.7.1 (and master 18c5805) can panic the host process, giving an availability-only denial of service, but only when the application has disabled gopacket's per-packet panic recovery - that is, with gopacket.DecodeOptions.SkipDecodeRecovery=true, DecodingLayerParser with IgnorePanic=true, or direct use of the registered SCTP decoders. A single segment as small as a 54-byte Ethernet/IPv4/SCTP frame carrying an 8-byte INIT chunk is enough; the default entry points (gopacket.NewPacket with default options, DecodingLayerParser with IgnorePanic=false) convert the same input into an ordinary per-packet decode error and do not crash. There is no data disclosure, modification, or allocation amplification, the trigger requires that the victim actually process IP protocol 132, and no public exploit identified at time of analysis (the advisory itself documents reproduction steps and regression tests); the flaw is fixed in v1.7.2.
Heap-based buffer overflow in Ghostscript's TrueType font rendering path lets an attacker crash the interpreter or potentially execute code by getting a crafted font - or a document embedding one - processed on the target host. The flaw is reachable whenever Ghostscript renders untrusted content, so automated document-conversion, print-filter and preview pipelines that ingest attacker-supplied files are the realistic exposure; the malicious file must reach and be parsed locally (AV:L) and the victim or service must open or render it (UI:R), while no authentication is required under the assessed vector. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, so urgency is moderate and ties to patch availability rather than active exploitation; the supplied base score of 5.8 understates the assessed vector, which adds PR:N and A:H and raises the effective severity.
Memory-exhaustion denial of service in LibreDWG 0.14 and earlier lets a crafted pre-R13 DWG file drive the pre-R13 entity decoder into a loop with no reachable normal exit, allocating a new object on every iteration until the process is OOM-killed or realloc fails. Any application or tool that calls dwg_read_file() on untrusted input is affected - including the bundled dwg2dxf, dwgread and dwg2svg - so a CAD viewer, document converter or CI asset pipeline that processes a malformed file supplied by a user or an automated feed can be taken down; the impact is availability only, with no code execution or data disclosure. No authentication is required, but the file must actually be opened by the target workflow. A 496-byte minimized proof-of-concept (magic header AC1.40) is published in the upstream advisory together with reproduction steps using dwgread; that PoC is a denial-of-service reproducer, not verified exploit code for other impact classes, and no CISA KEV entry exists for this issue.
Denial of service in LibreDWG versions before 0.14: a crafted R13-R2000 DWG file with a manipulated num_classes field drives the class-decoding loop in decode_R13_R2000 into an extremely slow realloc-per-iteration cycle, hanging or exhausting the memory of the process that parses it. The issue is availability-only (C:N/I:N/A:H) with a local attack vector and required user interaction, so an attacker must deliver the file to a victim application or user that actually parses it with the affected library. No public exploit code or active exploitation was identified at time of analysis, and the vendor-released fix is version 0.14.
Loading a crafted LSTM model into Tesseract OCR 5.5.3 and earlier aborts the host process on the default build configuration, giving denial of service against any application that calls TessBaseAPI::Init on untrusted .traineddata data. The flaw sits in WeightMatrix::DeSerialize, which trusts a single attacker-controlled mode byte and routes to a legacy parser that is unimplemented under FAST_FLOAT and calls ASSERT_HOST instead of returning an error; since FAST_FLOAT is enabled by default in both CMakeLists.txt and configure.ac, ordinary builds are affected. Impact is limited to process termination (no code execution or data disclosure) and requires the target to actually load an attacker-supplied model, so this is a moderate, correctly-rated issue rather than an urgent priority; a public PoC reference exists (the crafted mode-byte blob and reproduction recipe documented in the upstream advisory), though it is not verified as working exploit code, and no active exploitation has been reported.
Loading a crafted .traineddata language model file into Tesseract OCR versions prior to 5.5.4 can crash the process and, in some reuse paths, drive out-of-bounds heap accesses. The flaw lives in GENERIC_2D_ARRAY::DeSerializeSize for the TFile stream variant, which reads matrix dimensions as signed int32_t and compares them against UINT16_MAX with a signed check, so a negative dimension such as 0xFFFFFFFF (-1) or a 65535×65535 pair slips past validation into ResizeNoInit, where the element count overflows. The vector is local (AV:L) with required user interaction (UI:R) and no privileges needed, and the impact is limited to availability (A:H) - someone or something must load the malicious model, so applications that only ever load trusted, bundled language data are not practically exposed. This is a medium-severity denial-of-service issue, not a priority emergency; no public exploit code and no confirmed active exploitation were identified at time of analysis, and version 5.5.4 contains the fix.
Symbolic-link following in Zuke CLI (@zuke/cli prior to 1.4.0) allows a repository, template, or archive supplied by an untrusted party to redirect the scaffolder's writes outside the selected directory, with the invoking user's permissions. Running `zuke setup` in such a directory lets a planted symlink at `.gitignore` be read through and rewritten with no flag required, and with `--force` the launcher is written at the link's target and made executable; `zuke import` additionally reads link-target content and parses it into the generated build file, giving a confidentiality-exposure angle. The vector is CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N (5.5), reflecting that the attacker must first place content on disk and the victim must actively run the tool, and impact is capped by the invoking user's privileges; no public exploit was identified at time of analysis and there is no CISA KEV entry, so this is a moderate-priority item to address this month rather than an emergency.
Incorrect permission assignment in Dell OpenManage Enterprise versions prior to 4.8.0 lets a locally authenticated low-privileged user bypass a protection mechanism and access critical resources with high confidentiality impact, while integrity and availability are unaffected. The CVSS 3.1 score is 5.5 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), so exploitation requires local access and pre-existing low-level privileges and is not remotely reachable over the network. No public exploit was identified at time of analysis, and the CVE is not identified as actively exploited in CISA KEV.
Mandatory required-action challenges in Keycloak - as shipped in Red Hat Build of Keycloak and Red Hat Single Sign-On 7 - can be skipped when an authorization request carries a kc_action query parameter set to a required action that is already pending on the account, such as profile verification (VERIFY_PROFILE) or terms-and-conditions acceptance. The attacker must be an authenticated user (CVSS PR:L) whose administrator has already assigned that mandatory action; the broken application-initiated-action handling then lets the authorization code be issued without the challenge being completed, so the user reaches the application while bypassing onboarding and compliance gates. The exposure is confined to defeating that mandatory-action control (integrity impact only, per the assessed vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N, 5.4 medium) and does not escalate the user beyond their own granted access; no public exploit code or CISA KEV confirmation was identified at time of analysis.
Authentication bypass in the Drupal contrib module Domain Login Restrict (versions 0.0.0 through before 1.5.0) allows a low-privilege authenticated user to use an alternate path or channel to evade the module's domain-based login restrictions, with low confidentiality and integrity impact under CVSS 5.4. Exploitation requires the module to be installed and actively enforcing restrictions; the exact bypass path is not described in the available sources. No public exploit was identified at time of analysis, and EPSS is 0.19% (9th percentile).
Server-side template injection in the Drupal contributed module Linked Field (versions 0.0.0 through 1.8.0, fixed in 1.8.0) allows an authenticated user who holds the permission to configure the module's formatter/display settings to supply template syntax that the site then evaluates in its own server context, enabling code injection. This is a moderate-priority issue rather than an emergency: EPSS is 0.18% (7th percentile), there is no CISA KEV entry, and no public exploit has been identified at time of analysis. The vendor has released a patch, and the practical exposure is limited to sites that grant this administrative-style configuration permission to users beyond a small trusted set.