OpenClaiming provides a minimal primitive for publishing and verifying cryptographically signed statements—a foundation for building decentralized trust systems.

The Problem

Distributed systems need to establish trust without centralized authorities. Questions arise constantly:

• Who controls this identity?
• Does this user belong to this organization?
• Did a trusted party delegate permission?
• Are two accounts controlled by the same entity?

Existing solutions often require complex infrastructure—decentralized identity stacks, credential frameworks, schema registries. While powerful, they introduce significant overhead.

OpenClaiming asks: what if all you need is a cryptographically signed statement?

The Core Idea

OpenClaiming reduces trust assertions to a simple format:

issuer signs statement about subject

This model is intentionally minimal. It allows systems to express claims such as:

• example.com claims Alice is a moderator
• serverA claims latest state of object X is hash H
• Alice claims Bob may publish to stream Y

All of these statements share the same fundamental structure.

Minimal Surface Area

The core specification defines only essential fields: version, issuer, subject, statement, timestamps, and signature. This minimal design keeps implementations simple and auditable.

JSON as the Universal Format

OpenClaiming uses JSON for its universal support and human readability. To ensure consistent signatures across implementations, we use RFC 8785 JSON Canonicalization—guaranteeing identical byte representations regardless of language or library.

Cryptography First

Cryptographic signatures provide authenticity, integrity, and verifiability without trusted intermediaries. No registries, no central authorities—just public-key cryptography.

Decentralization

OpenClaiming is designed to work without centralized infrastructure. Claims can be published in many ways: web endpoints, distributed storage, application databases, blockchain systems, and peer-to-peer networks.

Composability

OpenClaiming is intended to be composable. Applications may build more complex systems on top of the primitive, including reputation systems, decentralized identity, access control frameworks, distributed consensus models, and governance protocols.

Compatibility with Existing Systems

OpenClaiming is designed to work alongside existing standards. It does not attempt to replace them. Examples include:

• HTTPS PKI — Domains may publish claims using existing HTTPS infrastructure.
• DNSSEC — Domains may sign claims using DNSSEC-secured identities.
• Verifiable Credentials — OpenClaims may serve as lightweight credentials within VC ecosystems.
• DIDs — OpenClaims may reference DID identifiers.
• Blockchains — Claims may be anchored by storing hashes, signatures, and timestamps.

Simplicity over Completeness

Most identity standards try to solve everything upfront, creating complex schemas and high implementation costs. OpenClaiming takes the opposite approach: provide a minimal primitive, let applications extend it as needed.

Transparency and Accountability

Signatures create accountability. Contradictory claims become public evidence of dishonesty—a natural deterrent that works without centralized enforcement.

Language Agnostic

OpenClaiming is designed to be easy to implement in any programming language. Because the protocol depends only on JSON, canonicalization, and standard cryptography, implementations can remain small and straightforward.

Future Evolution

Future versions may add optional features—embedded Merkle proofs, additional signature algorithms, ZK proof integrations. But the core principle stays the same:

issuer signs statement about subject

A Primitive for Trust

OpenClaiming is not an identity system, credential framework, or governance platform. Instead, it provides a primitive that can support all of these.

By keeping the protocol minimal and flexible, OpenClaiming aims to enable a wide variety of decentralized applications.

Summary

OpenClaiming reduces trust to its simplest form:

A signed statement that anyone can verify.

From this primitive, powerful systems emerge.