Improper access control in the Socket.IO signaling handlers of MiroTalk P2P through version 2.1.38 (and the 2.0.87 line) allows a peer that already holds a live socket connection to the server to reach other peers' WebRTC signaling channels by supplying a target's peer_id, bypassing room isolation. The impact is limited to signaling relay manipulation (ICE/SDP and related room/presenter events) with low confidentiality, integrity and availability effects - assessed as a medium-severity flaw (CVSS 3.1 5.3, PR:L), not an emergency. There is no CISA KEV listing and no public exploit identified at time of analysis; the vendor has released version 2.1.39 to fix it.
IrfanView 4.76.0.0 on Windows x64 has a heap-based buffer overflow (CWE-122) in its TIFF Wang Annotation handling: opening a crafted TIFF file that carries a malicious Wang annotation can corrupt heap memory. Exploitation is constrained - the TIF-Annotations feature is disabled by default and must be explicitly enabled by the user, and both the vendor and VulDB characterise successful triggering as difficult; no authentication is needed but the victim must open the attacker-supplied file. A public PoC reference exists (a GitHub write-up under dwBruijn/CVEs), but it is not verified as working exploit code; the CVSS 4.0 score is 1.3 and the priority label is 'monitor', consistent with a low real-world risk rather than an urgent one.
Authenticated privilege-management weakness in EasySoft ZenTao PMS through 22.6 allows a low-privileged user to manipulate the group argument handled by userModel::checkGroupChange in module/user/model.php, potentially gaining improper group-related privileges. The flaw is remotely reachable but requires a valid low-privilege account; assessed impacts are limited to low confidentiality, integrity, and availability effects with no scope change. No public exploit was identified at time of analysis, and the vendor did not respond to the disclosure.
Audit log spoofing in the HPE Networking Fabric Composer API lets an unauthenticated remote attacker falsify the client address recorded in audit records, undermining the reliability of those logs without exposing data or disrupting service. The CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, reflecting low integrity impact only, and no public exploit was identified at time of analysis. Exposure is concentrated in deployments where the management API is reachable from untrusted networks.
Sensitive information disclosure in the HPE Networking Fabric Composer API allows an authenticated, low-privileged remote attacker to read data from the affected system, provided certain preconditions outside the attacker's control are already met. The issue is rated CVSS 5.3 with high attack complexity (AC:H) precisely because those environmental prerequisites, which HPE does not enumerate in the available advisory text, gate exploitation; no user interaction is needed and the impact is limited to confidentiality (C:H) with no effect on integrity or availability. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor's own framing plus the priority label place this in this month's routine remediation queue rather than an emergency response.
Unauthenticated information disclosure in the HPE Networking Fabric Composer API allows remote attackers to obtain sensitive system details without credentials or user interaction. The flaw is rated CVSS 5.3 with confidentiality-only impact; no public exploit code or confirmed active exploitation was identified at time of analysis. Exposure is greatest where the management API is reachable from untrusted networks, so network segmentation materially lowers real-world risk.
Sensitive information disclosure in HPE Networking Fabric Composer allows an authenticated attacker with low privileges and network reachability to access sensitive information, with high confidentiality impact and no integrity or availability impact. The CVSS 3.1 score is 5.3 with attack complexity rated high, and the available sources do not describe the specific feature, protocol, configuration, or state required to trigger the disclosure. No CISA KEV entry is present and no public exploit identified at time of analysis; exploitation requires a valid low-privilege account.
Path traversal (CWE-22) in isomorphic-git up to and including 1.38.5 lets a malicious or man-in-the-middle-controlled non-GitHub remote write attacker-chosen files outside the working-tree root when a victim clones or checks out that repository, and overwriting shell rc, configuration or startup files can escalate the write into code execution. Affected are Node.js and browser deployments using any host-backed fs provider on Linux, macOS or Windows; the issue is unauthenticated (PR:N in the vector) but requires user-initiated clone/checkout of untrusted content (UI:R) and a non-GitHub remote, because GitHub runs fsck on push and rejects '..' entries, and escalation further depends on a writable security-relevant parent-path file existing. A public PoC reference demonstrating the escape write exists; it is not verified as working exploit code, there is no CISA KEV listing, and the overall priority is moderate rather than an emergency.
Authorization bypass in NetBox (2.9.0 up to but not including 4.7.4) lets authenticated users who hold a bulk add-component permission such as dcim.add_interface or dcim.add_modulebay act on parent devices and virtual machines that their ObjectPermission constraints should hide from them. By submitting arbitrary primary keys in the 'pk' list, or '_all' together with a GET filter, the attacker can view out-of-scope device details and create components on those parents; the flaw is in BulkComponentCreateView, which failed to apply the 'view' permission restriction to the parent queryset. Impact is limited to confidentiality and integrity at low severity (CVSS 5.3 / assessed CVSS:3.1 5.3, PR:L, no availability impact), it requires a valid account and the add-component permission, and it matters chiefly in multi-tenant or role-separated deployments using constrained ObjectPermissions; no public exploit code was identified at time of analysis and the issue is not in CISA KEV, with a vendor fix released in 4.7.4.
Stored cross-site scripting in buku's optional bukuserver web component (versions 5.0 through 5.1.1) lets an unauthenticated remote attacker plant a bookmark URL that executes JavaScript in the browser of any user who later opens the bookmark list page. Because the injected script runs same-origin with the bukuserver UI, it can issue API requests carrying the viewer's credentials, but the realized damage is bounded to those same-origin actions and requires a separate victim to load the affected page (passive user interaction). No CISA KEV entry and no public exploit identified at time of analysis; this is a genuine but moderate-priority web vulnerability rather than a high-urgency emergency.
Missing authorization in the ClickCease Click Fraud Protection WordPress plugin, versions through 3.3.0, allows remote unauthenticated attackers to reach a plugin feature that lacks an access-control/capability check, resulting in a bounded integrity impact with no confidentiality loss and no availability impact. The CVSS 3.1 base score is 5.3 (Medium) with vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, so no privileges and no user interaction are required, but the scope of what an attacker can change is limited (I:L). No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV; the specific endpoint or action missing the check is not described in the available sources.
AnyWhere Elementor, a WordPress plugin by WPVibes, ships with a missing authorization check (CWE-862) in versions up to and including 1.3.0, letting unauthenticated remote requests reach functionality that should have been capability-gated. Per the CVSS vector (PR:N/UI:N) no credentials or user interaction are needed, but the exposure is limited to partial confidentiality loss (C:L) with no integrity or availability impact, giving a moderate CVSS 5.3. No public exploit code or active exploitation is confirmed, and EPSS/KEV data were not provided; the trigger endpoint is not described in available sources, so real-world urgency is low-to-moderate rather than immediate.
Missing authorization in the weDevs Dokan Lite WordPress plugin (Dokan through 5.3.2) lets unauthenticated remote attackers reach functionality that should be access-controlled and read restricted data from the site. Rated CVSS 5.3 with confidentiality-only, low-magnitude impact (C:L/I:N/A:N), it needs no credentials and no user interaction against any site running an affected version. No public exploit was identified at time of analysis and there is no confirmed active exploitation; the priority label for this issue is 'this_month'.
Missing authorization in the Dokan Lite WordPress plugin through 5.3.2 permits unauthenticated network attackers to access limited information guarded by incorrectly configured access controls, with low confidentiality impact and no integrity or availability effect. No public exploit is identified at time of analysis, and active exploitation is not confirmed in the supplied data.
Missing authorization in WPMU DEV Forminator through 1.58.3 allows remote unauthenticated attackers to make limited integrity-impacting changes on WordPress sites running the plugin, per the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N with C:N/I:L/A:N. No public exploit was identified at time of analysis, and the issue is assessed as a moderate-severity, low-priority concern rather than an emergency; the specific endpoint or feature that triggers the flaw is not described in the available sources.
Missing authorization checks in the WC Lovers WCFM Membership WordPress plugin, in all versions up to and including 2.12.0, allow unauthenticated remote attackers to reach plugin functionality that should be gated by an access-control decision, with the official vector (CVSS 3.1 5.3, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N) describing only limited integrity impact and no confidentiality or availability effect. The flaw is classified CWE-862 (Missing Authorization), and the specific feature, endpoint or action that lacks the check is not described in the available sources. No CISA KEV entry and no public exploit code were identified at time of analysis, and the vulnerability is rated 'this_month' in the priority decision signal rather than act-now urgency.
Unauthenticated remote attackers can bypass intended access-control restrictions in the WordPress plugin Uncanny Automator through version 7.7.1, because a function or endpoint lacks a proper authorization check (CWE-862). The CVSS 3.1 score is 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N), so the worst confirmed outcome is limited integrity impact with no confidentiality or availability effect; the specific endpoint, feature, or configuration that exposes the missing check is not described in the available sources. No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor advisory details are available through Patchstack.
Unauthenticated information disclosure affects the WebberZone Better Search WordPress plugin through version 4.5.2, where a missing authorization check (CWE-862) lets network attackers reach functionality that should be access-controlled, exposing limited data (CVSS 5.3, C:L/I:N/A:N). Per the CVSS vector (PR:N/UI:N), no credentials or user interaction are required, but the impact is confined to partial confidentiality loss with no modification or denial of service. No public exploit code or CISA KEV entry was provided; the trigger endpoint is not described in the available sources, and the issue should be scheduled for patching rather than treated as an emergency.
Stored cross-site scripting in TeXlyre 0.11.0 through 0.13.4 lets an attacker run arbitrary JavaScript in the TeXlyre origin by supplying a malicious LSP or typesetter recipe whose free-form 'icon' field carries an HTML event handler such as <img onerror=...>; the payload is stored in the user's settings and re-executes each time the tool-settings card is rendered. Exploitation requires the victim to actively import the recipe via Settings → Import (file, URL, or pasted JSON), so the attack depends on social engineering around TeXlyre's recipe-sharing feature rather than unattended remote triggering. A public PoC reference exists in the vendor advisory; it is not verified as working exploit code, the issue is not listed in CISA KEV, and success yields read/exfiltration of IndexedDB-stored project documents plus access to in-memory decrypted Git backup tokens.
Missing authorization in Dromara domain-admin before 1.6.79 allows authenticated users to read member metadata from groups they do not belong to by calling POST /api/getGroupUserList with other group_id values. Attackers can enumerate sequential group IDs to disclose member usernames, leader and edit-permission flags, and owner usernames; exploitation requires a valid low-privileged account. No public exploit was identified at time of analysis, and the vendor has released version 1.6.79 with a group-membership permission check.
DbGate before 7.3.3 does not enforce LOGIN_PERMISSIONS connection restrictions on the /connections/test and /connections/save endpoints, so an authenticated user who is supposed to be limited to specific database connections can instead submit arbitrary connection definitions. That lets the user probe internal database hosts through the test endpoint and overwrite stored connection definitions through the save endpoint, both with limited (Low) confidentiality and integrity impact. Exploitation requires a valid low-privilege account in a multi-user deployment that actually enforces per-connection restrictions; no public exploit code has been identified at time of analysis, and the issue is rated medium severity (CVSS 5.3) with a moderate rather than urgent priority.
Cross-site scripting bypass in svg-sanitizer (Composer package enshrined/svg-sanitize) 1.0.0 and earlier lets an attacker who can supply or upload SVG content place a javascript: URL inside an animateTransform values attribute, which survives sanitization and overwrites an anchor's href, executing arbitrary JavaScript when a victim clicks the link. The bypass only fires in Apple Safari, which uniquely allows animateTransform to target href, and requires the victim to click the affected link (UI:R), so this is a genuine but moderate-risk stored-XSS sanitizer flaw rather than an emergency; the vendor demo tool accepted the published payload. No confirmed active exploitation or KEV listing is reported, and the upstream security advisory documents a public proof-of-concept payload; upgrading to 1.1.0 removes the bypass.
SVG Sanitizer 0.5.0 through 1.0.0 fails to strip remote URLs expressed with CSS escape sequences inside url() in SVG presentation attributes, so a sanitized SVG can still cause a browser to make an outbound request when rendered. The advisory shows that fill="url(//evil.example/x)" is removed while fill="url(\2f\2f evil.example/x)" is not, which can enable data exfiltration depending on how the application uses the SVG. This is a medium-severity issue (CVSS 4.0 base 5.3) with a this-month remediation priority; CISA KEV status is not indicated in the supplied data, and a public PoC reference exists in GHSA-3vh3-jf65-656w but is not verified as working exploit code.
Frappe HRMS before 15.61.0 allows any authenticated employee to read other employees' expense advance records by querying the Expense Claim Advances API, which fails to enforce ownership-based authorization (CWE-639). The exposure is limited to read access of sensitive financial data belonging to coworkers; there is no integrity or availability impact and an attacker must already hold valid employee credentials on the instance. A public advisory exists, no public exploit code has been identified at time of analysis, and this is tracked as a moderate-severity information-disclosure issue rather than an emergency.
Froxlor versions through 2.3.14 allow an authenticated customer to create MySQL databases through the Mysqls.add API endpoint even when the administrator has explicitly hidden or disabled the MySQL feature via panel.customer_hide_options, because add() omits the authorization check that get(), update(), and delete() enforce. The result is a policy violation rather than a breach: the customer provisions unauthorized databases only within their own existing quota, with no code execution or access to other tenants' data. This is a low-to-moderate real-world risk and should be treated as a policy/hardening fix rather than an urgent emergency; no public exploit code is confirmed in the available data, and exploitation requires both a valid customer account and the MySQL feature already being hidden.
Froxlor 2.3.0 through 2.3.14 lets an authenticated customer who holds a valid API key overwrite the Let's Encrypt-managed certificate and private key of a domain they own, because the Certificates.add and Certificates.update API commands never check the letsencrypt flag that the UI and read paths enforce. The attacker-supplied key pair is stored in domain_ssl_settings and pushed into the webserver configuration by a REBUILD_VHOST task, degrading or breaking HTTPS for that domain's visitors until the next ACME renewal and desynchronizing the panel from acme.sh; the original LE private key stays unreadable, so the exposure is an integrity/availability gap on the write path. Exploitation is bounded to the attacker's own domains and requires API access to be enabled for the customer account; a proof-of-concept with reproduction steps is documented in the published advisory, and no CISA KEV entry or EPSS score accompanies this CVE.
AzuraCast's station waveform endpoints (GET and POST /api/station/{station_id}/waveform/{media_id}) are missing the Permissions middleware that every sibling station-scoped media route carries, so any authenticated user - even one with no station assignment at all - can read another station's cached waveform JSON and overwrite it with arbitrary content. Successful abuse gives limited cross-station data disclosure and limited tampering with the Visual Cue Editor waveform data, not access to media files, credentials, or arbitrary filesystem paths (CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N; CVSS 4.0 base 5.3). Authentication of the lowest privilege tier is required and the attacker must reach the API with a target station_id and media_id; VulnCheck and the upstream advisory provide a PoC reference that boots the real application and introspects its compiled route table to prove the missing middleware - it is not verified as working end-to-end exploit code, and there is no KEV listing or active-exploitation reporting.
SurrealDB 3.1.0 through 3.2.x mishandles port-specific network deny rules, so an authenticated user who can call the http::* functions can reach an internal service that a --deny-net HOST:PORT or IP:PORT rule was meant to block simply by naming the same target through a different alias (a hostname that resolves to the denied IP, or the bare IP of a denied hostname). The advisory demonstrates this against the v3.2.0 release binary with published reproduction steps, so a public proof-of-concept reference exists; there is no CISA KEV entry indicating active exploitation. Scope is bounded: it is an egress-policy bypass that only matters to deployments relying on port-bearing deny rules, and bare-IP deny rules are unaffected; it is fixed in 3.3.0.
Incorrect authorization in SurrealDB 3.1.0 through 3.2.x lets an authenticated record user recover restricted field values by inference: the default streaming execution planner selects FULLTEXT, compound B-tree and HNSW indexes built on fields whose field-level SELECT permission is not FULL, then drops the index-covered predicate instead of re-evaluating it against the permission-reduced document. Affected are deployments that combine restrictive field-level SELECT permissions with indexes on those fields; direct SELECT output continues to hide the values, but result-set membership and ordering act as a confirmation or nearest-neighbour oracle, so the impact is low-severity, confidentiality-only disclosure (CVSS 4.0 5.3 / CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N, CWE-863/CWE-200). A public PoC reference exists (a reproduction script with recorded results in the GitHub advisory); it is not verified as working exploit code, and there is no CISA KEV listing.
FreeRDP clients up to and including 3.32.1 can be terminated by a malicious or compromised RDP server that sends a crafted ALPHA WIRETOSURFACE_2 graphics-pipeline command with zero width and zero height. The session crash is client-side and requires the victim to connect to the attacker's server with RDPGFX active (AUTODETECT enables it), so exploitation depends on a user-initiated connection rather than an exposed listening service. Confirmed termination was observed on builds compiled with verbose WINPR assertions, where an element-size assertion aborts the process; on builds without that assertion the advisory describes a following division by zero as a plausible but not executed termination path. No CISA KEV listing exists; the advisory supplies a handler-level reproducer and documents a preserved live server test, but this is not verified general-purpose exploit code.
Denial of service in FreeRDP clients at version 3.32.1 and earlier lets a malicious or compromised RDP server terminate the connecting client by sending a three-byte zero-output ZGFX payload (E0 20 00) on the RDPGFX dynamic channel after session activation. The decompressor returns success while leaving its output pointer null and its size zero, and rdpgfx_on_data_received - which rejects only negative decoder status - forwards that null pointer into Stream_StaticConstInit, whose WINPR_ASSERT(buffer) aborts builds compiled with verbose WinPR assertions, the upstream CMake default. A component-level reproduction and a documented live xfreerdp test (client exit 134) are public; only assertion-enabled builds are affected, the verified impact is limited to client availability with no memory corruption, disclosure or code execution, and no CISA KEV listing or confirmed active exploitation is reported (priority label: this_month).
FreeRDP clients up to and including 3.32.1 can be driven into excessive memory allocation by a malicious RDP server when serial device redirection is enabled, because the serial channel fails to cap the server-supplied OutputBufferLength carried in an IRP_MJ_DEVICE_CONTROL request before allocating and echoing it back. Only availability is affected: the vendor measured roughly 4.01 GiB peak RSS and about 3.8 seconds of handler time from a single IOCTL_USBPRINT_GET_1284_ID request, with no confidentiality or integrity impact observed. Exploitation requires the victim to connect out to an attacker-controlled server and to have serial redirection configured with a redirected device successfully opened; no public exploit is identified beyond the reproduction harness published in the vendor advisory, and there is no CISA KEV confirmation of active exploitation.
Drive redirection in FreeRDP 3.32.1 and earlier can be silently disabled by a malicious RDP server: a single truncated IRP_MJ_CREATE device I/O request terminates the drive worker while leaving its error state at CHANNEL_RC_OK, so the RDPDR channel stays up and every subsequent server request is queued in IrpQueue with no consumer until memory is exhausted or the session ends. Only clients that initiate a connection to an attacker-controlled or compromised RDP server with drive redirection enabled (/drive or drivestoredirect) under the default asynchronous RDPDR dispatch are affected, and the impact is availability loss confined to that session, with no confidentiality or integrity impact (assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L; upstream rates it 5.3). There is no CISA KEV listing and no reported in-the-wild exploitation; a public proof-of-concept verification harness accompanies the vendor advisory, and the issue is fixed in 3.32.2.
FreeRDP clients up to and including 3.32.1 can be crashed by a malicious or compromised RD Gateway that sends a PKT_TYPE_EXTENDED_AUTH_MSG (type 0x0003) immediately after the HTTP/WebSocket upgrade, before tunnel authentication completes. In the default configuration (GatewayHttpExtAuthSspiNtlm=FALSE) the HTTP authentication context is freed before tunnel packets are processed, so rdg_process_packet dispatches the extended-auth packet with rdg->auth NULL and a zero-length blob reaches credssp_auth_is_complete(NULL), producing a null-pointer dereference; the advisory documents an abort (exit 134) on an assertions-enabled build and a null-pointer read crash (exit 139) on an assertions-off build, with no memory-corruption or data-access effect demonstrated. The attacker does not reach the client directly: the victim must initiate a connection to the hostile gateway (CVSS 4.0 AV:N/PR:N/UI:P, our assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L, availability-only impact). A public proof-of-concept reproduction is published in the GitHub security advisory GHSA-8rjm-m7xg-mg6m and has been independently re-verified to crash affected clients; the issue is not in CISA KEV and no in-the-wild exploitation is reported, and the vulnerability is fixed in 3.32.2.
Memory exhaustion in FreeRDP's RD Gateway client (versions through 3.32.1) lets a malicious or compromised gateway force roughly 2 GiB of client-side allocation before tunnel authentication, tying up memory while the session waits on body bytes that never arrive. A single eight-byte RDG header declaring packetLength 0x7FFFFFFF slips past the INT_MAX check in rdg_receive_packet and reaches Stream_EnsureCapacity, where WinPR rounds the request to 0x80000000 and zero-fills the expanded stream. The attack is unauthenticated (CVSS PR:N) but narrow: the victim must be running xfreerdp/FreeRDP in RD Gateway mode (/gateway over HTTP or WebSocket) and must initiate a connection to the hostile endpoint, impact is availability-only, and if the host refuses the allocation the connection fails cleanly; there is no CISA KEV entry, and the GHSA advisory publishes a full reproduction harness that was executed and measured at 2.032 GiB resident memory.
Heap buffer over-read in FreeRDP's winpr PNG encoder (save_png_to_buffer) allows a malicious or compromised RDP server to embed a limited amount of client heap memory into a clipboard image and disclose it to a local application. FreeRDP 3.x through 3.32.1 built with WINPR_UTILS_IMAGE_PNG and clipboard redirection enabled is affected when the server offers a 16 bpp BI_BITFIELDS CF_DIB and a local application requests that clipboard content as image/png. The impact is limited to low confidentiality, with no integrity or availability effect and no code execution; no active exploitation or confirmed public exploit code is identified, although the vendor advisory includes a public reproduction harness that triggers the over-read under ASan.
Remote denial of service against FreeRDP client processes in versions 3.0.0 through 3.32.1: an attacker who operates (or intercepts with an accepted certificate) the Remote Desktop Gateway a user connects through can send a single crafted RPC-over-HTTP RTS PDU whose authentication padding contradicts the lengths declared in the header, tripping a reachable assertion in rts_read_auth_verifier and aborting the client. The abort is only reachable in builds compiled with WITH_VERBOSE_WINPR_ASSERT=ON, which is not the default for release-style builds; with the option disabled the same packet is rejected through the ordinary connection-error path with no crash, and FreeRDP server, proxy and shadow roles never enter this parser. No confidentiality or integrity impact and no memory corruption is involved, exploitation requires the victim to initiate the gateway connection (PR:N but user interaction required), and no in-the-wild exploitation has been confirmed; a public PoC reference exists in the form of an inline reproducer published in the upstream advisory, and it is not independently verified here as working exploit code.
A hostile RDP server can exhaust the file descriptor table of a FreeRDP client by repeatedly sending IRP_MJ_CREATE requests for a redirected parallel device, leaking one local descriptor per request until descriptor allocation fails and the client process crashes. FreeRDP versions 3.0.0 through 3.32.1 are affected (fixed in 3.32.2), and only clients that explicitly enable parallel-device redirection to an openable local path are exposed - with redirection disabled the vulnerable code path is unreachable. The CVSS vectors supplied by the vendor and by our assessment both mark this unauthenticated and network-reachable but user-interaction dependent (UI:P, PR:N), availability-only, and bounded to the single client process; the advisory ships a tested local relay PoC, so a public PoC reference exists for reproducing descriptor growth in a lab, but no active exploitation (CISA KEV) or EPSS signal is present in the available data.
FreeRDP clients built with the optional WITH_AAD=ON flag can be aborted by a crafted ARM gateway response: an HTTP 200 JSON reply that omits the redirectedServerCert field (or supplies it as a non-string) drives a NULL buffer into the target-certificate parser, tripping a WINPR_ASSERT in the stream initializer and terminating the client with SIGABRT. Only non-default AAD-enabled builds (>= 3.0.0 through 3.32.1) that also link WinPR JSON are affected; the advisory states the default AAD-off build does not compile the ARM gateway route and is unaffected. Impact is client-side availability loss only with no confidentiality or integrity effect, and exploitation requires the user to point the client at a malicious or malformed gateway. A public proof-of-concept fake-gateway reproducer is included in the vendor advisory, but it is a loopback-only test harness rather than general-purpose exploit code, and no confirmed active exploitation or KEV listing exists; the vendor addressed the flaw in 3.32.2.
Out-of-bounds read in FreeRDP's built-in GSM610/WAV49 audio decoder lets a malicious or compromised RDP server read past a received audio buffer and, when the read crosses an unmapped page boundary, terminate the client process - an availability-only denial of service with no write, code execution, confidentiality, or integrity impact claimed. FreeRDP releases from 2.0.0 through 3.32.1 are affected only when built with WITH_GSM=ON and WITH_DSP_FFMPEG=OFF, with audio playback enabled so the rdpsnd static channel loads; builds using the FFmpeg DSP backend or without libgsm are not exposed. Exploitation requires the victim to initiate the RDP session, the server to offer GSM610, and a WAVE2 message whose audio body is shorter than the next complete 33- or 32-byte WAV49 frame - the advisory ships a bounded guard-page proof-of-concept verifier that reproduces the read locally, but no confirmed working remote exploit code and no CISA KEV listing exists, so this is a medium-severity, schedule-for-this-month client fix rather than an emergency.
Authorization bypass in the AI Alt Text Generator WordPress plugin through 2.7.0 allows a Contributor-level user to modify the alt text of arbitrary attachments owned by other users, with the title, caption, and description also writable when the plugin's set_title, set_caption, or set_description options are enabled. The defect is a missing authorization check (CWE-862); exploitation requires a Contributor account to retrieve a valid nonce from post.php, post-new.php, or upload.php. No public exploit identified at time of analysis and no CISA KEV entry is present; impact is limited to attachment metadata integrity and rated medium severity (CVSS 5.3).
Unauthenticated visitors can modify JetEngine Options Page values on WordPress sites running JetFormBuilder 3.6.2 or earlier, because the plugin's Update_Options action class performs no capability check before processing submitted data. The flaw is only reachable on a narrow configuration: both JetFormBuilder (≤3.6.2) and JetEngine must be installed and active, and an administrator must have published a form wired to the 'Update Options' post-submission action - sites lacking such a form are not exploitable. Impact is integrity-only (CVSS 5.3, C:N/I:L/A:N), no public exploit code has been identified at time of analysis, and remediation is currently tracked to a trunk commit rather than an independently confirmed tagged release.
Unauthenticated attackers can hijack the account-linking flow in the WP Compress WordPress plugin on fresh installations or lite/free-mode installs that do not yet store an api_key, binding the victim site to an attacker-controlled WP Compress account and obtaining the shared key used by nopriv HMAC-gated endpoints. The missing authorization check (CWE-862) affects versions up to and including 7.22.01 and gives the attacker influence over cache purging, file deletion, opcode cache invalidation and other privileged plugin operations. Exposure is conditional on deployment state: sites that already hold an api_key are not reachable through this path, and no public exploit has been identified at time of analysis.
Integer underflow in TinyUSB's HID host report descriptor parser (tuh_hid_parse_report_descriptor()) allows a malicious USB device to trigger out-of-bounds reads and host denial of service by presenting a truncated report descriptor that makes the uint16_t remaining-length value wrap. TinyUSB releases before 0.20.1 used as a USB HID host are affected; exploitation requires physical attachment of a crafted device (AV:P), needs no authentication or user interaction, and is not reachable over a network. A vendor patch is available, and no public exploit was identified at time of analysis.
mongorestore in MongoDB Database Tools 100.4.0 through releases before 100.20.1 can be made to create an unauthorized, attacker-chosen database account - including one holding the root role - when an operator restores a crafted, untrusted dump. The root cause is inconsistent handling of the 'system.buckets.' prefix during collection-name validation, allowing a malicious collection name to slip past special-collection guards and operator namespace filters. The issue is not remotely or autonomously exploitable: the assessed vector is local (AV:L) with user interaction, and three prerequisites must all hold - an operator restores untrusted data, that restore runs with credentials carrying user-management privileges on the destination, and the tool version is vulnerable. No public exploit code was identified at time of analysis, and notably, excluding the admin namespace alone does not prevent the behavior.
Heap corruption and denial of service in AMD Compressonator SDK can be triggered when a local user or automated pipeline processes a specially crafted DirectDraw Surface (DDS) file. This is a medium-severity out-of-bounds write (CWE-787) that requires local access and user interaction; no public exploit identified at time of analysis. Exposure is limited to tools or pipelines that parse untrusted DDS input.
A heap-based out-of-bounds read in the AMD Compressonator SDK allows an attacker who can get crafted content processed by software built on the SDK to read past the end of an allocated heap buffer, yielding limited memory disclosure or an application crash. The vendor rates it 5.2 on CVSS 4.0 with a local attack vector; our independent CVSS 3.1 assessment (AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H) agrees this is a medium-severity, local-access issue rather than a high-urgency emergency, because exploitation requires the attacker to already have local reach and depends on a user loading or processing the malicious asset. No public exploit code or confirmed active exploitation (CISA KEV) is associated with this CVE at time of analysis, and the priority label is this_month.
An out-of-bounds read in the TGA image parser of the AMD Compressonator SDK allows a low-privileged local attacker to supply a crafted Truevision TGA file that, when parsed by software built on the SDK, over-reads a heap buffer and can disclose sensitive memory contents or crash the consuming process. Because the crafted file must be opened by a user or ingested by an automated asset pipeline, realistic exposure is concentrated in pipelines that automatically process untrusted TGA assets rather than in local workflows handling only trusted input. No public exploit code has been identified at time of analysis, and the issue carries a medium CVSS 4.0 base score of 5.2 (AV:L/AC:L/AT:N/PR:L/UI:P, with high confidentiality and availability impact and no integrity or scope impact).
Stored cross-site scripting in the TYPO3 'mail' extension allows an authenticated backend user with access to the mail module to inject arbitrary HTML and JavaScript into mail content or tracked URLs, with execution occurring in another backend user's session when that user views the mail preview or report. The issue is medium severity (CVSS 4.0 base 5.1; assessed CVSS 3.1 AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N), depends on victim interaction, and is limited to backend-user session confidentiality/integrity rather than server compromise or anonymous frontend exposure. No public exploit identified at time of analysis.
Path traversal (CWE-22) in the ShareActivity component of Vivo's BlueLM Copilot (com.vivo.ai.copilot) allows a malicious application already installed on the same device to write arbitrary files by sending a crafted ACTION_SEND intent whose ContentProvider-supplied file name contains '..' sequences. The flaw is local-only (AV:L) with no confidentiality impact - the assessed vector is C:N/I:L/A:L - so a hostile app must first be present on the device, and exposure is confined to Vivo devices running the Copilot app. It is rated medium severity (CVSS 4.0 base 5.1), flagged by Vivo's own security advisory; no public exploit code or CISA KEV entry was identified at time of analysis, and the vuln.today priority label is 'this_month'.