Inset of Sheet 8 of the atlas

HALLMARK_

What our machine read from outside dareakt.com at one release, signed, with a date after which it stops counting.

A hallmark is a signed record of what our machine read about this site from outside, at a stated time. It has a serial and a not-after time, after which it stops counting.

It says what was true as read at the time shown, not what is true now. It covers only checks that a machine reads over the public network, which anyone can repeat.

The verdict

Decided in your browser, never printed by us.

HALLMARK_SIGNED READING OF DAREAKT.COMH-······························ → ··········

Nothing on this page has been checked until its script has run. The result is worked out in your browser, never printed by us. The files are public, and the three ways to check them yourself are further down.

Add ?s=H-000001 to the address to read a particular serial. Without it, the newest hallmark in the register is shown.

Serial
Subject
Release
Issued
Not after
Scope

What a hallmark never covers

And the six states this page can show.

  • Claims read from inside (ATTESTED_): a stranger cannot repeat them.
  • Claims still NEXT_ or IN LOG_.
  • Promises (DECLARED_): a promise is not a reading.
  • What is true now: a hallmark says what was read at the time shown.
  • Anything not listed under What it covers. The claims record lists every claim, including those not yet live; a hallmark vouches only for its own list.

What it covers

Each check, how our machine made it, and the line you can run to repeat it.

  • dnssec

    dareakt.com is signed with DNSSEC, so a validating resolver can detect forged answers about it.

    Run delv @185.12.64.2 dareakt.com SOA and look for the words fully validated.
  • spf

    dareakt.com publishes an SPF record that names its own mail server as the sender.

    Run dig +short TXT dareakt.com and look for a v=spf1 record that names mail.dareakt.com.
  • dkim

    dareakt.com publishes two DKIM keys for its mail, one RSA and one Ed25519.

    Run dig +short TXT on v1-rsa-20260912._domainkey.dareakt.com and on v1-ed25519-20260912._domainkey.dareakt.com.
  • dmarc-enforce

    dareakt.com publishes a DMARC policy telling receivers to quarantine mail that fails its checks.

    Run dig +short TXT _dmarc.dareakt.com and look for p=quarantine or p=reject.
  • tls13

    dareakt.com accepts encrypted connections over TLS 1.3.

    Run openssl s_client -connect dareakt.com:443 -tls1_3 and look for a completed handshake.
  • security-txt

    dareakt.com publishes a security.txt saying how to report a vulnerability, with a future expiry date.

    Open dareakt.com/.well-known/security.txt and read the Contact and Expires lines.
  • csp-pages

    The public site pages of dareakt.com are served with an enforced Content Security Policy allowing no unsafe-inline.

    Run curl -sI https://dareakt.com/ and read the Content-Security-Policy header: it holds no unsafe-inline. The apps under /apps/ are not covered by this claim.
  • egress-check

    The browser refuses fetch, XHR and WebSocket requests from our public pages to any site not on our approved list.

    Run curl -sI https://dareakt.com/ and read the Content-Security-Policy header: connect-src lists only this site and our own pouch, silo and kairos hosts. Images and frames have their own lists, a page can still navigate to any address, and the apps under /apps/ are not covered by this claim.
  • key-pinning

    Page code refuses any signing key missing from its pinned list. This cannot stop an attacker controlling our server.

    Fetch the public page-code files that check signatures and read their pinned key list: it must hold at least one key, and the signature file must say pinning is enforced.
  • registry-signature

    Page code trusts no file hash unless a pinned key signed it. This cannot stop an attacker controlling our server.

    Fetch the public page-code files and read their text. The trust loader must open its pin function with the guard line, name the pin call exactly twice (a function check and the one call, so no alias or second route under that name) and hold no block comments; the signature file must carry the line saying registry verification is enforced and export the verifier. This reads served text and does not run it. Each release also runs the verifier itself on the signed list and on a copy with one hash changed, which it must refuse.

Check it yourself

Three ways, from weakest to strongest.

  1. ON THIS PAGE_

    The quickest way, and the weakest

    • Your browser checks the Ed25519 signature of the hallmark, of every register entry and of the head, against the key fingerprint this page carries.

    It shows the file is whole and signed by the key it names. It cannot show the key is ours, because the page and the key come from the same place.

  2. IN DNS_

    A second place for the key

    • The key's fingerprint is also published in our DNS, at _hallmark.dareakt.com.
    • One command with delv, on your own machine, reads it and says whether the answer was validated.

    The command dig does not check the signatures in DNS, so use delv.

  3. ON YOUR MACHINE_

    The strongest: nothing comes from this page

    • Five steps with curl, python3 and openssl 3 check a signature without trusting anything here.
    • Then repeat any check under What it covers with the command beneath it.

    If your own reading differs from ours, the hallmark is wrong.

The signed files

One file per hallmark, one register, one head. Every file is signed with an Ed25519 key over its payload text, byte for byte. The register is a hash chain, and the head records how long it was when it was signed, so a register cut short can be seen.

  1. A hallmark

    https://dareakt.com/.well-known/hallmark/H-NNNNNN.json
  2. The claims record it points at, kept byte for byte

    https://dareakt.com/.well-known/hallmark/H-NNNNNN.claims.json
  3. The register of every hallmark and every revoke

    https://dareakt.com/.well-known/hallmark/register.json
  4. The signed head of the register

    https://dareakt.com/.well-known/hallmark/head.json
  5. The public key

    https://dareakt.com/keys/hallmark-ed25519-public.pem

Check the key in DNS

This page cannot prove the key is ours, because the page and the key come from the same place. The DNS record is the second place.

  1. Read the key's record with delv

    delv @185.12.64.2 _hallmark.dareakt.com TXT

The answer must say "; fully validated", and a TXT line must carry spki-sha256= followed by the fingerprint below. If the answer is not validated, or the fingerprint differs, or there is no such record, do not trust the hallmark.

Verify it with OpenSSL

Five steps on any machine with curl, python3 and openssl 3. Replace the serial with the one you want to check; this page has filled in the one it read.

  1. 1. Fetch a hallmark and the key

    curl -sO https://dareakt.com/.well-known/hallmark/H-NNNNNN.json -O https://dareakt.com/keys/hallmark-ed25519-public.pem
  2. 2. Hash the key and compare it with the SPKI SHA-256 below

    openssl pkey -pubin -in hallmark-ed25519-public.pem -outform DER | openssl dgst -sha256
  3. 3. Compare it with the hash in DNS, using the delv command above.

  4. 4. Split the file into the signed text and the signature

    python3 -c 'import json,base64;d=json.load(open("H-NNNNNN.json",encoding="utf-8"));open("payload.txt","w",encoding="utf-8",newline="").write(d["payload"]);open("sig.bin","wb").write(base64.b64decode(d["signature"]["sig"]))'
  5. 5. Verify the signature

    openssl pkeyutl -verify -pubin -inkey hallmark-ed25519-public.pem -rawin -in payload.txt -sigfile sig.bin

A good file prints Signature Verified Successfully. The signed text is the payload field byte for byte, so do not reformat it.

Pinned key (hallmark-v1)SPKI SHA-256 88559d78b028ddaa6db16a8cad6e1fb1054f93c67438b72367332c8588c6d97b

Signing key
Register head signed
Checked by this page
Claims record
Scope hash
Prior serial
Previous hash

Every check inside a hallmark is a reading our machine made from outside, and its method is written on the PROOF_ page. If your own reading differs from ours, the hallmark is wrong.