authenticated data structures

This work addresses the challenge of formally guaranteeing security and correctness in the automated generation of authenticated data structures (ADS). We introduce the first relational separation logic supporting collision-resistant hash functions and construct a bilingual semantic model in Coq to rigorously characterize type abstraction security. Based on this logic, we implement fully automatic code generation for an ADS library and mechanize proofs of its functional correctness, memory safety, and equivalence of key optimizations. Moreover, we establish the first formal framework proving secure interoperability between automatically generated code and hand-optimized implementations. Our approach integrates Iris concurrent separation logic with cryptographic hash modeling, enabling end-to-end trustworthiness under a unified formal foundation. The result is a verifiable construction paradigm for high-assurance ADS systems.

This work addresses the challenge of efficiently verifying whether an AI agent’s behavior adheres to a prescribed policy without relying on trust in the agent or re-executing its computations. The authors propose a novel paradigm that integrates formal methods with cryptographic proofs: policy specifications are encoded as logical predicates, compiled into polynomial constraints, and used to generate succinct, independently verifiable certificates via Succinct Non-interactive Arguments of Knowledge (SNARKs), optionally with zero-knowledge guarantees. This framework enables an end-to-end transformation from high-level policy statements to verifiable evidence, facilitating trustless compliance auditing and bridging the gap between AI governance, deployment, and formal verification.

This work addresses the challenge of ensuring execution validity in partially observable environments, where existing mechanisms—focused solely on verifying computational and state integrity—fall short. The paper introduces the Reconstruction-based Authority Model (RAM), which formulates execution validity as a coverage reconstruction problem. RAM explicitly distinguishes between known states, asserted hypotheses, and unobservable residuals to dynamically assess the sufficiency of execution coverage and accordingly adjust or deny permissions. Integrating formal modeling, reconstruction-gated logic, coverage envelope analysis, and a trusted attestation mechanism, RAM transcends the limitations of traditional integrity-centric approaches. Empirical evaluation demonstrates zero invalid executions across 100,000 synthetic trials, whereas pure attestation mechanisms exhibit a 23.3% invalid execution rate even under full coverage conditions.

This paper addresses the challenge in formal verification of cryptographic protocols—balancing rigorous correctness proofs with cross-layer reusability. To this end, we propose Cryptis, the first verification framework for authentication protocols built upon Iris separation logic. Our approach comprises three key contributions: (1) designing the first separation logic specification tailored to authentication protocols, unifying the modeling of protocol behavior and security properties; (2) enabling hierarchical verification of protocols and their composed systems within the symbolic cryptographic model; and (3) conducting end-to-end formal verification in Coq of multiple classical authentication protocols and a key-value storage server, formally establishing confidentiality, integrity, and authentication. Crucially, Cryptis supports systematic reuse of verified components at the system level, thereby enhancing composability and trustworthiness of cryptographic modules.

This work addresses the limitations of traditional binary trust models in trusted computing by proposing a formal trust framework grounded in category theory and Heyting algebras. Trust elements, assertions, outcomes, and decisions are modeled as objects, while proofs, verification, and decision processes are treated as morphisms. The framework introduces exponential objects to capture the compositional nature of proof operations. Notably, it is the first to integrate category theory with Heyting algebras, enabling fine-grained representation of trust levels and providing a novel metric to quantify the expressive power of proof environments. Experimental evaluations demonstrate the model’s expressiveness and scalability in scenarios including boot-run-shutdown sequences, Evil Maid attack analysis, and multi-component dynamic systems.

This work addresses the growing complexity of cryptographic proofs and the high cost of manual verification and formal proof scripting. To tackle this challenge, the paper introduces ShannonProver, an agent-based automated framework that integrates with the EasyCrypt tool to synthesize formal proof scripts from user-specified security models and lemma-level proof obligations. This approach achieves, for the first time, the automated synthesis of proofs for numerous complex obligations arising in real-world protocols such as ChaChaPoly1305 and MEE-CBC. Evaluated on a diverse dataset encompassing textbook primitives, deployed protocols, and NIST proposals, ShannonProver substantially lowers the barrier to formal verification, thereby accelerating the development and deployment of trustworthy cryptographic protocols.

This work addresses the absence of cryptographic evidence verifying that autonomous AI agents comply with authorization policies within specific execution contexts. To bridge this gap, the paper introduces a cryptographically verifiable authorization relation, denoted $R_{CVA}$, which structurally decouples identity, request, and execution context. It formally defines critical security properties—such as authorization soundness and policy binding—and enables verification while preserving the confidentiality of private attributes. The authors instantiate the core model through a zero-knowledge proof prototype built upon the Groth16 zk-SNARK framework, thereby providing the first practical demonstration of cryptographically verifiable agent authorization.

Current AI agent protocols commonly suffer from incomplete security requirements, inconsistent enforcement, and a lack of cross-protocol accountability in both specifications and implementations. This work proposes AgentThread, a novel framework that introduces hierarchical security scopes and protocol-derived TLA+ invariants, coupled with a two-phase verification mechanism to enable end-to-end security analysis from textual specifications to runtime SDKs. By integrating formal verification, model checking, and source-code linkage techniques, AgentThread automatically compiles protocol specifications and generates replayable test cases. Evaluation across five widely used agent protocols uncovered 35 specification-level flaws, validated through 80 SDK tests, and revealed 30 previously unknown vulnerabilities that manifest only under specific protocol compositions.

This work addresses the high barrier to entry in formal verification of cryptographic protocols and the difficulty of tracing verification results back to concrete implementations. The authors propose a domain-specific language (DSL)-centric development methodology that pioneers a “language-first” modeling paradigm. Their approach automatically translates protocol implementations into Tamarin-verifiable models and integrates symbolic execution to ensure memory safety. This framework guarantees that general trace properties established through formal verification are correctly mapped back to the original source code. Empirical evaluation demonstrates the successful generation of precise models for Signed Diffie-Hellman and WireGuard protocols; notably, the resulting WireGuard implementation achieves interoperability, practical usability, and compositional security guarantees.

This work addresses the lack of formally verifiable, fine-grained access control mechanisms in local-first systems operating at scale under low-trust collaboration settings. We propose a bottom-up approach that integrates a capability-based authorization model with Hashed Chronicle—a replicated data type—to design a Byzantine fault-tolerant collaborative group management mechanism. For the first time, system-level formal verification is introduced into local-first access control by leveraging the Verus framework to specify and verify a Rust implementation with zero runtime overhead. We formalize the semantics and key invariants of a simplified CRDT and prove the correctness of the core authorization logic, thereby providing Matrix, Keyhive, and similar systems with an integrable, high-assurance security foundation.