What Is Cryptographic Prior Art? A Guide for Software Teams
Ask a room of developers “when did you build this feature?” and you’ll get a confident answer. Ask them to prove it in a way a stranger can verify and the room goes quiet. That gap — between knowing something and being able to demonstrate it to a third party — is exactly what cryptographic prior art closes.
This guide answers the question plainly: what is cryptographic prior art for software, how it works, why it matters to both developers and compliance teams, and how to get it without learning an ounce of protocol theory.
The Plain-Language Answer: What Cryptographic Prior Art Actually Means
Cryptographic prior art is mathematical proof that a specific piece of code existed at a specific time — without revealing the code itself.
Three parts of that sentence do real work:
- Mathematical proof. The evidence is verifiable by anyone using public data and standard hashing. It doesn’t depend on trusting a log file, a coworker’s memory, or a vendor’s database.
- Specific piece of code. The unit of proof is a fingerprint of your work, not the work itself. The fingerprint is a hash — a one-way value that uniquely represents your repository state at a moment in time. You cannot reverse it back into source code.
- Without revealing the code. You get provable existence and timing while keeping the implementation secret. That’s the property a patent filing cannot give you.
How it differs from the other kinds of “prior art”
| Type of evidence | What it proves | Weakness |
|---|---|---|
| Legal prior art (patents, publications) | A public disclosure existed | Expensive, slow, and forces you to publish |
| Informal evidence (internal logs, emails, tickets) | What your team wrote down | Editable; often dismissed as “self-serving” |
| Cryptographic prior art | A hash existed at a fixed point in time | Requires a public anchor to be meaningful |
The “cryptographic” part is what changes the strength of the claim. An internal Git log lives on a server you don’t control or in a database you can edit. A cryptographically anchored hash is frozen in a public, append-only ledger.
What it does not do
Cryptographic prior art protects proof of existence and authorship. It is not a grant of exclusive rights, it is not a patent, and it does not keep your code secret by itself — your repo permissions do that. If you want exclusive rights, you still file for a patent or rely on copyright. What you get here is evidence: a dated, tamper-evident record that can be presented when timing is disputed.
For software teams, the practical unit of proof is usually a Git commit, not a whole-repository snapshot. Commits are already granular, already hashed by Git, and already represent a meaningful unit of work.
A Real-World Analogy: The Notary, the Safe, and the Receipt
Picture the analog version:
- You write a document and put it in a tamper-evident envelope.
- You take the envelope to a public notary, who records the date and seals it.
- You keep the receipt — and you never hand over the document.
The cryptographic version maps almost one-to-one:
- The envelope is the hash. A SHA-256 fingerprint of your commit — a one-way value no one can reverse into code.
- The notary is the Bitcoin blockchain. A public record that no single company or government controls.
- The receipt is the proof file. A verifiable artifact you keep, and that anyone can check independently.
Two differences matter enormously:
The notary never sees the document. Only the sealed fingerprint is recorded. Your source code never leaves your environment.
Verification is mathematical, not institutional. With a traditional notary, you trust the notary’s continued existence and record-keeping. Here, verification is arithmetic against public block data. You can confirm a proof locally even if the company that produced it disappears.
Connect it back to Git: each commit is a sealed document, and the daily batch is the notary visit — one trip that stamps everything you wrote that day.
How It Works Under the Hood (Without the Protocol Rabbit Hole)
The chain is only three links long:
- Git produces a commit hash. Every commit already carries a SHA-1 or SHA-256 hash representing the exact repository state at that moment.
- Hashes are batched into a daily manifest. All pending commit hashes are grouped into a plain-text manifest (
.txt) per repository, and that manifest is hashed. - The Merkle root is anchored into Bitcoin. Many hashes are combined into one root, so a single Bitcoin transaction can prove thousands of commits across many repositories.
That Merkle-tree step is what makes this economically sane. Instead of paying for one blockchain transaction per commit, one transaction per day covers an entire batch — and each individual commit still has its own verifiable path back to the root.
Yes, you can wire this up yourself with the raw OpenTimestamps tooling and hand-built transactions. That is the hard way. The managed way is a GitHub App that performs the whole pipeline automatically each night.
Timestamp GIT is that managed layer. You install the GitHub App once, and every commit to a monitored repository is anchored without any developer action — no CLI tools, no protocol commands, no manual steps. Confirmation in Bitcoin normally takes about three hours, so the proof files land a few hours after the nightly run. They’re delivered as .ots receipt files plus the manifest, pushed into a dedicated timestamps branch or a shadow repository.
Why It Matters for Developers and Compliance Teams
Four groups get four different things out of the same mechanism:
- Developers. Protect reusable libraries, portfolio pieces, and milestone dates — without changing how you work. There’s nothing to install on developer machines.
- Compliance and legal. Get court-ready, vendor-independent evidence that doesn’t rely on internal logs that can be edited or dismissed as self-serving.
- Startups and agencies. Establish prior art before a patent filing, during a payment dispute over delivery dates, or when a competitor claims independent development of a feature you shipped 18 months earlier.
- Companies generally. Defend against patent trolls claiming royalties on systems you built internally and never published.
The zero-knowledge guarantee is what makes this palatable to security teams: Timestamp GIT never sees, copies, or stores your actual source code. It only stamps the Git hash. Verification is equally private — the verification pages run the entire Merkle-chain computation locally in your browser, so nobody sees what you verify. If you ever want to check a proof outside the product, the receipt files work with standard OpenTimestamps verification tools, which is why there’s no vendor lock-in.
Common Misconceptions About Cryptographic Prior Art
Misconception: “This publishes my code.” No. Only hashes are anchored. A hash is a one-way fingerprint — you cannot reconstruct a repository from it. Source code stays in your repository under your access controls.
Misconception: “It replaces a patent or copyright.” It doesn’t. It’s evidence of existence and timing, not a grant of exclusive rights. It’s the shield, not the sword — but as a shield against broad patent claims, it’s a strong one.
Misconception: “GitHub commit timestamps are enough.” Server-side timestamps live on infrastructure you don’t own and can be altered, backdated, or recreated if a repository is migrated. They aren’t cryptographically anchored to anything independent. A Git commit hash proves what changed; only an anchored timestamp proves when it existed.
Misconception: “It requires blockchain expertise or CLI tools.” Not with a managed service. The GitHub App path involves installing an app and nothing else. Developers keep committing exactly as they do today.
Misconception: “It only works for public repos.” Private repos are supported. For those, status URLs append an encrypted HMAC specific to the server instance, so only authorized viewers can see repository status.
How Timestamp GIT Turns the Concept Into a One-Step Workflow
Two deployment modes cover both ends of the trust spectrum.
Standard Mode (GitHub App). Install the GitHub App and it reads only the HEAD commit hash of monitored repositories automatically. Proofs are written to your own timestamps branch — either in the same repository as the source or in a separate one. GitHub’s permission model requires at least read-only access to the source repo (there’s no commit-hash-only scope) plus read-write access to the target repo.
Enterprise ZK Mode. A 12-line GitHub Action runs on your infrastructure and pushes only the commit hash to the Timestamp GIT API. The service needs read-write access to the target repo only, and none to the source repo — because the hash arrives from your own runner. Your source never leaves your environment.
From there, the pipeline is unattended:
- Commit hashes are queued in an in-memory key-value store for batching.
- A midnight cron worker groups pending hashes, builds manifest files per repo, constructs a Merkle tree natively, and creates OpenTimestamps proofs against public calendars.
- The Merkle root is anchored into a Bitcoin block. Once confirmed, it’s immutable — no one can alter or forge it, including the vendor.
- Manifests and
.otsreceipts are pushed back to your repository.
Then the evidence layer kicks in. Embeddable badges for your README display verification status publicly. A per-repository status dashboard shows proof longevity, earliest anchor date, daily regularity, Bitcoin block and transaction data, and a calendar heatmap. Audit CSVs and PDF certificates are downloadable, and the REST API automates all of it:
# Confirm the last anchored block for a repository
curl -s https://timestampgit.dev/api/statusLast/your-org/your-repo
# Pull the full audit ledger as CSV for a compliance review
curl -s -o audit.csv https://timestampgit.dev/api/audit/your-org/your-repo
# Download the PDF certificate for a specific day
curl -s -o certificate.pdf \
https://timestampgit.dev/api/report/your-org/your-repo/2026-10-12
For air-gapped or fully self-hosted environments, Timestamp GIT ships as a Docker image. A quick-start Docker Compose setup looks like this:
services:
timestampgit:
image: rue1401/timestampgit:prod
ports:
- "8080:8080"
volumes:
- ./data:/app/data
restart: unless-stopped
valkey:
image: valkey/valkey:8
restart: unless-stopped
docker compose pull
docker compose up -d
docker compose logs -f timestampgit
The app is available at http://localhost:8080 after startup, and a setup wizard on first launch walks you through connecting your GitHub App and configuring your instance. A time-limited demo license for evaluation is available through the Docker License request form.
FAQ: Cryptographic Prior Art for Software Teams
Is cryptographic prior art legally admissible in court?
Cryptographic prior art provides mathematically verifiable evidence that a specific commit hash existed at a specific time. Because it relies on public Bitcoin block data and standard SHA-256 hashing, it can be independently verified by any third party, including a court-appointed expert. It is typically used alongside other evidence, not as a replacement for legal advice.
What is the difference between a Git commit hash and a cryptographic timestamp?
A Git commit hash is a fingerprint of your repository state at a moment in time, but on its own it does not prove when that moment occurred. A cryptographic timestamp anchors that hash into a public blockchain, fixing its existence to a specific Bitcoin block. The hash proves what changed; the timestamp proves when it existed.
Does Timestamp GIT ever see my source code?
No. In Standard Mode, the GitHub App reads only the HEAD commit hash of monitored repositories. In Enterprise ZK Mode, a GitHub Action on your infrastructure pushes only the commit hash to the API, so the service never has read access to your source repository. Your code never leaves your environment.
Do developers need to install anything or change their workflow?
No. With the managed GitHub App, you install it once and commits are anchored automatically each night. There are no CLI tools, no OpenTimestamps commands, and no manual steps for developers. For air-gapped or self-hosted environments, a Docker image is available.
The Takeaway
Cryptographic prior art is a narrow, powerful idea: hash your commits, anchor the hash in a public ledger, keep the receipt. It doesn’t replace your legal strategy — it gives your legal strategy something a court can actually verify. And the practical barrier to entry is now roughly one GitHub App installation.
If you want to start collecting verifiable proof from your next commit onward, connect a repository on Timestamp GIT — the free Open Source tier covers public repos, and Pro Agency ($49/mo) and Enterprise ZK ($199/mo) cover private and air-gapped setups.
Related posts
- How to Independently Verify a Git Commit Timestamp
- Automatic Nightly Git Commit Anchoring to Bitcoin, Zero Manual Steps
- Code Timestamping Service Pricing for Private Repos