Skip to content
Crypto.world

Research

Hermes Seal: Zero-Knowledge Assurance for Autonomous Vehicle Communications

Autonomous vehicles benefit from cooperative perception — sharing what they detect with nearby vehicles and roadside units — but a receiving vehicle has no way to check whether a broadcast perception…

Hermes Seal: Zero-Knowledge Assurance for Autonomous Vehicle Communications
arXiv
2603.26343
Published
2026-03-27
Authors
Munawar Hasan, Apostol Vassilev, Edward Griffor, Thoshitha Gamage

AI summary

Overview

Research area: Cryptography and security — specifically zero-knowledge proofs (ZKPs) applied to autonomous vehicle (AV) perception and vehicle-to-vehicle (V2V) / vehicle-to-infrastructure (V2I) communication.

Technical level: Intermediate. The paper assumes familiarity with basic cryptographic primitives (hashing, digital signatures, commitments) and with zk-SNARK terminology, but it explains the zk-SNARK pipeline and its design rationale in accessible terms, so a reader with general ML/systems background can follow the argument.

Scope: The paper proposes and empirically evaluates Hermes' Seal, a zk-SNARK-based framework (built on Groth16 and Circom) that lets an autonomous vehicle attach a succinct cryptographic proof to broadcast perception data, certifying that the output satisfies a publicly specified regulatory policy without revealing raw sensor data, model weights, or internal activations.

What This Paper Is About

Autonomous vehicles benefit from cooperative perception — sharing what they detect with nearby vehicles and roadside units — but a receiving vehicle has no way to check whether a broadcast perception packet is correct, complete, or policy-compliant, since the sender is unknown and the underlying model and sensor data are proprietary. The paper's goal is to replace trust in the sender's identity with trust in a mathematical proof: the sending vehicle (prover) generates a non-interactive zk-SNARK showing that its perception output satisfies constraints defined by an enforcing authority, and any receiver (verifier) can check that proof cheaply without seeing private data. The framework is demonstrated through two case studies, one on real-time proof generation/verification and one on proving computation over an AV perception stack.

Key Contributions

  1. The Hermes' Seal framework itself. A zk-SNARK-based framework for "verifiable autonomous system information exchanges" that enables perception data to be exchanged with cryptographically verifiable correctness while concealing proprietary model information and raw sensor inputs. It is designed to be model-agnostic (works regardless of whether the AV uses YOLO, DETR, or PointPillars) and to integrate post-inference as a module without retraining existing models.

  2. A solution to a stated open problem in cooperative perception. The authors frame the lack of verifiable guarantees on externally received safety-critical data as a fundamental limitation, and address it for broadcast, receiver-agnostic V2X settings where senders and receivers have no prior relationship.

  3. A ZKP-based mechanism for privacy-preserving verification of vehicle compliance by authorities. The framework supports retrospective auditing, in which the enforcing authority can demand the opening of commitments to check historical data against logs.

  4. Two implemented, empirically evaluated case studies plus open-source code. Both case studies were implemented and evaluated within the framework, and the demonstration code is released on GitHub (https://github.com/mhasan08/zk-AV).

Main Findings

  • Millisecond-scale proofs in the first case study: The first case study demonstrates real-time proof generation and verification, achieving 8 ms proof generation and 1 ms verification on a GPU.
  • Second case study targets a real perception stack: The second case study evaluates the performance of an autonomous vehicle perception stack, enabling proof of computation without exposing proprietary or confidential data. (The specific quantitative results for this case study fall in the paper's experimental-results section, which is not included in the truncated content provided.)
  • Existing verifiable-ML systems are far too slow for AVs: The paper cites zkCNN, which requires 20–30 seconds to generate a proof for the VGG16 model (configuration D) with a proof size of 200–300 KB; Zkml, which takes 52.9 s to generate a 12 KB proof; Mystique, which requires communication overhead exceeding 1.5 GB for ResNet50; and vCNN, which takes up to 8 hours for proof generation and 19 s for verification. Each is characterized as unusable for real-time safety systems.
  • Groth16 chosen for constant-size proofs and fast verification: Groth16 produces proofs of constant size of approximately 128 bytes (three group elements) with constant-time verification, which the authors argue suits bandwidth-limited V2X links despite the need for a trusted setup. Alternatives such as PLONK, Halo2, and STARKs avoid the trusted setup but typically yield larger proofs and less uniform verification costs.
  • Non-interactive proofs are the right fit, not interactive ones: Because cooperative perception broadcasts data to many unknown receivers over asynchronous channels, maintaining interactive sessions with every recipient is described as infeasible; zk-SNARKs let each receiver independently verify a single standalone proof.
  • The trust anchor is a regulator, not a vendor: The enforcing authority (conceptually aligned with NHTSA, SAE, or AAA) defines the constraint set, compiles the circuit, runs the trusted setup, and maintains a registry of verification keys for approved model architectures. The paper claims this means no vehicle manufacturer gains unilateral influence over proving-key generation.
  • Scope is deliberately limited to inference-level verification: Rather than proving the entire autonomy stack, the framework verifies specific inference outputs against defined safety constraints, which the authors present as the balance needed to retain real-time performance.

Methodology in Plain English

The authors start from a concrete failure mode: an ego vehicle approaching an intersection cannot see a cyclist occluded by a building, while another vehicle can. Broadcasting that observation is useful, but the receiver has no basis to trust it. So the design puts a policy layer in the middle.

An enforcing authority writes down safety rules as formal constraints — the paper's running example is that an AV may initiate braking only if the probability of detecting the relevant object exceeds 75%. Those rules are compiled with Circom into an arithmetic circuit, converted into a Rank-1 Constraint System (R1CS) and then a Quadratic Arithmetic Program (QAP), and used with a universal Powers of Tau file to produce a proving key (given to manufacturers) and a verification key (published for everyone).

The vehicle then runs its normal perception model, and afterwards — as a separate module, with no retraining — takes the outputs and splits them into public inputs (the instance: e.g., the object label, the claimed coordinates or distance) and private inputs (the witness: raw sensor data, model weights, internal activations). A quantization scheme converts floating-point values into finite-field elements via a scaling function with factor ρ, with an inverse function for decoding; the paper's example maps 0.75 with ρ = 100 to 75 in the field, and notes that modular wraparound does not occur when values stay well below p/2. A commitment to the private data is computed inside the circuit using an arithmetic-friendly hash such as Poseidon, while the outer message signature uses a standard hash such as SHA-256.

The prover produces the proof and signs a payload that binds together a domain separator, hashes of the R1CS, verification key, certificate, and proof, plus the commitment, a Unix-epoch timestamp, and a random nonce for replay protection. The resulting package — proof, public inputs, commitment, signature, verification key, vehicle certificate, and the R1CS hash — is broadcast. A verifier first checks the digital signature to authenticate the source, then validates the proof against the verification key and public inputs. Security is analyzed in the Random Oracle Model against a probabilistic polynomial-time adversary acting either as a dishonest prover (attacking soundness and commitment binding) or as an external observer (attacking zero-knowledge and commitment hiding), with the enforcing authority treated as a trusted third party that securely destroys the "toxic waste" setup randomness.

Why This Matters

Impact on research. The paper pushes ZKP research away from full-model verification and blockchain-anchored verifiable computation toward narrow, latency-bounded verification of inference outputs. It explicitly argues that blockchain-based approaches introduce consensus latency and infrastructure dependency incompatible with millisecond decision loops, and that communication-heavy interactive protocols are unsuited to V2X bandwidth. Framing the enforcing authority as a regulator that issues proving and verification keys — analogous to existing credentialing for vehicle identification, emissions compliance, and V2X communication — gives the cryptographic protocol a governance story that most ZKP-for-ML work lacks.

Real-world applications:

  • Cooperative perception in occluded urban environments — extending effective sensing range beyond line-of-sight while preventing adversarial or faulty broadcast data from entering the safety-critical decision loop.
  • Regulatory compliance and type approval — proving that perception outputs meet minimum confidence thresholds, geometric consistency, and mandatory safety-critical object inclusion, without handing over proprietary models.
  • Post-incident investigation and auditing — the enforcing authority opens commitments to check that logged private inputs and randomness match what was committed at the time.
  • Insurance and consumer-safety assessment — AAA and insurers are named as potential parties that could define auditable safety guarantees.

Industry relevance. The framework is pitched as model-agnostic and modular, so a fleet operator using a camera-centric stack (Tesla is cited) and one using camera-LiDAR-HD-map fusion (Waymo is cited) could both produce proofs against the same public policy. That matters for heterogeneous fleets, for intellectual-property protection, and for any deployment where privacy regulation limits raw data sharing.

Future Directions

  • Transparent proof systems and adversarial enforcing authorities. The current work assumes a trusted EA; the authors state that extending Hermes' Seal to transparent proof systems or to an EA that need not be trusted remains an important direction, since the framework itself is agnostic to the proof system.
  • Extending beyond perception. The design principles claim extensibility to planning and control, with application-specific constraints in the circuit attesting to safety compliance, ethical decision logic, or policy adherence.
  • Key management and PKI integration. The paper explicitly places distribution and management of proving/verification keys, and the mechanism by which provers receive certificates and signing key pairs, outside its scope.
  • Threats outside the cryptographic boundary. Sensor integrity — protection against GPS spoofing or sensor blinding — is declared out of scope, leaving a gap between "the witness correctly reflects the sensor reading" and the physical world.

Target Audience

Cryptography and security researchers working on ZKPs for machine learning and cyber-physical systems; automotive engineers and architects designing perception stacks and V2X stacks; standards and regulatory staff at bodies such as NHTSA, SAE, or consumer-safety organizations evaluating verifiable compliance mechanisms; and graduate students looking for a concrete, open-source worked example of applying Groth16 and Circom to a latency-constrained real-world problem. Readers seeking complete benchmark tables, dataset sizes, or detailed hardware specifications will not find them in the excerpt analyzed here — those details belong to the paper's experimental-results section, which is not part of the provided content.

Authors’ abstract

The application of zero-knowledge proofs (ZKPs) in autonomous systems is an emerging area of research, motivated by the growing need for regulatory compliance, transparent auditing, and trustworthy operation in decentralized environments. zk-SNARK is a powerful cryptographic tool that allows a party (the prover) to prove to another party (the verifier) that a statement about its own internal state is true, without revealing sensitive or proprietary data about that state.…

The full abstract on arXiv
Read the original paper