What sensor attestation proofs must accompany physical actuator commands in autonomous robotics?

**Date of Record:** 2026 October 26 **Scope:** Applies when an agentic session issues physical actuator commands (motor control, throttle, steering) to an embodied system, and the underlying sensors (LiDAR, cameras, GPS) could be spoofed or compromised. Does not apply to strictly simulated environments or systems operating in fully controlled, secure perimeters with no adversarial physical presence.

Core Distinction

The separation between **software-level coordinates** (the raw data arrays from the sensor drivers, which can be spoofed by a compromised operating system or malicious process) and **hardware-rooted attestation** (cryptographic proof generated by a Secure Enclave, TPM, or hardware security module that binds the sensor reading to the physical hardware). Failing to distinguish these creates the **Sensor Spoofing Gap**: an attacker injects fake coordinates into the software stack, and the successor robot blindly trusts them, driving into a collision or off a cliff.

What Was Observed

In embodied agent architectures, failing to require hardware attestation for actuator commands produces three primary failure modes:

  1. **GPS Spoofing:** An attacker broadcasts a stronger, fake GPS signal. The robot's software layer receives and trusts the forged coordinates, and the successor agent navigates the robot into a restricted zone or off-course.
  2. **LiDAR Injection:** A malicious actor injects fake point-cloud data into the network bus, making the robot believe the path is clear when a human is standing in front of it. The successor resumes motion and causes a catastrophic collision.
  3. **Camera Override:** The operating system is compromised, and the camera driver is replaced with a spoofed feed of an empty road. The successor, trusting the software feed, accelerates into a real obstacle.

Recorded Elements

  1. **`hardware_attestation_signature`:** The cryptographic signature generated by the sensor's hardware root of trust (e.g., TPM quote or Secure Enclave attestation) over the raw sensor data.
  2. **`sensor_health_receipt`:** The cryptographic hash of the sensor's diagnostic state (temperature, voltage, calibration drift) at the time of the reading, proving the sensor is not physically degraded.
  3. **`actuator_command_nonce`:** The unique nonce binding the attestation to the specific actuator command, preventing replay attacks where a previously valid sensor reading is reused.
  4. **`physical_failsafe_state`:** The explicit state of the physical emergency-stop system at the time of command, ensuring the robot can safely abort if attestation fails.

Condition of Validity

* **Applies when:** The physical robot operates in an environment where an attacker could physically or digitally spoof sensor readings, and the consequences of a spoofed reading include physical harm, property damage, or security breach. * **Does not apply when:** The robot operates in an isolated, physically sealed environment with no adversarial presence, or the sensors are hardwired with no digital interface that could be compromised.

Decision Boundary

  1. **Is the actuator command moving the robot based on real-time sensor input?** If no, standard navigation logic applies. If yes, proceed.
  2. **Is the `hardware_attestation_signature` present and valid?** If no, the sensor reading is untrusted. The successor must immediately halt motion and engage the `physical_failsafe_state`.
  3. **Does the `sensor_health_receipt` indicate a degraded or tampered sensor?** If yes, the successor must treat the reading as invalid and abort the mission.
  4. **Conversely, when can a robot trust a sensor reading without hardware attestation?** Only if the robot is operating in a fully enclosed, supervised environment (e.g., a certified cleanroom) where physical spoofing is impossible, or the sensor reading is only used for non-safety-critical logging.

Operational Effect

  1. **Spoofing Immunity:** Prevents attackers from overriding physical sensor data by forcing the agent to verify the hardware root of trust before moving.
  2. **Physical Safety Enforcement:** Guarantees that motion only proceeds when the sensor data is cryptographically proven to originate from the physical hardware, not a compromised software layer.
  3. **Deterministic Abort:** Provides a fail-closed mechanism to immediately halt the robot if attestation fails, preventing catastrophic physical consequences.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ActuatorVerdict(Enum):
    SAFE_TO_ACTUATE = auto()
    HALT_SPOOFING_DETECTED = auto()
    HALT_SENSOR_DEGRADED = auto()
    HALT_NO_ATTESTATION = auto()

@dataclass(frozen=True)
class SensorReading:
    sensor_id: str
    raw_data_hash: str
    attestation_signature: str | None
    health_receipt_hash: str | None

@dataclass(frozen=True)
class ActuatorCommand:
    command_id: str
    nonce: str
    expected_sensor_id: str

@dataclass(frozen=True)
class ActuationManifest:
    verdict: ActuatorVerdict
    directive: str
    manifest_digest: str

class HardwareRootOfTrustGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_actuation(
        cls, reading: SensorReading, command: ActuatorCommand
    ) -> ActuationManifest:
        
        # Gate 1: Hardware attestation presence
        if not reading.attestation_signature:
            return ActuationManifest(
                verdict=ActuatorVerdict.HALT_NO_ATTESTATION,
                directive="HALT: Sensor reading lacks hardware attestation. Engage physical failsafe.",
                manifest_digest=cls._hash(f"NO_ATTEST:{command.command_id}")
            )

        # Gate 2: Sensor health
        if not reading.health_receipt_hash:
            return ActuationManifest(
                verdict=ActuatorVerdict.HALT_SENSOR_DEGRADED,
                directive="HALT: Sensor health receipt missing. Potential hardware tampering.",
                manifest_digest=cls._hash(f"DEGRADED:{reading.sensor_id}")
            )

        # Gate 3: Sensor identity match
        if reading.sensor_id != command.expected_sensor_id:
            return ActuationManifest(
                verdict=ActuatorVerdict.HALT_SPOOFING_DETECTED,
                directive=f"HALT: Command expected sensor {command.expected_sensor_id}, received {reading.sensor_id}.",
                manifest_digest=cls._hash(f"SENSOR_MISMATCH:{command.command_id}")
            )

        # Gate 4: Safe to actuate
        digest = cls._hash(json.dumps({
            "command": command.command_id,
            "sensor": reading.sensor_id,
            "nonce": command.nonce,
            "attestation": reading.attestation_signature
        }, sort_keys=True))
        
        return ActuationManifest(
            verdict=ActuatorVerdict.SAFE_TO_ACTUATE,
            directive="PROCEED: Hardware root of trust verified. Execute actuator command.",
            manifest_digest=digest
        )