The FrodoBots EarthRover Mini+ firmware version 6.2.4_6.2.5_0.614.0 has an insecure firmware update mechanism. The STM32 motor-controller firmware is downloaded over unencrypted HTTP, and integrity is only checked using MD5 with the hash provided in the same unprotected response. There is no code-signing implemented, which allows an attacker to replace the firmware with malicious code.
GALENO SISTEMI MAGISTRA version 3.12 has a vulnerability where the software downloads upgrade files without performing integrity checks. This flaw allows the installation of tampered updates, potentially compromising the system.
CompuGroup Medical Wingesfar versions prior to 10.2.1 implement software update functionality without adequate authenticity and integrity validation. This allows update packages to be accepted without sufficient cryptographic verification, potentially enabling malicious code to be installed during updates.
CVE-2026-118462 is a critical vulnerability in CompuGroup Medical Infantia where update components download and execute code without proper authenticity verification. The update process relies on ignored hashes or forgeable checksums, allowing potential execution of unauthorized code. Some update paths also permit archive traversal or script execution, increasing the risk of malicious payload delivery.
Missing integrity verification in the Progress Software Fiddler Download and Setup Skill on Linux, macOS, and Windows which allows an attacker to compromise or influence a release component and execute attacker-controlled code when a user runs the skill. On macOS, the skill stages the package at a predictable path and installs it with administrator privileges, which may allow code execution with root privileges after user approval. A local process may also replace the staged macOS package while the skill waits for approval.
Node Version Manager (nvm) is a POSIX-compliant shell function for managing multiple node.js versions. In versions 0.40.5 through 0.40.8, `nvm_download_artifact` downloads a release archive directly to its final path in `$NVM_DIR/.cache` and verifies its checksum afterwards; on a checksum mismatch it reports an error but leaves the rejected archive in place. A later `nvm install --offline` of the same version installs that cached file without a checksum, so an archive that was just rejected gets installed and its `node` and `npm` run. This gives code execution to a party who can alter the downloaded tarball (for example a poisoned CDN or cache object) but cannot also forge the `SHASUMS256.txt` beside it, if the victim runs `nvm install --offline` for that version after the visible "Checksums do not match" failure and before any online retry. Version 0.41.0 only puts an archive in the cache once its checksum has passed.
The PFI plugin framework deploys executable assemblies (DLLs) from a signed plugin package into the local plugin repository and loads them via reflection, but the deployment routine processes archive entries that were never covered by the signature verification. An unauthenticated local attacker can replace an unsigned DLL outside the signed prefix in the archive passes verification and overwrites the legitimate signed assembly at the same destination path. The plugin loader then instantiates the attacker-supplied code without any additional integrity check resulting in a full compromise of the affected systems.
CVE-2026-113717 is a low-severity vulnerability in pypa virtualenv versions prior to 21.14.9. It involves a bypass of the integrity check for downloaded code when using the --seeder pip --download option, allowing pip to select a package from the configured index without verifying its SHA-256 digest against PyPI metadata. This issue does not break TLS security or allow control over the index response. The vulnerability is fixed in version 21.14.9.
EnergizeLab Robot firmware (mode 104000), including the AI Station firmware, EilikO Linux robot firmware v2.1_20260617182218_release, and EnergizeLab Windows desktop app 3.1.2, download firmware updates over unencrypted HTTP without verifying their integrity or authenticity. This allows an attacker who can intercept or modify network traffic to substitute malicious firmware updates.
CVE-2026-93649 is a high-severity vulnerability in the Eclipse Foundation Adoptium Temurin website. The issue arises from improper validation of a redirect URL on the post-download page, which uses a naive string prefix check vulnerable to bypass via dot-segment normalization. This allows an attacker to craft a URL that appears to redirect to a trusted domain but actually leads to an attacker-controlled location, causing users to unknowingly download malicious binaries.
The plugin install flow in Claude Code and Claude Desktop checked out a marketplace's pinned commit SHA using `git checkout` without verifying that the resulting HEAD matched the pinned SHA. An attacker controlling a plugin's upstream repository could create a branch named identically to the pinned 40-character SHA, causing the checkout to silently resolve to the attacker's branch tip instead of the reviewed commit, resulting in attacker-controlled code being installed bypassing the pinned hash. Exploitation required a user to install a malicious plugin, pin to a safe hash, and for the plugin source to be hosted on a git host that permitted SHA-shaped branch names.
Users on standard Claude Code auto-update have received this fix already. Users performing manual updates are advised to update to the latest version.
Thank you to Or Nevo Michrowski of Air Security for reporting this issue.
nginx-ui versions 2.0.0 up to but not including 2.5.0 have a vulnerability in their self-upgrade mechanism where the binary and its checksum are downloaded from the same source without cryptographic signature verification. This allows an attacker controlling the download source or performing a man-in-the-middle attack on an HTTP proxy to substitute a malicious binary and matching digest, resulting in root code execution upon upgrade. The upgrade process replaces the running executable and restarts it as root. The vulnerability arises because integrity is only checked by comparing the binary's digest to a digest file fetched from the same origin, and the github_proxy setting accepts HTTP URLs, enabling cleartext interception. No official patch or fix is indicated in the provided data.
CVE-2026-29797 affects Red Lion Controls 700 Series devices by allowing firmware or bootloader updates without any authentication. This vulnerability enables attackers to push malicious files to the device easily. Additionally, attackers with the same software can scan networks for N-Tron devices and push or pull firmware using SNMP/TFTP without authentication.
DigitalCanion has discovered a vulnerability that allows an attacker to cause the system to load an attacker-controlled .so file instead of the expected legitimate module. The loading mechanism relies on a predictable module name without adequately verifying the file’s origin or integrity. A malicious shared object using the expected name can therefore be loaded by a privileged process. The module code then executes within the context and privileges of that process. This results in arbitrary code execution and full compromise of the Mitel Linux virtual machine.
DigitalCanion has discovered a vulnerability in the backup restoration functionality that allows an attacker with access to the configured backup repository to introduce arbitrary files into the system during restoration.
The specific flaw exists within the backup restoration mechanism, which fails to properly validate the paths, file types, integrity, and authenticity of files contained within a restored TGZ archive. The application does not perform file-signature verification before extracting the archive, allowing a specially crafted backup to contain attacker-controlled files.
An attacker with access to the backup SFTP or other configured repository can therefore provide a malicious TGZ archive that, when restored by the system, may place arbitrary files on the underlying Linux system. Depending on the location and permissions of the extracted files, this behavior can potentially be leveraged to achieve arbitrary code execution with root privileges and compromise the underlying virtual machine.
The absence of enforced backup passwords further reduces the protection provided by the backup mechanism and may facilitate unauthorized access to the repository.
CVE-2026-55251 is a code injection vulnerability in the netbox-community devicetype-library repository. The issue arises because the continuous integration (CI) workflow executed code from pull requests before any maintainer review, allowing an unprivileged contributor to run arbitrary code on the CI runner by modifying certain configuration files. This vulnerability has been patched by commit f41fc1e.
`download_wheel()` runs `pip download` and hands the result straight to the seeder, with nothing checking the bytes it gets back. The embedded pip and setuptools wheels carry a `BUNDLE_SHA256` that virtualenv checks on every load, but a wheel fetched over the network for the periodic-update feature or the `--download` flag had no equivalent verification.
A compromised index, a stale mirror, or a MITM'd download (when TLS is intercepted, e.g. via a misconfigured or malicious CA) could substitute a different wheel under the same distribution/version/filename, and virtualenv would cache and seed it into every environment created afterward with no warning.
Fixed by computing the downloaded wheel's sha256 and comparing it against the digest PyPI's public JSON API reports for that exact release, independent of which index actually served the file. The check is skipped, not treated as failure, when a custom index (`PIP_INDEX_URL`, `PIP_EXTRA_INDEX_URL`, `PIP_INDEX`) is configured, since a private index can legitimately serve a different, intentionally rebuilt wheel. Fix: https://github.com/pypa/virtualenv/pull/3251
Dell Secure Connect Gateway (SCG) Policy Manager versions prior to 5.34.00.16 and prior to 5.36 contain a vulnerability where code is downloaded without an integrity check. This flaw could allow an unauthenticated remote attacker to execute code, disclose information, tamper with data, or bypass protection mechanisms. The vulnerability has a medium severity rating with a CVSS score of 4.7. No official patch or remediation details are provided in the available data.
The Reachy Mini daemon exposes an HTTP API for managing the robot. Its app installation endpoint, POST /apps/install in src/reachy_mini/daemon/app/routers/apps.py, has no authentication. The handler's only dependency is Depends(get_app_manager), which just hands back the manager object from application state, so nothing in the chain ever checks a credential.
The endpoint takes an AppInfo body naming a Hugging Face Space. The daemon downloads that Space and installs it as a Python package through install_package in src/reachy_mini/apps/sources/local_common_venv.py, using uv or pip. Installing a Python package runs the package's own build and setup code, so whoever chooses the Space chooses what code the robot runs. Anyone can publish a public Hugging Face Space, so this is not a meaningful restriction on the attacker.
How far this reaches depends on the model. In _resolve_bind_host in src/reachy_mini/daemon/app/main.py the daemon binds 0.0.0.0 when it runs as the wireless version and 127.0.0.1 otherwise, with the vendor's own comment explaining that the robot has to be reachable on the LAN. On a wireless unit, then, any host on the same network can install and run code on the robot without credentials.
One related change has already shipped but does not fix this. Version 1.8.2 replaced the wildcard CORS policy with an allow list of localhost and Tauri origins. That closes the browser drive-by route, where a web page the victim visits silently calls the endpoint in the background. It has no effect on this issue: CORS is enforced by browsers and governs whether script may read a response, while a direct HTTP request from another machine on the network involves no browser, no preflight and no CORS check at all.