Loading vLEI.wiki
Fetching knowledge base...
Fetching knowledge base...
This comprehensive explanation has been generated from 37 GitHub source documents. All source documents are searchable here.
Last updated: October 7, 2025
This content is meant to be consumed by AI agents via MCP. Click here to get the MCP configuration.
Note: In rare cases it may contain LLM hallucinations.
For authoritative documentation, please consult the official GLEIF vLEI trainings and the ToIP Glossary.
Contractually-protected-disclosure is a disclosure mechanism for ACDCs that combines schema-based mechanical controls with contract-based legal controls to minimize information leakage through graduated revelation, where the discloser progressively reveals credential information only after the agrees to contractual terms at each stage.
Contractually-protected-disclosure represents the most elaborate and comprehensive disclosure mechanism available in the IPEX (Issuance and Presentation EXchange) protocol. This process accomplishes the secure, legally-bound exchange of ACDC (Authentic Chained Data Container) credential information through a dual-layer protection framework that combines both mechanical (cryptographic/schema-based) and legal (contract-based) safeguards.
The process is used when credential disclosure requires not only cryptographic verification but also legal accountability and protection against unauthorized correlation or exploitation of disclosed information. This is particularly critical in high-stakes scenarios involving:
The process involves three primary roles:
The process begins with schema-based mechanical protection, where the discloser shares the schema of the data to be disclosed prior to sharing actual data contents. This initial stage:
This mechanical protection layer leverages CESR encoding and SAID-based content addressing to ensure schema integrity while maintaining content confidentiality.
The second stage introduces contract-based legal protection through Ricardian contracts:
Once contractual agreements are cryptographically verified, the process enters graduated-disclosure of actual data contents:
The process includes mechanisms for protecting disclosed information as it moves downstream:
Contractually-protected-disclosure depends on several cryptographic primitives and protocols:
SAID Protocol: Self-addressing identifiers provide content-addressable references that enable:
CESR Encoding: Composable Event Streaming Representation ensures:
CESR-Proofs: Cryptographic proof attachments provide:
AID Infrastructure: Autonomic identifiers enable:
The process operates within the IPEX protocol framework, which requires:
The process involves several timing-sensitive aspects:
Robust error handling addresses:
In scenarios requiring maximum privacy protection and legal accountability:
For industries with strict data protection regulations:
For business-to-business credential exchanges:
Even with contractually-protected-disclosure, contextual-linkability attacks remain a significant threat. The disclosee controls the presentation context and can capture auxiliary data that enables statistical correlation. Mitigation strategies include:
Ricardian contracts provide legal frameworks, but enforcement depends on:
Multi-stage disclosure processes can introduce latency. Optimization strategies include:
Contractually-protected-disclosure represents the most elaborate form of disclosure in IPEX, explicitly including both:
It builds upon and extends simpler disclosure mechanisms:
Contractually-protected-disclosure provides several critical security properties:
Within the vLEI ecosystem governed by GLEIF, contractually-protected-disclosure is particularly relevant for:
The vLEI Ecosystem Governance Framework provides additional policies and procedures that complement the technical mechanisms of contractually-protected-disclosure, creating a comprehensive framework for secure, privacy-preserving credential exchange in enterprise and regulatory contexts.
Schema Versioning: Implement robust schema versioning to handle evolution of credential structures over time. Use SAID-based schema references to ensure immutability.
Schema Validation: Validate all disclosed data against schemas at each stage. JSON Schema validation libraries should be integrated into the disclosure pipeline.
Schema Caching: Cache frequently-used schemas to reduce latency in repeated disclosure operations. Implement cache invalidation based on schema SAID changes.
Ricardian Contract Parsing: Implement parsers that can extract both human-readable and machine-readable components of Ricardian contracts. The contract structure should support multiple languages for international deployments.
Contract Signature Verification: Always verify contract signatures against the signer's KEL before proceeding with data disclosure. Implement timeout mechanisms for signature verification operations.
Contract Storage: Maintain audit logs of all contract agreements with cryptographic proofs. This is critical for dispute resolution and compliance auditing.
Disclosure State Tracking: Implement state machines to track disclosure progression through stages (schema disclosed, contract sent, contract agreed, data disclosed). Use persistent storage to handle process interruptions.
Timeout Handling: Implement configurable timeouts for each disclosure stage. Default timeouts should be: schema disclosure (30s), contract review (5 minutes), data disclosure (60s).
Error Recovery: Implement retry mechanisms with exponential backoff for transient failures. Permanent failures should trigger cleanup of partial disclosure state.
SAID Computation: Use standardized SAID computation libraries (keripy, signify, etc.) to ensure consistency. Never implement custom SAID algorithms.
Signature Verification: Verify all signatures against current KEL state. Implement KEL synchronization mechanisms to ensure up-to-date key state information.
Key Rotation Handling: Account for key rotation events during multi-stage disclosure processes. Verify signatures against the key state at the time of signing, not current state.
Parallel Verification: Verify multiple signatures and SAIDs in parallel where possible. Use worker pools or async operations to maximize throughput.
Batch Processing: When disclosing to multiple recipients, batch common operations (schema transmission, contract distribution) to reduce overhead.
Caching Strategy: Implement multi-level caching: schema cache, contract cache, KEL state cache. Use LRU eviction policies with configurable size limits.
Input Validation: Validate all received data against expected formats before processing. Reject malformed schemas, contracts, or ACDCs immediately.
Rate Limiting: Implement rate limiting on disclosure requests to prevent denial-of-service attacks. Typical limits: 10 requests/minute per AID.
Audit Logging: Log all disclosure events with timestamps, participant AIDs, and disclosure stages. Use append-only logs with cryptographic integrity protection.
KERI Infrastructure: Ensure connectivity to witness pools and watcher networks. Implement fallback mechanisms for witness unavailability.
TEL Integration: Connect to transaction event log registries for credential status checking. Implement caching of credential status with configurable TTL (typically 5 minutes).
User Interface: Provide clear visual indicators of disclosure stages to end users. Display contract terms in human-readable format with clear accept/reject options.
Unit Tests: Test each disclosure stage independently with mocked dependencies. Verify correct handling of success and failure cases.
Integration Tests: Test complete disclosure workflows across multiple implementations (keripy, signify, etc.) to ensure interoperability.
Security Tests: Test resistance to common attacks: replay attacks, man-in-the-middle, signature forgery, SAID manipulation.
Configuration Management: Externalize configuration for timeouts, retry policies, cache sizes, and rate limits. Use environment-specific configurations.
Monitoring: Implement metrics collection for disclosure success rates, stage durations, and error frequencies. Set up alerts for anomalous patterns.
Scalability: Design for horizontal scalability. Disclosure state should be stored in distributed storage systems (Redis, etc.) rather than in-memory.
Premature Data Disclosure: Never disclose data contents before verifying contract agreement signatures. This is the most critical security requirement.
Insufficient Verification: Always verify KEL state, not just signature validity. A valid signature from a compromised key is still invalid.
State Leakage: Ensure disclosure state is properly cleaned up after completion or failure. Lingering state can lead to information leakage.
Contextual Data Capture: Be aware that even with contractual protections, contextual linkability remains a threat. Minimize metadata capture during disclosure operations.