IDEA-DAC: Integrity-Driven Editing for Accountable Decentralized Anonymous Credentials via ZK-JSON

Shuhao Zheng, Zonglun Li, Junliang Luo, Ziyue Xin, Xue Liu

TL;DR

This paper introduces IDEA-DAC, a novel system for managing decentralized anonymous credentials (DACs) that allows for direct, integrity-driven editing of JSON-formatted credentials. By leveraging Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge (ZK-SNARKs) and a custom R1CS circuit called ZK-JSON, IDEA-DAC ensures that credential updates are both accountable and privacy-preserving, overcoming the limitations of traditional revoke-and-reissue mechanisms.

What Problem Does This Paper Address?

Decentralized Anonymous Credentials (DACs) are crucial for privacy-preserving identity verification, allowing users to prove specific attributes without revealing their full identity. However, existing DAC systems often rely on a "revoke-and-reissue" model for updates, which is inefficient and can compromise the integrity of the credential. This process is cumbersome, requires re-verification, and doesn't inherently guarantee that modifications themselves are secure or adhere to predefined rules. Furthermore, as verifiable credentials are increasingly standardized in JSON format by organizations like the W3C, there's a growing need for systems that can efficiently and securely manage edits to these JSON documents while maintaining anonymity and accountability.

Methods

IDEA-DAC introduces Integrity-Driven Editing (IDE), a paradigm shift from revoke-and-reissue. The core of IDEA-DAC is the ZK-JSON circuit, a specialized Rank-1 Constraint System (R1CS) circuit designed for processing JSON documents. This circuit enables:

  • Serialization and Encryption: Efficiently converts JSON data into a format suitable for cryptographic processing and then encrypts it.
  • Edit-bound Conformity Checks: This is the key innovation. It allows for defining specific integrity rules (e.g., "one of the set," "append only," "meet certain format") that must be satisfied by any edit to a credential. These checks are performed using ZK-SNARKs, meaning the verifier can be convinced that the rules were followed without seeing the actual content of the edit.
  • Strictly Linear Circuit Size: The system is designed to scale linearly with the size of the JSON document, avoiding exponential complexity that would make it impractical for large datasets. This is achieved through techniques like batch merging of data.
  • One-time Setup: For homogeneous JSON documents up to a certain size, the ZK circuit requires only a single compilation, setup, and smart contract deployment.

Datasets

Not discussed in the paper. The paper focuses on a simulated use case of academic profiles for Ph.D. students to demonstrate the system's functionality.

Key Insights and Ideas

  • Direct Editing is Possible and Secure: The paper demonstrates that it's feasible to directly edit credential data within a ZKP framework, rather than resorting to the inefficient revoke-and-reissue cycle.
  • Integrity Rules for Edits: The concept of "edit-bound conformity checks" is crucial. It moves beyond just verifying the final state of a credential to verifying the process of modification, ensuring that edits adhere to predefined, context-specific rules.
  • ZK-JSON for Scalable JSON Processing: The ZK-JSON circuit is a significant contribution, offering an efficient way to handle JSON structures within ZKPs, which is vital given the W3C's adoption of JSON for verifiable credentials. Its linear complexity is key to practical scalability.
  • Balancing Privacy and Accountability: IDEA-DAC achieves a delicate balance. Users retain anonymity and control over their data, while issuers and verifiers can be assured of the integrity and accountability of credential updates.

Key Results

  • Linear Scalability: The number of rank-1 constraints in the ZK circuit scales linearly with the size of the JSON credential document. For example, a 1KB document requires approximately 3x10^5 constraints, with an increase of about 5x10^5 constraints for every 2KB increment.
  • Efficient Proving Times: While not strictly linear due to the use of ZK-friendly random oracles, proving times remain pragmatic. A 32KB document took about 80 seconds on a standard AWS EC2 instance. The paper notes that using more powerful hardware or advanced ZKP protocols (like Orion) can significantly reduce this time.
  • Constant Verification Times: Verification times are consistently low, ranging between 1ms and 2ms, which is essential for practical deployment.
  • Demonstrated Use Case: The system was successfully implemented and evaluated using a realistic academic profile use case, showcasing its ability to handle various integrity rules.

Limitations and Future Work

  • Pre-defined Value Types in Dictionaries: IDEA-DAC requires pre-determining the types of values within dictionaries to leverage its one-time setup property. The authors suggest a workaround by allowing empty values, which offers some flexibility.
  • R1CS Optimization: The current circuit design is optimized for R1CS arithmetization, favoring linear operations. While adaptable to other arithmetizations (like Plonkish), optimizing for them to enhance performance and reduce circuit size is a future research direction.
  • Adaptation to Other Arithmetizations: The paper suggests that adapting the primitives to other ZKP arithmetizations (e.g., Plonkish) is straightforward but requires further work to optimize performance and circuit size.

Summary updated

BibTeX
@article{zheng2024idea,
  author = {Shuhao Zheng and Zonglun Li and Junliang Luo and Ziyue Xin and Xue Liu},
  title = {{IDEA-DAC: Integrity-Driven Editing for Accountable Decentralized Anonymous Credentials via ZK-JSON}},
  journal = {IACR Cryptol. ePrint Arch.},
  year = {2024},
}
Figure