betaFeedback

WorksComputer Science

Not an Accident: Exploiting Safety Filter Inadequacy in Humanoid Robots

Abstract

As humanoid robots move from research laboratories toward deployment in human-centered environments such as homes, hospitals, and warehouses, safe operation around nearby people and objects becomes a fundamental requirement. Safety filters have emerged as a promising technique to address this challenge by providing mathematical guarantees that generated control actions do not result in collisions. This paper shows that these guarantees hold only when the safety parameters are configured correctly. However, correct parameter configurations are task- and environment-specific, and no general method exists to determine them across diverse deployments. As a result, safety filters shipped with humanoid robots can fail after deployment in specific scenarios. We show that attackers can exploit these failures through only normal user interactions without any additional privileges or capabilities. To demonstrate this risk, we present goal insertion attacks and develop SIREN, an automated tool that identifies vulnerable inserting goals for a given task and environment. Experimental results show that SIREN identifies attacks in all vulnerable scenarios in the SPARK dataset. Compared with a baseline approach, SIREN discovers three times as many attacks. We also show that SIREN is able to generate attacks against a real humanoid and cause it to collide while executing tasks. These results demonstrate that current safety filters introduce exploitable vulnerabilities that can cause safety violations, which reveals that existing safety mechanisms can themselves become a source of safety risk for humanoid robots.

Introduction

As humanoid robots move into human-centered environments such as homes and hospitals, ensuring safe operation around people and objects becomes a fundamental requirement that one must meet, because even a single collision can cause physical injury, property damage, or disruption of critical tasks [49].

Safety filters have emerged as a promising approach to this challenge. They monitor the control generated by a robot’s nominal controller and intervene whenever the nominal control violates safety constraints. Optimization-based safety filters compute an alternative control by solving a constrained optimization problem based on formulations such as safety indices [28, 60], safe sets [15, 28], and control barrier functions (CBFs) [3, 4]. By construction, the resulting control satisfies the specified safety constraints whenever the optimization problem is feasible. Thanks to these guarantees, safety filters have attracted significant industrial interest and have entered pilot deployments in large industrial sectors.

However, existing safety filters can still fail to prevent collisions. One well-known limitation is safe control infeasibility [2, 16], where the underlying optimization problem admits no feasible solution and therefore no safe control exists.

We identify a second limitation that has received little attention. Existing safety filters rely on safety-related parameters whose correct values depend on both the task and the environment. Improper parameter configurations can cause the controller to generate controls that satisfy the optimization problem but nevertheless fail to maintain safety. Humanoid robots exacerbate both limitations, as their high-dimensional articulated bodies and operation in cluttered, dynamic environments make optimization infeasibility more likely [22, 40] and accurate parameter configuration significantly more difficult [57].

Worse, we discover that existing optimization-based safety filters only optimize the current control step. They neither predict future states nor account for future optimization feasibility. As a result, a controller may successfully resolve the current safety violation while simultaneously steering the robot toward a future state where no feasible recovery exists.

In this paper, we show that these limitations expose a previously unrecognized attack surface. An adversary can exploit them to steer a humanoid robot into a safety-inadequate state where the safety controller can no longer prevent collision. Unlike prior attacks that compromise software, spoof sensors, or manipulate low-level control signals, our attack requires only legitimate task requests submitted through the robot’s normal user interface. By carefully selecting intermediate goals or task locations, an attacker can intentionally drive the robot toward a safety-inadequate state that its safety filter cannot avoid.

We argue that this vulnerability has a real-world implication. Consider a bedside assistant robot deployed in a hospital. While the robot delivers medication to a patient, another patient or visitor requests that it also retrieve a glass of water or pick up medication from a nearby room. Because the request appears legitimate and authorized, the task planner naturally inserts it into the execution schedule. The synthesized intermediate goal then steers the robot toward a safety-inadequate state. Depending on the robot’s fail-safe strategy, the robot may fail the original task, collide with nearby people or medical equipment, or even fall during recovery [18]. Since every interaction is legitimate, such attacks are difficult to detect or attribute.

To assess the practicality and impact of this attack, we develop SIREN, short for Safe-control Inadequacy via Reachable-goal Exploitation Nexus. SIREN is an automated framework that identifies safety-inadequate states in a given scenario, which is a combination of an environment and a target task, and synthesizes adversarial task goals that steer the robot into those states. We evaluate SIREN against seven representative optimization-based safety filter algorithms, including Control Barrier Functions (CBFs) [4], Safe Set Algorithm (SSA) [28], Sublevel Safe Set (SSS) [52], and their variants [15]. The evaluation demonstrates successful attacks against every evaluated safety filter in both simulation and on a Unitree G1 humanoid robot. Compared with a random-search baseline, the Cross-Entropy Method (CEM) used by SIREN discovers 1.86x times of attacks in 35 vulnerable scenarios from SPARK, a popular testbed that includes a benchmark for safety filter evaluation [48].

In summary, this paper makes the following contributions:

  • We identify safe-control inadequacy as a previously unrecognized security vulnerability in optimization-based humanoid safety filters and show that attackers can exploit the vulnerability to cause safety issues such as collisions. To the best of our knowledge, this is the first security attack that targets optimization-based safety filters in humanoid robots.

  • We present goal insertion attacks and develop SIREN, an automated framework that discovers safety-inadequate robot states and synthesizes adversarial task goals through normal user interactions.

  • We evaluate SIREN against seven representative safety filter algorithms in simulation and on a Unitree G1 humanoid robot. The results show successful attacks against every evaluated safety filter, and that SIREN discovers 1.86x times as many attacks as identified by the random-search baseline.

Background and Related Work

Robotic Security

Prior work on robotic security has shown that robots expose attack surfaces across multiple layers of the software and hardware stack. Existing work identifies vulnerabilities in network services, firmware, communication middleware, sensors, actuators, and application interfaces [32, 55], while attacks such as industrial-robot ransomware demonstrate that software compromise can translate directly into unsafe physical behavior [33]. These risks have been studied across a wide range of robotic platforms. In autonomous vehicles, researchers have demonstrated attacks against in-vehicle networks and remote interfaces [12, 26], localization through sensor-fusion and GPS manipulation [44], and camera and LiDAR perception pipelines [10, 11, 47, 58]. In robotic vehicles, prior work has used fuzzing and simulation to identify policy, maneuver, and supply chain vulnerabilities [23, 24, 35, 46], and multi-robot systems are vulnerable to semantic attacks against collaborative navigation [56].

Humanoid robots introduce additional security challenges. Contrary to autonomous vehicles and conventional mobile robots, humanoids possess articulated bodies with high-dimensional state spaces, configuration-dependent collision geometry, and state-dependent control authority. These properties create attack opportunities beyond conventional software, communication, and perception vulnerabilities. Recent work has identified security issues in commercial humanoids, including authentication vulnerabilities in Bluetooth [37], Wi-Fi [38], and DDS-based communication [39], as well as privacy and telemetry risks in commodity humanoid platforms [30, 31]. However, little attention has focused on vulnerabilities in humanoid-specific control and mechanisms such as humanoid safety algorithms.

Robot Dynamics

Following common practice in nonlinear control [21], we model a humanoid as a robot system governed by control-affine dynamics. Let x∈X⊆RNx\mathbf{x} \in\mathcal{X} \subseteq\mathbb{R}^{N_x} denote the state of the robot, which is a high-dimensional vector that describes information relevant to the robot at a particular time, where X\mathcal{X} is the set of admissible states and NxN_x is the dimension of the state. Depending on the robot and control abstraction, the state may include quantities such as joint positions, joint velocities, and the position and orientation of the robot base. Similarly, let u∈U⊆RNu\mathbf{u} \in\mathcal{U} \subseteq\mathbb{R}^{N_u} denote the control input, or action, which specifies commands that affect the robot’s motion, such as desired joint velocities or accelerations, where U\mathcal{U} is the set of admissible controls and NuN_u is the dimension of the control input.

The evolution of the state under a control input is described by the control-affine dynamics

x˙=f(x)+g(x)u,u∈U,(1)\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\qquad\mathbf{u}\in\mathcal{U}, \tag*{(1)}

where f(x)\mathbf{f}(\mathbf{x}) describes the uncontrolled evolution of the system and g(x)\mathbf{g}(\mathbf{x}) characterizes how the control input affects the state. For example, under a first-order dynamics model, the state may consist of joint positions and u\mathbf{u} specifies joint velocities; under a second-order model, the state additionally contains joint velocities and u\mathbf{u} specifies joint accelerations.

Modern robotic systems typically employ a nominal controller or policy to generate actions for accomplishing a task. We denote its output as the reference control uref\mathbf{u}_{\mathrm{ref}}. The reference control represents the action that the robot would execute in the absence of an additional safety intervention. It may be produced by a conventional controller, such as a proportional-integral-derivative (PID) controller [5] or inverse kinematics [45], or by a learning-based policy [27]. In increasingly autonomous robotic systems, the task policy may also incorporate foundation models, e.g., vision-language-action (VLA) models [7, 9, 25], to interpret high-level observations and commands and ultimately produce or condition the robot’s reference actions. The reference controller is primarily responsible for task performance and need not itself enforce the safety constraints considered below.

Safety Filter Algorithms

A safety filter operates between the nominal policy and the robot actuators. Rather than replacing the nominal controller, it receives uref\mathbf{u}_{\mathrm{ref}} and produces a safe control usafe\mathbf{u}_{\mathrm{safe}} that closely resembles the reference action while satisfying safety requirements. This architecture separates task execution from safety enforcement and allows the same safety mechanism to operate on reference actions generated by different upstream controllers.

A broad family of model-based safety filters characterize safety through a scalar named safety index denoted by ϕ(x)\phi(\mathbf{x}). Following the convention used in the work in the robotics safety literature [28, 52], ϕ(x)≤0\phi(\mathbf{x})\leq0 represents the desired safe region, whereas ϕ(x)>0\phi(\mathbf{x})>0 indicates a safety violation. For MM simultaneous safety constraints, the desired safe set is

Xs={x∈X∣ϕ[i](x)≤0, ∀i∈[M]}.(2)\mathcal{X}_{s}=\left\{\mathbf{x}\in\mathcal{X}\mid\phi^{[i]}(\mathbf{x})\leq0,\ \forall i\in[M]\right\}. \tag*{(2)}

For collision avoidance, for example, a basic safety specification can be constructed from the distance d(x,O)d(\mathbf{x},O) between the robot and an obstacle OO and a required minimum separation dmin⁡d_{\min}.

At a high level, optimization-based safety filters solve

usafe=arg⁡min⁡u∥u−uref∥Qu2subject tox˙=f(x)+g(x)u,ϕ˙[i](x,u)≤ρ[i](ϕ[i](x)),∀i∈[M],u∈U,(3)\begin{aligned} \mathbf{u}_{\mathrm{safe}}&=\underset{\mathbf{u}}{\arg\min}\quad\lVert\mathbf{u}-\mathbf{u}_{\mathrm{ref}}\rVert_{Q_{\mathbf{u}}}^{2}\\ &\text{subject to}\quad\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\\ &\qquad\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq\rho^{[i]}(\phi^{[i]}(\mathbf{x})),\quad\forall i\in[M],\\ &\qquad\mathbf{u}\in\mathcal{U}, \tag*{(3)} \end{aligned}

where QuQ_{\mathbf{u}} weights deviations from the reference action and ρ(⋅)\rho(\cdot) specifies the safety algorithm’s constraint on the evolution of the safety index.

Note that a safety filter does not necessarily modify the reference control. When the safety index is below zero, e.g., the humanoid maintains a distance greater than dmin⁡d_{\min} from obstacles, the safety filter preserves the reference control, such that usafe=uref\mathbf{u}_{\mathrm{safe}}=\mathbf{u}_{\mathrm{ref}}. The safety filter modifies the reference control only when necessary to enforce the safety constraint. In this paper, we refer to a safety filter as being engaged when it actively modifies the reference control.

Intuitively, once the robot approaches or enters an unsafe region, the safety filter constrains how quickly the robot goes back to safe region, which, analytically, is how quickly ϕ\phi may drop. We refer to this as the escape rate: the required rate at which the controller drives the system away from a safety violation and toward the safe region. Different safety-filter families impose different escape rates, and their corresponding hyperparameters directly influence both the aggressiveness of safety intervention and the deviation from uref\mathbf{u}_{\mathrm{ref}}.

Safe Set Algorithm (SSA) The Safe Set Algorithm (SSA) activates corrective constraints when a safety index reaches or exceeds the boundary of the safe set [28, 60]. For multiple constraints, its optimization can be written as

min⁡u∥u−uref∥Qu2subject tox˙=f(x)+g(x)u,ϕ˙[i](x,u)≤−ηssa,if ϕ[i](x)>0,ϕ˙[i](x,u)≤0,if ϕ[i](x)=0,(4)\begin{aligned} \min_{\mathbf{u}}\quad&\lVert\mathbf{u}-\mathbf{u}_{\mathrm{ref}}\rVert_{Q_{\mathbf{u}}}^{2}\\ \text{subject to}\quad&\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\\ &\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq-\eta_{\mathrm{ssa}},\qquad\text{if }\phi^{[i]}(\mathbf{x})>0,\\ &\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq0,\qquad\text{if }\phi^{[i]}(\mathbf{x})=0, \tag*{(4)} \end{aligned}

for all i∈[M]i\in[M], where ηssa>0\eta_{\mathrm{ssa}}>0 controls the required decrease of the safety index after a violation. Thus, ηssa\eta_{\mathrm{ssa}} directly specifies an escape-rate requirement: increasing ηssa\eta_{\mathrm{ssa}} requires the system to reduce a positive safety index more rapidly and generally results in a stronger correction to the reference control.

Sublevel Safe Set Algorithm (SSS) A related method, the Sublevel Safe Set (SSS) algorithm, instead imposes

ϕ˙[i](x,u)≤−λsssϕ[i](x),if ϕ[i](x)≥0.(5)\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq-\lambda_{\mathrm{sss}}\phi^{[i]}(\mathbf{x}),\qquad\text{if }\phi^{[i]}(\mathbf{x})\geq0. \tag*{(5)}

where λsss>0\lambda_{\mathrm{sss}}>0 scales the required decrease of the safety index with the current magnitude of that index. Unlike the constant escape rate of SSA, SSS scales the required correction with the magnitude of the safety violation.

Control Barrier Function (CBF) Control Barrier Function (CBF) filters continuously constrain the evolution of the safety index [3, 4]. Using a linear class-K\mathcal{K} function, the constraint takes the form

ϕ˙[i](x,u)≤−λcbfϕ[i](x),∀i∈[M],(6)\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq-\lambda_{\mathrm{cbf}}\phi^{[i]}(\mathbf{x}),\qquad\forall i\in[M], \tag*{(6)}

where λcbf>0\lambda_{\mathrm{cbf}} > 0 controls the allowable evolution of ϕ\phi. The resulting safe action is obtained by minimizing the deviation from uref\mathbf{u}_{\mathrm{ref}} subject to Eq. (6). In contrast to SSA and SSS, the CBF constraint remains active even when ϕ<0\phi< 0. Consequently, λcbf\lambda_{\mathrm{cbf}} affects not only how the controller responds to violations but also how much freedom the nominal controller retains while the system is already inside the safe set. CBFs are related to barrier certificates [41] and have been analyzed for robustness under disturbances [54] and extended to discrete-time systems for bipedal robots [1].

Slack-Relaxed Filters (R-SSA, R-SSS, and R-CBF). The relaxed variants of SSA, SSS, and CBF introduce one non-negative slack variable sis_i for each safety constraint and optimize the control and slack variables jointly. Their common formulation is

min⁡u,s∥u−uref∥Qu2+ws∥s∥ppsubject tox˙=f(x)+g(x)u,ϕ˙[i](x,u)≤ρA(ϕ[i](x))+si,∀i∈IA,u∈U,s≥0,(7)\begin{aligned} \min_{\mathbf{u},\mathbf{s}}\quad&\lVert\mathbf{u}-\mathbf{u}_{\mathrm{ref}}\rVert_{Q_u}^{2}+w_s\lVert\mathbf{s}\rVert_p^p\\ \text{subject to}\quad&\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\\ &\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq\rho_A\left(\phi^{[i]}(\mathbf{x})\right)+s_i,\quad\forall i\in I_A,\\ &\mathbf{u}\in\mathcal{U},\\ &\mathbf{s}\geq0, \tag*{(7)} \end{aligned}

where ∥s∥p\lVert\mathbf{s}\rVert_p is the ℓp\ell_p norm of the slack vector, A∈{R-SSA,R-SSS,R-CBF}A\in\{\mathrm{R\text{-}SSA},\mathrm{R\text{-}SSS},\mathrm{R\text{-}CBF}\} identifies the relaxed filter, and

ρA(ϕ)={−ηrssa,A=R-SSA,−λrsssϕ,A=R-SSS,−λrcbfϕ,A=R-CBF.(8)\rho_A(\phi)= \begin{cases} -\eta_{\mathrm{rssa}}, & A=\mathrm{R\text{-}SSA},\\ -\lambda_{\mathrm{rsss}}\phi, & A=\mathrm{R\text{-}SSS},\\ -\lambda_{\mathrm{rcbf}}\phi, & A=\mathrm{R\text{-}CBF}. \end{cases} \tag*{(8)}

As in their non-relaxed counterparts, R-SSA and R-SSS invoke the optimization when at least one enabled safety index is positive; during that optimization, IAI_A contains the enabled indices with ϕ[i](x)≥0\phi^{[i]}(\mathbf{x})\geq0. R-CBF instead invokes the optimization continuously, and IAI_A contains every enabled safety index, including those with ϕ[i](x)<0\phi^{[i]}(\mathbf{x})<0.

The optimizer yields usafe\mathbf{u}_{\mathrm{safe}} and s∗\mathbf{s}^{*}. Each si∗s_i^{*} is the amount by which the corresponding derivative bound is violated: si∗=0s_i^{*}=0 recovers the original filter constraint, while si∗>0s_i^{*}>0 weakens it. Consequently, provided that the control set U\mathcal{U} is nonempty, the slack variables prevent conflicting safety constraints from making the optimization infeasible. The SPARK implementation of these filters uses p=2p=2 by default and also supports p=1p=1. The slack weight ws>0w_s>0 determines a direct tradeoff within the single optimization: a larger value discourages relaxation and may require a greater deviation from uref\mathbf{u}_{\mathrm{ref}}, whereas a smaller value permits more safety-constraint violation in order to follow the reference control more closely.

Projected Safe Set Algorithm (p-SSA). For humanoid robots, simultaneously enforcing many safety constraints can make the optimization in SSA infeasible, i.e., there may be no control input u∈U\mathbf{u}\in\mathcal{U} that satisfies all required escape rates. The Projected Safe Set Algorithm (p-SSA) also introduces slack, but unlike the single-stage relaxed filters above, it first finds the minimum relaxation of the infeasible safety constraints and then computes the safe control.

Specifically, p-SSA operates in two phases. In the first phase, it computes the minimum relaxation required to obtain a feasible constraint set:

(u⋆,s⋆)=arg min⁡u,s∥s∥Qspsubject tox˙=f(x)+g(x)u,ϕ˙[i](x,u)≤−ηpssa+si,if ϕ[i](x)≥0, ∀i∈[M],u∈U,s≥0.(9)\begin{aligned} (\mathbf{u}^{\star},\mathbf{s}^{\star})&=\underset{\mathbf{u},\mathbf{s}}{\operatorname{arg\,min}}\quad\lVert\mathbf{s}\rVert_{Q_s}^{p}\\ \text{subject to}\quad&\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\\ &\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq-\eta_{\mathrm{pssa}}+s_i,\quad\text{if }\phi^{[i]}(\mathbf{x})\geq0,\ \forall i\in[M],\\ &\mathbf{u}\in\mathcal{U},\\ &\mathbf{s}\geq0. \tag*{(9)} \end{aligned}

Here, sis_i represents the amount by which the escape-rate requirement of the ii-th safety constraint must be relaxed. When all constraints can be simultaneously satisfied, s⋆=0\mathbf{s}^{\star}=\mathbf{0} and no relaxation is necessary.

The second phase of p-SSA fixes the minimum relaxation s⋆\mathbf{s}^{\star} and computes the control that most closely follows the reference control:

usafe=arg min⁡u∥u−uref∥Qu2subject tox˙=f(x)+g(x)u,ϕ˙[i](x,u)≤−ηpssa+si⋆,if ϕ[i](x)≥0, ∀i∈[M],u∈U.(10)\begin{aligned} \mathbf{u}_{\mathrm{safe}}&=\underset{\mathbf{u}}{\operatorname{arg\,min}}\quad\lVert\mathbf{u}-\mathbf{u}_{\mathrm{ref}}\rVert_{Q_u}^{2}\\ \text{subject to}\quad&\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\\ &\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u})\leq-\eta_{\mathrm{pssa}}+s_i^{\star},\\ &\text{if }\phi^{[i]}(\mathbf{x})\geq0,\ \forall i\in[M],\\ &\mathbf{u}\in\mathcal{U}. \tag*{(10)} \end{aligned}

Thus, p-SSA follows the same constant escape-rate principle as SSA, parameterized by ηpssa\eta_{\mathrm{pssa}}, but permits the requested escape rate to be minimally relaxed when multiple safety requirements cannot be simultaneously satisfied. By separating constraint relaxation from reference-control tracking, p-SSA prioritizes minimizing safety-constraint violations before minimizing deviation from uref\mathbf{u}_{\mathrm{ref}}.

Attack Scenario and Threat Model

Attack Scenario We consider an attack scenario where a humanoid robot operates in an environment containing obstacles and serves multiple users by executing user-specified tasks. For example, a service humanoid may deliver dishes to customers in a restaurant or distribute medication to patients in a healthcare facility. An attacker can be one of the users served by the humanoid and interacts with the robot through the same task interface available to benign users.

The robots may receive multiple tasks over time and dynamically schedule their execution according to priorities, deadlines, or execution costs. Consequently, the scheduler may insert a newly submitted task into the existing task sequence. For example, a delivery robot may prioritize a newly submitted request that is geographically close to its current location before resuming an earlier delivery.

We show that this benign task-insertion functionality can be exploited to induce safety-related failures. Consider an original task that requires the humanoid to move from a starting state toward a target goal. The attacker’s objective is to identify an intermediate goal, which we call an insertion, such that the original task succeeds when executed directly but fails after the robot first accomplishes the inserted goal and resumes its original task. In other words, although both the original goal and the inserted goal are individually legitimate, their composition drives the robot into a state from which its safety filter prevents successful completion of the original task.

We assume that a task-insertion mechanism exists in the robot’s application layer; the specific mechanism through which an attacker inserts a new task is outside the scope of this work.

Non-Attack Scenario A related but distinct scenario is one in which the task itself directly causes the humanoid to fail; for example, the humanoid collides with an obstacle while executing the task, regardless of whether an insertion has occurred. This scenario is outside the scope of our work because the failure is directly attributable to the task itself and can therefore be readily detected.

Threat Model We consider a knowledgeable but unprivileged attacker, who knows the safety filter deployed on the target humanoid, including its relevant configuration parameters. This assumption is realistic when the target platform is commercially available: an attacker may obtain an identical robot and analyze its software and firmware offline [6, 42]. Robot software and firmware may also be recovered from public resources [50], hardware debugging interfaces such as JTAG, or software vulnerabilities [42]. The attacker can then reverse engineer the control stack to recover the safety-filter implementation and its parameters.

We additionally assume that the attacker knows the relevant environment geometry, including the locations of obstacles. This information may be available because the attack takes place in a public or otherwise observable physical environment. The attacker also knows the target task, including its starting and ending locations, which may be obtained through reconnaissance. Given the knowledge of the robot, environment, and the target task, the attacker can construct an offline simulation or physical replica where candidate insertions can be evaluated before launching the attack in the real world.

However, at attack time, the attacker’s capabilities are substantially restricted. The attacker interacts with the humanoid only through the legitimate high-level task interface that is available to ordinary users. Attackers cannot exploit vulnerabilities to achieve, e.g., remote code execution, privileged software access, arbitrary control of joint-level commands, modification of the safety filter, sensor spoofing, communication hijacking, or physical tampering with the target robot.

Goal Injection Attacks

In this section, we present the goal insertion attacks. We first state the safety failures existing in the current safety filter algorithms. Then we present how attackers can exploit the safety failures maliciously, so that they can trap the victim humanoids to collisions.

Safety Filters Failures

In this subsection, we show that the safety requirements imposed by a safety filter can lead to two distinct failure modes. When the configured escape rate is too small, the safety filter may not drive the robot away from an obstacle sufficiently quickly. Conversely, when the configured escape rate is too large, the required safety response may exceed the robot’s available control authority, making the safe-control optimization infeasible. A goal injection attack exploits these limitations by steering the humanoid into a state where one of these failure modes can be triggered.

Recall from Equation (3) that the optimization-based safety filter computes usafe\mathbf{u}_{\mathrm{safe}} such that ϕ˙[i](x,u)≤ρ[i](ϕ[i](x))\dot{\phi}^{[i]}(\mathbf{x},\mathbf{u}) \leq\rho^{[i]}(\phi^{[i]}(\mathbf{x})), ∀i∈[M]\forall i \in[M]. In the rest of the analysis, we focus on one constraint ii without the loss of generality. For the ease of presentation, we let ϕ≡ϕ[i]\phi\equiv\phi^{[i]}, ρ≡ρ[i]\rho\equiv\rho^{[i]}, and s≡sis \equiv s_i. We then define the corresponding required escape rate, denoted by D‾\overline{D}, as

D‾=−ρ(ϕ(x)),D‾>0(11)\overline{D}=-\rho(\phi(\mathbf{x})),\qquad\overline{D}>0 \tag*{(11)}

For SSA-family and CBF/SSS-family filters, D‾=η\overline{D}=\eta and D‾=λϕ(x)\overline{D}=\lambda\phi(\mathbf{x}), respectively. For filters with slack variables, D‾=η+s\overline{D}=\eta+s or D‾=λϕ(x)+s\overline{D}=\lambda\phi(\mathbf{x})+s, where η\eta, λ\lambda, and ss are generic shorthand for the corresponding family-specific configuration parameters. Thus, despite their different formulations, these filters constrain the rate at which the safety index is allowed to evolve. Combining the simplified notation, for the rest of this section, the optimization problem that safety filters seek to compute is the following equation:

usafe=arg min⁡u∥u−uref∥Q2subject tox˙=f(x)+g(x)u,ϕ˙(x,u)≤−D‾,u∈U.(12)\begin{aligned} \mathbf{u}_{\mathrm{safe}}&=\underset{\mathbf{u}}{\operatorname{arg\,min}}\quad\lVert\mathbf{u}-\mathbf{u}_{\mathrm{ref}}\rVert_{\mathcal{Q}}^2\\ \text{subject to}\quad&\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})\mathbf{u},\\ &\dot{\phi}(\mathbf{x},\mathbf{u})\leq-\overline{D},\\ &\mathbf{u}\in\mathcal{U}. \tag*{(12)} \end{aligned}

Insufficient Escape Rate. The first failure mode occurs when the escape rate imposed by the safety filter is too small relative to the state of the humanoid when the safety filter engages. Consider a collision-specific safety index with a relative degree rr, following the definition of existing safety filters [15, 28, 36, 53]:

ϕ(x)=ϕ0(x)+k1ϕ˙0(x)+k2ϕ¨0(x)+⋯+kr−1ϕ0(r−1)(x),\phi(\mathbf{x})=\phi_0(\mathbf{x})+k_1\dot{\phi}_0(\mathbf{x})+k_2\ddot{\phi}_0(\mathbf{x})+\cdots+k_{r-1}\phi_0^{(r-1)}(\mathbf{x}),

where ϕ0(x)=dmin⁡−d(x)\phi_0(\mathbf{x})=d_{\min}-d(\mathbf{x}),

{#eq:13}

where the subscript in ϕ0\phi_0 identifies the underlying physical specification and d(x)d(\mathbf{x}) denotes the clearance between a robot collision volume and an obstacle. In the following, f(j)f^{(j)} denotes the jj-th total time derivative of any function f(⋅)f(\cdot). Because dmin⁡d_{\min} is constant, we have

ϕ(x)=dmin⁡−d(x)−k1d˙(x)−k2d¨(x)−⋯−kr−1d(r−1)(x)(13)\phi(\mathbf{x}) = d_{\min} - d(\mathbf{x}) - k_1\dot{d}(\mathbf{x}) - k_2\ddot{d}(\mathbf{x}) - \cdots- k_{r-1}d^{(r-1)}(\mathbf{x}) \tag*{(13)}

And differentiating Equation Equation (13) gives

ϕ˙(x)=−(d˙(x)+k1d¨(x)+k2d...(x)+⋯+kr−1d(r)(x)).(14)\dot{\phi}(\mathbf{x}) = -\left(\dot{d}(\mathbf{x}) + k_1\ddot{d}(\mathbf{x}) + k_2\dddot{d}(\mathbf{x}) + \cdots+ k_{r-1}d^{(r)}(\mathbf{x})\right). \tag*{(14)}

By Equation (11), D‾>0\overline{D} > 0 represents the minimum rate at which the filter requires the safety index to decrease. Combining Equation (14) and 11 gives

d˙(x)+k1d¨(x)+k2d...(x)+⋯+kr−1d(r)(x)≥D‾.(15)\dot{d}(\mathbf{x}) + k_1\ddot{d}(\mathbf{x}) + k_2\dddot{d}(\mathbf{x}) + \cdots+ k_{r-1}d^{(r)}(\mathbf{x}) \ge\overline{D}. \tag*{(15)}

Let DD be the actual value of the left hand side. The evolution of the distance satisfies

d˙(x)+k1d¨(x)+k2d...(x)+⋯+kr−1d(r)(x)=D≥D‾.(16)\dot{d}(\mathbf{x}) + k_1\ddot{d}(\mathbf{x}) + k_2\dddot{d}(\mathbf{x}) + \cdots+ k_{r-1}d^{(r)}(\mathbf{x}) = D \ge\overline{D}. \tag*{(16)}

Equation (16) exposes an important limitation of high related degree safety filters: when r>1r > 1, it does not require d˙(x)≥0\dot{d}(\mathbf{x}) \ge0. The clearance d(x)d(\mathbf{x}) may therefore continue to decrease after the safety filter engages, even while the filter successfully drives ϕ(x)\phi(\mathbf{x}) downward.

Therefore, there exist engagement states with positive clearance but sufficiently adverse approach dynamics for which the inherited motion consumes the remaining clearance before the safety response can reverse it. At some future time tct_c, the robot can then satisfy Equation (16) while d(x(tc))<0d(\mathbf{x}(t_c)) < 0. Decreasing the safety index does not by itself certify that the robot avoids physical contact.

In details, we provide a close-form expression of the clearance function d(x)d(\mathbf{x}) via solving the ordinary differential equation, and discuss its possibility of being negative in Appendix § 12.

Note that this failure does not imply that a small, instead of insufficient, escape rate is inherently unsafe. Rather, it arises from the combination of an escape rate and an unfavorable engagement state. If the safety filter engages early, the available clearance may be sufficient for even a relatively small escape rate. A goal injection attack changes this condition by steering the humanoid into a state with unfavorable approach dynamics before the critical safety constraint becomes active. Once the original task resumes, the filter may engage from a state for which its configured escape rate is insufficient to recover the clearance before collision.

Insufficient Control Authority. Increasing the escape rate does not eliminate the attack surface. A second failure mode occurs when the requested escape rate exceeds what the robot can physically realize at its current state.

For the control-affine dynamics in Equation (1), the time derivative of a safety index is

ϕ˙(x)=∂ϕ∂xf(x)+∂ϕ∂xg(x)u=Lfϕ(x)+Lgϕ(x)u,(17)\dot{\phi}(\mathbf{x}) = \frac{\partial\phi}{\partial\mathbf{x}}f(\mathbf{x}) + \frac{\partial\phi}{\partial\mathbf{x}}g(\mathbf{x})\mathbf{u} = L_f\phi(\mathbf{x}) + L_g\phi(\mathbf{x})\mathbf{u}, \tag*{(17)}

where Lfϕ(x)L_f\phi(\mathbf{x}) captures the evolution of the safety index due to the uncontrolled system dynamics and Lgϕ(x)L_g\phi(\mathbf{x}) captures its sensitivity to the control input.

We define the control authority with respect to ϕ\phi as the largest decrease in the safety index that can be produced by an admissible control:

Cϕ(x)=max⁡u∈U(−Lgϕ(x)u).(18)C_\phi(\mathbf{x}) = \max_{\mathbf{u}\in\mathcal{U}}\left(-L_g\phi(\mathbf{x})\mathbf{u}\right). \tag*{(18)}

For a symmetric box-constrained control set

U={u∣∣uj∣≤uˉj, j=1,…,Nu},(19)\mathcal{U} = \{\mathbf{u} \mid|u_j| \le\bar{u}_j,\ j = 1,\ldots,N_u\}, \tag*{(19)}

where NuN_u is the number of control inputs. The control authority then has the closed form

Cϕ(x)=∑j=1Nuuˉj∣[Lgϕ(x)]j∣.(20)C_\phi(\mathbf{x}) = \sum_{j=1}^{N_u} \bar{u}_j \left|[L_g\phi(\mathbf{x})]_j\right|. \tag*{(20)}

As defined in Equation (11), D‾\overline{D} is nonnegative whenever the corresponding constraint requires the safety index to decrease. A control satisfying the safety requirement exists if and only if

min⁡u∈U(Lfϕ(x)+Lgϕ(x)u)≤−D‾.(21)\min_{\mathbf{u}\in\mathcal{U}}\left(L_f\phi(\mathbf{x}) + L_g\phi(\mathbf{x})\mathbf{u}\right) \le-\overline{D}. \tag*{(21)}

By the definition of CϕC_\phi, this condition is equivalent to

Lfϕ(x)−Cϕ(x)≤−D‾,(22)L_f\phi(\mathbf{x}) - C_\phi(\mathbf{x}) \le-\overline{D}, \tag*{(22)}

or

Cϕ(x)−D‾−Lfϕ(x)≥0.(23)C_\phi(\mathbf{x}) - \overline{D} - L_f\phi(\mathbf{x}) \ge0. \tag*{(23)}

We therefore define the feasibility margin

γ(x)=Cϕ(x)−D‾−Lfϕ(x).(24)\gamma(\mathbf{x}) = C_\phi(\mathbf{x}) - \overline{D} - L_f\phi(\mathbf{x}). \tag*{(24)}

A single safety constraint is feasible if and only if

γ(x)≥0.(25)\gamma(\mathbf{x}) \ge0. \tag*{(25)}

When

γ(x)<0,(26)\gamma(\mathbf{x}) < 0, \tag*{(26)}

no admissible control can achieve the escape rate requested by the safety filter.

Importantly, uref\mathbf{u}_{\mathrm{ref}} does not appear in Equation (24). The reference control affects which feasible control is selected by the minimum-deviation objective above, but it does not determine whether the safety constraints themselves are feasible. Feasibility is instead a property of the current robot state, environment, safety specification, and control limits.

For multiple simultaneously active safety constraints, individual feasibility is necessary but not sufficient for joint feasibility. Restoring the constraint superscript, the authority, required rate, and margin associated with ϕ[i]\phi^{[i]} satisfy

γ[i](x)=Cϕ[i](x)−D‾[i]−Lfϕ[i](x)≥0,∀i∈[M],(27)\gamma^{[i]}(\mathbf{x}) = C_{\phi}^{[i]}(\mathbf{x}) - \overline{D}^{[i]} - L_f\phi^{[i]}(\mathbf{x}) \ge0,\qquad\forall i \in[M], \tag*{(27)}

but different constraints may require mutually incompatible controls. The exact joint-feasibility condition is

∃u∈U,Lgϕ[i](x)u≤−D‾[i]−Lfϕ[i](x),∀i∈[M].(28)\exists\mathbf{u} \in\mathcal{U},\qquad L_g\phi^{[i]}(\mathbf{x})\mathbf{u} \le-\overline{D}^{[i]} - L_f\phi^{[i]}(\mathbf{x}),\qquad\forall i \in[M]. \tag*{(28)}

Lack of Proactive Failure Avoidance Existing safety filter algorithms operate myopically. At each control cycle, they compute only the control input for the next time step and intervene only after the safety index exceeds a predefined threshold. Consequently, the computed safe control usafe\mathbf{u}_{safe} may drive the humanoid into a state from which the safety controller can no longer recover. Because the controller neither predicts future states nor accounts for the long-term consequences of its actions, it cannot proactively prevent such failures.

In summary, the two failures expose a fundamental tradeoff in the configuration of safety filter: if the escape rate is too small, the controller may recover too slowly from a dangerous higher-order state, and if the escape rate is too large, the required control input may exceed the robot’s available control authority, which renders the safety optimization infeasible. Furthermore, both the recovery requirements and the available control authority depend on the robot configuration and the surrounding environment. As a result, a single fixed parameter configuration cannot provide adequate safety guarantees across all states that an articulated humanoid may encounter. Combined with the lack of proactive failure avoidance, the current design provides no mechanism to eliminate either failure.

Exploiting Safety Failures Adversarially

The two failure modes described above are both state dependent. Whether the escape rate is sufficient depends on the state at which the safety filter engages, while whether the safety optimization is feasible depends on the control authority available at the current state. Consequently, there exist robot states from which a safety filter can fail even though the same filter operates correctly from other states.

This observation suggests a direct attack strategy: identify a failure-inducing state x∗\mathbf{x}^{*} and place the humanoid in that state before it executes a target task. In practice, however, directly searching for and setting such a state is difficult for two reasons. First, the state space of a humanoid is high dimensional. As described in § 2, x\mathbf{x} may contain the positions and velocities of many joints in addition to the robot base state. A humanoid with NN controllable degrees of freedom can therefore have a state space with dimension on the order of NN under first-order dynamics and 2N2N under second-order dynamics. Exhaustively searching this space for failure-inducing states quickly becomes intractable.

This challenge is fundamentally different from that of a rigid mobile system. Consider, for example, an autonomous vehicle approaching a stationary obstacle along a fixed direction. Its collision behavior can often be characterized using a small number of state variables, such as the distance to the obstacle and the vehicle’s longitudinal velocity. An adversary searching for a dangerous state could therefore reason directly about a critical approach speed or stopping distance.

A humanoid does not admit the same reduction. Its geometry changes with its joint configuration, and the available control authority depends on the configuration-dependent kinematics of individual links. The same wrist position, for example, can be realized by multiple arm configurations with different joint positions, velocities, and Jacobians, and therefore different safety responses. Moreover, several robot links may simultaneously interact with different obstacles. Thus, a failure-inducing humanoid state cannot generally be described by a single quantity such as approach speed. Searching directly over x\mathbf{x} requires reasoning about a high-dimensional articulated configuration.

Second, under our threat model, an attacker does not have an interface for directly assigning x\mathbf{x}. The attacker cannot set individual joint positions or velocities, inject arbitrary low-level controls, or modify the internal state of the robot. The only available interface is the same high-level task interface exposed to benign users.

Although the attacker cannot directly manipulate the robot state x\mathbf{x}, the attacker can indirectly influence it through high-level reaching goals. Specifically, executing a goal G\mathcal{G} from an initial state x0\mathbf{x}_0 induces a resulting robot state xG\mathbf{x}_{\mathcal{G}}. We denote this closed-loop state transition as

T(x0,G)=xG.(29)\mathcal{T}(\mathbf{x}_0,\mathcal{G}) = \mathbf{x}_{\mathcal{G}}. \tag*{(29)}

The mapping T\mathcal{T} captures the execution of the nominal controller together with the deployed safety filter and need not be available in closed form.

This observation reduces the attack from searching directly over the high-dimensional robot state space,

x∗∈X,(30)\mathbf{x}^{*} \in\mathcal{X}, \tag*{(30)}

to searching over legitimate task goals,

G∗∈G,(31)\mathcal{G}^{*} \in\mathcal{G}, \tag*{(31)}

where G\mathcal{G} denotes the set of goals accepted by the robot’s task interface. For the reaching tasks considered in this work, G\mathcal{G} is a Cartesian target and therefore has substantially lower dimension than the full humanoid state x\mathbf{x}.

The attacker can thus use the robot’s own controller to realize the desired state transition: rather than directly specifying a failure-inducing joint-level state, the attacker searches for a high-level goal whose execution places the humanoid in a state from which the subsequent task triggers one of the safety failures identified in § 4.1.

Attack Formalization

Consider an original task that moves the humanoid from the state induced by an initial goal G0\mathrm{G}_0 to a destination G1\mathrm{G}_1. The attacker inserts an intermediate goal G′\mathrm{G}', changing the task sequence from G0→G1\mathrm{G}_0 \to\mathrm{G}_1 to G0→G′→G1\mathrm{G}_0 \to\mathrm{G}' \to\mathrm{G}_1. Let Succ⁡(x,G)∈{0,1}\operatorname{Succ}(x,\mathrm{G}) \in\{0,1\} indicate whether executing goal G\mathrm{G} from state xx succeeds, and let T(x,G)\mathcal{T}(x,\mathrm{G}) denote the terminal state produced by that execution.

Goal Insertion Attacks. The goal insertion attacks problem is to find an inserted goal G′∈G\mathrm{G}' \in\mathcal{G} such that

Succ⁡(x0,G1)=1,Succ⁡(x0,G′)=1,Succ⁡(T(x0,G′),G1)=0.(32)\begin{aligned} \operatorname{Succ}(x_0,\mathrm{G}_1) &= 1,\\ \operatorname{Succ}(x_0,\mathrm{G}') &= 1,\\ \operatorname{Succ}(\mathcal{T}(x_0,\mathrm{G}'),\mathrm{G}_1) &= 0. \tag*{(32)} \end{aligned}

The first condition establishes that the target task is normally successful. The second prevents the attacker from trivially choosing an inherently invalid or unreachable intermediate goal. The third captures the attack itself: executing the legitimate intermediate goal changes the humanoid state such that subsequently executing the original goal fails.

Crucially, G′\mathrm{G}' need not itself be close to an obstacle or directly cause a safety violation. Its purpose is to induce a particular robot state xinsx_{\mathrm{ins}}. Depending on the failure mechanism, this state may cause the robot to approach an obstacle with unfavorable higher-order dynamics, resulting in an insufficient escape rate, or may place the articulated body in a configuration with insufficient control authority, resulting in safe-control infeasibility. The safety failure can therefore occur only during the subsequent G′→G1\mathrm{G}' \to\mathrm{G}_1 leg, even though G0→G′\mathrm{G}_0 \to\mathrm{G}' is itself safe.

This reduction is important from both an attack and a security perspective. Instead of requiring privileged access to manipulate a high-dimensional internal robot state, the attacker searches a low-dimensional space of authorized task inputs and lets the robot’s own nominal controller realize the corresponding state transition. The resulting trajectory is generated by legitimate robot software, the state observed by the safety filter remains truthful, and the injected goal is itself a valid command. The adversarial effect arises solely from selecting a goal whose induced state makes a subsequent legitimate task encounter a safety-filter failure.

Finding Inserting Goals

The formalization above defines when an inserted goal constitutes a successful attack, but it does not directly yield a closed-form objective over the Cartesian goal space. The attacker can evaluate candidates in a simulator with the same nominal controller, robot model, obstacle geometry, and safety filter ψ\psi. The attacker’s task is therefore to search for an inserted goal G′\mathrm{G}' such that the original task succeeds, the inserted goal is itself executable, but the two-stage execution [G′,G1][\mathrm{G}',\mathrm{G}_1] causes safety filter to fail.

Exhaustive search is inefficient for finding such attacks. Each candidate G′\mathrm{G}' must be evaluated through closed-loop execution: the collision state induced by reaching G′\mathrm{G}' depends on inverse kinematics, robot dynamics, the nominal controller, and the known safety filter. Inspired by existing work in search-guided fuzzing [8, 13, 14, 19, 29], we use the Cross-Entropy Method (CEM) [43] to focus simulation trials on regions of the admissible goal space that are more likely to produce failure-inducing collision states, with a self-defined score for guidance.

For a candidate inserted goal G′\mathrm{G}', the search first checks that the inserted goal is legitimate:

Succ⁡ψ(x0,G′)=1.(33)\operatorname{Succ}_{\psi}(x_0,\mathrm{G}') = 1. \tag*{(33)}

Only candidates that pass this gate are evaluated as attacks. We score a candidate by simulating the full attacked task under ψ\psi:

S(G′)=sψ(Exec⁡ψ(Tψ(x0,G′,G1))).(34)S(\mathrm{G}') = s_{\psi}\left(\operatorname{Exec}_{\psi}\left(\mathcal{T}_{\psi}(x_0,\mathrm{G}',\mathrm{G}_1)\right)\right). \tag*{(34)}

The score is the sum of a discrete outcome bonus and a continuous guidance term:

sψ(r)=b(ℓ(r))−dcollision(r),(35)s_{\psi}(r) = b\left(\ell(r)\right) - d_{\mathrm{collision}}(r), \tag*{(35)}

where rr is the simulation run result returned by Sim⁡ψ\operatorname{Sim}_{\psi}, ℓ(r)\ell(r) is the simulation outcome label, dcollision(r)d_{\mathrm{collision}}(r) is the obstacle clearance at the collision from the inserted goal back to the original goal. The outcome bonus is

b(ℓ)={2,ℓ=COLLISION,1,ℓ=TIMEOUT,0,ℓ=REACHED.(36)b(\ell) = \begin{cases} 2, & \ell= \mathrm{COLLISION},\\ 1, & \ell= \mathrm{TIMEOUT},\\ 0, & \ell= \mathrm{REACHED}. \end{cases} \tag*{(36)}

Thus, confirmed failures dominate near misses, while the continuous terms rank candidates within the same outcome class. In particular, smaller collision clearance increases the score, guiding CEM toward inserted goals that return control to the original task near the obstacle.

Figure 1 separates attack validity from search guidance. Lines 6–9 enforce the legitimacy of the inserted goal: the attacker may submit only goals that the robot can execute as standalone tasks. Lines 10–12 then evaluate the actual attack by executing the inserted goal followed by the original goal under safety filter. CEM uses the resulting score to update its Gaussian search distribution in Lines 17–18, concentrating later samples around inserted goals that either already cause failure or move the system closer to a failure-inducing collision state.

SIREN’s CEM-based search algorithm

Figure 1. SIREN’s CEM-based search algorithm.

Implementation

We develop SIREN as a Python module in the SPARK v1.0 simulation framework [48]. The core implementation consists of approximately 1,400 lines of code, and the complete codebase with the adaptation layer and experiment analysis comprises approximately 6,800 lines of code.

Input: initial state $x_0$, original goal $G_1$, goal space $G$, filter $\psi$, simulator $\operatorname{Sim}_{\psi}$, budget $B$, batch size $m$, elite fraction $\alpha$
Output: ranked inserted goals and confirmed attacks
1  $(\mu,\sigma) \leftarrow \operatorname{InitGaussian}(G)$
2  $\mathcal{R} \leftarrow 0$; $n \leftarrow 0$
3  while $n < B$ do
4  $\mathcal{B} \leftarrow \operatorname{Clip}_{G}(\{g_i \sim \mathcal{N}(\mu,\operatorname{diag}(\sigma^2))\}_{i=1}^{m})$
5  $\mathcal{S} \leftarrow 0$
6  for each $G' \in \mathcal{B}$ do
7  if $\neg\operatorname{Admissible}(G')$ then continue
8  $r_{\mathrm{ins}} \leftarrow \operatorname{Sim}_{\psi}(x_0,[G'])$
9  if $\neg\operatorname{Succ}(r_{\mathrm{ins}})$ then continue
10  $r_{\mathrm{atk}} \leftarrow \operatorname{Sim}_{\psi}(x_0,[G',G_1])$
11  $\operatorname{score} \leftarrow s_{\psi}(r_{\mathrm{atk}})$
12  $\operatorname{attack} \leftarrow \operatorname{Fail}(r_{\mathrm{atk}})$
13  $\mathcal{S} \leftarrow \mathcal{S} \cup \{(G',\operatorname{score},\operatorname{attack})\}$
14  $\mathcal{R} \leftarrow \mathcal{R} \cup \{(G',\operatorname{score},\operatorname{attack})\}$
15  $n \leftarrow n+1$
16  end for
17  $\mathcal{E} \leftarrow \operatorname{Top}_{\lceil\alpha|\mathcal{S}|\rceil}(\mathcal{S})$
18  $(\mu,\sigma) \leftarrow \operatorname{FitGaussian}(\{G':(G',\cdot,\cdot)\in\mathcal{E}\})$
19  end while
20  return $\operatorname{SortByScore}(\mathcal{R})$

Evaluation

Our evaluation aims to answer the following questions:

  • Vulnerability Presence: Does goal insertion attacks exist for each safety filter under concrete deployment scenarios (§ 7.1)?

  • Attack Realism: Can goal insertion attacks compromise real humanoid robots and cause safety violations such as collisions (§ 7.2)?

  • Attack Effectiveness: How effectively can SIREN discover goal insertion attacks across different safety filters and deployment scenarios (§ 7.3)?

We build our evaluation on SPARK [48], a humanoid robotics testbed that provides simulation environments, a diverse set of safety filter implementations, and a benchmark suite for evaluating them. The benchmark covers a broad range of scenarios, including static and dynamic obstacles, full-body and upper-body tasks, and different safety index formulations. This diversity enables a comprehensive evaluation of both safety filters and goal insertion attacks. All experiments are conducted on macOS running on an Apple M3 processor with 128GB of memory.

Safety Filter Vulnerability Presence

Although our analysis (§ 4) shows that safety filter algorithms can be vulnerable, it remains unclear whether concrete scenarios exist in which an attacker can trigger these vulnerabilities. One possible approach is to directly use the SPARK benchmark. However, using the benchmark as-is makes it difficult to isolate and reason about the feasibility of goal insertion attacks in a concrete environment. Some SPARK tasks may fail even without an attack, while successful attacks in complex benchmark environments may involve many interacting obstacles and constraints, making it difficult to attribute the observed failure specifically to goal insertion attacks. We therefore study simplified scenarios to establish the existence and feasibility of goal insertion attacks under controlled conditions.

In this experiment, we employ a simple enumeration approach to identify attacks in an environment containing a single obstacle. We sample tasks from the SPARK benchmark, where each task specifies a starting point and an ending point that the humanoid must reach. For each sampled task, we search jointly for an inserting goal and an obstacle location such that the safety filter fails during the attacked execution, resulting in either a collision or a deadlock. To ensure that the observed failure is caused by goal insertion attacks rather than an inherently infeasible task, we compare task execution with and without the attack. We consider an attack valid only if the original task succeeds without goal insertion attacks, while the same task fails after goal insertion attacks is introduced.

To construct a feasible goal insertion attacks, we enumerate candidate inserting goals within a preconfigured 30×30×30 cm330 \times30 \times30\ \mathrm{cm}^{3} three-dimensional region, sampling one point every 5 cm. For each candidate inserting goal, we search for an obstacle location satisfying three conditions, following the definition of goal insertion attacks (§ 5.1): (1) the original task (from the starting point to the ending point) succeeds; (2) the first leg of the attacked execution (from the starting point to the inserting goal) succeeds; and (3) the second leg (from the inserting goal to the original ending point) fails.

To efficiently identify candidate obstacle locations, we compute the swept volumes of the humanoid along the three trajectories: the original trajectory, the first leg of the attacked trajectory, and the second leg. We select obstacle locations that lie outside the swept volumes of both the original trajectory and the first leg, but inside the swept volume of the second leg. Among these locations, we prioritize those farther from the swept volumes of the original trajectory and the first leg. Intuitively, this procedure places the obstacle where it is unlikely to interfere with either the original task or the first leg, while positioning it to interact with the humanoid during the second leg and potentially trigger a safety filter failure. Finally, we validate each candidate by simulating the complete attacked execution from the starting point to the inserting goal and subsequently to the original ending point.

Note that this enumeration procedure is sound but not complete: every reported attack is validated through simulation, but the procedure may miss inserting goals that would also produce successful attacks. Our objective in this experiment is to establish whether concrete instances of goal insertion attacks exist for the evaluated safety filters, rather than to exhaustively discover all possible attacks in a given environment. We study the problem of efficiently identifying attacks in Section 7.3.

As shown in Table 1, the results demonstrate that goal insertion attacks is feasible against all evaluated safety filters. Across the evaluated SPARK tasks, we are able to identify an inserting goal and an obstacle placement for which the original task succeeds, the first leg of the attacked task succeeds, and the safety filter is subsequently engaged but fails during the second leg. These results provide concrete instances of the vulnerabilities established analytically in Section 4.1, demonstrating that they can be reached through goal insertion rather than requiring direct manipulation of the humanoid’s internal state.

Safety FilterValid AttacksMin Original Distance (cm)Initial Collision Distance (cm)
SSA✓0.0187-0.0152
R-SSA✓0.0241-0.0298
p-SSA✓0.0858-0.0443
CBF✓0.2729-0.0181
R-CBF✓0.0841-0.0273
R-SSS✓0.0625-0.0458
SSS✓0.0187-0.0102

Table 1. Validated goal-insertion attacks found by enumeration in single-obstacle environments.

Case Study To understand how an attack defeat the safety filter, we study one successful case. In this case, the obstacle is posed in front of the chest humanoid, and the original task is to move the right arm from a point below the obstacle to a point on the robot’s left side to the obstacle while move the left arm to a fixed point and stay hold (default in SPARK), as shown in Figure 2. We identify an inserting goal against the Safe Set Algorithm (SSA), where we insert a middle target right to the obstacle. With this inserted goal, a collision happens when the right arm moves from the middle point to the ending point.

A goal insertion attack against SSA

Figure 2. A goal insertion attack against SSA.

In more details, SSA was engaged before the collision happen. However, the safety escaping rate, η\eta, associated with the safety filter is configured to be too slow compared to the current arm speed of the humanoid. By introducing the insertion point, we manage to induce the humanoid’s arm to a speed that beyond the SSA’s configured safety escaping rate. Therefore, although SSA was triggered when the distance between the humanoid arm and the obstacle is below threshold, and SSA successfully adjusts the control to move away from the obstacle, given the current speed of the humanoid and its inertia, the SSA-adjusted control was not able to turn the arm away in time.

Furthermore, we enumerate the value of η\eta and see how the change of the value affect the attack success on this inserting goal, as shown in Figure 3. Interestingly, we observe that as we increase the value, i.e., let the robot generate controls to escape from the obstacle faster, the attack will be firstly invalidated, but become validated again after a certain value. This is because SSA can no longer compute a feasible solution given η\eta’s new value. At some states determined by the location and speed of the humanoid, the control authority of the nearest body part degrades below the expected escape rate. Therefore, the algorithm cannot generate a control that meets the safety requirement.

Figure 3. Original task success over SSA safety escaping rate.

Figure 4 shows this effect for ηSSA=20\eta_{\mathrm{SSA}} = 20 by plotting the control authority associated with the body part closest to the obstacle at each step. In this specific case, the nearest point to the obstacle switches across the arm, including from wrist joints to the elbow. Because these body parts provide different control authority, the switch can leave SSA unable to compute a safe action that satisfies the configured escape rate. It is the inserting goal that induces the nearest-point change and triggers the infeasibility.

Figure 4. Control authority of the nearest body part at each step.

Overall, to defend against this particular attacking point, the safety escaping rate has to be carefully chosen within a niche range. Deciding safety escaping rate is tricky in realworld scenarios. The range of a proper safety escaping rate is a narrow interval, and that interval differs for different attacking point, tasks, and obstacles. Even worse, if the obstacle is dynamic or even unknown to the developer, the developer cannot reason about the proper rate range. There may not be a proper configuration that can defend against all attacking points. Due to the specificality and sensitivity of the parameters, the chance that an inserting goal exists can be high, and many safety filter will be affected by such type of attack.

Exploitation on a Real Humanoid

In this section, we deploy the identified attacks from the above experiment in the real world and validate if the identified attacks work in real-world setups. Ideally, one would validate all identified attacks. However, this is intractable for real-humanoid testing for the following reasons. First, the current humanoid safety benchmark SPARK has only been properly tested for upper-body sim-to-real deployment. Second, for the dynamic obstacle scenarios in benchmark, it will be hard to achieve accurate sim-to-real setup because it is hard to realize multiple moving obstacles each of which moves under an exact speed. Third, such a safety experiment is risky and costly, especially that our goal is to demonstrate collision or sudden stops, both of which may cause unfixable damage to the testing humanoid and cost $50K.

Due to the above limitations, we selected attacks that use the upper-body model and static obstacle scenarios, and we randomly chose one attacking scenario for each safety filter algorithm. For each selected scenario, we replayed the attack in simulation and then reproduced the same setup on the real humanoid by matching the goal sequence and obstacle placement.

Table 2 shows the simulation and real-humanoid outcomes for all evaluated safety filters. Across SSA, CBF, SSS, and their robust or relaxed variants, the same qualitative failure observed in simulation is reproduced on the physical humanoid. This result indicates that the attacks identified in the controlled simulation setting are not merely simulator artifacts: when the environment is restricted to the upper-body, single-obstacle setting that can be faithfully reproduced on hardware, the attack transfers to the real robot.

SSACBFSSS
Simulation — Real HumanoidSimulation — Real HumanoidSimulation — Real Humanoid
R-SSAR-CBFR-SSSp-SSA
Simulation — Real HumanoidSimulation — Real HumanoidSimulation — Real HumanoidSimulation — Real Humanoid
Starting Point — Ending PointStarting Point — Insertion Point — Collision
Original TaskTask with Insertion Attack

Table 2. The deployment of goal insertion attacks to real humanoids.

To further explain the sim-to-real deployment procedure, we present one representative case study. Using the SSA scenario as an example, Figure 5 compares the original task with the attacked execution on the deployed real-world setup. In the original task, the humanoid successfully moves from the starting point to the ending point without contacting the obstacle. With the inserting goal attack, however, the inserted goal first drives the arm toward the obstacle; when the humanoid subsequently moves toward the original ending point, the arm collides with the obstacle. This case study illustrates the same validation condition used throughout RQ2: the task is executable in the real setup without the insertion, but the same setup fails once the attacker inserts the intermediate goal.

Figure 5. Real-world attack demonstration. The original task succeeds without contacting the obstacle, while the insertion attack drives the humanoid through an intermediate point and causes a collision during the return to the original goal.

Attack Discovery Effectiveness

In this experiment, we evaluate the effectiveness of the CEM-based search in identifying inserting goals in vulnerable scenarios. Unlike the previous experiment, which establishes the existence of goal insertion attacks, this experiment evaluates its scalability. Specifically, we measure how many successful attacks an automated search algorithm can discover in a vulnerable scenario.

To this end, we construct a dataset of vulnerable scenarios from the SPARK benchmark. We randomly sample scenarios from the benchmark and validate each scenario against a safety filter. A scenario is considered vulnerable if the original task sequence [G0,G1][G_0,G_1] succeeds, while a planted sequence [G0,G′,G1][G_0,G',G_1] consistently causes a failure during the second task. This process yields five vulnerable scenarios for each safety filter, for a total of 35 scenarios.

For each scenario, we compare the following search strategies:

  • Random: uniformly samples insertion points in the three-dimensional search space.

  • SIREN: the proposed CEM-based search algorithm.

We also evaluate two variants, Random-NI and SIREN-NI, which initialize the search near obstacles. These variants test the hypothesis that successful inserting goals are more likely to occur close to obstacles.

Simulation time varies across runs, and simulation dominates the overall search cost. Therefore, instead of limiting wall-clock time, we assign every search algorithm the same budget of 125 simulation trials. This design provides a fair comparison across search strategies. On average, each search process costs 61.1 minutes.

We synthesize the experiment results shown in Table 3. Both random search and SIREN identify at least one successful attack in all 35 scenarios. However, SIREN discovers substantially more attacks than random search: SIREN identifies 3277 attacks, whereas the random search approach identifies 1760 attacks, which is nearly only a half of SIREN’s discovery. The attack hit rates of SIREN and SIREN-NI both exceed 60%. Surprisingly, neither near-obstacle initialization variant

Method# Attacked ScenariosScenario Hit Rate# Total AttacksAttack Hit Rate
Random40/40100.0%176035.2%
Random-NI40/40100.0%175135.0%
SIREN40/40100.0%327765.5%
SIREN-NI38/4095.0%300660.1%

Table 3. Search effectiveness across 35 scenarios.

outperforms its corresponding baseline. Although SIREN-NI achieves a slightly higher hit rate, it fails to identify attacks in every scenario. These results demonstrate that SIREN is significantly more effective than random search for identifying attacks, while providing no evidence that successful inserting goals are concentrated near obstacles.

Specifically, we examine the search process of SIREN, as illustrated in Figure 6. In the figure, the small red points denote the inserting goals identified by SIREN, whereas the white points represent all sampled search points. SIREN initializes the search with points sampled uniformly at random in the three-dimensional workspace. During the CEM-based optimization, the search rapidly converges to the region between the two obstacles, where it identifies 21 attacking points out of 125 search trials. This result shows that CEM efficiently concentrates the search on regions that are likely to contain attacking points. We also observe that points located near obstacles are not necessarily attacking points. This observation explains why initializing the search near obstacles does not improve attack discovery.

Case study showing searched points by SIREN

Figure 6. Case study: searched points by SIREN. Large red balls denote the obstacles. The blue point is the starting point, and the green point is the ending point of the original task.

Potential Defense and Mitigation

The root cause of the vulnerability in safety filter is its design. Safety parameters depend on both the task and the environment, and inaccurate parameter configurations create opportunities for attack. Unfortunately, no existing method can determine the correct parameter values for arbitrary tasks and environments. Moreover, little prior work studies the relationship between safety parameters and task or environmental characteristics.

A complete defense against goal insertion attacks requires accurate parameter configurations for each task and environment while keeping both fixed during execution. An alternative direction is to develop new safety algorithms that adapt their parameters dynamically according to changes in the task or environment [17, 57, 59].

One practical mitigation is to prohibit insertion into tasks that have already been scheduled. This restriction prevents failures of scheduled tasks. Because the attacker cannot predict future tasks, it also makes it significantly more difficult to insert goals at the precise time required for a successful attack. Although this mitigation may reduce the flexibility and efficiency of the humanoid, it improves both task reliability and operational safety.

Another possible mitigation is to introduce an additional runtime monitor that halts the humanoid upon collision. However, such a mechanism requires more than a conventional emergency stop. Existing emergency-stop procedures or transitions to a fixed recovery pose can themselves cause the humanoid to fall or collide during recovery [18]. Therefore, defenders need a dynamic emergency-stop mechanism that minimizes collateral damage while safely terminating execution.

Although mitigations reduce the attack surface, they cannot eliminate the vulnerability fundamentally. Therefore, this limitation is structural; as long as safety filters compute controls solely from the current state without reasoning about future feasibility or permitting temporary task-reversing maneuvers, an adversary can always steer the robot toward a state that causes safety infeasibility. Eliminating this vulnerability requires predictive safe control with inclusive feasibility guarantees, which remains an open research problem [20, 34, 51, 60].

Limitations and Future Work

Although we show that goal insertion attacks is possible, we do not know the prevalence of goal insertion attacks. In particular, given an arbitrary task and environment, we cannot estimate the probability that a successful attack exists. Quantifying this prevalence is challenging because the state space of humanoid systems is prohibitively large. Although many scenarios do not admit a successful attack, we currently lack a principled method to determine whether an attack exists or to characterize the conditions under which one becomes feasible.

Also, this paper assumes that the attacker has complete knowledge of the safety filter deployed on the target humanoid, including its algorithm and parameter values. Future work could relax this assumption by considering attackers with incomplete information. For example, an attacker may know the type of safety filter but not its parameter values, or may not know the deployed safety filter at all. With limited interaction or probing of the target robot, it may be possible to infer sufficient information to construct effective attacks under these weaker assumptions.

Lastly, this paper does not consider the complete humanoid software stack or its impact on attack success. A practical humanoid system includes components such as perception and simultaneous localization and mapping (SLAM), which estimate the robot’s pose and the locations of surrounding obstacles. Errors in these components may affect the execution and success of goal insertion attacks. As a first step, this paper focuses on demonstrating that the vulnerability in safety filter is fundamentally exploitable. Future work will investigate attacks against end-to-end humanoid systems that remain effective despite inaccuracies in perception, localization, and other system components.

Conclusion

In this paper, we demonstrate that existing safety filter algorithms contain security vulnerabilities that attackers can exploit to cause safety violations such as collisions. We present goal insertion attacks and show that a scalable and automated approach can identify vulnerable inserting goals, which underscores the practical severity of the vulnerability. Our evaluation confirms that goal insertion attacks exists in realistic scenarios and can compromise real humanoid robots. Finally, we discuss potential defenses and mitigation strategies against goal insertion attacks.

Ethical Considerations

As safety filters for humanoid robots remain an emerging technology, the safety filters evaluated in this work are still undergoing industry validation and have not yet been productized or integrated into the default configurations used in humanoid robot manufacturing. The goal of this work is to proactively discover critical and adversarial safety issues before any humanoids being deployed. We will work with the respective authors to identify downstream users who may have deployed the affected safety filters and to inform them of the vulnerabilities identified in this work.

Clearance Derivation

This appendix formalizes the collision possibility by deriving the closed-form expression for the clearance d(t)d(t) between a humanoid collision volume and an obstacle. Let t=0t=0 denote the state x0\mathbf{x}_0 at which the relevant safety constraint engages, and write d(t)≡d(x(t))d(t)\equiv d(\mathbf{x}(t)). Following the notation in § 4.1, assume over the local interval of interest that the achieved value of the left-hand side of Equation (16) is constant:

d˙(t)+k1d¨(t)+k2d(3)(t)+⋯+kr−1d(r)(t)=D,D≥D‾.(37)\dot{d}(t)+k_1\ddot{d}(t)+k_2d^{(3)}(t)+\cdots+k_{r-1}d^{(r)}(t)=D,\qquad D\geq\overline{D}. \tag*{(37)}

This assumption is exact over an interval where the achieved escape rate is constant; more generally, it provides a local model of the clearance response until the clearance either recovers or reaches zero.

Define

z(t)=d(t)+k1d˙(t)+⋯+kr−1d(r−1)(t).(38)z(t)=d(t)+k_1\dot{d}(t)+\cdots+k_{r-1}d^{(r-1)}(t). \tag*{(38)}

Equation (37) gives z˙(t)=D\dot{z}(t)=D. Moreover, Equation (13) gives z(0)=dmin⁡−ϕ(x0)z(0)=d_{\min}-\phi(\mathbf{x}_0). Therefore,

d(t)+k1d˙(t)+⋯+kr−1d(r−1)(t)=dmin⁡−ϕ(x0)+Dt.(39)d(t)+k_1\dot{d}(t)+\cdots+k_{r-1}d^{(r-1)}(t)=d_{\min}-\phi(\mathbf{x}_0)+Dt. \tag*{(39)}

Let

p(s)=1+k1s+k2s2+⋯+kr−1sr−1.(40)p(s)=1+k_1s+k_2s^2+\cdots+k_{r-1}s^{r-1}. \tag*{(40)}

Assume that every root of p(s)p(s) has strictly negative real part. The solution of Equation (39) can then be written as

d(t)=A+Dt+h(t),(41)d(t)=A+Dt+h(t), \tag*{(41)}

where

A=dmin⁡−ϕ(x0)−k1D,(42)A=d_{\min}-\phi(\mathbf{x}_0)-k_1D, \tag*{(42)}

and h(t)h(t) is the homogeneous response needed to match the derivatives of dd at engagement. Its coefficients also depend on DD, and it decays to zero under the stability assumption. For distinct roots s1,…,sr−1s_1,\ldots,s_{r-1}, h(t)=∑j=1r−1cjesjth(t)=\sum_{j=1}^{r-1}c_je^{s_jt}; repeated roots produce the usual polynomial–exponential terms.

The three terms in Equation (41) expose the relevant behavior. The constant AA combines the engagement state with a rate-dependent offset, the linear term captures recovery induced by the achieved escape rate, and h(t)h(t) captures the inherited approach dynamics. A positive DD therefore does not preclude an initial decrease in d(t)d(t).

To obtain a sufficient collision condition, first consider the zero-rate solution, denoted by d0(t)d_0(t). From Equations (41) and (42),

lim⁡t→∞d0(t)=dmin⁡−ϕ(x0).(43)\lim_{t\to\infty}d_0(t)=d_{\min}-\phi(\mathbf{x}_0). \tag*{(43)}

Hence, if

ϕ(x0)>dmin⁡,(44)\phi(\mathbf{x}_0)>d_{\min}, \tag*{(44)}

then the limiting clearance is negative. Even when d(0)>0d(0)>0, continuity implies that d0(T)<0d_0(T)<0 for some finite T>0T>0. Solutions of the linear ODE in Equation (37) depend continuously on DD. There consequently exists an ε>0\varepsilon>0 such that

0<D<ε⟹d(T)<0.(45)0<D<\varepsilon\quad\Longrightarrow\quad d(T)<0. \tag*{(45)}

Thus, for the same engagement state, a sufficiently small positive achieved escape rate can satisfy the safety-index derivative constraint throughout the fixed-rate interval while the physical clearance crosses zero.

References

  1. [1]Ayush Agrawal and Koushil Sreenath. Discrete control barrier functions for safety-critical control of discrete systems with application to bipedal robot navigation. In Robotics: Science and Systems (RSS), 2017. doi: 10.15607/RSS.2017.XIII.073.DOI
  2. [2]Devansh K. Agrawal and Dimitra Panagou. Safe control synthesis via input constrained control barrier functions. In IEEE Conference on Decision and Control (CDC), 2021. arXiv:2104.01704.DOI
  3. [3]Aaron D. Ames, Samuel Coogan, Magnus Egerstedt, Gennaro Notomista, Koushil Sreenath, and Paulo Tabuada. Control barrier functions: Theory and applications. In European Control Conference (ECC), pages 3420–3431, 2019.arxiv.org/abs/1903.11199
  4. [4]Aaron D. Ames, Xiangru Xu, Jessy W. Grizzle, and Paulo Tabuada. Control barrier function based quadratic programs for safety critical systems. IEEE Transactions on Automatic Control, 62(8):3861–3876, 2017. arXiv: 1609.06408, doi:10.1109/TAC.2016.2638961.DOI
  5. [5]Karl Johan Åström and Tore Hägglund. PID Controllers: Theory, Design, and Tuning. Instrument Society of America, 2nd edition, 1995.
  6. [6]Bin4ry. Uniteabag: Unitree upk firmware update decryption and encryption. https://github.com/Bin4ry/UniTEABag, 2026.
  7. [7]Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, et al. π₀: A vision-language-action flow model for general robot control. arXiv preprint arXiv:2410.24164, 2024. arXiv: 2410.24164.arxiv.org/abs/2410.24164
  8. [8]Marcel Böhme, Van-Thuan Pham, Manh-Dung Nguyen, and Abhik Roychoudhury. Directed greybox fuzzing. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security (CCS), pages 2329–2344. ACM, 2017.DOI
  9. [9]Anthony Brohan, Noah Brown, Justice Carbajal, Yevgen Chebotar, Xi Chen, Krzysztof Choromanski, Tianli Ding, Danny Driess, Avinava Dubey, Chelsea Finn, et al. RT-2: Vision-language-action models transfer web knowledge to robotic control. In Conference on Robot Learning (CoRL), 2023. arXiv:2307.15818.arxiv.org/abs/2307.15818
  10. [10]Yulong Cao, Ningfei Wang, Chaowei Xiao, Dawei Yang, Jin Fang, Ruigang Yang, Qi Alfred Chen, Mingyan Liu, and Bo Li. Invisible for both camera and LiDAR: Security of multi-sensor fusion based perception in autonomous driving under physical-world attacks. In IEEE Symposium on Security and Privacy, 2021.DOI
  11. [11]Yulong Cao, Chaowei Xiao, Benjamin Cyr, Yimeng Zhou, Won Park, Sara Rampazzi, Qi Alfred Chen, Kevin Fu, and Z. Morley Mao. Adversarial sensor attack on LiDAR-based perception in autonomous driving. In ACM SIGSAC Conference on Computer and Communications Security, pages 2267–2281, 2019.DOI
  12. [12]Stephen Checkoway, Damon McCoy, Brian Kantor, Danny Anderson, Hovav Shacham, Stefan Savage, Karl Koscher, Alexei Czeskis, Franziska Roesner, and Tadayoshi Kohno. Comprehensive experimental analyses of automotive attack surfaces. In USENIX Security Symposium, 2011.
  13. [13]Hongxu Chen, Bihuan Chen, Yinxing Xue, Xiaofei Xie, Yang Liu, Yong Li, and Xiaohong Wu. Hawkeye: Towards a desired directed grey-box fuzzer. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security (CCS), pages 2095–2108. ACM, 2018.DOI
  14. [14]Peng Chen and Hao Chen. Angora: Efficient fuzzing by principled search. In Proceedings of the 2018 IEEE Symposium on Security and Privacy (SP), pages 711–725. IEEE, 2018.arxiv.org/abs/1803.01307
  15. [15]Rui Chen, Yifan Sun, and Changliu Liu. Dexterous safe control for humanoids in cluttered environments via projected safe set algorithm. arXiv preprint arXiv:2502.02858, 2025. URL: https://arxiv.org/abs/2502.02858, arXiv:2502.02858.
  16. [16]Yuxiao Chen, Mrdjan Jankovic, Mario Santillo, and Aaron D. Ames. Backup control barrier functions: Formulation and comparative study. In IEEE Conference on Decision and Control (CDC), 2021. arXiv:2104.11332.arxiv.org/abs/2104.11332
  17. [17]Charles Dawson, Sicun Gao, and Chuchu Fan. Safe control with learned certificates: A survey of neural Lyapunov, barrier, and contraction methods. IEEE Transactions on Robotics, 2023. arXiv:2202.11762, doi:10.1109/TRO.2022.3232542.DOI
  18. [18]Caiwu Ding, Tao Cui, Lingyun Wang, and Chengtao Wen. Toward certified functional safety for industrial humanoid robots: The fail-passive gap and a infeasibility study. arXiv preprint arXiv:2608.02809, 2026. URL: https://arxiv.org/abs/2608.02809, arXiv:2608.02809.
  19. [19]Andrea Fioraldi, Dominik Maier, Heiko Eissfeldt, and Marc Heuse. Afl++: Combining incremental steps of fuzzing research. In 14th USENIX Workshop on Offensive Technologies (WOOT 20), 2020.
  20. [20]Thomas Gurriet, Andrew W. Singletary, Jake Reher, Laurent Ciarletta, Eric M. Feron, and Aaron D. Ames. Towards a framework for realizable safety critical control through active set invariance. In ACM/IEEE International Conference on Cyber-Physical Systems (ICCPS), 2018.
  21. [21]Hassan K. Khalil. Nonlinear Systems. Prentice Hall, 3rd edition, 2002.
  22. [22]Charles Khazoom, Daniel González-Díaz, Yanran Ding, and Sangbae Kim. Humanoid self-collision avoidance using whole-body control with control barrier functions. In IEEE-RAS International Conference on Humanoid Robots, 2022.arxiv.org/abs/2207.00692
  23. [23]Hyungsub Kim, Muslum Ozgur Ozmen, Antonio Bianchi, Z. Berkay Celik, and Dongyan Xu. PGFUZZ: Policy-guided fuzzing for robotic vehicles. In Network and Distributed System Security Symposium, 2021.DOI
  24. [24]Hyungsub Kim, Muslum Ozgur Ozmen, Z. Berkay Celik, Antonio Bianchi, and Dongyan Xu. PatchVerif: Discovering faulty patches in robotic vehicles. In USENIX Security Symposium, 2023.
  25. [25]Moo Jin Kim, Karl Pertsch, Siddharth Karamcheti, Oier Mees, Shikhar Bahl, Antonio Loquercio, Suraj Shi, Finale Doshi-Velez, Chelsea Finn, Sergey Levine, et al. OpenVLA: An open-source vision-language-action model. In Conference on Robot Learning (CoRL), 2024. arXiv:2406.09246.arxiv.org/abs/2406.09246
  26. [26]Karl Koscher, Alexei Czeskis, Franziska Roesner, Shwetak Patel, Tadayoshi Kohno, Stephen Checkoway, Damon McCoy, Brian Kantor, Danny Anderson, Hovav Shacham, and Stefan Savage. Experimental security analysis of a modern automobile. In IEEE Symposium on Security and Privacy, pages 447–462, 2010.
  27. [27]Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016.arxiv.org/abs/1504.00702
  28. [28]Changliu Liu and Masayoshi Tomizuka. Algorithmic safety measures for intelligent industrial co-robots. In IEEE International Conference on Robotics and Automation (ICRA), pages 3095–3102, 2016. doi:10.1109/ICRA.2016.7487476.DOI
  29. [29]Chenyang Lyu, Shouling Ji, Chao Zhang, Yuwei Li, Wei-Han Lee, Yu Song, and Raheem Beyah. MOPT: Optimized mutation scheduling for fuzzers. In 28th USENIX Security Symposium (USENIX Security ’19), pages 1949–1966. USENIX Association, 2019.
  30. [30]Víctor Mayoral-Vilches. Cybersecurity AI: Humanoid robots as attack vectors. arXiv preprint arXiv:2509.14139, 2025.
  31. [31]Víctor Mayoral-Vilches. The cybersecurity of a humanoid robot: An early study on the cybersecurity of humanoid robots via the Unitree G1. arXiv preprint arXiv:2509.14096, 2025.
  32. [32]Víctor Mayoral Vilches, Laura Alzola Kirschgens, Asier Bilbao Calvo, Alejandro Hernández Cordero, Rodrigo Izquierdo Pisón, David Mayoral Vilches, Aday Muñiz Rosas, Gorka Olalde Mendia, Lander Usategi San Juan, Irati Zamalloa Ugarte, Endika Gil-Uriarte, Erik Tews, and Andreas Peter. Introducing the robot security framework (RSF), a standardized methodology to perform security assessments in robotics. arXiv preprint arXiv:1806.04042, 2018.arxiv.org/abs/1806.04042
  33. [33]Víctor Mayoral-Vilches, Unai Ayucar Carbajo, and Endika Gil-Uriarte. Industrial robot ransomware: Akerbeltz. In 2020 Fourth IEEE International Conference on Robotic Computing (IRC), pages 432–435, 2020.
  34. [34]Ian M. Mitchell, Alexandre M. Bayen, and Claire J. Tomlin. A time-dependent Hamilton-Jacobi formulation of reachable sets for continuous dynamic games. IEEE Transactions on Automatic Control, 50(7):947–957, 2005. doi:10.1109/TAC.2005.851439.DOI
  35. [35]Raymond Muller, Yanmao Man, Z. Berkay Celik, Ming Li, and Ryan Gerdes. DriveTruth: Automated autonomous driving dataset generation for security applications. In International Workshop on Automotive and Autonomous Vehicle Security, 2022.
  36. [36]Quan Nguyen and Koushil Sreenath. Exponential control barrier functions for enforcing high relative-degree safety-critical constraints. In American Control Conference (ACC), 2016.
  37. [37]NIST. National vulnerability database: CVE-2025-35027. https://nvd.nist.gov/vuln/detail/CVE-2025-35027, 2025.
  38. [38]NIST. National vulnerability database: CVE-2025-60017. https://nvd.nist.gov/vuln/detail/CVE-2025-60017, 2025.
  39. [39]NIST. National vulnerability database: CVE-2026-27509. https://nvd.nist.gov/vuln/detail/CVE-2026-27509, 2026.
  40. [40]Chengyang Peng, Victor Paredes, Guillermo A. Castillo, and Ayonga Hereid. Real-time safe bipedal robot navigation using linear discrete control barrier functions. In IEEE International Conference on Robotics and Automation (ICRA), 2025. arXiv:2411.03619, doi:10.1109/ICRA55743.2025.11128366.DOI
  41. [41]Stephen Prajna and Ali Jadbabaie. Safety verification of hybrid systems using barrier certificates. In Hybrid Systems: Computation and Control (HSCC), Lecture Notes in Computer Science, 2004. doi:10.1007/978-3-540-24743-2_32.DOI
  42. [42]L. Prieto-López, S. Sánchez de la Fuente, D. Carrera-Martínez, F. J. Rodríguez-Lera, and L. Sánchez-González. Cybersecurity audit of the Unitree Go2 quadruped robot. In Artificial Intelligence in Security. Springer, 2026. doi:10.1007/978-3-032-29251-3_12.
  43. [43]Reuven Y. Rubinstein. The cross-entropy method for combinatorial and continuous optimization. Methodology and Computing in Applied Probability, 1(2):127–190, 1999. doi:10.1023/A:1010091220143.DOI
  44. [44]Junjie Shen, Jun Yeon Won, Zeyuan Chen, and Qi Alfred Chen. Drift with devil: Security of multi-sensor fusion based localization in high-level autonomous driving under GPS spoofing. In USENIX Security Symposium, 2020.
  45. [45]Bruno Siciliano, Lorenzo Sciavicco, Luigi Villani, and Giuseppe Oriolo. Robotics. Modelling, Planning and Control. Springer, 2009. doi:10.1007/978-1-84628-642-1.
  46. [46]Ruoyu Song, Muslim Ozgur Ozmen, Hyungsub Kim, Raymond Muller, Z. Berkay Celik, and Antonio Bianchi. Discovering adversarial driving maneuvers against autonomous vehicles. In USENIX Security Symposium, 2023.
  47. [47]Jiachen Sun, Yulong Cao, Qi Alfred Chen, and Z. Morley Mao. Towards robust LiDAR-based perception in autonomous driving: General black-box adversarial sensor attack and countermeasures. In USENIX Security Symposium, 2020.arxiv.org/abs/2006.16974
  48. [48]Yifan Sun, Rui Chen, Kai S. Yun, Yikuan Fang, Sebin Jung, Feihan Li, Bowei Li, Weiye Zhao, and Changliu Liu. SPARK: Safe protective and assistive robot kit. In IFAC Symposium on Robotics, 2025. URL: https://arxiv.org/abs/2502.03132, arXiv:2502.03132.
  49. [49]UC San Diego Today. Surgeons use teleoperated humanoid robots to perform live surgery. https://today.ucsd.edu/story/surgeons-use-teleoperated-humanoid-robots-to-perform-live-surgery-a-world-first, 2026.
  50. [50]Unitree Robotics. Unitree robot SDK version 2 (unitree_sdk2). https://github.com/unitreerobotics/unitree_sdk2, 2024. Accessed 2025.
  51. [51]Kim P. Wabersich and Melanie N. Zeilinger. A predictive safety filter for learning-based control of constrained nonlinear dynamical systems. Automatica, 129:109597, 2021.arxiv.org/abs/1812.05506
  52. [52]Tianhao Wei and Changliu Liu. Safe control algorithms using energy functions: A unified framework, benchmark, and new directions. In IEEE Conference on Decision and Control (CDC), 2019. arXiv:1908.01883.arxiv.org/abs/1908.01883
  53. [53]Wei Xiao and Calin Belta. Control barrier functions for systems with high relative degree. In IEEE Conference on Decision and Control (CDC), 2019.arxiv.org/abs/1903.04706
  54. [54]Xiangru Xu, Paulo Tabuada, Jessy W. Grizzle, and Aaron D. Ames. Robustness of control barrier functions for safety critical control. In IFAC Conference on Analysis and Design of Hybrid Systems (ADHS), 2015.DOI
  55. [55]Jean-Paul A. Yaacoub, Hassan N. Noura, Ola Salman, and Ali Chehab. Robotics cyber security: Vulnerabilities, attacks, countermeasures, and recommendations. International Journal of Information Security, 21:115–158, 2022.DOI
  56. [56]Doguhan Yeke, Kartik A. Pant, Muslum Ozgur Ozmen, Hyungsub Kim, James M. Goppert, Inseok Hwang, Antonio Bianchi, and Z. Berkay Celik. Automated discovery of semantic attacks in multi-robot navigation systems. In USENIX Security Symposium, 2025.
  57. [57]Kai S. Yun, Rui Chen, Chase Dunaway, John M. Dolan, and Changliu Liu. Safe control of quadruped in varying dynamics via safety index adaptation. In IEEE International Conference on Robotics and Automation (ICRA), 2025. arXiv:2409.09882, doi:10.1109/ICRA55743.2025.11127362.DOI
  58. [58]Yan Zhang, Zihao Liu, Yi Zhu, and Chenglin Miao. Towards real-time defense against object-based lidar attacks in autonomous driving. In Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security, CCS ’25, page 3825–3839, New York, NY, USA, 2025. Association for Computing Machinery.DOI
  59. [59]Weiye Zhao, Tairan He, and Changliu Liu. Model-free safe control for zero-violation reinforcement learning. In Conference on Robot Learning (CoRL), 2021.
  60. [60]Weiye Zhao, Tairan He, Tianhao Wei, Simin Liu, and Changliu Liu. Safety index synthesis via sum-of-squares programming. In American Control Conference (ACC), pages 732–737. IEEE, 2023. arXiv:2209.09134, doi:10.23919/ACC55779.2023.10156463.DOI

Paper details

vlnc:W_v2fdf5pk
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY-SA 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents