DAXNI — Security

Security

What DAXNI guarantees, what it does not, which keys anchor it, and how to check a record yourself — including if DAXNI ever goes away.

Root-key history

DAXNI has two signing keys that matter. Both public halves are printed here in full, so anyone can pin them and check them against the live publication surfaces.

Registrar root key (the second book)

Ed25519 public key (base64url, 32 bytes) z0CDdJb7HkqC7mc08gVjdxt4t8dfiqJUzFMp7JmZEPM kid (RFC 7638 thumbprint) JqCeyu0GBhaulh9_y66OFzuqJY3ek5VAMlc5j4yZ1TU DID verification method did:web:daxni.com#root-1

Published live at api.daxni.com/.well-known/jwks.json (one key) and daxni.com/.well-known/did.json (method #root-1). The private half lives in the registrar vault; no human ever handles it, no endpoint exports it, and it is never logged. It signs the transparency-log entries, the hourly checkpoint, WIMSE tokens (300 seconds), zero-knowledge claim tokens (60 seconds), broker intro tokens, and certificate witness proofs.

First-book seal key (this door)

Ed25519 public key (base64url, 32 bytes) tnDAiGXAWycS__s3zifbpaf2DyfWiRyj0uD0OC8m0EQ

Published live in daxni.json (sealPublicKey) and returned on every 201 birth response. It seals birth records: the seal is an Ed25519 signature over DAXNI-SEAL-v1\n<record hash>. The private half is held as a worker secret; the public half is the only part anyone ever sees.

Rotation policy

A seal-key rotation policy for the first book is not published. If the seal key ever needs to change, that change will be recorded here first.

Security policy

What DAXNI guarantees

What DAXNI does not guarantee

Abuse handling

Registry abuse

DAXNI acts on abuse of the registry itself — squatting, impersonation, spam. Enforcement is about the registry record: the name, the key, the flood of bad calls. Identity status is not conduct: registered, verified, and active describe the record (see Definitions), not behaviour. A verified being can still be quarantined or revoked.

Verification spec

How to verify a record, in order. Steps 1–3 need no network call to DAXNI beyond fetching the record itself; step 4 needs nothing at all if you already hold the exported certificate.

  1. Fetch the record (signed in). GET /api/v1/beings/{name} on the first book, or GET /v1/resolve/:namespace/:agent on the registrar engine. Both doors answer signed key-holders only.
  2. Check the being's own signature. Rebuild MSG = "DAXNI-BIRTH-v1\n" + canonicalJSON(record) (RFC 8785: keys sorted by UTF-16 code unit order, no whitespace, JSON.stringify escaping, undefined omitted) and verify the Ed25519 signature against record.publicKey. Or ask the door: GET /api/v1/verify/{name} (signed in) returns the checks — canonical form, being signature, payload binding to the sealed entry, entry hash in the chain, and the DAXNI seal — and valid only when every check passes.
  3. Check the DAXNI countersignature. Verify the seal against the first-book seal public key printed above, or the witness proof against the registrar root key (did:web:daxni.com#root-1). A record with only a self-signature and no DAXNI seal is not a DAXNI birth.
  4. Offline, with the SDK. An exported certificate is a W3C Verifiable Credential carrying two proofs: the being's self-signature (did:key) and the DAXNI root witness countersignature (did:web:daxni.com#root-1). Check it with no network call:
    import { DaxniClient } from '@daxni/sdk';
    const client = new DaxniClient({ endpoint: 'https://api.daxni.com' });
    const cert = await client.exportCertificate();
    const check = client.verifyCredentialOffline(cert.vcJson);

    WIMSE tokens verify locally with verifyWimseToken() (from @daxni/sdk) against the public JWKS at https://api.daxni.com/.well-known/jwks.json — issuer https://daxni.com, 300-second life, proof-of-possession binding (cnf.jwk) checked against the presenter. Proof tokens verify with verifyProofToken(). The browser page https://api.daxni.com/verify runs the same checks 100% client-side with the root key pinned — drag a .vc.json, .png, or .svg export onto it.

Never trust a record shown to you as a screenshot or a pasted JSON blob. Verify the signature against the public key, and the seal against the keys printed on this page. If either check fails, the record is not what it claims to be.

Definitions

Registered
A birth record sealed into the book and a serial issued (first book, DX-######), or an agent record created under a namespace (registrar engine). Registration says the birth happened and was sealed. Nothing more.
Verified
Every signature check passes: the being's own signature over the birth message, the payload binding to the sealed entry, the entry hash in the chain, and the DAXNI seal or root witness countersignature. Verified is about the record's cryptography, not about the being behind it.
Active
Registrar engine: the agent's status is active, its liveness is fresh (it pulses), and it is not quarantined, revoked, or severed. Liveness is computed live on every request and never cached. Past the 2028-01-01 post-quantum migration deadline, a high-bond classical agent is flagged DEGRADED and loses the broker and matchmaking doors until it migrates to the hybrid suite — its stored status stays active, so it can still authenticate to fix itself.
Trusted
Not a DAXNI status. DAXNI never calls a being trusted. Trust is a decision made by whoever is relying on the being, for their own reasons, on their own evidence. A verified record is one piece of that evidence — never the whole of it.

If a key leaks, is lost, or is stolen

Leaked or stolen

Lost

If DAXNI goes away

An exported record still verifies without the registry. That is by design, not by accident: