A flaw in the binding process of Govee’s cloud platform and devices allows a remote attacker to bind an existing, online Govee device to the attacker’s account, resulting in full control of the device and removal of the device from its legitimate owner’s account.
The server‑side API allows device association using a set of identifiers: "device", "sku", "type", and a client‑computed "value", that are not cryptographically bound to a secret originating from the device itself.
The vulnerability has been verified for the Govee H6056 - lamp device in firmware version 1.08.13, but may affect also other Govee cloud‑connected devices. The vendor is investigating other potentially affected models.
The vendor has deployed server-side security enhancements and automatic firmware updates for model H6056. Most of H6056 devices have been successfully patched through automatic updates. Remaining H6056 users with upgradeable hardware versions must manually update firmware through the Govee Home app while keeping their device WiFi-connected. Users should open the Govee Home app, tap their H6056 device card to enter the device details page, tap the settings icon in the upper right corner, navigate to Device Information section (Firmware Version), and tap the Update button to install the security patch immediately.
Govee H6056 devices with hardware versions 1.00.10 or 1.00.11 cannot receive firmware update due to hardware limitations.
Open OnDemand provides remote web access to supercomputers. In versions 4.0.8 and prior, the Apache proxy allows sensitive headers to be passed to origin servers. This means malicious users can create an origin server on a compute node that record these headers when unsuspecting users connect to it. Maintainers anticipate a patch in a 4.1 release. Workarounds exist for 4.0.x versions. Using `custom_location_directives` in `ood_portal.yml` in version 4.0.x (not available for versions below 4.0) centers can unset and or edit these headers. Note that `OIDCPassClaimsAs both` is the default and centers can set `OIDCPassClaimsAs ` to `none` or `environment` to stop passing these headers to the client. Centers that have an OIDC provider with the `OIDCPassClaimsAs` with `none` or `environment` settings can adjust the settings using guidance provided in GHSA-2cwp-8g29-9q32 to unset the mod_auth_openidc_session cookies.
CVE-2025-14764 is a medium-severity vulnerability in the Amazon S3 Encryption Client for Go involving the use of a broken or risky cryptographic algorithm due to missing cryptographic key commitment. This flaw allows a user with write access to an S3 bucket to introduce a new encrypted data key (EDK) that decrypts to different plaintext when the encrypted data key is stored in an instruction file rather than S3 metadata. The vulnerability does not impact confidentiality but can compromise data integrity by enabling unauthorized data manipulation. Exploitation requires network access, low privileges (write access), and no user interaction, with a CVSS score of 5.3. AWS has addressed this issue in version 4.0 or later of the S3 Encryption Client for Go. European organizations using vulnerable versions should upgrade promptly to prevent potential data integrity attacks, especially those relying on instruction file storage for encrypted data keys. Countries with significant AWS usage and cloud adoption, such as Germany, the UK, France, and the Netherlands, are most likely to be affected.
Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js. Prior to versions 8.6.2 and 9.1.1-alpha.1, the Instagram authentication adapter allows clients to specify a custom API URL via the `apiURL` parameter in `authData`. This enables SSRF attacks and possibly authentication bypass if malicious endpoints return fake responses to validate unauthorized users. This is fixed in versions 8.6.2 and 9.1.1-alpha.1 by hardcoding the Instagram Graph API URL `https://graph.instagram.com` and ignoring client-provided `apiURL` values. No known workarounds are available.
A memory leak vulnerability in the Linux kernel's SMB client component (cifs_construct_tcon) has been fixed. The issue occurs during multiuser mounts with a specified domain using cifscreds, where domainname is set without proper freeing, causing a memory leak. This flaw was detected by kmemleak and affects certain linux-aws kernel versions. A patch is available to address this issue.
CVE-2025-13152 is a high-severity DLL hijacking vulnerability in Lenovo One Client that allows a local authenticated user to execute code with elevated privileges. The flaw arises from an uncontrolled search path element, enabling attackers to load malicious DLLs. Exploitation requires local access and no user interaction, but no known exploits are currently in the wild. The vulnerability impacts confidentiality, integrity, and availability due to privilege escalation potential. European organizations using Lenovo One Client are at risk, especially in countries with high Lenovo market penetration and critical infrastructure reliance on this software. Mitigation involves applying vendor patches once available, restricting local user permissions, and monitoring for suspicious DLL loads. Given the CVSS 8.5 score, this vulnerability demands prompt attention to prevent potential lateral movement or system compromise. No authentication bypass or remote exploitation is possible, but the elevated privileges gained can lead to significant damage.
Client-side template injection (CSTI) in Azuriom CMS admin dashboard allows a low-privilege user to execute arbitrary template code in the context of an administrator's session. This can occur via plugins or dashboard components that render untrusted user input, potentially enabling privilege escalation to an administrative account. Fixed in Azuriom 1.2.7.
CVE-2025-66570 is a critical authentication bypass vulnerability in versions of the yhirose cpp-httplib library prior to 0.27.0. The flaw allows attacker-controlled HTTP headers (REMOTE_ADDR, REMOTE_PORT, LOCAL_ADDR, LOCAL_PORT) to be injected and influence server-side metadata, logging, and authorization decisions due to header shadowing. Because the library processes client headers before adding its own internal metadata headers with the same names, downstream code that retrieves header values uses attacker-supplied data, enabling IP spoofing, log poisoning, and authorization bypass without authentication or user interaction. This vulnerability affects any server using vulnerable cpp-httplib versions and can lead to full compromise of confidentiality and integrity. The issue is fixed in version 0.27.0. European organizations using cpp-httplib in web services should urgently update to mitigate risk.
In the Linux kernel, the following vulnerability has been resolved: fuse: fix livelock in synchronous file put from fuseblk workers I observed a hang when running generic/323 against a fuseblk server. This test opens a file, initiates a lot of AIO writes to that file descriptor, and closes the file descriptor before the writes complete. Unsurprisingly, the AIO exerciser threads are mostly stuck waiting for responses from the fuseblk server: # cat /proc/372265/task/372313/stack [<0>] request_wait_answer+0x1fe/0x2a0 [fuse] [<0>] __fuse_simple_request+0xd3/0x2b0 [fuse] [<0>] fuse_do_getattr+0xfc/0x1f0 [fuse] [<0>] fuse_file_read_iter+0xbe/0x1c0 [fuse] [<0>] aio_read+0x130/0x1e0 [<0>] io_submit_one+0x542/0x860 [<0>] __x64_sys_io_submit+0x98/0x1a0 [<0>] do_syscall_64+0x37/0xf0 [<0>] entry_SYSCALL_64_after_hwframe+0x4b/0x53 But the /weird/ part is that the fuseblk server threads are waiting for responses from itself: # cat /proc/372210/task/372232/stack [<0>] request_wait_answer+0x1fe/0x2a0 [fuse] [<0>] __fuse_simple_request+0xd3/0x2b0 [fuse] [<0>] fuse_file_put+0x9a/0xd0 [fuse] [<0>] fuse_release+0x36/0x50 [fuse] [<0>] __fput+0xec/0x2b0 [<0>] task_work_run+0x55/0x90 [<0>] syscall_exit_to_user_mode+0xe9/0x100 [<0>] do_syscall_64+0x43/0xf0 [<0>] entry_SYSCALL_64_after_hwframe+0x4b/0x53 The fuseblk server is fuse2fs so there's nothing all that exciting in the server itself. So why is the fuse server calling fuse_file_put? The commit message for the fstest sheds some light on that: "By closing the file descriptor before calling io_destroy, you pretty much guarantee that the last put on the ioctx will be done in interrupt context (during I/O completion). Aha. AIO fgets a new struct file from the fd when it queues the ioctx. The completion of the FUSE_WRITE command from userspace causes the fuse server to call the AIO completion function. The completion puts the struct file, queuing a delayed fput to the fuse server task. When the fuse server task returns to userspace, it has to run the delayed fput, which in the case of a fuseblk server, it does synchronously. Sending the FUSE_RELEASE command sychronously from fuse server threads is a bad idea because a client program can initiate enough simultaneous AIOs such that all the fuse server threads end up in delayed_fput, and now there aren't any threads left to handle the queued fuse commands. Fix this by only using asynchronous fputs when closing files, and leave a comment explaining why.
Virtual Network Computing (VNC) is a remote display system which allows users to view a computing desktop environment not only on the machine where it is running, but from anywhere on the Internet and from a wide variety of machine architectures. TigerVNC is a suite of VNC servers and clients.
Security Fix(es):
* xorg: xmayland: Use-after-free in XPresentNotify structure creation (CVE-2025-62229)
* xorg: xwayland: Use-after-free in Xkb client resource removal (CVE-2025-62230)
* xorg: xmayland: Value overflow in XkbSetCompatMap() (CVE-2025-62231)
For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.
The HashJack attack leverages the URL fragment identifier ('#') to manipulate AI-powered browser behavior, potentially allowing attackers to influence how AI browsers process and render web content. This technique exploits the way AI browsers interpret URL fragments, which are typically client-side and not sent to servers, to inject commands or control instructions. While no known exploits are currently active in the wild, the attack vector poses a medium severity risk due to its potential to affect confidentiality and integrity without requiring authentication or significant user interaction. European organizations using AI-integrated browsers or web applications that rely on AI for content rendering or decision-making could be impacted, especially those in sectors with high AI adoption. Mitigation involves updating AI browser software to properly sanitize and validate URL fragments, implementing strict input handling, and monitoring for unusual AI browser behaviors. Countries with advanced digital infrastructure and high AI technology adoption, such as Germany, France, the UK, and the Netherlands, are more likely to be affected. Given the medium severity, organizations should proactively assess their exposure and apply targeted mitigations to prevent exploitation.
Fugue is a unified interface for distributed computing that lets users execute Python, Pandas, and SQL code on Spark, Dask, and Ray with minimal rewrites. In version 0.9.2 and prior, there is a remote code execution vulnerability by pickle deserialization via FlaskRPCServer. The Fugue framework implements an RPC server system for distributed computing operations. In the core functionality of the RPC server implementation, I found that the _decode() function in fugue/rpc/flask.py directly uses cloudpickle.loads() to deserialize data without any sanitization. This creates a remote code execution vulnerability when malicious pickle data is processed by the RPC server. The vulnerability exists in the RPC communication mechanism where the client can send arbitrary serialized Python objects that will be deserialized on the server side, allowing attackers to execute arbitrary code on the victim's machine. This issue has been patched via commit 6f25326.
This update for valkey fixes the following issues:
Update to 8.0.6:
- Security fixes:
- CVE-2025-49844: Fixed that a Lua script may lead to remote code execution (bsc#1250995)
- CVE-2025-46817: Fixed that a Lua script may lead to integer overflow and potential RCE (bsc#1250995)
- CVE-2025-46818: Fixed that a Lua script can be executed in the context of another user (bsc#1250995)
- CVE-2025-46819: Fixed LUA out-of-bound read (bsc#1250995)
- Bug fixes:
* Fix accounting for dual channel RDB bytes in replication stats (#2614)
* Fix EVAL to report unknown error when empty error table is provided (#2229)
* Fix use-after-free when active expiration triggers hashtable to shrink (#2257)
* Fix MEMORY USAGE to account for embedded keys (#2290)
* Fix memory leak when shrinking a hashtable without entries (#2288)
* Prevent potential assertion in active defrag handling large allocations (#2353)
* Prevent bad memory access when NOTOUCH client gets unblocked (#2347)
* Converge divergent shard-id persisted in nodes.conf to primary's shard id (#2174)
* Fix client tracking memory overhead calculation (#2360)
* Fix RDB load per slot memory pre-allocation when loading from RDB snapshot (#2466)
* Don't use AVX2 instructions if the CPU doesn't support it (#2571)
* Fix bug where active defrag may be unable to defrag sparsely filled pages (#2656)
Changes from 8.0.5:
https://github.com/valkey-io/valkey/releases/tag/8.0.5
SCIM provisioning was introduced in Grafana Enterprise and Grafana Cloud in April to improve how organizations manage users and teams in Grafana by introducing automated user lifecycle management.
In Grafana versions 12.x where SCIM provisioning is enabled and configured, a vulnerability in user identity handling allows a malicious or compromised SCIM client to provision a user with a numeric externalId, which in turn could allow to override internal user IDs and lead to impersonation or privilege escalation.
This vulnerability applies only if all of the following conditions are met:
- `enableSCIM` feature flag set to true
- `user_sync_enabled` config option in the `[auth.scim]` block set to true
CVE-2025-63879 is a reflected cross-site scripting (XSS) vulnerability found in the /ecommerce/products.php component of E-commerce Project v1.0 and earlier. Attackers can inject malicious JavaScript code via the 'id' parameter, which executes in the context of a user's browser when they visit a crafted URL. This vulnerability requires user interaction, such as clicking a malicious link, and does not require authentication. The CVSS score is 6.1 (medium severity), reflecting limited impact on confidentiality and integrity but no impact on availability. Although no known exploits are currently in the wild, the vulnerability poses a risk of session hijacking, credential theft, or other client-side attacks. European organizations using this e-commerce platform should prioritize patching or mitigating this issue to protect their customers. Countries with significant e-commerce activity and adoption of this platform are at higher risk.
CVE-2025-63883 is a DOM-based cross-site scripting (XSS) vulnerability in the electic-shop v1.0 e-commerce platform. The vulnerability arises because client-side JavaScript unsafely inserts attacker-controlled input into the DOM using innerHTML, insertAdjacentHTML, or document.write without proper sanitization or encoding. An attacker can craft a malicious URL that executes arbitrary JavaScript in the victim's browser under the electic-shop origin when visited. This vulnerability requires user interaction (clicking the malicious link) but does not require authentication. The CVSS score is 5.4 (medium severity), reflecting limited confidentiality and integrity impact and no availability impact. No known exploits are currently reported in the wild. European organizations using electic-shop v1.