mark.noblestar.tech
Reference / Specification

Mark Signing Protocol (MSP) v1

The formal specification for the Mark Signing Protocol. This document defines the data structures, algorithms, and verification procedures that make up MSP v1.

Overview

The Mark Signing Protocol (MSP) is an open standard for cryptographic document signing with tiered identity assurance. It defines how to create, package, and verify digital signatures that are self-contained, independently verifiable, and platform-independent.

MSP v1 uses Ed25519 (RFC 8032) for all signatures, SHA-256 for document hashing, and a two-level key hierarchy (root key + signing subkeys) for identity management.

SignedBundle

The SignedBundle is the core proof artifact. It contains everything needed to verify a signature without contacting any server.

Field
Type
Description
document_hash
string (hex)
SHA-256 hash of the signed document
signer_fingerprint
string (hex)
SHA-256 hash of the signer's root public key
timestamp
string (ISO 8601)
Signing time in UTC
signature
string (base64)
Ed25519 signature over the canonicalized signed_input
subkey_certificate
object
The signing subkey's authorization certificate
identity_pointer
string
Pointer to the signer's service record (polygon:{fingerprint} or legacy IPNS name)
ots_proof
string (base64)
OpenTimestamps proof (may be pending until Bitcoin confirmation)
polygon_tx
string (hex)
Polygon transaction hash for the on-chain anchor

Signed input canonicalization

The signature is computed over a canonicalized string, not over the raw JSON. The signed input is constructed as:

{document_hash}:{signer_fingerprint}:{timestamp}

All fields are UTF-8 encoded. The timestamp uses ISO 8601 format with UTC timezone (trailing Z). No whitespace padding.

Subkey certificate

Field
Type
Description
subkey_public_key
string (base64)
The signing subkey's Ed25519 public key
valid_from
string (ISO 8601)
Start of the subkey's validity window
valid_until
string (ISO 8601)
End of the subkey's validity window
root_signature
string (base64)
Root key's signature over the subkey authorization

The root_signature is computed over: {subkey_public_key}:{valid_from}:{valid_until}

Service record

The service record is the signer's public identity document, published to the Polygon blockchain as an event log. It contains:

  • root_public_key — the identity anchor
  • active_subkeys — list of currently valid subkey certificates
  • revoked_subkeys — list of revoked subkey fingerprints with revocation timestamps
  • trust_tier — current identity assurance level (T0-T4)
  • identity_claims — name, email, domain (depending on tier)
  • attestation — hardware attestation certificate (T4 only)
  • polygon_contract — address of the on-chain registry contract

Verification procedure

5 steps

A conforming verifier MUST perform these checks in order:

  1. Signature check — verify the Ed25519 signature over the canonicalized signed_input using the subkey from the subkey_certificate.
  2. Authorization check — verify the root_signature in the subkey_certificate using the root_public_key from the service record.
  3. Temporal check — verify that the signature timestamp falls within the subkey's valid_from/valid_until window.
  4. Revocation check — verify that the signing subkey does not appear in the service record's revoked_subkeys list.
  5. Anchor check — verify that the service record hash matches the value stored in the Polygon registry contract.
  6. Bundle existence check — query the MarkSignatureBundleRegistry contract for SignatureBundlePublished events matching the document hash. If present, the Polygon block timestamp provides independent temporal proof of when the bundle was published on-chain.

Steps 1-3 can be performed offline using only the SignedBundle. Steps 4-6 require network access (Polygon RPC).

JSON Schemas

MSP v1 defines nine JSON Schema (2020-12) documents covering all protocol data structures. The canonical schemas are maintained in the spec/v1/ directory of the Mark repository.

Next:Manual verification guide