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.
NULL pointer dereference in the H.264 parser of gst-plugins-bad lets a crafted Multiview (MVC) H.264 file cause a parse failure whose cleanup path dereferences NULL, crashing the GStreamer-based application and causing a denial of service. The issue is medium severity (CVSS 5.5) with a local attack vector, no privileges required, and user interaction needed to get the crafted file ingested; affected deployments include gst-plugins-bad on Red Hat Enterprise Linux 6 through 10. No public exploit identified at time of analysis.
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.
Code injection in the Drupal contributed module Inline Formatter Field (versions 0.0.0 through 4.2.0) allows a user who is permitted to configure the field formatter to supply crafted template-engine syntax that is evaluated when the field is rendered, giving partial confidentiality and integrity impact (CVSS 3.1: 5.4, AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N). The flaw is not reachable by anonymous users in a default configuration; the attacker must already hold the formatter/field-configuration privilege, so real-world exposure depends on how liberally a site delegates that permission. No public exploit code has been identified at time of analysis and the CVE is not in CISA KEV; EPSS is 0.18% (7th percentile), and the vendor has released a patch, pointing to a moderate, this-month priority rather than an emergency.
Stored cross-site scripting in the Drupal Leaflet contributed module allows an authenticated user with permission to create or edit Leaflet-rendered content to persist a payload that executes in another user's browser when the affected map, popup, tooltip, or field output is displayed. The issue is rated CVSS 5.4 and affects Leaflet versions up to the 10.4.13 fix; EPSS is 0.16% (5th percentile), and no public exploit was identified at time of analysis. Remediation is a routine module update to 10.4.13 rather than emergency action.
Cross-site scripting in the Drupal contrib module 'MathJax: LaTeX for Drupal' (versions 0.0.0 through 4.1.2) lets an attacker get an unsanitized payload rendered into a generated page, executing script in a victim's browser session; the victim must view the affected page (UI:R), which limits this to opportunistic or social-engineering delivery rather than silent mass exploitation. Impact is bounded to low confidentiality and integrity loss in the victim's browser context with no availability impact, and the assessed vector requires a low-privileged authenticated position (PR:L) even though the published score lists PR:N. There is no CISA KEV entry and no public exploit identified at time of analysis; EPSS is 0.15% (4th percentile), and the vendor has released a fixed version.
Authenticated low-privileged users can bypass intended authorization checks in Drupal's Inline Entity Form Dialog contributed module (versions 0.0.0 through 1.0.6 per the CVE description), using forceful browsing to reach restricted functionality with limited confidentiality and integrity impact. The flaw requires the module to be installed and enabled plus a valid low-privilege session (CVSS PR:L), so anonymous exploitation is not possible unless the site grants the needed role to self-registered users. No public exploit was identified at time of analysis and there is no CISA KEV entry; EPSS is 0.14% (percentile 4%), and the vendor has a patch available, making this a moderate, this-month priority rather than an emergency.
Access-control bypass in the Drupal Gutenberg contrib module allows an authenticated low-privilege user to reach resources or routes they should not be permitted to access through forceful browsing. Only sites running the module at versions 0.0.0 through 2.15.0 or 3.0.0 through 3.0.7 are exposed, and the CVSS 5.4 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N) confirms a valid account is required with no user interaction; the exposure is a moderate access-control weakness rather than an anonymous takeover path. No public exploit has been identified at time of analysis and EPSS is low at 0.14% (4th percentile), so this is real but non-urgent risk that fits a normal monthly patch cadence.
Missing capability checks in the Fraud Prevention For WooCommerce and EDD WordPress plugin before 2.3.6 allow any authenticated user at Subscriber role or above to add a legitimate customer's details to the store's fraud blacklist, which then prevents that customer from placing orders. Exploitation requires the plugin to be active alongside WooCommerce or EDD and requires a valid low-privilege account, so sites that disable open self-registration raise the bar considerably; there is no data disclosure and no code execution, and impact is confined to integrity and availability of the ordering/blacklist function. No public exploit code has been identified at time of analysis, EPSS is 0.13% (3rd percentile), the vendor has released a patch, and this is assessed as a moderate, low-urgency issue rather than a high-priority emergency.
Insecure temporary-file handling in Mix's partitioned dependency compilation lets a local user on a shared host execute arbitrary shell commands as another user's build account. Elixir releases 1.20.0-rc.4 through 1.20.4 write the serialized project configuration into a fixed-name directory under the system temp dir (created with File.mkdir_p/1, which accepts a pre-existing directory regardless of owner) and each partition VM trusts the file it reads back, so an attacker who owns that directory can swap in a payload whose dependency compile: commands Mix then runs as the victim. Exploitation requires partitioned compilation explicitly enabled via MIX_OS_DEPS_COMPILE_PARTITION_COUNT greater than 1, a build compiling at least two non-local dependencies, a shared temp directory (Linux default when TMPDIR is unset; macOS and Windows use per-user temp dirs by default and are not affected), and a local low-privileged attacker account (PR:L) that wins a timing race; the vendor advisory documents a step-by-step proof-of-concept, there is no CISA KEV listing, and the vendor has released a fix in mix 1.20.5. Even without pre-creating the directory, the world-readable partition file discloses project configuration, including Mix.install compile-time config, to other local users during the build.