2026-11-03
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'.
Reflected cross-site scripting in Vembu BDRSuite's restore progress endpoint (templates/progress/clientside/restoreprogress.sgp) lets remote attackers inject arbitrary JavaScript into a victim's browser session via parameters such as mn, rnm, isRepliRestore, rusr and rpwd, which are echoed into the HTML response without sanitization. All deployments prior to 7.6.0 are affected; no authentication is required to craft the malicious URL, but a BDRSuite interface user must open the crafted link for the payload to run. Resulting impact is confined to the victim's browser context - session hijacking or interface manipulation - rather than the server; no public exploit code has been confirmed and this is rated a moderate, not high-priority, issue.
An open-redirect flaw (CWE-601) in the Atlas SQL JDBC Driver's authentication component lets a hostile or compromised endpoint steer the driver into handing an attacker-chosen URI to the operating system's default protocol handler during interactive sign-in. Only users who choose to connect the driver to an endpoint outside their trust boundary are exposed, and no confidentiality or availability impact is assessed - the outcome is a low-integrity effect from opening an arbitrary local address. No public exploit code or CISA KEV entry is associated with this issue at time of analysis, and it is rated a moderate, not high, priority (this_month) because exploitation hinges on user interaction and endpoint selection.
Denial of service in the AMD Compressonator SDK affects applications that parse untrusted DirectDraw Surface (DDS) files, where an integer overflow can crash or hang the consuming process when a local attacker supplies a crafted file. The CVSS 4.0 vector (AV:L/AC:L/PR:L/UI:P/VA:H, with VC:N and VI:N) means a local user or process with low privileges must actually load or process the malicious asset; there is no confidentiality or integrity impact and no network vector. No public exploit code or CISA KEV entry is identified in the available data, and the vendor bulletin AMD-SB-6032 is the primary reference; the vuln.today decision label is this_month, consistent with a medium-severity, availability-only issue rather than an emergency.
Stored cross-site scripting in PostfixAdmin through 4.0.5 lets an authenticated mailbox user persist a script payload in the description field of a TOTP exception, which then executes in the browser of a global administrator who opens totp-exceptions.php and can issue authenticated admin requests using that page's CSRF token. The same output-escaping defect exists in the application-password list (app-passwords.php), which the vendor commit fixes alongside the TOTP list. Exploitation is bounded: it needs a legitimate low-privilege mailbox account, the TOTP feature in use, and an administrator actually viewing the affected list page; the upstream fix is public (PRs #1172 and #1186), no tagged patched release is confirmed in the supplied data, and no public exploit code or active exploitation was identified at time of analysis.
Path traversal in SQLBot through 1.10.3 allows an authenticated workspace administrator to read files outside the upload directory by supplying an absolute path or ../ sequences in the filePath parameter of the /datasource/importToDb endpoint, with the imported content materialized into queryable excel_* tables. Impact is confidentiality-only and practically constrained: the targeted file must parse as CSV or a spreadsheet, so arbitrary binaries are not straightforwardly disclosed, and the attacker must already hold a high-privilege admin role (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:L/I:N/A:N). The published score is 5.1 (CVSS:4.0/AV:N/AC:L/AT:N/PR:H/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N); a vendor fix exists in commit 3d15c67 and no public exploit code was identified at time of analysis, so this is a moderate-severity, high-privilege information-disclosure issue slotted for this-month remediation rather than an emergency.
Stored CSV formula injection in AzuraCast 0.23.8 and earlier allows a station user holding the Media permission to persist formula-prefixed values (leading =, +, -, @, tab, or carriage return) in media titles, artists, albums, genres, lyrics, ISRC, extra metadata, or station custom fields through POST /api/station/{station_id}/files/bulk. The injected payload is neutralized nowhere on export, so it becomes live the moment a second authorized user downloads the station's bulk media CSV via GET /api/station/{station_id}/files/bulk and opens it in a formula-evaluating spreadsheet such as Microsoft Excel. Impact is confined to the downstream spreadsheet client - the advisory explicitly disclaims server-side or OS-level code execution inside the AzuraCast process - and success depends on victim interaction plus the spreadsheet's version and security settings; no public exploit code was identified at time of analysis and the issue is not in CISA KEV, consistent with a medium-severity, non-urgent priority.
CRLF injection in AzuraCast's public PLS playlist generation lets a station user who holds only the Station:MountPoints or Station:RemoteRelays permission plant extra FileN=/TitleN= entries into /public/{station}/playlist.pls, pointing guest listeners at an attacker-controlled stream that still displays the victim station's own name. The advisory scopes affected installations as AzuraCast before 0.24.0 and verifies the flaw on rolling release commit 2cb84e2f874d08ad9ff743ebda94fb30bc77041f; exploitation is second-order and depends on a guest downloading the playlist and using a media player that honors the injected entries, so impact stays within content spoofing and listener redirection with no code execution and no data exposure (assessed CVSS:3.1 AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:L/A:N). Step-by-step reproduction requests are published in GitHub advisory GHSA-cqgx-rqjr-5gf4, so a public PoC reference exists, but it is not verified as working exploit code; no CISA KEV entry or other active-exploitation signal is present, and priority is this_month.
SurrealDB 3.1.0 through versions before 3.3.0 lets a database Owner bypass operator-defined port-specific deny-net rules and reach explicitly denied internal services, because the JWKS fetch path resolves URL ports with Url::port(), which returns None when an HTTP or HTTPS URL relies on the implicit default port. An attacker who can configure a JWT or record access method simply supplies a JWKS URL such as http://127.0.0.1/jwks.json (no :80) so that a rule like deny-net 127.0.0.1:80 receives a host-only target and no longer matches, producing a blind server-side GET against the denied endpoint. Exploitation requires authenticated Owner privileges (CVSS PR:H) and is only meaningful where port-specific deny rules are in place; the response is blind and parsed only as JWKS, so impact is limited to reachability, timing and parse-success inference with no integrity or availability effect. Scoring is medium (CVSS 4.0 base 5.1; internally assessed CVSS 3.1 AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:N/A:N), no public exploit code was identified at time of analysis although the vendor advisory includes a full reproduction test, and the issue is prioritised as this-month rather than emergency.
Stored cross-site scripting in AM System's Alo Suite lets an authenticated user persist JavaScript through the 'Nombre' field of the /Trabajadores/Create (worker creation) workflow, which is later rendered unsanitized in the delivery-note functionality and executes in the browser of any other user who opens the affected record. Exploitation requires a valid low-privileged account plus victim interaction - a second user actually viewing the record - after which the script can alter displayed content and act within the victim's session. Rated 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), this aligns with a 'this_month' remediation priority rather than an emergency, and no public exploit has been identified at time of analysis.
Stored cross-site scripting in AM System Alo Suite's delivery-note functionality allows an authenticated user to persist JavaScript through the "Observaciones" field on the /Terceros/Create endpoint, which then executes in another user's browser when that record is viewed. The vendor-supplied CVSS 4.0 score is 5.1, with exploitation requiring a valid account that can create or edit delivery notes and a victim who subsequently opens the affected record; the payload can alter displayed content and perform actions in the victim's session. No public exploit code or CISA KEV entry was identified at time of analysis.
Stored cross-site scripting in Alo Suite (AM System) lets an authenticated user with access to the mail-template editor inject JavaScript through the 'Nombre' field at /PlantillasMail/Edit; the payload is persisted and then executes in the browser of another user who views the affected delivery-note records, allowing the attacker to alter displayed content and act within the victim's session. The vendor rates it CVSS 4.0 base 5.1, and the assessed impact is confined to the victim's session (S:C/C:L/I:L, no server-side confidentiality, integrity or availability impact). No public exploit was identified at time of analysis and there is no KEV listing; priority is routine (this_month).
Stored cross-site scripting in AM System's Alo Suite lets an authenticated user persist JavaScript through the 'Nombre' field of the delivery note / PDF template editor at /PlantillasPdf/Edit/1273129, which then runs in the browser of any other user who opens the affected record. The vendor-agnostic CPE entry (cpe:2.3:a:am_system:alo_suite:*:*:*:*:*:*:*:*) gives no version boundary, so all deployments of the affected module should be treated as potentially exposed until the vendor confirms a fixed release. Impact is confined to the victim's browser session in the application context (VC:N/VI:N/VA:N, SC:L/SI:L) and requires a second user to view the poisoned record; INCIBE rates it CVSS 4.0 5.1 (medium) and no public exploit code has been identified at time of analysis.
Stored cross-site scripting (CWE-79) in AM System Alo Suite lets an authenticated, low-privileged user persist JavaScript through the NombrePF field submitted to /Empresas/Create, which then executes in the browser of any user who later opens the affected company or delivery note record. Because the payload runs inside the victim's session, it can alter displayed content and perform actions as that user, although the vendor/NVD CVSS 4.0 score of 5.1 (AV:N/AC:L/AT:N/PR:L/UI:P, subsequent confidentiality and integrity Low) and our independent CVSS 3.1 assessment (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N) both keep the rating moderate: valid credentials and a second user viewing the stored record are prerequisites. No public exploit code was identified at time of analysis and the CVE is not in CISA KEV, so this is a this-month priority rather than an emergency.
Stored cross-site scripting in Alo Suite lets an authenticated user with access to /Inmuebles/Create persist JavaScript in the 'Nombre' field, which executes in another user's browser when that person views the affected delivery note or property record. The CVSS 4.0 base score is 5.1 (medium), and the issue is a scheduled, this-month remediation item; no public exploit was identified at time of analysis, and exploitation requires valid low-privilege credentials plus a victim viewing the poisoned record.
Stored cross-site scripting (CWE-79) in AM System's Alo Suite lets an authenticated low-privilege user plant JavaScript in the 'Nombre' field reached through the /Familias/Edit/{id} endpoint of the delivery-note functionality; the script is persisted without adequate sanitization and executes in the browser of any other user who later opens the poisoned record. Because the payload runs in the victim's authenticated session context, it can alter displayed content and perform actions as that user, although impact is confined to the victim's browser (scope change limited to low confidentiality and integrity). Exploitation is not remote-unauthenticated: it requires a valid low-privilege account to write the field plus a second user who views the record; no public exploit code and no CISA KEV active-exploitation listing were identified at the time of analysis, and the vendor priority signal rates it as an issue to handle this month.
Stored cross-site scripting in AM System's Alo Suite lets authenticated users with access to the current-accounts creation function persist JavaScript in the 'Nombre' field of delivery-note records, where it executes in another user's browser when that record is viewed. The issue is medium severity (CVSS 5.1, CVSS 4.0; CWE-79) and requires both a valid low-privileged account and victim interaction, so the payload does not fire automatically or affect unauthenticated users. Impact is limited to the victim's browser session (SC:L/SI:L), with no stated effect on the server's own confidentiality, integrity, or availability; no public exploit was identified at time of analysis.
Stored cross-site scripting in AM Systems Alo Suite lets an authenticated user with write access to the 'Codigo' field of the '/CategoriasFicheros/Edit/{id}' endpoint persist JavaScript that later executes in other users' browsers when they open the affected delivery-note record. The injected script runs in the victim's session context, allowing the attacker to alter displayed content and perform actions as that user; there is no direct server-side confidentiality, integrity or availability impact. Rated CVSS 4.0 base 5.1 (assessed CVSS 3.1 vector AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N), it requires a valid account with access to this feature plus victim interaction, and no public exploit code or active exploitation has been identified at time of analysis; priority is this_month.
Stored cross-site scripting in Alo Suite lets authenticated users with article or delivery-note creation rights inject JavaScript through the Nombre parameter of /Articulos/Create, and the script executes in the browser of another user who later views the affected record. The reported CVSS 4.0 base score is 5.1 (medium), with the independent assessment scoring it CVSS 3.1 AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N. Impact is limited to the victim's browser session, and no public exploit was identified at time of analysis.
Stored cross-site scripting in Alo Suite's delivery note editor allows a user who can edit delivery notes to persist JavaScript through the ReferenceOtherParty field on the /Documents/DeliveryNotes/Edit/{id} endpoint, which then executes in the browser of any other user who opens the affected record. The vendor rates it CVSS 4.0 base 5.1 and our assessment scores it CVSS 3.1 6.1 with scope change, reflecting that impact is confined to the victim's browser session (content modification and actions performed as that user) rather than the server. Exploitation requires an authenticated low-privilege account plus a second user viewing the tampered note; no public exploit code or CISA KEV entry was identified at time of analysis, and the priority label is 'this_month' rather than an emergency.
Clickjacking in the AM Systems Alo Suite web application lets an attacker embed the login interface inside an attacker-controlled page and trick a victim into clicking disguised controls, so the practical impact is tampering with user interactions rather than disclosure of data. Deployments are exposed when the login page is served without X-Frame-Options or a Content-Security-Policy frame-ancestors directive; the CPE entry carries a wildcard version, so no specific release range is pinned in the available data. Severity is moderate (CVSS 4.0 base 5.1, integrity-only impact rated Low, active user interaction required), the issue is not listed in CISA KEV, and no public exploit code was identified at time of analysis.
Path traversal (CWE-22) in Tanium Data Service, with Tanium Interact also listed among the affected components, allows a high-privileged, authenticated attacker reaching the service over the network to manipulate files in a way that compromises integrity (rated High) and, to a lesser degree, availability (Low), with no confidentiality impact. Tanium reports it has addressed the issue in advisory TAN-2026-082, and the CVSS 3.1 base score is 5.0 (AV:N/AC:H/PR:H/UI:N/S:U/C:N/I:H/A:L). No public exploit code or confirmed active exploitation was identified at time of analysis, and the vuln.today priority decision places it in the this_month remediation cadence rather than an emergency one.
SQL injection in WooCommerce Multilingual & Multicurrency with WPML up to and including 5.5.7 lets an authenticated attacker with Shop Manager-level access or above store a crafted currency exchange-rate value that is later concatenated into an ORDER BY clause, allowing additional SQL queries to read sensitive database contents. The weakness is confidentiality-only and requires the plugin to be active with multicurrency configured; no public exploit or CISA KEV entry was identified at time of analysis. CVSS 4.9 reflects the high privilege prerequisite rather than low real-world exposure.
WSO2 Identity Server and the related WSO2 Carbon OAuth family of products will issue OAuth2 access tokens for JWT Bearer and SAML2 Bearer grant requests even when the federated Identity Provider (IDP) that vouched for the assertion has been disabled, because the IDP's enabled state is not re-validated before the token is minted. Remote unauthenticated attackers can exploit this only if they already hold a valid assertion issued by that now-disabled IDP, which is why the vendor rates it CVSS 4.8 with high attack complexity (AC:H) and limited confidentiality/integrity impact. It is not listed in CISA KEV and no public exploit has been identified at time of analysis, but the priority label is this_month, so it warrants scheduling rather than emergency response.
pybddisasm 0.3.0 and earlier can disclose residual process memory to any consuming application that reads an INSTRUX object returned by a failed instruction decode. The four decode entry points leave the returned object uninitialized when decoding fails, including failures caused by invalid parameters, so an application that surfaces those members after a failure may expose leftover heap or stack contents; a caller that checks the decode status first is unaffected. The package is unmaintained with no fixed release, the vector is local and privilege-gated with confidentiality-only impact, and no public exploit has been identified at time of analysis.
Out-of-bounds reads in the pybddisasm Python bindings for the Bitdefender disassembler can expose up to roughly 15 bytes of adjacent process memory when an integrating application decodes a buffer that is shorter than the length it declares. nd_decode may read up to 15 bytes regardless of the actual Python buffer length, while nd_decode_ex, nd_decode_ex2, and nd_decode_with_context pass a caller-supplied size to the decoder without checking it against the real buffer, and nd_get_instrux_bytes then returns a fixed 16-byte list that can carry the leaked bytes. Exploitation is not self-contained: it requires a host application to make these calls with mismatched buffer/length arguments and to surface the decoded bytes to an attacker, and the affected package is no longer maintained, so fix responsibility falls to integrators. All quantitative signals point to a modest, non-urgent issue; no public exploit code and no confirmed active exploitation were identified at time of analysis.
Stored cross-site scripting in AWS Amplify's maplibre-gl-js-amplify library (versions through 4.0.2) lets an authenticated user who can write location or geofence data persist an HTML/JavaScript payload that later executes in a different user's browser session when the affected map popup or geofence list item is rendered. The vulnerable sinks are the GeoJSON feature properties title, address and place_name used by popupRender, plus the geofenceId value rendered in AmplifyGeofenceControl list items and the delete-confirmation prompt; the payload fires only when a victim interacts with the element, such as clicking the marker or opening/deleting a geofence entry, so this is not a drive-by issue. No public exploit code or active exploitation has been identified at time of analysis, and the vendor-released patch is version 4.0.3, which escapes the affected values via a new escapeHtml() utility.
An out-of-bounds read in wlroots's XWayland window-management code (read_surface_class() in xwayland/xwm.c) lets a local X11 client leak a small amount of compositor heap memory by setting a WM_CLASS property whose instance string is NUL-terminated but whose class string is not. All wlroots releases before 0.20.2 are affected, but only when the compositor runs with XWayland support active and an attacker already has a local client inside that session. The over-read bytes are surfaced back as the window class or app_id over IPC, giving confidentiality-only exposure with no integrity or availability impact; the vendor shipped a fix in 0.20.2, and no public exploit code was identified at time of analysis.