Attestation Standing Reference.

iqa is a URI scheme for citing the attestation standing of a subject — reported by one of three named organs (forge · tss · gateway) — without carrying the underlying proof. The scheme is submitted to IANA (Provisional, pending).

Citable standing

The address says where to ask; the state says what is currently true. Reading the syntax establishes nothing about any subject — standing is established only by the seal and by the answering organ.

"The URI is an entry fingerprint; the AID is the identity; the seal is the evidence."

One click — nothing installed, no administrator rights, removable later in the browser's protocol-handler settings. The address is iqa://<subject>.<organ>.<root>/<action>. Reaching it from a web page adds the browser's own reserved prefix, which is the same address, not a second protocol — same authority, same path, same derived ROUTE_SHARD. The form without that prefix reaches the same place through a one-time operating-system registration instead. Coverage: the identical handler shape (see rttp.com) was measured on Windows Chrome. The resolver page needs no registration at all.

iqa:// · URI reference Attest, seal and verify — in your own browser iqa.org/URI →

AICENT-009 §10 – §12

What the specification states

Closed-set actions

verify / audit / attest / revoke

Organs

forge / tss / gateway

Standings

ghost / probation / radiant / genesis

DNS lookups

the address is derived, not resolved

IQA-ORG v1.2.8 — published packages

measured against the published artifacts · re-asserted by CI on every push

256 bit

Seal

HMAC-SHA256 · AICENT-009 §4

75 (3 skipped)

Python · default

core install

Python · [ed25519]

with the optional backend

Node · npm

individual implementation

37 (1 skipped)

Rust · default

SHA-256 written in-crate

Rust · [ed25519]

cargo test --features ed25519

Published vectors

SPEC/IQA-URI-ATTEST-v1.2.6 §5

Core dependencies

standard library only

No unmeasured claims

Core Mechanism

Certification

01. ENVELOPE

A claim travels as a signed envelope: it carries the AID — SHA-256 of the public key — so a verifier needs no key directory and no issuer (AICENT-009 §10).

// The envelope — live verifier and vectors at iqa.org/URI/
pub struct Envelope {
    pub subject_uri: String,   // iqa://<subject>.<organ>.<root>
    pub organ: Organ,           // closed set: forge | tss | gateway
    pub standing: Standing,     // closed set: ghost | probation | radiant | genesis
    pub aid: [u8; 32],          // AID = SHA-256(public key)
    pub ts: u64,               // claim timestamp
    pub nonce: [u8; 8],         // replay guard
    pub sig: [u8; 64],          // Ed25519 over the canonical form
}

02. ATTESTATION SEAL

A 256-bit HMAC-SHA256 seal computed over the canonical claim and bound to the subject AID — a verifier needs nothing but the envelope itself (AICENT-009 §10).

03. ACTION SAFETY

The action class decides what is reachable: verify and audit are reads, while attest and revoke are NOT-SAFE and must not be reachable by dereferencing alone (AICENT-009 §11).

NOT-SAFE action: requires an explicit request, not dereferencing (AICENT-009 §11.4)

Implementation Standard

Offline Envelope Verification

A verifier needs nothing but the envelope: canonicalise the claim, check the signature against the public key, and require the standing to be inside the closed set. Unverified callers get the read path only — everything else fails closed. The envelope signature itself checks offline — demonstrated live, in the browser, at iqa.org/URI/.

// AICENT-009 §10.2 / §11 — verify an envelope offline
envelope = {
  alg: 'ed25519',
  aid: '3125ee20b2238281f70ca408192f82152647d365219184fa1fe22c08a42c035e',
  subject_uri: 'iqa://3f9a1b2c.gateway.iqa',
  organ: 'gateway',
  standing: 'radiant',
  ts: 1760000000, nonce: '0011223344556677',
  sig: '054b74c8dcd2b2128291ce433409983609d62c63a002138475d5e33bd21ea0b0c6243790db3d926ad6820cdf7e64f49cbd49a794a1b693cb60217a3382a5f007'
}
verify(aid, canonicalize(envelope), sig) == true   // offline, from the envelope itself

read   → default operation (SAFE)   // dereferencing only reads
attest → NOT-SAFE                   // needs an explicit request (§11.4)