[Paper] Vouchsafe: A Zero-Infrastructure Capability Graph Model for Offline Identity and Trust

Source: arXiv - 2601.02254v1

Overview

The paper introduces Vouchsafe, a system that lets you prove who you are, delegate authority, and revoke credentials without any online infrastructure. By modeling identity and trust as a Zero‑Infrastructure Capability Graph (ZI‑CG), the authors show that all verification can be done locally on a device, making secure identity possible even in disaster zones, isolated networks, or under censorship.

Key Contributions

• Zero‑Infrastructure Capability Graph (ZI‑CG) – A formal model that represents identities, delegations, and revocations as self‑contained, signed statements that can be evaluated deterministically without external services.
• Vouchsafe implementation – A practical prototype built entirely from existing standards (Ed25519 signatures, SHA‑256 hashes, and JSON Web Tokens) – no new cryptography or protocols required.
• Offline verification algorithm – A deterministic, local evaluation procedure that checks the entire trust chain using only the data present in the statements.
• Empirical evaluation – Benchmarks demonstrating that verification latency and memory usage are suitable for resource‑constrained devices (e.g., smartphones, embedded IoT nodes).
• Open‑source reference – The authors release the code and test vectors, enabling immediate experimentation and integration.

Methodology

1. Capability Graph Construction – Identities issue capability tokens (signed JSON objects) that encode a specific right (e.g., “read sensor X”). Tokens can delegate sub‑capabilities to other principals, forming a directed acyclic graph.
2. Self‑Containment – Each token carries all the information needed for verification: the issuer’s public key, the delegation chain, expiration timestamps, and a revocation hash. No lookup to a remote directory is required.
3. Deterministic Evaluation – The verifier walks the graph from the presented token back to a root of trust (a pre‑installed “anchor” public key). At each step it checks:
   • Signature validity (Ed25519)
   • Temporal constraints (not before/after)
   • Revocation status (hash‑based proof that a revocation has not been issued)
4. Implementation Stack – The prototype uses standard JWT fields (iss, sub, exp, nbf) plus custom claims for delegation and revocation. Cryptographic operations rely on widely‑available libraries (libsodium for Ed25519, OpenSSL for SHA‑256).

Results & Findings

• Verification time: < 5 ms on a mid‑range smartphone for graphs up to 10 hops; < 20 ms on a low‑power ARM Cortex‑M4 MCU.
• Memory footprint: < 150 KB of RAM for the entire verification engine and token cache.
• Scalability: The graph size grows linearly with delegation depth; performance degrades gracefully, making the model practical for typical use‑cases (e.g., a few delegation hops).
• Security: Formal analysis confirms that, under the standard assumptions for Ed25519 and SHA‑256, an attacker cannot forge a valid capability chain or bypass revocation without possessing the private key of an authorized issuer.

Practical Implications

• Disaster response – Field teams can exchange signed capability tokens (e.g., “access to medical inventory”) without needing a central server, ensuring that only authorized personnel can act even when cellular networks are down.
• Edge/IoT deployments – Devices can delegate limited rights to neighboring nodes (e.g., “publish sensor data for the next hour”) without contacting a cloud‑based policy engine, reducing latency and bandwidth usage.
• Censorship‑resistant services – Applications can verify user permissions locally, preventing adversaries from blocking trust verification by taking down online directories.
• Zero‑trust architectures – Vouchsafe can complement existing zero‑trust stacks by providing an offline fallback for credential validation when connectivity is intermittent.

Limitations & Future Work

• Root of trust distribution – The model assumes that each verifier already possesses a trusted anchor public key; bootstrapping this anchor in truly hostile environments remains an open challenge.
• Revocation propagation – While revocation is expressed as a hash proof of non‑existence, disseminating fresh revocation information still requires occasional out‑of‑band updates (e.g., physical media or opportunistic sync).
• Graph size constraints – Extremely deep delegation chains could become unwieldy for ultra‑constrained devices; future work may explore compression or summarization techniques.
• Formal verification – The authors plan to develop machine‑checked proofs of the evaluation algorithm to further harden the security guarantees.

Authors

• Jay Kuri

Paper Information

• arXiv ID: 2601.02254v1
• Categories: cs.CR, cs.DC
• Published: January 5, 2026
• PDF: Download PDF