Loading vLEI.wiki
Fetching knowledge base...
Fetching knowledge base...
This comprehensive explanation has been generated from 22 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.
keride is a Rust programming language library implementation for the Key Event Receipt Infrastructure (KERI) protocol. As part of the WebOfTrust GitHub organization's official KERI suite of technologies, keride provides foundational cryptographic and data structure capabilities for building KERI-compliant applications in Rust.
keride is implemented in Rust, a systems programming language that provides significant advantages for cryptographic identity infrastructure:
Memory Safety: Rust's ownership system eliminates entire classes of memory-related vulnerabilities without requiring garbage collection, which is critical for security-sensitive identity applications.
Performance: As a compiled systems language, Rust provides performance characteristics suitable for high-throughput applications and resource-constrained environments.
Type Safety: Rust's strong type system provides compile-time guarantees that help prevent common programming errors in cryptographic code.
The choice of Rust makes keride particularly suitable for:
keride implements five fundamental KERI protocol capabilities:
keride follows a specific naming convention for cryptographic primitives derived from the KERI glossary:
These names are intentionally distinct from generic terms to avoid confusion and provide clear semantic meaning within the KERI context.
When implementing CESR stream parsing with keride:
Rust's memory safety guarantees are particularly valuable for cryptographic code:
Drop trait to securely zero sensitive datakeride is designed to integrate with:
keride provides comprehensive support for CESR, KERI's compact encoding scheme for cryptographic primitives. CESR is fundamental to KERI's design, enabling efficient serialization and transmission of cryptographic material.
Dual-Domain Encoding: CESR supports both text (Base64 URL-safe) and binary representations with full round-trip conversion capability. This allows:
Self-Framing: Each CESR primitive includes its own type and length information through derivation codes, enabling stream parsing without external schema knowledge. This self-describing property is essential for processing KERI event streams where different primitive types may be concatenated.
Composability: CESR primitives can be composed hierarchically using count codes and group codes, supporting complex data structures built from simple primitives. This composability enables efficient pipeline processing of event streams.
keride's CESR implementation handles the complete primitive type system defined in the CESR specification, including cryptographic digests, keys, signatures, and various framing codes necessary for stream processing.
keride provides cryptographic signing capabilities essential for KERI's security model. These operations enable the creation of non-repudiable digital signatures that authenticate key events in a Key Event Log (KEL).
Event Signing: Support for signing different types of KERI events:
Cryptographic Suite Support: While the source documents don't specify which exact cryptographic algorithms keride implements, KERI specifications reference multiple signature schemes including Ed25519 and ECDSA. The library implements the signing operations necessary for KERI protocol compliance.
keride implements KERI's self-certifying identifier system through prefixing mechanisms. This is a core KERI innovation that enables identifiers to be cryptographically verifiable without relying on external infrastructure.
Derivation Codes: Each identifier prefix includes a derivation code that specifies:
Self-Certifying Property: The derivation code binds the cryptographic derivation process to the identifier itself, making the identifier self-describing and verifiable without external metadata.
Identifier Types: KERI supports multiple identifier types including:
keride's prefixing support enables generation and validation of these various identifier types according to KERI specifications.
keride implements pathing mechanisms for navigating and referencing data structures within KERI. The source documents indicate this is a feature of keride but provide limited detail on the specific pathing syntax or mechanisms implemented.
Purpose: Pathing enables addressing specific fields or elements within structured data, which is essential for:
In the broader KERI ecosystem, pathing is relevant for ACDC (Authentic Chained Data Container) credentials where selective disclosure of attributes may be required. The pathing capability allows precise reference to credential fields without disclosing the entire credential structure.
keride provides stream parsing capabilities for processing CESR streams and KERI event data. This is a critical capability because KERI relies on processing sequences of key events encoded in CESR format.
Stream Processing: The parsing functionality handles:
Event Validation: Parsing of KERI events involves:
Self-Framing Advantage: Because CESR is self-framing, each primitive includes its own length information. This enables cold-start parsing where a parser can begin processing a stream without prior context about what primitive types to expect.
The parsing capability is foundational for any KERI implementation because all KERI data structures—key events, receipts, credentials—are encoded in CESR format and must be parsed correctly to verify their cryptographic integrity.
keride occupies a specific position within the broader KERI ecosystem:
Multi-Language Ecosystem: KERI has multiple implementations in different programming languages, each serving different use cases:
Protocol Implementation Library: keride is characterized as a library rather than a complete application. This means:
Standards Compliance: keride implements the KERI protocol specifications maintained in the WebOfTrust GitHub organization. As noted in the vLEI Technical Requirements document, all KERI implementations must conform to the official KERI family of specifications to ensure interoperability.
keride is maintained as an open-source project within the WebOfTrust GitHub organization, indicating its status as an official component of the KERI suite. This organizational placement ensures:
Community Coordination: The WebOfTrust organization coordinates development across multiple KERI implementations through:
Specification Tracking: As documented in the July 2023 meeting archives, different implementation teams (KERIpy, KERIA, SignifyPy, SignifyTS, CESRide, KERIsse) report on their development progress, ensuring implementations stay synchronized with evolving specifications.
Cross-Implementation Consistency: The existence of multiple implementations in different languages creates a network effect where:
While keride itself is a library rather than an application, it enables various KERI use cases:
Embedded Systems: Rust's efficiency and lack of garbage collection make keride suitable for resource-constrained devices that need KERI capabilities.
High-Performance Services: Server applications requiring high throughput can leverage Rust's performance characteristics.
Security-Critical Applications: Memory safety guarantees make keride appropriate for applications where security vulnerabilities could have severe consequences.
Integration with Rust Ecosystems: Applications already built in Rust can integrate KERI capabilities through keride without language boundaries.
The source documents mention CESRide in the context of KERI community meetings, which appears to be related to but distinct from keride. Based on the glossary definitions:
cesride: Described as "concerned with parsing CESR primitives" and built from cryptographic primitives (Diger, Verfer, Signer, Siger, Cigar, Salter). This suggests cesride may be a more focused CESR parsing library.
keride: Described as implementing CESR, signing, prefixing, pathing, and parsing—a broader scope than pure CESR parsing.
The relationship between these components reflects KERI's modular architecture where different layers (CESR encoding, event processing, credential handling) can be implemented as separate but interoperable components.
To understand keride's role, it's essential to understand what KERI solves. As stated in the glossary:
"KERI protocol solves one problem. Secure Attribution."
Secure attribution means cryptographically proving who made a statement through:
keride provides the cryptographic and data structure primitives necessary to implement this secure attribution model in Rust applications. By handling CESR encoding, signing operations, and event parsing, keride enables applications to create and verify the cryptographic proofs that underpin KERI's security model.
The source documents provide limited information about keride's internal architecture, specific API design, or implementation details. What we can definitively state:
Confirmed Capabilities: The five core features (CESR, signing, prefixing, pathing, parsing) are explicitly documented.
Rust Implementation: The use of Rust is confirmed, with its associated benefits for memory safety and performance.
WebOfTrust Maintenance: Official maintenance within the WebOfTrust organization is documented.
What Is NOT Documented: The source materials do not provide:
Any description of these aspects would be speculation beyond what the source documents support.
keride is a Rust library implementation of the KERI protocol that provides five core capabilities: CESR encoding/decoding, cryptographic signing operations, self-certifying identifier prefixing, data structure pathing, and stream parsing. As an official component of the WebOfTrust KERI suite, it enables Rust applications to implement KERI's secure attribution model with memory safety guarantees and high performance. The library serves as a protocol implementation foundation upon which applications can build higher-level KERI functionality while maintaining interoperability with other KERI implementations across the multi-language ecosystem.
Use Rust's Result type consistently:
pub type KeriResult<T> = Result<T, KeriError>;
This forces explicit error handling and prevents silent failures in security-critical code paths.