Get your log witnessed

Your log signs its own state, but that signature doesn't stop it from showing you one history and the next reader a different one, both signed, both checking out. A witness is an outsider who remembers what it signed and refuses to sign a different version. We run one. It's free, it signs for anyone, and the tools below are the same code we run.

Run a log

All we need is your log's state published as a c2sp.org/tlog-checkpoint note at an address that doesn't change. If you already do that, skip this section.

git clone https://github.com/MarkovianProtocol/log-server
cd log-server && pip install cryptography
python3 log_server.py --selftest && python3 log_server.py --serve

log_server.py

A database plus the standard log structure (RFC 6962), serving the log's state, tiles, proofs, and one-file offline proofs.

verify_tlog_proof.py

The checking side: give it a proof file, a record and a policy, and it says PASS or FAIL, no network needed.

witness_server.py

Run a witness yourself. Signing for someone else's log takes a few hundred lines of code and a small program that's always on.

Send your state out

Signatures you never collect prove nothing, so this is the part that does the work. It takes your log's state, sends those exact bytes to every witness, checks each signature that comes back against that witness's known key before publishing anything, and drops whatever doesn't check out.

curl -O https://raw.githubusercontent.com/MarkovianProtocol/log-server/main/submit_witnesses.py
curl -O https://raw.githubusercontent.com/MarkovianProtocol/log-server/main/witness_keys.json
python3 submit_witnesses.py

witness_keys.json has the seven witness keys we use, each copied from the operator's own page, not from any log. Sending to several witnesses at once is the point. A signature from a witness whose key you got from the log you're checking is worth nothing.

Getting signed

Two ways. The first is better and doesn't involve us at all.

The shared list. Sign up at witness-network.org/participate. Our witness follows three of its lists every hour (testing and both staging tiers) and picks up new logs automatically, and so do the other witnesses, so one sign-up gets you several signatures instead of one. It's where our own seven came from.

Or just us. Open an issue on log-server with three lines: your log's name, its public key, and the address of its state. We copy the key from your page, never from your log, and start signing. It's public, so the record of who asked and what we did stays checkable.

The rules

Public, so a badge means the same thing everywhere:

• Your log publishes c2sp.org/tlog-checkpoint notes at an address that doesn't change. No state, nothing to sign.
• Your key lives on your own page, and that's where we copy it from. A log that served its own key could also swap it.
• Your log's name never changes. A new name is a new log.
• We only sign versions that build on what we already signed. Forks and rollbacks get refused, on the record.
• You can leave, but the signatures we already gave stay.

If our server dies

That fourth rule comes down to one row per log in one database file: the biggest version of your log we've signed. Restore that file from an old backup and we'd keep enforcing the rule against a mark that has quietly slipped backwards. Lose the file completely and it's worse: a witness that remembers nothing will accept anything, once, for every log at the same time.

So the row doesn't only live on our server. Once an hour the witness writes its marks (log name, size, fingerprint) into markovianprotocol.com/log, which seven witnesses from six operators sign and which is stamped into Bitcoin. When it starts up, it reads the newest of those back, but only from a state that meets that log's own 4-of-7 rule, and only after a proof (RFC 9162) shows the record is really in it. Then, for each log, it keeps whichever mark is higher, published or stored. Marks only go up: an old or replayed copy can fail to raise one but can never lower it. An empty database refuses to run rather than starting from scratch.

The gap is the time between those hourly writes. Recovering puts us back at the last published mark, not where we actually were, so up to an hour of progress for a log can open up again. Writing more often narrows that gap but doesn't close it. And none of it stops someone with full control of our server from editing the file directly, because nothing running on that server can. What it does is make a rollback a deliberate act that leaves published evidence against it. Current state is on /about, re-checked every hour.

Your badge

Type your log's name. The badge is drawn live from our signing records: it turns green, with your log's size, once we're actually signing for you, and not before. This page has no say in it.

Member logs

Every log we currently sign for, straight from our signing records. A signature means the same thing for all of them. The tag says what the log itself holds, so a test or demo log isn't mistaken for a real one.

We watch the witnesses too

A witness that told different people different things about the same log could get away with it, ours included. So every hour we ask eight witnesses what they've signed, through the tlog-witness monitoring API, and check each signature against its known key. So far only our witness offers that API, so there's nothing to compare yet. Alerts for log operators are free; just ask.

A witness signature means your history was never rewritten. It says nothing about whether your records are true.