nic.whisper.online · the complete record

The whole record, in one place.

This is everything a registry is expected to publish, kept current: the resources we hold, the access endpoints, how to bring your own domain and prove it, how identities are issued under your domain, the recipes anyone can run to check an identity, and the policy of the transparency log. We are conservative in what we state and clear about what is live versus on its way.

Every command below is run against the live service and pasted exactly as it answers. For the engineering behind it - the dozen internet standards named by RFC - see whisper.online/under-the-hood.

The autonomous system and the address space.

The registry is operated by Whisper Security (viaGraph B.V.), Amsterdam, the Netherlands, on infrastructure we hold ourselves. The number resources are real and registered in the RIPE NCC region.

Registry number resources
Autonomous systemAS219419, IPv6-only, announced from as219419.net
Agent identity block2a04:2a01::/32 - one /128 per agent identity, within RIPE allocation 2a04:2a00::/31
Assignment modelinet6num, AGGREGATED-BY-LIR, assignment-size 128: every agent is a normally-allocated, individually-recorded /128
Resolver / DNS serviceauthoritative ns1.whisper.online + ns2.whisper.online; the recursive upstream is the unbound resolver at 2a04:2a00::53
Routing postureRPKI ROA-covered origin, MANRS-compliant, dual-homed (two independent transits) for redundancy
OperatorviaGraph B.V. (dba Whisper Security), Amsterdam, NL - no third party in the trust path

Every agent identity is a normally-allocated, DNSSEC-signed, registry-anchored IPv6 address. The registry record for each /128 refers up to RIPE's own record for 2a04:2a01::/32, so the ground under it is independently confirmable. See the live statistics for current counts.

Where to query the record.

The registry record is served on the protocols you already speak. None needs a key.

Registry access endpoints
RDAP, by addresshttps://rdap.whisper.online/ip/<addr> (RFC 9083) - the canonical machine-readable object
RDAP, by domainhttps://rdap.whisper.online/domain/<apex-or-fqdn> (RFC 9082/9083) - the served-zone object, with secureDNS and the parent referral
WHOISwhois.whisper.online, port 43 (RFC 3912) - the same record in inet6num form
Finger, by identityfinger.whisper.online, port 79 (RFC 1288) - the same record in plain-text identity form, answerable by /128 or agent FQDN
FTP archive, anonymousftp.whisper.online, port 21 (RFC 959) - anonymous read-only archive of the NIC registry documents (the same content served over RDAP / WHOIS / HTTP)
DNSSEC trust anchorsthe served zones are signed and chained: publish a DS at the parent for agents.whisper.online and whisper.online (ECDSA P-256, algorithm 13)
Keyless verificationhttps://rdap.whisper.online/verify-identity/<addr> - one call that checks the whole chain (DANE + signed identity document) and returns a plain verdict

Confirm the DNSSEC trust anchors yourself: the parent carries a DS for each served zone, so a validating resolver can build the chain. Check it with delv rather than by reading that resolver's AD flag, which only reports its claim.

read-only · the DS at the parent for the served zones
$ dig +short DS agents.whisper.online @1.1.1.1
54705 13 2 99B88E7C1FD2A815F3DA0374D9FED2C4735F7EFDDB864CB1A79F9D55 43DFE06D
$ dig +short DS whisper.online @1.1.1.1
50855 13 2 3B33E9998425C1F43FCC3B8D4696DB587DB7CEA3F2A235E1556C4C4F 47E247D3

Algorithm 13 is ECDSA P-256 with SHA-256; digest type 2 is SHA-256. The DS values rotate with the keys, so treat the above as a worked example and read your own live answer. Validate a forward query's signatures yourself (for example delv @1.1.1.1 AAAA ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online, which prints ; fully validated) rather than requiring the ad flag, which only reports a resolver's claim.

Check any identity yourself, no key, no SDK.

Every identity can be checked from a plain terminal. The examples use a live resident, 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478; swap in any agent's /128 or its name. Each command is run against the live service and pasted verbatim, and the proofs carry the numbers whisper.online/docs/identity gives them.

Proof 1. Reverse DNS names the address (the address spells itself back, signed):

reverse DNS · PTR
$ dig -x 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478 +short
ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online

Proof 2. The forward name points back to the same address (the loop closes):

forward DNS · AAAA
$ dig +short AAAA ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478

Proof 3. The friendly name resolves to the same agent (a CNAME in the same signed zone):

friendly name · CNAME
$ dig +short CNAME scout.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online

Proof 4. The agent's key is pinned in DNS itself (DANE-EE 3 1 1, anchored by DNSSEC, no certificate authority in the path):

DANE · TLSA
$ dig +short TLSA _443._tcp.ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
3 1 1 9EC1EF18A1F15E5480A0FC3C8D6E9690B2CCF1A7FA7146201940F28C 422BB47D

Proof 4, on the wire. The TLS leaf matches that pin (a DANE-aware client validates the cert against the TLSA record, with no public CA):

DANE-validated TLS · openssl
$ openssl s_client -dane_tlsa_domain ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online \
    -dane_tlsa_rrdata "3 1 1 9EC1EF18A1F15E5480A0FC3C8D6E9690B2CCF1A7FA7146201940F28C 422BB47D" \
    -connect [2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478]:443 </dev/null 2>/dev/null | grep "DANE TLSA"
DANE TLSA 3 1 1 ...c273b8184b29... matched EE certificate

The agent's certificate is anchored by the TLSA record in signed DNS, not by a public CA, so a plain curl that only trusts public CAs will reject it - that is the point. Use a DANE-aware client, or the keyless gateway check in proof 7, which validates the chain for you.

Proofs 5 and 6. The registry knows it by address and by name (RDAP, the canonical record; WHOIS, the same on the legacy protocol):

RDAP + WHOIS · read-only
$ curl -s https://rdap.whisper.online/ip/2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478 | jq -r .name
scout
$ whois -h whois.whisper.online 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
inet6num    2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478
netname     scout
...
origin      AS219419
aggregate   2a04:2a01::/32

RDAP also serves the name as a domain object: curl -s https://rdap.whisper.online/domain/ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online returns the signed-DNS / referral view of the same identity.

Proof 7. One keyless call checks the whole chain (DANE + the signed identity document + the registry record), returning a plain verdict:

keyless full-chain check · runs nothing
$ curl -s https://rdap.whisper.online/verify-identity/2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478 | jq '{is_whisper_agent,dane_ok,jws_ok}'
{
  "is_whisper_agent": true,
  "dane_ok": true,
  "jws_ok": true
}

Beyond the seven: the signed identity document and the did:web record live under the agent's own name, at /.well-known/. There is no public CA in front of them: the certificate is pinned by the DANE TLSA 3 1 1 record in the signed zone, so a bare curl refuses the connection and is right to. Check the pin yourself, then read the documents. -k here is not skipping a check, it is declining one you have already done better:

self-published identity · JWS + did:web
$ dig +short TLSA _443._tcp.ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
3 1 1 <SHA-256 of the SubjectPublicKeyInfo this name is allowed to serve>

$ openssl s_client -connect ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online:443 -servername ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online </dev/null 2>/dev/null \
    | openssl x509 -pubkey -noout | openssl pkey -pubin -outform DER \
    | openssl dgst -sha256 -binary | xxd -p -c 64
<the same 32 bytes, lowercase>
# they match, so the key on the socket is the key the signed zone pins - no CA was consulted

$ curl -sk https://ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online/.well-known/whisper-identity   # signed JWS identity statement
$ curl -sk https://ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online/.well-known/did.json          # W3C did:web document (same key)

Beyond the seven: the agent's SSH key fingerprint is in DNS too (SSHFP, so an SSH client can verify the host key from signed DNS):

SSH host key · SSHFP
$ dig +short SSHFP ae3b051ff3bf7f478.tdc38e7c55bad3306a92b830f9bb1e4f9.agents.whisper.online
3 2 <SHA-256 of this host's Ed25519 host key>
# compare it with what your SSH client is offered; signed DNS is the second opinion

Every one of these is independent, runs against the live service, and depends on signed DNS and your own tools, not on our word. The registry record links straight up to RIPE's own record for 2a04:2a01::/32, so even the ground under it is theirs to confirm.

Onboard your domain, and prove it by delegation.

You can put your agents under a domain you already own. You keep the name at your registrar; we run the authoritative DNS for it, sign it, and mint the identities inside it. The proof is the delegation itself, observed live in the public DNS: there is no token to copy. Onboarding is self-serve with your own API key, through whisper.agents({op:'domain'}) or the CLI.

The worked example below is a real domain we hold, everwatch.io (registered at Gandi), and a real agent under it, demo.everwatch.io. The domain verified at 13:39Z on 20 Oct 2026 and every output was captured that afternoon; the keyless steps are runnable by anyone right now. Keyed steps show the command, and the one keyed response shown is a real capture.

1. Submit the domain, then delegate it and publish the DS we hand back

The keyed call returns the exact record set to publish: NS to our two servers, the DS for the per-domain signing key in digest types 2 (SHA-256) and 4 (SHA-384), the matching CDS/CDNSKEY, and the CAA lines. Publish the NS and DS at your registrar; add no glue, our nameservers are out of bailiwick.

keyed · your API key
$ whisper domain submit {your-domain} --json

What the .io registry publishes for everwatch.io, read from its own server a0.nic.io, and the CDS our servers publish for registrars that scan for it (RFC 7344):

keyless · the delegation at the parent
$ dig +norec everwatch.io NS @a0.nic.io +noall +authority
everwatch.io.		3600	IN	NS	ns1.whisper.online.
everwatch.io.		3600	IN	NS	ns2.whisper.online.
$ dig +norec everwatch.io DS @a0.nic.io +noall +answer
everwatch.io.		3600	IN	DS	61903 13 2 DC1DFA1AE92A8B25F7F74970551C85092A12C2DBC23763C00EFB8CBA AB6F6917
$ dig everwatch.io CDS @ns1.whisper.online +noall +answer
everwatch.io.		300	IN	CDS	61903 13 2 DC1DFA1AE92A8B25F7F74970551C85092A12C2DBC23763C00EFB8CBA AB6F6917
everwatch.io.		300	IN	CDS	61903 13 4 CB12BB797E49900BA508A57D161157247A451744B3F9580AEDE99E2A 9F5F8AFAF9AABE143F8070900390ACF7DC2D18AB

2. The proof is observed

We poll the parent and independent public resolvers from several vantage points until the delegation and a matching DS are seen everywhere. Delegation plus DS, observed in the wild, is the proof; no TXT challenge. It is fail-closed: an unproven domain is never authorized. A daily continuity sweep re-checks it, and a definitive break (NS moved, DS removed) revokes it. The keyed status call reports what the observer saw, and a validating resolver that owes us nothing sets the AD flag on the parent's DS (AD is that resolver's claim, not proof; the delv runs further down check the chain yourself):

keyed · your onboarding state
$ whisper domain status everwatch.io --json
{"columns":["op","ok","status","result","error","retry_after","elapsed_ms"],"rows":[{"op":"domain","ok":true,"status":200,"result":{"columns":["name","state","key","value"],"rows":[["everwatch.io","verified","observed_ns","ns1.whisper.online"],["everwatch.io","verified","observed_ns","ns2.whisper.online"],["everwatch.io","verified","observed_ds","61903 13 2 DC1DFA1AE92A8B25F7F74970551C85092A12C2DBC23763C00EFB8CBAAB6F6917"],["everwatch.io","verified","first_seen_wild","1792503014584"],["everwatch.io","verified","last_observed","1792503536938"],["everwatch.io","verified","anchor","ds_ours"],["everwatch.io","verified","parent_ds_ttl","3600"],["everwatch.io","verified","served_here","true"]],"sensitive":[]},"error":null,"retry_after":null,"elapsed_ms":25}],"statistics":{"rowCount":1,"executionTimeMs":25}}
keyless · the parent DS, validated
$ dig +tcp +dnssec @1.1.1.1 everwatch.io DS
# (header and answer shown)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 25652
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
everwatch.io.		3600	IN	DS	61903 13 2 DC1DFA1AE92A8B25F7F74970551C85092A12C2DBC23763C00EFB8CBA AB6F6917
everwatch.io.		3600	IN	RRSIG	DS 8 2 3600 20261110131804 20261020121804 43371 io. RdRFULo+OwvDlXgjsYjhSPhHo/yVhDrH1vXpkYT4yKLhxBK146cGRMmS eePOrmg42W5ruUM6c47TCCJT243iP+86GiUI4tsqeF2i7L+ycbdzntTq xslMJ/S/4mkGqulLbdQi7DMk/SlO4VSHiwOdetVBV2whafcG50k7tUXA 2lA=

If you move from another DNS host, public resolvers may still hold that host's negative answers for up to its SOA minimum (3 hours at some DNS hosts), so validation can lag the DS for that long.

3. The first agent is minted under your apex

With the domain verified, every agent the account mints lands at a{hex}.{your-domain} instead of under agents.whisper.online. For everwatch.io the result row included agent, address, fqdn (a4f988041b1326d8a.everwatch.io.), ptr, member (demo.everwatch.io., a signed CNAME to the agent name), member_published (true), and the agent's own API key, whisper_live_..., redacted here.

keyed · mint an agent
$ curl -s https://graph.whisper.online/api/query \
  -H "X-API-Key: {your-api-key}" -H 'content-type: application/json' \
  -d '{"query":"CALL whisper.agents({op:\"register\", args:{label:\"{agent-name}\"}})"}'

4. Verify it: signed DNS, DANE, RDAP and WHOIS

Forward, reverse and the DANE pin, each with the AD flag set by a validating resolver that owes us nothing. AD is that resolver's claim; the delv runs below check the chain locally. The forward names and the pin are signed with the everwatch.io key (tag 61903, the one in the parent's DS); the PTR is signed in our reverse zone (tag 58485). The TLS endpoint then presents the key the pin names, with no public CA consulted, and the CLI walks the same chain from the member name:

keyless · signed DNS, DANE, the CLI
$ dig +tcp +dnssec @1.1.1.1 a4f988041b1326d8a.everwatch.io AAAA
# (header and answer shown)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 6383
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
a4f988041b1326d8a.everwatch.io.	60 IN	AAAA	2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
a4f988041b1326d8a.everwatch.io.	60 IN	RRSIG	AAAA 13 3 60 20261022130000 20261020120000 61903 everwatch.io. 4ulZgfr6+O6hkOeIQJ9oRoP1I5e0sVnVxlxdZXdBHWiD+wzRWAcQgyqr LDq8yxMC3/RjIErO0X3lmFvwQDNPnQ==
$ dig +tcp +dnssec @1.1.1.1 -x 2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
# (header and answer shown)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 29670
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
a.8.d.6.2.3.1.b.1.4.0.8.8.9.f.4.8.e.3.2.d.6.b.9.1.0.a.2.4.0.a.2.ip6.arpa. 60 IN	PTR a4f988041b1326d8a.everwatch.io.
a.8.d.6.2.3.1.b.1.4.0.8.8.9.f.4.8.e.3.2.d.6.b.9.1.0.a.2.4.0.a.2.ip6.arpa. 60 IN	RRSIG PTR 13 34 60 20261022130000 20261020120000 58485 1.0.a.2.4.0.a.2.ip6.arpa. l1jqJptg/RDgho2fn9VwLWnNO6sRFcgc54MFcKRVmvCCgRDhdJTQnDSA L9RCHM1zGetiS7jl9DelUWer4Glx2w==
$ dig +tcp +dnssec @1.1.1.1 _443._tcp.a4f988041b1326d8a.everwatch.io TLSA
# (header and answer shown)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 9605
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
_443._tcp.a4f988041b1326d8a.everwatch.io. 60 IN	TLSA 3 1 1 BFD4CF2E0275244754B2F99FE0803D020D03EA2C8A0052407DAFFB55 E6748DDA
_443._tcp.a4f988041b1326d8a.everwatch.io. 60 IN	RRSIG TLSA 13 5 60 20261022130000 20261020120000 61903 everwatch.io. JWwOpuuhQK7EpTJZoUiEXifGllBK5YRy34YbwKtD64vBbxqyp5F1XcbI nrFaTJWYHtTuF+hHY3GXtcZmIxRHFA==
$ openssl s_client -connect [2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a]:443 \
    -servername a4f988041b1326d8a.everwatch.io \
    -dane_tlsa_domain a4f988041b1326d8a.everwatch.io \
    -dane_tlsa_rrdata "3 1 1 BFD4CF2E0275244754B2F99FE0803D020D03EA2C8A0052407DAFFB55E6748DDA"
# (trimmed to the verification lines)
CONNECTED(00000003)
subject=CN = a4f988041b1326d8a.everwatch.io
issuer=CN = Whisper Agent Identity Issuing CA, O = viaGraph B.V.
Verification: OK
DANE TLSA 3 1 1 ...8a0052407daffb55e6748dda matched EE certificate at depth 0
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Verify return code: 0 (ok)
$ whisper verify demo.everwatch.io
FIELD                VALUE                                                           
agent                yes                                                             
fqdn                 a4f988041b1326d8a.everwatch.io                                  
operator             everwatch.io.                                                   
dane_ok              yes                                                             
jws_ok               yes                                                             
dane_tlsa_sha256     bfd4cf2e0275244754b2f99fe0803d020d03ea2c8a0052407daffb55e6748dda
served_leaf_matches  yes                                                             
whisper: a4f988041b1326d8a.everwatch.io is a verified Whisper agent (DANE-anchored)

The AD flag is a resolver's verdict. delv does the validation itself: it fetches the DNSKEYs and checks every signature from the root trust anchor down, so neither resolver below has to be trusted. Captured 20 Oct 2026, through two unrelated public resolvers; the member name demo.everwatch.io resolves through its signed CNAME to the agent:

keyless · delv, validating locally
$ delv @1.1.1.1 demo.everwatch.io AAAA
# (RRSIG lines omitted)
; fully validated
demo.everwatch.io.	60	IN	CNAME	a4f988041b1326d8a.everwatch.io.
a4f988041b1326d8a.everwatch.io.	60 IN	AAAA	2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
$ delv @1.1.1.1 a4f988041b1326d8a.everwatch.io AAAA
# (RRSIG lines omitted)
; fully validated
a4f988041b1326d8a.everwatch.io.	60 IN	AAAA	2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
$ delv @1.1.1.1 _443._tcp.a4f988041b1326d8a.everwatch.io TLSA
# (RRSIG lines omitted)
; fully validated
_443._tcp.a4f988041b1326d8a.everwatch.io. 60 IN	TLSA 3 1 1 BFD4CF2E0275244754B2F99FE0803D020D03EA2C8A0052407DAFFB55 E6748DDA
$ delv @1.1.1.1 -x 2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
# (RRSIG lines omitted)
; fully validated
a.8.d.6.2.3.1.b.1.4.0.8.8.9.f.4.8.e.3.2.d.6.b.9.1.0.a.2.4.0.a.2.ip6.arpa. 60 IN	PTR a4f988041b1326d8a.everwatch.io.
$ delv @8.8.8.8 demo.everwatch.io AAAA
# (RRSIG lines omitted)
; fully validated
demo.everwatch.io.	60	IN	CNAME	a4f988041b1326d8a.everwatch.io.
a4f988041b1326d8a.everwatch.io.	40 IN	AAAA	2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
$ delv @8.8.8.8 a4f988041b1326d8a.everwatch.io AAAA
# (RRSIG lines omitted)
; fully validated
a4f988041b1326d8a.everwatch.io.	60 IN	AAAA	2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
$ delv @8.8.8.8 _443._tcp.a4f988041b1326d8a.everwatch.io TLSA
# (RRSIG lines omitted)
; fully validated
_443._tcp.a4f988041b1326d8a.everwatch.io. 60 IN	TLSA 3 1 1 BFD4CF2E0275244754B2F99FE0803D020D03EA2C8A0052407DAFFB55 E6748DDA
$ delv @8.8.8.8 -x 2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
# (RRSIG lines omitted)
; fully validated
a.8.d.6.2.3.1.b.1.4.0.8.8.9.f.4.8.e.3.2.d.6.b.9.1.0.a.2.4.0.a.2.ip6.arpa. 60 IN	PTR a4f988041b1326d8a.everwatch.io.

The per-/128 RDAP and WHOIS records are ours, and say so: the registrant is the domain itself, and the object links up to RIPE's record for the covering block. A plain whois goes to RIPE and answers with that block, registered to viaGraph b.v. with our abuse contact:

keyless · RDAP and WHOIS
$ curl -s https://rdap.whisper.online/ip/2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a \
    | jq -c '{handle, name, registrant: [.entities[] | select(.roles | index("registrant")) | .handle], up: [.links[] | select(.rel == "rdap-related-up") | .href], notice: .notices[0].title}'
{"handle":"a4f988041b1326d8a","name":"demo","registrant":["everwatch.io."],"up":["https://rdap.db.ripe.net/ip/2a04:2a01::/32"],"notice":"Published by the holder"}
$ whois -h whois.whisper.online a4f988041b1326d8a.everwatch.io | grep -E '^(inet6num|netname|agent|tenant|fqdn|status|origin|org|aggregate|source) '
inet6num    2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a
netname     demo
agent       a4f988041b1326d8a
tenant      everwatch.io.
fqdn        a4f988041b1326d8a.everwatch.io
status      active
origin      AS219419
org         viaGraph B.V.
aggregate   2a04:2a01::/32
source      WHISPER
$ whois 2a04:2a01:9b6d:23e8:4f98:8041:b132:6d8a | grep -E 'Abuse contact|^(inet6num|netname|status|assignment-size|org-name):'
% Abuse contact for '2a04:2a01::/32' is 'security@whisper.security'
inet6num:       2a04:2a01::/32
netname:        WHISPER-AGENTS
status:         AGGREGATED-BY-LIR
assignment-size:128
org-name:       viaGraph b.v.

What moves to your name, and what stays ours.

Yours

The name, and the agent names under it. The DS at your parent, which decides whether our signatures count and which you can withdraw at any time. The registrant on every per-/128 RDAP and WHOIS record. Identities already issued under agents.whisper.online keep resolving; your domain takes over for new mints.

Ours

The zone signing: one ECDSA P-256 key per domain, derived identically on both nameservers, so the DS is stable. The /128, which stays in 2a04:2a01::/32 (AS219419). The PTR, which lives in our reverse zone, delegated to us through RIPE. The per-/128 RDAP and WHOIS service, and the transparency log. Browser-trusted (WebPKI) certificates under a domain you bring are not offered yet; every identity gets a DANE-EE pin instead.

The plain-language walkthrough is on the main site: whisper.online/bring-your-own-identity, and the reference, with the observer's four checks and withdrawal, at whisper.online/docs/bring-your-own-domain.

A tamper-evident, independently-witnessed history of every identity.

Each identity carries an append-only, hash-chained record of its events - issuance, rotation, revocation - signed by a dedicated log key with a published key id. You can read it today, per /128:

live · per-identity transparency feed
$ curl -s https://rdap.whisper.online/ip/2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478/transparency | jq '{count,root_hash,root_signature_alg}'
{
  "count": 1,
  "root_hash": "...",
  "root_signature_alg": "ES256"
}

The record returns the event chain plus a signed root, so a revocation cannot be quietly erased from an identity's history. As of the transparency-log rollout (live since 0.112.0), this per-identity feed is anchored in a single append-only Merkle log of all identity commitments, with the public proof surface below.

The public proof surface live

The whole log is published, keyless, on the same gateway. Every endpoint below is run against the live service and pasted as it answers.

Live transparency-log endpoints
Signed checkpointGET https://rdap.whisper.online/checkpoint - the C2SP signed note: origin whisper.online/ledger/g2, the tree_size, the base64 root hash, and one Ed25519 signature line per cosigner
Published log keyGET https://rdap.whisper.online/checkpoint/key - key id d40e573a, the Ed25519 public key and its SPKI form
Merkle tilesGET https://rdap.whisper.online/tile/<level>/<index> - the immutable node hashes the tree is built from (raw 32-byte SHA-256 blocks)
Consistency proofGET https://rdap.whisper.online/consistency?from=<a>&to=<b> - the append-only-extension proof that tree a is a prefix of tree b (nothing was ever rewritten)
Inclusion (per identity)GET https://rdap.whisper.online/ip/<addr>/transparency now carries a ledger arm: {tree_size, checkpoint, leaves:[{index, leaf_hash, inclusion_proof[]}]} - opaque commitments only
Inclusion (per leaf)GET https://rdap.whisper.online/inclusion?leaf=<N> returns the RFC-6962 inclusion proof for any leaf index: {leaf_hash, proof[], checkpoint}

Fetch the log key and the signed checkpoint (the trust anchor; the checkpoint Link header points at the key):

live · the DNSSEC-anchored key set + the signed checkpoint
$ dig +short TXT _whisper-ledger.whisper.online
"v=whisper1; k=ed25519; n=whisper.online/ledger/g2; p=MCowBQYDK2VwAyEA7pSYYInKXm2TMjwAqEsoKon/d3E8SDq34V1VUrgTAm0="
... two more n=whisper.online/ledger/g2 entries, the keys the log may roll to
$ curl -s https://rdap.whisper.online/checkpoint/key
{"object":"whisper-ledger-key","origin":"whisper.online/ledger/g2","alg":"Ed25519",
 "key_id":"d40e573a","public_key":"7pSYYInKXm2TMjwAqEsoKon/d3E8SDq34V1VUrgTAm0=",
 "public_key_spki":"MCowBQYDK2VwAyEA7pSYYInKXm2TMjwAqEsoKon/d3E8SDq34V1VUrgTAm0="}
$ curl -s https://rdap.whisper.online/checkpoint
# the current signed note: line 1 origin whisper.online/ledger/g2, line 2 the tree
# size, line 3 the base64 root, then a signature line for the log and one for each
# witness. Fetch it yourself for the live root; a copy pasted here would be stale
# the moment the next identity is minted.

Lines are: the origin, the tree_size, the base64 root hash, then one signature line per cosigner, each <origin> <base64(key-id || Ed25519 sig)>. The first four bytes of the log's own blob are the key id d40e573a, which you can re-derive yourself as SHA-256(origin || 0x0A || 0x01 || pubkey)[:4] - so the key the checkpoint is signed with is the one published at /checkpoint/key, with nothing to trust in between.

A worked example, from the tree

Ask any resident for its ledger arm and you get its leaf indices plus the inclusion proof that folds them to the signed root. Fetch it live - the tree grows with every mint, so a leaf's proof lengthens over time and any snapshot pasted here would go stale:

live · the ledger arm of an in-tree identity
$ curl -s https://rdap.whisper.online/ip/2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478/transparency \
    | jq '.ledger'
{
  "object": "ledger-inclusion",
  "origin": "whisper.online/ledger/g2",
  "tree_size": {size},
  "leaves": [
    {
      "index": {n},
      "leaf_hash": "{hex}",
      "inclusion_proof": ["{hex}", ...]
    }
  ]
}

Identities minted before the current genesis do not carry a leaf in it - their ledger.leaves is [] until a back-fill folds them in. An empty leaves means “no Merkle leaf in this tree yet,” not “not an agent”; the per-/128 hash-chained feed above still covers them.

Verify it yourself, with stock tools

No SDK, no key. The leaf commitment is sha256(salt || event); the Merkle leaf is sha256(0x00 || commitment); interior nodes are sha256(0x01 || left || right). Fetch a leaf's inclusion_proof, fold it up to the root in the signed checkpoint, then check the Ed25519 signature with the published key - all stock crypto:

copy-paste · curl + sha256sum, no key, no SDK
# 1. the raw 32-byte Merkle leaf for index 0 (the tile IS the leaf hash):
$ curl -s https://rdap.whisper.online/tile/0/0 | xxd -p -c64
# the leaf hash for leaf 0, i.e. sha256(0x00 || commitment)

# 2. that leaf's inclusion proof, plus the root in the signed checkpoint (base64 line 3):
$ curl -s "https://rdap.whisper.online/inclusion?leaf=0"   # {leaf_hash, proof[], checkpoint}
$ curl -s https://rdap.whisper.online/checkpoint | sed -n '3p' | base64 -d | xxd -p -c64

# 3. fold each proof step up to the root, then verify the signature:
#      node = sha256( 0x01 || left || right )   # RFC 6962 interior hash; sha256sum does it
#    keep folding until you reach the checkpoint root, then check the Ed25519
#    signature line with the key from /checkpoint/key. Nothing to trust in between.

Or one command with the CLI verifier (same stock crypto - Ed25519 + SHA-256 + RFC 6962 folding - wrapped up). checkpoint verifies the signed root; verify proves a disclosed event is in the tree (the subject hands you the salt and the canonical event out of band - that is the selective disclosure):

copy-paste · the whisper CLI verifier (keyless)
$ whisper ledger checkpoint                         # fetch + verify the signed checkpoint
whisper: checkpoint VERIFIED - signed tree of {n} leaves
$ whisper ledger verify 2a04:2a01:b69a:6717:e3b0:51ff:3bf7:f478 \
    --salt {hex} --event-file event.bin           # prove a disclosed (salt, event) is in the tree
whisper: VERIFIED - the disclosed commitment is in the signed ledger at leaf {i} of {n}
The claim. This is a tamper-evident, independently-witnessed transparency log (cross-witnessed by MarkovianProtocol; Bitcoin-anchored underneath): every checkpoint is signed, openly published, and Bitcoin-anchored, so anyone can verify the proofs today, and the served claim reaches publicly verifiable / split-view-resistant once a quorum of at least two genuinely independent witnesses is cosigning the served checkpoint (gated in code, self-reverting; the live X-Whisper-Ledger-Claim header is the source of truth). Independently witnessed today by MarkovianProtocol, one such witness, and additional witnesses are welcome: run one and we'll cosign back, so the log grows mutually, independently verifiable for everyone who takes part, and each new independent witness brings the quorum. MarkovianProtocol's cosignature on the current checkpoint is verifiable at witness.markovianprotocol.com/checkpoints. Verification is by selective disclosure - the tree holds only opaque salted commitments, so the public proofs show that a commitment sits in the signed tree, not what it attests. See the policy and the signed checkpoint.

Live today live

The per-/128 append-only, signed event feed at /ip/<addr>/transparency (now with a ledger inclusion arm), the signed /checkpoint and its published key (id d40e573a), the immutable /tile/<level>/<index> Merkle tiles, the /consistency append-only proof, and the keyless whisper ledger verifier - all stock crypto, no SDK.

An open invitation

Independently witnessed by MarkovianProtocol; more witnesses are welcome: run one against the checkpoints and we'll cosign back, so the log is mutually, independently verifiable for everyone who takes part. The genesis back-fill that folds pre-log identities into the tree is also in flight.

The whole record, kept straight.

Everything here is real, every command checks out, and anything still on its way is marked as such. When you are ready, there is room here for yours.