Loading vLEI.wiki
Fetching knowledge base...
Fetching knowledge base...
This comprehensive explanation has been generated from 176 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.
Authorization is fundamentally the function of specifying access rights and privileges to resources, formally defined as the process of defining an access policy. In computing systems, authorization answers the question "what is this entity allowed to do?" after authentication has answered "who is this entity?"
In traditional systems, authorization typically involves:
The core properties of authorization systems include:
The scope of authorization extends from simple binary access decisions (allow/deny) to complex policy frameworks involving contextual factors, temporal constraints, and hierarchical delegation structures.
Traditional authorization systems have relied on centralized authorities to maintain and enforce access policies. In PKI (Public Key Infrastructure) systems, certificate authorities issue certificates that authorize specific uses of public keys. In web systems, OAuth tokens authorize applications to access user resources on behalf of users.
These approaches share common limitations:
When implementing authorization verification in KERI:
Temporal Key State Resolution: Verifiers must resolve the key state that was authoritative at the time of authorization issuance, not the current key state. This requires:
KEL Retrieval and Validation: Before verifying any authorization:
Authorization Chain Validation: For chained authorizations (e.g., vLEI credentials):
Revocation Checking: When revocation status matters:
Key Compromise Impact: Authorization security is only as strong as the underlying AID security. Implementers must:
Delegation Depth: Deep authorization chains increase verification complexity and potential attack surface. Consider:
Offline Verification: KERI enables offline authorization verification, but:
The evolution toward decentralized identity systems created demand for authorization mechanisms that could operate without centralized intermediaries while maintaining cryptographic verifiability.
KERI implements authorization through cryptographically signed statements that include the AID (Autonomic Identifier) under which the authorization is issued. This approach provides several critical properties:
Cryptographic Binding: Each authorization statement is cryptographically bound to a specific AID through digital signatures. The signature proves that the controller of the AID at a specific point in time authorized the statement.
Temporal Verification: Verification uses keys that were authoritative at the time of issuance, not necessarily current keys. This is crucial because KERI supports key rotation - the keys used to sign an authorization may have been rotated since issuance, but the authorization remains valid if it was properly signed with keys that were authoritative when issued.
Inherited Security: Authorization security in KERI inherits from the associated AID's security. This means:
KERI's authorization model integrates with W3C Verifiable Credentials (VCs), which represent a standardized form of authorization. VCs utilize the W3C Decentralized Identifier (DID) standard, providing URI-like namespace syntax for decentralized identifiers.
Critical Architectural Distinctions:
The relationship between KERI AIDs and W3C DIDs is nuanced:
This flexibility means KERI's authorization model works independently of any specific namespace choice, enabling:
A key innovation in KERI's approach is end-verifiability of authorizations. Any party receiving an authorization statement can:
This end-verifiability eliminates dependence on:
KERI supports hierarchical authorization structures through ACDC (Authentic Chained Data Container) chaining:
Proof of Authority Chains: ACDCs can chain together to create verifiable delegation paths. For example:
Each step in this chain is cryptographically verifiable, creating an unbroken chain of authority from the root (GLEIF) to the end credential holder.
Cooperative Delegation: KERI's delegation model is cooperative, requiring both delegator and delegate to participate in cryptographic operations. This ensures:
KERI's authorization model enables legitimized human-meaningful identifiers through the aid|lid couplet pattern:
This approach solves the historical tension between security (cryptographic identifiers) and usability (human-meaningful names) by using authorization as the bridge between the two.
Credential Issuance Authorization: In the vLEI ecosystem, Legal Entities must authorize QVIs to issue role credentials on their behalf. This authorization:
Service Endpoint Authorization: Controllers can authorize specific service endpoints to act on behalf of their AIDs:
Delegated Authority: Organizations can create hierarchical authorization structures:
Cryptographic Verifiability: Every authorization can be cryptographically verified without trusted intermediaries, enabling true zero-trust architectures.
Temporal Integrity: Authorizations remain verifiable even after key rotations, as verification uses historically authoritative keys rather than current keys.
Namespace Agnostic: Authorization mechanisms work across different identifier namespaces (DIDs, URLs, etc.), preventing vendor lock-in.
Hierarchical Scalability: Delegation enables authorization structures that scale from individual users to global enterprises while maintaining cryptographic integrity.
Revocation Support: Integration with TELs (Transaction Event Logs) enables efficient revocation checking when needed, while maintaining offline verifiability for non-revoked authorizations.
Complexity: KERI's authorization model requires understanding of KELs, key rotation, and temporal key state verification, creating a steeper learning curve than simple token-based systems.
Key Management Burden: Security depends on proper key management by all parties in the authorization chain. Compromise of any AID's keys compromises authorizations issued under that AID.
Verification Overhead: End-verifiable authorization requires verifiers to process KELs and perform cryptographic verification, which is more computationally intensive than simple token validation.
Revocation Latency: While KERI supports revocation through TELs, there may be latency between revocation and verifier awareness, especially in offline scenarios.
Infrastructure Requirements: Full KERI authorization verification requires access to KELs, which may necessitate witness networks, watchers, or other infrastructure components.