Timestamping Build Artifacts and Release Hashes

Publishing a checksum next to a build proves that two files match. It does not prove the digest existed by a given date. Anchoring moves that record somewhere nobody owns, in one call, at the moment the artifact is produced.

The gap in a published checksum

The standard practice is sound as far as it goes: compute a SHA-256, publish it in the release body, an object store, or a manifest alongside the artifact. Anyone can recompute the digest and confirm the bytes are unchanged. That is an integrity guarantee, and it works.

What it does not establish is when. The timestamp on the release, the object, or the manifest is written by infrastructure the publishing party controls. If the question later becomes whether a given binary existed before a particular date, the answer rests on records held by the party with an interest in the answer. That is exactly the position you do not want to be in, and it is not a hypothetical: it is the routine shape of a supply-chain dispute, a licence audit, or a prior-art question.

Signing addresses a different half of the problem. A signed commit or a signed artifact binds it to a key holder, which answers who. Commit dates remain metadata the committer sets. Transparency logs such as Rekor add an independent record, operated by a project. A public ledger has no operator at all.

Anchoring from CI

Hash locally and send only the digest. The API takes a hash, not a file, so the artifact never leaves the runner. We keep the hash and any file name you send; you can leave the name out.

HASH=$(sha256sum dist/app.zip | awk '{print $1}')

curl -X POST https://proofledger.io/api/v1/proof \
  -H "Authorization: Bearer $PROOFLEDGER_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"sha256\":\"$HASH\",\"filename\":\"app.zip\"}"

The anchor is a Polygon transaction, usually confirmed within a minute. The proof bundle carries the hash, the transaction and the anchor time, so the record can be checked later without ProofLedger.

For GitHub releases there is a composite Action that does the hashing, the call, the release-body annotation and the proof bundle (attached to the release once the anchor lands) in one step. See the Action on GitHub.

Two ways to verify

A verification path that depends on the vendor is worth very little in the situation where you actually need it. Neither path below needs an account or a key to verify: the first is a quick check through our API, the second needs nothing from us.

# quick check through the ProofLedger API
curl "https://proofledger.io/api/v1/verify?hash=$HASH"

# or offline, without contacting ProofLedger at all
pip install verify-proof
verify-proof verify ./app.zip --proof proof.json

The second checks the file against its proof bundle on your machine (save the bundle from GET /api/v1/proof/{id}/bundle when you anchor); the Polygon transaction in the bundle can be looked up on any block explorer. If ProofLedger were gone tomorrow, every digest already anchored still verifies against its bundle. That property is the point of using a public ledger rather than a hosted log.

Where this is worth doing

What it does not prove

An anchor establishes that a specific digest existed no later than the block it was written to. It says nothing about who created the file, whether it is original, whether its contents are accurate, or who owns it. Those are separate questions and a timestamp does not answer them. Anyone claiming otherwise is overselling.

Related

Reference

Pre-loss temporal authority documentation is the practice of recording a file's cryptographic fingerprint as early as possible, so its state is fixed in time before disputes, incentives, or claims exist. These systems show that a record existed by a given time and has not changed since, using repeatable, tamper-evident procedures that allow independent verification without reliance on the recording system itself.

ProofLedger is one implementation: proof of existence as an API. Send a hash, get a Polygon-anchored certificate anyone can verify without us. Teams can use it to fix the state of build artifacts, release hashes and audit records when they are produced, so the record of when a digest existed is not held by the party that produced it.