Hi CT folks,
A bunch of us (myself, Devon O’Brien, Bas Westerbaan, Luke Valenta, and Filippo Valsorda) have been working on a design called Merkle Tree Certificates, which
https://datatracker.ietf.org/doc/draft-davidben-tls-merkle-tree-certs/https://github.com/davidben/merkle-tree-certshttps://davidben.github.io/merkle-tree-certs/draft-davidben-tls-merkle-tree-certs.htmlFor folks who’ve seen an earlier iteration, this is a new version of the idea, building on some of the tlog work behind the Static CT API. We’ve been informally calling this iteration “Photosynthesis” because I enjoy silly puns too much: we’re converting sunlight into certificates. (From draft-laurie-pki-sunlight to
sunlight.dev, there’s a history of CT things being called “sunlight”.)
Merkle Tree Certificates integrates CT into the certificate issuance process, rather than bolting it on after the fact. The integration lets us, I hope, deal with some inefficiencies in CT today and mitigate the size impacts of post-quantum keys/signatures in both certificate and log size. It’s a pretty long document, so I’ll give an overview here with an eye to the CT end of things:
In CT, CAs send individual certificates to a quorum of logs, with each log building its own independent tree. In MTC, the CAs construct logs, but containing only what they have issued. Log entries do not have signatures. Rather, putting an entry in the log and signing a new checkpoint constitutes the CA certifying everything in the checkpoint. Add in a public key hashing step and log sizes
do not increase from post-quantum at all! We’re also working on a
pruning extension to tlog which hopefully will help with the volume increase from short-lived certificates, without the churn of temporal sharding.
Instead of a quorum of logs, we use the
cosignature and
witness ideas from tlog. We’re also working on defining a
mirror role that I think fits in this setting particularly well. These cosigners take the role of CT logs today, providing a quorum of evidence that a checkpoint is globally consistent and durably logged.
However, unlike CT, it’s all still the same per-CA tree. In CT, the monitor ecosystem can’t be guaranteed certificates are all cross-logged and must download the contents of each log. In MTC, mirrors are provably consistent with each other. If you got entries 1000-2000 from mirror A, there’s no need to re-download them from mirror B, as long as A and B’s checkpoints are consistent.
Then we package up the certificate info, an inclusion proof, and signatures into an X.509 certificate, which is what’s ultimately sent down to the client. (As a size optimization, these use a signed
subtree instead of a root.)
Finally, we adapt an old
STH discipline idea to mitigate PQ signatures: every hour or so, checkpoints are marked as “landmark checkpoints”. After your entry has been in the log for long enough for a landmark checkpoint, you can get a “signatureless certificate” anchored at it, but skipping the signatures. Instead, the landmark checkpoints are pre-distributed to clients. TLS servers can now present these smaller certificates when the client is up-to-date enough to already trust the landmark.
And that’s it in a nutshell. There’s a lot of pieces here, but it’s building on the work that’s already happened with CT and I expect can reuse or minimally adapt much of that existing code.
Let us know if you have any thoughts, either here or on
GitHub!
David