Incorrect authorization of exec requests in the openclaw macOS app leads to arbitrary code execution risk
The vulnerability stems from a logic flaw in how the macOS app runtime handles exec approval requests. Even when an allowlist and manual confirmation policy are configured, the app still automatically resolves unauthorized commands as "allow once". An attacker can trigger this behavior over the network without user interaction, bypassing gateway-side security interception, so arbitrary system commands execute silently on the victim host and integrity and availability are severely compromised.
Component
OpenClaw is an automation system that integrates agent orchestration and device control. Its macOS client joins the gateway architecture as an edge node, handles execution instructions from the central agent, and uses the local runtime to perform hardware-level interactions such as screen snapshots and system command execution. It aims to extend what intelligent agents can do on the host operating system while keeping policies consistent.
Fix the approval decision logic in the client runtime so that the preset security policy is strictly enforced, prohibit automatic approval of commands not on the allowlist, and add a second verification of the approval state to prevent unintended authorization.
CSSA Exclusive Early Warning
10.0 Critical
Missing authorization in the open-lovable API leads to arbitrary command execution and data disclosure
An attacker can exploit the lack of authentication and session checks on every route endpoint under the `app/api/` directory to send malicious HTTP requests directly without any credentials. Because the system stores the current active sandbox state in a single global variable `global.activeSandbox` without user isolation, an attacker can craft specific JSON payloads to execute arbitrary commands, read sensitive files, or inject malicious code, causing cross-tenant data disclosure, integrity damage, and denial of service that seriously affect system security.
Component
open-lovable is an AI-assisted development platform built on Next.js. By integrating cloud sandbox technologies such as Vercel Sandbox or E2B, it provides automated code generation, environment configuration, and application deployment. Its core components use a RESTful API design that supports creating sandbox instances, executing system commands, reading and writing files, and installing dependencies, and global state management coordinates concurrent multi-user requests for efficient multi-tenant resource sharing and workflow automation.
Developers should add strict authentication middleware at API entry points and enforce access control based on session tokens or API keys. The state management mechanism should also be refactored to replace the globally shared variable with independent context storage keyed by user ID or session ID, so that requests from different users are isolated and unauthorized access is prevented.
CSSA Exclusive Early Warning
10.0 Critical
Missing authentication and URL validation in a Supabase Studio endpoint enable unauthenticated SSRF to obtain sensitive internal data
An attacker can send unauthenticated requests to the /api/edge-functions/test endpoint. Because the URL validation logic in self-hosted environments only checks the path format and ignores hostname restrictions, the attacker can point the target at internal services or cloud metadata addresses and, combined with custom HTTP headers, obtain the full response, leading to disclosure of the internal network topology and theft of sensitive information.
Component
Supabase is an open-source Backend-as-a-Service platform. Its Studio component is the core management interface, providing visual database management and edge function development and testing. It aims to simplify how developers configure, monitor, and debug cloud-native backend services, enabling efficient data interaction and service orchestration through an integrated web console.
Enforce strict authentication on all API endpoints, validate request target hostnames against an allowlist on the server side, prohibit resolving arbitrary IP addresses or unexpected domains, and deploy network-layer access control to block illegitimate probing of sensitive internal resources.
CVE Intelligence
3
CVE-2026-102693
CVSS
10.0 Critical
2026-10-17
Input validation bypass in generic applications leads to remote code execution
In affected applications, a flaw in the security check mechanism allows an attacker to bypass validation with specially crafted input and execute arbitrary code. With carefully crafted input data, an attacker can break through the application's security boundary and directly trigger remote code execution (RCE). Because public proof-of-concept (PoC) code exists and the vulnerability has been exploited, it poses a serious threat to system security. The attacker needs no complex preconditions; sending a crafted request to the target application is enough to trigger the vulnerability, which may lead to full server takeover, data disclosure, or service interruption. All application deployments without mitigations are affected. The attack can be launched remotely over the network, and malicious code can be executed without user interaction.
Component
Affected applications typically include input processing modules that receive and handle external data; without strict input validation and sanitization, they are susceptible to this type of attack.
Risks
From ordinary user to administrator: If the victim runs the application with administrator privileges, the attacker can obtain the same privileges
Complete system control: An attacker can execute arbitrary code on the victim system and, depending on user privileges, install programs, view/change/delete data, or create new fully privileged accounts
No user interaction: The vulnerability is triggered directly with crafted input, so the attacker can achieve remote code execution without luring the user into any further action
Implement strict input validation and filtering to reject illegal or malformed data
Enable a Web Application Firewall (WAF) to intercept known malicious input patterns
CVE-2026-110957
CVSS
10.0 Critical
2026-10-15
Remote OS command injection in Wavlink WL-WN530BE2-A leads to remote code execution
In Wavlink WL-WN530BE2-A (versions up to M30BE2_V250604), the function sub_12580 in the api.cgi file of the Login Processing component mishandles the REMOTE_ADDR parameter, resulting in an OS command injection (CWE-77) flaw. An attacker can send requests remotely and exploit this vulnerability to execute arbitrary commands on the underlying operating system. The exploitation method has been publicly disclosed and may be used. Affected devices include all Wavlink WL-WN530BE2-A units not updated to version 2026-09-24-841a51c6d5_tclinux.bin. An attacker can control the device remotely without authentication, so the risk is extremely high.
Component
Wavlink WL-WN530BE2-A is a wireless network adapter device that provides network connectivity; its firmware includes components that handle login and API requests.
Risks
Complete system control: An attacker can execute arbitrary system commands on the victim device and gain full control of it
Remote unauthenticated attack: An attacker needs no credentials or user interaction; sending a crafted request over the network is enough to trigger the vulnerability
Data disclosure and tampering: An attacker can read, modify, or delete sensitive data on the device, or implant malware
Immediately upgrade the firmware to version 2026-09-24-841a51c6d5_tclinux.bin or later
Block unnecessary external access to the device's api.cgi endpoint at the firewall or network perimeter
Monitor device logs for anomalous command execution or connection attempts from unknown sources
CVE-2026-34006
CVSS
10.0 Critical
2026-10-15
Missing authentication for critical functions in sMedio DTCP MOVE leads to remote system access
In sMedio DTCP MOVE versions before 1.4.5, critical function modules lack an authentication mechanism, resulting in a missing authentication for critical function (CWE-306) flaw. A remote attacker can exploit this vulnerability to bypass security restrictions and gain system access directly. sMedio DTCP MOVE does not enforce effective identity checks on critical operation interfaces, so an attacker can trigger the flaw remotely over the network, leading to unauthorized system access or control. All sMedio DTCP MOVE users not updated to 1.4.5 are affected. An attacker can exploit the vulnerability remotely without any user interaction, directly threatening system integrity and confidentiality.
Component
sMedio DTCP MOVE is a device or software component that supports transfer and moving of digital rights management (DRM) content, commonly used for protecting and distributing media content.
Risks
From ordinary user to administrator: If the system is misconfigured, an attacker who gains access may escalate privileges to administrator level
Complete system control: An attacker can perform arbitrary operations on the victim system and, depending on access privileges, view/change/delete data or install malicious programs
No user interaction: An attacker only needs to send specific requests over the network to trigger the vulnerability, with no clicks or interaction from the target user
Immediately upgrade sMedio DTCP MOVE to 1.4.5 or later
Restrict network access to the component's critical ports so that only trusted IP addresses can connect
Deploy an intrusion detection system (IDS) to monitor for anomalous authentication bypass attempts or unauthorized access
Package Poisoning
2
Package Poisoning
npm2026-10-16
asistenyorstore@>= 0
flagged as malicious
This version was found communicating with a malicious domain and executing malicious commands. Audit your dependencies and pin safe versions immediately.
MD5
617277688539a34c74900285f6ca8127
Package Poisoning
npm2026-10-16
xmd-baileys@>= 0
flagged as malicious
This version was found communicating with a malicious domain and executing malicious commands. Audit your dependencies and pin safe versions immediately.
